@tangle-network/agent-eval 0.216.1 → 0.218.1

package/dist/eval-campaign-90jeaCAI.js

@@ -1,343 +0,0 @@
-import { d as verifyAgentProfileCell, o as buildAgentProfileCell, p as hashJson } from "./agent-profile-cell-BK8mlqlq.js";
-import { c as validateRunRecord } from "./run-record-Boc5IUTp.js";
-import { t as researchReport } from "./summary-report-V_JACR4Y.js";
-import { t as TraceEmitter } from "./emitter-DbMXUIVP.js";
-import { t as FileSystemRawProviderSink } from "./raw-provider-sink-DoHz4JNG.js";
-import { n as assertRunCaptured, t as RunIntegrityError } from "./integrity-BXOsAb3i.js";
-//#region src/eval-campaign.ts
-/**
-* EvalCampaign — opinionated matrix runner that wires the four
-* capture-integrity directives by construction.
-*
-* The canonical benchmark shape — matrix runner → for each
-* (variant, scenario, seed) → start a TraceEmitter → call LLMs → end the
-* run → analyze — has a bug class at the integration boundary: raw
-* events not captured, route silently wrong, integrity not asserted,
-* analyst never run. The directives in `SKILL.md § Capture integrity`
-* are the mitigations.
-*
-* `EvalCampaign` is the structural fix — consumers don't wire the
-* integrity surface themselves; the campaign owns it. Specifically:
-*
-*   - constructs a per-run `TraceStore` and `RawProviderSink` via factories
-*   - builds the run's `ChatClient` through `chatFactory`, handing it the
-*     run's raw sink and trace context — a transport built any other way has
-*     no raw HTTP envelope, and `assertRunCaptured` says so
-*   - calls `assertRunCaptured` after every `endRun` and routes failures
-*     through a configurable policy (`throw` / `mark_failed` / `log`)
-*   - assembles per-run `RunRecord`s and runs `researchReport` at the end
-*     so the campaign artifact is launch-decision-grade by default
-*   - embeds the campaign fingerprint (a SHA-256 over the canonicalised
-*     run set) and optional `preregistrationHash` in the report
-*
-* The runner contract is intentionally narrow: produce a `CampaignRunOutcome`
-* given a fully-wired `CampaignRunContext`. Everything orchestration-shaped
-* lives in the campaign. This is the inversion-of-control point — consumers
-* stop writing matrix runners and start writing scenario-runners.
-*
-* Out of scope for v1 (tracked in `docs/research-report-methodology.md`):
-*
-*   - Distributed/cluster execution (concurrency is local async)
-*   - Adaptive sampling / sequential interim looks
-*   - Resume from partial state across crashes
-*   - LLM-call retry beyond what the caller's transport already does
-*/
-const DEFAULT_INTEGRITY = {
-	llmSpansMin: 1,
-	requireRawCoverageOfLlmSpans: true,
-	requireOutcome: true
-};
-async function runEvalCampaign(opts) {
-	if (opts.variants.length === 0) throw new Error("runEvalCampaign: variants must be non-empty.");
-	if (opts.scenarios.length === 0) throw new Error("runEvalCampaign: scenarios must be non-empty.");
-	const variantIds = /* @__PURE__ */ new Set();
-	for (const v of opts.variants) {
-		if (variantIds.has(v.id)) throw new Error(`runEvalCampaign: duplicate variant id "${v.id}".`);
-		variantIds.add(v.id);
-	}
-	const scenarioIds = /* @__PURE__ */ new Set();
-	for (const s of opts.scenarios) {
-		if (scenarioIds.has(s.scenarioId)) throw new Error(`runEvalCampaign: duplicate scenarioId "${s.scenarioId}".`);
-		scenarioIds.add(s.scenarioId);
-	}
-	if (opts.report?.comparator && !variantIds.has(opts.report.comparator)) throw new Error(`runEvalCampaign: report.comparator "${opts.report.comparator}" is not a configured variantId.`);
-	if (!opts.commitSha) throw new Error("runEvalCampaign: commitSha is required (every RunRecord needs it).");
-	const seeds = opts.seeds ?? [
-		0,
-		1,
-		2
-	];
-	const splitTag = opts.splitTag ?? "holdout";
-	const concurrency = Math.max(1, opts.concurrency ?? 1);
-	const integrity = {
-		...DEFAULT_INTEGRITY,
-		...opts.integrity ?? {}
-	};
-	const onIntegrityFailure = opts.onIntegrityFailure ?? "mark_failed";
-	const now = opts.now ?? (() => Date.now());
-	const executionRef = opts.executionRef ?? null;
-	const preregistrationHash = opts.preregistrationHash ?? null;
-	const rawSinkFactory = opts.rawSinkFactory ?? defaultRawSinkFactory(opts.workDir);
-	const campaignFingerprint = await hashJson({
-		campaignId: opts.campaignId,
-		variants: opts.variants.map((v) => v.id).sort(),
-		scenarios: opts.scenarios.map((s) => s.scenarioId).sort(),
-		seeds: [...seeds].sort((a, b) => a - b),
-		splitTag,
-		comparator: opts.report?.comparator ?? null,
-		executionRef,
-		preregistrationHash
-	});
-	const cells = [];
-	for (const variant of opts.variants) for (const scenario of opts.scenarios) for (const seed of seeds) cells.push({
-		variant,
-		scenario,
-		seed
-	});
-	const startedAt = new Date(now()).toISOString();
-	const runs = [];
-	const integrityReports = [];
-	const failedRuns = [];
-	let cursor = 0;
-	let aborting = false;
-	const genuineErrors = [];
-	const openRuns = /* @__PURE__ */ new Map();
-	async function worker() {
-		while (!aborting) {
-			const i = cursor++;
-			if (i >= cells.length) return;
-			const cell = cells[i];
-			try {
-				const result = await runOneCell(cell);
-				runs.push(result.record);
-				integrityReports.push(result.integrity);
-			} catch (err) {
-				if (err instanceof CellExecutionError) {
-					failedRuns.push(err.failed);
-					if (err.integrity) integrityReports.push(err.integrity);
-				} else {
-					genuineErrors.push(err);
-					aborting = true;
-					return;
-				}
-			}
-		}
-	}
-	async function runOneCell(cell) {
-		const runId = (opts.runId ?? defaultRunId)({
-			campaignId: opts.campaignId,
-			runId: "",
-			variantId: cell.variant.id,
-			scenarioId: cell.scenario.scenarioId,
-			seed: cell.seed
-		});
-		const factoryParams = {
-			campaignId: opts.campaignId,
-			runId,
-			variantId: cell.variant.id,
-			scenarioId: cell.scenario.scenarioId,
-			seed: cell.seed
-		};
-		const store = opts.storeFactory(factoryParams);
-		const rawSink = rawSinkFactory(factoryParams);
-		const emitter = new TraceEmitter(store, {
-			runId,
-			now: opts.now,
-			onRunComplete: opts.onRunComplete
-		});
-		openRuns.set(runId, emitter);
-		const chat = opts.chatFactory({
-			rawSink,
-			runId
-		});
-		const ctx = {
-			runId,
-			experimentId: opts.campaignId,
-			variant: cell.variant.payload,
-			variantId: cell.variant.id,
-			scenarioId: cell.scenario.scenarioId,
-			scenarioTags: cell.scenario.tags ?? {},
-			seed: cell.seed,
-			splitTag,
-			emitter,
-			store,
-			rawSink,
-			chat
-		};
-		try {
-			const wallStart = now();
-			let outcome;
-			try {
-				outcome = await opts.runner(ctx);
-			} catch (err) {
-				const message = err instanceof Error ? err.message : String(err);
-				await finalizeAbort(emitter, runId, message);
-				throw new CellExecutionError({
-					runId,
-					variantId: cell.variant.id,
-					scenarioId: cell.scenario.scenarioId,
-					seed: cell.seed,
-					reason: "runner_threw",
-					error: message
-				});
-			}
-			const wallMs = now() - wallStart;
-			const integrityReport = await assertRunCaptured(store, runId, {
-				...integrity,
-				rawSink
-			});
-			if (!integrityReport.ok) switch (onIntegrityFailure) {
-				case "throw": throw new RunIntegrityError(integrityReport);
-				case "mark_failed": throw new CellExecutionError({
-					runId,
-					variantId: cell.variant.id,
-					scenarioId: cell.scenario.scenarioId,
-					seed: cell.seed,
-					reason: "integrity_failed",
-					error: integrityReport.issues.map((i) => i.code).join(", ")
-				}, integrityReport);
-			}
-			const recordOutcome = { raw: outcome.raw ?? {} };
-			if (splitTag === "holdout") recordOutcome.holdoutScore = outcome.score;
-			else recordOutcome.searchScore = outcome.score;
-			if (outcome.judgeScores !== void 0) recordOutcome.judgeScores = outcome.judgeScores;
-			const record = {
-				runId,
-				experimentId: opts.campaignId,
-				candidateId: cell.variant.id,
-				seed: cell.seed,
-				model: outcome.model,
-				promptHash: outcome.promptHash,
-				configHash: outcome.configHash,
-				commitSha: opts.commitSha,
-				wallMs,
-				costUsd: outcome.costUsd,
-				costProvenance: outcome.costProvenance,
-				tokenUsage: outcome.tokenUsage,
-				terminalOutcome: "succeeded",
-				judgeMetadata: outcome.judgeMetadata,
-				outcome: recordOutcome,
-				...outcome.failureClass ? { failureClass: outcome.failureClass } : {},
-				failureMode: outcome.failureMode,
-				splitTag,
-				scenarioId: cell.scenario.scenarioId
-			};
-			const profileSource = outcome.agentProfile ?? (typeof opts.agentProfile === "function" ? await opts.agentProfile({
-				campaignId: opts.campaignId,
-				runId,
-				variantId: cell.variant.id,
-				scenarioId: cell.scenario.scenarioId,
-				seed: cell.seed,
-				variant: cell.variant.payload,
-				scenarioTags: cell.scenario.tags ?? {}
-			}) : opts.agentProfile);
-			if (profileSource !== void 0) {
-				const agentProfile = await resolveAgentProfileCell(profileSource);
-				assertAgentProfileMatchesRun(agentProfile, outcome.model, outcome.promptHash);
-				record.agentProfile = agentProfile;
-			}
-			return {
-				record: validateRunRecord(record),
-				integrity: integrityReport
-			};
-		} finally {
-			openRuns.delete(runId);
-		}
-	}
-	const workers = Array.from({ length: Math.min(concurrency, cells.length) }, () => worker());
-	await Promise.allSettled(workers);
-	for (const [runId, emitter] of openRuns) await finalizeAbort(emitter, runId, "campaign aborted: genuine error in a sibling run");
-	openRuns.clear();
-	if (genuineErrors.length > 0) throw genuineErrors.length === 1 ? genuineErrors[0] : new AggregateError(genuineErrors, `runEvalCampaign: ${genuineErrors.length} runs failed with genuine (non-run-level) errors`);
-	let report;
-	if (opts.report) {
-		const reportOpts = {
-			...opts.report,
-			comparator: opts.report.comparator,
-			split: splitTag === "dev" ? "search" : splitTag,
-			generatedAt: new Date(now()).toISOString(),
-			preregistrationHash: preregistrationHash ?? void 0
-		};
-		report = await researchReport(runs, reportOpts);
-	}
-	const endedAt = new Date(now()).toISOString();
-	return {
-		campaignId: opts.campaignId,
-		campaignFingerprint,
-		preregistrationHash,
-		runs,
-		integrityReports,
-		failedRuns,
-		report,
-		startedAt,
-		endedAt
-	};
-}
-var CellExecutionError = class extends Error {
-	failed;
-	integrity;
-	constructor(failed, integrity) {
-		super(`cell ${failed.variantId}/${failed.scenarioId}@${failed.seed} failed: ${failed.reason}`);
-		this.failed = failed;
-		this.integrity = integrity;
-	}
-};
-/**
-* Abort a run whose owning work threw or was orphaned by a sibling's genuine
-* error, finalizing the emitter so hooks fire and the store records a terminal
-* status. Safe to call unconditionally: it only aborts runs that are still
-* `running`. Two no-op cases are intentional and benign:
-*
-*   - the run was never started (absent from the store) — nothing to finalize
-*   - the run is already terminal (`completed` / `failed` / `aborted`) —
-*     finalizing again would overwrite the real outcome (e.g. flip a passed run
-*     to `aborted` with `{ pass: false, notes: reason }`), so we leave it alone
-*
-* Any OTHER failure of the store read or the abort write (disk full, FS fault,
-* backend down) is a genuine diagnostic and propagates rather than being
-* swallowed.
-*/
-async function finalizeAbort(emitter, runId, reason) {
-	const existing = await emitter.traceStore.getRun(runId);
-	if (existing === void 0) return;
-	if (existing.status !== "running") return;
-	const droppedBefore = emitter.captureStats().dropped;
-	await emitter.abortRun(reason);
-	const after = emitter.captureStats();
-	if (after.dropped > droppedBefore) throw new Error(`finalizeAbort: run ${runId} could not be finalized: ${after.lastError}`);
-}
-function defaultRawSinkFactory(workDir) {
-	return (params) => {
-		if (!workDir) throw new Error("runEvalCampaign: rawSinkFactory not supplied and workDir not set. Pass either to enable raw provider capture, or pass `new NoopRawProviderSink()` via rawSinkFactory to opt out explicitly.");
-		return new FileSystemRawProviderSink({ dir: `${workDir}/raw-events/${params.runId}` });
-	};
-}
-async function resolveAgentProfileCell(input) {
-	if (isAgentProfileCell(input)) {
-		if (!await verifyAgentProfileCell(input)) throw new Error(`runEvalCampaign: agentProfile.cellId does not match its content`);
-		return input;
-	}
-	return buildAgentProfileCell(input);
-}
-function isAgentProfileCell(input) {
-	return "schemaVersion" in input && "cellId" in input;
-}
-function assertAgentProfileMatchesRun(profile, model, promptHash) {
-	if (profile.model !== void 0 && profile.model !== model) throw new Error(`runEvalCampaign: agentProfile.model "${profile.model}" does not match outcome.model "${model}"`);
-	if (profile.promptHash !== void 0 && profile.promptHash !== promptHash) throw new Error(`runEvalCampaign: agentProfile.promptHash "${profile.promptHash}" does not match outcome.promptHash "${promptHash}"`);
-}
-function defaultRunId(params) {
-	const base = `${params.campaignId}::${params.variantId}::${params.scenarioId}::${params.seed}`;
-	let h1 = 2166136261;
-	let h2 = 305419896;
-	for (let i = 0; i < base.length; i++) {
-		const c = base.charCodeAt(i);
-		h1 = Math.imul(h1 ^ c, 16777619) >>> 0;
-		h2 = Math.imul(h2 ^ c, 2654435761) >>> 0;
-	}
-	return `run-${h1.toString(16).padStart(8, "0")}${h2.toString(16).padStart(8, "0")}`;
-}
-//#endregion
-export { runEvalCampaign as t };
-
-//# sourceMappingURL=eval-campaign-90jeaCAI.js.map

package/dist/eval-campaign-90jeaCAI.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"eval-campaign-90jeaCAI.js","names":[],"sources":["../src/eval-campaign.ts"],"sourcesContent":["/**\n * EvalCampaign — opinionated matrix runner that wires the four\n * capture-integrity directives by construction.\n *\n * The canonical benchmark shape — matrix runner → for each\n * (variant, scenario, seed) → start a TraceEmitter → call LLMs → end the\n * run → analyze — has a bug class at the integration boundary: raw\n * events not captured, route silently wrong, integrity not asserted,\n * analyst never run. The directives in `SKILL.md § Capture integrity`\n * are the mitigations.\n *\n * `EvalCampaign` is the structural fix — consumers don't wire the\n * integrity surface themselves; the campaign owns it. Specifically:\n *\n *   - constructs a per-run `TraceStore` and `RawProviderSink` via factories\n *   - builds the run's `ChatClient` through `chatFactory`, handing it the\n *     run's raw sink and trace context — a transport built any other way has\n *     no raw HTTP envelope, and `assertRunCaptured` says so\n *   - calls `assertRunCaptured` after every `endRun` and routes failures\n *     through a configurable policy (`throw` / `mark_failed` / `log`)\n *   - assembles per-run `RunRecord`s and runs `researchReport` at the end\n *     so the campaign artifact is launch-decision-grade by default\n *   - embeds the campaign fingerprint (a SHA-256 over the canonicalised\n *     run set) and optional `preregistrationHash` in the report\n *\n * The runner contract is intentionally narrow: produce a `CampaignRunOutcome`\n * given a fully-wired `CampaignRunContext`. Everything orchestration-shaped\n * lives in the campaign. This is the inversion-of-control point — consumers\n * stop writing matrix runners and start writing scenario-runners.\n *\n * Out of scope for v1 (tracked in `docs/research-report-methodology.md`):\n *\n *   - Distributed/cluster execution (concurrency is local async)\n *   - Adaptive sampling / sequential interim looks\n *   - Resume from partial state across crashes\n *   - LLM-call retry beyond what the caller's transport already does\n */\n\nimport {\n  type AgentProfileCell,\n  type AgentProfileCellInput,\n  buildAgentProfileCell,\n  verifyAgentProfileCell,\n} from './agent-profile-cell'\nimport type { ChatClient } from './analyst/chat-client'\nimport { hashJson } from './pre-registration'\nimport type {\n  JudgeScoresRecord,\n  RunCostProvenance,\n  RunJudgeMetadata,\n  RunOutcome,\n  RunRecord,\n  RunSplitTag,\n  RunTaskFailure,\n  RunTokenUsage,\n} from './run-record'\nimport { validateRunRecord } from './run-record'\nimport { type ResearchReport, type ResearchReportOptions, researchReport } from './summary-report'\nimport type { RunCompleteHook } from './trace/emitter'\nimport { TraceEmitter } from './trace/emitter'\nimport {\n  assertRunCaptured,\n  RunIntegrityError,\n  type RunIntegrityExpectations,\n  type RunIntegrityReport,\n} from './trace/integrity'\nimport { FileSystemRawProviderSink, type RawProviderSink } from './trace/raw-provider-sink'\nimport type { TraceStore } from './trace/store'\n\n// ── Public types ─────────────────────────────────────────────────────────\n\nexport interface CampaignVariant<V> {\n  id: string\n  payload: V\n}\n\nexport interface CampaignScenario {\n  scenarioId: string\n  /** Free-form metadata propagated to runs and reports. */\n  tags?: Record<string, string>\n}\n\nexport interface CampaignRunContext<V> {\n  /** Stable run id. The campaign generates this; the runner does not. */\n  runId: string\n  /** Logical experiment id (campaignId by default; overridable per-run via opts). */\n  experimentId: string\n  variant: V\n  variantId: string\n  scenarioId: string\n  scenarioTags: Record<string, string>\n  seed: number\n  splitTag: RunSplitTag\n  /**\n   * The TraceEmitter for this run, with `onRunComplete` hooks pre-wired\n   * (analyst auto-execution if configured, plus integrity check). The\n   * runner MUST call `emitter.startRun` before doing any work and either\n   * `emitter.endRun` or `emitter.abortRun` before returning.\n   */\n  emitter: TraceEmitter\n  store: TraceStore\n  rawSink: RawProviderSink\n  /**\n   * The run's model transport, built by `chatFactory` with this run's\n   * `rawSink` and `runId` already bound.\n   */\n  chat: ChatClient\n}\n\n/** What the campaign binds into the run's transport. */\nexport interface CampaignChatWiring {\n  /**\n   * Raw provider sink for this run. Bind it into the transport: the campaign's\n   * integrity check requires every LLM span to carry a matching raw request\n   * event, so a transport built without it fails `assertRunCaptured`.\n   */\n  rawSink: RawProviderSink\n  runId: string\n}\n\ninterface CampaignRunOutcomeFields {\n  /** Did the run pass? Mirrors `RunOutcome.pass` semantics. */\n  pass: boolean\n  /** Score for the run on its split. Maps to `searchScore` or `holdoutScore`. */\n  score: number\n  /** Cost in USD, or null when the runner could not capture it. */\n  costUsd: number | null\n  /** Source of the cost amount. */\n  costProvenance: RunCostProvenance\n  tokenUsage: RunTokenUsage\n  /** Snapshot model id (e.g. `claude-sonnet-4-6@2025-04-15`). */\n  model: string\n  /** sha256 of the effective prompt sent to the model. */\n  promptHash: string\n  /** sha256 of the effective config (model, temperature, tools, judges, splits). */\n  configHash: string\n  /** Optional extra numeric metrics to land in `outcome.raw`. */\n  raw?: Record<string, number>\n  /** Optional judge metadata when a judge was used. */\n  judgeMetadata?: RunJudgeMetadata\n  /**\n   * Optional per-judge / per-dim breakdown for ensemble-judged runs.\n   * Propagated to `outcome.judgeScores` on the resulting `RunRecord`.\n   * Single-judge or scalar-only runs leave this unset.\n   */\n  judgeScores?: JudgeScoresRecord\n  /**\n   * Agent profile cell observed by the runner. When supplied, it overrides\n   * `EvalCampaignOptions.agentProfile` for this run and must match the\n   * outcome's `model` and `promptHash`.\n   */\n  agentProfile?: AgentProfileCell | AgentProfileCellInput\n}\n\n/** Campaign result with the same task-failure invariant as `RunRecord`. */\nexport type CampaignRunOutcome = CampaignRunOutcomeFields & RunTaskFailure\n\nexport type CampaignRunner<V> = (ctx: CampaignRunContext<V>) => Promise<CampaignRunOutcome>\n\nexport type CampaignIntegrityPolicy = 'throw' | 'mark_failed' | 'log'\n\nexport interface EvalCampaignOptions<V> {\n  /**\n   * Stable id for the campaign. Used as the default `experimentId` on\n   * every run, and folded into the campaign fingerprint.\n   */\n  campaignId: string\n  variants: CampaignVariant<V>[]\n  scenarios: CampaignScenario[]\n  /** Default `[0, 1, 2]`. */\n  seeds?: number[]\n  /** Default `'holdout'` — the split that anchors a launch decision. */\n  splitTag?: RunSplitTag\n  /** Git SHA the campaign is run against. Mandatory; `RunRecord` rejects unset. */\n  commitSha: string\n  /**\n   * Build the model transport for one run. agent-eval executes no paid model:\n   * the caller owns the transport and the credential never enters this\n   * package. The campaign calls this once per run and passes the run's raw\n   * provider sink and `runId`, so a transport that binds them captures the\n   * raw HTTP envelope `assertRunCaptured` checks for.\n   */\n  chatFactory: (wiring: CampaignChatWiring) => ChatClient\n  /**\n   * Caller-declared identity of the execution route, folded into the campaign\n   * fingerprint so two campaigns run against different endpoints do not share\n   * one identity. agent-eval no longer knows the endpoint; the owner of\n   * execution names it.\n   */\n  executionRef?: string\n  /**\n   * Per-run TraceStore factory. Common shape: a fresh store per run keyed\n   * on `runId`. Implementations that share a store across the campaign\n   * are valid — the campaign only writes through `emitter`.\n   */\n  storeFactory: (params: CampaignFactoryParams) => TraceStore\n  /**\n   * Per-run RawProviderSink factory. Defaults to `FileSystemRawProviderSink`\n   * rooted at `${workDir}/raw-events/${runId}` if `workDir` is supplied;\n   * otherwise required. Forensic capture is non-negotiable in a campaign\n   * run — pass `NoopRawProviderSink` explicitly if you want to opt out.\n   */\n  rawSinkFactory?: (params: CampaignFactoryParams) => RawProviderSink\n  /**\n   * Filesystem root for default `rawSinkFactory`. Ignored if\n   * `rawSinkFactory` is supplied.\n   */\n  workDir?: string\n  /**\n   * Extra `onRunComplete` hooks the campaign appends (after its own\n   * integrity-check hook). Pass `traceAnalystOnRunComplete(...)` here.\n   */\n  onRunComplete?: RunCompleteHook[]\n  /**\n   * Per-run integrity expectations. Defaults to:\n   *   `{ llmSpansMin: 1, requireRawCoverageOfLlmSpans: true, requireOutcome: true }`.\n   * Override (e.g. `{ llmSpansMin: 0 }`) for runs that don't call LLMs.\n   */\n  integrity?: RunIntegrityExpectations\n  /** Behaviour when integrity fails. Default `'mark_failed'`. */\n  onIntegrityFailure?: CampaignIntegrityPolicy\n  /**\n   * Per-run runner. Receives a fully-wired context; produces an outcome\n   * the campaign converts into a `RunRecord`.\n   */\n  runner: CampaignRunner<V>\n  /**\n   * If set, the campaign computes `researchReport` at the end. `comparator`\n   * is a `variantId`. Other fields are forwarded verbatim.\n   */\n  report?: { comparator?: string } & Omit<\n    ResearchReportOptions,\n    'comparator' | 'preregistrationHash' | 'generatedAt'\n  >\n  /**\n   * Hash of a signed `HypothesisManifest` (see `pre-registration.ts`).\n   * Embedded in the campaign fingerprint and the research report.\n   */\n  preregistrationHash?: string\n  /** Local concurrency. Default `1` (sequential). */\n  concurrency?: number\n  /**\n   * Override the time source. Tests pass a mock to make wallMs deterministic.\n   */\n  now?: () => number\n  /** Override the runId generator. Tests pin this. */\n  runId?: (params: CampaignFactoryParams) => string\n  /**\n   * Agent profile cell for campaign runs. Static profiles can pass an object;\n   * routers or variant-specific harnesses can pass a factory. The campaign\n   * stamps the built cell onto every `RunRecord` and rejects profile/model or\n   * profile/prompt contradictions.\n   */\n  agentProfile?:\n    | AgentProfileCell\n    | AgentProfileCellInput\n    | ((\n        params: CampaignFactoryParams & {\n          variant: V\n          scenarioTags: Record<string, string>\n        },\n      ) =>\n        | AgentProfileCell\n        | AgentProfileCellInput\n        | Promise<AgentProfileCell | AgentProfileCellInput>)\n}\n\nexport interface CampaignFactoryParams {\n  campaignId: string\n  runId: string\n  variantId: string\n  scenarioId: string\n  seed: number\n}\n\nexport interface FailedRun {\n  runId: string\n  variantId: string\n  scenarioId: string\n  seed: number\n  reason: string\n  error?: string\n}\n\nexport interface EvalCampaignResult {\n  campaignId: string\n  /** SHA-256 over canonicalised `(variantIds, scenarioIds, seeds, comparator, splitTag, executionRef, preregistrationHash)`. */\n  campaignFingerprint: string\n  preregistrationHash: string | null\n  /** Successful runs only. Failed runs land in `failedRuns`. */\n  runs: RunRecord[]\n  /** Integrity reports for every successful run. */\n  integrityReports: RunIntegrityReport[]\n  failedRuns: FailedRun[]\n  /** Computed when `report` is set on options. */\n  report?: ResearchReport\n  startedAt: string\n  endedAt: string\n}\n\n// ── Implementation ───────────────────────────────────────────────────────\n\nconst DEFAULT_INTEGRITY: RunIntegrityExpectations = {\n  llmSpansMin: 1,\n  requireRawCoverageOfLlmSpans: true,\n  requireOutcome: true,\n}\n\nexport async function runEvalCampaign<V>(\n  opts: EvalCampaignOptions<V>,\n): Promise<EvalCampaignResult> {\n  // ── Preflight ──────────────────────────────────────────────────────\n  if (opts.variants.length === 0) {\n    throw new Error('runEvalCampaign: variants must be non-empty.')\n  }\n  if (opts.scenarios.length === 0) {\n    throw new Error('runEvalCampaign: scenarios must be non-empty.')\n  }\n  const variantIds = new Set<string>()\n  for (const v of opts.variants) {\n    if (variantIds.has(v.id)) {\n      throw new Error(`runEvalCampaign: duplicate variant id \"${v.id}\".`)\n    }\n    variantIds.add(v.id)\n  }\n  const scenarioIds = new Set<string>()\n  for (const s of opts.scenarios) {\n    if (scenarioIds.has(s.scenarioId)) {\n      throw new Error(`runEvalCampaign: duplicate scenarioId \"${s.scenarioId}\".`)\n    }\n    scenarioIds.add(s.scenarioId)\n  }\n  if (opts.report?.comparator && !variantIds.has(opts.report.comparator)) {\n    throw new Error(\n      `runEvalCampaign: report.comparator \"${opts.report.comparator}\" is not a configured variantId.`,\n    )\n  }\n  if (!opts.commitSha) {\n    throw new Error('runEvalCampaign: commitSha is required (every RunRecord needs it).')\n  }\n\n  const seeds = opts.seeds ?? [0, 1, 2]\n  const splitTag: RunSplitTag = opts.splitTag ?? 'holdout'\n  const concurrency = Math.max(1, opts.concurrency ?? 1)\n  const integrity = { ...DEFAULT_INTEGRITY, ...(opts.integrity ?? {}) }\n  const onIntegrityFailure: CampaignIntegrityPolicy = opts.onIntegrityFailure ?? 'mark_failed'\n  const now = opts.now ?? (() => Date.now())\n  const executionRef = opts.executionRef ?? null\n  const preregistrationHash = opts.preregistrationHash ?? null\n\n  const rawSinkFactory = opts.rawSinkFactory ?? defaultRawSinkFactory(opts.workDir)\n\n  // ── Fingerprint ────────────────────────────────────────────────────\n  const campaignFingerprint = await hashJson({\n    campaignId: opts.campaignId,\n    variants: opts.variants.map((v) => v.id).sort(),\n    scenarios: opts.scenarios.map((s) => s.scenarioId).sort(),\n    seeds: [...seeds].sort((a, b) => a - b),\n    splitTag,\n    comparator: opts.report?.comparator ?? null,\n    executionRef,\n    preregistrationHash,\n  })\n\n  // ── Plan the matrix ────────────────────────────────────────────────\n  type Cell = { variant: CampaignVariant<V>; scenario: CampaignScenario; seed: number }\n  const cells: Cell[] = []\n  for (const variant of opts.variants) {\n    for (const scenario of opts.scenarios) {\n      for (const seed of seeds) {\n        cells.push({ variant, scenario, seed })\n      }\n    }\n  }\n\n  const startedAt = new Date(now()).toISOString()\n  const runs: RunRecord[] = []\n  const integrityReports: RunIntegrityReport[] = []\n  const failedRuns: FailedRun[] = []\n\n  // ── Execute (bounded-concurrency worker pool) ──────────────────────\n  // A genuine (non-CellExecutionError) error from any worker is a bug, not a\n  // run-level failure. We must NOT let `Promise.all` reject mid-flight and\n  // orphan the other workers' in-progress runs (emitters never finalized,\n  // sinks/handles leak, partial work silently discarded). Instead: capture the\n  // first genuine error, stop dispatching new cells so in-flight workers wind\n  // down, finalize every still-open run, then re-throw the aggregated error.\n  let cursor = 0\n  let aborting = false\n  const genuineErrors: unknown[] = []\n  // Emitters for runs that are currently mid-flight, keyed by runId. A worker\n  // registers its emitter before invoking the runner and removes it once the\n  // run is finalized (via endRun/abortRun, success or failure). Anything left\n  // here after the pool settles is an orphan we must abort.\n  const openRuns = new Map<string, TraceEmitter>()\n\n  async function worker(): Promise<void> {\n    while (!aborting) {\n      const i = cursor++\n      if (i >= cells.length) return\n      const cell = cells[i]!\n      try {\n        const result = await runOneCell(cell)\n        runs.push(result.record)\n        integrityReports.push(result.integrity)\n      } catch (err) {\n        if (err instanceof CellExecutionError) {\n          failedRuns.push(err.failed)\n          if (err.integrity) integrityReports.push(err.integrity)\n        } else {\n          // Genuine bug — not a runner failure, not an integrity failure.\n          // Capture it and stop dispatching so peers wind down gracefully;\n          // re-thrown after the pool settles. Do not surface here — that would\n          // reject Promise.all and orphan the other workers' runs.\n          genuineErrors.push(err)\n          aborting = true\n          return\n        }\n      }\n    }\n  }\n\n  async function runOneCell(\n    cell: Cell,\n  ): Promise<{ record: RunRecord; integrity: RunIntegrityReport }> {\n    const runId = (opts.runId ?? defaultRunId)({\n      campaignId: opts.campaignId,\n      runId: '', // unused by default generator\n      variantId: cell.variant.id,\n      scenarioId: cell.scenario.scenarioId,\n      seed: cell.seed,\n    })\n    const factoryParams: CampaignFactoryParams = {\n      campaignId: opts.campaignId,\n      runId,\n      variantId: cell.variant.id,\n      scenarioId: cell.scenario.scenarioId,\n      seed: cell.seed,\n    }\n    const store = opts.storeFactory(factoryParams)\n    const rawSink = rawSinkFactory(factoryParams)\n\n    const emitter = new TraceEmitter(store, {\n      runId,\n      now: opts.now,\n      onRunComplete: opts.onRunComplete,\n    })\n    // Track this run as open so a genuine error elsewhere in the pool can\n    // finalize it instead of orphaning it. Removed in the finally below.\n    openRuns.set(runId, emitter)\n\n    const chat = opts.chatFactory({ rawSink, runId })\n\n    const ctx: CampaignRunContext<V> = {\n      runId,\n      experimentId: opts.campaignId,\n      variant: cell.variant.payload,\n      variantId: cell.variant.id,\n      scenarioId: cell.scenario.scenarioId,\n      scenarioTags: cell.scenario.tags ?? {},\n      seed: cell.seed,\n      splitTag,\n      emitter,\n      store,\n      rawSink,\n      chat,\n    }\n\n    try {\n      const wallStart = now()\n      let outcome: CampaignRunOutcome\n      try {\n        outcome = await opts.runner(ctx)\n      } catch (err) {\n        const message = err instanceof Error ? err.message : String(err)\n        // The runner threw mid-execution. Abort the run so the emitter\n        // finalizes. The only benign abortRun failure is \"the runner never\n        // started the run\" (nothing to finalize). A store-write failure (disk\n        // full, FS error) is a genuine diagnostic — surface it rather than\n        // masking it as a plain runner failure.\n        await finalizeAbort(emitter, runId, message)\n        throw new CellExecutionError({\n          runId,\n          variantId: cell.variant.id,\n          scenarioId: cell.scenario.scenarioId,\n          seed: cell.seed,\n          reason: 'runner_threw',\n          error: message,\n        })\n      }\n      const wallMs = now() - wallStart\n\n      const integrityReport = await assertRunCaptured(store, runId, { ...integrity, rawSink })\n      if (!integrityReport.ok) {\n        switch (onIntegrityFailure) {\n          case 'throw':\n            throw new RunIntegrityError(integrityReport)\n          case 'mark_failed':\n            throw new CellExecutionError(\n              {\n                runId,\n                variantId: cell.variant.id,\n                scenarioId: cell.scenario.scenarioId,\n                seed: cell.seed,\n                reason: 'integrity_failed',\n                error: integrityReport.issues.map((i) => i.code).join(', '),\n              },\n              integrityReport,\n            )\n          case 'log':\n            // Caller wants the run admitted with a flagged report; fall through.\n            break\n        }\n      }\n\n      const recordOutcome: RunOutcome = {\n        raw: outcome.raw ?? {},\n      }\n      if (splitTag === 'holdout') recordOutcome.holdoutScore = outcome.score\n      else recordOutcome.searchScore = outcome.score\n      if (outcome.judgeScores !== undefined) recordOutcome.judgeScores = outcome.judgeScores\n\n      const record: RunRecord = {\n        runId,\n        experimentId: opts.campaignId,\n        candidateId: cell.variant.id,\n        seed: cell.seed,\n        model: outcome.model,\n        promptHash: outcome.promptHash,\n        configHash: outcome.configHash,\n        commitSha: opts.commitSha,\n        wallMs,\n        costUsd: outcome.costUsd,\n        costProvenance: outcome.costProvenance,\n        tokenUsage: outcome.tokenUsage,\n        terminalOutcome: 'succeeded',\n        judgeMetadata: outcome.judgeMetadata,\n        outcome: recordOutcome,\n        ...(outcome.failureClass ? { failureClass: outcome.failureClass } : {}),\n        failureMode: outcome.failureMode,\n        splitTag,\n        scenarioId: cell.scenario.scenarioId,\n      }\n      const profileSource =\n        outcome.agentProfile ??\n        (typeof opts.agentProfile === 'function'\n          ? await opts.agentProfile({\n              campaignId: opts.campaignId,\n              runId,\n              variantId: cell.variant.id,\n              scenarioId: cell.scenario.scenarioId,\n              seed: cell.seed,\n              variant: cell.variant.payload,\n              scenarioTags: cell.scenario.tags ?? {},\n            })\n          : opts.agentProfile)\n      if (profileSource !== undefined) {\n        const agentProfile = await resolveAgentProfileCell(profileSource)\n        assertAgentProfileMatchesRun(agentProfile, outcome.model, outcome.promptHash)\n        record.agentProfile = agentProfile\n      }\n      return { record: validateRunRecord(record), integrity: integrityReport }\n    } finally {\n      // This run's worker has finished with it (success, run-level failure, or\n      // genuine error). It is no longer the pool's job to finalize — drop it so\n      // the post-settle sweep doesn't double-abort a finalized run.\n      openRuns.delete(runId)\n    }\n  }\n\n  const workers = Array.from({ length: Math.min(concurrency, cells.length) }, () => worker())\n  // allSettled (not all): a genuine error in one worker must not reject the\n  // pool mid-flight and orphan the others. Each worker captures its own\n  // genuine error into `genuineErrors` and returns; we re-throw below.\n  await Promise.allSettled(workers)\n\n  // Finalize any run still open after the pool wound down. With the\n  // stop-dispatch flag these are the runs that were mid-flight in peer workers\n  // when the first genuine error fired — abort them so their emitters finalize\n  // (hooks fire, store records a terminal status) instead of leaking.\n  for (const [runId, emitter] of openRuns) {\n    await finalizeAbort(emitter, runId, 'campaign aborted: genuine error in a sibling run')\n  }\n  openRuns.clear()\n\n  if (genuineErrors.length > 0) {\n    throw genuineErrors.length === 1\n      ? genuineErrors[0]\n      : new AggregateError(\n          genuineErrors,\n          `runEvalCampaign: ${genuineErrors.length} runs failed with genuine (non-run-level) errors`,\n        )\n  }\n\n  // ── Optional research report ───────────────────────────────────────\n  let report: ResearchReport | undefined\n  if (opts.report) {\n    const reportOpts: ResearchReportOptions = {\n      ...opts.report,\n      comparator: opts.report.comparator,\n      split: splitTag === 'dev' ? 'search' : splitTag,\n      generatedAt: new Date(now()).toISOString(),\n      preregistrationHash: preregistrationHash ?? undefined,\n    }\n    report = await researchReport(runs, reportOpts)\n  }\n\n  const endedAt = new Date(now()).toISOString()\n\n  return {\n    campaignId: opts.campaignId,\n    campaignFingerprint,\n    preregistrationHash,\n    runs,\n    integrityReports,\n    failedRuns,\n    report,\n    startedAt,\n    endedAt,\n  }\n}\n\n// ── Internal ─────────────────────────────────────────────────────────────\n\nclass CellExecutionError extends Error {\n  readonly failed: FailedRun\n  readonly integrity?: RunIntegrityReport\n  constructor(failed: FailedRun, integrity?: RunIntegrityReport) {\n    super(`cell ${failed.variantId}/${failed.scenarioId}@${failed.seed} failed: ${failed.reason}`)\n    this.failed = failed\n    this.integrity = integrity\n  }\n}\n\n/**\n * Abort a run whose owning work threw or was orphaned by a sibling's genuine\n * error, finalizing the emitter so hooks fire and the store records a terminal\n * status. Safe to call unconditionally: it only aborts runs that are still\n * `running`. Two no-op cases are intentional and benign:\n *\n *   - the run was never started (absent from the store) — nothing to finalize\n *   - the run is already terminal (`completed` / `failed` / `aborted`) —\n *     finalizing again would overwrite the real outcome (e.g. flip a passed run\n *     to `aborted` with `{ pass: false, notes: reason }`), so we leave it alone\n *\n * Any OTHER failure of the store read or the abort write (disk full, FS fault,\n * backend down) is a genuine diagnostic and propagates rather than being\n * swallowed.\n */\nexport async function finalizeAbort(\n  emitter: TraceEmitter,\n  runId: string,\n  reason: string,\n): Promise<void> {\n  const existing = await emitter.traceStore.getRun(runId)\n  if (existing === undefined) return // run never started; nothing to abort\n  if (existing.status !== 'running') return // already finalized; never overwrite a real outcome\n  // The emitter never throws on a failed store write; it counts it. A failed\n  // abort write is a genuine diagnostic here, so read the count and surface it.\n  const droppedBefore = emitter.captureStats().dropped\n  await emitter.abortRun(reason)\n  const after = emitter.captureStats()\n  if (after.dropped > droppedBefore) {\n    throw new Error(`finalizeAbort: run ${runId} could not be finalized: ${after.lastError}`)\n  }\n}\n\nfunction defaultRawSinkFactory(workDir: string | undefined) {\n  return (params: CampaignFactoryParams): RawProviderSink => {\n    if (!workDir) {\n      throw new Error(\n        'runEvalCampaign: rawSinkFactory not supplied and workDir not set. Pass either to enable raw provider capture, or pass `new NoopRawProviderSink()` via rawSinkFactory to opt out explicitly.',\n      )\n    }\n    return new FileSystemRawProviderSink({\n      dir: `${workDir}/raw-events/${params.runId}`,\n    })\n  }\n}\n\nasync function resolveAgentProfileCell(\n  input: AgentProfileCell | AgentProfileCellInput,\n): Promise<AgentProfileCell> {\n  if (isAgentProfileCell(input)) {\n    if (!(await verifyAgentProfileCell(input))) {\n      throw new Error(`runEvalCampaign: agentProfile.cellId does not match its content`)\n    }\n    return input\n  }\n  return buildAgentProfileCell(input)\n}\n\nfunction isAgentProfileCell(\n  input: AgentProfileCell | AgentProfileCellInput,\n): input is AgentProfileCell {\n  return 'schemaVersion' in input && 'cellId' in input\n}\n\nfunction assertAgentProfileMatchesRun(\n  profile: AgentProfileCell,\n  model: string,\n  promptHash: string,\n): void {\n  if (profile.model !== undefined && profile.model !== model) {\n    throw new Error(\n      `runEvalCampaign: agentProfile.model \"${profile.model}\" does not match outcome.model \"${model}\"`,\n    )\n  }\n  if (profile.promptHash !== undefined && profile.promptHash !== promptHash) {\n    throw new Error(\n      `runEvalCampaign: agentProfile.promptHash \"${profile.promptHash}\" does not match outcome.promptHash \"${promptHash}\"`,\n    )\n  }\n}\n\nfunction defaultRunId(params: CampaignFactoryParams): string {\n  // Stable across re-runs: fingerprint of (campaignId, variantId, scenarioId, seed).\n  // Caller can override via opts.runId for non-deterministic IDs.\n  const base = `${params.campaignId}::${params.variantId}::${params.scenarioId}::${params.seed}`\n  // TWO 32-bit FNV-1a accumulators with different offsets, concatenated for a\n  // 64-bit-wide id. Not crypto-grade; stability and uniqueness are what this\n  // needs. Frozen: the value names a persisted cell, and the second\n  // accumulator's offset is part of the identity, so no single-accumulator\n  // helper can replace it.\n  let h1 = 0x811c9dc5\n  let h2 = 0x12345678\n  for (let i = 0; i < base.length; i++) {\n    const c = base.charCodeAt(i)\n    h1 = Math.imul(h1 ^ c, 0x01000193) >>> 0\n    h2 = Math.imul(h2 ^ c, 0x9e3779b1) >>> 0\n  }\n  return `run-${h1.toString(16).padStart(8, '0')}${h2.toString(16).padStart(8, '0')}`\n}\n"],"mappings":"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"}

package/dist/evaluation-6Yoi74gM.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"evaluation-6Yoi74gM.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,UAAU,GAAG,MACvB,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,UAAU,GAAG;UA6BpE,uBAAuB,GAAG,UAAU,UAAU;EAC7D;EACA;EACA,YAAY,YAAY,GAAG;EAC3B,UAAU;IAAY,UAAU;IAAG,UAAU;KAAK;EAClD,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/exporters-X4xwla8A.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"exporters-X4xwla8A.js","names":[],"sources":["../src/rollout/exporters.ts"],"sourcesContent":["/**\n * Pure exporters over `tangle.rollout.v1` lines → the training-data shapes\n * the improvement loops feed:\n *   - SFT chat JSONL           (clean trainable successes, {messages, metadata})\n *   - reward rows              (every scored line, success or failure, with steps)\n *   - Prime Intellect verifiers RolloutOutput (prompt/completion split + reward)\n *   - OpenAI RFT items         (prompt turns + verdict reference fields)\n *\n * All exporters are pure functions of the lines — filtering (never train on\n * holdout, reward thresholds, the realness gate) happens HERE, on inline\n * labels, no joins.\n *\n * Every exporter takes `MintedRolloutLine[]`, not `RolloutLine[]`: the reward\n * on a minted line has been checked against the anti-Goodhart invariant, and\n * the brand is what stops a hand-built object literal claiming a positive\n * reward on a gamed run from being handed to an exporter that copies it\n * verbatim into training data.\n */\n\nimport type {\n  ChatMessage,\n  MintedRolloutLine,\n  RolloutLine,\n  RolloutSplit,\n  RolloutStep,\n  ToolDef,\n} from './schema'\nimport { assertRewardGate } from './schema'\n\n// ---------------------------------------------------------------------------\n// The realness claims every emitted row carries.\n// ---------------------------------------------------------------------------\n\n/**\n * The gate's two claims, which travel TOGETHER on every emitted row.\n *\n * `realness_gated` alone is ambiguous, and the ambiguity is exploitable:\n * `false` reads as \"we screened it and nothing fired\", so a producer that has no\n * screen at all emitted rows indistinguishable from screened-clean ones, and\n * every consumer of the published dataset read them as clean. The second field\n * is what separates the two claims, and it only removes the ambiguity if it\n * reaches the WIRE — for a round it existed on `RolloutOutcome` and on no\n * exported row shape at all, which left the published rows exactly as ambiguous\n * as before.\n *\n * So there is one helper and every row shape spreads it. A row that states one\n * claim without the other is not constructible by copying the pattern, and\n * `exporters.test.ts` walks every emitted shape to prove none does.\n */\nexport interface RealnessLabels {\n  /** The screen's VERDICT: the run faked its success signal. */\n  realness_gated: boolean\n  /**\n   * Whether a screen RAN at all. `true` = it ran, so `realness_gated` is its\n   * verdict. `false` = the producer declares it has none. `null` = not stated\n   * (pre-unification producers), which is \"unknown\" and never \"clean\".\n   */\n  realness_screened: boolean | null\n}\n\nfunction realnessLabels(line: MintedRolloutLine): RealnessLabels {\n  return {\n    realness_gated: line.outcome.realness_gated === true,\n    // `?? null` rather than `?? false`: absent means the producer never stated\n    // it, and `false` is a load-bearing claim (\"no screen exists\") that would be\n    // an invention here.\n    realness_screened: line.outcome.realness_screened ?? null,\n  }\n}\n\n// ---------------------------------------------------------------------------\n// (a) SFT chat JSONL\n// ---------------------------------------------------------------------------\n\nexport interface TrainingExportOptions {\n  /** Include held-out evaluation data in training output. Default false. */\n  allowHeldOutTrainingData?: boolean\n  /** Require reward to be strictly greater than this value. Default 0. */\n  minimumQualityExclusive?: number\n  /**\n   * Explicit split selection, replacing the default trainable-split rule.\n   * Use this only when producing a deliberately named non-training slice\n   * (e.g. `['holdout']` for a holdout-only evaluation bundle).\n   */\n  splitFilter?: RolloutSplit[]\n}\n\n/**\n * What a signed-signal exporter (verifiers, RFT) does with lines that are not\n * clean trainable successes — realness-gated lines above all.\n *\n *   - 'exclude'       — the default, the same fail-closed policy as every\n *                       other training export: positive, completed,\n *                       non-gated rows on a trainable split.\n *   - 'zero-and-flag' — keep them, at their non-positive (or null) reward,\n *                       with `RealnessLabels` on the row. The dataset release\n *                       sets this per `FORMAT_GATE_DISPOSITION`: in these\n *                       formats the reward is a signed learning signal, so a\n *                       gamed trajectory at reward 0 is a correct negative,\n *                       and dropping it would bias the negative population\n *                       toward honest failures and leave a trainer no example\n *                       of gaming being penalized. The split policy is NOT\n *                       relaxed: held-out lines still need the named opt-in.\n *\n * SFT deliberately has no such option — an SFT row is an imitation target and\n * a gamed trajectory must never appear in one at any weight.\n */\nexport type GatedLineDisposition = 'exclude' | 'zero-and-flag'\n\nexport interface SignedSignalExportOptions extends TrainingExportOptions {\n  /** Disposition for non-trainable lines. Default 'exclude'. */\n  gatedLines?: GatedLineDisposition\n}\n\nexport type SftExportOptions = TrainingExportOptions\n\nexport interface SftRow {\n  messages: ChatMessage[]\n  metadata: {\n    rollout_id: string\n    run_id: string\n    candidate_id: string | null\n    instance_id: string\n    reward: number\n  } & RealnessLabels\n}\n\n/**\n * Supervised fine-tune rows: the completed conversation of each qualifying\n * line. Fail-closed filters: trainable split only (never holdout/canary unless\n * an explicit `splitFilter` names a non-training slice),\n * reward strictly above `minimumQualityExclusive` (default 0), realness-gated\n * lines never qualify, gap lines carry no trainable content, and\n * copied-context turns are dropped from the transcript (Harbor ATIF RFC 0001\n * rule 7 — see `ChatMessage.is_copied_context`).\n *\n * `realness_gated` is therefore always `false` on an emitted row. It is carried\n * anyway: an SFT row is a pure imitation target, so the row states its realness\n * claims instead of making the reader know the format's policy, and carrying\n * both flags on all four shapes is what lets the release accounting measure\n * every config with one rule rather than skipping the one whose row shape\n * happened to omit the field.\n */\nexport function toSftRows(lines: MintedRolloutLine[], options: SftExportOptions = {}): SftRow[] {\n  for (const line of lines) assertRewardGate(line, 'SFT export')\n  return lines\n    .filter((line) => isTrainingLineEligible(line, options) && line.messages.length > 0)\n    .map((line) => ({\n      // Dropped, not kept-and-masked: a copied-context turn was authored by\n      // another agent, and an SFT trainer has no notion of \"present but not a\n      // target\" — every message it is handed is something to imitate.\n      messages: line.messages.filter((message) => message.is_copied_context !== true),\n      metadata: {\n        rollout_id: line.rollout_id,\n        run_id: line.run_id,\n        candidate_id: line.candidate_id ?? null,\n        instance_id: line.task.instance_id,\n        reward: line.outcome.reward as number,\n        ...realnessLabels(line),\n      },\n    }))\n    .filter((row) => row.messages.length > 0)\n}\n\n// ---------------------------------------------------------------------------\n// (b) Reward rows\n// ---------------------------------------------------------------------------\n\nexport interface RewardRow {\n  /** First user turn — the task prompt. */\n  prompt: string\n  steps: RolloutStep[]\n  reward: number\n  metadata: {\n    rollout_id: string\n    run_id: string\n    candidate_id: string | null\n    instance_id: string\n    split: RolloutSplit\n    /**\n     * The anti-Goodhart verdict AND whether a screen produced it, carried on the\n     * row rather than left implicit in a reward of 0. Zeroing alone is lossy: it\n     * makes a run that FAKED its success indistinguishable from one that\n     * honestly failed, so a consumer can neither drop the gamed population nor\n     * mine it (a labeled gamed trajectory is the training signal for a gaming\n     * detector). `realness_gated` alone is lossy the same way in the other\n     * direction — see `RealnessLabels`.\n     */\n  } & RealnessLabels\n}\n\n/**\n * Reward-labeled rows for completed, positive-quality training runs.\n */\nexport function toRewardRows(\n  lines: MintedRolloutLine[],\n  options: TrainingExportOptions = {},\n): RewardRow[] {\n  for (const line of lines) assertRewardGate(line, 'reward-row export')\n  return lines\n    .filter(\n      (line) =>\n        isTrainingLineEligible(line, options) &&\n        line.messages.some(\n          (message) =>\n            message.role === 'user' &&\n            typeof message.content === 'string' &&\n            message.content.length > 0,\n        ),\n    )\n    .map((line) => ({\n      prompt: line.messages.find((m) => m.role === 'user')?.content ?? '',\n      steps: line.steps ?? [],\n      reward: line.outcome.reward as number,\n      metadata: {\n        rollout_id: line.rollout_id,\n        run_id: line.run_id,\n        candidate_id: line.candidate_id ?? null,\n        instance_id: line.task.instance_id,\n        split: line.task.split,\n        ...realnessLabels(line),\n      },\n    }))\n}\n\n// ---------------------------------------------------------------------------\n// (c) Prime Intellect verifiers RolloutOutput\n// ---------------------------------------------------------------------------\n\nexport interface VerifiersTokenUsage {\n  input_tokens: number | null\n  output_tokens: number | null\n  reasoning_tokens: number | null\n  cache_read_tokens: number | null\n  cache_write_tokens: number | null\n}\n\nexport interface VerifiersRolloutOutput {\n  /** Messages through the last turn BEFORE the first assistant turn. */\n  prompt: ChatMessage[]\n  /** The first assistant turn onward — what the policy produced. */\n  completion: ChatMessage[]\n  reward: number | null\n  metrics: Record<string, unknown>\n  tool_defs: ToolDef[]\n  token_usage: VerifiersTokenUsage\n  info: {\n    task: RolloutLine['task']\n    policy: RolloutLine['policy']\n    rollout_id: string\n    run_id: string\n    experiment_id: string | null\n    candidate_id: string | null\n    generation: number | null\n    candidate_index: number | null\n    role: RolloutLine['role']\n  } & RealnessLabels\n}\n\n/** Index of the first assistant turn; messages.length when none exists. */\nfunction firstAssistantIndex(messages: ChatMessage[]): number {\n  const index = messages.findIndex((m) => m.role === 'assistant')\n  return index === -1 ? messages.length : index\n}\n\nfunction assertCompleteProjection(line: MintedRolloutLine, context: string): void {\n  if (line.provenance.lossy_projection === true) {\n    throw new Error(`${context}: rollout ${line.rollout_id} has a lossy projection`)\n  }\n}\n\nexport function toVerifiersRolloutOutput(line: MintedRolloutLine): VerifiersRolloutOutput {\n  assertRewardGate(line, 'verifiers export')\n  assertCompleteProjection(line, 'verifiers export')\n  const split = firstAssistantIndex(line.messages)\n  return {\n    prompt: line.messages.slice(0, split),\n    completion: line.messages.slice(split),\n    reward: line.outcome.reward,\n    metrics: line.outcome.metrics,\n    tool_defs: line.tool_defs,\n    token_usage: {\n      input_tokens: line.cost.tokens_in,\n      output_tokens: line.cost.tokens_out,\n      reasoning_tokens: line.cost.tokens_reasoning,\n      cache_read_tokens: line.cost.cache_read,\n      cache_write_tokens: line.cost.cache_write,\n    },\n    info: {\n      task: line.task,\n      policy: line.policy,\n      rollout_id: line.rollout_id,\n      run_id: line.run_id,\n      experiment_id: line.experiment_id ?? null,\n      candidate_id: line.candidate_id ?? null,\n      generation: line.generation,\n      candidate_index: line.candidate_index,\n      role: line.role,\n      ...realnessLabels(line),\n    },\n  }\n}\n\nexport function toVerifiersRolloutOutputs(\n  lines: MintedRolloutLine[],\n  options: SignedSignalExportOptions = {},\n): VerifiersRolloutOutput[] {\n  if (options.gatedLines === 'zero-and-flag') {\n    return lines\n      .filter(\n        (line) =>\n          isSplitEligible(line, options) &&\n          line.provenance.lossy_projection !== true &&\n          line.messages.length > 0,\n      )\n      .map(toVerifiersRolloutOutput)\n  }\n  return lines\n    .filter(\n      (line) =>\n        isTrainingLineEligible(line, options) &&\n        firstAssistantIndex(line.messages) > 0 &&\n        firstAssistantIndex(line.messages) < line.messages.length,\n    )\n    .map(toVerifiersRolloutOutput)\n}\n\n// ---------------------------------------------------------------------------\n// (d) OpenAI RFT items\n// ---------------------------------------------------------------------------\n\nexport interface RftItem {\n  /** Prompt turns only — the graded completion is re-sampled during RFT. */\n  messages: ChatMessage[]\n  /** Verdict/label fields the grader references as item.reference.* */\n  reference: {\n    reward: number | null\n    reward_source: string | null\n    verdict: unknown\n    instance_id: string\n    suite: string\n    split: RolloutSplit\n    rollout_id: string\n  } & RealnessLabels\n}\n\nexport function toRftItem(line: MintedRolloutLine): RftItem {\n  assertRewardGate(line, 'RFT export')\n  assertCompleteProjection(line, 'RFT export')\n  const split = firstAssistantIndex(line.messages)\n  return {\n    messages: line.messages.slice(0, split),\n    reference: {\n      reward: line.outcome.reward,\n      reward_source: line.outcome.reward_source,\n      verdict: line.outcome.verdict,\n      instance_id: line.task.instance_id,\n      suite: line.task.suite,\n      split: line.task.split,\n      rollout_id: line.rollout_id,\n      ...realnessLabels(line),\n    },\n  }\n}\n\n/** RFT needs a real prompt: lines whose transcript starts with prompt turns. */\nexport function toRftItems(\n  lines: MintedRolloutLine[],\n  options: SignedSignalExportOptions = {},\n): RftItem[] {\n  return lines\n    .filter(\n      (line) =>\n        (options.gatedLines === 'zero-and-flag'\n          ? isSplitEligible(line, options) && line.provenance.lossy_projection !== true\n          : isTrainingLineEligible(line, options)) &&\n        line.messages.length > 0 &&\n        firstAssistantIndex(line.messages) > 0,\n    )\n    .map(toRftItem)\n}\n\n// ---------------------------------------------------------------------------\n// Serialization — one JSON object per line, the interchange format for\n// every export. `tangle.rollout.v1` lines and export rows alike.\n// ---------------------------------------------------------------------------\n\nexport function toJsonl(rows: ReadonlyArray<unknown>): string {\n  return rows.map((r) => JSON.stringify(r)).join('\\n') + (rows.length ? '\\n' : '')\n}\n\n/**\n * The split half of the training policy alone: `search` is trainable, held-out\n * needs the named opt-in, `dev` and `canary` never ship. This is the ONE check\n * `'zero-and-flag'` does not relax — a gated line is shipped as a labeled\n * negative, not as a licence to train on evaluation data. An explicit\n * `splitFilter` names a non-training slice instead of the default rule.\n *\n * Exported as the single implementation of that rule: `rl/exporters` applies\n * it on its line paths too, so the two waists cannot drift on which splits are\n * trainable.\n */\nexport function isSplitEligible(\n  line: RolloutLine,\n  options: Pick<TrainingExportOptions, 'allowHeldOutTrainingData' | 'splitFilter'>,\n): boolean {\n  if (options.splitFilter !== undefined) return options.splitFilter.includes(line.task.split)\n  if (line.task.split === 'search') return true\n  return line.task.split === 'holdout' && options.allowHeldOutTrainingData === true\n}\n\n/**\n * The whole fail-closed training policy for one line: scored, positive above\n * the floor, completed, not gated, on an eligible split. Shared with\n * `rl/exporters` so its text-lookup adapter cannot drift from this rule.\n */\nexport function isTrainingLineEligible(\n  line: RolloutLine,\n  options: TrainingExportOptions,\n): line is RolloutLine & { outcome: RolloutLine['outcome'] & { reward: number } } {\n  const minimumQualityExclusive = options.minimumQualityExclusive ?? 0\n  if (!Number.isFinite(minimumQualityExclusive)) {\n    throw new Error('minimumQualityExclusive must be finite')\n  }\n\n  const reward = line.outcome.reward\n  if (reward === null) return false\n  if (!Number.isFinite(reward)) {\n    throw new Error(`training reward for rollout \"${line.rollout_id}\" must be finite`)\n  }\n  if (reward <= minimumQualityExclusive) return false\n  if (!line.outcome.is_completed || line.outcome.is_truncated || line.outcome.error !== null) {\n    return false\n  }\n  if (line.outcome.realness_gated === true) return false\n  if (line.provenance.lossy_projection === true) return false\n  return isSplitEligible(line, options)\n}\n"],"mappings":"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"}

package/dist/external-optimizer-process-BjMGUuds.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"external-optimizer-process-BjMGUuds.js","names":[],"sources":["../src/campaign/external-optimizer-callback.ts"],"sourcesContent":["import { createServer, type IncomingMessage, type ServerResponse } from 'node:http'\nimport { contentHash } from '../verdict-cache'\nimport {\n  type ExternalOptimizerCallback,\n  type ExternalOptimizerCallbackLimits,\n  type ExternalOptimizerEvaluationObservation,\n  type ExternalTextCandidate,\n  type ExternalTextEvaluationRequest,\n  isExternalTextCandidate,\n  isRecord,\n  resolveExternalOptimizerCallbackLimits,\n} from './external-optimizer-contracts'\nimport {\n  closeServer,\n  listenLocal,\n  sendJsonIfOpen,\n  waitForActiveHandlers,\n} from './external-optimizer-http'\n\ntype UnsequencedObservation = ExternalOptimizerEvaluationObservation extends infer T\n  ? T extends ExternalOptimizerEvaluationObservation\n    ? Omit<T, 'sequence'>\n    : never\n  : never\n\nexport async function startExternalOptimizerCallback<TResponse>(args: {\n  token: string\n  maxEvaluations: number\n  acceptEvaluation?: () => number | undefined\n  evaluate: (request: ExternalTextEvaluationRequest, signal: AbortSignal) => Promise<TResponse>\n  observe?: (observation: ExternalOptimizerEvaluationObservation) => void\n  /** Loopback JSON byte limits. Omitted fields use finite defaults. */\n  limits?: Partial<ExternalOptimizerCallbackLimits>\n  signal?: AbortSignal\n}): Promise<ExternalOptimizerCallback> {\n  assertCallbackConfig(args)\n  const limits = resolveExternalOptimizerCallbackLimits(args.limits)\n  args.signal?.throwIfAborted()\n  let evaluations = 0\n  let accepting = true\n  let closePromise: Promise<void> | undefined\n  const activeControllers = new Set<AbortController>()\n  const activeHandlers = new Set<Promise<void>>()\n  const proposedCandidateHashes = new Set<string>()\n  let observationSequence = 0\n  const server = createServer((request, response) => {\n    if (!accepting) {\n      sendJsonIfOpen(response, 503, { error: 'external optimizer callback is closing' })\n      return\n    }\n\n    const controller = new AbortController()\n    const abortRequest = (): void => {\n      request.destroy()\n      response.destroy()\n    }\n    activeControllers.add(controller)\n    controller.signal.addEventListener('abort', abortRequest, { once: true })\n\n    let handler!: Promise<void>\n    handler = handleCallback(\n      request,\n      response,\n      controller.signal,\n      args,\n      limits,\n      () => {\n        const accepted = args.acceptEvaluation ? args.acceptEvaluation() : evaluations + 1\n        if (accepted === undefined) return undefined\n        if (!Number.isSafeInteger(accepted) || accepted <= 0) {\n          throw new Error('external optimizer callback: invalid accepted evaluation count')\n        }\n        if (accepted > args.maxEvaluations) return undefined\n        evaluations += 1\n        return accepted\n      },\n      (observation) => {\n        if (!args.observe) return\n        args.observe({ ...observation, sequence: ++observationSequence })\n      },\n      proposedCandidateHashes,\n    ).finally(() => {\n      controller.signal.removeEventListener('abort', abortRequest)\n      activeControllers.delete(controller)\n      activeHandlers.delete(handler)\n    })\n    activeHandlers.add(handler)\n    void handler.catch(() => undefined)\n  })\n  const port = await listenLocal(server)\n  const close = (): Promise<void> => {\n    closePromise ??= closeCallbackServer()\n    return closePromise\n  }\n  const onAbort = (): void => {\n    void close().catch(() => undefined)\n  }\n  args.signal?.addEventListener('abort', onAbort, { once: true })\n  if (args.signal?.aborted) onAbort()\n  return {\n    url: `http://127.0.0.1:${port}/evaluate`,\n    token: args.token,\n    evaluations: () => evaluations,\n    close,\n  }\n\n  async function closeCallbackServer(): Promise<void> {\n    args.signal?.removeEventListener('abort', onAbort)\n    accepting = false\n    const closingServer = closeServer(server)\n    server.closeIdleConnections?.()\n    for (const controller of activeControllers) controller.abort()\n    const [serverResult] = await Promise.allSettled([\n      closingServer,\n      waitForActiveHandlers(activeHandlers),\n    ])\n    if (activeControllers.size !== 0 || activeHandlers.size !== 0) {\n      throw new Error('external optimizer callback closed with active request work')\n    }\n    if (serverResult?.status === 'rejected') throw serverResult.reason\n  }\n}\n\nasync function handleCallback<TResponse>(\n  request: IncomingMessage,\n  response: ServerResponse,\n  signal: AbortSignal,\n  args: {\n    token: string\n    maxEvaluations: number\n    acceptEvaluation?: () => number | undefined\n    evaluate: (request: ExternalTextEvaluationRequest, signal: AbortSignal) => Promise<TResponse>\n    observe?: (observation: ExternalOptimizerEvaluationObservation) => void\n  },\n  limits: ExternalOptimizerCallbackLimits,\n  nextEvaluation: () => number | undefined,\n  observe: (observation: UnsequencedObservation) => void,\n  proposedCandidateHashes: Set<string>,\n): Promise<void> {\n  try {\n    if (request.method !== 'POST' || request.url !== '/evaluate') {\n      sendJsonIfOpen(response, 404, { error: 'not found' })\n      return\n    }\n    if (request.headers.authorization !== `Bearer ${args.token}`) {\n      sendJsonIfOpen(response, 401, { error: 'unauthorized' })\n      return\n    }\n    let body: unknown\n    try {\n      body = await readJson(request, limits.maxRequestBytes)\n    } catch {\n      observe({ kind: 'refusal', reason: 'invalid-request' })\n      sendJsonIfOpen(response, 400, { error: 'request body must be bounded valid JSON' })\n      return\n    }\n    if (\n      !isRecord(body) ||\n      !isExternalTextCandidate(body.candidate) ||\n      typeof body.exampleId !== 'string'\n    ) {\n      observe({ kind: 'refusal', reason: 'invalid-request' })\n      sendJsonIfOpen(response, 400, { error: 'candidate and exampleId are required strings' })\n      return\n    }\n    const candidate = cloneCandidate(body.candidate)\n    const candidateHash = contentHash({ kind: 'external-text-candidate', candidate })\n    if (!proposedCandidateHashes.has(candidateHash)) {\n      observe({ kind: 'proposal', candidate, candidateHash })\n      proposedCandidateHashes.add(candidateHash)\n    }\n    const count = nextEvaluation()\n    if (count === undefined) {\n      observe({\n        kind: 'refusal',\n        reason: 'evaluation-limit',\n        candidate,\n        candidateHash,\n        exampleId: body.exampleId,\n      })\n      sendJsonIfOpen(response, 429, { error: 'evaluation limit reached' })\n      return\n    }\n    let result: TResponse\n    try {\n      result = await args.evaluate({ candidate, exampleId: body.exampleId }, signal)\n    } catch (error) {\n      observe({\n        kind: 'refusal',\n        reason: 'evaluation-failed',\n        candidate,\n        candidateHash,\n        exampleId: body.exampleId,\n      })\n      // The thrown detail is the only diagnostic for a failed evaluation —\n      // an opaque 500 costs the caller a blind debugging round.\n      sendJsonIfOpen(response, 500, {\n        error: `evaluation failed: ${String(error).slice(0, 400)}`,\n      })\n      return\n    }\n    let encoded: string\n    try {\n      encoded = encodeJsonResponse(result)\n    } catch {\n      observe({\n        kind: 'refusal',\n        reason: 'evaluation-failed',\n        candidate,\n        candidateHash,\n        exampleId: body.exampleId,\n      })\n      sendJsonIfOpen(response, 500, { error: 'evaluation response must be valid JSON' })\n      return\n    }\n    if (Buffer.byteLength(encoded) > limits.maxResponseBytes) {\n      observe({\n        kind: 'refusal',\n        reason: 'evaluation-failed',\n        candidate,\n        candidateHash,\n        exampleId: body.exampleId,\n      })\n      sendJsonIfOpen(response, 413, { error: 'evaluation response too large' })\n      return\n    }\n    observe({\n      kind: 'evaluation',\n      candidate,\n      candidateHash,\n      exampleId: body.exampleId,\n      evaluationNumber: count,\n      response: structuredClone(result),\n    })\n    sendEncodedJsonIfOpen(response, 200, encoded)\n  } catch {\n    sendJsonIfOpen(response, 500, { error: 'evaluation failed' })\n  }\n}\n\nfunction readJson(request: IncomingMessage, maxRequestBytes: number): Promise<unknown> {\n  return new Promise((resolvePromise, reject) => {\n    let size = 0\n    const chunks: Buffer[] = []\n    request.on('data', (chunk: Buffer) => {\n      size += chunk.length\n      if (size > maxRequestBytes) {\n        reject(new Error('callback body too large'))\n        request.destroy()\n        return\n      }\n      chunks.push(chunk)\n    })\n    request.on('error', reject)\n    request.on('end', () => {\n      try {\n        resolvePromise(JSON.parse(Buffer.concat(chunks).toString('utf8')))\n      } catch (error) {\n        reject(error)\n      }\n    })\n  })\n}\n\nfunction encodeJsonResponse(value: unknown): string {\n  const encoded = JSON.stringify(value)\n  if (encoded === undefined) throw new Error('evaluation response must be JSON-serializable')\n  return encoded\n}\n\nfunction sendEncodedJsonIfOpen(response: ServerResponse, status: number, encoded: string): void {\n  if (response.destroyed || response.writableEnded) return\n  response.writeHead(status, {\n    'content-type': 'application/json; charset=utf-8',\n    'content-length': String(Buffer.byteLength(encoded)),\n  })\n  response.end(encoded)\n}\n\nfunction assertCallbackConfig(args: {\n  token: string\n  maxEvaluations: number\n  acceptEvaluation?: () => number | undefined\n  evaluate: (request: ExternalTextEvaluationRequest, signal: AbortSignal) => Promise<unknown>\n  observe?: (observation: ExternalOptimizerEvaluationObservation) => void\n  limits?: Partial<ExternalOptimizerCallbackLimits>\n  signal?: AbortSignal\n}): void {\n  if (typeof args.token !== 'string' || !args.token.trim()) {\n    throw new Error('external optimizer callback: token must be non-empty')\n  }\n  if (!Number.isSafeInteger(args.maxEvaluations) || args.maxEvaluations <= 0) {\n    throw new Error('external optimizer callback: maxEvaluations must be a positive safe integer')\n  }\n  if (args.acceptEvaluation !== undefined && typeof args.acceptEvaluation !== 'function') {\n    throw new Error('external optimizer callback: acceptEvaluation must be a function')\n  }\n  if (typeof args.evaluate !== 'function') {\n    throw new Error('external optimizer callback: evaluate must be a function')\n  }\n  if (args.observe !== undefined && typeof args.observe !== 'function') {\n    throw new Error('external optimizer callback: observe must be a function')\n  }\n}\n\nfunction cloneCandidate(candidate: ExternalTextCandidate): ExternalTextCandidate {\n  return typeof candidate === 'string' ? candidate : { ...candidate }\n}\n"],"mappings":"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"}