Home /Modules/advantage/DEFINITIONS.md

DEFINITIONS.md

lib/advantage/DEFINITIONS.md · 459 line(s) · markdown

artifact; pure; gasoline;

<!-- preonem: this document is an enacted artifact of the advantage legislature, graded unto time and space. See PREONEM.md. -->

Definitions — the advantage package

A single consolidated glossary for everything in lib/advantage: the Sequitur onion model, the trade math subject (math/), and the trust-field physics subject (physics/). Each entry gives the term, a plain definition, and where it is implemented.

Companion docs: README.md (overview), MATH.md (trade economics), PHYSICS.md (trust fields).

Contents

  1. Core concepts
  2. The Sequitur onion model
  3. Dynamic alteration & restitute
  4. Trade math subject (math/)
  5. Trust-field physics subject (physics/)
  6. Cross-cutting conventions
  7. Class index
  8. Vertical-integration subject (integration/)
  9. Sophistication grading subject (grading/)
  10. Output seam (output/)

1. Core concepts

TermDefinitionWhere
AdvantageA source of leverage: something you can draw on to know, decide, or act with more effect than you otherwise could. The net movement a dividend makes away from its base.SLAdvantageDividend.advantage()
DividendThe value being advantaged. "Unique" because it carries its own identity (a label); held "with respect to a model" (a named frame of reference).SLAdvantageDividend
ModelThe frame of reference a dividend is evaluated against (e.g. quarterly-plan, pricing-model). Distinct from the two encapsulation models (user's / developer's).SLAdvantageDividend.model
OwnerThe party to whose advantage a model is tuned. Folded into the restitution snapshot.SLAdvantageDividend.owner
BaseThe dividend's starting value before any layer is applied.SLAdvantageDividend.base
CurrentThe dividend's running value as layers are applied.SLAdvantageDividend.current
User's modelA simple, outcome-facing encapsulation: state a dividend, nudge a few plain dials, press a button, read the result. Hides the onion.SLAdvantageUserModel
Developer's modelA full-control encapsulation: build the onion, tune every layer, navigate the cursor, run passes, iterate.SLAdvantageDeveloperModel

2. The Sequitur onion model

TermDefinitionWhere
SequiturLatin "it follows". An ordered list of layers in which each follows the previous in logical order. The engine's name for the onion.SLAdvantageSequitur
OnionA set of concentric layers navigated by depth: depth 0 is the outermost skin, higher depth is further inward toward the core.SLAdvantageSequitur.layers
LayerOne stage of the process: a name, a kind, and a signed numeric contribution it folds into the running dividend when applied.SLAdvantageLayer
DepthA layer's position in the onion (0 = outermost). Also the cursor's current location.SLAdvantageLayer.depth, SLAdvantageSequitur.cursor
ContributionThe signed amount a layer applies to the dividend's running value when the layer is applied.SLAdvantageLayer.contribution
CursorThe current depth. Moving it is how the model "iterates further down or up" the onion.SLAdvantageSequitur.cursor
Inward / outwardNavigation directions: inward (goInward) increases depth toward the core; outward (goOutward) decreases it toward the skin.SLAdvantageSequitur.goInward / goOutward
PassOne full inward sweep applying every layer from skin to core in order, folding each contribution into the dividend.SLAdvantageSequitur.runInwardPass
IterationRunning further passes (rebasing each time), keeping the best net advantage found, up to a cap.SLAdvantageDeveloperModel.iterate

The eight standard layers (outer → inner)

DepthLayerKindMeaning
0dividendvaluethe value under consideration
1reviewvalidatelook again; confirm the premise
2concernsrisksurface risks and caveats
3mathsquantthe quantitative core
4additionsgrowwhat the layer adds to the dividend
5subtractionshrinkwhat the layer takes away
6regroupingreorgreorganize concepts; carry/borrow across the model
7iterationloopdecide to go further down or back up the onion

3. Dynamic alteration & restitute

TermDefinitionWhere
Update modelDynamically re-point the dividend onto a new model / label / base at runtime. The onion shape is preserved; the original identity is retained for restitution.SLAdvantageDeveloperModel.updateModel, SLAdvantageUserModel.updateModel
Favor the ownerA dynamic alteration biasing the onion toward the owner: maths, additions, regrouping each gain +strength; a cost in subtraction is softened toward zero (never flipped); review/concerns/iteration are left untouched.SLAdvantageSequitur.favorOwner, SLAdvantageDeveloperModel.favorOwner, SLAdvantageUserModel.favorMe
SnapshotThe captured restitution point — the dividend identity (snapshot()) and the onion shape (snapshotShape()) that restitute() restores to.SLAdvantageDividend.snapshot, SLAdvantageSequitur.snapshotShape
Commit baselineAdopt the current (altered) state as the new restitution point, so a later restitute() returns here instead of to the init() state.SLAdvantageDeveloperModel.commitBaseline
Full restituteRestore both the dividend's identity (label, model, owner, base) and the whole onion shape to the captured baseline, clearing the pass counter. A complete, known-good undo of every dynamic alteration.SLAdvantageDeveloperModel.restitute, SLAdvantageDividend.restitute, SLAdvantageSequitur.restitute

Honesty guardrail. favorOwner never fabricates a clean review or silences a concern, and never turns a cost into a gain — biasing is an honest re-weighting, consistent with the package's metadata-honesty posture.


4. Trade math subject (math/)

Bilateral trade economics: treat buyer and seller as one coordinated system, maximize the total surplus, then divide it. Curves are quadratic (R_B(Q)=rbA·Q−rbB·Q², C_S(Q)=csA·Q+csB·Q²) so every optimum is closed-form. Full treatment in MATH.md.

4.1 Joint Profit Maximization — SLJointProfitMax

TermDefinition
Integrated surplus Π_total(Q)The total available pool of profit, R_B(Q) − C_S(Q), when both parties act as one system.
Buyer revenue R_B(Q)The buyer's revenue / utility valuation from Q units.
Seller cost C_S(Q)The seller's total cost to produce/supply Q units.
Marginal revenuedR_B/dQ — the extra revenue from one more unit.
Marginal (supply) costdC_S/dQ — the extra cost of one more unit.
Decision rule (Q*)The optimal quantity where marginal revenue equals marginal supply cost: MR = MC ⇒ Q* = (rbA − csA)/(2·(rbB + csB)).
Max joint profitΠ_total(Q*) — the surplus evaluated at the optimal quantity.

4.2 Bilateral monopoly & Nash bargaining — SLNashBargaining

TermDefinition
Wholesale price PThe transfer price that determines how the fixed pool at Q* is split.
Seller profit curveΠ_S(P,Q) = P·Q − C_S(Q).
Buyer profit curveΠ_B(P,Q) = R_B(Q) − P·Q.
Reservation profit Π_S⁰ / Π_B⁰The disagreement point — what each party makes if the deal falls through (alternative vendors, scrap value).
Bargainable surplus SΠ_total(Q*) − Π_S⁰ − Π_B⁰ — the value available to split beyond both fallbacks.
Bargaining power αAn index in [0,1]; the seller's share of S. α = 0.5 splits evenly.
Nash objectiveThe geometric product maximized by the solution: [Π_S − Π_S⁰]^α · [Π_B − Π_B⁰]^(1−α).
Nash price P*The closed-form price awarding the seller a fraction α of S: P* = (Π_S⁰ + α·S + C_S(Q*)) / Q*.

4.3 Bilateral newsvendor — SLBilateralNewsvendor

TermDefinition
Overage cost c_oThe cost of one unit too many. Seller: cs − vs; buyer: P − vb.
Underage cost c_uThe cost of one unit too few. Seller: P − cs; buyer: r − P.
Salvage vs / vbRecovered value per unsold unit — seller salvage vs, buyer salvage vb.
Retail price rThe end-market price per unit.
Production cost csThe seller's unit production cost.
Centralized critical ratio F(Q*)The system-wide service level that avoids double marginalization: (r − cs) / ((r − cs) + (cs − vb)).
Double marginalizationThe inefficiency when both parties hedge separately and restrict inventory too much, shrinking the pool.
Coordination gapHow far the buyer's standalone ratio falls short of the system ratio — how much a buyback / revenue-share contract must lift it.

4.4 Helpers — SLTradeMath

TermDefinition
expD / lnDRange-reduced Taylor / atanh series for eˣ and ln y.
powAB(a,b)General power a^b = exp(b·ln a) for a > 0 (used for the fractional Nash exponents).
sqrtDSquare root via powAB(a, 0.5).

5. Trust-field physics subject (physics/)

A structural-economics analogy: trust and announcements are modelled as geometric / topological / stochastic objects. The mathematics is implemented faithfully; the economic reading is an analogy (flagged in every class). Full treatment in PHYSICS.md.

5.1 Trust metric — SLTrustMetric

TermDefinition
Metric tensor g_μνThe object that defines distance and curvature on the economic manifold. Here a conformal 2×2 g = f(τ)·I in a flat double[4].
Trust level τA trust parameter in (0,1] that sets the conformal factor.
Conformal factor f(τ)1/τ — the scaling applied to distances. f → 1 at full trust (Euclidean); f → ∞ as trust → 0.
Line element ds²f(τ)·(dx² + dy²) — the squared length of a displacement under the metric.
Effective distance√(ds²) — the operational cost to cross a displacement; inflates as trust falls.
Warpingf(τ) − 1 ≥ 0 — the field's departure from flatness; 0 at full trust.
Flat / Euclidean fieldFull-trust regime where distances behave normally.
Warped / hyperbolic fieldLow-trust regime where friction and distance inflate.

5.2 Transactional geodesic — SLTransactionalGeodesic

TermDefinition
GeodesicThe shortest path between buyer and seller through the warped manifold; a straight line only when the field is flat.
Geodesic equationd²xᵘ/dλ² + Γᵘ_αβ (dxᵃ/dλ)(dxᵝ/dλ) = 0.
Christoffel symbols Γᵘ_αβThe "gravitational pull" of market friction, systemic risk, or political instability; derived from φ = −½ ln τ.
Trust field τ(x,y)τ₀ + gx·x + gy·y (clamped) — a trust level that varies across the plane.
Curvature ruleAs trust → 0 the Christoffel symbols balloon and the path bends; crossing the same distance costs exponentially more (capital, legal overhead, insurance).
Geodesic lengthThe accumulated trust-metric arc length along the integrated path.

5.3 Announcement contact structure — SLAnnouncementContact

TermDefinition
AnnouncementA sovereign/corporate declaration (tariff, currency peg, verified manifest) that imposes a boundary constraint on an open topological space.
Phase spaceThe 3-D space (Volume, Price, Trust) the market moves through.
Contact manifold (M, α)A 3-D space with a 1-form α satisfying the contact condition.
Contact 1-form αHere α = dz − y·dx; its kernel defines the allowed moves.
Contact condition α ∧ dα ≠ 0Non-integrability — timing, sequence, and momentum matter. The coefficient of α ∧ dα is reported as the "contact volume".
Hyperplane restrictionThe announcement confines allowed instantaneous moves to the 2-D distribution ker(α) — a slice of phase space.
Homotopy deformation H(x,t)A continuous warp (t: 0 → 1) from the announced surface back to the hidden cost reality.
Topologically nullAn announcement with no binding force — when credibility is 0 the residual credibility·(1−t) collapses to 0.

5.4 Stochastic trust decay — SLTrustDecaySDE

TermDefinition
SDEThe stochastic differential equation dτ_t = κ(τ̄ − τ_t)dt + σ√τ_t dW_t − δ dJ_t.
Mean-reversion κ(τ̄ − τ_t)Pull back toward baseline institutional trust τ̄ at speed κ.
Baseline τ̄The long-run historical institutional trust level.
Brownian motion dW_tStandard random market noise; diffusion scales with σ√τ_t.
Diffusion σThe noise scale (CIR square-root volatility).
Poisson jump δ dJ_tA breach: a sudden catastrophic drop of size δ when an announced contract is broken.
Expected pathThe deterministic trajectory (dW = 0, no jumps) — converges to τ̄.
BreachA single fired jump: τ → τ − δ (clamped at 0).

5.5 Helpers — SLPhysicsMath

Self-contained expD / lnD / powAB / sqrtD / absD, named distinctly from math/SLTradeMath to avoid cross-directory class-name ambiguity.


6. Cross-cutting conventions

TermDefinition
Metadata Class metapatternThe mandatory descriptive-metadata block (eleven catalogued attributes with get/set pairs) every new SLeeLa class carries. See .kiro/steering/metadata-class-standard.md.
metaNationalScheduleThe real, citable instrument governing a class, or "none" — never invented. The trade/physics subjects cite Cournot (1838), Nash (1950), Arrow–Harris–Marschak (1951), Einstein (1915), Cox–Ingersoll–Ross (1985).
SubjectA focused topic area within the package, organized as a subfolder (math/, physics/). The inventory generator keys the package on the first path component, so subfolders remain under the advantage package.
Sibling auto-linkingsleela run links all .sleela files in the same directory with no imports; each demo validates its own siblings.
Flat matrix storage2-D data is stored row-major in a flat double[] with r*cols + c indexing (house style, cf. lib/math/SLMatrix); SLeeLa does not use double[][].
Modelling analogyThe physics subject models economics as physics; the math is real, the economic interpretation is an analogy, declared in each class and doc.

7. Class index

ClassSubjectFile
SLPackagepackage facadeSLPackage.sleela
SLAdvantageLayeronionSLAdvantageLayer.sleela
SLAdvantageDividendonionSLAdvantageDividend.sleela
SLAdvantageSequituronionSLAdvantageSequitur.sleela
SLAdvantageUserModelonionSLAdvantageUserModel.sleela
SLAdvantageDeveloperModelonionSLAdvantageDeveloperModel.sleela
SLJointProfitMaxtrade mathmath/SLJointProfitMax.sleela
SLNashBargainingtrade mathmath/SLNashBargaining.sleela
SLBilateralNewsvendortrade mathmath/SLBilateralNewsvendor.sleela
SLTradeMathtrade mathmath/SLTradeMath.sleela
SLTrustMetricphysicsphysics/SLTrustMetric.sleela
SLTransactionalGeodesicphysicsphysics/SLTransactionalGeodesic.sleela
SLAnnouncementContactphysicsphysics/SLAnnouncementContact.sleela
SLTrustDecaySDEphysicsphysics/SLTrustDecaySDE.sleela
SLPhysicsMathphysicsphysics/SLPhysicsMath.sleela
SLIntegrationKindintegrationintegration/SLIntegrationKind.sleela
SLCompartmentintegrationintegration/SLCompartment.sleela
SLEngineeringBayintegrationintegration/SLEngineeringBay.sleela
SLTrialCompartmentintegrationintegration/SLTrialCompartment.sleela
SLNewtonMedianTrayintegrationintegration/SLNewtonMedianTray.sleela
SLVerticalIntegrationintegrationintegration/SLVerticalIntegration.sleela
SLModuleGradegradinggrading/SLModuleGrade.sleela
SLGradeSetgradinggrading/SLGradeSet.sleela
SLSophisticationCircuitgradinggrading/SLSophisticationCircuit.sleela
SLGradeBookgradinggrading/SLGradeBook.sleela
SLAdvantageSinkoutputoutput/SLAdvantageSink.sleela
SLAdvantageEmitteroutputoutput/SLAdvantageEmitter.sleela

Runnable demos (sibling-linked, each validates its subject): advantage-demo.sleela, math/trade-math-demo.sleela, physics/physics-demo.sleela, integration/integration-demo.sleela, grading/grading-demo.sleela, output/output-demo.sleela.


8. Vertical-integration subject (integration/)

A sophisticated modelling option for vertical integration through capitalism / retail: an ordered stack of value-chain tiers, each a recursively composable compartment with its own capacitive space, meaning, and relevance. Mainly a vertical arrangement (upstream → downstream). Full treatment is in the subject's classes; terms below.

8.1 Structural terms

TermDefinitionWhere
Vertical integrationOwning multiple consecutive tiers of a value chain (supply → … → retail) as one coordinated system. The top-level model.SLVerticalIntegration
TierOne stage of the chain, stored in order from upstream (index 0) to downstream (last). Each tier is a compartment.SLVerticalIntegration.tiers
CompartmentThe self-similar building block: a kind, a capacitive space, meaning, relevance, and child compartments (its own model).SLCompartment
Capacitive spaceA compartment's capacity and used units — how much it can hold and how full it is.SLCompartment.capacity / used
MeaningWhat a compartment is for (one line), derived from its kind.SLCompartment.meaning
RelevanceA compartment's weight (1–10) in the chain; summed across the tree as a value-density proxy.SLCompartment.relevance
RecursionA compartment can hold child compartments, so it recursively contains its own model(s); a nested-model kind is exactly this.SLCompartment.children, subtreeSize, depth
Vertical flowMoving used units from an upstream tier to the next downstream tier, limited by what the source holds and the destination can accept.SLVerticalIntegration.flowDownstream / runChain
System sophisticationA rolled-up score rewarding breadth (compartments), depth (recursive nesting), and relevance density: compartments + 3·maxDepth + relevance/4.SLVerticalIntegration.sophistication
UtilizationUsed units as a percentage of total capacity across the whole tree.SLVerticalIntegration.utilization

8.2 Compartment kinds (SLIntegrationKind)

The OOD vocabulary. Each kind sets a default capacity class, a meaning, and a relevance weight.

idkindmeaningcapacity class
0nested-modelrecursively embeds its own integration modelrecursive
1oniona straight Sequitur onion-model componentsmall
2engineering-baymedium-capacity build and processmedium
3trialtrial compartment for studysmall
4newton-traynewton median tray for enlightenmentsmall
5resourcesecuring resourcessmall
6mediumsecuring mediumssmall
7hobbyhobbiessmall
8gamegamessmall
9entertainmententertainmentsmall
10processprocessessmall
11consumptionconsumptionsmall
12tradingtradingsmall
13gaininggainingsmall
14sellingsellingsmall
15forcingforcingsmall
16challengingchallengingsmall

Capacity classes map to units: none 0, small 10, medium 100, large 1000, recursive 100000 (a practical cap).

8.3 Specialized compartments

TermDefinitionWhere
Engineering bayA medium-capacity productive compartment: load raw units, build a batch converting input to output at a yield percentage.SLEngineeringBay
YieldOutput as a percentage of consumed input in a bay build.SLEngineeringBay.yieldPct
Trial compartmentA study compartment: log outcome scores, report how many pass a threshold and the success rate / mean. De-risks the chain.SLTrialCompartment
Success ratePassing trials as a percentage of recorded trials at a threshold.SLTrialCompartment.successRate
Newton median trayAn enlightenment compartment: gather samples and distil insight via the median (robust centre), with spread and a robustness score.SLNewtonMedianTray
MedianThe central sample after sorting — the tray's enlightenment value; resists outliers a mean would chase.SLNewtonMedianTray.median
RobustnessA 1–10 heuristic for how trustworthy the median insight is (more samples + tighter spread → higher).SLNewtonMedianTray.robustness

8.4 Worked example (validated in integration-demo)

A retail chain `supply → engineering-bay → trial → newton-tray → nested-model(2 warehouses) → selling`:

engineering bay: load 60, build 50 at 80% yield   → produced 40
trial: outcomes 90,60,80,50 at threshold 70        → success rate 50%
newton tray: samples 3,1,9,5,7 → sorted 1,3,5,7,9  → median 5, spread 8
vertical flow: store 8 at supply, push downstream  → 8 units into the bay
aggregates: 8 compartments, maxDepth 2, capacity 100160, relevance 52
system sophistication = 8 + 3·2 + 52/4 = 27

9. Sophistication grading subject (grading/)

A sophistication circuit grader: it scores each module and rates any set of modules — winning, losing, grader, and absolute — producing letter + tier ratings throughout.

9.1 Terms

TermDefinitionWhere
Module (gradable)Any gradable unit, represented by a name and a raw sophistication score. Anything in the package (onion, compartment, vertical model, or another grader) plugs in by its score.SLModuleGrade
ScoreThe raw sophistication number fed into the grader.SLModuleGrade.score
RatingThe derived grade on two scales: a tier (1–10, roughly score/10) and a letter (S/A/B/C/D/F from the tier).SLModuleGrade.tier / letter
RoleHow a module participates: 0 normal, 1 grader (it grades others — and is itself gradable), 2 absolute (judged against a fixed bar, not the field).SLModuleGrade.role
Circuit graderThe engine: registers modules, holds the win/lose/absolute thresholds, and partitions the field into named sets.SLSophisticationCircuit
Win bar / lose barScore thresholds: a module wins if score ≥ winBar, loses if score < loseBar.SLSophisticationCircuit.winBar / loseBar
Absolute barA fixed standard: an absolute-role module passes only if score ≥ absoluteBar, independent of the field.SLSophisticationCircuit.absoluteBar
ChampionThe single highest-scoring module in the field.SLSophisticationCircuit.champion
Grade setA named collection of graded modules with its own aggregate rating (size, mean/best/worst, set letter+tier).SLGradeSet
Grade bookThe top-level face: per-module and per-set ratings, an overall field rating, win rate, and the rating of any externally-supplied set.SLGradeBook

9.2 The five sets

SetMembership ruleAccessor
allevery registered module (any set of modules)SLGradeBook.all
winningscore ≥ winBarSLGradeBook.winning
losingscore < loseBarSLGradeBook.losing
graderrole == grader (meta-graded by the same scale)SLGradeBook.graders
absoluterole == absolute and score ≥ absoluteBarSLGradeBook.absolutes

Each set is an SLGradeSet, so it carries its own rating; SLGradeBook.rateSet rates any set a caller assembles independently.

9.3 Rating scale

TierLetterScore band
10S100+
9A90–99
8B80–89
6–7C60–79
4–5D40–59
1–3Fbelow 40

9.4 Worked example (validated in grading-demo)

Eight modules graded at win = 70, lose = 40, absolute = 80:

onion 65(C6)  trade 92(A9)  physics 78(C7)  integration 100(S10)
weak 30(F3)   judge 85(B8, grader)  standard 88(B8, absolute)  flawed-abs 55(D5, absolute)

all:      8 modules, mean 74  -> C7      win rate 62%
winning:  5 (trade, physics, integration, judge, standard), mean 88 -> B8
losing:   1 (weak)                                                  -> F3
grader:   1 (judge)                                                 -> B8
absolute: 1 (standard; flawed-abs excluded — below the 80 bar)      -> B8
champion: integration (S10)

10. Output seam (output/)

So the subject modules need not stay silent (previously only the demos printed): a selectable output sink and a module-facing emitter, built on the toolchain's CommonRails printing surface.

10.1 Terms

TermDefinitionWhere
SinkDecides where rendered output goes and captures a copy.SLAdvantageSink
TargetThe sink's destination: 0 terminal (stdout), 1 commonrails (stdout, column-formatted via PrintRail), 2 socket/connector (framed + buffered), 3 silent (capture only).SLAdvantageSink.target
EndpointFor the socket target, the connector identity (e.g. host:port) prefixed onto each framed line.SLAdvantageSink.endpoint / bindEndpoint
FrameOne emitted line as stored in the capture; the socket target prefixes it with the endpoint.SLAdvantageSink.emit / appendFrame
Capture / drainThe buffered frames; lastFrame() reads them, drain() returns and clears them (a native host forwards the drained text with slnet_write).SLAdvantageSink.drain / lastFrame
EmitterThe module-facing API: line, state, status, report, pair, component, grade. Chooses formatting (CommonRails vs plain); the sink chooses destination.SLAdvantageEmitter
CommonRails formattingFor the commonrails target the emitter renders through the toolchain's PrintRail: state → stateLineText, pair → a bordered tableRowText cell, component → the professional componentLine. Naming PrintRail auto-resolves lib/common-rails; explicit character counts are passed because Core has no string-length primitive.SLAdvantageEmitter.state / pair / component
Connector lifecycleThe socket target is a real connector: bindEndpoint names it, openConnector opens it (native slnet_connect), wireWrite hands a framed line + byte count to it (native slnet_write), closeConnector closes it (native slnet_close); getBytesWritten is the running wire byte account.SLAdvantageSink.openConnector / wireWrite / closeConnector
emitThroughA self-report method on the top-level models (SLAdvantageDeveloperModel, SLVerticalIntegration, SLGradeBook): hands the model's describe() to an emitter.*.emitThrough(emitter)

10.2 The four targets

TargetBehaviour
terminal (0)print() to stdout and record a copy
commonrails (1)format via PrintRail, print() to stdout, record a copy
socket (2)real connector lifecycle: openConnector → wireWrite (framed line + byte count, accrued in getBytesWritten) → closeConnector; buffered under run (no live dial), drain() yields it for a native slnet_write
silent (3)record only, no stdout

10.3 Worked example (validated in output-demo)

terminal:    [CIRCUIT] grading modules            (printed, 2 frames)
             [GRADE] integration -> S10
commonrails: PrintRail-formatted "[WORKING] trade Q* found" padded to 80 cols
socket:      bindEndpoint("ledger.example:9077"); emit two lines; drain() ->
               [ledger.example:9077] [CIRCUIT] winning=5 losing=1
               [ledger.example:9077] [GRADE] physics -> C7
             frame count resets to 0 after drain
silent:      report("sophistication","27") -> captured "sophistication: 27"
module:      SLVerticalIntegration.emitThrough(emitter) -> 1 frame to its sink

10.4 Honest limits