@smthrs/harness 0.0.0-stage → 1.0.0-rc.3

package/dist/cjs/internal/frame.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../src/internal/frame.ts"],
+  "sourcesContent": ["/**\n * The decisions one controller frame takes from what it measured.\n *\n * `CellTurn` seals a model step and runs a cell, and both need a model, a\n * sandbox and an engine. What the frame decides from the result needs none of\n * them: what it did to the run's ledgers, whether a completion is handed back,\n * and which interventions the next frame is handed are functions of the state\n * the frame opened on and the facts it measured. Each phase here returns a\n * value, events included, instead of writing a variable a later exit reads, so\n * each one is read and tested without running a frame.\n *\n * @since 1.0.0-rc.0\n * @private\n */\n\nimport { ModelRequest } from \"@smthrs/model\"\nimport type * as Evaluator from \"@smthrs/model/Evaluator\"\nimport { Effect, Option, type Schema } from \"effect\"\nimport * as AgentEvent from \"../AgentEvent.ts\"\nimport * as CallLedger from \"../CallLedger.ts\"\nimport type { State } from \"../CellTurn.ts\"\nimport * as CompletionClaim from \"../CompletionClaim.ts\"\nimport type * as ContextWindow from \"../ContextWindow.ts\"\nimport type * as EngineLike from \"../EngineLike.ts\"\nimport * as FailedCall from \"../FailedCall.ts\"\nimport type * as HarnessError from \"../HarnessError.ts\"\nimport * as NarrowedCheck from \"../NarrowedCheck.ts\"\nimport * as Sufficiency from \"../Sufficiency.ts\"\nimport * as TruncatedOutput from \"../TruncatedOutput.ts\"\nimport * as UnmovedTree from \"../UnmovedTree.ts\"\nimport * as UnresolvedFailure from \"../UnresolvedFailure.ts\"\nimport * as VariablesPanel from \"../VariablesPanel.ts\"\nimport * as bytes from \"./bytes.ts\"\nimport * as DemandText from \"./demandText.ts\"\nimport * as elide from \"./elide.ts\"\nimport { paidTogether } from \"./paidUsage.ts\"\nimport * as UnfinishedWork from \"./unfinishedWork.ts\"\nimport * as UnobservedCall from \"./unobservedCall.ts\"\n\n/** The one journal-event-type table; see `AgentEvent.eventType`. */\nconst eventType = AgentEvent.eventType\n\n/**\n * The fields of controller state one step changes; everything else is carried.\n *\n * @since 1.0.0-rc.0\n * @private\n */\nexport type StateChanges = Partial<ConstructorParameters<typeof State>[0]>\n\n/**\n * Whether the frame budget leaves a frame after this one.\n *\n * @since 1.0.0-rc.0\n * @private\n */\nexport const hasNextFrame = (state: State): boolean => state.maxFrames === 0 || state.frame + 1 < state.maxFrames\n\n/**\n * Whether a completion can be handed back: a frame is left to answer in, and\n * spending it cannot end the run at the read-only cap. See `judgeCompletion`.\n *\n * @since 1.0.0-rc.1\n * @private\n */\nexport const handBackRoom = (state: State, readOnlyFrames: number): boolean =>\n  hasNextFrame(state) && (state.readOnlyCap === 0 || readOnlyFrames + 1 < state.readOnlyCap * 2)\n\n/**\n * One call a cell made this frame, as the frame's accounting reads it.\n *\n * Every call the frame settles is remembered so a raise can hand the model its\n * partial work. Without this, one uncaught throw discarded the frame's reads\n * and the next cell re-did them \u2014 often raising the same way again. Prime\n * Agent's tool errors return stdout-so-far plus the traceback for exactly this\n * reason.\n *\n * @since 1.0.0-rc.0\n * @private\n */\nexport interface ObservedCall {\n  readonly flow: string\n  readonly ok: boolean\n  readonly summary: string\n  /** Where this call lands in the run's ledger, so a salvage line can name it. */\n  readonly ordinal: number\n  /**\n   * Whether the call reached the engine declaring a write, which is what\n   * breaks a read-only run. A call the boundary refused is not one: it\n   * declared a write and performed none.\n   */\n  readonly mutates: boolean\n  /**\n   * Whether the write behind `mutates` was measured on a tree the host's\n   * workspace walk does not cover: the result carried the reserved `mutated`\n   * key, which `bash` sets by fingerprinting a container's working directory\n   * either side of the command. The read-only cap counts such a write like\n   * any other; the unmoved-tree demand and the claim judge need to know that\n   * the host digests holding still says nothing about it.\n   */\n  readonly remote: boolean\n  /**\n   * What this invocation asked for, as `CellTurn`'s `signatureOf` names it,\n   * with the tree it asked about folded in.\n   *\n   * The repeat ledger reads this one, because the identical command against\n   * a pinned tree and against the live tree are two different questions and\n   * a run that asks both has learned twice.\n   */\n  readonly signature: string\n  /**\n   * The same, with the tree left out: what the call asked, of whatever\n   * tree.\n   *\n   * The check ledgers read this one, because `Sufficiency` matches a\n   * failing reading against the passing reading that answered it, and the\n   * whole shape this surface exists for takes those two readings of one\n   * command over two different trees. Keyed on the tree they would never\n   * meet. For a call on the live tree the two are the same string, so\n   * nothing that existed before checkpoints re-keys.\n   */\n  readonly subject: string\n  /** The checkpoint this call ran against, when it named one. */\n  readonly at: string | undefined\n  /** What this invocation asked for, verbatim, for the narrowing ledger. */\n  readonly input: Schema.Json\n  /** What the call resolved with, verbatim, for the call ledger's digest. */\n  readonly value: Schema.Json\n  /** What the flow said about a failure, for the call ledger's digest. */\n  readonly message: string | undefined\n  /** What the flow said about its own failure, when it said it ran nothing. */\n  readonly invalidProbe: { readonly reason: string; readonly message: string } | undefined\n  /**\n   * Whether the result reported a failing exit status about its subject.\n   *\n   * A call that declared an invalid probe is never failing here, whatever\n   * its exit status: the flow itself said the failure was about the command\n   * and not about the code, so the result is not a statement about the tree\n   * at all. See `UnresolvedFailure` `failed`.\n   */\n  readonly failing: boolean\n  /**\n   * Whether the result reported a passing exit status about its subject.\n   *\n   * Not the negation of `failing`: a flow that reports no exit status is\n   * neither, and `Sufficiency` needs the difference between a check that\n   * passed and a call that never checked anything. An invalid probe is\n   * neither either, for the same reason it is never failing \u2014 the flow\n   * itself said the result is not a statement about the tree.\n   */\n  readonly passing: boolean\n}\n\n/**\n * States, unambiguously, that a call this frame failed about itself.\n *\n * The whole defect this closes is that `exitCode: 1` reads the same whether the\n * bug reproduced or the command named a test that does not exist. The flow that\n * ran the command is the only party that can tell, so it says so in its result;\n * this turns that into a sentence the next frame cannot summarise away.\n */\nconst invalidProbeNotice = (calls: ReadonlyArray<ObservedCall>): string | undefined => {\n  const lines = calls.flatMap((call) =>\n    call.invalidProbe === undefined\n      ? []\n      : [`- ${call.flow} (${call.invalidProbe.reason}): ${call.invalidProbe.message}`]\n  )\n  if (lines.length === 0) return undefined\n  return `Invalid probe \u2014 ${lines.length} call${\n    lines.length === 1 ? \"\" : \"s\"\n  } this frame failed about the command, not about the code:\\n${\n    lines.join(\"\\n\")\n  }\\nThat result is not a reproduction and is not a regression: it reads identically on a broken tree and on a fixed one, so it can neither prove the bug nor prove the repair. Repair the command before editing anything \u2014 find the real names first \u2014 and do not store it as \\`state.verification\\` or name it when you complete.`\n}\n\n/**\n * How many distinct call signatures one run carries forward.\n *\n * The ledger is durable controller state, so it is bounded. Sixty-four covers a\n * whole run at the rate a graded wave actually calls flows \u2014 its longest run\n * issued 43 calls across 24 frames \u2014 so a call is recognised as a repeat\n * however early the run first made it. A run that outlives the bound forgets\n * its oldest distinct calls first, which can cost a demand and can never\n * invent one.\n */\nconst retainedSignatures = 64\n\n/**\n * Folds one frame's signatures into the run's ledger, newest last and bounded.\n *\n * A repeated signature moves to the newest position rather than taking a\n * second slot, so a run looping on one command cannot push everything it\n * learned earlier out of the ledger.\n */\nconst remember = (\n  known: ReadonlyArray<string>,\n  made: ReadonlyArray<string>\n): ReadonlyArray<string> => {\n  const newest = new Set(known)\n  for (const digest of made) {\n    newest.delete(digest)\n    newest.add(digest)\n  }\n  const distinct = [...newest]\n  return distinct.slice(Math.max(0, distinct.length - retainedSignatures))\n}\n\n/**\n * The frame's own record of what it did to the world, computed once and\n * carried out through every exit that continues the run.\n *\n * @since 1.0.0-rc.0\n * @private\n */\nexport interface Accounting {\n  /** Whether the frame changed the workspace, by declaration or by measurement. */\n  readonly mutated: boolean\n  /** The journal's record of how that answer was reached. */\n  readonly observed: AgentEvent.MutationObserved\n  /**\n   * The digest the frame closed on, when its closing measurement covered the\n   * tree; empty otherwise, which makes every demand that reads it inert.\n   */\n  readonly workspaceDigest: string\n  /** This frame's readings of the live tree, in the order they settled. */\n  readonly frameChecks: ReadonlyArray<NarrowedCheck.Check>\n  /**\n   * Every call the frame settled, verbatim, in the order they settled.\n   *\n   * The ledgers above are what a run carries forward, and they are bounded\n   * and lossy on purpose: a durable check entry keeps a clipped label and two\n   * exit-status flags, never a result. This is the one place the whole result\n   * of a call still exists, and it exists for one frame. `CompletionClaim`\n   * quotes the last check out of it; nothing else reads it.\n   */\n  readonly calls: ReadonlyArray<ObservedCall>\n  /** The cell the frame ran, verbatim, for `FailedCall`. */\n  readonly source: string\n  /** The frame's own broken probes, stated once for whichever exit it takes. */\n  readonly probeNotice: string | undefined\n  /**\n   * Every state field the frame's measurements settle.\n   *\n   * A continuing exit states only what it changes on top of these, so a field\n   * measured here is carried whichever exit the frame leaves by. The read-only\n   * streak is one of them: when each exit passed it by hand, the frame's\n   * accounting was only as complete as the exit that remembered to.\n   */\n  readonly facts:\n    & StateChanges\n    & Required<\n      Pick<StateChanges, \"readOnlyFrames\" | \"repeatFrames\" | \"checks\" | \"failures\" | \"mutations\" | \"remoteMutations\">\n    >\n    & Required<Pick<StateChanges, \"openingDigest\" | \"callLedger\" | \"reported\">>\n}\n\n/**\n * What one frame that ran a cell did to the run's ledgers.\n *\n * Read off the calls the cell made and the two workspace measurements either\n * side of them, and nothing else: no model, sandbox or engine is consulted, so\n * a replayed frame accounts exactly as its original attempt did.\n *\n * @since 1.0.0-rc.0\n * @private\n */\nexport const account = (options: {\n  /** The state the frame opened on. */\n  readonly state: State\n  /** Every call the cell made, in the order they settled. */\n  readonly calls: ReadonlyArray<ObservedCall>\n  /** The workspace before the frame's calls. */\n  readonly opened: Option.Option<EngineLike.Observation>\n  /** The workspace after them. */\n  readonly closed: Option.Option<EngineLike.Observation>\n  /** Ids of the trees the frame pinned, oldest first. */\n  readonly minted: ReadonlyArray<string>\n  /** What the realm holds after the frame, for the variables panel. */\n  readonly bindings: ReadonlyArray<VariablesPanel.Binding>\n  /** Output the run has been handed as a fragment, this frame's included. */\n  readonly captures: ReadonlyArray<TruncatedOutput.Capture>\n  /** The cell the frame ran, verbatim; omitted reads as a cell that inspects nothing. */\n  readonly source?: string | undefined\n}): Accounting => {\n  const { calls, closed, opened, state } = options\n\n  // `declaredWrites` is what the frame's calls said about themselves and the\n  // measurement is what the workspace says. A measurement adds a mutation\n  // nothing declared \u2014 the shell redirect this exists for \u2014 and it does not\n  // take away a declaration made by a call that *succeeded*, because it does\n  // not cover the whole world: it stops at a bound, it prunes directories,\n  // and it is rooted at one path, so a real edit outside what it covers\n  // would read as an idle frame and twice the cap later the run would fail\n  // as `read_only_cap` having edited files the whole time.\n  //\n  // A declaration made by a call that *failed* is a different claim. It says\n  // what the call would have written, and a complete measurement that saw\n  // the workspace hold still contradicts it directly rather than merely\n  // failing to confirm it: nothing was written, so nothing was written\n  // outside the bound either. Wave 7 recorded two such frames on one\n  // instance \u2014 an anchor miss reporting `Failed to find expected lines`, and\n  // an edit reporting `oldString does not occur` \u2014 each of which cleared a\n  // read-only streak the run had not broken. Where the measurement is\n  // partial or absent the old rule stands, because then the digest holding\n  // still is not evidence of anything.\n  const declaredWrites = calls.filter((call) => call.mutates).length\n  const measured = Option.isSome(opened) && Option.isSome(closed)\n  const covered = measured && opened.value.complete && closed.value.complete\n  const standingWrites = calls.filter((call) => call.mutates && (call.ok || !covered)).length\n  const mutated = standingWrites > 0 || (covered && opened.value.digest !== closed.value.digest)\n  // Writes the host measurement could not have seen. A failed call measured\n  // nothing, so only a settled one counts; see `ObservedCall.remote`.\n  const remoteWrites = calls.filter((call) => call.ok && call.mutates && call.remote).length\n  const closingDigest = Option.match(closed, { onNone: () => \"\", onSome: (value) => value.digest })\n\n  // The frame's own repetition, measured the same way and carried the same\n  // way: a frame repeats when it issued calls, issued none this run had not\n  // already issued, and changed nothing. A signature the ledger has\n  // forgotten reads as new, which delays a demand and never fabricates one.\n  const signatures = calls.map((call) => call.signature)\n  const asked = new Set(state.callSignatures)\n  const novel = signatures.some((signature) => !asked.has(signature))\n  const repeatFrames = signatures.length === 0\n    ? state.repeatFrames\n    : novel || mutated\n    ? 0\n    : state.repeatFrames + 1\n\n  // The frame's own checks, and the tree they were taken over.\n  //\n  // Only a call that succeeded and declared no write is a check: a failed\n  // call observed nothing, and a call that changes the workspace is not an\n  // observation of it. The digest is the frame's own closing measurement, and\n  // only when that measurement covered the tree \u2014 under a partial or absent\n  // one a moved digest is as likely to be a bound moving as work, and this\n  // ledger's entire purpose is to say that the tree changed since a check\n  // ran. An empty digest makes an entry inert rather than wrong.\n  const workspaceDigest = covered ? closingDigest : \"\"\n  // Where the frame's writes sit among its calls, so a check can be stamped\n  // with the tree it actually read. `calls` settle in order, so a check with\n  // no standing write after it read the tree the frame closed on, whatever\n  // the frame did before it; a check with one after it read an earlier tree\n  // and the closing digest would be somebody else's answer. A measurement\n  // that moved with nothing declaring it cannot be placed among the calls at\n  // all, so that frame stamps nothing as read.\n  const standingAt = calls.map((call) => call.mutates && (call.ok || !covered))\n  const lastStandingWrite = standingAt.lastIndexOf(true)\n  const unattributedMutation = mutated && lastStandingWrite === -1\n  const readings = (checkpointed: boolean) =>\n    calls.flatMap((call, index) => {\n      if (!call.ok || call.mutates || (call.at !== undefined) !== checkpointed) return []\n      const recorded = NarrowedCheck.check({\n        flow: call.flow,\n        signature: call.subject,\n        input: call.input,\n        // A reading taken against a checkpoint is a reading of a tree that is\n        // not this workspace, so it carries no workspace digest: every ledger\n        // that reads one asks a question about the tree the run is standing\n        // on, and an entry stamped with this frame's digest would answer that\n        // question with somebody else's tree. Empty makes it inert there.\n        digest: checkpointed ? \"\" : workspaceDigest,\n        failing: call.failing,\n        passing: call.passing,\n        // Whether the tree stamped above is the tree this call read. Every\n        // write the frame declared is a call with a position among these ones,\n        // so the answer is positional: a check with no standing write after it\n        // read the closing tree, and one with a write after it read a tree\n        // that is gone. That is what lets the loop a real agent runs \u2014 edit,\n        // then run the check that was red, in one frame \u2014 hold its own\n        // evidence, while `check, then edit` still stamps nothing.\n        //\n        // A checkpointed reading is stable for a different reason: the tree it\n        // read was pinned and cannot move, so the ordering is established by\n        // the pin rather than by position \u2014 which is exactly what that surface\n        // exists to buy, and what the run used to buy by reverting its work.\n        stable: checkpointed || (!unattributedMutation && index > lastStandingWrite)\n      })\n      return recorded === undefined ? [] : [recorded]\n    })\n  const frameChecks = readings(false)\n\n  return {\n    mutated,\n    calls,\n    source: options.source ?? \"\",\n    observed: new AgentEvent.MutationObserved({\n      eventType: eventType.mutationObserved,\n      basis: covered ? \"observed\" : measured ? \"partial\" : \"declared\",\n      mutated,\n      digest: closingDigest,\n      paths: Option.match(closed, { onNone: () => 0, onSome: (value) => value.paths }),\n      declaredWrites\n    }),\n    workspaceDigest,\n    frameChecks,\n    probeNotice: invalidProbeNotice(calls),\n    facts: {\n      // Seeded from what earlier frames were handed and appended to as this\n      // frame's calls settled.\n      truncatedOutputs: TruncatedOutput.retain(options.captures),\n      workspace: closed,\n      // A frame is read-only when it changed nothing; see\n      // `State.readOnlyFrames` for why that is measured and not declared.\n      // Once the run has written something, a read-only frame that settled a\n      // call this run had not issued before holds the streak where it was: it\n      // asked a new question about work that exists, which is debugging, not a\n      // stall. Before the first write every read-only frame counts, because a\n      // run that only ever reads new things is the failure the cap was built\n      // for. Zero-call and repeat-only frames always advance it.\n      readOnlyFrames: mutated\n        ? 0\n        : novel && state.mutations > 0\n        ? state.readOnlyFrames\n        : state.readOnlyFrames + 1,\n      repeatFrames,\n      callSignatures: remember(state.callSignatures, signatures),\n      // Ids this frame pinned: a checkpoint a frame minted before it raised is\n      // still a tree the run holds, and forgetting it would leak a stored tree\n      // nothing can name.\n      checkpointIds: options.minted.length === 0 ? state.checkpointIds : [...state.checkpointIds, ...options.minted],\n      // Live readings only. Every consumer of this ledger \u2014 the narrowing\n      // demand, the unresolved-failure demand, the vacuous-verification notice\n      // \u2014 asks whether the tree the run is completing on was checked, and a\n      // checkpointed reading is not a reading of that tree.\n      checks: NarrowedCheck.remember(state.checks, frameChecks),\n      // What this frame asked, folded into what the run had already asked. A\n      // raise carries it too: a call that settled before the throw is work\n      // the run paid for, and the ledger is the only place the next model turn\n      // can read it.\n      callLedger: CallLedger.remember(state.callLedger, calls),\n      // Every call that reported an exit status, writes included, for the\n      // claim brake. See `CompletionClaim.record`.\n      reported: CompletionClaim.record(state.reported, calls),\n      // Which of this frame's checks failed before any change did, and how\n      // many frames have changed the workspace. Both, because this is the one\n      // ledger a checkpointed reading belongs in: its whole question is an\n      // ordering \u2014 this failed, then something changed, then that passed \u2014 and\n      // a pinned tree answers the first half honestly from a frame that also\n      // did the changing.\n      failures: Sufficiency.remember(state.failures, {\n        frame: [...readings(true), ...frameChecks],\n        epoch: state.mutations\n      }),\n      mutations: state.mutations + (mutated ? 1 : 0),\n      remoteMutations: state.remoteMutations + remoteWrites,\n      // The tree the run was handed, fixed the first time a frame measured one\n      // and never restamped. See `State.openingDigest`.\n      openingDigest: state.openingDigest !== \"\"\n        ? state.openingDigest\n        : Option.match(opened, {\n          onNone: () => \"\",\n          onSome: (value) => value.complete ? value.digest : \"\"\n        }),\n      // The panel the next frame opens with, stamped by the frame that ran.\n      panel: VariablesPanel.stamp(state.panel, options.bindings, state.frame),\n      ...(mutated ? { readOnlyGrace: 0, pendingReadOnlyDemand: undefined } : {})\n    }\n  }\n}\n\n/**\n * The distinct terms of everything the harness itself put in front of the run.\n *\n * The prefix zone is exactly that text \u2014 the cell contract, the flow catalog,\n * memory, and the task \u2014 and nothing else: transcript, observations, and\n * compaction summaries all land in the tail, so no term a model wrote can\n * reach this set. `NarrowedCheck.findOnly` reads it as the vocabulary the run\n * was taught, which no completion may be bounced for repeating: a run that\n * invokes the runner its task prescribes, with the flag its task prescribes,\n * added no condition of its own. Prefix parts that carry no text \u2014 a tool\n * declaration, a structured message \u2014 teach no terms.\n */\nconst taughtTerms = (window: ContextWindow.ContextWindow): ReadonlyArray<string> =>\n  NarrowedCheck.terms(\n    window.segments\n      .filter((segment) => segment.zone === \"prefix\")\n      .flatMap((segment) => segment.content)\n      .map((part) => \"text\" in part && typeof part.text === \"string\" ? part.text : \"\")\n      .join(\"\\n\")\n  )\n\n/**\n * One completion handed back, and what handing it back costs.\n *\n * @since 1.0.0-rc.0\n * @private\n */\nexport interface CompletionDemand {\n  /** The control event that names the demand in the journal. */\n  readonly event:\n    | AgentEvent.UnmovedDemanded\n    | AgentEvent.UnresolvedDemanded\n    | AgentEvent.FailedCallDemanded\n    | AgentEvent.UnobservedDemanded\n    | AgentEvent.NarrowedDemanded\n    | AgentEvent.NarrowOnlyDemanded\n    | AgentEvent.ClaimDemanded\n  /** The in-frame observation the next frame answers. */\n  readonly note: string\n  /**\n   * Whether the answer this demand takes away may come back as the run's\n   * answer when the frame budget runs out; see `CellTurn.budgetMessage`.\n   *\n   * True for the measured demands except `FailedCall`, whose answer was\n   * written over a call that failed. `UnobservedCall` keeps its answer: the\n   * brake reads the source, not the sentence, so an answer it refused may be\n   * right, and a run that ends on the budget should end on it rather than on\n   * a bare notice. Each of the others says the record is\n   * missing a fact, not that the sentence is wrong, so a run that spends its\n   * last frame and never completes again is better served by the answer it\n   * wrote than by a bare budget notice.\n   *\n   * For the claim brake it depends on which of its two heights fired, because\n   * they mean different things. A reading between `CompletionClaim.unsupportedAt`\n   * and `CompletionClaim.inventedAt` is a bounce that would let the same\n   * sentence stand if the run re-stated it, so discarding it against an\n   * exhausted budget would throw away an answer the brake was never going to\n   * refuse. A reading at or above `inventedAt` is one the brake *would* refuse:\n   * restoring that sentence on the budget notice is how one measured run turned\n   * a bounced \"the tests pass\" into its final answer with a `stop` finish over a\n   * repository whose test exits 1. A bounce that cannot be re-judged must not be\n   * undone by the budget. See `CompletionClaim.unrecorded`.\n   */\n  readonly keeps: boolean\n  /** The cap the demand spends. */\n  readonly spent: StateChanges\n}\n\n/**\n * What judging one completion produced: at most one demand, and at most one\n * reading to journal whichever way it went.\n *\n * `observed` exists for the sixth brake alone. The five before it are derived\n * from measurements the journal already carries, so a grader recomputes them\n * and there is nothing to write when they stay silent; the claim brake asks a\n * model, and a reading nobody records is a reading nobody can grade. It is set\n * only where that brake ran and issued no demand \u2014 when it does demand, the\n * same event travels on `demand.event`, so exactly one `claim-demanded` is\n * written per evaluation.\n *\n * @since 1.0.0-rc.0\n * @private\n */\nexport interface CompletionJudgement {\n  /** The claim brake's reading, when it ran and issued no demand. */\n  readonly observed: AgentEvent.ClaimDemanded | undefined\n  /** The demand that hands the completion back, when one of the six issued. */\n  readonly demand: CompletionDemand | undefined\n  /**\n   * The failure the run ends with when the claim brake read a claim the\n   * evidence does not support and no bounce was left to spend. It travels on\n   * the judgement rather than as the effect's own failure so the caller\n   * journals `observed` first: a reading that ends a run is the one a grader\n   * most needs, and an effect that failed would take it with it.\n   */\n  readonly unproven: HarnessError.HarnessError | undefined\n  /**\n   * The claim brake's whole decision, whenever it read one: the evidence, the\n   * questions and the answers behind the three numbers `observed` or the\n   * demand carries. Set on every way a reading comes out, because the record a\n   * reader reopens a decision from is needed most for the one that acted.\n   */\n  readonly decision: AgentEvent.DecisionSettled | undefined\n  /** The per-sentence decision, when the brake asked for one. */\n  readonly sentenceDecision?: AgentEvent.DecisionSettled | undefined\n  /**\n   * Whether the completion reported its own work unfinished, when the verdict\n   * asked. See `UnfinishedWork`.\n   */\n  readonly unfinishedDecision?: AgentEvent.DecisionSettled | undefined\n}\n\n/** Nothing to say about this completion: it stands. */\nconst stands: CompletionJudgement = {\n  observed: undefined,\n  demand: undefined,\n  unproven: undefined,\n  decision: undefined\n}\n\n/** One demand, with the brake's decision beside it when the brake issued it. */\nconst handBack = (demand: CompletionDemand, decision?: AgentEvent.DecisionSettled): CompletionJudgement => ({\n  observed: undefined,\n  demand,\n  unproven: undefined,\n  decision\n})\n\n/**\n * The prose the harness itself put in front of the run as its task.\n *\n * The `instructions` segments of the prefix zone and nothing else: `Agent`\n * writes the task there, while the cell contract, the flow catalog, the\n * project's instructions and the host's memory go in as `system` and the\n * transcript goes in the tail. So this is the closest thing the controller holds to the task as\n * the person stated it, and it cannot pick up a sentence the model wrote.\n *\n * @since 1.0.0-rc.0\n * @private\n */\nexport const taskText = (window: ContextWindow.ContextWindow): string =>\n  window.segments\n    .filter((segment) => segment.zone === \"prefix\" && segment.kind === \"instructions\")\n    .flatMap((segment) => segment.content)\n    .map((part) => \"text\" in part && typeof part.text === \"string\" ? part.text : \"\")\n    .filter((text) => text !== \"\")\n    .join(\"\\n\\n\")\n\n/**\n * The last reading of the completing frame that reported an exit status.\n *\n * The verbatim result exists for exactly one frame, the one being judged, so\n * this is the only check the brake can quote in full, and a completing frame\n * that ran none sends none rather than sending a description of one.\n *\n * It is not the run's evidence, only the newest page of it. `CompletionClaim.record`\n * is the rest, and the two are separate because one measured live failure was\n * exactly the difference: a run that fixed the planted bug, ran the\n * repository's test, and then ran `git diff` to show its work sent the\n * `git diff` and not the test, so its true sentence reported a result nothing\n * in the payload recorded. See `CompletionClaim.Evidence`.\n */\nconst lastCheck = (calls: ReadonlyArray<ObservedCall>): CompletionClaim.Check | undefined => {\n  for (let index = calls.length - 1; index >= 0; index--) {\n    const call = calls[index]!\n    if (!call.ok || call.mutates) continue\n    const status = UnresolvedFailure.exitStatus(call.value)\n    if (status === undefined) continue\n    return {\n      command: CompletionClaim.quote(call.input),\n      exitCode: status,\n      output: CompletionClaim.newest(CompletionClaim.quote(call.value))\n    }\n  }\n  return undefined\n}\n\n/**\n * The demands a completion's own measurements produce, in precedence order \u2014\n * `FailedCall`, `UnobservedCall`, then the three below \u2014 or nothing. The\n * `UnmovedTree` demand is not one of them: an unmoved tree is the right tree\n * for a question, so it is issued only when the claim brake reads the\n * completion as unsupported. See `judgeCompletion`. Every fact read here was taken by the frame that is\n * completing or by an earlier one, so this is a pure function of the state\n * and the accounting and it is what `judgeCompletion` consults first.\n *\n * @since 1.0.0-rc.0\n * @private\n */\nconst measuredDemand = (\n  state: State,\n  accounting: Accounting,\n  contextWindow: ContextWindow.ContextWindow,\n  nextFrame: number,\n  claim: string\n): CompletionDemand | undefined => {\n  const { calls, facts, frameChecks, workspaceDigest } = accounting\n  // First, because the others read a record this completion was written\n  // without: its own cell failed a call before the claim existed. It is the\n  // one measured demand whose answer is not kept, because the answer it takes\n  // away is the sentence written blind. See `FailedCall`.\n  if (state.failedCallDemands < FailedCall.cap) {\n    const failures = FailedCall.find(calls, claim, accounting.source)\n    if (failures.length > 0) {\n      return {\n        event: new AgentEvent.FailedCallDemanded({\n          eventType: eventType.failedCallDemanded,\n          failures: failures.map((failure) => ({ flow: failure.flow, message: failure.message })),\n          nextFrame\n        }),\n        note: FailedCall.demand(failures),\n        keeps: false,\n        spent: { failedCallDemands: state.failedCallDemands + 1 }\n      }\n    }\n  }\n  // Second, for the same reason: the claim was written before any result of\n  // its own cell existed, so every demand below would grade a sentence the\n  // model wrote without reading. Kept, unlike the one above: the source was\n  // read, not the sentence, so it stays the run's answer at the budget. See\n  // `UnobservedCall`.\n  if (state.unobservedDemands < UnobservedCall.cap) {\n    const unread = UnobservedCall.find(calls, accounting.source)\n    if (unread.length > 0) {\n      return {\n        event: new AgentEvent.UnobservedDemanded({\n          eventType: eventType.unobservedDemanded,\n          calls: unread,\n          nextFrame\n        }),\n        note: UnobservedCall.demand(unread),\n        keeps: true,\n        spent: { unobservedDemands: state.unobservedDemands + 1 }\n      }\n    }\n  }\n  if (state.unresolvedDemands < state.unresolvedCap) {\n    const unresolved = UnresolvedFailure.find({ ledger: facts.checks, digest: workspaceDigest })\n    if (unresolved !== undefined) {\n      return {\n        event: new AgentEvent.UnresolvedDemanded({\n          eventType: eventType.unresolvedDemanded,\n          flow: unresolved.failed.flow,\n          failed: unresolved.failed.label,\n          instead: unresolved.instead.label,\n          currentDigest: workspaceDigest,\n          nextFrame\n        }),\n        note: UnresolvedFailure.demand(unresolved),\n        keeps: true,\n        spent: { unresolvedDemands: state.unresolvedDemands + 1 }\n      }\n    }\n  }\n  if (state.narrowingDemands >= state.narrowingCap) return undefined\n  const spent = { narrowingDemands: state.narrowingDemands + 1 }\n  const narrowing = NarrowedCheck.find({ ledger: state.checks, frame: frameChecks, digest: workspaceDigest })\n  if (narrowing !== undefined) {\n    return {\n      event: new AgentEvent.NarrowedDemanded({\n        eventType: eventType.narrowedDemanded,\n        flow: narrowing.earlier.flow,\n        broader: narrowing.earlier.label,\n        narrower: narrowing.later.label,\n        broaderDigest: narrowing.earlier.digest,\n        currentDigest: workspaceDigest,\n        nextFrame\n      }),\n      note: NarrowedCheck.demand(narrowing),\n      keeps: true,\n      spent\n    }\n  }\n  const only = NarrowedCheck.findOnly({\n    ledger: facts.checks,\n    before: state.checks.map((entry) => entry.signature),\n    frame: frameChecks,\n    taught: taughtTerms(contextWindow)\n  })\n  if (only === undefined) return undefined\n  return {\n    event: new AgentEvent.NarrowOnlyDemanded({\n      eventType: eventType.narrowOnlyDemanded,\n      flow: only.later.flow,\n      check: only.later.label,\n      targets: only.targets,\n      currentDigest: workspaceDigest,\n      nextFrame\n    }),\n    note: NarrowedCheck.demandOnly(only),\n    keeps: true,\n    spent\n  }\n}\n\n/**\n * Whether a `complete` transition stands, or which demand hands it back.\n *\n * The completion's own evidence, judged once per demand. A run gets exactly\n * one frame wrong for free \u2014 the last one \u2014 and five things can be wrong with\n * it, four of them read off measurements the controller already took, under\n * four caps:\n *\n * 1. `UnmovedTree`: the tree it is completing on is the tree it opened on, so\n *    there is no change for any evidence to be about. This one is not read\n *    alone: a question is answered on the tree it was asked on, so it is\n *    issued only where the claim brake (5) found the completion unsupported,\n *    and then in the brake's place;\n * 2. `UnresolvedFailure`: a check over this exact tree reported a failing exit\n *    status and the run answered it with a different reading of the same\n *    subject rather than with the check itself;\n * 3. `NarrowedCheck.find`: this frame's check repeats an earlier, broader one\n *    and adds conditions to it, run after a change the broader one never saw;\n * 4. `NarrowedCheck.findOnly`: the check this frame ended on is the run's only\n *    reading of what it names \u2014 nothing broader was ever taken, so there was\n *    no broader check for (3) to find \u2014 and it carries a condition the run\n *    itself added, one taught neither by the prefix this harness wrote nor by\n *    the run's own other checks.\n *\n * Demands 3 and 4 share one cap. They are two readings of one question \u2014\n * whether the evidence covers what it looks like it covers \u2014 and a run that\n * answers either has answered the question; a second bounce would be the loop\n * asking it twice in different words.\n *\n * 5. `CompletionClaim`: the last brake and the only one that is not a\n *    measurement. The four above have said nothing, which means the tree\n *    moved, no check was stepped around, and whatever the run checked it\n *    checked whole \u2014 and none of that reads the sentence the run wrote. So\n *    the claim, the task, the tree fact, every check the run took over this\n *    tree and the verbatim result of the last one go to Jev, and a claim that\n *    reports a command or a result none of that records hands the frame back\n *    from a cap of its own. It is last because it is the only one\n *    that costs a request, and because a run one of the four already named\n *    has a demand to answer: asking a model to add a second one would hand\n *    the frame two questions. It never falls back: a completion Jev could\n *    not judge \u2014 no evaluator on the host, a refusal, a deadline, an answer\n *    that does not decode \u2014 fails the turn as `completion_unjudged` carrying\n *    the reason, the way `read_only_cap` ends a run, rather than standing.\n *    `Evaluator` is therefore a required service of this function and of\n *    every turn above it.\n *\n * The fifth is the one that is read on *every* completion, and the three\n * things below that take a demand away do not take the reading away. The\n * others are recomputable from the journal, so skipping them costs a grader\n * nothing and a skipped one lets a completion stand that the truth bar still\n * judges. This one is a sentence being checked against the record, it is what\n * the server banner and the operator docs promise happens to every completion,\n * and the run's answer is the product. So when there is no bounce left to\n * spend \u2014 the cap is used up, or none of the room below exists \u2014 a claim that\n * reports work the record does not record ends the run as `claim_unproven`\n * instead of standing. That is the shape `read_only_cap` already uses, and it\n * is the only shape that keeps the promise: a cap that stops at the bounce\n * means the second identical claim is accepted unread, which is what a live\n * run did.\n *\n * The verdict is narrower than the bounce, and that is the whole of what this\n * lane changed. A completion the brake merely finds thin is handed back once\n * and then stands; only a completion at `CompletionClaim.inventedAt` \u2014 a\n * sentence reporting a command or a result nothing in the run produced \u2014 is\n * refused. Arming the verdict on \"is the task done\" instead killed roughly one\n * honest run in four, including five question-shaped turns in a row and one\n * live CI dispatch whose planted bug was fixed. `CompletionClaim`'s header\n * carries the eighteen-state corpus that measured it.\n *\n * A thin completion that stands is still not a success when it says so\n * itself. Where the verdict is reached on a completion read as not done, one\n * more question asks whether the completion reports its own work unfinished,\n * and one that does ends the run as `completion_incomplete` quoting that\n * report, so a host never settles \"I could not finish\" as a completed run.\n * See `UnfinishedWork`.\n *\n * At most one is named, in that order, because they are in descending order of\n * how fundamental the missing thing is: there is nothing to check, then the\n * check said no, then the check said less than it looks like it said, then\n * nothing in the record matches what the run said it did. Naming two at once\n * would ask the run to answer a question it has not been given a frame for.\n *\n * The loop names what is missing and hands the frame back; it does not re-run\n * anything, and it does not judge the answer that comes back.\n *\n * Asking costs the run a frame it can answer in, so a demand is issued only\n * where that frame exists, and three separate things take it away (and leave\n * the claim brake reading anyway, as above):\n *\n * - the frame budget, which has no frame left to spend, and turning a\n *   completion into an exhausted budget would lose the run's answer to make a\n *   point about it;\n * - the read-only cap, which is the other budget that ends a run and ends it as\n *   a typed failure carrying nothing. A run that changed nothing is exactly the\n *   run `UnmovedTree` fires on, so a completion one frame short of twice the\n *   cap would be bounced, spend that frame reading, and die as `read_only_cap`\n *   with the answer it had already written discarded \u2014 a demand turning a\n *   finished run into a failure, which is the one outcome none of these may\n *   produce;\n * - a demand this run has already answered. Each demand ends by promising that\n *   what comes back next is the answer that stands, and three of them fire on\n *   one transition, so the frame written to answer one is never judged by the\n *   next. See `State.demandedFrame`.\n *\n * @since 1.0.0-rc.0\n * @private\n */\nexport const judgeCompletion = (\n  state: State,\n  accounting: Accounting,\n  contextWindow: ContextWindow.ContextWindow,\n  claim: string,\n  read: typeof CompletionClaim.read = CompletionClaim.read\n): Effect.Effect<CompletionJudgement, HarnessError.HarnessError, Evaluator.Evaluator> =>\n  Effect.gen(function*() {\n    const { calls, facts, workspaceDigest } = accounting\n    const room = handBackRoom(state, facts.readOnlyFrames) && state.demandedFrame !== state.frame\n    const nextFrame = state.frame + 1\n    if (room) {\n      const measured = measuredDemand(state, accounting, contextWindow, nextFrame, claim)\n      // A measured demand names a missing fact, so the answer it takes away\n      // is worth restoring if the budget runs out, unless the demand says the\n      // answer was written blind. See `CompletionDemand`.\n      if (measured !== undefined) return handBack(measured)\n    }\n\n    // The sixth brake, and the only one that leaves this package to decide.\n    // `claimCap` of zero disarms it: no request, no event, no failure, which\n    // is what a host that does not want a model in this path asks for.\n    if (state.claimCap === 0) return stands\n    // A host may put prior conversation before the current request. Keep\n    // both ends of the task; clipping its head alone can leave only history.\n    // Reserve the elision notice inside the task's byte budget.\n    const originalTask = taskText(contextWindow).trim()\n    const recallTask = \"the run record has the whole task\"\n    const task = elide.middle(\n      originalTask,\n      CompletionClaim.proseBytes - elide.noticeCost(bytes.size(originalTask), recallTask),\n      recallTask\n    )\n    const check = lastCheck(calls)\n    const unmovedTree = UnmovedTree.find({\n      opened: facts.openingDigest,\n      digest: workspaceDigest,\n      elsewhere: facts.remoteMutations\n    })\n    const evidence: CompletionClaim.Evidence = {\n      task,\n      claim: CompletionClaim.prose(claim),\n      // The `UnmovedTree` fact, read the other way round. An unmeasured tree\n      // reads as moved, which is the reading that asks for nothing.\n      treeMoved: unmovedTree === undefined,\n      checksRun: facts.reported,\n      callsRun: facts.callLedger.map((entry) => ({\n        flow: entry.flow,\n        input: entry.subject,\n        ok: entry.ok,\n        resultSummary: entry.digest\n      })),\n      ...(check === undefined ? {} : { lastCheck: check })\n    }\n    const reading = yield* read(evidence)\n    if (reading === undefined) return stands\n    const found = CompletionClaim.find(reading)\n    // One bounce while the cap and a frame allow it; the verdict after that,\n    // and only over the readings the verdict is about.\n    const bounced = found !== undefined && room && state.claimDemands < state.claimCap\n    // An unmoved tree alone is not a demand: a read-only question is answered\n    // on exactly the tree it was asked on, and bouncing that answer discarded\n    // correct replies (#2937). The tree fact names what is missing only when\n    // this reading found the claim unsupported, and then its wording is the\n    // more precise of the two, so it takes the bounce while its cap lasts and\n    // the reading is journaled beside it as one that did not demand.\n    const unmoved = found !== undefined && room && state.unmovedDemands < state.unmovedCap\n      ? unmovedTree\n      : undefined\n    // The third way a reading comes out, stated on the event because nothing\n    // downstream can derive it: a reading that neither stands nor hands the\n    // frame back is the one that ends the run, and a projection that could not\n    // tell it from a reading that stood wrote no card for it. See\n    // `AgentEvent.ClaimDemanded.refused`.\n    const refused = found !== undefined && !bounced && unmoved === undefined && CompletionClaim.unrecorded(found)\n    // A completion read as not done, with no bounce left and nothing to\n    // refuse, used to stand here whatever it said, so a run reporting its own\n    // work unfinished settled as a completed one (#3009). Whether it said so\n    // is one more question, asked only here; see `UnfinishedWork`.\n    const unfinished = found !== undefined && !bounced && unmoved === undefined && !refused &&\n        reading.complete <= CompletionClaim.disprovenAt\n      ? yield* UnfinishedWork.read(evidence, reading.usage)\n      : undefined\n    const incomplete = unfinished !== undefined && unfinished.unfinished >= UnfinishedWork.reportedAt\n    const usage = paidTogether(reading.usage, unfinished?.usage)\n    const event = new AgentEvent.ClaimDemanded({\n      eventType: eventType.claimDemanded,\n      complete: reading.complete,\n      overclaims: reading.overclaims,\n      invented: reading.invented,\n      latencyMs: reading.latencyMs + (unfinished?.latencyMs ?? 0),\n      ...(usage === undefined ? {} : { usage }),\n      demanded: bounced && unmoved === undefined,\n      refused,\n      currentDigest: workspaceDigest,\n      nextFrame\n    })\n    // The same reading with what it was a reading OF. `acted` is the two ways\n    // a reading changes what the run does next, and a reader that reported no\n    // evidence journals no decision: see `CompletionClaim.Reading.asked`.\n    const decision = reading.asked === undefined ? undefined : new AgentEvent.DecisionSettled({\n      eventType: eventType.decisionSettled,\n      scope: state.session,\n      frame: state.frame,\n      classifier: CompletionClaim.classifier.id,\n      digest: CompletionClaim.classifier.digest,\n      state: reading.asked.state,\n      questions: CompletionClaim.classifier.questions,\n      answers: reading.asked.answers,\n      latencyMs: reading.latencyMs,\n      acted: bounced || refused || unmoved !== undefined || incomplete,\n      decidedBy: \"jev\"\n    })\n    const unfinishedDecision = unfinished === undefined ? undefined : new AgentEvent.DecisionSettled({\n      eventType: eventType.decisionSettled,\n      scope: state.session,\n      frame: state.frame,\n      classifier: unfinished.asked.classifier,\n      digest: unfinished.asked.digest,\n      state: unfinished.asked.state,\n      questions: unfinished.asked.questions,\n      answers: unfinished.asked.answers,\n      latencyMs: unfinished.latencyMs,\n      acted: incomplete,\n      decidedBy: \"jev\"\n    })\n    // The per-sentence reading, journaled as its own decision because it is\n    // one: its own classifier, questions and answers. See\n    // `CompletionClaim.sentenceClassifier`.\n    const sentenceDecision = reading.sentences === undefined ? undefined : new AgentEvent.DecisionSettled({\n      eventType: eventType.decisionSettled,\n      scope: state.session,\n      frame: state.frame,\n      classifier: reading.sentences.classifier,\n      digest: reading.sentences.digest,\n      state: reading.sentences.state,\n      questions: reading.sentences.questions,\n      answers: reading.sentences.answers,\n      latencyMs: reading.sentences.latencyMs,\n      acted: bounced || refused || unmoved !== undefined,\n      decidedBy: \"jev\"\n    })\n    if (found === undefined) {\n      return { observed: event, demand: undefined, unproven: undefined, decision, sentenceDecision }\n    }\n    if (unmoved !== undefined) {\n      return {\n        ...handBack({\n          event: new AgentEvent.UnmovedDemanded({\n            eventType: eventType.unmovedDemanded,\n            openedDigest: unmoved.opened,\n            currentDigest: unmoved.closed,\n            nextFrame\n          }),\n          note: UnmovedTree.demand(unmoved),\n          keeps: !CompletionClaim.unrecorded(found),\n          spent: { unmovedDemands: state.unmovedDemands + 1 }\n        }, decision),\n        observed: event,\n        sentenceDecision\n      }\n    }\n    if (bounced) {\n      return {\n        ...handBack({\n          event,\n          note: CompletionClaim.demand(),\n          // A bounce the brake would not refuse is worth restoring against an\n          // exhausted budget; one it would refuse is not. See `CompletionDemand`.\n          keeps: !CompletionClaim.unrecorded(found),\n          spent: { claimDemands: state.claimDemands + 1 }\n        }, decision),\n        sentenceDecision\n      }\n    }\n    // Out of bounces. A claim the brake only found thin stands here: it was\n    // handed back once, the run answered, and refusing the answer as well is\n    // the price that destroyed honest runs. Only an unrecorded claim is\n    // refused, and only a completion reporting its own work unfinished fails.\n    return {\n      observed: event,\n      demand: undefined,\n      // Either bounce handed the claim back: the unmoved demand spends its\n      // own cap in the claim brake's place.\n      unproven: refused\n        ? CompletionClaim.unproven(found, state.claimDemands + state.unmovedDemands > 0, claim)\n        : incomplete\n        ? UnfinishedWork.incomplete(reading.complete, unfinished.unfinished, claim)\n        : undefined,\n      decision,\n      sentenceDecision,\n      ...(unfinishedDecision === undefined ? {} : { unfinishedDecision })\n    }\n  })\n\n/**\n * The interventions one ordinary continuing frame hands to the next.\n *\n * @since 1.0.0-rc.0\n * @private\n */\nexport interface Discipline {\n  /** The control events that issue them, in journal order. */\n  readonly events: ReadonlyArray<AgentEvent.AgentEvent>\n  /** The messages the next frame reads after the steering it was sent. */\n  readonly messages: ReadonlyArray<ModelRequest.Message>\n  /** What issuing them changes on top of the frame's facts. */\n  readonly changes: StateChanges\n}\n\n/**\n * The read-only, repeat and sufficiency interventions for a frame that settled\n * a `continue` transition and has a frame after it.\n *\n * The read-only intervention. At the cap the next frame is told, structurally,\n * that it must write something or say why it cannot; a justification is typed\n * data on the transition, is recorded, and buys a bounded quiet spell without\n * resetting the counter that ends the run at twice the cap.\n *\n * A justification buys that spell only when it *answers* a demand this frame\n * was handed. A justification volunteered by a frame nobody asked is recorded \u2014\n * it is a field on the transition and the journal writes the whole transition \u2014\n * and buys nothing. The two cannot be the same price, because the counter runs\n * regardless of which one is written: a run that volunteers one every few\n * frames used to renew the quiet spell before the streak could ever hand the\n * demand out, so the demand was never issued, never journaled, and never got\n * its one chance to redirect the run, while the hard stop at twice the cap \u2014\n * which no grace touches \u2014 killed the run anyway. Two SWE-bench waves lost\n * `pydata__xarray-7393` exactly so: ten volunteered justifications, zero\n * `read-only-demanded` events, and death at 24 frames against a cap of 12\n * without the control ever speaking.\n *\n * The convergence intervention. It is journaled when it is *issued* rather than\n * when the next frame answers it, because what answers it is the shape of that\n * frame's calls \u2014 which the journal already writes one by one \u2014 and not a\n * field on a transition the controller has to wait for. Issuing it restarts the\n * count, so a run that keeps repeating is told once every `repeatCap` frames\n * instead of every frame.\n *\n * The counterweight, and the only notice here that asks for nothing. It is\n * written on the frame that completes the pair rather than at a completion,\n * because its whole purpose is to reach a run that is still deciding whether to\n * keep working \u2014 a run at its `complete` transition has already decided. See\n * `Sufficiency`.\n *\n * @since 1.0.0-rc.0\n * @private\n */\nexport const discipline = (\n  state: State,\n  accounting: Accounting,\n  justification: string | undefined\n): Discipline => {\n  const { facts } = accounting\n  const cap = state.readOnlyCap\n  const readOnly = !accounting.mutated\n  const graceLeft = readOnly ? state.readOnlyGrace : 0\n  const justified = readOnly && state.pendingReadOnlyDemand !== undefined &&\n    (justification ?? \"\").trim().length > 0\n  // Only a frame that advanced the streak earns the demand: a probing frame\n  // holds the streak where it was, and repeating the demand to it every frame\n  // would nag a run the cap has already decided is working.\n  const advanced = readOnly && facts.readOnlyFrames > state.readOnlyFrames\n  const demanded = cap > 0 && advanced && facts.readOnlyFrames >= cap && graceLeft === 0 && !justified\n  const repeated = state.repeatCap > 0 && facts.repeatFrames >= state.repeatCap\n  const sufficient = state.sufficiencyStated\n    ? undefined\n    : Sufficiency.find({ ledger: facts.failures, frame: accounting.frameChecks, epoch: facts.mutations })\n  const nextFrame = state.frame + 1\n  return {\n    events: [\n      ...(demanded\n        ? [\n          new AgentEvent.ReadOnlyDemandIssued({\n            eventType: eventType.readOnlyDemandIssued,\n            streak: facts.readOnlyFrames,\n            cap,\n            nextFrame\n          })\n        ]\n        : []),\n      ...(repeated\n        ? [\n          new AgentEvent.RepeatDemanded({\n            eventType: eventType.repeatDemanded,\n            frames: facts.repeatFrames,\n            cap: state.repeatCap,\n            nextFrame\n          })\n        ]\n        : []),\n      ...(sufficient === undefined ? [] : [\n        new AgentEvent.SufficiencyObserved({\n          eventType: eventType.sufficiencyObserved,\n          flow: sufficient.failed.flow,\n          failed: sufficient.failed.label,\n          passed: sufficient.passed.label,\n          epoch: sufficient.failed.epoch,\n          nextFrame\n        })\n      ])\n    ],\n    messages: [\n      ...(accounting.probeNotice === undefined ? [] : [ModelRequest.Message.user(accounting.probeNotice)]),\n      ...(demanded ? [ModelRequest.Message.user(DemandText.readOnly(cap, facts.readOnlyFrames))] : []),\n      ...(repeated ? [ModelRequest.Message.user(DemandText.repeat(facts.repeatFrames, state.repeatCap))] : []),\n      ...(sufficient === undefined ? [] : [ModelRequest.Message.user(Sufficiency.observation(sufficient))])\n    ],\n    changes: {\n      readOnlyGrace: justified ? cap : Math.max(0, graceLeft - 1),\n      repeatFrames: repeated ? 0 : facts.repeatFrames,\n      ...(sufficient === undefined ? {} : { sufficiencyStated: true }),\n      pendingReadOnlyDemand: demanded ? { streak: facts.readOnlyFrames, cap } : undefined\n    }\n  }\n}\n"],
+  "mappings": "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",
+  "names": []
+}

package/dist/cjs/internal/nonNegativeSafeInt.d.ts

@@ -0,0 +1,20 @@
+/**
+ * The bound every journaled count in this package is declared with.
+ *
+ * A count that crossed the safe-integer ceiling would compare and re-encode
+ * wrongly on the way back out of a journal, so every ordinal, frame number,
+ * byte count and cap is admitted through one validator rather than six copies
+ * that happened to agree.
+ *
+ * @since 1.0.0-rc.0
+ * @private
+ */
+import { Schema } from "effect";
+/**
+ * A count in `[0, Number.MAX_SAFE_INTEGER]`.
+ *
+ * @since 1.0.0-rc.0
+ * @private
+ */
+export declare const NonNegativeSafeInt: Schema.Int;
+//# sourceMappingURL=nonNegativeSafeInt.d.ts.map

package/dist/cjs/internal/nonNegativeSafeInt.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"nonNegativeSafeInt.d.ts","sourceRoot":"","sources":["../../../src/internal/nonNegativeSafeInt.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;GAUG;AAEH,OAAO,EAAE,MAAM,EAAE,MAAM,QAAQ,CAAA;AAE/B;;;;;GAKG;AACH,eAAO,MAAM,kBAAkB,YAG9B,CAAA"}

package/dist/cjs/internal/nonNegativeSafeInt.js

@@ -0,0 +1,29 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var nonNegativeSafeInt_exports = {};
+__export(nonNegativeSafeInt_exports, {
+  NonNegativeSafeInt: () => NonNegativeSafeInt
+});
+module.exports = __toCommonJS(nonNegativeSafeInt_exports);
+var import_effect = require("effect");
+const NonNegativeSafeInt = import_effect.Schema.Int.check(
+  import_effect.Schema.isGreaterThanOrEqualTo(0),
+  import_effect.Schema.isLessThanOrEqualTo(Number.MAX_SAFE_INTEGER)
+);
+//# sourceMappingURL=nonNegativeSafeInt.js.map

package/dist/cjs/internal/nonNegativeSafeInt.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../src/internal/nonNegativeSafeInt.ts"],
+  "sourcesContent": ["/**\n * The bound every journaled count in this package is declared with.\n *\n * A count that crossed the safe-integer ceiling would compare and re-encode\n * wrongly on the way back out of a journal, so every ordinal, frame number,\n * byte count and cap is admitted through one validator rather than six copies\n * that happened to agree.\n *\n * @since 1.0.0-rc.0\n * @private\n */\n\nimport { Schema } from \"effect\"\n\n/**\n * A count in `[0, Number.MAX_SAFE_INTEGER]`.\n *\n * @since 1.0.0-rc.0\n * @private\n */\nexport const NonNegativeSafeInt = Schema.Int.check(\n  Schema.isGreaterThanOrEqualTo(0),\n  Schema.isLessThanOrEqualTo(Number.MAX_SAFE_INTEGER)\n)\n"],
+  "mappings": ";;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAYA,oBAAuB;AAQhB,MAAM,qBAAqB,qBAAO,IAAI;AAAA,EAC3C,qBAAO,uBAAuB,CAAC;AAAA,EAC/B,qBAAO,oBAAoB,OAAO,gBAAgB;AACpD;",
+  "names": []
+}

package/dist/cjs/internal/paidUsage.d.ts

@@ -0,0 +1,52 @@
+/**
+ * The model usage a recorded boundary paid for, summed over its readings.
+ *
+ * @since 1.0.0-rc.1
+ * @private
+ */
+import type * as Classifier from "@smthrs/model/Classifier";
+import * as Evaluator from "@smthrs/model/Evaluator";
+import type * as EngineLike from "../EngineLike.ts";
+/**
+ * One reading's metered usage and the model that read it; absent when the
+ * transport reported none.
+ *
+ * @since 1.0.0-rc.1
+ * @private
+ */
+export type Metered = {
+    readonly inputTokens: number;
+    readonly outputTokens: number;
+    readonly modelId?: string | undefined;
+} | undefined;
+/**
+ * Sums the readings that were metered, one share per model in the order each
+ * model first read. `undefined` when none was: a reading the transport did not
+ * meter is not a reading that cost zero.
+ *
+ * @since 1.0.0-rc.1
+ * @private
+ */
+export declare const paidUsage: (readings: ReadonlyArray<Metered>) => ReadonlyArray<EngineLike.Paid> | undefined;
+/**
+ * What two readings of one completion paid together. Either may come back
+ * unmetered; the completion costs what was metered. Both ask the same judge,
+ * so the sum keeps its model id, and drops it only when a fallback answered
+ * one.
+ *
+ * @since 1.0.0-rc.1
+ * @private
+ */
+export declare const paidTogether: (first: Evaluator.Usage | undefined, second: Evaluator.Usage | undefined) => Evaluator.Usage | undefined;
+/**
+ * A reading that failed, as the typed cause its turn fails with: the
+ * transport's code and structured facts, its public message (a transport's
+ * own text can name hosts and URLs), and what it paid with what the
+ * `earlier` readings of the same completion paid, so the run's budget
+ * charges both (#3010).
+ *
+ * @since 1.0.0-rc.1
+ * @private
+ */
+export declare const failedReading: (error: Classifier.ClassifierError, earlier: Evaluator.Usage | undefined) => Evaluator.EvaluatorError;
+//# sourceMappingURL=paidUsage.d.ts.map

package/dist/cjs/internal/paidUsage.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"paidUsage.d.ts","sourceRoot":"","sources":["../../../src/internal/paidUsage.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAEH,OAAO,KAAK,KAAK,UAAU,MAAM,0BAA0B,CAAA;AAC3D,OAAO,KAAK,SAAS,MAAM,yBAAyB,CAAA;AACpD,OAAO,KAAK,KAAK,UAAU,MAAM,kBAAkB,CAAA;AAEnD;;;;;;GAMG;AACH,MAAM,MAAM,OAAO,GACf;IAAE,QAAQ,CAAC,WAAW,EAAE,MAAM,CAAC;IAAC,QAAQ,CAAC,YAAY,EAAE,MAAM,CAAC;IAAC,QAAQ,CAAC,OAAO,CAAC,EAAE,MAAM,GAAG,SAAS,CAAA;CAAE,GACtG,SAAS,CAAA;AAEb;;;;;;;GAOG;AACH,eAAO,MAAM,SAAS,GAAI,UAAU,aAAa,CAAC,OAAO,CAAC,KAAG,aAAa,CAAC,UAAU,CAAC,IAAI,CAAC,GAAG,SAY7F,CAAA;AAED;;;;;;;;GAQG;AACH,eAAO,MAAM,YAAY,GACvB,OAAO,SAAS,CAAC,KAAK,GAAG,SAAS,EAClC,QAAQ,SAAS,CAAC,KAAK,GAAG,SAAS,KAClC,SAAS,CAAC,KAAK,GAAG,SASpB,CAAA;AAED;;;;;;;;;GASG;AACH,eAAO,MAAM,aAAa,GACxB,OAAO,UAAU,CAAC,eAAe,EACjC,SAAS,SAAS,CAAC,KAAK,GAAG,SAAS,KACnC,SAAS,CAAC,cASZ,CAAA"}

package/dist/cjs/internal/paidUsage.js

@@ -0,0 +1,70 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var paidUsage_exports = {};
+__export(paidUsage_exports, {
+  failedReading: () => failedReading,
+  paidTogether: () => paidTogether,
+  paidUsage: () => paidUsage
+});
+module.exports = __toCommonJS(paidUsage_exports);
+var Evaluator = __toESM(require("@smthrs/model/Evaluator"), 1);
+const paidUsage = (readings) => {
+  const shares = /* @__PURE__ */ new Map();
+  for (const reading of readings) {
+    if (reading === void 0) continue;
+    const share = shares.get(reading.modelId);
+    shares.set(reading.modelId, {
+      inputTokens: (share?.inputTokens ?? 0) + reading.inputTokens,
+      outputTokens: (share?.outputTokens ?? 0) + reading.outputTokens
+    });
+  }
+  if (shares.size === 0) return void 0;
+  return [...shares].map(([modelId, usage]) => modelId === void 0 ? { usage } : { usage, modelId });
+};
+const paidTogether = (first, second) => {
+  if (first === void 0) return second;
+  if (second === void 0) return first;
+  const modelId = first.modelId === second.modelId ? first.modelId : void 0;
+  return {
+    inputTokens: first.inputTokens + second.inputTokens,
+    outputTokens: first.outputTokens + second.outputTokens,
+    ...modelId === void 0 ? {} : { modelId }
+  };
+};
+const failedReading = (error, earlier) => {
+  const usage = paidTogether(earlier, error.usage);
+  return new Evaluator.EvaluatorError({
+    code: error.code,
+    message: Evaluator.publicMessage(error),
+    ...error.resetAtEpochMillis === void 0 ? {} : { resetAtEpochMillis: error.resetAtEpochMillis },
+    ...error.status === void 0 ? {} : { status: error.status },
+    ...usage === void 0 ? {} : { usage }
+  });
+};
+//# sourceMappingURL=paidUsage.js.map

package/dist/cjs/internal/paidUsage.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../src/internal/paidUsage.ts"],
+  "sourcesContent": ["/**\n * The model usage a recorded boundary paid for, summed over its readings.\n *\n * @since 1.0.0-rc.1\n * @private\n */\n\nimport type * as Classifier from \"@smthrs/model/Classifier\"\nimport * as Evaluator from \"@smthrs/model/Evaluator\"\nimport type * as EngineLike from \"../EngineLike.ts\"\n\n/**\n * One reading's metered usage and the model that read it; absent when the\n * transport reported none.\n *\n * @since 1.0.0-rc.1\n * @private\n */\nexport type Metered =\n  | { readonly inputTokens: number; readonly outputTokens: number; readonly modelId?: string | undefined }\n  | undefined\n\n/**\n * Sums the readings that were metered, one share per model in the order each\n * model first read. `undefined` when none was: a reading the transport did not\n * meter is not a reading that cost zero.\n *\n * @since 1.0.0-rc.1\n * @private\n */\nexport const paidUsage = (readings: ReadonlyArray<Metered>): ReadonlyArray<EngineLike.Paid> | undefined => {\n  const shares = new Map<string | undefined, { inputTokens: number; outputTokens: number }>()\n  for (const reading of readings) {\n    if (reading === undefined) continue\n    const share = shares.get(reading.modelId)\n    shares.set(reading.modelId, {\n      inputTokens: (share?.inputTokens ?? 0) + reading.inputTokens,\n      outputTokens: (share?.outputTokens ?? 0) + reading.outputTokens\n    })\n  }\n  if (shares.size === 0) return undefined\n  return [...shares].map(([modelId, usage]) => modelId === undefined ? { usage } : { usage, modelId })\n}\n\n/**\n * What two readings of one completion paid together. Either may come back\n * unmetered; the completion costs what was metered. Both ask the same judge,\n * so the sum keeps its model id, and drops it only when a fallback answered\n * one.\n *\n * @since 1.0.0-rc.1\n * @private\n */\nexport const paidTogether = (\n  first: Evaluator.Usage | undefined,\n  second: Evaluator.Usage | undefined\n): Evaluator.Usage | undefined => {\n  if (first === undefined) return second\n  if (second === undefined) return first\n  const modelId = first.modelId === second.modelId ? first.modelId : undefined\n  return {\n    inputTokens: first.inputTokens + second.inputTokens,\n    outputTokens: first.outputTokens + second.outputTokens,\n    ...(modelId === undefined ? {} : { modelId })\n  }\n}\n\n/**\n * A reading that failed, as the typed cause its turn fails with: the\n * transport's code and structured facts, its public message (a transport's\n * own text can name hosts and URLs), and what it paid with what the\n * `earlier` readings of the same completion paid, so the run's budget\n * charges both (#3010).\n *\n * @since 1.0.0-rc.1\n * @private\n */\nexport const failedReading = (\n  error: Classifier.ClassifierError,\n  earlier: Evaluator.Usage | undefined\n): Evaluator.EvaluatorError => {\n  const usage = paidTogether(earlier, error.usage)\n  return new Evaluator.EvaluatorError({\n    code: error.code,\n    message: Evaluator.publicMessage(error),\n    ...(error.resetAtEpochMillis === undefined ? {} : { resetAtEpochMillis: error.resetAtEpochMillis }),\n    ...(error.status === undefined ? {} : { status: error.status }),\n    ...(usage === undefined ? {} : { usage })\n  })\n}\n"],
+  "mappings": ";;;;;;;;;;;;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAQA,gBAA2B;AAsBpB,MAAM,YAAY,CAAC,aAAiF;AACzG,QAAM,SAAS,oBAAI,IAAuE;AAC1F,aAAW,WAAW,UAAU;AAC9B,QAAI,YAAY,OAAW;AAC3B,UAAM,QAAQ,OAAO,IAAI,QAAQ,OAAO;AACxC,WAAO,IAAI,QAAQ,SAAS;AAAA,MAC1B,cAAc,OAAO,eAAe,KAAK,QAAQ;AAAA,MACjD,eAAe,OAAO,gBAAgB,KAAK,QAAQ;AAAA,IACrD,CAAC;AAAA,EACH;AACA,MAAI,OAAO,SAAS,EAAG,QAAO;AAC9B,SAAO,CAAC,GAAG,MAAM,EAAE,IAAI,CAAC,CAAC,SAAS,KAAK,MAAM,YAAY,SAAY,EAAE,MAAM,IAAI,EAAE,OAAO,QAAQ,CAAC;AACrG;AAWO,MAAM,eAAe,CAC1B,OACA,WACgC;AAChC,MAAI,UAAU,OAAW,QAAO;AAChC,MAAI,WAAW,OAAW,QAAO;AACjC,QAAM,UAAU,MAAM,YAAY,OAAO,UAAU,MAAM,UAAU;AACnE,SAAO;AAAA,IACL,aAAa,MAAM,cAAc,OAAO;AAAA,IACxC,cAAc,MAAM,eAAe,OAAO;AAAA,IAC1C,GAAI,YAAY,SAAY,CAAC,IAAI,EAAE,QAAQ;AAAA,EAC7C;AACF;AAYO,MAAM,gBAAgB,CAC3B,OACA,YAC6B;AAC7B,QAAM,QAAQ,aAAa,SAAS,MAAM,KAAK;AAC/C,SAAO,IAAI,UAAU,eAAe;AAAA,IAClC,MAAM,MAAM;AAAA,IACZ,SAAS,UAAU,cAAc,KAAK;AAAA,IACtC,GAAI,MAAM,uBAAuB,SAAY,CAAC,IAAI,EAAE,oBAAoB,MAAM,mBAAmB;AAAA,IACjG,GAAI,MAAM,WAAW,SAAY,CAAC,IAAI,EAAE,QAAQ,MAAM,OAAO;AAAA,IAC7D,GAAI,UAAU,SAAY,CAAC,IAAI,EAAE,MAAM;AAAA,EACzC,CAAC;AACH;",
+  "names": []
+}

package/dist/cjs/internal/printChannel.d.ts

@@ -0,0 +1,233 @@
+/**
+ * The print channel: how a REPL frame's `console.log` calls become the bytes
+ * its successor reads.
+ *
+ * Two jobs live here, and both were priced off the `rerun-r95repl` lane rather
+ * than chosen.
+ *
+ * Every number here is a count of UTF-8 bytes, which is what the frame bound
+ * and the retention ceiling both mean by "bytes": the notices this module writes
+ * carry a `…`, three bytes wide and one UTF-16 unit, and counting them in units
+ * put a frame one byte over its own ceiling.
+ *
+ * **Sharing the frame budget.** Statements used to cap independently at 4 KiB
+ * each, head-first, under a 16 KiB frame bound that almost nobody reached: 197
+ * of the lane's 357 printing frames had a statement cut, 191 of those while the
+ * frame bound sat mostly unspent, and 3.06 MB went to per-statement caps against
+ * 6 frames that ever reached the frame one. Head-first is the part that cost
+ * verdicts — `sympy__sympy-13878` fused one `console.log` of 38,928 bytes whose
+ * head was a Python deprecation banner, so what it lost was the tail: the result
+ * of a three-minute test suite the same frame had just paid for, and the `git
+ * diff` that would have shown it the edit was already in the tree. It re-ran
+ * that suite four frames later. So the statements of a frame share one budget,
+ * each is elided from the middle, and no ceiling moves: 16 KiB was the most a
+ * frame could deliver before and it is the most now.
+ *
+ * **Compacting a printed structure.** A result printed whole is mostly repeated
+ * keys — a grep hit names `file`, `line`, `text` once per match — so an array of
+ * matches renders as file groups with numbered hits and context; other records
+ * render as a table with the union of keys named once. It is keyed on the shape
+ * and nothing else — this module knows no flow. Repeated keys save bytes;
+ * sparse records with mostly distinct keys can cost more as a table.
+ *
+ * @since 0.1.0
+ * @private
+ * @slop
+ */
+import type { Schema } from "effect";
+/**
+ * How many UTF-8 bytes of one frame's whole print buffer reach the next model turn.
+ *
+ * This is the only ceiling on the channel. A frame's statements *share* it:
+ * each is middle-elided to the share it is apportioned, and a statement short
+ * of its share hands the remainder back to the statements that are over theirs.
+ *
+ * They used to cap independently at 4 KiB each, head-first, and the r95repl
+ * lane priced that: 197 of its 357 printing frames had a statement cut, 191 of
+ * them while this frame budget sat mostly unspent, and 3.06 MB went to
+ * per-statement caps against 6 frames that ever reached this one. The
+ * `sympy__sympy-13878` run fused one `console.log` of 38,928 bytes; it was
+ * shown the first 4,096 and lost the tail, which held the result of a
+ * three-minute test suite the frame had already paid for. It ran that suite
+ * again four frames later. Sharing the budget shows that frame 16 KiB from both
+ * ends instead of 4 KiB from the head, and moves no ceiling: 16 KiB was the
+ * most a frame could ever deliver before, and it is the most now.
+ *
+ * Every elision is from the middle with the dropped byte count stated, because
+ * the head and the tail of a log are where it identifies itself, and the notices
+ * are reserved out of this budget before any of it is apportioned — so the
+ * assembled buffer is bounded outright and nothing has to shorten it a second
+ * time. Sized against the `recall` budget it replaces, and delivered once rather
+ * than re-rendered every frame.
+ *
+ * @category constants
+ * @since 0.1.0
+ */
+export declare const printFrameBytes: number;
+/**
+ * The smallest UTF-8-byte share of {@link printFrameBytes} one print statement is given.
+ *
+ * A share below this is all notice and no value — a middle elision of 80 bytes
+ * says less than the sentence explaining it — so a frame that printed more
+ * statements than the budget can floor drops whole statements from the middle
+ * and states how many, rather than cutting every one of them to nothing. That
+ * is the same shape the frame bound already had, applied a statement at a time
+ * so nothing is cut mid-line.
+ *
+ * It bounds how many statements are *kept*, but it is not a division of the
+ * budget: how many a frame can carry is priced off the statements it actually
+ * printed, so a statement at or under this size is shown whole and costs only
+ * itself. Two hundred eight-byte lines cost eighteen hundred bytes and all two
+ * hundred survive; sixty statements of four times this size do not, and whole
+ * ones go from the middle rather than every one of them being cut to a notice.
+ *
+ * @category constants
+ * @since 0.1.0
+ * @slop
+ */
+export declare const printStatementFloor = 512;
+/**
+ * How many UTF-8 bytes of one frame's print buffer the host keeps while the cell still runs.
+ *
+ * {@link printFrameBytes} bounds what the model is shown; this bounds what the
+ * host holds to show it from, and the two are different numbers because they
+ * answer different questions. A cell printing in a loop hands the host one
+ * payload per statement, and every payload is copied out of the sandbox's heap
+ * and decoded before anything can judge it surplus, so the frame budget alone
+ * bounds the answer while leaving the work unbounded. Sixteen times the frame
+ * budget is far past any honest use and still a fixed ceiling: past it the
+ * payload is not read at all, and the count of what went unread is stated in the
+ * buffer rather than dropped in silence.
+ *
+ * A statement is held at no more than {@link printFrameBytes} — the two ends of
+ * it, with the size it had — because a whole frame's budget is the most any one
+ * statement could ever be shown. So this ceiling holds at least sixteen
+ * statements whatever a cell prints, and a cell that prints many small values
+ * reaches it only after hundreds of them.
+ *
+ * @category constants
+ * @since 0.1.0
+ */
+export declare const printRetainedBytes: number;
+/**
+ * The fewest records an array needs before it is rendered as a table.
+ *
+ * Two rows do not repay a header line, and one row is not a table at all.
+ *
+ * @since 0.1.0
+ * @private
+ * @slop
+ */
+export declare const tableRows = 3;
+/**
+ * What the model is told when a print was cut: the value is still bound.
+ *
+ * @since 0.1.0
+ * @private
+ * @slop
+ */
+export declare const recall = "print a narrower slice of this value; it is still bound in the realm";
+/**
+ * One `console.log` call, as the host kept it.
+ *
+ * @since 0.1.0
+ * @private
+ * @slop
+ */
+export interface Statement {
+    /** The head and tail the host kept, in order and possibly the whole thing. */
+    readonly text: string;
+    /** What the statement rendered to before anything was dropped. */
+    readonly bytes: number;
+}
+/**
+ * Renders an array of records as a table, or nothing.
+ *
+ * Columns are the union of keys in first-seen order. An absent member is an
+ * empty cell; explicit null, empty arrays and empty objects stay `null`, `[]`
+ * and `{}`. Cells are the string itself where that is unambiguous — no newline,
+ * no column separator — and canonical JSON everywhere else. An empty string
+ * still looks absent, and a string spelling a JSON literal still looks like
+ * that value: this is a log rather than a wire format, so it is not paid for in
+ * quoting every cell.
+ *
+ * @since 0.1.0
+ * @private
+ * @slop
+ */
+export declare const table: (value: Schema.Json) => string | undefined;
+/**
+ * Renders one printed JSON value compactly.
+ *
+ * A match list becomes numbered source lines; other records become a table.
+ * An object with exactly one such member becomes that object's other members
+ * as JSON, then the member's name, count and rendered list. An exact failed-call
+ * envelope becomes its code, message and optional hint. Everything else is
+ * canonical JSON as before.
+ *
+ * Tables save repeated keys but pay for every column boundary, including
+ * absent members. The three-row, two-column floor saves bytes for uniform
+ * records; it does not guarantee savings for sparse records. Rendering stays
+ * shape-based rather than comparing both encodings.
+ *
+ * @since 0.1.0
+ * @private
+ * @slop
+ */
+export declare const render: (value: Schema.Json) => string;
+/**
+ * Apportions one budget across statements of the given sizes.
+ *
+ * Short statements take what they need and hand the remainder back, so a frame
+ * that printed one long value and three short ones spends the budget on the long
+ * one. Allocation runs shortest first, which is what makes the hand-back
+ * possible, and the result is in the order the sizes were given.
+ *
+ * @since 0.1.0
+ * @private
+ * @slop
+ */
+export declare const shares: (sizes: ReadonlyArray<number>, budget: number) => ReadonlyArray<number>;
+/**
+ * How many of *these* statements a budget can keep at the floor, head first.
+ *
+ * A count of the statements in hand rather than a constant, because what a
+ * statement costs is what it is. Taken as `printFrameBytes / printStatementFloor`
+ * it was 32 whatever a frame printed, so a frame of two hundred eight-byte lines
+ * dropped a hundred and sixty-eight of them while fifteen of its sixteen
+ * kilobytes went unspent — the failure the shared budget exists to end,
+ * reintroduced one level up. Two hundred lines that cost nine bytes each cost
+ * eighteen hundred, and the budget keeps every one of them.
+ *
+ * The walk takes the head, then the tail, then the head again, which is the
+ * order {@link buffer} assembles them in, so a budget that affords an odd number
+ * spends the odd one on the earlier statement.
+ *
+ * @since 0.1.0
+ * @private
+ * @slop
+ */
+export declare const capacity: (statements: ReadonlyArray<Statement>, budget: number) => number;
+/**
+ * Assembles what a frame printed, bounded by {@link printFrameBytes}.
+ *
+ * `unread` is the count of statements the host stopped copying out of the realm
+ * because the frame had already handed over more than it holds. It is stated
+ * rather than dropped, because a buffer that simply stopped reads as a cell that
+ * simply stopped printing.
+ *
+ * The bound holds by construction rather than by a second pass over the result,
+ * because a second pass would cut a notice in half and that is the one thing a
+ * bound may not do. {@link capacity} charges every kept statement the floor it is
+ * promised, the notice it would print and its newline; what survives that walk is
+ * therefore affordable, and the apportionment below spends only what the walk
+ * left. A statement at or under the floor is shown whole and reserves no notice
+ * at all — reserving one apiece is what left a frame of short lines nothing to
+ * spend on the lines themselves.
+ *
+ * @since 0.1.0
+ * @private
+ * @slop
+ */
+export declare const buffer: (statements: ReadonlyArray<Statement>, unread: number) => string;
+//# sourceMappingURL=printChannel.d.ts.map

package/dist/cjs/internal/printChannel.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"printChannel.d.ts","sourceRoot":"","sources":["../../../src/internal/printChannel.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAmCG;AAIH,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,QAAQ,CAAA;AAIpC;;;;;;;;;;;;;;;;;;;;;;;;;;;GA2BG;AACH,eAAO,MAAM,eAAe,QAAY,CAAA;AAExC;;;;;;;;;;;;;;;;;;;;GAoBG;AACH,eAAO,MAAM,mBAAmB,MAAM,CAAA;AAEtC;;;;;;;;;;;;;;;;;;;;;GAqBG;AACH,eAAO,MAAM,kBAAkB,QAAa,CAAA;AAE5C;;;;;;;;GAQG;AACH,eAAO,MAAM,SAAS,IAAI,CAAA;AAE1B;;;;;;GAMG;AACH,eAAO,MAAM,MAAM,yEAAyE,CAAA;AAE5F;;;;;;GAMG;AACH,MAAM,WAAW,SAAS;IACxB,8EAA8E;IAC9E,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAA;IACrB,kEAAkE;IAClE,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAA;CACvB;AAiED;;;;;;;;;;;;;;GAcG;AACH,eAAO,MAAM,KAAK,GAAI,OAAO,MAAM,CAAC,IAAI,KAAG,MAAM,GAAG,SASnD,CAAA;AAED;;;;;;;;;;;;;;;;;GAiBG;AACH,eAAO,MAAM,MAAM,GAAI,OAAO,MAAM,CAAC,IAAI,KAAG,MA4B3C,CAAA;AAED;;;;;;;;;;;GAWG;AACH,eAAO,MAAM,MAAM,GAAI,OAAO,aAAa,CAAC,MAAM,CAAC,EAAE,QAAQ,MAAM,KAAG,aAAa,CAAC,MAAM,CAezF,CAAA;AAsBD;;;;;;;;;;;;;;;;;;GAkBG;AACH,eAAO,MAAM,QAAQ,GAAI,YAAY,aAAa,CAAC,SAAS,CAAC,EAAE,QAAQ,MAAM,KAAG,MAW/E,CAAA;AAED;;;;;;;;;;;;;;;;;;;;GAoBG;AACH,eAAO,MAAM,MAAM,GAAI,YAAY,aAAa,CAAC,SAAS,CAAC,EAAE,QAAQ,MAAM,KAAG,MAwC7E,CAAA"}