@tangle-network/agent-eval 0.216.1 → 0.217.1

package/dist/{evaluation-6Yoi74gM.d.ts → evaluation-jTjC_QQD.d.ts}

@@ -1,6 +1,6 @@
 import { a as CostLedgerHandle, d as CostReceiptInput, m as MaximumCharge, r as CostChannel, u as CostReceipt } from "./cost-ledger-Jk62OBfF.js";
-import { a as AnalystFinding, n as Analyst, r as AnalystContext } from "./types-C1tnkEgM.js";
-import { R as Scenario, S as JudgeConfig, w as JudgeScore } from "./types-Cq8mSbq8.js";
+import { i as AnalystFinding, n as AnalystContext, t as Analyst } from "./types-CW8ewATZ.js";
+import { R as Scenario, S as JudgeConfig, w as JudgeScore } from "./types-D8GhJoHk.js";
 //#region src/evaluation.d.ts
 interface EvaluationResult<T> {
   value: T;
@@ -21,7 +21,7 @@ interface EvaluationContext {
   /** Awaited after accounting and before validation or result delivery. */
   onReceipt?: (receipt: CostReceipt) => void | Promise<void>;
 }
-type Evaluator<I, O> = (input: I, context?: EvaluationContext) => Promise<EvaluationResult<O>>;
+type CostedEvaluator<I, O> = (input: I, context?: EvaluationContext) => Promise<EvaluationResult<O>>;
 interface EvaluatorOptions<I, O> {
   execute: (input: I, context: {
     signal: AbortSignal;
@@ -36,12 +36,12 @@ interface EvaluatorOptions<I, O> {
   validate?: (value: O, input: I) => void | Promise<void>;
 }
 /** A metered function, independent of providers, question formats, and application policy. */
-declare function createEvaluator<I, O>(options: EvaluatorOptions<I, O>): Evaluator<I, O>;
+declare function createEvaluator<I, O>(options: EvaluatorOptions<I, O>): CostedEvaluator<I, O>;
 interface EvaluationJudgeOptions<A, S extends Scenario, O> {
   name: string;
   version: string;
   dimensions: JudgeConfig<A, S>['dimensions'];
-  evaluate: Evaluator<{
+  evaluate: CostedEvaluator<{
     artifact: A;
     scenario: S;
   }, O>;
@@ -71,5 +71,5 @@ interface EvaluationAnalystOptions<I, O> {
 /** Registry, graph, and trace consumers keep the same Analyst interface. */
 declare function asAnalyst<I, O>(options: EvaluationAnalystOptions<I, O>): Analyst<I>;
 //#endregion
-export { Evaluator as a, asJudge as c, EvaluationResult as i, createEvaluator as l, EvaluationContext as n, EvaluatorOptions as o, EvaluationJudgeOptions as r, asAnalyst as s, EvaluationAnalystOptions as t };
-//# sourceMappingURL=evaluation-6Yoi74gM.d.ts.map
+export { EvaluationResult as a, asJudge as c, EvaluationJudgeOptions as i, createEvaluator as l, EvaluationAnalystOptions as n, EvaluatorOptions as o, EvaluationContext as r, asAnalyst as s, CostedEvaluator as t };
+//# sourceMappingURL=evaluation-jTjC_QQD.d.ts.map

package/dist/evaluation-jTjC_QQD.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"evaluation-jTjC_QQD.d.ts","names":[],"sources":["../src/evaluation.ts"],"mappings":";;;;UAWiB,iBAAiB;EAChC,OAAO;EACP,SAAS;EACT;;UAGe;;;EAGf;EACA,SAAS;EACT,aAAa;EACb;EACA,UAAU;EACV;EACA,WAAW;EACX,gBAAgB;;EAEhB,aAAa,SAAS,uBAAuB;;KAGnC,gBAAgB,GAAG,MAC7B,OAAO,GACP,UAAU,sBACP,QAAQ,iBAAiB;UAEb,iBAAiB,GAAG;EACnC,UAAU,OAAO,GAAG;IAAW,QAAQ;IAAa;QAA6B,QAAQ;EACzF,UAAU,OAAO,MAAM;EACvB,oBAAoB,OAAO,UAAU;EACrC,mBAAmB,OAAO;EAC1B,aAAa;EACb,gBAAgB;;EAEhB,YAAY,OAAO,GAAG,OAAO,aAAa;;;iBAI5B,gBAAgB,GAAG,GAAG,SAAS,iBAAiB,GAAG,KAAK,gBAAgB,GAAG;UA6B1E,uBAAuB,GAAG,UAAU,UAAU;EAC7D;EACA;EACA,YAAY,YAAY,GAAG;EAC3B,UAAU;IAAkB,UAAU;IAAG,UAAU;KAAK;EACxD,MAAM,OAAO,GAAG;IAAS,UAAU;IAAG,UAAU;QAAQ,aAAa,QAAQ;;EAE7E,UACE,QAAQ,iBAAiB,IACzB;IAAS,UAAU;IAAG,UAAU;eACtB;EACZ,aAAa,UAAU;;;iBAIT,QAAQ,GAAG,UAAU,UAAU,GAC7C,SAAS,uBAAuB,GAAG,GAAG,KACrC,YAAY,GAAG;UA4BD,yBAAyB,GAAG;EAC3C;EACA;EACA;EACA,WAAW,QAAQ;EACnB,MAAM,QAAQ;EACd,WACE,OAAO,GACP,SAAS,mBACT,gBAAgB,mBACb,QAAQ,iBAAiB;EAC9B,MAAM,OAAO,GAAG,OAAO,GAAG,SAAS,mBAAmB,mBAAmB,QAAQ;EACjF,UAAU,QAAQ,iBAAiB,IAAI,OAAO,GAAG,SAAS,0BAA0B;;;iBAItE,UAAU,GAAG,GAAG,SAAS,yBAAyB,GAAG,KAAK,QAAQ"}

package/dist/evaluation.d.ts

@@ -1,2 +1,2 @@
-import { a as Evaluator, c as asJudge, i as EvaluationResult, l as createEvaluator, n as EvaluationContext, o as EvaluatorOptions, r as EvaluationJudgeOptions, s as asAnalyst, t as EvaluationAnalystOptions } from "./evaluation-6Yoi74gM.js";
-export { EvaluationAnalystOptions, EvaluationContext, EvaluationJudgeOptions, EvaluationResult, Evaluator, EvaluatorOptions, asAnalyst, asJudge, createEvaluator };
+import { a as EvaluationResult, c as asJudge, i as EvaluationJudgeOptions, l as createEvaluator, n as EvaluationAnalystOptions, o as EvaluatorOptions, r as EvaluationContext, s as asAnalyst, t as CostedEvaluator } from "./evaluation-jTjC_QQD.js";
+export { CostedEvaluator, EvaluationAnalystOptions, EvaluationContext, EvaluationJudgeOptions, EvaluationResult, EvaluatorOptions, asAnalyst, asJudge, createEvaluator };

package/dist/evaluation.js

@@ -1,4 +1,4 @@
-import { t as CostLedger } from "./cost-ledger-BP8V4kUQ.js";
+import { t as CostLedger } from "./cost-ledger-D0352Z4d.js";
 //#region src/evaluation.ts
 /** A metered function, independent of providers, question formats, and application policy. */
 function createEvaluator(options) {

package/dist/evaluation.js.map

@@ -1 +1 @@
-{"version":3,"file":"evaluation.js","names":[],"sources":["../src/evaluation.ts"],"sourcesContent":["import type { Analyst, AnalystContext, AnalystFinding } from './analyst/types'\nimport type { JudgeConfig, JudgeScore, Scenario } from './campaign/types'\nimport type {\n  CostChannel,\n  CostLedgerHandle,\n  CostReceipt,\n  CostReceiptInput,\n  MaximumCharge,\n} from './cost-ledger'\nimport { CostLedger } from './cost-ledger'\n\nexport interface EvaluationResult<T> {\n  value: T\n  receipt: CostReceipt\n  durationMs: number\n}\n\nexport interface EvaluationContext {\n  /** Physical paid-call identity, forwarded through the existing ledger and transport.\n   * Reusing it in one ledger conflicts; it is not an automatic result-replay policy. */\n  callId?: string\n  signal?: AbortSignal\n  costLedger?: CostLedgerHandle\n  actor?: string\n  channel?: CostChannel\n  costPhase?: string\n  costTags?: Record<string, string>\n  maximumCharge?: MaximumCharge\n  /** Awaited after accounting and before validation or result delivery. */\n  onReceipt?: (receipt: CostReceipt) => void | Promise<void>\n}\n\nexport type Evaluator<I, O> = (\n  input: I,\n  context?: EvaluationContext,\n) => Promise<EvaluationResult<O>>\n\nexport interface EvaluatorOptions<I, O> {\n  execute: (input: I, context: { signal: AbortSignal; idempotencyKey: string }) => Promise<O>\n  receipt: (value: O) => CostReceiptInput\n  receiptFromError?: (error: Error) => CostReceiptInput | undefined\n  model?: string | ((input: I) => string)\n  costLedger?: CostLedgerHandle\n  maximumCharge?: MaximumCharge\n  /** Awaited after accounting, so invalid output never erases paid work. */\n  validate?: (value: O, input: I) => void | Promise<void>\n}\n\n/** A metered function, independent of providers, question formats, and application policy. */\nexport function createEvaluator<I, O>(options: EvaluatorOptions<I, O>): Evaluator<I, O> {\n  const defaults = { ...options }\n  const ledger = defaults.costLedger ?? new CostLedger()\n  return async (input, context = {}) => {\n    context.signal?.throwIfAborted()\n    const started = performance.now()\n    const paid = await (context.costLedger ?? ledger).runPaidCall({\n      callId: context.callId,\n      actor: context.actor ?? 'evaluation',\n      channel: context.channel ?? 'evaluation',\n      phase: context.costPhase ?? 'evaluation',\n      tags: context.costTags,\n      model: typeof defaults.model === 'function' ? defaults.model(input) : defaults.model,\n      signal: context.signal,\n      maximumCharge: context.maximumCharge ?? defaults.maximumCharge,\n      execute: (signal, idempotencyKey) => defaults.execute(input, { signal, idempotencyKey }),\n      receipt: defaults.receipt,\n      receiptFromError: defaults.receiptFromError,\n    })\n    if (paid.receipt) await context.onReceipt?.(paid.receipt)\n    if (!paid.succeeded) throw paid.error\n    // A transport can complete after cancellation. Keep its paid receipt, not a live decision.\n    context.signal?.throwIfAborted()\n    await defaults.validate?.(paid.value, input)\n    context.signal?.throwIfAborted()\n    return { value: paid.value, receipt: paid.receipt, durationMs: performance.now() - started }\n  }\n}\n\nexport interface EvaluationJudgeOptions<A, S extends Scenario, O> {\n  name: string\n  version: string\n  dimensions: JudgeConfig<A, S>['dimensions']\n  evaluate: Evaluator<{ artifact: A; scenario: S }, O>\n  map: (value: O, input: { artifact: A; scenario: S }) => JudgeScore | Promise<JudgeScore>\n  /** Persist the complete observation before reducing it to a verdict. */\n  record?: (\n    result: EvaluationResult<O>,\n    input: { artifact: A; scenario: S },\n  ) => void | Promise<void>\n  appliesTo?: (scenario: S) => boolean\n}\n\n/** Return the existing contract. Mapping never performs another inference call. */\nexport function asJudge<A, S extends Scenario, O>(\n  options: EvaluationJudgeOptions<A, S, O>,\n): JudgeConfig<A, S> {\n  // The version describes these callbacks, not later mutations of the caller's options.\n  const config = { ...options, dimensions: structuredClone(options.dimensions) }\n  return {\n    name: config.name,\n    judgeVersion: config.version,\n    dimensions: config.dimensions,\n    appliesTo: config.appliesTo,\n    async score({ artifact, scenario, signal, costLedger, costPhase, costTags }) {\n      signal.throwIfAborted()\n      const input = { artifact, scenario }\n      const result = await config.evaluate(input, {\n        signal,\n        costLedger,\n        actor: config.name,\n        channel: 'judge',\n        costPhase,\n        costTags: { ...costTags, scenarioId: scenario.id },\n      })\n      await config.record?.(result, input)\n      signal.throwIfAborted()\n      const score = await config.map(result.value, input)\n      signal.throwIfAborted()\n      return score\n    },\n  }\n}\n\nexport interface EvaluationAnalystOptions<I, O> {\n  id: string\n  version: string\n  description: string\n  inputKind: Analyst<I>['inputKind']\n  cost: Analyst<I>['cost']\n  evaluate: (\n    input: I,\n    context: EvaluationContext,\n    analystContext: AnalystContext,\n  ) => Promise<EvaluationResult<O>>\n  map: (value: O, input: I, context: AnalystContext) => AnalystFinding[] | Promise<AnalystFinding[]>\n  record?: (result: EvaluationResult<O>, input: I, context: AnalystContext) => void | Promise<void>\n}\n\n/** Registry, graph, and trace consumers keep the same Analyst interface. */\nexport function asAnalyst<I, O>(options: EvaluationAnalystOptions<I, O>): Analyst<I> {\n  const config = { ...options, cost: structuredClone(options.cost) }\n  return {\n    id: config.id,\n    version: config.version,\n    description: config.description,\n    inputKind: config.inputKind,\n    cost: config.cost,\n    async analyze(input, context) {\n      const signals = context.signal ? [context.signal] : []\n      if (context.deadlineMs !== undefined) {\n        const remaining = context.deadlineMs - Date.now()\n        if (!Number.isFinite(remaining)) throw new TypeError('Analyst deadline must be finite')\n        if (remaining <= 0) throw new DOMException('Analyst deadline exceeded', 'TimeoutError')\n        signals.push(AbortSignal.timeout(Math.ceil(remaining)))\n      }\n      const signal = AbortSignal.any(signals)\n      signal.throwIfAborted()\n      const analystContext = { ...context, signal }\n      const result = await config.evaluate(\n        input,\n        {\n          signal,\n          // No implicit account may override the evaluator's configured spending authority.\n          costLedger:\n            context.costLedger ??\n            (context.budgetUsd === undefined\n              ? undefined\n              : new CostLedger({ costCeilingUsd: context.budgetUsd })),\n          actor: config.id,\n          channel: 'analyst',\n          costPhase: context.costPhase,\n          costTags: { ...context.tags, runId: context.runId, correlationId: context.correlationId },\n          onReceipt: (receipt) =>\n            context.recordUsage?.({\n              calls: 1,\n              tokens: receipt.usageUnknown\n                ? null\n                : { input: receipt.inputTokens, output: receipt.outputTokens },\n              cost: receipt.costUnknown\n                ? { kind: 'uncaptured', usd: null }\n                : {\n                    kind: receipt.actualCostUsd === undefined ? 'estimated' : 'observed',\n                    usd: receipt.costUsd,\n                  },\n            }),\n        },\n        analystContext,\n      )\n      await config.record?.(result, input, analystContext)\n      signal.throwIfAborted()\n      const findings = await config.map(result.value, input, analystContext)\n      signal.throwIfAborted()\n      return findings\n    },\n  }\n}\n"],"mappings":"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"}
+{"version":3,"file":"evaluation.js","names":[],"sources":["../src/evaluation.ts"],"sourcesContent":["import type { Analyst, AnalystContext, AnalystFinding } from './analyst/types'\nimport type { JudgeConfig, JudgeScore, Scenario } from './campaign/types'\nimport type {\n  CostChannel,\n  CostLedgerHandle,\n  CostReceipt,\n  CostReceiptInput,\n  MaximumCharge,\n} from './cost-ledger'\nimport { CostLedger } from './cost-ledger'\n\nexport interface EvaluationResult<T> {\n  value: T\n  receipt: CostReceipt\n  durationMs: number\n}\n\nexport interface EvaluationContext {\n  /** Physical paid-call identity, forwarded through the existing ledger and transport.\n   * Reusing it in one ledger conflicts; it is not an automatic result-replay policy. */\n  callId?: string\n  signal?: AbortSignal\n  costLedger?: CostLedgerHandle\n  actor?: string\n  channel?: CostChannel\n  costPhase?: string\n  costTags?: Record<string, string>\n  maximumCharge?: MaximumCharge\n  /** Awaited after accounting and before validation or result delivery. */\n  onReceipt?: (receipt: CostReceipt) => void | Promise<void>\n}\n\nexport type CostedEvaluator<I, O> = (\n  input: I,\n  context?: EvaluationContext,\n) => Promise<EvaluationResult<O>>\n\nexport interface EvaluatorOptions<I, O> {\n  execute: (input: I, context: { signal: AbortSignal; idempotencyKey: string }) => Promise<O>\n  receipt: (value: O) => CostReceiptInput\n  receiptFromError?: (error: Error) => CostReceiptInput | undefined\n  model?: string | ((input: I) => string)\n  costLedger?: CostLedgerHandle\n  maximumCharge?: MaximumCharge\n  /** Awaited after accounting, so invalid output never erases paid work. */\n  validate?: (value: O, input: I) => void | Promise<void>\n}\n\n/** A metered function, independent of providers, question formats, and application policy. */\nexport function createEvaluator<I, O>(options: EvaluatorOptions<I, O>): CostedEvaluator<I, O> {\n  const defaults = { ...options }\n  const ledger = defaults.costLedger ?? new CostLedger()\n  return async (input, context = {}) => {\n    context.signal?.throwIfAborted()\n    const started = performance.now()\n    const paid = await (context.costLedger ?? ledger).runPaidCall({\n      callId: context.callId,\n      actor: context.actor ?? 'evaluation',\n      channel: context.channel ?? 'evaluation',\n      phase: context.costPhase ?? 'evaluation',\n      tags: context.costTags,\n      model: typeof defaults.model === 'function' ? defaults.model(input) : defaults.model,\n      signal: context.signal,\n      maximumCharge: context.maximumCharge ?? defaults.maximumCharge,\n      execute: (signal, idempotencyKey) => defaults.execute(input, { signal, idempotencyKey }),\n      receipt: defaults.receipt,\n      receiptFromError: defaults.receiptFromError,\n    })\n    if (paid.receipt) await context.onReceipt?.(paid.receipt)\n    if (!paid.succeeded) throw paid.error\n    // A transport can complete after cancellation. Keep its paid receipt, not a live decision.\n    context.signal?.throwIfAborted()\n    await defaults.validate?.(paid.value, input)\n    context.signal?.throwIfAborted()\n    return { value: paid.value, receipt: paid.receipt, durationMs: performance.now() - started }\n  }\n}\n\nexport interface EvaluationJudgeOptions<A, S extends Scenario, O> {\n  name: string\n  version: string\n  dimensions: JudgeConfig<A, S>['dimensions']\n  evaluate: CostedEvaluator<{ artifact: A; scenario: S }, O>\n  map: (value: O, input: { artifact: A; scenario: S }) => JudgeScore | Promise<JudgeScore>\n  /** Persist the complete observation before reducing it to a verdict. */\n  record?: (\n    result: EvaluationResult<O>,\n    input: { artifact: A; scenario: S },\n  ) => void | Promise<void>\n  appliesTo?: (scenario: S) => boolean\n}\n\n/** Return the existing contract. Mapping never performs another inference call. */\nexport function asJudge<A, S extends Scenario, O>(\n  options: EvaluationJudgeOptions<A, S, O>,\n): JudgeConfig<A, S> {\n  // The version describes these callbacks, not later mutations of the caller's options.\n  const config = { ...options, dimensions: structuredClone(options.dimensions) }\n  return {\n    name: config.name,\n    judgeVersion: config.version,\n    dimensions: config.dimensions,\n    appliesTo: config.appliesTo,\n    async score({ artifact, scenario, signal, costLedger, costPhase, costTags }) {\n      signal.throwIfAborted()\n      const input = { artifact, scenario }\n      const result = await config.evaluate(input, {\n        signal,\n        costLedger,\n        actor: config.name,\n        channel: 'judge',\n        costPhase,\n        costTags: { ...costTags, scenarioId: scenario.id },\n      })\n      await config.record?.(result, input)\n      signal.throwIfAborted()\n      const score = await config.map(result.value, input)\n      signal.throwIfAborted()\n      return score\n    },\n  }\n}\n\nexport interface EvaluationAnalystOptions<I, O> {\n  id: string\n  version: string\n  description: string\n  inputKind: Analyst<I>['inputKind']\n  cost: Analyst<I>['cost']\n  evaluate: (\n    input: I,\n    context: EvaluationContext,\n    analystContext: AnalystContext,\n  ) => Promise<EvaluationResult<O>>\n  map: (value: O, input: I, context: AnalystContext) => AnalystFinding[] | Promise<AnalystFinding[]>\n  record?: (result: EvaluationResult<O>, input: I, context: AnalystContext) => void | Promise<void>\n}\n\n/** Registry, graph, and trace consumers keep the same Analyst interface. */\nexport function asAnalyst<I, O>(options: EvaluationAnalystOptions<I, O>): Analyst<I> {\n  const config = { ...options, cost: structuredClone(options.cost) }\n  return {\n    id: config.id,\n    version: config.version,\n    description: config.description,\n    inputKind: config.inputKind,\n    cost: config.cost,\n    async analyze(input, context) {\n      const signals = context.signal ? [context.signal] : []\n      if (context.deadlineMs !== undefined) {\n        const remaining = context.deadlineMs - Date.now()\n        if (!Number.isFinite(remaining)) throw new TypeError('Analyst deadline must be finite')\n        if (remaining <= 0) throw new DOMException('Analyst deadline exceeded', 'TimeoutError')\n        signals.push(AbortSignal.timeout(Math.ceil(remaining)))\n      }\n      const signal = AbortSignal.any(signals)\n      signal.throwIfAborted()\n      const analystContext = { ...context, signal }\n      const result = await config.evaluate(\n        input,\n        {\n          signal,\n          // No implicit account may override the evaluator's configured spending authority.\n          costLedger:\n            context.costLedger ??\n            (context.budgetUsd === undefined\n              ? undefined\n              : new CostLedger({ costCeilingUsd: context.budgetUsd })),\n          actor: config.id,\n          channel: 'analyst',\n          costPhase: context.costPhase,\n          costTags: { ...context.tags, runId: context.runId, correlationId: context.correlationId },\n          onReceipt: (receipt) =>\n            context.recordUsage?.({\n              calls: 1,\n              tokens: receipt.usageUnknown\n                ? null\n                : { input: receipt.inputTokens, output: receipt.outputTokens },\n              cost: receipt.costUnknown\n                ? { kind: 'uncaptured', usd: null }\n                : {\n                    kind: receipt.actualCostUsd === undefined ? 'estimated' : 'observed',\n                    usd: receipt.costUsd,\n                  },\n            }),\n        },\n        analystContext,\n      )\n      await config.record?.(result, input, analystContext)\n      signal.throwIfAborted()\n      const findings = await config.map(result.value, input, analystContext)\n      signal.throwIfAborted()\n      return findings\n    },\n  }\n}\n"],"mappings":";;;AAiDA,SAAgB,gBAAsB,SAAwD;CAC5F,MAAM,WAAW,EAAE,GAAG,QAAQ;CAC9B,MAAM,SAAS,SAAS,cAAc,IAAI,WAAW;CACrD,OAAO,OAAO,OAAO,UAAU,CAAC,MAAM;EACpC,QAAQ,QAAQ,eAAe;EAC/B,MAAM,UAAU,YAAY,IAAI;EAChC,MAAM,OAAO,OAAO,QAAQ,cAAc,OAAA,CAAQ,YAAY;GAC5D,QAAQ,QAAQ;GAChB,OAAO,QAAQ,SAAS;GACxB,SAAS,QAAQ,WAAW;GAC5B,OAAO,QAAQ,aAAa;GAC5B,MAAM,QAAQ;GACd,OAAO,OAAO,SAAS,UAAU,aAAa,SAAS,MAAM,KAAK,IAAI,SAAS;GAC/E,QAAQ,QAAQ;GAChB,eAAe,QAAQ,iBAAiB,SAAS;GACjD,UAAU,QAAQ,mBAAmB,SAAS,QAAQ,OAAO;IAAE;IAAQ;GAAe,CAAC;GACvF,SAAS,SAAS;GAClB,kBAAkB,SAAS;EAC7B,CAAC;EACD,IAAI,KAAK,SAAS,MAAM,QAAQ,YAAY,KAAK,OAAO;EACxD,IAAI,CAAC,KAAK,WAAW,MAAM,KAAK;EAEhC,QAAQ,QAAQ,eAAe;EAC/B,MAAM,SAAS,WAAW,KAAK,OAAO,KAAK;EAC3C,QAAQ,QAAQ,eAAe;EAC/B,OAAO;GAAE,OAAO,KAAK;GAAO,SAAS,KAAK;GAAS,YAAY,YAAY,IAAI,IAAI;EAAQ;CAC7F;AACF;;AAiBA,SAAgB,QACd,SACmB;CAEnB,MAAM,SAAS;EAAE,GAAG;EAAS,YAAY,gBAAgB,QAAQ,UAAU;CAAE;CAC7E,OAAO;EACL,MAAM,OAAO;EACb,cAAc,OAAO;EACrB,YAAY,OAAO;EACnB,WAAW,OAAO;EAClB,MAAM,MAAM,EAAE,UAAU,UAAU,QAAQ,YAAY,WAAW,YAAY;GAC3E,OAAO,eAAe;GACtB,MAAM,QAAQ;IAAE;IAAU;GAAS;GACnC,MAAM,SAAS,MAAM,OAAO,SAAS,OAAO;IAC1C;IACA;IACA,OAAO,OAAO;IACd,SAAS;IACT;IACA,UAAU;KAAE,GAAG;KAAU,YAAY,SAAS;IAAG;GACnD,CAAC;GACD,MAAM,OAAO,SAAS,QAAQ,KAAK;GACnC,OAAO,eAAe;GACtB,MAAM,QAAQ,MAAM,OAAO,IAAI,OAAO,OAAO,KAAK;GAClD,OAAO,eAAe;GACtB,OAAO;EACT;CACF;AACF;;AAkBA,SAAgB,UAAgB,SAAqD;CACnF,MAAM,SAAS;EAAE,GAAG;EAAS,MAAM,gBAAgB,QAAQ,IAAI;CAAE;CACjE,OAAO;EACL,IAAI,OAAO;EACX,SAAS,OAAO;EAChB,aAAa,OAAO;EACpB,WAAW,OAAO;EAClB,MAAM,OAAO;EACb,MAAM,QAAQ,OAAO,SAAS;GAC5B,MAAM,UAAU,QAAQ,SAAS,CAAC,QAAQ,MAAM,IAAI,CAAC;GACrD,IAAI,QAAQ,eAAe,KAAA,GAAW;IACpC,MAAM,YAAY,QAAQ,aAAa,KAAK,IAAI;IAChD,IAAI,CAAC,OAAO,SAAS,SAAS,GAAG,MAAM,IAAI,UAAU,iCAAiC;IACtF,IAAI,aAAa,GAAG,MAAM,IAAI,aAAa,6BAA6B,cAAc;IACtF,QAAQ,KAAK,YAAY,QAAQ,KAAK,KAAK,SAAS,CAAC,CAAC;GACxD;GACA,MAAM,SAAS,YAAY,IAAI,OAAO;GACtC,OAAO,eAAe;GACtB,MAAM,iBAAiB;IAAE,GAAG;IAAS;GAAO;GAC5C,MAAM,SAAS,MAAM,OAAO,SAC1B,OACA;IACE;IAEA,YACE,QAAQ,eACP,QAAQ,cAAc,KAAA,IACnB,KAAA,IACA,IAAI,WAAW,EAAE,gBAAgB,QAAQ,UAAU,CAAC;IAC1D,OAAO,OAAO;IACd,SAAS;IACT,WAAW,QAAQ;IACnB,UAAU;KAAE,GAAG,QAAQ;KAAM,OAAO,QAAQ;KAAO,eAAe,QAAQ;IAAc;IACxF,YAAY,YACV,QAAQ,cAAc;KACpB,OAAO;KACP,QAAQ,QAAQ,eACZ,OACA;MAAE,OAAO,QAAQ;MAAa,QAAQ,QAAQ;KAAa;KAC/D,MAAM,QAAQ,cACV;MAAE,MAAM;MAAc,KAAK;KAAK,IAChC;MACE,MAAM,QAAQ,kBAAkB,KAAA,IAAY,cAAc;MAC1D,KAAK,QAAQ;KACf;IACN,CAAC;GACL,GACA,cACF;GACA,MAAM,OAAO,SAAS,QAAQ,OAAO,cAAc;GACnD,OAAO,eAAe;GACtB,MAAM,WAAW,MAAM,OAAO,IAAI,OAAO,OAAO,OAAO,cAAc;GACrE,OAAO,eAAe;GACtB,OAAO;EACT;CACF;AACF"}

package/dist/{exact-types-ClugMJfI.d.ts → exact-types-CflbJ9f3.d.ts}

@@ -1,4 +1,4 @@
-import { d as AnalystRunResult, f as AnalystRunSummary, l as AnalystRunEvent, n as Analyst } from "./types-C1tnkEgM.js";
+import { c as AnalystRunEvent, d as AnalystRunSummary, t as Analyst, u as AnalystRunResult } from "./types-CW8ewATZ.js";
 import { z } from "zod";
 //#region src/analyst/exact-types.d.ts
 /** Analyst metadata required before the exact registry path will execute it. */
@@ -231,4 +231,4 @@ declare const exactExecutionPlanSchema: z.ZodObject<{
 }, z.core.$strict>;
 //#endregion
 export { ExactAnalystRunPolicySnapshot as a, ExactAnalystSnapshot as c, ExactExecutionComponentSnapshot as d, ExactAnalystRunEvent as i, ExactCapableAnalyst as l, ExactAnalystExecutionPlanSnapshot as n, ExactAnalystRunResult as o, ExactAnalystRunCompletion as r, ExactAnalystRunSummary as s, ExactAnalystBudgetSnapshot as t, ExactExecutionComponentIdentity as u };
-//# sourceMappingURL=exact-types-ClugMJfI.d.ts.map
+//# sourceMappingURL=exact-types-CflbJ9f3.d.ts.map

package/dist/{exact-types-ClugMJfI.d.ts.map → exact-types-CflbJ9f3.d.ts.map}

@@ -1 +1 @@
-{"version":3,"file":"exact-types-ClugMJfI.d.ts","names":[],"sources":["../src/analyst/exact-types.ts"],"mappings":";;;;UAMiB,oBAAoB,0BAA0B,QAAQ;;WAE5D,iBAAiB,SAAS;;KAGhC,aAAa,KAAK,0BAA0B,mBACpC,aAAa,UACtB,+BACc,aAAa,IAAI,aAAa,EAAE,WAC5C;KAEM,uBAAuB,aAAa,EAAE,aAAa;KACnD,6BAA6B,aAAa,EAAE,aAAa;;UAGpD;EACf;EACA;EACA,QAAQ,SAAS;;;UAIF;EACf;EACA;EACA;;KAyBU,gCAAgC,aAAa,EAAE,aAAa;KAC5D,oCAAoC,aAC9C,EAAE,aAAa;KAGL,yBAAyB;;EAEnC;;KAGU;EACN;;EAEA;EACA;IAAS;IAAe;;;UAGb,8BAA8B;EAC7C,aAAa;EACb,gBAAgB;EAChB,YAAY;;;KAIF,wBACP,QAAQ;EAAmB;;EAC1B,gBAAgB;MAEjB,KAAK,QAAQ;EAAmB;;EAC/B,SAAS;KAEX,QAAQ;EAAmB;MAC1B,KAAK,QAAQ;EAAmB;;EAC/B,SAAS;MAEV,KAAK,QAAQ;EAAmB;;EAC/B,QAAQ;;cAwCR,uBAAqB,EAAA;;;;;;;;;;;;;;;;;;;;;;;;;GAOzB,EAAA,KAAA;cAII,sBAAoB,EAAA,uBAAA,EAAA;;;;;;;;;;;GAaxB,EAAA,KAAA;cAiBI,sBAAoB,EAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAYxB,EAAA,KAAA;cAEI,0BAAwB,EAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA+E1B,EAAA,KAAA"}
+{"version":3,"file":"exact-types-CflbJ9f3.d.ts","names":[],"sources":["../src/analyst/exact-types.ts"],"mappings":";;;;UAMiB,oBAAoB,0BAA0B,QAAQ;;WAE5D,iBAAiB,SAAS;;KAGhC,aAAa,KAAK,0BAA0B,mBACpC,aAAa,UACtB,+BACc,aAAa,IAAI,aAAa,EAAE,WAC5C;KAEM,uBAAuB,aAAa,EAAE,aAAa;KACnD,6BAA6B,aAAa,EAAE,aAAa;;UAGpD;EACf;EACA;EACA,QAAQ,SAAS;;;UAIF;EACf;EACA;EACA;;KAyBU,gCAAgC,aAAa,EAAE,aAAa;KAC5D,oCAAoC,aAC9C,EAAE,aAAa;KAGL,yBAAyB;;EAEnC;;KAGU;EACN;;EAEA;EACA;IAAS;IAAe;;;UAGb,8BAA8B;EAC7C,aAAa;EACb,gBAAgB;EAChB,YAAY;;;KAIF,wBACP,QAAQ;EAAmB;;EAC1B,gBAAgB;MAEjB,KAAK,QAAQ;EAAmB;;EAC/B,SAAS;KAEX,QAAQ;EAAmB;MAC1B,KAAK,QAAQ;EAAmB;;EAC/B,SAAS;MAEV,KAAK,QAAQ;EAAmB;;EAC/B,QAAQ;;cAwCR,uBAAqB,EAAA;;;;;;;;;;;;;;;;;;;;;;;;;GAOzB,EAAA,KAAA;cAII,sBAAoB,EAAA,uBAAA,EAAA;;;;;;;;;;;GAaxB,EAAA,KAAA;cAiBI,sBAAoB,EAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAYxB,EAAA,KAAA;cAEI,0BAAwB,EAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA+E1B,EAAA,KAAA"}

package/dist/{exec-ChJ6d5if.js → exec-CpbtOXVt.js}

@@ -168,28 +168,6 @@ function finalRecordedOutcome(steps) {
 		reason: kind
 	};
 }
-/**
-* Steps whose recorded exit a replay cannot check.
-*
-* A killed step counts: the recording holds no exit status to compare a replay
-* against, so agreement on it cannot be measured either way.
-*/
-function unreadableExitCount(steps) {
-	return steps.filter((step) => classifyObservation(step.observation) !== "command-result").length;
-}
-/**
-* Throw unless every recorded command survived the dump.
-*
-* A replay executes `steps` verbatim, so one elision marker in an action means
-* the replay runs the literal two-to-four characters of the marker instead of
-* the command the run executed. The guard is here so a replayer needs one call
-* rather than a field check it can forget.
-*/
-function assertReplayableTrajectory(decoded) {
-	if (decoded.elidedCommands === 0) return;
-	const markers = decoded.steps.filter((step) => isElidedField(step.action)).map((step) => step.action);
-	throw new Error(`trajectory holds ${decoded.elidedCommands} command(s) the dump elided (${markers.slice(0, 5).join(", ")}); no dictionary maps a marker back to its text, so this trajectory cannot be replayed`);
-}
 //#endregion
 //#region src/trajectory-replay/exec.ts
 /**
@@ -203,6 +181,6 @@ function wrapActionForExec(action, cwd) {
 	return `cd ${`'${cwd.replaceAll("'", `'\\''`)}'`} && printf %s ${b64} | base64 -d | sh`;
 }
 //#endregion
-export { assertReplayableTrajectory as a, deriveFailureSignature as c, isRecordedTimeout as d, isSubmitAction as f, unreadableExitCount as g, parseRecordedReturncode as h, TIMEOUT_OBSERVATION_MARKER as i, finalRecordedOutcome as l, parseObservationOutput as m, FORMAT_ERROR_OBSERVATION_PREFIX as n, classifyObservation as o, isSubmitOnlyAction as p, SUBMIT_ACTION_SIGNATURE as r, decodeRecordedTurns as s, wrapActionForExec as t, isElidedField as u };
+export { classifyObservation as a, finalRecordedOutcome as c, isSubmitOnlyAction as d, parseObservationOutput as f, TIMEOUT_OBSERVATION_MARKER as i, isRecordedTimeout as l, FORMAT_ERROR_OBSERVATION_PREFIX as n, decodeRecordedTurns as o, parseRecordedReturncode as p, SUBMIT_ACTION_SIGNATURE as r, deriveFailureSignature as s, wrapActionForExec as t, isSubmitAction as u };
 
-//# sourceMappingURL=exec-ChJ6d5if.js.map
+//# sourceMappingURL=exec-CpbtOXVt.js.map

package/dist/{exec-ChJ6d5if.js.map → exec-CpbtOXVt.js.map}

@@ -1 +1 @@
-{"version":3,"file":"exec-ChJ6d5if.js","names":[],"sources":["../src/trajectory-replay/steps.ts","../src/trajectory-replay/exec.ts"],"sourcesContent":["/**\n * Recorded shell-trajectory steps and the observation grammar they carry.\n *\n * A recorded trajectory is the action/observation sequence an agent actually\n * ran. Scaffolds that execute one shell command per step (mini-SWE and the\n * CodeTracer-normalized corpora built from it) tag each observation with the\n * command's returncode and its combined output:\n *\n *     <returncode>2</returncode>\n *     <output>\n *     …command output…\n *     </output>\n *\n * That is one of four shapes a recorded turn carries, and the other three are\n * not command results at all:\n *\n *   - a timeout notice, when the environment killed the command at its bound;\n *   - a format-error notice, when the scaffold rejected the turn and ran\n *     nothing;\n *   - an elision marker `$<hex>`, when the published dump dropped the string.\n *\n * A turn also carries no observation when it is the run's last turn, because\n * the scaffold records an observation only when it hands one back to the model.\n *\n * The parsers here are the only place that grammar is decoded. Everything\n * downstream — replay verdicts, corpus enumeration, admission funnels, fix\n * prompts — reads the returncode, the output, and the failure signature through\n * these functions. A second decoder elsewhere is how a corpus reads as\n * unreplayable when it is not.\n */\n\n/**\n * One step of a recorded shell trajectory. Structural: any richer step record\n * (file refs, thinking text, tool type) satisfies it.\n */\nexport interface RecordedTrajectoryStep {\n  /** 1-based position in the trajectory. */\n  readonly step_id: number\n  readonly action: string\n  /** Null when the step recorded no observation (terminal submit steps). */\n  readonly observation: string | null\n}\n\n/** Recorded returncode of a step, or null when the observation carries none. */\nexport function parseRecordedReturncode(observation: string | null): number | null {\n  if (!observation) return null\n  const m = /<returncode>(-?\\d+)<\\/returncode>/.exec(observation)\n  return m ? Number(m[1]) : null\n}\n\n/** Text between the observation's <output> tags, or the raw observation when\n *  the tags are absent. */\nexport function parseObservationOutput(observation: string | null): string {\n  if (!observation) return ''\n  const m = /<output>\\n?([\\s\\S]*?)\\n?<\\/output>/.exec(observation)\n  return m ? m[1]! : observation\n}\n\n/**\n * Stable failure-signature candidate: the first error line, or a shell\n * command-not-found suffix. Null when neither exists — a verdict then falls\n * back to returncode-only matching and says so.\n * Pass an explicit signature to override (compiler quote glyphs vary with\n * locale, so a hand-picked ASCII substring is often more robust).\n */\nexport function deriveFailureSignature(observation: string | null): string | null {\n  for (const line of parseObservationOutput(observation).split('\\n')) {\n    if (/\\berror\\b/i.test(line)) return line.trim().slice(0, 200)\n    // The shell prefix differs between recorded bash and replayed /bin/sh.\n    const missingCommand = /([A-Za-z0-9_.+/-]+: (?:command )?not found)\\b/.exec(line)\n    if (missingCommand) return missingCommand[1]!.slice(0, 200)\n  }\n  return null\n}\n\n/** mini-SWE's end-of-run submit convention: the agent echoes this sentinel\n *  and dumps the diff. A label on this step marks a bad SUBMIT DECISION, not a\n *  failed command — there is no executable failure to reproduce, so it is\n *  never a counterfactual replay target. */\nexport const SUBMIT_ACTION_SIGNATURE = 'COMPLETE_TASK_AND_SUBMIT_FINAL_OUTPUT'\n\nexport function isSubmitAction(action: string): boolean {\n  return action.includes(SUBMIT_ACTION_SIGNATURE)\n}\n\n/**\n * True when the action is the sentinel echo and nothing else.\n *\n * The distinction decides whether a step may be dropped. An agent is told to\n * issue the sentinel alone, and 5.7% of recorded runs end on a command that\n * writes files or edits them and then echoes it. Dropping such a step because\n * it holds the sentinel would remove the run's last state change from the\n * replay, so the recorded end state and the replayed one would differ.\n */\nexport function isSubmitOnlyAction(action: string): boolean {\n  return /^echo\\s+(?:\"COMPLETE_TASK_AND_SUBMIT_FINAL_OUTPUT\"|'COMPLETE_TASK_AND_SUBMIT_FINAL_OUTPUT'|COMPLETE_TASK_AND_SUBMIT_FINAL_OUTPUT)$/.test(\n    action.trim(),\n  )\n}\n\n// ── Fields the published dump dropped ────────────────────────────────\n\n/**\n * A field the dump replaced with a counter instead of its text.\n *\n * The counter is hexadecimal and rises by one per dropped string in document\n * order, so a decimal-only reading (`$12`) accepts every marker that carries a\n * letter (`$3a`) as if it were real text. A command read that way replays as\n * the literal two-to-four characters `$3a`, which is not the command the run\n * executed.\n *\n * Nothing in the dump maps a marker back to its text: the same marker carries\n * different content in different rows, so there is no dictionary to read. A\n * field that matches is unrecoverable, so a caller rejects the row that holds\n * it rather than replaying the marker.\n */\nconst RECORDED_ELISION_PATTERN = /^\\$[0-9a-f]+$/\n\nexport function isElidedField(value: string | null | undefined): boolean {\n  return typeof value === 'string' && RECORDED_ELISION_PATTERN.test(value)\n}\n\n// ── Observation grammar ──────────────────────────────────────────────\n\n/** Substring the timeout notice always carries, whatever the command was. */\nexport const TIMEOUT_OBSERVATION_MARKER = 'timed out and has been killed'\n\n/** Opening of the notice the scaffold writes when a turn held no single action. */\nexport const FORMAT_ERROR_OBSERVATION_PREFIX =\n  'Please always provide EXACTLY ONE action in triple backticks, found '\n\n/**\n * What a recorded observation is.\n *\n * `command-result` is the only kind that carries an exit status. `timeout` and\n * `format-error` are the scaffold speaking rather than a command: the first\n * says the environment killed the command, the second says no command ran at\n * all. `elided` and `absent` carry no information about the step, and\n * `unreadable` is a shape this grammar does not know — never assumed to be\n * anything.\n */\nexport type RecordedObservationKind =\n  | 'command-result'\n  | 'timeout'\n  | 'format-error'\n  | 'elided'\n  | 'absent'\n  | 'unreadable'\n\nexport function classifyObservation(observation: string | null): RecordedObservationKind {\n  if (observation === null) return 'absent'\n  if (isElidedField(observation)) return 'elided'\n  if (parseRecordedReturncode(observation) !== null) return 'command-result'\n  if (observation.startsWith(FORMAT_ERROR_OBSERVATION_PREFIX)) return 'format-error'\n  if (observation.includes(TIMEOUT_OBSERVATION_MARKER)) return 'timeout'\n  return 'unreadable'\n}\n\n/** True when the recording shows the environment killed this step at its\n *  wall-clock bound. Such a step carries no returncode, so no replay can\n *  confirm or contradict it. */\nexport function isRecordedTimeout(observation: string | null): boolean {\n  return classifyObservation(observation) === 'timeout'\n}\n\n// ── Turns to steps ───────────────────────────────────────────────────\n\n/**\n * One turn as the published trajectory dump holds it.\n *\n * A turn is not a step: the system prompt, the task statement and every turn\n * the scaffold rejected are turns that executed nothing.\n */\nexport interface RecordedTrajectoryTurn {\n  readonly src?: string | null\n  readonly msg?: string | null\n  readonly tools?: readonly { readonly cmd?: string | null }[] | null\n  readonly obs?: string | null\n}\n\nexport interface DecodedTrajectory {\n  /** Executed commands in recorded order, each holding its OWN observation. */\n  readonly steps: readonly RecordedTrajectoryStep[]\n  /** Turns the scaffold rejected before anything ran. */\n  readonly formatErrorTurns: number\n  /**\n   * Executed commands whose text the dump dropped.\n   *\n   * The step stays in `steps` carrying the marker, because the run did execute\n   * a command there and a shorter list would misreport the trajectory. The\n   * marker is not a command, so any count above zero means this trajectory\n   * cannot be replayed: gate on it, or call `assertReplayableTrajectory`.\n   */\n  readonly elidedCommands: number\n  /** True when the run's last turn was the submit sentinel with no observation. */\n  readonly endedOnSubmitSentinel: boolean\n  /** Turns carrying an observation this grammar cannot read. */\n  readonly unreadableTurns: number\n}\n\n/**\n * Pair every recorded command with the observation of its own turn.\n *\n * Collecting commands and observations into two lists and zipping them is the\n * decode that looks right and is not: a turn the scaffold rejected carries an\n * observation of its own, so from the first such turn onward every observation\n * belongs to a different command than the one it is read against.\n *\n * A rejected turn executed nothing, so it is never a step — including when the\n * dump recorded a command for it. The scaffold rejects a turn holding several\n * bash blocks and runs none of them, while the dump keeps one of the blocks in\n * the command field. Replaying that field would execute a command the recorded\n * run did not, which is a worse corpus than a smaller one.\n *\n * A rejected turn is recognised by its observation, so a rejected turn whose\n * observation the dump elided is indistinguishable from an executed command\n * whose observation it elided. Both read as a step. Nothing in the dump\n * separates them, and the row-level defence is the share of unreadable exits a\n * caller admits: a row with no elided observation cannot hold this case at all.\n *\n * A trailing step that echoes the sentinel and nothing else, with no\n * observation, is dropped from `steps` and reported as `endedOnSubmitSentinel`.\n * The scaffold records an observation only when it hands one to the model, and\n * the sentinel ends the run, so the missing observation is the end of the\n * transcript rather than a gap in it. Echoing the sentinel changes no state, so\n * the recorded end state is the state the step before it left.\n *\n * A step that DID get an observation stays a step: the run continued past it.\n * So does a step that echoes the sentinel after doing real work — its state\n * change is part of the recorded end state, and with no observation its exit is\n * unknown, which `finalRecordedOutcome` reports rather than hides.\n */\nexport function decodeRecordedTurns(turns: readonly RecordedTrajectoryTurn[]): DecodedTrajectory {\n  const steps: RecordedTrajectoryStep[] = []\n  let formatErrorTurns = 0\n  let unreadableTurns = 0\n  for (const turn of turns) {\n    const command = turn.tools?.[0]?.cmd ?? null\n    const observation = turn.obs ?? null\n    const kind = classifyObservation(observation)\n    if (kind === 'format-error') {\n      formatErrorTurns += 1\n      continue\n    }\n    if (command === null) {\n      if (kind === 'unreadable' || kind === 'elided') unreadableTurns += 1\n      continue\n    }\n    steps.push({ step_id: steps.length + 1, action: command, observation })\n  }\n  const last = steps[steps.length - 1]\n  const endedOnSubmitSentinel =\n    last !== undefined && last.observation === null && isSubmitOnlyAction(last.action)\n  if (endedOnSubmitSentinel) steps.pop()\n  return {\n    steps,\n    formatErrorTurns,\n    elidedCommands: steps.filter((step) => isElidedField(step.action)).length,\n    endedOnSubmitSentinel,\n    unreadableTurns,\n  }\n}\n\n// ── The state a trajectory ended in ──────────────────────────────────\n\n/**\n * How the recorded run's last executed command ended.\n *\n * `killed` is a measured outcome, not a missing one: the environment stopped\n * the command at its bound and wrote a notice instead of an exit status.\n * `unreadable` names the observation kind that blocked the read, so a funnel\n * can report which shape cost it the row.\n */\nexport type RecordedFinalOutcome =\n  | { readonly kind: 'returncode'; readonly value: number }\n  | { readonly kind: 'killed' }\n  | { readonly kind: 'unreadable'; readonly reason: RecordedObservationKind }\n\n/**\n * The outcome of the last step, or `null` when the trajectory has no steps.\n *\n * Reads only the last step. `decodeRecordedTurns` has already removed the turns\n * that executed nothing, so the last step is the last command the run ran.\n */\nexport function finalRecordedOutcome(\n  steps: readonly RecordedTrajectoryStep[],\n): RecordedFinalOutcome | null {\n  const last = steps[steps.length - 1]\n  if (last === undefined) return null\n  const kind = classifyObservation(last.observation)\n  if (kind === 'command-result') {\n    return { kind: 'returncode', value: parseRecordedReturncode(last.observation)! }\n  }\n  if (kind === 'timeout') return { kind: 'killed' }\n  return { kind: 'unreadable', reason: kind }\n}\n\n/**\n * Steps whose recorded exit a replay cannot check.\n *\n * A killed step counts: the recording holds no exit status to compare a replay\n * against, so agreement on it cannot be measured either way.\n */\nexport function unreadableExitCount(steps: readonly RecordedTrajectoryStep[]): number {\n  return steps.filter((step) => classifyObservation(step.observation) !== 'command-result').length\n}\n\n/**\n * Throw unless every recorded command survived the dump.\n *\n * A replay executes `steps` verbatim, so one elision marker in an action means\n * the replay runs the literal two-to-four characters of the marker instead of\n * the command the run executed. The guard is here so a replayer needs one call\n * rather than a field check it can forget.\n */\nexport function assertReplayableTrajectory(decoded: DecodedTrajectory): void {\n  if (decoded.elidedCommands === 0) return\n  const markers = decoded.steps\n    .filter((step) => isElidedField(step.action))\n    .map((step) => step.action)\n  throw new Error(\n    `trajectory holds ${decoded.elidedCommands} command(s) the dump elided (${markers.slice(0, 5).join(', ')}); ` +\n      'no dictionary maps a marker back to its text, so this trajectory cannot be replayed',\n  )\n}\n","/**\n * The execution boundary replay runs across.\n *\n * A replay needs one thing from its environment: a session that runs a shell\n * command inside the trajectory's own image and reports the exit code and\n * output. That is the whole contract. Concrete backends — a sandbox platform\n * client, a docker exec, an SSH shell — live with the consumer that owns the\n * infrastructure, so this package depends on no sandbox client.\n */\n\nexport interface ReplayExecResult {\n  exitCode: number\n  stdout: string\n  stderr: string\n}\n\nexport interface ReplayExecSession {\n  exec(command: string, timeoutMs: number): Promise<ReplayExecResult>\n  close(): Promise<void>\n}\n\nexport interface ReplayExecBackend {\n  /** One fresh execution environment per call; the caller closes it. */\n  open(): Promise<ReplayExecSession>\n}\n\n/** Builds a backend pinned to one image. Callers that resolve images\n *  internally (batch, corpus wire, finding verification) take this instead of\n *  a backend, so every case runs against its own image. */\nexport type ReplayExecBackendFactory = (image: string) => ReplayExecBackend\n\n/**\n * mini-SWE runs every action as a fresh /bin/sh subshell from a fixed\n * workdir. Reproduce that exactly — and stay quote-proof for arbitrary\n * recorded actions — by piping the base64 of the action into `sh` after\n * cd-ing to the workdir. Exit code is sh's, i.e. the action's.\n */\nexport function wrapActionForExec(action: string, cwd: string): string {\n  const b64 = Buffer.from(action, 'utf8').toString('base64')\n  const quotedCwd = `'${cwd.replaceAll(\"'\", `'\\\\''`)}'`\n  return `cd ${quotedCwd} && printf %s ${b64} | base64 -d | sh`\n}\n"],"mappings":"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"}
+{"version":3,"file":"exec-CpbtOXVt.js","names":[],"sources":["../src/trajectory-replay/steps.ts","../src/trajectory-replay/exec.ts"],"sourcesContent":["/**\n * Recorded shell-trajectory steps and the observation grammar they carry.\n *\n * A recorded trajectory is the action/observation sequence an agent actually\n * ran. Scaffolds that execute one shell command per step (mini-SWE and the\n * CodeTracer-normalized corpora built from it) tag each observation with the\n * command's returncode and its combined output:\n *\n *     <returncode>2</returncode>\n *     <output>\n *     …command output…\n *     </output>\n *\n * That is one of four shapes a recorded turn carries, and the other three are\n * not command results at all:\n *\n *   - a timeout notice, when the environment killed the command at its bound;\n *   - a format-error notice, when the scaffold rejected the turn and ran\n *     nothing;\n *   - an elision marker `$<hex>`, when the published dump dropped the string.\n *\n * A turn also carries no observation when it is the run's last turn, because\n * the scaffold records an observation only when it hands one back to the model.\n *\n * The parsers here are the only place that grammar is decoded. Everything\n * downstream — replay verdicts, corpus enumeration, admission funnels, fix\n * prompts — reads the returncode, the output, and the failure signature through\n * these functions. A second decoder elsewhere is how a corpus reads as\n * unreplayable when it is not.\n */\n\n/**\n * One step of a recorded shell trajectory. Structural: any richer step record\n * (file refs, thinking text, tool type) satisfies it.\n */\nexport interface RecordedTrajectoryStep {\n  /** 1-based position in the trajectory. */\n  readonly step_id: number\n  readonly action: string\n  /** Null when the step recorded no observation (terminal submit steps). */\n  readonly observation: string | null\n}\n\n/** Recorded returncode of a step, or null when the observation carries none. */\nexport function parseRecordedReturncode(observation: string | null): number | null {\n  if (!observation) return null\n  const m = /<returncode>(-?\\d+)<\\/returncode>/.exec(observation)\n  return m ? Number(m[1]) : null\n}\n\n/** Text between the observation's <output> tags, or the raw observation when\n *  the tags are absent. */\nexport function parseObservationOutput(observation: string | null): string {\n  if (!observation) return ''\n  const m = /<output>\\n?([\\s\\S]*?)\\n?<\\/output>/.exec(observation)\n  return m ? m[1]! : observation\n}\n\n/**\n * Stable failure-signature candidate: the first error line, or a shell\n * command-not-found suffix. Null when neither exists — a verdict then falls\n * back to returncode-only matching and says so.\n * Pass an explicit signature to override (compiler quote glyphs vary with\n * locale, so a hand-picked ASCII substring is often more robust).\n */\nexport function deriveFailureSignature(observation: string | null): string | null {\n  for (const line of parseObservationOutput(observation).split('\\n')) {\n    if (/\\berror\\b/i.test(line)) return line.trim().slice(0, 200)\n    // The shell prefix differs between recorded bash and replayed /bin/sh.\n    const missingCommand = /([A-Za-z0-9_.+/-]+: (?:command )?not found)\\b/.exec(line)\n    if (missingCommand) return missingCommand[1]!.slice(0, 200)\n  }\n  return null\n}\n\n/** mini-SWE's end-of-run submit convention: the agent echoes this sentinel\n *  and dumps the diff. A label on this step marks a bad SUBMIT DECISION, not a\n *  failed command — there is no executable failure to reproduce, so it is\n *  never a counterfactual replay target. */\nexport const SUBMIT_ACTION_SIGNATURE = 'COMPLETE_TASK_AND_SUBMIT_FINAL_OUTPUT'\n\nexport function isSubmitAction(action: string): boolean {\n  return action.includes(SUBMIT_ACTION_SIGNATURE)\n}\n\n/**\n * True when the action is the sentinel echo and nothing else.\n *\n * The distinction decides whether a step may be dropped. An agent is told to\n * issue the sentinel alone, and 5.7% of recorded runs end on a command that\n * writes files or edits them and then echoes it. Dropping such a step because\n * it holds the sentinel would remove the run's last state change from the\n * replay, so the recorded end state and the replayed one would differ.\n */\nexport function isSubmitOnlyAction(action: string): boolean {\n  return /^echo\\s+(?:\"COMPLETE_TASK_AND_SUBMIT_FINAL_OUTPUT\"|'COMPLETE_TASK_AND_SUBMIT_FINAL_OUTPUT'|COMPLETE_TASK_AND_SUBMIT_FINAL_OUTPUT)$/.test(\n    action.trim(),\n  )\n}\n\n// ── Fields the published dump dropped ────────────────────────────────\n\n/**\n * A field the dump replaced with a counter instead of its text.\n *\n * The counter is hexadecimal and rises by one per dropped string in document\n * order, so a decimal-only reading (`$12`) accepts every marker that carries a\n * letter (`$3a`) as if it were real text. A command read that way replays as\n * the literal two-to-four characters `$3a`, which is not the command the run\n * executed.\n *\n * Nothing in the dump maps a marker back to its text: the same marker carries\n * different content in different rows, so there is no dictionary to read. A\n * field that matches is unrecoverable, so a caller rejects the row that holds\n * it rather than replaying the marker.\n */\nconst RECORDED_ELISION_PATTERN = /^\\$[0-9a-f]+$/\n\nexport function isElidedField(value: string | null | undefined): boolean {\n  return typeof value === 'string' && RECORDED_ELISION_PATTERN.test(value)\n}\n\n// ── Observation grammar ──────────────────────────────────────────────\n\n/** Substring the timeout notice always carries, whatever the command was. */\nexport const TIMEOUT_OBSERVATION_MARKER = 'timed out and has been killed'\n\n/** Opening of the notice the scaffold writes when a turn held no single action. */\nexport const FORMAT_ERROR_OBSERVATION_PREFIX =\n  'Please always provide EXACTLY ONE action in triple backticks, found '\n\n/**\n * What a recorded observation is.\n *\n * `command-result` is the only kind that carries an exit status. `timeout` and\n * `format-error` are the scaffold speaking rather than a command: the first\n * says the environment killed the command, the second says no command ran at\n * all. `elided` and `absent` carry no information about the step, and\n * `unreadable` is a shape this grammar does not know — never assumed to be\n * anything.\n */\nexport type RecordedObservationKind =\n  | 'command-result'\n  | 'timeout'\n  | 'format-error'\n  | 'elided'\n  | 'absent'\n  | 'unreadable'\n\nexport function classifyObservation(observation: string | null): RecordedObservationKind {\n  if (observation === null) return 'absent'\n  if (isElidedField(observation)) return 'elided'\n  if (parseRecordedReturncode(observation) !== null) return 'command-result'\n  if (observation.startsWith(FORMAT_ERROR_OBSERVATION_PREFIX)) return 'format-error'\n  if (observation.includes(TIMEOUT_OBSERVATION_MARKER)) return 'timeout'\n  return 'unreadable'\n}\n\n/** True when the recording shows the environment killed this step at its\n *  wall-clock bound. Such a step carries no returncode, so no replay can\n *  confirm or contradict it. */\nexport function isRecordedTimeout(observation: string | null): boolean {\n  return classifyObservation(observation) === 'timeout'\n}\n\n// ── Turns to steps ───────────────────────────────────────────────────\n\n/**\n * One turn as the published trajectory dump holds it.\n *\n * A turn is not a step: the system prompt, the task statement and every turn\n * the scaffold rejected are turns that executed nothing.\n */\nexport interface RecordedTrajectoryTurn {\n  readonly src?: string | null\n  readonly msg?: string | null\n  readonly tools?: readonly { readonly cmd?: string | null }[] | null\n  readonly obs?: string | null\n}\n\nexport interface DecodedTrajectory {\n  /** Executed commands in recorded order, each holding its OWN observation. */\n  readonly steps: readonly RecordedTrajectoryStep[]\n  /** Turns the scaffold rejected before anything ran. */\n  readonly formatErrorTurns: number\n  /**\n   * Executed commands whose text the dump dropped.\n   *\n   * The step stays in `steps` carrying the marker, because the run did execute\n   * a command there and a shorter list would misreport the trajectory. The\n   * marker is not a command, so any count above zero means this trajectory\n   * cannot be replayed: gate on it, or call `assertReplayableTrajectory`.\n   */\n  readonly elidedCommands: number\n  /** True when the run's last turn was the submit sentinel with no observation. */\n  readonly endedOnSubmitSentinel: boolean\n  /** Turns carrying an observation this grammar cannot read. */\n  readonly unreadableTurns: number\n}\n\n/**\n * Pair every recorded command with the observation of its own turn.\n *\n * Collecting commands and observations into two lists and zipping them is the\n * decode that looks right and is not: a turn the scaffold rejected carries an\n * observation of its own, so from the first such turn onward every observation\n * belongs to a different command than the one it is read against.\n *\n * A rejected turn executed nothing, so it is never a step — including when the\n * dump recorded a command for it. The scaffold rejects a turn holding several\n * bash blocks and runs none of them, while the dump keeps one of the blocks in\n * the command field. Replaying that field would execute a command the recorded\n * run did not, which is a worse corpus than a smaller one.\n *\n * A rejected turn is recognised by its observation, so a rejected turn whose\n * observation the dump elided is indistinguishable from an executed command\n * whose observation it elided. Both read as a step. Nothing in the dump\n * separates them, and the row-level defence is the share of unreadable exits a\n * caller admits: a row with no elided observation cannot hold this case at all.\n *\n * A trailing step that echoes the sentinel and nothing else, with no\n * observation, is dropped from `steps` and reported as `endedOnSubmitSentinel`.\n * The scaffold records an observation only when it hands one to the model, and\n * the sentinel ends the run, so the missing observation is the end of the\n * transcript rather than a gap in it. Echoing the sentinel changes no state, so\n * the recorded end state is the state the step before it left.\n *\n * A step that DID get an observation stays a step: the run continued past it.\n * So does a step that echoes the sentinel after doing real work — its state\n * change is part of the recorded end state, and with no observation its exit is\n * unknown, which `finalRecordedOutcome` reports rather than hides.\n */\nexport function decodeRecordedTurns(turns: readonly RecordedTrajectoryTurn[]): DecodedTrajectory {\n  const steps: RecordedTrajectoryStep[] = []\n  let formatErrorTurns = 0\n  let unreadableTurns = 0\n  for (const turn of turns) {\n    const command = turn.tools?.[0]?.cmd ?? null\n    const observation = turn.obs ?? null\n    const kind = classifyObservation(observation)\n    if (kind === 'format-error') {\n      formatErrorTurns += 1\n      continue\n    }\n    if (command === null) {\n      if (kind === 'unreadable' || kind === 'elided') unreadableTurns += 1\n      continue\n    }\n    steps.push({ step_id: steps.length + 1, action: command, observation })\n  }\n  const last = steps[steps.length - 1]\n  const endedOnSubmitSentinel =\n    last !== undefined && last.observation === null && isSubmitOnlyAction(last.action)\n  if (endedOnSubmitSentinel) steps.pop()\n  return {\n    steps,\n    formatErrorTurns,\n    elidedCommands: steps.filter((step) => isElidedField(step.action)).length,\n    endedOnSubmitSentinel,\n    unreadableTurns,\n  }\n}\n\n// ── The state a trajectory ended in ──────────────────────────────────\n\n/**\n * How the recorded run's last executed command ended.\n *\n * `killed` is a measured outcome, not a missing one: the environment stopped\n * the command at its bound and wrote a notice instead of an exit status.\n * `unreadable` names the observation kind that blocked the read, so a funnel\n * can report which shape cost it the row.\n */\nexport type RecordedFinalOutcome =\n  | { readonly kind: 'returncode'; readonly value: number }\n  | { readonly kind: 'killed' }\n  | { readonly kind: 'unreadable'; readonly reason: RecordedObservationKind }\n\n/**\n * The outcome of the last step, or `null` when the trajectory has no steps.\n *\n * Reads only the last step. `decodeRecordedTurns` has already removed the turns\n * that executed nothing, so the last step is the last command the run ran.\n */\nexport function finalRecordedOutcome(\n  steps: readonly RecordedTrajectoryStep[],\n): RecordedFinalOutcome | null {\n  const last = steps[steps.length - 1]\n  if (last === undefined) return null\n  const kind = classifyObservation(last.observation)\n  if (kind === 'command-result') {\n    return { kind: 'returncode', value: parseRecordedReturncode(last.observation)! }\n  }\n  if (kind === 'timeout') return { kind: 'killed' }\n  return { kind: 'unreadable', reason: kind }\n}\n\n/**\n * Steps whose recorded exit a replay cannot check.\n *\n * A killed step counts: the recording holds no exit status to compare a replay\n * against, so agreement on it cannot be measured either way.\n */\nexport function unreadableExitCount(steps: readonly RecordedTrajectoryStep[]): number {\n  return steps.filter((step) => classifyObservation(step.observation) !== 'command-result').length\n}\n\n/**\n * Throw unless every recorded command survived the dump.\n *\n * A replay executes `steps` verbatim, so one elision marker in an action means\n * the replay runs the literal two-to-four characters of the marker instead of\n * the command the run executed. The guard is here so a replayer needs one call\n * rather than a field check it can forget.\n */\nexport function assertReplayableTrajectory(decoded: DecodedTrajectory): void {\n  if (decoded.elidedCommands === 0) return\n  const markers = decoded.steps\n    .filter((step) => isElidedField(step.action))\n    .map((step) => step.action)\n  throw new Error(\n    `trajectory holds ${decoded.elidedCommands} command(s) the dump elided (${markers.slice(0, 5).join(', ')}); ` +\n      'no dictionary maps a marker back to its text, so this trajectory cannot be replayed',\n  )\n}\n","/**\n * The execution boundary replay runs across.\n *\n * A replay needs one thing from its environment: a session that runs a shell\n * command inside the trajectory's own image and reports the exit code and\n * output. That is the whole contract. Concrete backends — a sandbox platform\n * client, a docker exec, an SSH shell — live with the consumer that owns the\n * infrastructure, so this package depends on no sandbox client.\n */\n\nexport interface ReplayExecResult {\n  exitCode: number\n  stdout: string\n  stderr: string\n}\n\nexport interface ReplayExecSession {\n  exec(command: string, timeoutMs: number): Promise<ReplayExecResult>\n  close(): Promise<void>\n}\n\nexport interface ReplayExecBackend {\n  /** One fresh execution environment per call; the caller closes it. */\n  open(): Promise<ReplayExecSession>\n}\n\n/** Builds a backend pinned to one image. Callers that resolve images\n *  internally (batch, corpus wire, finding verification) take this instead of\n *  a backend, so every case runs against its own image. */\nexport type ReplayExecBackendFactory = (image: string) => ReplayExecBackend\n\n/**\n * mini-SWE runs every action as a fresh /bin/sh subshell from a fixed\n * workdir. Reproduce that exactly — and stay quote-proof for arbitrary\n * recorded actions — by piping the base64 of the action into `sh` after\n * cd-ing to the workdir. Exit code is sh's, i.e. the action's.\n */\nexport function wrapActionForExec(action: string, cwd: string): string {\n  const b64 = Buffer.from(action, 'utf8').toString('base64')\n  const quotedCwd = `'${cwd.replaceAll(\"'\", `'\\\\''`)}'`\n  return `cd ${quotedCwd} && printf %s ${b64} | base64 -d | sh`\n}\n"],"mappings":"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"}

package/dist/execution-tracks-CpgFPpS5.js.map

@@ -1 +1 @@
-{"version":3,"file":"execution-tracks-CpgFPpS5.js","names":[],"sources":["../src/trace/execution-tracks.ts"],"sourcesContent":["export interface ExecutionLane {\n  key: string\n  scopeKey: string\n  start: number | null\n  end: number | null\n}\n\n/** Assign lanes to serial tracks without joining concurrent or ambiguously timed work. */\nexport function executionTrackByLane(lanes: readonly ExecutionLane[]): Map<string, string> {\n  const unique = new Map<string, ExecutionLane>()\n  for (const lane of lanes) {\n    const existing = unique.get(lane.key)\n    if (existing && !sameLane(existing, lane)) {\n      throw new Error(`execution lane '${lane.key}' has conflicting scope or timing`)\n    }\n    unique.set(lane.key, lane)\n  }\n\n  const trackByLane = new Map<string, string>()\n  const lanesByScope = new Map<string, ExecutionLane[]>()\n  for (const lane of unique.values()) {\n    const scoped = lanesByScope.get(lane.scopeKey) ?? []\n    scoped.push(lane)\n    lanesByScope.set(lane.scopeKey, scoped)\n  }\n\n  for (const [scopeKey, scoped] of lanesByScope) {\n    if (scoped.some((lane) => lane.start === null && lane.end === null)) {\n      for (const lane of scoped) trackByLane.set(lane.key, trackId('lane', lane.key))\n      continue\n    }\n    const incompleteKeys = new Set<string>()\n    const boundarySet = new Set<number>()\n    for (const lane of scoped) {\n      if (lane.start !== null && lane.end !== null && lane.end > lane.start) continue\n      incompleteKeys.add(lane.key)\n      const boundary = lane.start ?? lane.end\n      if (boundary !== null) boundarySet.add(boundary)\n      trackByLane.set(lane.key, trackId('lane', lane.key))\n    }\n    const boundaries = [...boundarySet].sort((a, b) => a - b)\n    const completeBySegment = new Map<number, ExecutionLane[]>()\n    for (const lane of scoped) {\n      if (incompleteKeys.has(lane.key)) continue\n      const segment = upperBound(boundaries, lane.start!)\n      const nextBoundary = boundaries[segment]\n      if (nextBoundary !== undefined && nextBoundary < lane.end!) {\n        trackByLane.set(lane.key, trackId('lane', lane.key))\n        continue\n      }\n      const complete = completeBySegment.get(segment) ?? []\n      complete.push(lane)\n      completeBySegment.set(segment, complete)\n    }\n\n    let serialTrack = 0\n    for (const [, segment] of [...completeBySegment].sort(([a], [b]) => a - b)) {\n      const ordered = [...segment].sort(\n        (a, b) => a.start! - b.start! || a.end! - b.end! || a.key.localeCompare(b.key),\n      )\n      let component: ExecutionLane[] = []\n      let componentEnd = Number.NEGATIVE_INFINITY\n      const flush = () => {\n        if (component.length === 1) {\n          trackByLane.set(component[0]!.key, trackId('serial', scopeKey, serialTrack))\n        } else if (component.length > 1) {\n          for (const lane of component) trackByLane.set(lane.key, trackId('lane', lane.key))\n          serialTrack += 1\n        }\n        component = []\n        componentEnd = Number.NEGATIVE_INFINITY\n      }\n\n      for (const lane of ordered) {\n        if (component.length > 0 && lane.start! >= componentEnd) flush()\n        component.push(lane)\n        componentEnd = Math.max(componentEnd, lane.end!)\n      }\n      flush()\n      serialTrack += 1\n    }\n  }\n\n  return trackByLane\n}\n\nfunction sameLane(a: ExecutionLane, b: ExecutionLane): boolean {\n  return a.scopeKey === b.scopeKey && a.start === b.start && a.end === b.end\n}\n\nfunction trackId(kind: string, key: string, index?: number): string {\n  return JSON.stringify(index === undefined ? [kind, key] : [kind, key, index])\n}\n\nfunction upperBound(sorted: readonly number[], target: number): number {\n  let low = 0\n  let high = sorted.length\n  while (low < high) {\n    const middle = (low + high) >>> 1\n    if (sorted[middle]! <= target) low = middle + 1\n    else high = middle\n  }\n  return low\n}\n"],"mappings":"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"}
+{"version":3,"file":"execution-tracks-CpgFPpS5.js","names":[],"sources":["../src/trace/execution-tracks.ts"],"sourcesContent":["interface ExecutionLane {\n  key: string\n  scopeKey: string\n  start: number | null\n  end: number | null\n}\n\n/** Assign lanes to serial tracks without joining concurrent or ambiguously timed work. */\nexport function executionTrackByLane(lanes: readonly ExecutionLane[]): Map<string, string> {\n  const unique = new Map<string, ExecutionLane>()\n  for (const lane of lanes) {\n    const existing = unique.get(lane.key)\n    if (existing && !sameLane(existing, lane)) {\n      throw new Error(`execution lane '${lane.key}' has conflicting scope or timing`)\n    }\n    unique.set(lane.key, lane)\n  }\n\n  const trackByLane = new Map<string, string>()\n  const lanesByScope = new Map<string, ExecutionLane[]>()\n  for (const lane of unique.values()) {\n    const scoped = lanesByScope.get(lane.scopeKey) ?? []\n    scoped.push(lane)\n    lanesByScope.set(lane.scopeKey, scoped)\n  }\n\n  for (const [scopeKey, scoped] of lanesByScope) {\n    if (scoped.some((lane) => lane.start === null && lane.end === null)) {\n      for (const lane of scoped) trackByLane.set(lane.key, trackId('lane', lane.key))\n      continue\n    }\n    const incompleteKeys = new Set<string>()\n    const boundarySet = new Set<number>()\n    for (const lane of scoped) {\n      if (lane.start !== null && lane.end !== null && lane.end > lane.start) continue\n      incompleteKeys.add(lane.key)\n      const boundary = lane.start ?? lane.end\n      if (boundary !== null) boundarySet.add(boundary)\n      trackByLane.set(lane.key, trackId('lane', lane.key))\n    }\n    const boundaries = [...boundarySet].sort((a, b) => a - b)\n    const completeBySegment = new Map<number, ExecutionLane[]>()\n    for (const lane of scoped) {\n      if (incompleteKeys.has(lane.key)) continue\n      const segment = upperBound(boundaries, lane.start!)\n      const nextBoundary = boundaries[segment]\n      if (nextBoundary !== undefined && nextBoundary < lane.end!) {\n        trackByLane.set(lane.key, trackId('lane', lane.key))\n        continue\n      }\n      const complete = completeBySegment.get(segment) ?? []\n      complete.push(lane)\n      completeBySegment.set(segment, complete)\n    }\n\n    let serialTrack = 0\n    for (const [, segment] of [...completeBySegment].sort(([a], [b]) => a - b)) {\n      const ordered = [...segment].sort(\n        (a, b) => a.start! - b.start! || a.end! - b.end! || a.key.localeCompare(b.key),\n      )\n      let component: ExecutionLane[] = []\n      let componentEnd = Number.NEGATIVE_INFINITY\n      const flush = () => {\n        if (component.length === 1) {\n          trackByLane.set(component[0]!.key, trackId('serial', scopeKey, serialTrack))\n        } else if (component.length > 1) {\n          for (const lane of component) trackByLane.set(lane.key, trackId('lane', lane.key))\n          serialTrack += 1\n        }\n        component = []\n        componentEnd = Number.NEGATIVE_INFINITY\n      }\n\n      for (const lane of ordered) {\n        if (component.length > 0 && lane.start! >= componentEnd) flush()\n        component.push(lane)\n        componentEnd = Math.max(componentEnd, lane.end!)\n      }\n      flush()\n      serialTrack += 1\n    }\n  }\n\n  return trackByLane\n}\n\nfunction sameLane(a: ExecutionLane, b: ExecutionLane): boolean {\n  return a.scopeKey === b.scopeKey && a.start === b.start && a.end === b.end\n}\n\nfunction trackId(kind: string, key: string, index?: number): string {\n  return JSON.stringify(index === undefined ? [kind, key] : [kind, key, index])\n}\n\nfunction upperBound(sorted: readonly number[], target: number): number {\n  let low = 0\n  let high = sorted.length\n  while (low < high) {\n    const middle = (low + high) >>> 1\n    if (sorted[middle]! <= target) low = middle + 1\n    else high = middle\n  }\n  return low\n}\n"],"mappings":"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"}

package/dist/experiment/index.d.ts

@@ -1,10 +1,9 @@
-import { c as ValidationError, r as CaptureIntegrityError } from "../errors-DEE6u6ot.js";
 import { n as bonferroni, r as holm, t as benjaminiHochberg } from "../multiplicity-DIWHvysC.js";
-import { $ as paretoSignificanceGate, A as PairArmsOptions, At as EProcess, B as PowerPreflight, C as hashJson, Ct as FinalEvidenceError, Dt as FinalEvidenceRecord, E as verifyManifest, Et as FinalEvidenceOutcome, Gt as pairedRiskDifferenceScore, H as powerPreflight, K as EvidenceVector, L as comparePairedArms, Lt as ProportionInterval, Mt as EProcessState, N as PairedArmRow, Nt as EProcessStep, O as MatchedPair, Ot as FinalEvidenceReservation, Pt as eProcess, Q as paretoPolicy, R as pairArms, S as evaluateHypothesis, St as FinalEvidenceConflictError, T as signManifest, Tt as FinalEvidenceMeasurement, Ut as pairedRiskDifference, V as PowerPreflightOptions, Vt as mcnemar, Wt as pairedRiskDifferenceExact, X as PromotionPolicy, Z as buildEvidenceVector, _ as sequentialPairedGate, at as createCampaignEvidenceReceipt, b as SignedManifest, c as pairHoldout, ct as EvidenceAuthority, d as SequentialDecision, dt as EvidenceReceipt, f as SequentialObservation, ft as EvidenceReceiptVerification, g as sequentialDecide, ht as verifyEvidenceReceipt, i as PairedHoldout, it as CampaignEvidenceContext, j as PairArmsResult, jt as EProcessOptions, kt as openFinalEvidenceLedger, lt as EvidenceAuthorityKind, m as SequentialPairedGateOptions, mt as isIndependentEvidence, n as HeldoutSignificance, ot as CreateEvidenceReceiptInput, p as SequentialPairedGate, pt as createEvidenceReceipt, qt as wilson, r as HeldoutSignificanceOptions, s as heldoutSignificance, st as EVIDENCE_RECEIPT_VERSION, ut as EvidenceBinding, v as HypothesisManifest, w as manifestContentDigest, wt as FinalEvidenceLedger, x as SignedManifestAlgo, y as HypothesisResult, z as pairRunRecords } from "../statistical-heldout-CYpGaoDH.js";
-import { c as BOOTSTRAP_GATE_MIN_N, d as PairedBootstrapResult, h as pairedBootstrap, u as PairedBootstrapOptions } from "../paired-promotion-decision-DPKz8ZnF.js";
+import { At as EProcessStep, B as powerPreflight, Bt as pairedRiskDifferenceScore, C as signManifest, Ct as FinalEvidenceOutcome, Dt as EProcess, E as MatchedPair, Et as openFinalEvidenceLedger, F as comparePairedArms, Ht as wilson, I as pairArms, J as PromotionPolicy, L as pairRunRecords, Lt as mcnemar, O as PairArmsOptions, Ot as EProcessOptions, Pt as ProportionInterval, R as PowerPreflight, Rt as pairedRiskDifference, S as manifestContentDigest, St as FinalEvidenceMeasurement, Tt as FinalEvidenceReservation, W as EvidenceVector, X as paretoPolicy, Y as buildEvidenceVector, Z as paretoSignificanceGate, _ as HypothesisManifest, at as EvidenceAuthority, b as SignedManifestAlgo, bt as FinalEvidenceError, ct as EvidenceReceipt, d as SequentialObservation, dt as isIndependentEvidence, f as SequentialPairedGate, ft as verifyEvidenceReceipt, g as sequentialPairedGate, h as sequentialDecide, i as PairedHoldout, it as CreateEvidenceReceiptInput, j as PairedArmRow, jt as eProcess, k as PairArmsResult, kt as EProcessState, lt as EvidenceReceiptVerification, n as HeldoutSignificance, nt as CampaignEvidenceContext, o as heldoutSignificance, ot as EvidenceAuthorityKind, p as SequentialPairedGateOptions, r as HeldoutSignificanceOptions, rt as createCampaignEvidenceReceipt, s as pairHoldout, st as EvidenceBinding, u as SequentialGateDecision, ut as createEvidenceReceipt, v as HypothesisResult, w as verifyManifest, wt as FinalEvidenceRecord, x as hashJson, xt as FinalEvidenceLedger, y as SignedManifest, yt as FinalEvidenceConflictError, z as PowerPreflightOptions, zt as pairedRiskDifferenceExact } from "../statistical-heldout-C9AbgREN.js";
+import { c as BOOTSTRAP_GATE_MIN_N, l as PairedBootstrapOptions, m as pairedBootstrap, u as PairedBootstrapResult } from "../paired-promotion-decision-CQMJ5xGN.js";
 import { a as requiredPairedSampleSize, i as pairedMde, n as mcnemarPower, o as requiredSampleSize, r as mcnemarRequiredN, t as mulberry32 } from "../random-DGEyr3zG.js";
 import { at as summarizeEvaluationUnits, it as defineEvaluationClaim, nt as EvaluationClaim, rt as EvaluationUnitSummary } from "../search-ledger-types-p2xKfiDJ.js";
-import { a as PairedEvalueStep, d as sequentialCrossingHorizon, i as PairedEvalueSequence, o as SequentialCrossingHorizon, r as PairedEvalueOptions, s as SequentialCrossingHorizonOptions, u as pairedEvalueSequence } from "../sequential-BhsrMupG.js";
+import { a as PairedEvalueStep, i as PairedEvalueSequence, o as SequentialCrossingHorizon, r as PairedEvalueOptions, s as SequentialCrossingHorizonOptions, u as pairedEvalueSequence } from "../sequential-KwGspfeR.js";
 import { a as JsonValue, i as EvidenceRecord, n as IntervalSpec, r as computeInterval, t as ComputedInterval } from "../interval-ohuOJurX.js";
 import { z } from "zod";
 //#region src/experiment/ast/predicate.d.ts
@@ -33,8 +32,6 @@ type Predicate = {
 };
 /** Read a dot-separated field path. Missing segments yield `undefined`. */
 export declare function readField(record: EvidenceRecord, path: string): unknown;
-/** Evaluate a predicate against one evidence record. */
-export declare function evaluatePredicate(predicate: Predicate, record: EvidenceRecord): boolean;
 //#endregion
 //#region src/experiment/ast/validity.d.ts
 /** A registered control that must exist before a class of verdicts is read. */
@@ -74,40 +71,11 @@ type ValidityGate = {
   op: 'basename-eq';
   onFail: 'abort';
 };
-interface GateResult {
+interface ValidityGateResult {
   id: string;
   passed: boolean;
   evidence: JsonValue;
 }
-/**
- * Replicate-flip counting over graded states. A state whose replicates split
- * between pass and fail is flipping; its flip rate is the minority share.
- */
-export declare function evaluateOracleDeterminismGate(id: string, gate: Extract<ValidityGate, {
-  kind: 'oracle-determinism';
-}>, repsByState: Record<string, readonly boolean[]>): GateResult;
-/**
- * Join two population snapshots on `joinOn` and compare the registered fields.
- * Only rows present in both snapshots are compared; a presence change is a
- * different failure and needs its own gate.
- */
-export declare function evaluatePopulationReproducibilityGate(id: string, gate: Extract<ValidityGate, {
-  kind: 'population-reproducibility';
-}>, populations: {
-  left: readonly EvidenceRecord[];
-  right: readonly EvidenceRecord[];
-}): GateResult;
-/** The registered claim about provenance must hold on the provenance record. */
-export declare function evaluateProvenanceGate(id: string, gate: Extract<ValidityGate, {
-  kind: 'provenance-assertion';
-}>, provenance: EvidenceRecord): GateResult;
-/** Final path segment equality between the pinned and the served identity. */
-export declare function evaluateIdentityGate(id: string, _gate: Extract<ValidityGate, {
-  kind: 'identity';
-}>, identities: {
-  pinned: string;
-  served: string;
-}): GateResult;
 /**
  * The design's power at minimumEffect must reach the registered target.
  * The curve must cover the registered effect grid exactly — a curve
@@ -118,7 +86,7 @@ export declare function evaluatePowerFloorGate(id: string, gate: Extract<Validit
 }>, curve: readonly {
   effect: number;
   power: number;
-}[]): GateResult;
+}[]): ValidityGateResult;
 //#endregion
 //#region src/experiment/ast/budget.d.ts
 /** Checks as prerequisites: any named gate failing refuses the spend. */
@@ -135,7 +103,6 @@ interface HaltOutcome {
   action: 'refuse-spend' | null;
   failedGates: string[];
 }
-export declare function evaluateHaltRule(halt: HaltRule, gates: readonly GateResult[]): HaltOutcome;
 /**
  * Spend schedules as data. `ledger` names every entry the ceiling counts, so
  * what the gate reads is registered, not improvised at gate time.
@@ -168,15 +135,6 @@ interface UniformPassSchedule {
   decisions: UniformPassDecision[];
   uniformN: number;
 }
-/**
- * Execute the uniform-pass schedule against measured pass costs. Pass 1 always
- * runs; each later pass runs only when the cumulative spend plus the last
- * measured pass cost stays at or under the registered ceiling. The registered
- * ledger is the pre-spend the ceiling counts.
- */
-export declare function runUniformPassBudget(rule: Extract<BudgetRule, {
-  kind: 'uniform-pass';
-}>, measuredPassCosts: readonly number[]): UniformPassSchedule;
 interface NLadderProjection {
   chosenN: number | null;
   projections: {
@@ -189,17 +147,6 @@ interface NLadderProjection {
     reason: string;
   };
 }
-/**
- * Walk the registered n-ladder and pick the first affordable step. When no
- * step fits the ceiling, the rule refuses and reports the projection instead
- * of shrinking the row set — "never subset rows" is the registered invariant.
- */
-export declare function projectNLadderBudget(rule: Extract<BudgetRule, {
-  kind: 'n-ladder';
-}>, measured: {
-  unitCostUsd: number;
-  rows: number;
-}): NLadderProjection;
 /** Arm budget matching as a refusal, not prose. Verified by `verifyMatchedBudgets`. */
 interface MatchedBudgetRule {
   measure: 'realized-tokens';
@@ -322,8 +269,6 @@ interface EstimandResult {
   numerator: number;
   denominator: number;
 }
-/** Compute an estimand over evidence rows. Pure; reads only registered fields. */
-export declare function computeEstimand(estimand: Estimand, rows: readonly EvidenceRecord[]): EstimandResult;
 //#endregion
 //#region src/experiment/ast/reissue.d.ts
 /** Carrier faults are reissued; model outcomes stand. Closed enumeration. */
@@ -333,12 +278,6 @@ interface ReissuePolicy {
   maxIssues: number;
 }
 type ReissueVerdict = 'reissue' | 'stands' | 'exhausted';
-/**
- * Classify one rollout event under the registered reissue policy. A carrier
- * event within the issue budget is reissued; a model outcome always stands;
- * a carrier event past `maxIssues` is exhausted and reported, never retried.
- */
-export declare function classifyReissue(policy: ReissuePolicy, event: string, issuesSoFar: number): ReissueVerdict;
 //#endregion
 //#region src/experiment/ast/selection.d.ts
 /**
@@ -389,28 +328,8 @@ type SelectionRule = {
     dir: 'asc' | 'desc';
   };
 };
-/**
- * Execute a selection rule.
- *
- * Round-robin walks groups in lexicographic order and takes ids in
- * within-group order until `take` ids are chosen. Filter-of keeps the ids of
- * `bases[rule.base]` whose record satisfies the predicate, in the registered
- * order. Ids absent from `records` are evaluated on their id alone (fields
- * derived from the id via `idFields`), so a sealed base outlives its source
- * records.
- */
-export declare function runSelectionRule(rule: SelectionRule, records: readonly EvidenceRecord[], options: {
-  /** Field carrying a row's identity. */
-  idField: string;
-  /** Sealed or previously-computed subsets, by name. */
-  bases?: Record<string, readonly string[]>;
-  /** Derive predicate-readable fields from a bare id when its record is absent. */
-  idFields?: (id: string) => EvidenceRecord;
-}): string[];
 //#endregion
 //#region src/experiment/budget.d.ts
-/** Arms whose realized budgets diverge past the registered tolerance. */
-export declare class MatchedBudgetError extends CaptureIntegrityError {}
 interface ArmRealizedBudget {
   armId: string;
   /** Realized prompt + completion tokens the arm actually consumed. */
@@ -440,8 +359,6 @@ export declare function verifyMatchedBudgets(rule: MatchedBudgetRule, arms: read
 export declare function assertMatchedBudgets(rule: MatchedBudgetRule, arms: readonly ArmRealizedBudget[]): MatchedBudgetVerdict;
 //#endregion
 //#region src/experiment/funnel.d.ts
-/** A funnel stage gained rows, double-counted them, or failed to reconcile. */
-export declare class FunnelIntegrityError extends CaptureIntegrityError {}
 interface FunnelStageCount {
   id: string;
   entering: number;
@@ -493,8 +410,6 @@ export declare function buildFunnel(input: {
     count: number;
   }[];
 }): ExperimentFunnel;
-/** A chain that does not add up is a broken denominator, so this throws. */
-export declare function assertFunnelReconciles(funnel: ExperimentFunnel): void;
 interface AdmissionExecution {
   funnel: ExperimentFunnel;
   survivors: EvidenceRecord[];
@@ -522,8 +437,6 @@ export declare function composeFunnels(first: ExperimentFunnel, second: Experime
 export declare function renderFunnelTable(funnel: ExperimentFunnel): string;
 //#endregion
 //#region src/experiment/define.d.ts
-/** A sealed experiment whose digest no longer matches its spec. */
-export declare class SealIntegrityError extends ValidationError {}
 interface ArmSpec {
   id: string;
   role: 'treatment' | 'control';
@@ -634,7 +547,7 @@ export declare function amendExperiment(sealed: SealedExperiment, amendment: {
 /** True when the supported seal matches its canonical spec. */
 export declare function verifySealedExperiment(sealed: SealedExperiment): Promise<boolean>;
 /** Evidence a gate executor consumes, discriminated to match the gate kind. */
-type GateEvidence = {
+type ExperimentGateEvidence = {
   kind: 'oracle-determinism';
   repsByState: Record<string, readonly boolean[]>;
 } | {
@@ -672,9 +585,9 @@ interface RegisteredExperiment {
     idField: string;
   }): string[];
   /** Evaluate a registered validity gate on evidence of the matching kind. */
-  gate(name: string, evidence: GateEvidence): GateResult;
+  gate(name: string, evidence: ExperimentGateEvidence): ValidityGateResult;
   /** Evaluate the registered halt rule over gate results. */
-  halt(gates: readonly GateResult[]): HaltOutcome;
+  halt(gates: readonly ValidityGateResult[]): HaltOutcome;
   /** Execute the registered uniform-pass budget schedule. */
   runUniformPassBudget(measuredPassCosts: readonly number[]): UniformPassSchedule;
   /** Project the registered n-ladder budget. */
@@ -758,24 +671,8 @@ export declare const evidenceRegistryRecordSchema: z.ZodObject<{
   notes: z.ZodOptional<z.ZodString>;
 }, z.core.$strict>;
 type EvidenceRegistryRecord = z.infer<typeof evidenceRegistryRecordSchema>;
-/** Parse one record; throws with the zod issue list on any violation. */
-export declare function parseEvidenceRegistryRecord(raw: unknown): EvidenceRegistryRecord;
-/**
- * Validate a set of records as one registry: every record parses, ids are
- * unique, and every `supersedes` target exists. Returns records sorted in
- * the registry's canonical order (trust ladder, then date desc, then id).
- */
-export declare function validateEvidenceRegistry(raws: readonly unknown[]): EvidenceRegistryRecord[];
-/**
- * Render the registry's human index from records. Deterministic: identical
- * records always produce identical output, so a byte diff against the
- * committed index is the freshness check. No clocks, no environment.
- */
-export declare function renderEvidenceIndex(raws: readonly unknown[]): string;
 //#endregion
 //#region src/experiment/power.d.ts
-/** A design refused at configuration time, before any spend. */
-export declare class DesignRefusalError extends ValidationError {}
 interface ClusteredPowerOptions {
   /** Rows per independent cluster, e.g. [6, 3, 3, 2]. */
   clusterSizes: number[];
@@ -1065,5 +962,5 @@ interface ProspectiveCanaryJoinInput {
  */
 export declare function joinProspectiveCanaryReceipts(input: ProspectiveCanaryJoinInput): CanaryObservation[];
 //#endregion
-export { type AdmissionExecution, type AdmissionPartition, type AdmissionRule, type AdmissionStage, type ArmRealizedBudget, type ArmSpec, BOOTSTRAP_GATE_MIN_N, type BudgetRule, type CampaignEvidenceContext, type CanaryArm, type CanaryAssignmentReceipt, type CanaryCohortReceipt, type CanaryCohortVerifier, type CanaryObservation, type CanaryRefusal, type ClusteredPowerOptions, type ClusteredPowerPoint, type ClusteredPowerRefusal, type ClusteredPowerResult, type ComputedInterval, type Condition, type CreateEvidenceReceiptInput, type DecisionBranch, type DecisionOutcome, type DecisionRule, type DerivedQuantities, type EProcess, type EProcessOptions, type EProcessState, type EProcessStep, EVIDENCE_RECEIPT_VERSION, type Estimand, type EstimandResult, type EvaluationClaim, type EvaluationUnitSummary, type EvidenceAuthority, type EvidenceAuthorityKind, type EvidenceBinding, type EvidenceDenominator, type EvidenceReceipt, type EvidenceReceiptVerification, type EvidenceRecord, type EvidenceRegistryRecord, type EvidenceState, type EvidenceVector, type ExperimentFunnel, type ExperimentSpec, FinalEvidenceConflictError, FinalEvidenceError, type FinalEvidenceLedger, type FinalEvidenceMeasurement, type FinalEvidenceOutcome, type FinalEvidenceRecord, type FinalEvidenceReservation, type FunnelPartitionCount, type FunnelStageCount, type FunnelStageInput, type GateEvidence, type GateResult, type HaltOutcome, type HaltRule, type HeldoutSignificance, type HeldoutSignificanceOptions, type HypothesisManifest, type HypothesisResult, type IntervalSpec, type JsonValue, type MatchedBudgetRule, type MatchedBudgetVerdict, type MatchedPair, type NLadderProjection, type Obligation, type OutcomeSpec, type PairArmsOptions, type PairArmsResult, type PairedArmRow, type PairedBootstrapOptions, type PairedBootstrapResult, type PairedEvalueOptions, type PairedEvalueSequence, type PairedEvalueStep, type PairedHoldout, type PowerPreflight, type PowerPreflightOptions, type Predicate, type PromotionPolicy, type ProportionInterval, type ProspectiveCanaryAssignment, type ProspectiveCanaryBilling, type ProspectiveCanaryExecution, type ProspectiveCanaryJoinInput, type ProspectiveCanaryOutcome, type RandomizedCanaryDecision, type RandomizedCanaryRule, type RegisteredExperiment, type ReissuePolicy, type ReissueVerdict, type SealAmendment, type SealedExperiment, type SealedRandomizedCanaryRule, type SeedDerivation, type SelectionRule, type SequentialCrossingHorizon, type SequentialCrossingHorizonOptions, type SequentialDecision, type SequentialObservation, type SequentialPairedGate, type SequentialPairedGateOptions, type SetExpr, type SignFlipFloor, type SignedManifest, type SignedManifestAlgo, type UniformPassDecision, type UniformPassSchedule, type ValidityGate, benjaminiHochberg, bonferroni, buildEvidenceVector, comparePairedArms, computeInterval, createCampaignEvidenceReceipt, createEvidenceReceipt, defineEvaluationClaim, eProcess, evaluateHypothesis, hashJson, heldoutSignificance, holm, isIndependentEvidence, manifestContentDigest, mcnemar, mcnemarPower, mcnemarRequiredN, mulberry32, openFinalEvidenceLedger, pairArms, pairHoldout, pairRunRecords, pairedBootstrap, pairedEvalueSequence, pairedMde, pairedRiskDifference, pairedRiskDifferenceExact, pairedRiskDifferenceScore, paretoPolicy, paretoSignificanceGate, powerPreflight, requiredPairedSampleSize, requiredSampleSize, sequentialCrossingHorizon, sequentialDecide, sequentialPairedGate, signManifest, summarizeEvaluationUnits, verifyEvidenceReceipt, verifyManifest, wilson };
+export { type AdmissionExecution, type AdmissionPartition, type AdmissionRule, type AdmissionStage, type ArmRealizedBudget, type ArmSpec, BOOTSTRAP_GATE_MIN_N, type BudgetRule, type CampaignEvidenceContext, type CanaryArm, type CanaryAssignmentReceipt, type CanaryCohortReceipt, type CanaryCohortVerifier, type CanaryObservation, type CanaryRefusal, type ClusteredPowerOptions, type ClusteredPowerPoint, type ClusteredPowerRefusal, type ClusteredPowerResult, type ComputedInterval, type Condition, type CreateEvidenceReceiptInput, type DecisionBranch, type DecisionOutcome, type DecisionRule, type DerivedQuantities, type EProcess, type EProcessOptions, type EProcessState, type EProcessStep, type Estimand, type EstimandResult, type EvaluationClaim, type EvaluationUnitSummary, type EvidenceAuthority, type EvidenceAuthorityKind, type EvidenceBinding, type EvidenceDenominator, type EvidenceReceipt, type EvidenceReceiptVerification, type EvidenceRecord, type EvidenceRegistryRecord, type EvidenceState, type EvidenceVector, type ExperimentFunnel, type ExperimentGateEvidence, type ExperimentSpec, FinalEvidenceConflictError, FinalEvidenceError, type FinalEvidenceLedger, type FinalEvidenceMeasurement, type FinalEvidenceOutcome, type FinalEvidenceRecord, type FinalEvidenceReservation, type FunnelPartitionCount, type FunnelStageCount, type FunnelStageInput, type HaltOutcome, type HaltRule, type HeldoutSignificance, type HeldoutSignificanceOptions, type HypothesisManifest, type HypothesisResult, type IntervalSpec, type JsonValue, type MatchedBudgetRule, type MatchedBudgetVerdict, type MatchedPair, type NLadderProjection, type Obligation, type OutcomeSpec, type PairArmsOptions, type PairArmsResult, type PairedArmRow, type PairedBootstrapOptions, type PairedBootstrapResult, type PairedEvalueOptions, type PairedEvalueSequence, type PairedEvalueStep, type PairedHoldout, type PowerPreflight, type PowerPreflightOptions, type Predicate, type PromotionPolicy, type ProportionInterval, type ProspectiveCanaryAssignment, type ProspectiveCanaryBilling, type ProspectiveCanaryExecution, type ProspectiveCanaryJoinInput, type ProspectiveCanaryOutcome, type RandomizedCanaryDecision, type RandomizedCanaryRule, type RegisteredExperiment, type ReissuePolicy, type ReissueVerdict, type SealAmendment, type SealedExperiment, type SealedRandomizedCanaryRule, type SeedDerivation, type SelectionRule, type SequentialCrossingHorizon, type SequentialCrossingHorizonOptions, type SequentialGateDecision, type SequentialObservation, type SequentialPairedGate, type SequentialPairedGateOptions, type SetExpr, type SignFlipFloor, type SignedManifest, type SignedManifestAlgo, type UniformPassDecision, type UniformPassSchedule, type ValidityGate, type ValidityGateResult, benjaminiHochberg, bonferroni, buildEvidenceVector, comparePairedArms, computeInterval, createCampaignEvidenceReceipt, createEvidenceReceipt, defineEvaluationClaim, eProcess, hashJson, heldoutSignificance, holm, isIndependentEvidence, manifestContentDigest, mcnemar, mcnemarPower, mcnemarRequiredN, mulberry32, openFinalEvidenceLedger, pairArms, pairHoldout, pairRunRecords, pairedBootstrap, pairedEvalueSequence, pairedMde, pairedRiskDifference, pairedRiskDifferenceExact, pairedRiskDifferenceScore, paretoPolicy, paretoSignificanceGate, powerPreflight, requiredPairedSampleSize, requiredSampleSize, sequentialDecide, sequentialPairedGate, signManifest, summarizeEvaluationUnits, verifyEvidenceReceipt, verifyManifest, wilson };
 //# sourceMappingURL=index.d.ts.map

package/dist/experiment/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","names":[],"sources":["../../src/experiment/ast/predicate.ts","../../src/experiment/ast/validity.ts","../../src/experiment/ast/budget.ts","../../src/experiment/ast/decision.ts","../../src/experiment/ast/estimand.ts","../../src/experiment/ast/reissue.ts","../../src/experiment/ast/selection.ts","../../src/experiment/budget.ts","../../src/experiment/funnel.ts","../../src/experiment/define.ts","../../src/experiment/evidence-record.ts","../../src/experiment/power.ts","../../src/experiment/randomized-canary.ts","../../src/experiment/prospective-canary-join.ts"],"mappings":"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"}
+{"version":3,"file":"index.d.ts","names":[],"sources":["../../src/experiment/ast/predicate.ts","../../src/experiment/ast/validity.ts","../../src/experiment/ast/budget.ts","../../src/experiment/ast/decision.ts","../../src/experiment/ast/estimand.ts","../../src/experiment/ast/reissue.ts","../../src/experiment/ast/selection.ts","../../src/experiment/budget.ts","../../src/experiment/funnel.ts","../../src/experiment/define.ts","../../src/experiment/evidence-record.ts","../../src/experiment/power.ts","../../src/experiment/randomized-canary.ts","../../src/experiment/prospective-canary-join.ts"],"mappings":"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CA;EACA,KAAK;;UAGU,0BAA0B;;EAEzC;EACA;;EAEA;EACA;;EAEA;;EAEA;;EAEA;EACA;EACA;EACA;;;UAIe;EACf;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;;EAEA;EACA;EACA;EACA;EACA;;EAEA;EACA;;EAEA;;EAEA;;EAEA;;EAEA;;;UAIe;EACf;EACA;EACA;EACA;EACA;EACA;EACA;EACA;;EAEA;EACA;EACA;EACA;EACA;;;KAIU,wBACV,SAAS,qBACT,UAAU;EAGN;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;;EAEA;EAAiB;;UAEN;EACf,MAAM;EACN;EACA;;KAGU;UASK;EACf;EACA;EACA;EACA;EACA;;EAEA;;EAEA;EACA;EACA;EACA;EACA;EACA;EACA;EACA,UAAU,OACR;IAEE;IACA;IACA;IACA;;EAGJ;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;IAAqB;IAAa;;EAClC;EACA;IAA0B;IAAa;;EACvC;;EAEA;EACA;EACA;EACA;EACA;EACA,SAAS;;EAET;;;wBAwBc,6BAA6B,eAAe;;wBA6B5C,kCAAkC,eAAe;;wBAiFjD,yBAAyB,MAAM,uBAAuB;;wBAOtD,uBACd,QAAQ,4BACR,QAAQ,qBACR,eAAe,qBACf,cAAc,uBACb;;;;UC3Sc,oCAAoC;EACnD;EACA;;;UAIe;EACf;EACA;EACA;EACA;EACA;;;UAIe;EACf;EACA;EACA;EACA;EACA;EACA;EACA;EACA;;;UAIe;EACf;EACA;EACA;EACA;EACA;EACA;;UAGe;;EAEf;EACA,QAAQ;;EAER;;EAEA;EACA,sBAAsB;EACtB,mBAAmB;EACnB,qBAAqB;EACrB,kBAAkB;;;;;;;wBA4DJ,8BACd,OAAO,6BACN"}