@tangle-network/agent-runtime 7.0.0 → 8.0.0

package/dist/util-C_cdPNC4.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"util-C_cdPNC4.js","names":[],"sources":["../src/runtime/supervise/deadline.ts","../src/runtime/supervise/resources.ts","../src/runtime/util.ts"],"sourcesContent":["import { ValidationError } from '../../errors'\nimport type { Executor } from './types'\n\n// Node clamps larger delays to 1 ms instead of waiting, so long budgets must be armed in chunks.\nconst MAX_TIMER_DELAY_MS = 2_147_483_647\n\nexport const DEFAULT_SUCCESSFUL_SHUTDOWN_MS = 5_000\n\n/** The abort reason a child's own deadline carries. */\nexport const CHILD_DEADLINE_REASON = 'child deadline exceeded'\n/** The abort reason the root's budget deadline cascades to every node. */\nexport const ROOT_DEADLINE_REASON = 'root budget deadline exceeded'\n\n/**\n * What a steerable child's own time box does: a check-in, not a kill. At the child's deadline its\n * lead's scope delivers `DEADLINE_CHECK_IN_MESSAGE` to the child's inbox and keeps it\n * running; the child is stopped (reason `child deadline exceeded`) only once it then makes no\n * progress for `idleMs`. The run's own deadline, the budgets and cancellation still stop it at once.\n * `false` restores the hard kill at the time box. A child that exposes no inbox cannot be told,\n * so it is stopped at its time box as before.\n *\n * Four of 42 directors\n * were killed at the 90-minute boxes their root set, three of them mid-turn, losing 27, 6 and 91\n * minutes since their last recorded page, and each successor spent 12 to 19 minutes re-reading\n * before its first page.\n */\nexport type DeadlineCheckIn = false | { readonly idleMs?: number }\n\n/** How long a checked-in child may go without progress before it is stopped: 30 min. */\nexport const DEFAULT_CHECK_IN_IDLE_MS = 30 * 60_000\n\n/** The check-in a child receives at its own time box. */\nexport const DEADLINE_CHECK_IN_MESSAGE =\n  'Check-in: your time box has ended. This is not a stop. Finish the step you are on and start ' +\n  'nothing new. Record your current state and every result you have not recorded yet, then call ' +\n  'submit_result with what you have now; if the work is not done, mark it incomplete and name ' +\n  'what remains. Your lead decides whether to continue you or hand the work on. You keep running ' +\n  'while you make progress.'\n\n/** The idle bound a check-in policy sets, or undefined when time boxes are hard kills. */\nexport function checkInIdleMs(policy: DeadlineCheckIn | undefined): number | undefined {\n  if (policy === false) return undefined\n  const idleMs = policy?.idleMs ?? DEFAULT_CHECK_IN_IDLE_MS\n  if (!Number.isSafeInteger(idleMs) || idleMs <= 0) {\n    throw new ValidationError(\n      'deadlineCheckIn.idleMs must be a positive safe integer of milliseconds',\n    )\n  }\n  return idleMs\n}\n\n/** How long a manager whose result was accepted has to end the turn that submitted it before an\n *  abort, or Runtime's cancel of its retained run, stops its harness: the turn's end meters its\n *  usage and commits its result; its workspace capture runs after, in the manager's owner. */\nexport const ACCEPTED_RESULT_GRACE_MS = 5 * 60_000\n\n/** Whether an abort reason is a deadline: the child's own or the root budget's. */\nexport function isDeadlineAbortReason(reason: unknown): boolean {\n  return reason === CHILD_DEADLINE_REASON || reason === ROOT_DEADLINE_REASON\n}\nconst TEARDOWN_ACKNOWLEDGEMENT_MS = 250\n\n/** Arm a finite wall-clock deadline in safe chunks. Resource deadlines unref by default;\n * a standalone wait opts into keeping the process alive until it settles or is cancelled. */\nexport function armDeadlineTimer(\n  delayMs: number,\n  onDeadline: () => void,\n  keepAlive = false,\n): () => void {\n  const deadlineAtMs = Date.now() + Math.max(0, delayMs)\n  if (!Number.isFinite(delayMs) || !Number.isSafeInteger(Math.ceil(deadlineAtMs))) {\n    throw new ValidationError('timer delay must produce a finite safe deadline')\n  }\n  let cleared = false\n  let timer: ReturnType<typeof setTimeout> | undefined\n\n  const arm = (): void => {\n    if (cleared) return\n    const remainingMs = Math.max(0, deadlineAtMs - Date.now())\n    timer = setTimeout(\n      () => {\n        if (cleared) return\n        if (Date.now() >= deadlineAtMs) onDeadline()\n        else arm()\n      },\n      Math.min(remainingMs, MAX_TIMER_DELAY_MS),\n    )\n    if (!keepAlive && typeof timer.unref === 'function') timer.unref()\n  }\n\n  arm()\n  return () => {\n    cleared = true\n    if (timer !== undefined) clearTimeout(timer)\n  }\n}\n\n/**\n * Resolve a spawned child's duration into one absolute cutoff. An omitted child deadline inherits\n * the parent cutoff; an explicit child duration may shorten, but never extend, that cutoff.\n */\nexport function boundedChildDeadlineAt(\n  parentDeadlineAtMs: number,\n  childDeadlineMs: number | undefined,\n  nowMs: number,\n): number | undefined {\n  const parent = parentDeadlineAtMs > 0 ? parentDeadlineAtMs : undefined\n  const child = childDeadlineMs === undefined ? undefined : nowMs + childDeadlineMs\n  if (parent === undefined) return child\n  if (child === undefined) return parent\n  return Math.min(parent, child)\n}\n\n/** One answer from `Executor.teardown`. */\nexport type TeardownAnswer = Awaited<ReturnType<Executor<unknown>['teardown']>>\n\n/** Invoke teardown once and bound how long the runtime waits for its acknowledgement. A hard\n * execution deadline always wins; without one, numeric grace gets a short acknowledgement\n * allowance and a brutal kill gets only that allowance. Explicit `infinity` remains unbounded\n * only when no execution deadline exists. The losing promise stays observed. `ask` issues the\n * request; a scope passes its per-child single-flight asker (see `singleFlightTeardown`). */\nexport async function teardownExecutor<Out>(\n  executor: Executor<Out>,\n  grace: number | 'brutalKill' | 'infinity',\n  deadlineAtMs: number | undefined,\n  now: () => number,\n  ask: (grace: number | 'brutalKill' | 'infinity') => Promise<TeardownAnswer> = (requested) =>\n    Promise.resolve(executor.teardown(requested)),\n): Promise<void> {\n  const work = Promise.resolve(ask(grace))\n\n  const requestedWaitMs =\n    grace === 'infinity'\n      ? undefined\n      : grace === 'brutalKill'\n        ? (executor.teardownTimeoutMs ?? TEARDOWN_ACKNOWLEDGEMENT_MS)\n        : grace + TEARDOWN_ACKNOWLEDGEMENT_MS\n  // The execution cutoff stops new work; cleanup still gets a small, bounded acknowledgement\n  // window after that cutoff. Otherwise an already-resolved brutal kill invoked exactly at the\n  // deadline would be mislabeled as a cleanup failure without receiving one microtask.\n  const deadlineWaitMs =\n    deadlineAtMs === undefined\n      ? undefined\n      : Math.max(0, deadlineAtMs - now()) + TEARDOWN_ACKNOWLEDGEMENT_MS\n  const waitMs =\n    requestedWaitMs === undefined\n      ? deadlineWaitMs\n      : deadlineWaitMs === undefined\n        ? requestedWaitMs\n        : Math.min(requestedWaitMs, deadlineWaitMs)\n\n  let receipt: TeardownAnswer\n  if (waitMs === undefined) {\n    receipt = await work\n  } else if (waitMs <= 0) {\n    void work.catch(() => undefined)\n    throw new ValidationError('executor teardown did not acknowledge before its deadline')\n  } else {\n    let clearTimer: (() => void) | undefined\n    const timedOut = new Promise<never>((_resolve, reject) => {\n      clearTimer = armDeadlineTimer(\n        waitMs,\n        () =>\n          reject(new ValidationError(`executor teardown did not acknowledge within ${waitMs}ms`)),\n        true,\n      )\n    })\n    try {\n      receipt = await Promise.race([work, timedOut])\n    } finally {\n      clearTimer?.()\n    }\n  }\n\n  if (!receipt.destroyed) {\n    throw new ValidationError(\n      `executor teardown reported destroyed=false${receipt.detail ? `: ${receipt.detail}` : ''}`,\n    )\n  }\n}\n\n/**\n * The optional teardown surfaces a wrapping executor forwards, so wrapping never changes how a\n * child is released: the acknowledgement window a remote teardown needs, the release of a\n * retained execution at root settlement, and the environments an unconfirmed teardown names for\n * a sweeper. A wrapper that dropped `releaseRetained` left every retained child it wrapped\n * running after settlement. Each surface is present only when the inner executor implements it.\n */\nexport function teardownSurfaces(\n  inner: Executor<unknown>,\n): Pick<\n  Executor<unknown>,\n  'teardownTimeoutMs' | 'releaseRetained' | 'heldEnvironments' | 'heldForContinuation'\n> {\n  return {\n    ...(inner.teardownTimeoutMs === undefined\n      ? {}\n      : { teardownTimeoutMs: inner.teardownTimeoutMs }),\n    ...(inner.releaseRetained === undefined\n      ? {}\n      : { releaseRetained: (signal: AbortSignal) => inner.releaseRetained!(signal) }),\n    ...(inner.heldEnvironments === undefined\n      ? {}\n      : { heldEnvironments: () => inner.heldEnvironments!() }),\n    ...(inner.heldForContinuation === undefined\n      ? {}\n      : { heldForContinuation: () => inner.heldForContinuation!() }),\n  }\n}\n\n/**\n * An asker that sends an executor at most one teardown at a time. While a request is still\n * running, every later ask returns that same request instead of sending another beside it.\n *\n * A settlement's own teardown has a short acknowledgement window, and a request that misses it\n * keeps running. Without this, the first settlement retry sent a second teardown next to the\n * first. An executor that does not deduplicate internally, such as one that re-issues its\n * cancels, then ran two teardowns at once. `onRequest` runs once for each request actually sent.\n */\nexport function singleFlightTeardown<Out>(\n  executor: Executor<Out>,\n  onRequest: () => void,\n): (grace: number | 'brutalKill' | 'infinity') => Promise<TeardownAnswer> {\n  let inFlight: Promise<TeardownAnswer> | undefined\n  return (grace) => {\n    if (inFlight !== undefined) return inFlight\n    onRequest()\n    let request: Promise<TeardownAnswer>\n    try {\n      request = Promise.resolve(executor.teardown(grace))\n    } catch (error) {\n      request = Promise.reject(error)\n    }\n    inFlight = request\n    const settle = (): void => {\n      if (inFlight === request) inFlight = undefined\n    }\n    request.then(settle, settle)\n    return request\n  }\n}\n","import type { Budget, ResourceSpend, Spend } from './types'\n\n/** Validate caller-owned names and units without assigning domain meaning to them. */\nexport function assertResources(\n  resources: Budget['resources'] | Spend['resources'],\n  kind: 'limit' | 'amount',\n  label: string,\n): void {\n  if (resources === undefined) return\n  if (resources === null || typeof resources !== 'object' || Array.isArray(resources)) {\n    throw new Error(`${label} must be a resource map`)\n  }\n  for (const [name, resource] of Object.entries(resources)) {\n    if (\n      !name.trim() ||\n      !resource ||\n      typeof resource !== 'object' ||\n      typeof resource.unit !== 'string' ||\n      !resource.unit.trim()\n    ) {\n      throw new Error(`${label}: resource names and units must be non-empty strings`)\n    }\n    const value =\n      kind === 'limit'\n        ? 'limit' in resource\n          ? resource.limit\n          : undefined\n        : 'amount' in resource\n          ? resource.amount\n          : undefined\n    if (typeof value !== 'number' || !Number.isSafeInteger(value) || value < 0) {\n      throw new Error(`${label}.${name}.${kind} must be a non-negative safe integer`)\n    }\n    if (kind === 'amount' && (!('known' in resource) || typeof resource.known !== 'boolean')) {\n      throw new Error(`${label}.${name}.known must be a boolean`)\n    }\n  }\n}\n\n/** Missing contributors are not usage claims; enforced omissions are marked before aggregation.\n * Overflow retains a safe lower bound and marks it unknown, preserving readable component receipts. */\nexport function addResourceSpend(...maps: ReadonlyArray<Spend['resources']>): {\n  resources?: Record<string, ResourceSpend>\n} {\n  const totals = new Map<string, ResourceSpend>()\n  for (const resources of maps) {\n    assertResources(resources, 'amount', 'resource spend')\n    for (const [name, resource] of Object.entries(resources ?? {})) {\n      const prior = totals.get(name)\n      if (prior && prior.unit !== resource.unit) throw new Error(`resource ${name}: unit mismatch`)\n      const amount = (prior?.amount ?? 0) + resource.amount\n      totals.set(name, {\n        unit: resource.unit,\n        amount: Math.min(amount, Number.MAX_SAFE_INTEGER),\n        known: (prior?.known ?? true) && resource.known && Number.isSafeInteger(amount),\n      })\n    }\n  }\n  return totals.size ? { resources: Object.fromEntries(totals) } : {}\n}\n\n/** A terminal omission under an enforced ceiling is unknown, never measured zero. */\nexport function withBudgetResources(\n  spend: Spend,\n  budget: Pick<Budget, 'resources'>,\n  notStarted = false,\n): Spend {\n  const resources = new Map(Object.entries(addResourceSpend(spend.resources).resources ?? {}))\n  for (const [name, limit] of Object.entries(budget.resources ?? {})) {\n    const observed = resources.get(name)\n    if (observed && observed.unit !== limit.unit) throw new Error(`resource ${name}: unit mismatch`)\n    if (!observed) resources.set(name, { unit: limit.unit, amount: 0, known: notStarted })\n  }\n  return resources.size ? { ...spend, resources: Object.fromEntries(resources) } : spend\n}\n\n/** Stream increments and a terminal total describe the same work; never sum them twice. */\nexport function resourceTelemetry(streamed: Spend, terminal: Spend): Pick<Spend, 'resources'> {\n  const resources = new Map(Object.entries(addResourceSpend(terminal.resources).resources ?? {}))\n  for (const [name, value] of Object.entries(streamed.resources ?? {})) {\n    const other = resources.get(name)\n    if (other && other.unit !== value.unit) throw new Error(`resource ${name}: unit mismatch`)\n    resources.set(name, {\n      ...value,\n      amount: Math.max(value.amount, other?.amount ?? 0),\n      known:\n        value.known &&\n        (other?.known ?? true) &&\n        (other === undefined || other.amount === value.amount),\n    })\n  }\n  return addResourceSpend(Object.fromEntries(resources))\n}\n","/**\n *\n * Internal loop-kernel utilities shared across the kernel, drivers, and the\n * sandbox-acquire layer. Not part of the public barrel surface.\n *\n * @experimental\n */\n\nimport type { SandboxInstance } from '@tangle-network/sandbox'\nimport { ValidationError } from '../errors'\nimport { armDeadlineTimer } from './supervise/deadline'\nimport { addResourceSpend } from './supervise/resources'\nimport type { Spend, TokenUsageProvenance } from './supervise/types'\nimport { runTaskQueue } from './task-queue'\nimport type { LoopTokenUsage } from './types'\n\n/**\n * Best-effort sandbox delete. Skips instances without a `delete` (test fakes);\n * swallows errors (the platform reaps on expiry). Returns `false` when delete\n * threw, `true` otherwise, so callers can surface a leak if they choose.\n */\nexport async function deleteBoxSafe(box: SandboxInstance | undefined): Promise<boolean> {\n  if (!box || typeof (box as { delete?: unknown }).delete !== 'function') return true\n  try {\n    await box.delete()\n    return true\n  } catch {\n    return false\n  }\n}\n\n/** Short base36 id for trace correlation. Not cryptographic, not collision-free. */\nexport function randomSuffix(len = 8): string {\n  return Math.random()\n    .toString(36)\n    .slice(2, 2 + len)\n}\n\n/** Collision-resistant id for sandbox naming (find-by-name recovery must be unique). */\nexport function randomUuid(): string {\n  return crypto.randomUUID()\n}\n\n/** Construct an AbortError carrying the abort reason's message. Downstream code pattern-matches on `err.name`. */\nexport function abortError(reason?: unknown): Error {\n  const err = new Error(\n    reason instanceof Error ? reason.message : reason === undefined ? 'aborted' : String(reason),\n  )\n  err.name = 'AbortError'\n  return err\n}\n\n/** Throw an AbortError. */\nexport function throwAbort(): never {\n  throw abortError()\n}\n\n/** Throw if the signal is already aborted; otherwise no-op. */\nexport function throwIfAborted(signal: AbortSignal | undefined): void {\n  if (signal?.aborted) throw abortError()\n}\n\n/** True for any error whose `name` is `AbortError` (the cross-kernel abort contract). */\nexport function isAbortError(err: unknown): boolean {\n  return err instanceof Error && err.name === 'AbortError'\n}\n\n/**\n * Sleep that resolves early on abort and always clears its timer so it never\n * keeps the event loop alive. Resolves (does not reject) on abort — callers\n * re-check the signal explicitly after the sleep.\n */\nexport function sleep(ms: number, signal?: AbortSignal, keepAlive = true): Promise<void> {\n  if (signal?.aborted) return Promise.resolve()\n  return new Promise((resolve) => {\n    const done = () => {\n      clearTimer()\n      signal?.removeEventListener('abort', done)\n      resolve()\n    }\n    const clearTimer = armDeadlineTimer(ms, done, keepAlive)\n    signal?.addEventListener('abort', done, { once: true })\n  })\n}\n\n/**\n * Race a promise against a timeout. Resolves with the value if it settles in\n * time, otherwise resolves with `undefined`. Always clears the timer.\n */\nexport function withTimeout<T>(promise: Promise<T>, ms: number): Promise<T | undefined> {\n  return new Promise<T | undefined>((resolve) => {\n    const clearTimer = armDeadlineTimer(ms, () => resolve(undefined), true)\n    promise.then(\n      (value) => {\n        clearTimer()\n        resolve(value)\n      },\n      () => {\n        clearTimer()\n        resolve(undefined)\n      },\n    )\n  })\n}\n\ninterface StringifyOptions {\n  /** Pretty-print with 2-space indent. Default false (compact). */\n  pretty?: boolean\n  /** Truncate to this many chars, appending `…`. Default unbounded. */\n  max?: number\n}\n\n/**\n * `JSON.stringify` with a `String()` fallback on throw (cyclic / non-JSON).\n * Strings pass through unstringified so a preview of a string output is the\n * string itself, not a quoted re-encoding.\n */\nexport function stringifySafe(value: unknown, opts: StringifyOptions = {}): string {\n  let s: string\n  try {\n    if (typeof value === 'string') {\n      s = value\n    } else {\n      const json = opts.pretty ? JSON.stringify(value, null, 2) : JSON.stringify(value)\n      s = json ?? String(value)\n    }\n  } catch {\n    s = String(value)\n  }\n  if (opts.max !== undefined && s.length > opts.max) return `${s.slice(0, opts.max)}…`\n  return s\n}\n\n/** A fresh zero token-usage accumulator. */\nexport function zeroTokenUsage(): LoopTokenUsage {\n  return { input: 0, output: 0 }\n}\n\n/**\n * Sum the catalog-priced part of a dollar total across spends, as a field to spread.\n *\n * Returns nothing when no input carried one. A fold of pure provider receipts must not gain a\n * `usdEstimated: 0`, which would read as \"this runtime checked and priced none\" on a path that\n * never prices at all.\n */\nfunction usdEstimatedOf(...spends: ReadonlyArray<{ usdEstimated?: number }>): {\n  usdEstimated?: number\n} {\n  let total = 0\n  let priced = false\n  for (const spend of spends) {\n    if (spend.usdEstimated === undefined) continue\n    priced = true\n    total += spend.usdEstimated\n  }\n  return priced ? { usdEstimated: total } : {}\n}\n\n/** A conserved spend with every channel at zero and no completeness claim on it. */\nexport function zeroSpend(): Spend {\n  return { iterations: 0, tokens: zeroTokenUsage(), usd: 0, ms: 0 }\n}\n\n/**\n * The spend of work that HAPPENED and reported no usage receipt.\n *\n * Not the same value as {@link zeroSpend} even though both carry `{0,0}` tokens and `$0`. A bare\n * zero asserts a MEASUREMENT — \"this ran and cost nothing\" — and every consumer downstream reads it\n * that way: the pool keeps reporting `readout().tokensKnown === true`, the journal totals stay\n * clean, the OTEL span records a priced zero, and a caller's token-denominated ceiling can never\n * fire no matter how much the work really burned. A ceiling that cannot fire is worse than no\n * ceiling, because it reads as protection.\n *\n * `tokensKnown` is the marker the substrate already threads end to end for exactly this case\n * (`budget.ts`, `otel-spans.ts`, `spawn-journal.ts`, `supervisor.ts`): the work is recorded, the\n * zero is labelled a floor rather than a total, and every rollup that touches it reports its\n * balance as a ceiling rather than a measurement. Use this — never a bare zero — whenever a runtime\n * cannot see what its worker spent.\n *\n * The same rule applies to dollars. A dollar-capped run must refuse an executor whose billed spend\n * is unknowable; `budgetExempt` does not authorize Runtime to relabel unknown spend as a measured\n * zero. Callers that require dollar accounting must use a backend with a trusted billing receipt.\n */\nexport function unmeteredSpend(ms: number): Spend {\n  return {\n    iterations: 0,\n    tokens: zeroTokenUsage(),\n    tokensKnown: false,\n    usd: 0,\n    usdKnown: false,\n    ms,\n  }\n}\n\n/** Copy a conserved spend without dropping a completeness marker or the catalog-priced part. */\nexport function cloneSpend(spend: Spend): Spend {\n  return {\n    ...addResourceSpend(spend.resources),\n    iterations: spend.iterations,\n    tokens: cloneTokenUsage(spend.tokens),\n    ...(spend.tokensKnown === false ? { tokensKnown: false } : {}),\n    usd: spend.usd,\n    ...(spend.usdKnown === false ? { usdKnown: false } : {}),\n    ...(spend.usdEstimated !== undefined ? { usdEstimated: spend.usdEstimated } : {}),\n    ms: spend.ms,\n    ...boxMinutesOf(spend),\n    ...(spend.tokensProvenance === undefined ? {} : { tokensProvenance: spend.tokensProvenance }),\n  }\n}\n\n/**\n * Sum two conserved spends per channel. Tokens and dollars never fold into each other, an\n * incomplete input keeps the sum incomplete on that channel, and the catalog-priced part of the\n * dollar total is summed separately so `usd - usdEstimated` still names what a provider billed.\n */\nexport function addSpend(a: Spend, b: Spend): Spend {\n  const tokens = cloneTokenUsage(a.tokens)\n  addTokenUsage(tokens, b.tokens)\n  return {\n    ...addResourceSpend(a.resources, b.resources),\n    iterations: a.iterations + b.iterations,\n    tokens,\n    ...(a.tokensKnown === false || b.tokensKnown === false ? { tokensKnown: false } : {}),\n    usd: a.usd + b.usd,\n    ...(a.usdKnown === false || b.usdKnown === false ? { usdKnown: false } : {}),\n    ...usdEstimatedOf(a, b),\n    ms: a.ms + b.ms,\n    ...boxMinutesOf(a, b),\n    ...tokensProvenanceOf(a, b),\n  }\n}\n\n/**\n * Fold the token-provenance channel across spends, as a field to spread.\n *\n * Returns nothing when no contributor stated one, because ABSENT already means \"the executor's own\n * live stream\", which is what every path reported before a harness store was readable. A\n * contributor that stated one and a contributor that did not therefore disagree, and the sum is\n * `'mixed'` — the honest answer for a tree whose spend came from two kinds of receipt.\n */\nfunction tokensProvenanceOf(...spends: ReadonlyArray<Spend>): {\n  tokensProvenance?: TokenUsageProvenance\n} {\n  let folded: TokenUsageProvenance | undefined\n  let sawStated = false\n  for (const spend of spends) {\n    const stated = spend.tokensProvenance ?? 'stream-receipt'\n    if (spend.tokensProvenance !== undefined) sawStated = true\n    folded = folded === undefined || folded === stated ? stated : 'mixed'\n  }\n  return !sawStated || folded === undefined || folded === 'stream-receipt'\n    ? {}\n    : { tokensProvenance: folded }\n}\n\n/**\n * Fold the platform box-time channel across spends, as a field to spread.\n *\n * Returns nothing when no input carried the channel, so a fold over router or cli-bridge work —\n * which runs no box at all — never gains a `boxMinutesProvenance: 'uncaptured'` that would claim\n * a box ran and went unmetered.\n *\n * Three rules, one per field:\n *  - `boxMinutes` sums the numbers that are present, and stays ABSENT when none is. A missing\n *    measurement never enters the sum as a zero.\n *  - `boxMinutesKnown` is sticky-false, like `tokensKnown`: one contributor that could not state\n *    its box time makes the whole sum a floor.\n *  - `boxMinutesProvenance` degrades. `'observed'` survives only when every contributor that\n *    carried a number was observed; one derived number makes the sum `'estimated'`; no number at\n *    all is `'uncaptured'`.\n */\nfunction boxMinutesOf(...spends: ReadonlyArray<Spend>): {\n  boxMinutes?: number\n  boxMinutesKnown?: boolean\n  boxMinutesProvenance?: 'observed' | 'estimated' | 'uncaptured'\n} {\n  const present = spends.filter((spend) => spend.boxMinutesProvenance !== undefined)\n  if (present.length === 0) return {}\n  let minutes = 0\n  let sawNumber = false\n  let known = true\n  let observedOnly = true\n  for (const spend of present) {\n    if (typeof spend.boxMinutes === 'number' && Number.isFinite(spend.boxMinutes)) {\n      minutes += spend.boxMinutes\n      sawNumber = true\n      if (spend.boxMinutesProvenance !== 'observed') observedOnly = false\n    }\n    if (spend.boxMinutesKnown !== true) known = false\n  }\n  return {\n    ...(sawNumber ? { boxMinutes: roundBoxMinutes(minutes) } : {}),\n    boxMinutesKnown: known,\n    boxMinutesProvenance: sawNumber ? (observedOnly ? 'observed' : 'estimated') : 'uncaptured',\n  }\n}\n\n/**\n * Box minutes at four decimals — a tenth of a second.\n *\n * Fine enough that a box alive for two seconds reports `0.0333` instead of a zero that would read\n * as a measured free box, and coarse enough that summing floats does not print\n * `1.5000000000000002`.\n */\nexport function roundBoxMinutes(minutes: number): number {\n  return Number(minutes.toFixed(4))\n}\n\n/** Copy a token subtotal without dropping optional provider cache telemetry. */\nexport function cloneTokenUsage(usage: LoopTokenUsage): LoopTokenUsage {\n  const cacheBreakdownUnknown =\n    usage.cacheBreakdownKnown === false || (usage.input > 0 && !hasClassifiedCacheBreakdown(usage))\n  return {\n    input: usage.input,\n    output: usage.output,\n    ...(usage.tokensKnown === false ? { tokensKnown: false as const } : {}),\n    ...(usage.freshInput !== undefined ? { freshInput: usage.freshInput } : {}),\n    ...(usage.cacheRead !== undefined ? { cacheRead: usage.cacheRead } : {}),\n    ...(usage.cacheWrite !== undefined ? { cacheWrite: usage.cacheWrite } : {}),\n    ...(cacheBreakdownUnknown ? { cacheBreakdownKnown: false as const } : {}),\n  }\n}\n\n/** True only when every positive prompt token has a consistent cache classification. */\nexport function hasCompleteCacheBreakdown(usage: LoopTokenUsage): boolean {\n  if (usage.cacheBreakdownKnown === false) return false\n  return hasClassifiedCacheBreakdown(usage)\n}\n\nfunction hasClassifiedCacheBreakdown(usage: LoopTokenUsage): boolean {\n  if (usage.input === 0) return true\n  if (\n    usage.freshInput === undefined ||\n    usage.cacheRead === undefined ||\n    usage.cacheWrite === undefined\n  ) {\n    return false\n  }\n  return usage.freshInput + usage.cacheRead + usage.cacheWrite === usage.input\n}\n\n/**\n * The token charge for one observation: every token counted ONCE, at the moment it first enters\n * the context — `input − cacheRead + output`.\n *\n * `input` is a rolled-up prompt total that re-counts a cached prefix on every turn that reads it,\n * so charging `input` makes a 100K prefix read 40 times cost 4.1M for content authored once. A\n * cache read is content that was already charged when it was written, so it is the one class the\n * charge subtracts. Under a complete split the result is exactly `freshInput + cacheWrite`. No\n * price weight is involved: this counts work, and money is a separate channel.\n *\n * The subtraction form is what makes the charge ADDITIVE. `input` and `cacheRead` both accumulate\n * through `addTokenUsage`, so the charge on an aggregate equals the sum of the charges on the\n * records that built it — including an aggregate that mixes classified and unclassified turns,\n * where the unclassified remainder is charged in full and only the reported cache reads are\n * credited. A form that read `freshInput + cacheWrite` directly loses that: one unclassified turn\n * would drop the whole aggregate to `input + output` and over-charge every classified turn with it.\n *\n * The one arithmetic guarantee: a set of classes that does not FIT inside the prompt total it\n * partitions credits nothing, so the charge is never below `output` and a class that overflows its\n * own total buys no tokens. It is not a guarantee against a provider that reports a cache read it\n * never served — that provider can under-report `input` just as easily, and the token channel is an\n * accounting unit, not a trust boundary. Prompt tokens the provider left unclassified are charged\n * in full, so a spend with no readable split charges an upper bound on newly-presented work rather\n * than a measurement, and every caller that enforces a ceiling must report the difference\n * (`BudgetPool` does it through `readout().cacheBreakdownKnown`).\n */\nexport function chargedTokens(usage: LoopTokenUsage): number {\n  return usage.input - creditedCacheRead(usage) + usage.output\n}\n\n/** `cacheRead` if the reported classes fit inside `input`, else nothing. */\nfunction creditedCacheRead(usage: LoopTokenUsage): number {\n  const { cacheRead } = usage\n  if (cacheRead === undefined) return 0\n  return classifiedTotal(usage, cacheRead) > usage.input ? 0 : cacheRead\n}\n\nfunction classifiedTotal(usage: Partial<LoopTokenUsage>, cacheRead: number): number {\n  return (usage.freshInput ?? 0) + cacheRead + (usage.cacheWrite ?? 0)\n}\n\n/**\n * The only two members this reads out of a provider prompt-cache report, named rather than taken as\n * an open record: both the typed `PromptCacheUsage` and the open `promptCache` an `llm_call` carries\n * satisfy it, and each value is validated before it is credited.\n */\ninterface PromptCacheCounters {\n  readonly readTokens?: unknown\n  readonly writeTokens?: unknown\n}\n\n/** The prompt-cache token classes of one observation, as `LoopTokenUsage` members. */\ntype PromptCacheTokenClasses = Pick<\n  LoopTokenUsage,\n  'freshInput' | 'cacheRead' | 'cacheWrite' | 'cacheBreakdownKnown'\n>\n\n/**\n * Translate one provider prompt-cache report into the prompt token classes `addTokenUsage` folds\n * and `chargedTokens` credits.\n *\n * The input is the open `promptCache` record an `llm_call` carries, keyed by the `PromptCacheUsage`\n * vocabulary (`readTokens`, `writeTokens`). Providers report that vocabulary unevenly, and the\n * three outcomes are different facts that must not collapse into one another:\n *\n *  - **Nothing reported** — no classes and no marker. The caller's own unknown handling decides,\n *    because a provider that says nothing about caching has not said the split is unknowable.\n *  - **Read and write both reported, and fitting inside `input`** — a complete partition, so\n *    `freshInput` is the remainder and the split is known.\n *  - **One counter reported, or classes that overflow `input`** — the counters that ARE measured\n *    pass through and `cacheBreakdownKnown` is false. A read with no write counter (OpenAI reports\n *    no write) still credits the read it measured, while declaring the rest unclassified so the\n *    charge stays a declared upper bound. An overflowing claim buys nothing: it cannot be a\n *    partition of a total it exceeds.\n *\n * A counter the provider did not report stays absent. A zero would claim the provider measured no\n * cache, which is a different fact from a provider that did not report.\n */\nexport function promptCacheTokenClasses(\n  input: number | undefined,\n  promptCache: PromptCacheCounters | undefined,\n): PromptCacheTokenClasses {\n  if (promptCache === undefined) return {}\n  const read = tokenCount(promptCache.readTokens)\n  const write = tokenCount(promptCache.writeTokens)\n  if (read === undefined && write === undefined) return {}\n  if (input === undefined || (read ?? 0) + (write ?? 0) > input) {\n    return { cacheBreakdownKnown: false }\n  }\n  if (read !== undefined && write !== undefined) {\n    return { freshInput: input - read - write, cacheRead: read, cacheWrite: write }\n  }\n  return {\n    ...(read !== undefined ? { cacheRead: read } : {}),\n    ...(write !== undefined ? { cacheWrite: write } : {}),\n    cacheBreakdownKnown: false,\n  }\n}\n\nfunction tokenCount(value: unknown): number | undefined {\n  return typeof value === 'number' && Number.isSafeInteger(value) && value >= 0 ? value : undefined\n}\n\n/**\n * Add the observed subtotal into `acc`; token and cache incompleteness are sticky.\n *\n * A delta whose classes do not FIT inside its own `input` contributes its prompt total and NO\n * classes. Folding them in would hide the overflow: the accumulator's larger `input` can absorb a\n * class total that overflowed the one delta that reported it, and `chargedTokens` would then credit\n * at the aggregate a cache read it refuses at the record. That is the one way the charge could come\n * out below the sum of the charges on the records that built it.\n */\nexport function addTokenUsage(acc: LoopTokenUsage, delta: Partial<LoopTokenUsage>): void {\n  acc.input += delta.input ?? 0\n  acc.output += delta.output ?? 0\n  if (delta.tokensKnown === false) acc.tokensKnown = false\n\n  const input = delta.input ?? 0\n  const fits = classifiedTotal(delta, delta.cacheRead ?? 0) <= input\n  if (fits) {\n    if (delta.freshInput !== undefined) acc.freshInput = (acc.freshInput ?? 0) + delta.freshInput\n    if (delta.cacheRead !== undefined) acc.cacheRead = (acc.cacheRead ?? 0) + delta.cacheRead\n    if (delta.cacheWrite !== undefined) acc.cacheWrite = (acc.cacheWrite ?? 0) + delta.cacheWrite\n  }\n\n  const classified =\n    fits &&\n    delta.freshInput !== undefined &&\n    delta.cacheRead !== undefined &&\n    delta.cacheWrite !== undefined &&\n    delta.freshInput + delta.cacheRead + delta.cacheWrite === input\n  // A provider that reports prompt input without all three classes leaves the\n  // split unknown. Do not let an earlier complete turn make the aggregate look\n  // complete after a later unclassified positive-input turn.\n  if (delta.cacheBreakdownKnown === false || (input > 0 && !classified)) {\n    acc.cacheBreakdownKnown = false\n  }\n}\n\n/**\n * Map `items` through `fn` with at most `limit` calls in flight at once,\n * preserving input order in the result. On the first `fn` rejection no NEW\n * items are picked up; already-in-flight calls are awaited, then the first\n * error is rethrown. `limit` is clamped to ≥ 1.\n *\n * Used where a burst of provisioning (e.g. forking N child boxes) must respect\n * the loop's concurrency bound instead of firing all N at once.\n */\nexport async function mapWithConcurrency<T, R>(\n  items: readonly T[],\n  limit: number,\n  fn: (item: T, index: number) => Promise<R>,\n): Promise<R[]> {\n  const results = new Array<R>(items.length)\n  let next = 0\n  for await (const settled of runTaskQueue({\n    concurrency: Math.max(1, Math.min(Math.floor(limit), items.length)),\n    take: () => {\n      const index = next++\n      return index < items.length ? { id: String(index), value: index } : undefined\n    },\n    execute: ({ value: index }) => fn(items[index] as T, index),\n  })) {\n    if (settled.status === 'rejected') throw settled.reason\n    results[settled.task.value] = settled.value\n  }\n  return results\n}\n\n/** The message of a thrown value: an `Error`'s own message, anything else stringified. */\nexport function errorMessage(error: unknown): string {\n  return error instanceof Error ? error.message : String(error)\n}\n\n/** True for an object whose `Symbol.asyncIterator` is callable, so `for await` can consume it. */\nexport function isAsyncIterable<T>(value: unknown): value is AsyncIterable<T> {\n  return (\n    value !== null &&\n    typeof value === 'object' &&\n    typeof (value as { [Symbol.asyncIterator]?: unknown })[Symbol.asyncIterator] === 'function'\n  )\n}\n\n/** 32-bit FNV-1a over a string's UTF-16 code units, as eight lowercase hex digits. */\nexport function fnv1a32Hex(text: string): string {\n  let h = 0x811c9dc5\n  for (let i = 0; i < text.length; i += 1) {\n    h ^= text.charCodeAt(i)\n    h = Math.imul(h, 0x01000193)\n  }\n  return (h >>> 0).toString(16).padStart(8, '0')\n}\n\n/** Parent journals may already contain an interrupted driver's inference prefix. */\nexport function unreportedSpend(total: Spend, prior: Spend): Spend {\n  const tokens = { ...total.tokens }\n  for (const key of ['input', 'output', 'freshInput', 'cacheRead', 'cacheWrite'] as const) {\n    const value = total.tokens[key]\n    if (value !== undefined) tokens[key] = Math.max(0, value - (prior.tokens[key] ?? 0))\n  }\n  return {\n    ...total,\n    ...addResourceSpend(\n      total.resources === undefined\n        ? undefined\n        : Object.fromEntries(\n            Object.entries(total.resources).map(([name, value]) => {\n              const previous = prior.resources?.[name]\n              if (previous && previous.unit !== value.unit)\n                throw new ValidationError(`resource ${name}: unit mismatch`)\n              return [\n                name,\n                {\n                  ...value,\n                  amount: Math.max(0, value.amount - (previous?.amount ?? 0)),\n                  known: value.known && (previous?.known ?? true),\n                },\n              ]\n            }),\n          ),\n    ),\n    iterations: Math.max(0, total.iterations - prior.iterations),\n    tokens,\n    usd: Math.max(0, total.usd - prior.usd),\n    ms: Math.max(0, total.ms - prior.ms),\n    ...(total.usdEstimated === undefined\n      ? {}\n      : { usdEstimated: Math.max(0, total.usdEstimated - (prior.usdEstimated ?? 0)) }),\n    ...(total.boxMinutes === undefined\n      ? {}\n      : { boxMinutes: Math.max(0, total.boxMinutes - (prior.boxMinutes ?? 0)) }),\n  }\n}\n"],"mappings":"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"}