@tangle-network/agent-eval 0.161.1 → 0.170.0

package/CHANGELOG.md

@@ -4,6 +4,162 @@ All notable changes to `@tangle-network/agent-eval` and its sibling `agent-eval-
 
 ---
 
+## [0.170.0] — 2026-08-21
+
+### Added
+
+- `pnpm check:collation-ordering`, wired into `verify:package`. It reports a `localeCompare` comparator inside a function that also canonicalizes or hashes — the shape that let eleven orderings decide a digest from the host's collation rather than from the value. The rule is narrow on purpose: ordering a table a human reads is not this gate's business, and a Markdown renderer that sorts rows does not canonicalize, so it is not reported. An allowlist entry matching nothing fails the gate, so a stale waiver cannot hide a new one.
+- `scripts/source-scan.mjs` holds the reading primitives both source gates share — walking `src/`, naming a function by its binding, locating an offset, visiting a tree. A second gate with its own copies would have re-created the duplication these releases removed, and sharing them means the naming fix in 0.168.1 reaches both gates rather than one.
+
+---
+
+## [0.169.0] — 2026-08-21
+
+### Fixed
+
+- Eleven orderings that reach a digest, a stable serialization, or a stored identity no longer read the host's collation. RFC 8785 canonicalizes an array **by position**, so a `localeCompare` sort in front of `canonicalString` or `hashCanonical` let the machine decide the digest bytes: the ids `Accuracy, brevity, Clarity` order as `Accuracy,brevity,Clarity` under an en-US collation and as `Accuracy,Clarity,brevity` by code unit, and the two produce different digests for the same data. `compareCodeUnits` in `src/ledger-core/canonical.ts` is now the one comparator for an ordering whose result is hashed.
+  - Three of the ten carried a docstring asserting an invariant the code did not hold: `hashScenarios` ("independent of insertion order" — it was not independent of collation), `Dataset.toJsonl` ("deterministic byte-for-byte"), and `serializeFeedbackTrajectoriesJsonl` ("two exports of equal stores are byte-equal"). `testSuiteDigest`'s "two suites with the same digest are the same suite" was in the same position.
+  - Digest and serialization sites: `src/dataset.ts` (`hashScenarios`, `toJsonl`), `src/feedback-trajectory.ts` (`serializeFeedbackTrajectoriesJsonl`), `src/trace-repair/test-oracle.ts` (`testSuiteDigest`), `src/campaign/provenance.ts` (`costReceiptsDigest`, `campaignMeasurementDigest` cells), `src/analyst/benchmark-summary.ts` (finding signature), `src/analyst/benchmark-verification-artifacts.ts` (artifact order, which reaches a verification span id), `src/rl/verified-findings-dataset.ts` (dataset rows), `src/campaign/run-campaign.ts` (the campaign's retained cell order).
+  - Ordering-only sites fixed for the same reason, since each decides which records a caller sees: `src/campaign/labeled-store/fs-adapter.ts` (which records a `slice(0, count)` returns) and `src/analyst/benchmark-public-data.ts` (which rows a seeded public-benchmark sample selects).
+  - No retention window is added, and that is a per-site finding rather than an assumption: nothing in this package stores one of these values and later recomputes it from source data to compare. `verifyLoopProvenanceRecord` re-hashes the record's stored fields, and `assertCampaignSplitIdentity` recomputes a split digest whose builder never sorted. The values move once, like `rubricVersion` in 0.167.0, rather than needing the dual-verify `surfaceHash` required.
+  - A comparator for a report a human reads is left alone; `renderSurfaceDiff` and the Markdown renderers keep `localeCompare`.
+
+---
+
+## [0.168.1] — 2026-08-21
+
+### Fixed
+
+- `scripts/check-canonical-json.mjs` no longer names a function after the function it is passed to. An arrow in argument position sits behind the text `helper(`, and the name fallback read that as its name; the fabricated name then entered the module's sorter set, so every caller of the REAL function of that name read as sorting. A gate that reports a file and line whose function contains no sort teaches the next reader that it lies, which is how a useful check gets switched off.
+- Names now come from a binding only — a declaration id, a `const`/`let`/`var` binding, or an object-property key — and a function with no binding is reported as `(anonymous)` and located by its line. Only a bound function can be called by name, so only a bound one is registered as a sorting helper.
+
+---
+
+## [0.168.0] — 2026-08-21
+
+### Fixed
+
+- A component surface's stored identity no longer depends on the host's collation. `componentSurfaceIdentityMaterial` ordered component names with `localeCompare`, which reads the runtime's default collation rather than the value, and that material feeds `surfaceContentHash` and `surfaceHash` — identities that are **written down** and later recomputed and compared. Three sites do exactly that (`src/campaign/provenance.ts:351`, `src/campaign/presets/run-optimization.ts:658` and `:693`), each of them a fail-closed refusal, so under a different ICU build or locale a legitimate resume or parent selection could be rejected as a surface that does not match its own identity. The material now comes from `canonicalString`, which orders keys by UTF-16 code unit (RFC 8785) — a property of the value alone.
+- `surfaceHashMatches(surface, storedHash)` is the verify path for the retention window. A stored loop key is 16 hex characters with no room for a scheme tag, so unlike an `agent-profile-cell` id it cannot name the scheme that minted it; the matcher tries the current material and then the retired one, which gives the same property — a key minted by an earlier release still matches its own surface, and an edited surface matches neither. The retired builder is private and reachable only from that matcher; nothing mints from it. The three comparison sites now use the matcher instead of `!==`.
+- Every stored component-surface identity moves, not only one whose names sort differently under a collation: RFC 8785 also orders the two top-level keys, so `components` now precedes `schema`. Prompt and code surfaces are unaffected — neither builds material from an ordered key list.
+
+---
+
+## [0.167.1] — 2026-08-21
+
+### Changed
+
+- `waitForActiveHandlers` and `sendJsonIfOpen` had three byte-identical private copies each, one per local HTTP server (`src/analyst/trace-tool-callback.ts`, `src/campaign/external-optimizer-callback.ts`, `src/campaign/external-optimizer-model-proxy.ts`). Both now live in `src/campaign/external-optimizer-http.ts`, the module all three already imported `closeServer`, `listenLocal`, and `sendJson` from. The drain loop re-reads the handler set on every pass because a running handler can register another; a copy that awaited one snapshot would let the caller close the server with work outstanding. No behavior change and no export change: the helpers are internal to that module's consumers.
+
+---
+
+## [0.167.0] — 2026-08-21
+
+### Changed
+
+- `rubricVersion` is now `<name>@sha256-rfc8785:<hex>` and comes from `hashCanonical`, this package's only canonical-JSON encoder. It was a 32-bit djb2 hash over a private `stableStringify` — the twelfth canonical-JSON encoder in the tree, and the only one whose key order came from `localeCompare`. `localeCompare` orders by the runtime's collation rather than by the value, so a rubric whose dimension ids differ only in case (`Accuracy`, `brevity`) could serialize in a different order under a different collation and produce a different tag for the same rubric. RFC 8785 orders by UTF-16 code unit, which depends on the value alone.
+  - The scheme is named inside the value. A consumer holding a tag from an earlier release reads a different scheme and can tell "this package changed how it hashes" from "the rubric changed"; with a bare hex string the two are indistinguishable. Tags minted before this release (`anti-slop@a4f2b8c1`) are not comparable with these, and nothing in this package verifies a stored tag — `rubricVersion` is compared for equality, never recomputed against a record — so no legacy encoder is retained.
+  - `WIRE_VERSION` is `1.1.0`. The request and response shapes are unchanged, so the major stays `1` and every client that checks the major (`clients/python/src/agent_eval_rpc/client.py:139`) keeps working; the minor moves because a response value changed meaning.
+  - The Python client carries `rubricVersion` as an opaque `str` and never computes or parses it, so it needs no change beyond the version lockstep.
+- `RUBRIC_VERSION_SCHEME` is exported from `/wire` for a caller that wants to compare a tag's scheme without parsing the string.
+
+---
+
+## [0.166.1] — 2026-08-21
+
+### Changed
+
+- The seven FNV-1a loops in this package each say what they hash and why they are frozen. They look interchangeable and are not: one hashes IEEE-754 bytes rather than a string (`src/statistics/internal.ts`), one masks each code unit to a byte and the rest do not (`src/partition-held-out.ts`), one is deliberately left signed so subtracting two results is a valid comparator (`src/analyst/benchmark.ts`), and one runs two accumulators with different offsets to make a 64-bit-wide id (`src/eval-campaign.ts`). Unifying them would move held-out splits, cell keys, replay seeds, and published bootstrap intervals that were already decided under the current values, so each now carries the one line that stops the next reader from "fixing" it. No behavior change.
+
+---
+
+## [0.165.0] — 2026-08-21
+
+### Added
+
+- `@tangle-network/agent-eval/adapters/http` is published. `httpDispatch` (coordinator side) and `runDispatchServer` (worker side) have existed in `src/adapters/http.ts` with a test, a two-process runnable example under `examples/distributed-driver/`, and a design document since 0.130.x, but no `exports` entry — so every `import` line in `docs/distributed-driver.md` threw `ERR_PACKAGE_PATH_NOT_EXPORTED` against an installed copy, and the example could only be run from a checkout. The document's status note and the three "not currently published" fence comments are removed because they are no longer true.
+
+---
+
+## [0.164.2] — 2026-08-21
+
+### Changed
+
+- Three vocabularies that were declared twice now derive from one array each. No member changes, no reordering, and no public export changes; the schemas that validate them are generated from the same declaration they validate against, so the two halves cannot drift apart.
+  - `AnalystComparisonMetric` was a hand-written 18-member union, `METRICS` repeated the same 18 members as an array, `LOWER_IS_BETTER` repeated 8 of them as a set, and `src/analyst/benchmark-command-validation.ts` repeated all 18 again as a `z.enum` over the persisted artifact. A metric added to the union but missed in that enum would have been rejected at artifact validation with no compile error. One `ANALYST_COMPARISON_METRIC_DIRECTION` table now carries every metric and its direction; the type, the reporting order, the artifact schema, and `analystComparisonMetricDirection` all derive from it.
+  - `FailureClass` was a 35-member union followed by `FAILURE_CLASSES`, a `readonly FailureClass[]` repeating the same 35 members. The array could silently omit a member the type declared. `FAILURE_CLASSES` is now the `as const` owner and the type derives from it.
+  - `AnalystSeverity` was a union in `src/analyst/types.ts` and `ANALYST_SEVERITIES` was a private copy in `src/analyst/finding-signature.ts` feeding the finding schema's `z.enum`. `ANALYST_SEVERITIES` now lives beside the type it defines.
+
+---
+
+## [0.164.1] — 2026-08-21
+
+### Changed
+
+- The analyst-benchmark pin is authored by the tool that checks it. `pnpm analyst:pin` (`--write`) rewrites `ANALYST_BENCHMARK_IMPLEMENTATION_FILES` from the import graph and both live digests from the sources; it refuses a `--source-root` and never writes `ANALYST_BENCHMARK_EVIDENCE_IMPLEMENTATION_SHA256` or `ANALYST_BENCHMARK_EVIDENCE_DEPENDENCY_LOCK_SHA256`, which state facts about already-published evidence. Every check the gate made still runs unchanged in every other mode.
+- `src/analyst/benchmark-implementation.test.ts` no longer keeps a second hand-copied copy of the 108-entry source manifest. `assertCompleteSourceManifest` in the checker already proves the manifest equals the import graph on every `pnpm build` and `pnpm verify:package`; the test's `EXPECTED_FILES` restated the constant it imported, so adding one source file meant editing the same list in two places. The two tests that prove the gate actually fails — a mutated bound source, and a transitive source missing from the manifest — are unchanged and now read the constant.
+
+---
+
+## [0.164.0] — 2026-08-21
+
+### Removed
+
+- `createVerifierAdapter`, `createRunCriticAdapter`, and `createJudgeAdapter` from `/analyst`, with their `VerifierAdapterOpts`, `RunCriticAdapterOpts`, and `JudgeAdapterOpts`. Every channel was silent: no import or mention across the 31 repositories the census sweeps on their default branches, no hit in a GitHub code search across the organisation outside this repository's own source and changelog, nothing in the published `dist/` of `@tangle-network/agent-runtime@0.153.1`, `@tangle-network/agent-knowledge@10.6.0`, or `@tangle-network/braid@0.2.0`, and no test, example, doc, or in-repository caller. `createSemanticConceptJudgeAdapter` is the remaining adapter and is unchanged.
+
+### Added
+
+- `docs/code-agent-intake.md`. The per-harness intake functions — `fromCodexSession`, `fromClaudeCodeSession`, `fromOpenCodeSession`, `fromKimiCodeSession`, `fromPiSession` — plus `parseCodeAgentJsonl`, `parseCodeAgentJsonlFile`, `streamCodeAgentJsonlFile`, `observeCodeAgentSession`, `parseAgentTrace`, and `partitionRunsByAuthoringModel` had no Markdown front door, which is the only reason the census read them as unused. The document states the three steps, names the fields on `CodeAgentSessionDiagnostic` and `CodeAgentSessionMetrics` that a caller must read before aggregating, and says which path to use above V8's string ceiling. Linked from the README documentation index.
+
+### Fixed
+
+- `pnpm api:census` counted `scripts/` and `benchmarks/` as no evidence at all. Neither directory was walked, so a symbol whose only caller is a maintenance script read as a deletion candidate — including `renderEvidenceIndex`, which `pnpm evidence:check` calls inside `pnpm verify:package`. Acting on that row would have failed the release gate. Both directories are now walked and count as in-package production callers, and `SOURCE_FILE` accepts `.mjs`/`.cjs`/`.js` so a `.mjs` script is read at all. Eleven symbols moved from `none` to `production` on this pass.
+- `docs/public-api.md` now records the four rules that decided the `none` review, so the next reader inherits the judgment rather than repeating the sweep. Totals moved from 903/211/238 (production/planned/none) to 926/205/220.
+
+---
+
+## [0.163.2] — 2026-08-21
+
+### Fixed
+
+- `scoreKnowledgeReadiness` and `acquisitionPlansForKnowledgeGaps` no longer emit an optional key with no value. `KnowledgeBundle.metadata` and `DataAcquisitionPlan.questions` are both declared optional, but the bundle set `metadata: options.metadata` and every non-`ask_user` plan set `questions: undefined`, so a caller that omitted them got a key present and undefined rather than an absent key. `runAgentControlLoop` fingerprints loop state with RFC 8785 canonical JSON, which refuses an `undefined`-valued field so that two states differing only in such a field cannot hash alike — so a readiness report placed in loop state aborted the run with `value has no canonical JSON form: $.metadata is undefined` and no step was ever taken. Measured downstream: every Agent Knowledge control-loop run through `createKnowledgeControlLoopAdapter` failed this way. Both sites now use the omit form already used by `reference-replay.ts` and the two measured-comparison builders.
+
+### Changed
+
+- `ANALYST_BENCHMARK_DEPENDENCY_LOCK_SHA256` is `a9eb17be…a7ef623d` for this release's manifests. The historical `ANALYST_BENCHMARK_EVIDENCE_DEPENDENCY_LOCK_SHA256` is unchanged.
+
+---
+
+## [0.163.1] — 2026-08-21
+
+### Changed
+
+- Every byte-identical private copy of a shared primitive now routes through one owner. No public export changes and no behavior changes.
+  - `mulberry32` had five implementations: the exported owner in `src/statistics/random.ts`, named private copies in `src/trajectory-replay/batch.ts` and `src/judge-calibration.ts`, and unnamed inline copies in `src/rl/contamination.ts` (`shuffleOrder`) and `src/fuzz/explorer.ts` (`FuzzExplorer.rng`). The copies used `seed >>> 0` where the owner uses `seed | 0` — the same 32 bits, so the streams are identical (verified over 150,000 draws across 15 seeds). All four are deleted. The replay fix-case sample, the judge-calibration bootstrap, the contamination probe's order-shuffle perturbation, and the fuzz explorer now inherit the owner's refusal of a non-finite seed instead of silently seeding from `NaN >>> 0 === 0`. `src/statistics/random.test.ts` pins the stream with known-answer vectors, so a future edit to the PRNG cannot silently move an already-published statistic.
+  - `toAttributes` and `msToNs` were byte-identical in `src/trace/otel.ts` and `src/trace/otel-export.ts`. Both exporters emit the same `OtlpSpan`, so two copies of the value-tagging rule meant the same attribute could be typed differently depending on which exporter ran. They are now `toOtlpAttributes` and `msToUnixNano` in the private `src/trace/otlp-encoding.ts`.
+  - `cryptoRandomId` / `cryptoEventId` / `cryptoId` were three byte-identical id mints in `src/trace/emitter.ts`, `src/llm-client.ts`, and `src/builder-eval/builder-session.ts`. Each carried a `Date.now()`-plus-`Math.random()` fallback that is unreachable on every runtime this package supports (`engines.node >= 20`, where `globalThis.crypto.randomUUID` is always present). One private `newRecordId` in `src/record-id.ts` replaces all three, and the weaker id path is gone.
+
+---
+
+
+---
+
+## [0.163.0] — 2026-08-21
+
+### Fixed
+
+- `calibrationCurve` measured the metric the caller named instead of always reading the run score. Its private extractor returned `run.outcome.score` whenever a score was present, for every metric id, and the report was then stamped with the requested `evalMetric` — so a curve labelled `costUsd` or `durationMs` plotted the score. `correlationStudy`'s separate copy returned `null` for `outputTokens` and `failureClass`, which dropped the pair from the study rather than reporting it, and an unrecognized metric id produced an empty study in both entry points instead of a refusal. Three private copies of one extractor had drifted; `runMetricExtractor` in `src/trace/query.ts` is now the only one, and an id outside `RUN_METRICS` raises `ValidationError` naming the built-in metrics.
+
+### Added
+
+- `RUN_METRICS`, `RunMetric`, `isRunMetric`, and `runMetricExtractor` on `/traces`. `RUN_METRICS` is the vocabulary `regressionView`, `correlationStudy`, and `calibrationCurve` read without a caller-supplied `extract`: `score`, `overallScore`, `pass`, `durationMs`, `costUsd`, `inputTokens`, `outputTokens`, `failureClass`. `RunMetric` derives from the array, so a metric cannot be declared without an extractor arm.
+
+### Changed
+
+- `ANALYST_BENCHMARK_DEPENDENCY_LOCK_SHA256` is `114f0786…eeb69400` for this release's manifests. The historical `ANALYST_BENCHMARK_EVIDENCE_DEPENDENCY_LOCK_SHA256` is unchanged.
+
+---
+
 ## [0.161.1] — 2026-08-21
 
 ### Changed

package/README.md

@@ -153,6 +153,7 @@ and [DSPy](./docs/campaign-proposers.md#use-official-dspy-optimizers).
 | `@tangle-network/agent-eval/benchmarks` | Benchmark adapters and retrieval metrics. |
 | `@tangle-network/agent-eval/rl` | Export rewards, preferences, and training rows. |
 | `@tangle-network/agent-eval/wire` | HTTP and RPC schemas for other languages. |
+| `@tangle-network/agent-eval/adapters/http` | Run campaign cells on remote workers over HTTP. |
 
 Use the root import for common primitives.
 Use a subpath when you want an explicit capability boundary.
@@ -169,6 +170,7 @@ Use a subpath when you want an explicit capability boundary.
 | How do I register an experiment as a sealed object? | [`docs/experiment.md`](./docs/experiment.md) |
 | How is something certified without an answer key? | [`docs/verification-strategies.md`](./docs/verification-strategies.md) |
 | Where does every verifier land its result? | [`docs/verdicts.md`](./docs/verdicts.md) |
+| How do I turn a coding-agent session log into runs? | [`docs/code-agent-intake.md`](./docs/code-agent-intake.md) |
 | How do I score a string from another language? | [`docs/wire-protocol.md`](./docs/wire-protocol.md) |
 
 The [example index](./examples/README.md) lists every runnable example.

package/dist/{active-curriculum-CD5TU2yW.js → active-curriculum-OjIWgrUJ.js}

@@ -1,4 +1,4 @@
-import { i as makeRng } from "./internal-BDHPCnjk.js";
+import { i as makeRng } from "./internal-BMFSR8Ns.js";
 import { n as observedScore } from "./reward-nw2xZGZG.js";
 //#region src/rl/active-curriculum.ts
 /**
@@ -201,4 +201,4 @@ function sampleGamma(shape, rng) {
 //#endregion
 export { thompsonCurriculum as n, varianceBasedCurriculum as r, observationsFromRunRecords as t };
 
-//# sourceMappingURL=active-curriculum-CD5TU2yW.js.map
+//# sourceMappingURL=active-curriculum-OjIWgrUJ.js.map

package/dist/{active-curriculum-CD5TU2yW.js.map → active-curriculum-OjIWgrUJ.js.map}

@@ -1 +1 @@
-{"version":3,"file":"active-curriculum-CD5TU2yW.js","names":[],"sources":["../src/rl/active-curriculum.ts"],"sourcesContent":["/**\n * Adaptive curriculum / active scenario selection.\n *\n * Fixed scenario sets waste sample budget on cells the policy already\n * passes (no information left) and cells the policy never passes (no\n * gradient available either). Active learning over scenarios fixes this\n * by allocating the next sample budget to cells where the policy's\n * outcome is *uncertain* — those carry the most decision-relevant signal.\n *\n * This module ships two complementary strategies:\n *\n *   1. **Variance-based** — score each (variant, scenario) cell by the\n *      empirical variance of past observations. Allocate next-round budget\n *      proportional to variance. Standard active-learning-by-uncertainty\n *      heuristic; works well when the policy is non-deterministic and\n *      cells differ in observation noise.\n *\n *   2. **Bandit-based (Thompson sampling)** — model each (variant,\n *      scenario) cell as a Beta-Bernoulli arm; sample a posterior; pick\n *      cells whose posterior mean is closest to the per-scenario decision\n *      threshold. The right primitive when scenarios are\n *      \"pass/fail\" rather than continuous, and when promotion gates fire\n *      at a known threshold (e.g., 0.5).\n *\n * The output is a *next-round budget allocation* — a list of (variant,\n * scenario, count) triples. The consumer's matrix runner consumes the\n * allocation, runs those cells, feeds the new observations back. Loop.\n *\n * Out of scope (deliberate): scenario *generation* — that's the\n * adversarial primitive's job. This module allocates over an existing\n * scenario pool.\n */\n\nimport { observedScore } from '../rollout/reward'\nimport type { RunRecord } from '../run-record'\nimport { makeRng } from '../statistics/internal'\n\nexport interface CellObservation {\n  variantId: string\n  scenarioId: string\n  /** Observed score in [0, 1]. */\n  score: number\n  /** For Bernoulli arms — derive from the score with a threshold if needed. */\n  pass?: boolean\n}\n\nexport interface CurriculumAllocation {\n  variantId: string\n  scenarioId: string\n  /** How many additional reps to run on this cell. */\n  count: number\n  /** Strategy-specific reason for the allocation. */\n  reason: string\n}\n\nexport interface VarianceCurriculumOptions {\n  /** Total reps to allocate across all cells. */\n  budget: number\n  /**\n   * Smoothing prior on variance — keeps the allocator from concentrating\n   * on a cell with one observation just because its 1-sample variance is\n   * 0. Default 0.05.\n   */\n  variancePrior?: number\n  /**\n   * Minimum reps per cell — even when the variance estimate is low, give\n   * every cell at least this many. Default 1.\n   */\n  floorPerCell?: number\n}\n\n/**\n * Variance-proportional allocation. For each cell, estimate variance from\n * past observations + a prior, then allocate the budget proportional to\n * (sqrt(variance) + 1/sqrt(n)) — a classical optimal-allocation rule\n * (Neyman 1934) that balances \"explore noisy cells\" with \"explore\n * under-sampled cells.\"\n */\nexport function varianceBasedCurriculum(\n  observations: CellObservation[],\n  candidateCells: Array<{ variantId: string; scenarioId: string }>,\n  opts: VarianceCurriculumOptions,\n): CurriculumAllocation[] {\n  const variancePrior = opts.variancePrior ?? 0.05\n  const floor = opts.floorPerCell ?? 1\n  const budget = opts.budget\n\n  const grouped = new Map<string, number[]>()\n  for (const o of observations) {\n    const k = `${o.variantId}::${o.scenarioId}`\n    const arr = grouped.get(k) ?? []\n    arr.push(o.score)\n    grouped.set(k, arr)\n  }\n\n  const cellStats = candidateCells.map((c) => {\n    const k = `${c.variantId}::${c.scenarioId}`\n    const samples = grouped.get(k) ?? []\n    const n = samples.length\n    const mean = n === 0 ? 0.5 : samples.reduce((s, v) => s + v, 0) / n\n    const variance =\n      n < 2\n        ? variancePrior\n        : samples.reduce((s, v) => s + (v - mean) ** 2, 0) / (n - 1) + variancePrior\n    // Neyman optimal allocation: weight ∝ √variance; add √(1/n) to break\n    // ties toward under-sampled cells.\n    const weight = Math.sqrt(variance) + 1 / Math.sqrt(Math.max(1, n))\n    return { variantId: c.variantId, scenarioId: c.scenarioId, n, mean, variance, weight }\n  })\n\n  // Reserve floor*N for the floor; allocate the rest proportional to weight.\n  const floorTotal = floor * cellStats.length\n  if (floorTotal >= budget) {\n    const each = Math.max(1, Math.floor(budget / Math.max(1, cellStats.length)))\n    return cellStats.map((c) => ({\n      variantId: c.variantId,\n      scenarioId: c.scenarioId,\n      count: each,\n      reason: `floor allocation (budget tight; n=${c.n})`,\n    }))\n  }\n  const remaining = budget - floorTotal\n  const totalWeight = cellStats.reduce((s, c) => s + c.weight, 0)\n  return cellStats.map((c) => {\n    const proportional = totalWeight === 0 ? 0 : Math.round((c.weight / totalWeight) * remaining)\n    return {\n      variantId: c.variantId,\n      scenarioId: c.scenarioId,\n      count: floor + proportional,\n      reason: `variance ${c.variance.toFixed(3)} (n=${c.n}, mean=${c.mean.toFixed(3)})`,\n    }\n  })\n}\n\nexport interface ThompsonCurriculumOptions {\n  budget: number\n  /**\n   * The per-scenario decision threshold. Cells whose posterior mean is\n   * closest to this get the most budget — that's where the next observation\n   * has the highest information value for the gate decision. Default 0.5.\n   */\n  decisionThreshold?: number\n  /** Beta prior parameters. Default α=β=1 (uniform). */\n  priorAlpha?: number\n  priorBeta?: number\n  /** Seed the Thompson sampler. Absent, the seed is derived from the observed\n   *  scores, so the same observations reproduce the same allocation. */\n  seed?: number\n}\n\n/**\n * Thompson-sampling-style allocation for pass/fail cells. For each cell:\n *\n *   - Maintain Beta(α + passes, β + failures) posterior on pass-rate\n *   - Allocation weight ∝ exp(-((sampledMean - threshold) / σ)^2):\n *     cells whose sampled posterior straddles the decision boundary get\n *     the most weight; cells already clearly above or below get less.\n *\n * This is the right primitive when promotion gates fire at a known\n * threshold and you want to sharpen the posterior near the boundary.\n */\nexport function thompsonCurriculum(\n  observations: CellObservation[],\n  candidateCells: Array<{ variantId: string; scenarioId: string }>,\n  opts: ThompsonCurriculumOptions,\n): CurriculumAllocation[] {\n  const threshold = opts.decisionThreshold ?? 0.5\n  const alpha0 = opts.priorAlpha ?? 1\n  const beta0 = opts.priorBeta ?? 1\n  const rng = makeRng(\n    opts.seed,\n    observations.map((observation) => observation.score),\n  )\n\n  const grouped = new Map<string, { passes: number; failures: number }>()\n  for (const o of observations) {\n    const k = `${o.variantId}::${o.scenarioId}`\n    const cur = grouped.get(k) ?? { passes: 0, failures: 0 }\n    const pass = o.pass ?? o.score >= threshold\n    if (pass) cur.passes += 1\n    else cur.failures += 1\n    grouped.set(k, cur)\n  }\n\n  const stats = candidateCells.map((c) => {\n    const k = `${c.variantId}::${c.scenarioId}`\n    const cur = grouped.get(k) ?? { passes: 0, failures: 0 }\n    const a = alpha0 + cur.passes\n    const b = beta0 + cur.failures\n    // Sample a single Beta draw — the Thompson signal.\n    const sampled = sampleBeta(a, b, rng)\n    const distance = Math.abs(sampled - threshold)\n    // Information-near-threshold weight: closer = higher.\n    // Use Gaussian-shaped kernel with σ tuned to posterior std.\n    const variance = (a * b) / ((a + b) ** 2 * (a + b + 1))\n    const sigma = Math.max(0.05, Math.sqrt(variance))\n    const weight = Math.exp(-((distance / sigma) ** 2))\n    return {\n      variantId: c.variantId,\n      scenarioId: c.scenarioId,\n      n: cur.passes + cur.failures,\n      sampled,\n      sigma,\n      weight,\n      a,\n      b,\n    }\n  })\n\n  const totalWeight = stats.reduce((s, c) => s + c.weight, 0)\n  return stats.map((c) => {\n    const proportional = totalWeight === 0 ? 0 : Math.round((c.weight / totalWeight) * opts.budget)\n    return {\n      variantId: c.variantId,\n      scenarioId: c.scenarioId,\n      count: Math.max(0, proportional),\n      reason: `Beta(${c.a.toFixed(1)},${c.b.toFixed(1)}) sample=${c.sampled.toFixed(3)} (target ${threshold})`,\n    }\n  })\n}\n\n/** Convenience: extract `CellObservation[]` directly from `RunRecord[]`. */\nexport function observationsFromRunRecords(\n  runs: RunRecord[],\n  opts: { passThreshold?: number; useHoldout?: boolean } = {},\n): CellObservation[] {\n  const threshold = opts.passThreshold ?? 0.5\n  const useHoldout = opts.useHoldout ?? true\n  const out: CellObservation[] = []\n  for (const r of runs) {\n    if (!r.scenarioId) continue\n    // Ungated on purpose, and the precedence is caller policy, not a default:\n    // `useHoldout: false` means \"score this curriculum on the search split when\n    // both exist\". This feeds sampling COUNTS, not an exported reward. Known\n    // risk: a gamed run's high score inflates the cell's Beta posterior, so the\n    // curriculum stops sampling a cell it wrongly believes is solved. The fix\n    // for that is an upstream filter on gated records — zeroing the score here\n    // would push the posterior the opposite way and be equally wrong.\n    const score = observedScore(r, useHoldout ? 'holdout' : 'search')\n    if (typeof score !== 'number' || !Number.isFinite(score)) continue\n    out.push({\n      variantId: r.candidateId,\n      scenarioId: r.scenarioId,\n      score,\n      pass: score >= threshold,\n    })\n  }\n  return out\n}\n\n// ── Helpers ──────────────────────────────────────────────────────────────\n\n/**\n * Sample from Beta(α, β) via the Marsaglia–Tsang method using two Gamma\n * variates. Accuracy is good for α, β > 1; we floor the parameters at 1\n * to avoid degenerate cases.\n */\nfunction sampleBeta(alpha: number, beta: number, rng: () => number): number {\n  const a = Math.max(1, alpha)\n  const b = Math.max(1, beta)\n  const x = sampleGamma(a, rng)\n  const y = sampleGamma(b, rng)\n  return x / (x + y)\n}\n\nfunction sampleGamma(shape: number, rng: () => number): number {\n  // Marsaglia–Tsang for shape ≥ 1.\n  const d = shape - 1 / 3\n  const c = 1 / Math.sqrt(9 * d)\n  while (true) {\n    let x: number\n    let v: number\n    do {\n      const u1 = rng() || 1e-12\n      const u2 = rng() || 1e-12\n      // Box-Muller for a normal sample.\n      x = Math.sqrt(-2 * Math.log(u1)) * Math.cos(2 * Math.PI * u2)\n      v = 1 + c * x\n    } while (v <= 0)\n    v = v * v * v\n    const u = rng()\n    if (u < 1 - 0.0331 * x ** 4) return d * v\n    if (Math.log(u) < 0.5 * x * x + d * (1 - v + Math.log(v))) return d * v\n  }\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AA8EA,SAAgB,wBACd,cACA,gBACA,MACwB;CACxB,MAAM,gBAAgB,KAAK,iBAAiB;CAC5C,MAAM,QAAQ,KAAK,gBAAgB;CACnC,MAAM,SAAS,KAAK;CAEpB,MAAM,0BAAU,IAAI,IAAsB;CAC1C,KAAK,MAAM,KAAK,cAAc;EAC5B,MAAM,IAAI,GAAG,EAAE,UAAU,IAAI,EAAE;EAC/B,MAAM,MAAM,QAAQ,IAAI,CAAC,KAAK,CAAC;EAC/B,IAAI,KAAK,EAAE,KAAK;EAChB,QAAQ,IAAI,GAAG,GAAG;CACpB;CAEA,MAAM,YAAY,eAAe,KAAK,MAAM;EAC1C,MAAM,IAAI,GAAG,EAAE,UAAU,IAAI,EAAE;EAC/B,MAAM,UAAU,QAAQ,IAAI,CAAC,KAAK,CAAC;EACnC,MAAM,IAAI,QAAQ;EAClB,MAAM,OAAO,MAAM,IAAI,KAAM,QAAQ,QAAQ,GAAG,MAAM,IAAI,GAAG,CAAC,IAAI;EAClE,MAAM,WACJ,IAAI,IACA,gBACA,QAAQ,QAAQ,GAAG,MAAM,KAAK,IAAI,SAAS,GAAG,CAAC,KAAK,IAAI,KAAK;EAGnE,MAAM,SAAS,KAAK,KAAK,QAAQ,IAAI,IAAI,KAAK,KAAK,KAAK,IAAI,GAAG,CAAC,CAAC;EACjE,OAAO;GAAE,WAAW,EAAE;GAAW,YAAY,EAAE;GAAY;GAAG;GAAM;GAAU;EAAO;CACvF,CAAC;CAGD,MAAM,aAAa,QAAQ,UAAU;CACrC,IAAI,cAAc,QAAQ;EACxB,MAAM,OAAO,KAAK,IAAI,GAAG,KAAK,MAAM,SAAS,KAAK,IAAI,GAAG,UAAU,MAAM,CAAC,CAAC;EAC3E,OAAO,UAAU,KAAK,OAAO;GAC3B,WAAW,EAAE;GACb,YAAY,EAAE;GACd,OAAO;GACP,QAAQ,qCAAqC,EAAE,EAAE;EACnD,EAAE;CACJ;CACA,MAAM,YAAY,SAAS;CAC3B,MAAM,cAAc,UAAU,QAAQ,GAAG,MAAM,IAAI,EAAE,QAAQ,CAAC;CAC9D,OAAO,UAAU,KAAK,MAAM;EAC1B,MAAM,eAAe,gBAAgB,IAAI,IAAI,KAAK,MAAO,EAAE,SAAS,cAAe,SAAS;EAC5F,OAAO;GACL,WAAW,EAAE;GACb,YAAY,EAAE;GACd,OAAO,QAAQ;GACf,QAAQ,YAAY,EAAE,SAAS,QAAQ,CAAC,EAAE,MAAM,EAAE,EAAE,SAAS,EAAE,KAAK,QAAQ,CAAC,EAAE;EACjF;CACF,CAAC;AACH;;;;;;;;;;;;AA6BA,SAAgB,mBACd,cACA,gBACA,MACwB;CACxB,MAAM,YAAY,KAAK,qBAAqB;CAC5C,MAAM,SAAS,KAAK,cAAc;CAClC,MAAM,QAAQ,KAAK,aAAa;CAChC,MAAM,MAAM,QACV,KAAK,MACL,aAAa,KAAK,gBAAgB,YAAY,KAAK,CACrD;CAEA,MAAM,0BAAU,IAAI,IAAkD;CACtE,KAAK,MAAM,KAAK,cAAc;EAC5B,MAAM,IAAI,GAAG,EAAE,UAAU,IAAI,EAAE;EAC/B,MAAM,MAAM,QAAQ,IAAI,CAAC,KAAK;GAAE,QAAQ;GAAG,UAAU;EAAE;EAEvD,IADa,EAAE,QAAQ,EAAE,SAAS,WACxB,IAAI,UAAU;OACnB,IAAI,YAAY;EACrB,QAAQ,IAAI,GAAG,GAAG;CACpB;CAEA,MAAM,QAAQ,eAAe,KAAK,MAAM;EACtC,MAAM,IAAI,GAAG,EAAE,UAAU,IAAI,EAAE;EAC/B,MAAM,MAAM,QAAQ,IAAI,CAAC,KAAK;GAAE,QAAQ;GAAG,UAAU;EAAE;EACvD,MAAM,IAAI,SAAS,IAAI;EACvB,MAAM,IAAI,QAAQ,IAAI;EAEtB,MAAM,UAAU,WAAW,GAAG,GAAG,GAAG;EACpC,MAAM,WAAW,KAAK,IAAI,UAAU,SAAS;EAG7C,MAAM,WAAY,IAAI,MAAO,IAAI,MAAM,KAAK,IAAI,IAAI;EACpD,MAAM,QAAQ,KAAK,IAAI,KAAM,KAAK,KAAK,QAAQ,CAAC;EAChD,MAAM,SAAS,KAAK,IAAI,GAAG,WAAW,UAAU,EAAE;EAClD,OAAO;GACL,WAAW,EAAE;GACb,YAAY,EAAE;GACd,GAAG,IAAI,SAAS,IAAI;GACpB;GACA;GACA;GACA;GACA;EACF;CACF,CAAC;CAED,MAAM,cAAc,MAAM,QAAQ,GAAG,MAAM,IAAI,EAAE,QAAQ,CAAC;CAC1D,OAAO,MAAM,KAAK,MAAM;EACtB,MAAM,eAAe,gBAAgB,IAAI,IAAI,KAAK,MAAO,EAAE,SAAS,cAAe,KAAK,MAAM;EAC9F,OAAO;GACL,WAAW,EAAE;GACb,YAAY,EAAE;GACd,OAAO,KAAK,IAAI,GAAG,YAAY;GAC/B,QAAQ,QAAQ,EAAE,EAAE,QAAQ,CAAC,EAAE,GAAG,EAAE,EAAE,QAAQ,CAAC,EAAE,WAAW,EAAE,QAAQ,QAAQ,CAAC,EAAE,WAAW,UAAU;EACxG;CACF,CAAC;AACH;;AAGA,SAAgB,2BACd,MACA,OAAyD,CAAC,GACvC;CACnB,MAAM,YAAY,KAAK,iBAAiB;CACxC,MAAM,aAAa,KAAK,cAAc;CACtC,MAAM,MAAyB,CAAC;CAChC,KAAK,MAAM,KAAK,MAAM;EACpB,IAAI,CAAC,EAAE,YAAY;EAQnB,MAAM,QAAQ,cAAc,GAAG,aAAa,YAAY,QAAQ;EAChE,IAAI,OAAO,UAAU,YAAY,CAAC,OAAO,SAAS,KAAK,GAAG;EAC1D,IAAI,KAAK;GACP,WAAW,EAAE;GACb,YAAY,EAAE;GACd;GACA,MAAM,SAAS;EACjB,CAAC;CACH;CACA,OAAO;AACT;;;;;;AASA,SAAS,WAAW,OAAe,MAAc,KAA2B;CAC1E,MAAM,IAAI,KAAK,IAAI,GAAG,KAAK;CAC3B,MAAM,IAAI,KAAK,IAAI,GAAG,IAAI;CAC1B,MAAM,IAAI,YAAY,GAAG,GAAG;CAE5B,OAAO,KAAK,IADF,YAAY,GAAG,GACT;AAClB;AAEA,SAAS,YAAY,OAAe,KAA2B;CAE7D,MAAM,IAAI,QAAQ,IAAI;CACtB,MAAM,IAAI,IAAI,KAAK,KAAK,IAAI,CAAC;CAC7B,OAAO,MAAM;EACX,IAAI;EACJ,IAAI;EACJ,GAAG;GACD,MAAM,KAAK,IAAI,KAAK;GACpB,MAAM,KAAK,IAAI,KAAK;GAEpB,IAAI,KAAK,KAAK,KAAK,KAAK,IAAI,EAAE,CAAC,IAAI,KAAK,IAAI,IAAI,KAAK,KAAK,EAAE;GAC5D,IAAI,IAAI,IAAI;EACd,SAAS,KAAK;EACd,IAAI,IAAI,IAAI;EACZ,MAAM,IAAI,IAAI;EACd,IAAI,IAAI,IAAI,QAAS,KAAK,GAAG,OAAO,IAAI;EACxC,IAAI,KAAK,IAAI,CAAC,IAAI,KAAM,IAAI,IAAI,KAAK,IAAI,IAAI,KAAK,IAAI,CAAC,IAAI,OAAO,IAAI;CACxE;AACF"}
+{"version":3,"file":"active-curriculum-OjIWgrUJ.js","names":[],"sources":["../src/rl/active-curriculum.ts"],"sourcesContent":["/**\n * Adaptive curriculum / active scenario selection.\n *\n * Fixed scenario sets waste sample budget on cells the policy already\n * passes (no information left) and cells the policy never passes (no\n * gradient available either). Active learning over scenarios fixes this\n * by allocating the next sample budget to cells where the policy's\n * outcome is *uncertain* — those carry the most decision-relevant signal.\n *\n * This module ships two complementary strategies:\n *\n *   1. **Variance-based** — score each (variant, scenario) cell by the\n *      empirical variance of past observations. Allocate next-round budget\n *      proportional to variance. Standard active-learning-by-uncertainty\n *      heuristic; works well when the policy is non-deterministic and\n *      cells differ in observation noise.\n *\n *   2. **Bandit-based (Thompson sampling)** — model each (variant,\n *      scenario) cell as a Beta-Bernoulli arm; sample a posterior; pick\n *      cells whose posterior mean is closest to the per-scenario decision\n *      threshold. The right primitive when scenarios are\n *      \"pass/fail\" rather than continuous, and when promotion gates fire\n *      at a known threshold (e.g., 0.5).\n *\n * The output is a *next-round budget allocation* — a list of (variant,\n * scenario, count) triples. The consumer's matrix runner consumes the\n * allocation, runs those cells, feeds the new observations back. Loop.\n *\n * Out of scope (deliberate): scenario *generation* — that's the\n * adversarial primitive's job. This module allocates over an existing\n * scenario pool.\n */\n\nimport { observedScore } from '../rollout/reward'\nimport type { RunRecord } from '../run-record'\nimport { makeRng } from '../statistics/internal'\n\nexport interface CellObservation {\n  variantId: string\n  scenarioId: string\n  /** Observed score in [0, 1]. */\n  score: number\n  /** For Bernoulli arms — derive from the score with a threshold if needed. */\n  pass?: boolean\n}\n\nexport interface CurriculumAllocation {\n  variantId: string\n  scenarioId: string\n  /** How many additional reps to run on this cell. */\n  count: number\n  /** Strategy-specific reason for the allocation. */\n  reason: string\n}\n\nexport interface VarianceCurriculumOptions {\n  /** Total reps to allocate across all cells. */\n  budget: number\n  /**\n   * Smoothing prior on variance — keeps the allocator from concentrating\n   * on a cell with one observation just because its 1-sample variance is\n   * 0. Default 0.05.\n   */\n  variancePrior?: number\n  /**\n   * Minimum reps per cell — even when the variance estimate is low, give\n   * every cell at least this many. Default 1.\n   */\n  floorPerCell?: number\n}\n\n/**\n * Variance-proportional allocation. For each cell, estimate variance from\n * past observations + a prior, then allocate the budget proportional to\n * (sqrt(variance) + 1/sqrt(n)) — a classical optimal-allocation rule\n * (Neyman 1934) that balances \"explore noisy cells\" with \"explore\n * under-sampled cells.\"\n */\nexport function varianceBasedCurriculum(\n  observations: CellObservation[],\n  candidateCells: Array<{ variantId: string; scenarioId: string }>,\n  opts: VarianceCurriculumOptions,\n): CurriculumAllocation[] {\n  const variancePrior = opts.variancePrior ?? 0.05\n  const floor = opts.floorPerCell ?? 1\n  const budget = opts.budget\n\n  const grouped = new Map<string, number[]>()\n  for (const o of observations) {\n    const k = `${o.variantId}::${o.scenarioId}`\n    const arr = grouped.get(k) ?? []\n    arr.push(o.score)\n    grouped.set(k, arr)\n  }\n\n  const cellStats = candidateCells.map((c) => {\n    const k = `${c.variantId}::${c.scenarioId}`\n    const samples = grouped.get(k) ?? []\n    const n = samples.length\n    const mean = n === 0 ? 0.5 : samples.reduce((s, v) => s + v, 0) / n\n    const variance =\n      n < 2\n        ? variancePrior\n        : samples.reduce((s, v) => s + (v - mean) ** 2, 0) / (n - 1) + variancePrior\n    // Neyman optimal allocation: weight ∝ √variance; add √(1/n) to break\n    // ties toward under-sampled cells.\n    const weight = Math.sqrt(variance) + 1 / Math.sqrt(Math.max(1, n))\n    return { variantId: c.variantId, scenarioId: c.scenarioId, n, mean, variance, weight }\n  })\n\n  // Reserve floor*N for the floor; allocate the rest proportional to weight.\n  const floorTotal = floor * cellStats.length\n  if (floorTotal >= budget) {\n    const each = Math.max(1, Math.floor(budget / Math.max(1, cellStats.length)))\n    return cellStats.map((c) => ({\n      variantId: c.variantId,\n      scenarioId: c.scenarioId,\n      count: each,\n      reason: `floor allocation (budget tight; n=${c.n})`,\n    }))\n  }\n  const remaining = budget - floorTotal\n  const totalWeight = cellStats.reduce((s, c) => s + c.weight, 0)\n  return cellStats.map((c) => {\n    const proportional = totalWeight === 0 ? 0 : Math.round((c.weight / totalWeight) * remaining)\n    return {\n      variantId: c.variantId,\n      scenarioId: c.scenarioId,\n      count: floor + proportional,\n      reason: `variance ${c.variance.toFixed(3)} (n=${c.n}, mean=${c.mean.toFixed(3)})`,\n    }\n  })\n}\n\nexport interface ThompsonCurriculumOptions {\n  budget: number\n  /**\n   * The per-scenario decision threshold. Cells whose posterior mean is\n   * closest to this get the most budget — that's where the next observation\n   * has the highest information value for the gate decision. Default 0.5.\n   */\n  decisionThreshold?: number\n  /** Beta prior parameters. Default α=β=1 (uniform). */\n  priorAlpha?: number\n  priorBeta?: number\n  /** Seed the Thompson sampler. Absent, the seed is derived from the observed\n   *  scores, so the same observations reproduce the same allocation. */\n  seed?: number\n}\n\n/**\n * Thompson-sampling-style allocation for pass/fail cells. For each cell:\n *\n *   - Maintain Beta(α + passes, β + failures) posterior on pass-rate\n *   - Allocation weight ∝ exp(-((sampledMean - threshold) / σ)^2):\n *     cells whose sampled posterior straddles the decision boundary get\n *     the most weight; cells already clearly above or below get less.\n *\n * This is the right primitive when promotion gates fire at a known\n * threshold and you want to sharpen the posterior near the boundary.\n */\nexport function thompsonCurriculum(\n  observations: CellObservation[],\n  candidateCells: Array<{ variantId: string; scenarioId: string }>,\n  opts: ThompsonCurriculumOptions,\n): CurriculumAllocation[] {\n  const threshold = opts.decisionThreshold ?? 0.5\n  const alpha0 = opts.priorAlpha ?? 1\n  const beta0 = opts.priorBeta ?? 1\n  const rng = makeRng(\n    opts.seed,\n    observations.map((observation) => observation.score),\n  )\n\n  const grouped = new Map<string, { passes: number; failures: number }>()\n  for (const o of observations) {\n    const k = `${o.variantId}::${o.scenarioId}`\n    const cur = grouped.get(k) ?? { passes: 0, failures: 0 }\n    const pass = o.pass ?? o.score >= threshold\n    if (pass) cur.passes += 1\n    else cur.failures += 1\n    grouped.set(k, cur)\n  }\n\n  const stats = candidateCells.map((c) => {\n    const k = `${c.variantId}::${c.scenarioId}`\n    const cur = grouped.get(k) ?? { passes: 0, failures: 0 }\n    const a = alpha0 + cur.passes\n    const b = beta0 + cur.failures\n    // Sample a single Beta draw — the Thompson signal.\n    const sampled = sampleBeta(a, b, rng)\n    const distance = Math.abs(sampled - threshold)\n    // Information-near-threshold weight: closer = higher.\n    // Use Gaussian-shaped kernel with σ tuned to posterior std.\n    const variance = (a * b) / ((a + b) ** 2 * (a + b + 1))\n    const sigma = Math.max(0.05, Math.sqrt(variance))\n    const weight = Math.exp(-((distance / sigma) ** 2))\n    return {\n      variantId: c.variantId,\n      scenarioId: c.scenarioId,\n      n: cur.passes + cur.failures,\n      sampled,\n      sigma,\n      weight,\n      a,\n      b,\n    }\n  })\n\n  const totalWeight = stats.reduce((s, c) => s + c.weight, 0)\n  return stats.map((c) => {\n    const proportional = totalWeight === 0 ? 0 : Math.round((c.weight / totalWeight) * opts.budget)\n    return {\n      variantId: c.variantId,\n      scenarioId: c.scenarioId,\n      count: Math.max(0, proportional),\n      reason: `Beta(${c.a.toFixed(1)},${c.b.toFixed(1)}) sample=${c.sampled.toFixed(3)} (target ${threshold})`,\n    }\n  })\n}\n\n/** Convenience: extract `CellObservation[]` directly from `RunRecord[]`. */\nexport function observationsFromRunRecords(\n  runs: RunRecord[],\n  opts: { passThreshold?: number; useHoldout?: boolean } = {},\n): CellObservation[] {\n  const threshold = opts.passThreshold ?? 0.5\n  const useHoldout = opts.useHoldout ?? true\n  const out: CellObservation[] = []\n  for (const r of runs) {\n    if (!r.scenarioId) continue\n    // Ungated on purpose, and the precedence is caller policy, not a default:\n    // `useHoldout: false` means \"score this curriculum on the search split when\n    // both exist\". This feeds sampling COUNTS, not an exported reward. Known\n    // risk: a gamed run's high score inflates the cell's Beta posterior, so the\n    // curriculum stops sampling a cell it wrongly believes is solved. The fix\n    // for that is an upstream filter on gated records — zeroing the score here\n    // would push the posterior the opposite way and be equally wrong.\n    const score = observedScore(r, useHoldout ? 'holdout' : 'search')\n    if (typeof score !== 'number' || !Number.isFinite(score)) continue\n    out.push({\n      variantId: r.candidateId,\n      scenarioId: r.scenarioId,\n      score,\n      pass: score >= threshold,\n    })\n  }\n  return out\n}\n\n// ── Helpers ──────────────────────────────────────────────────────────────\n\n/**\n * Sample from Beta(α, β) via the Marsaglia–Tsang method using two Gamma\n * variates. Accuracy is good for α, β > 1; we floor the parameters at 1\n * to avoid degenerate cases.\n */\nfunction sampleBeta(alpha: number, beta: number, rng: () => number): number {\n  const a = Math.max(1, alpha)\n  const b = Math.max(1, beta)\n  const x = sampleGamma(a, rng)\n  const y = sampleGamma(b, rng)\n  return x / (x + y)\n}\n\nfunction sampleGamma(shape: number, rng: () => number): number {\n  // Marsaglia–Tsang for shape ≥ 1.\n  const d = shape - 1 / 3\n  const c = 1 / Math.sqrt(9 * d)\n  while (true) {\n    let x: number\n    let v: number\n    do {\n      const u1 = rng() || 1e-12\n      const u2 = rng() || 1e-12\n      // Box-Muller for a normal sample.\n      x = Math.sqrt(-2 * Math.log(u1)) * Math.cos(2 * Math.PI * u2)\n      v = 1 + c * x\n    } while (v <= 0)\n    v = v * v * v\n    const u = rng()\n    if (u < 1 - 0.0331 * x ** 4) return d * v\n    if (Math.log(u) < 0.5 * x * x + d * (1 - v + Math.log(v))) return d * v\n  }\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AA8EA,SAAgB,wBACd,cACA,gBACA,MACwB;CACxB,MAAM,gBAAgB,KAAK,iBAAiB;CAC5C,MAAM,QAAQ,KAAK,gBAAgB;CACnC,MAAM,SAAS,KAAK;CAEpB,MAAM,0BAAU,IAAI,IAAsB;CAC1C,KAAK,MAAM,KAAK,cAAc;EAC5B,MAAM,IAAI,GAAG,EAAE,UAAU,IAAI,EAAE;EAC/B,MAAM,MAAM,QAAQ,IAAI,CAAC,KAAK,CAAC;EAC/B,IAAI,KAAK,EAAE,KAAK;EAChB,QAAQ,IAAI,GAAG,GAAG;CACpB;CAEA,MAAM,YAAY,eAAe,KAAK,MAAM;EAC1C,MAAM,IAAI,GAAG,EAAE,UAAU,IAAI,EAAE;EAC/B,MAAM,UAAU,QAAQ,IAAI,CAAC,KAAK,CAAC;EACnC,MAAM,IAAI,QAAQ;EAClB,MAAM,OAAO,MAAM,IAAI,KAAM,QAAQ,QAAQ,GAAG,MAAM,IAAI,GAAG,CAAC,IAAI;EAClE,MAAM,WACJ,IAAI,IACA,gBACA,QAAQ,QAAQ,GAAG,MAAM,KAAK,IAAI,SAAS,GAAG,CAAC,KAAK,IAAI,KAAK;EAGnE,MAAM,SAAS,KAAK,KAAK,QAAQ,IAAI,IAAI,KAAK,KAAK,KAAK,IAAI,GAAG,CAAC,CAAC;EACjE,OAAO;GAAE,WAAW,EAAE;GAAW,YAAY,EAAE;GAAY;GAAG;GAAM;GAAU;EAAO;CACvF,CAAC;CAGD,MAAM,aAAa,QAAQ,UAAU;CACrC,IAAI,cAAc,QAAQ;EACxB,MAAM,OAAO,KAAK,IAAI,GAAG,KAAK,MAAM,SAAS,KAAK,IAAI,GAAG,UAAU,MAAM,CAAC,CAAC;EAC3E,OAAO,UAAU,KAAK,OAAO;GAC3B,WAAW,EAAE;GACb,YAAY,EAAE;GACd,OAAO;GACP,QAAQ,qCAAqC,EAAE,EAAE;EACnD,EAAE;CACJ;CACA,MAAM,YAAY,SAAS;CAC3B,MAAM,cAAc,UAAU,QAAQ,GAAG,MAAM,IAAI,EAAE,QAAQ,CAAC;CAC9D,OAAO,UAAU,KAAK,MAAM;EAC1B,MAAM,eAAe,gBAAgB,IAAI,IAAI,KAAK,MAAO,EAAE,SAAS,cAAe,SAAS;EAC5F,OAAO;GACL,WAAW,EAAE;GACb,YAAY,EAAE;GACd,OAAO,QAAQ;GACf,QAAQ,YAAY,EAAE,SAAS,QAAQ,CAAC,EAAE,MAAM,EAAE,EAAE,SAAS,EAAE,KAAK,QAAQ,CAAC,EAAE;EACjF;CACF,CAAC;AACH;;;;;;;;;;;;AA6BA,SAAgB,mBACd,cACA,gBACA,MACwB;CACxB,MAAM,YAAY,KAAK,qBAAqB;CAC5C,MAAM,SAAS,KAAK,cAAc;CAClC,MAAM,QAAQ,KAAK,aAAa;CAChC,MAAM,MAAM,QACV,KAAK,MACL,aAAa,KAAK,gBAAgB,YAAY,KAAK,CACrD;CAEA,MAAM,0BAAU,IAAI,IAAkD;CACtE,KAAK,MAAM,KAAK,cAAc;EAC5B,MAAM,IAAI,GAAG,EAAE,UAAU,IAAI,EAAE;EAC/B,MAAM,MAAM,QAAQ,IAAI,CAAC,KAAK;GAAE,QAAQ;GAAG,UAAU;EAAE;EAEvD,IADa,EAAE,QAAQ,EAAE,SAAS,WACxB,IAAI,UAAU;OACnB,IAAI,YAAY;EACrB,QAAQ,IAAI,GAAG,GAAG;CACpB;CAEA,MAAM,QAAQ,eAAe,KAAK,MAAM;EACtC,MAAM,IAAI,GAAG,EAAE,UAAU,IAAI,EAAE;EAC/B,MAAM,MAAM,QAAQ,IAAI,CAAC,KAAK;GAAE,QAAQ;GAAG,UAAU;EAAE;EACvD,MAAM,IAAI,SAAS,IAAI;EACvB,MAAM,IAAI,QAAQ,IAAI;EAEtB,MAAM,UAAU,WAAW,GAAG,GAAG,GAAG;EACpC,MAAM,WAAW,KAAK,IAAI,UAAU,SAAS;EAG7C,MAAM,WAAY,IAAI,MAAO,IAAI,MAAM,KAAK,IAAI,IAAI;EACpD,MAAM,QAAQ,KAAK,IAAI,KAAM,KAAK,KAAK,QAAQ,CAAC;EAChD,MAAM,SAAS,KAAK,IAAI,GAAG,WAAW,UAAU,EAAE;EAClD,OAAO;GACL,WAAW,EAAE;GACb,YAAY,EAAE;GACd,GAAG,IAAI,SAAS,IAAI;GACpB;GACA;GACA;GACA;GACA;EACF;CACF,CAAC;CAED,MAAM,cAAc,MAAM,QAAQ,GAAG,MAAM,IAAI,EAAE,QAAQ,CAAC;CAC1D,OAAO,MAAM,KAAK,MAAM;EACtB,MAAM,eAAe,gBAAgB,IAAI,IAAI,KAAK,MAAO,EAAE,SAAS,cAAe,KAAK,MAAM;EAC9F,OAAO;GACL,WAAW,EAAE;GACb,YAAY,EAAE;GACd,OAAO,KAAK,IAAI,GAAG,YAAY;GAC/B,QAAQ,QAAQ,EAAE,EAAE,QAAQ,CAAC,EAAE,GAAG,EAAE,EAAE,QAAQ,CAAC,EAAE,WAAW,EAAE,QAAQ,QAAQ,CAAC,EAAE,WAAW,UAAU;EACxG;CACF,CAAC;AACH;;AAGA,SAAgB,2BACd,MACA,OAAyD,CAAC,GACvC;CACnB,MAAM,YAAY,KAAK,iBAAiB;CACxC,MAAM,aAAa,KAAK,cAAc;CACtC,MAAM,MAAyB,CAAC;CAChC,KAAK,MAAM,KAAK,MAAM;EACpB,IAAI,CAAC,EAAE,YAAY;EAQnB,MAAM,QAAQ,cAAc,GAAG,aAAa,YAAY,QAAQ;EAChE,IAAI,OAAO,UAAU,YAAY,CAAC,OAAO,SAAS,KAAK,GAAG;EAC1D,IAAI,KAAK;GACP,WAAW,EAAE;GACb,YAAY,EAAE;GACd;GACA,MAAM,SAAS;EACjB,CAAC;CACH;CACA,OAAO;AACT;;;;;;AASA,SAAS,WAAW,OAAe,MAAc,KAA2B;CAC1E,MAAM,IAAI,KAAK,IAAI,GAAG,KAAK;CAC3B,MAAM,IAAI,KAAK,IAAI,GAAG,IAAI;CAC1B,MAAM,IAAI,YAAY,GAAG,GAAG;CAE5B,OAAO,KAAK,IADF,YAAY,GAAG,GACT;AAClB;AAEA,SAAS,YAAY,OAAe,KAA2B;CAE7D,MAAM,IAAI,QAAQ,IAAI;CACtB,MAAM,IAAI,IAAI,KAAK,KAAK,IAAI,CAAC;CAC7B,OAAO,MAAM;EACX,IAAI;EACJ,IAAI;EACJ,GAAG;GACD,MAAM,KAAK,IAAI,KAAK;GACpB,MAAM,KAAK,IAAI,KAAK;GAEpB,IAAI,KAAK,KAAK,KAAK,KAAK,IAAI,EAAE,CAAC,IAAI,KAAK,IAAI,IAAI,KAAK,KAAK,EAAE;GAC5D,IAAI,IAAI,IAAI;EACd,SAAS,KAAK;EACd,IAAI,IAAI,IAAI;EACZ,MAAM,IAAI,IAAI;EACd,IAAI,IAAI,IAAI,QAAS,KAAK,GAAG,OAAO,IAAI;EACxC,IAAI,KAAK,IAAI,CAAC,IAAI,KAAM,IAAI,IAAI,KAAK,IAAI,IAAI,KAAK,IAAI,CAAC,IAAI,OAAO,IAAI;CACxE;AACF"}

package/dist/adapters/http.d.ts

@@ -0,0 +1,108 @@
+import { R as Scenario, d as DispatchContext, f as DispatchFn } from "../types-Dy237wiH.js";
+import "../index-Bfs5aufo.js";
+//#region src/adapters/http.d.ts
+interface HttpDispatchOptions<TScenario extends Scenario, _TArtifact> {
+  /** Static endpoint URL. Mutually exclusive with `resolveUrl`. */
+  url?: string;
+  /**
+   * Dynamic per-cell URL resolver. Receives the scenario + the substrate
+   * placement key (from `RunCampaignOptions.cellPlacement`) and returns the
+   * worker URL to invoke. Mutually exclusive with `url`.
+   */
+  resolveUrl?: (input: {
+    scenario: TScenario;
+    placement?: string;
+    cellId: string;
+  }) => string;
+  /** Bearer token or static auth string set as `Authorization`. */
+  auth?: string | (() => string | Promise<string>);
+  /** Extra headers merged into every request. */
+  headers?: Record<string, string>;
+  /** Per-call timeout in ms. Default 5 minutes. */
+  timeoutMs?: number;
+  /** How many idempotent retries on 5xx / network errors. Default 2. */
+  retries?: number;
+  /** Optional fetch override (auth wrappers, custom agent, mocks). */
+  fetchImpl?: typeof fetch;
+}
+interface HttpDispatchRequestBody<TScenario extends Scenario> {
+  scenario: TScenario;
+  cellId: string;
+  runAttemptId: string;
+  rep: number;
+  generation?: number;
+  seed: number;
+  placement?: string;
+  cycleId?: string;
+}
+interface HttpDispatchResponseBody<TArtifact> {
+  artifact: TArtifact;
+}
+/**
+ * Wrap a remote HTTP endpoint as a `Dispatch`. The remote side should run
+ * `runDispatchServer` (or any service that speaks the same wire shape).
+ *
+ * Cancellation: the substrate's per-cell `AbortSignal` is forwarded; the
+ * server's `runDispatchServer` translates the resulting `AbortError` into
+ * a 499 (client-closed) so the client doesn't retry.
+ */
+declare function httpDispatch<TScenario extends Scenario, TArtifact>(opts: HttpDispatchOptions<TScenario, TArtifact>): DispatchFn<TScenario, TArtifact>;
+interface RunDispatchServerOptions<TScenario extends Scenario, TArtifact> {
+  /** The Dispatch this server exposes — what runs when a request lands. */
+  dispatch: DispatchFn<TScenario, TArtifact>;
+  /** TCP port to bind. */
+  port: number;
+  /** Optional bind host; defaults to 0.0.0.0. */
+  host?: string;
+  /** Required for any non-test deployment: the bearer token clients must
+   *  send. The substrate refuses to start without auth unless `auth: false`
+   *  is set explicitly (intended ONLY for closed-network/internal testing). */
+  auth: string | false;
+  /** Path the server listens on. Default `/dispatch`. */
+  path?: string;
+  /**
+   * Per-request handler that wraps `dispatch` with whatever context the
+   * worker side needs to construct a `DispatchContext` — typically the
+   * trace writer, artifact writer, and cost meter. The substrate provides
+   * synthetic-but-typed defaults if not supplied; production deployments
+   * should wire real ones (e.g. ship traces to your OTel collector).
+   */
+  contextFactory?: (req: HttpDispatchRequestBody<TScenario>, signal: AbortSignal) => Promise<DispatchContext>;
+  /** Optional max payload size for the request body (bytes). Default 10 MB. */
+  maxBodyBytes?: number;
+  /** Hook for observability — called on every successful or failed turn. */
+  onRequest?: (event: {
+    cellId: string;
+    durationMs: number;
+    success: boolean;
+    error?: unknown;
+  }) => void;
+}
+interface DispatchServerHandle {
+  /** The actual bound port (useful when `port: 0` requests an ephemeral port). */
+  port: number;
+  /** Stop accepting new connections and drain existing ones. */
+  close: () => Promise<void>;
+}
+/**
+ * Start an HTTP server exposing a local `Dispatch` over the wire. Pair with
+ * `httpDispatch` on the driver side.
+ *
+ * Wire shape:
+ *
+ *   POST /dispatch
+ *   Authorization: Bearer <token>
+ *   Body: HttpDispatchRequestBody
+ *   200 OK: HttpDispatchResponseBody
+ *   401: missing/invalid auth
+ *   408: per-request timeout exceeded
+ *   499: client aborted before completion
+ *   500: dispatch threw
+ *
+ * The server is `node:http`-based to keep the runtime dependency surface
+ * minimal — works in plain Node, sandbox, or any container.
+ */
+declare function runDispatchServer<TScenario extends Scenario, TArtifact>(opts: RunDispatchServerOptions<TScenario, TArtifact>): Promise<DispatchServerHandle>;
+//#endregion
+export { DispatchServerHandle, HttpDispatchOptions, HttpDispatchRequestBody, HttpDispatchResponseBody, RunDispatchServerOptions, httpDispatch, runDispatchServer };
+//# sourceMappingURL=http.d.ts.map

package/dist/adapters/http.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"http.d.ts","names":[],"sources":["../../src/adapters/http.ts"],"mappings":";;;UA0CiB,oBAAoB,kBAAkB,UAAU;;EAE/D;;;;;;EAMA,cAAc;IAAS,UAAU;IAAW;IAAoB;;;EAEhE,gCAAgC;;EAEhC,UAAU;;EAEV;;EAEA;;EAEA,mBAAmB;;UAGJ,wBAAwB,kBAAkB;EACzD,UAAU;EACV;EACA;EACA;EACA;EACA;EACA;EACA;;UAGe,yBAAyB;EACxC,UAAU;;;;;;;;;;iBAiBI,aAAa,kBAAkB,UAAU,WACvD,MAAM,oBAAoB,WAAW,aACpC,WAAS,WAAW;UAqFN,yBAAyB,kBAAkB,UAAU;;EAEpE,UAAU,WAAS,WAAW;;EAE9B;;EAEA;;;;EAIA;;EAEA;;;;;;;;EAQA,kBACE,KAAK,wBAAwB,YAC7B,QAAQ,gBACL,QAAQ;;EAEb;;EAEA,aAAa;IACX;IACA;IACA;IACA;;;UAIa;;EAEf;;EAEA,aAAa;;;;;;;;;;;;;;;;;;;;iBAqBO,kBAAkB,kBAAkB,UAAU,WAClE,MAAM,yBAAyB,WAAW,aACzC,QAAQ"}

package/dist/adapters/http.js

@@ -0,0 +1,208 @@
+//#region src/adapters/http.ts
+function resolveAuth(auth) {
+	if (!auth) return Promise.resolve(null);
+	if (typeof auth === "string") return Promise.resolve(auth);
+	return Promise.resolve(auth());
+}
+/**
+* Wrap a remote HTTP endpoint as a `Dispatch`. The remote side should run
+* `runDispatchServer` (or any service that speaks the same wire shape).
+*
+* Cancellation: the substrate's per-cell `AbortSignal` is forwarded; the
+* server's `runDispatchServer` translates the resulting `AbortError` into
+* a 499 (client-closed) so the client doesn't retry.
+*/
+function httpDispatch(opts) {
+	if (!opts.url && !opts.resolveUrl) throw new Error("httpDispatch: pass exactly one of `url` or `resolveUrl`.");
+	if (opts.url && opts.resolveUrl) throw new Error("httpDispatch: pass exactly one of `url` or `resolveUrl`, not both.");
+	const timeoutMs = opts.timeoutMs ?? 300 * 1e3;
+	const maxRetries = opts.retries ?? 2;
+	const f = opts.fetchImpl ?? ((...args) => fetch(...args));
+	return async (scenario, ctx) => {
+		const url = opts.url ?? opts.resolveUrl({
+			scenario,
+			placement: ctx.placement,
+			cellId: ctx.cellId
+		});
+		const authValue = await resolveAuth(opts.auth);
+		const body = {
+			scenario,
+			cellId: ctx.cellId,
+			runAttemptId: ctx.runAttemptId,
+			rep: ctx.rep,
+			generation: ctx.generation,
+			seed: ctx.seed,
+			placement: ctx.placement,
+			cycleId: ctx.cycleId
+		};
+		let lastError;
+		for (let attempt = 0; attempt <= maxRetries; attempt++) {
+			const ourTimeout = AbortSignal.timeout(timeoutMs);
+			const combinedSignal = AbortSignal.any([ctx.signal, ourTimeout]);
+			try {
+				const res = await f(url, {
+					method: "POST",
+					headers: {
+						"Content-Type": "application/json",
+						...authValue ? { Authorization: authValue.startsWith("Bearer ") ? authValue : `Bearer ${authValue}` } : {},
+						...opts.headers
+					},
+					body: JSON.stringify(body),
+					signal: combinedSignal
+				});
+				if (!res.ok) {
+					if (!(res.status >= 500 || res.status === 408 || res.status === 429) || attempt === maxRetries) {
+						const text = await res.text().catch(() => "");
+						throw new Error(`httpDispatch ${url} failed (${res.status}): ${text.slice(0, 500)}`);
+					}
+					await sleep(2 ** attempt * 200 + Math.random() * 200);
+					continue;
+				}
+				return (await res.json()).artifact;
+			} catch (err) {
+				if (ctx.signal.aborted) throw err;
+				lastError = err;
+				if (attempt === maxRetries) throw err;
+				await sleep(2 ** attempt * 200 + Math.random() * 200);
+			}
+		}
+		throw lastError ?? /* @__PURE__ */ new Error("httpDispatch exhausted retries");
+	};
+}
+function sleep(ms) {
+	return new Promise((resolve) => {
+		const t = setTimeout(resolve, ms);
+		if (typeof t.unref === "function") t.unref();
+	});
+}
+/**
+* Start an HTTP server exposing a local `Dispatch` over the wire. Pair with
+* `httpDispatch` on the driver side.
+*
+* Wire shape:
+*
+*   POST /dispatch
+*   Authorization: Bearer <token>
+*   Body: HttpDispatchRequestBody
+*   200 OK: HttpDispatchResponseBody
+*   401: missing/invalid auth
+*   408: per-request timeout exceeded
+*   499: client aborted before completion
+*   500: dispatch threw
+*
+* The server is `node:http`-based to keep the runtime dependency surface
+* minimal — works in plain Node, sandbox, or any container.
+*/
+async function runDispatchServer(opts) {
+	if (opts.auth === void 0) throw new Error("runDispatchServer: 'auth' is required (pass a bearer-token string, or `auth: false` explicitly for a closed-network test deployment).");
+	const path = opts.path ?? "/dispatch";
+	const maxBytes = opts.maxBodyBytes ?? 10 * 1024 * 1024;
+	const expectedAuth = typeof opts.auth === "string" ? `Bearer ${opts.auth.replace(/^Bearer\s+/, "")}` : null;
+	const { createServer } = await import("node:http");
+	const server = createServer(async (req, res) => {
+		const start = Date.now();
+		let cellId = "unknown";
+		let success = false;
+		let errCaught;
+		try {
+			if (req.method !== "POST" || req.url?.split("?")[0] !== path) {
+				res.statusCode = 404;
+				res.end("not found");
+				return;
+			}
+			if (expectedAuth) {
+				if (req.headers.authorization !== expectedAuth) {
+					res.statusCode = 401;
+					res.end("unauthorized");
+					return;
+				}
+			}
+			const chunks = [];
+			let totalBytes = 0;
+			const aborter = new AbortController();
+			res.on("close", () => {
+				if (!res.writableEnded) aborter.abort();
+			});
+			for await (const chunk of req) {
+				const buf = chunk;
+				totalBytes += buf.length;
+				if (totalBytes > maxBytes) {
+					res.statusCode = 413;
+					res.end("payload too large");
+					return;
+				}
+				chunks.push(buf);
+			}
+			const body = JSON.parse(Buffer.concat(chunks).toString("utf8"));
+			if (typeof body.runAttemptId !== "string" || body.runAttemptId.trim().length === 0) throw new Error("runDispatchServer: request runAttemptId is required");
+			cellId = body.cellId;
+			const ctx = opts.contextFactory ? await opts.contextFactory(body, aborter.signal) : {
+				cellId: body.cellId,
+				runAttemptId: body.runAttemptId,
+				rep: body.rep,
+				generation: body.generation,
+				seed: body.seed,
+				signal: aborter.signal,
+				placement: body.placement,
+				cycleId: body.cycleId,
+				trace: NOOP_TRACE,
+				artifacts: NOOP_ARTIFACTS,
+				cost: NOOP_COST
+			};
+			if (ctx.runAttemptId !== body.runAttemptId) throw new Error("runDispatchServer: contextFactory must preserve request runAttemptId");
+			const responseBody = { artifact: await opts.dispatch(body.scenario, ctx) };
+			res.statusCode = 200;
+			res.setHeader("content-type", "application/json");
+			res.end(JSON.stringify(responseBody));
+			success = true;
+		} catch (err) {
+			errCaught = err;
+			if (err?.name === "AbortError") {
+				res.statusCode = 499;
+				res.end("client aborted");
+				return;
+			}
+			res.statusCode = 500;
+			res.setHeader("content-type", "application/json");
+			res.end(JSON.stringify({ error: err instanceof Error ? err.message : String(err) }));
+		} finally {
+			opts.onRequest?.({
+				cellId,
+				durationMs: Date.now() - start,
+				success,
+				error: errCaught
+			});
+		}
+	});
+	await new Promise((resolve, reject) => {
+		server.once("error", reject);
+		server.listen(opts.port, opts.host ?? "0.0.0.0", () => resolve());
+	});
+	const addr = server.address();
+	return {
+		port: typeof addr === "object" && addr ? addr.port : opts.port,
+		close: () => new Promise((resolve, reject) => {
+			server.close((err) => err ? reject(err) : resolve());
+		})
+	};
+}
+const NOOP_TRACE = { span: () => ({
+	end: () => {},
+	setAttribute: () => {},
+	setStatus: () => {},
+	recordException: () => {},
+	addEvent: () => {}
+}) };
+const NOOP_ARTIFACTS = {
+	write: async () => void 0,
+	read: async () => void 0,
+	list: async () => []
+};
+const NOOP_COST = {
+	record: () => {},
+	total: () => 0
+};
+//#endregion
+export { httpDispatch, runDispatchServer };
+
+//# sourceMappingURL=http.js.map