@tangle-network/agent-eval 0.129.0 → 0.130.1

package/dist/chunk-G7MGMCZD.js

@@ -1,153 +0,0 @@
-import {
-  observedScore
-} from "./chunk-OIUOT4QD.js";
-
-// src/rl/active-curriculum.ts
-function varianceBasedCurriculum(observations, candidateCells, opts) {
-  const variancePrior = opts.variancePrior ?? 0.05;
-  const floor = opts.floorPerCell ?? 1;
-  const budget = opts.budget;
-  const grouped = /* @__PURE__ */ new Map();
-  for (const o of observations) {
-    const k = `${o.variantId}::${o.scenarioId}`;
-    const arr = grouped.get(k) ?? [];
-    arr.push(o.score);
-    grouped.set(k, arr);
-  }
-  const cellStats = candidateCells.map((c) => {
-    const k = `${c.variantId}::${c.scenarioId}`;
-    const samples = grouped.get(k) ?? [];
-    const n = samples.length;
-    const mean = n === 0 ? 0.5 : samples.reduce((s, v) => s + v, 0) / n;
-    const variance = n < 2 ? variancePrior : samples.reduce((s, v) => s + (v - mean) ** 2, 0) / (n - 1) + variancePrior;
-    const weight = Math.sqrt(variance) + 1 / Math.sqrt(Math.max(1, n));
-    return { variantId: c.variantId, scenarioId: c.scenarioId, n, mean, variance, weight };
-  });
-  const floorTotal = floor * cellStats.length;
-  if (floorTotal >= budget) {
-    const each = Math.max(1, Math.floor(budget / Math.max(1, cellStats.length)));
-    return cellStats.map((c) => ({
-      variantId: c.variantId,
-      scenarioId: c.scenarioId,
-      count: each,
-      reason: `floor allocation (budget tight; n=${c.n})`
-    }));
-  }
-  const remaining = budget - floorTotal;
-  const totalWeight = cellStats.reduce((s, c) => s + c.weight, 0);
-  return cellStats.map((c) => {
-    const proportional = totalWeight === 0 ? 0 : Math.round(c.weight / totalWeight * remaining);
-    return {
-      variantId: c.variantId,
-      scenarioId: c.scenarioId,
-      count: floor + proportional,
-      reason: `variance ${c.variance.toFixed(3)} (n=${c.n}, mean=${c.mean.toFixed(3)})`
-    };
-  });
-}
-function thompsonCurriculum(observations, candidateCells, opts) {
-  const threshold = opts.decisionThreshold ?? 0.5;
-  const alpha0 = opts.priorAlpha ?? 1;
-  const beta0 = opts.priorBeta ?? 1;
-  const rng = makeRng(opts.seed);
-  const grouped = /* @__PURE__ */ new Map();
-  for (const o of observations) {
-    const k = `${o.variantId}::${o.scenarioId}`;
-    const cur = grouped.get(k) ?? { passes: 0, failures: 0 };
-    const pass = o.pass ?? o.score >= threshold;
-    if (pass) cur.passes += 1;
-    else cur.failures += 1;
-    grouped.set(k, cur);
-  }
-  const stats = candidateCells.map((c) => {
-    const k = `${c.variantId}::${c.scenarioId}`;
-    const cur = grouped.get(k) ?? { passes: 0, failures: 0 };
-    const a = alpha0 + cur.passes;
-    const b = beta0 + cur.failures;
-    const sampled = sampleBeta(a, b, rng);
-    const distance = Math.abs(sampled - threshold);
-    const variance = a * b / ((a + b) ** 2 * (a + b + 1));
-    const sigma = Math.max(0.05, Math.sqrt(variance));
-    const weight = Math.exp(-((distance / sigma) ** 2));
-    return {
-      variantId: c.variantId,
-      scenarioId: c.scenarioId,
-      n: cur.passes + cur.failures,
-      sampled,
-      sigma,
-      weight,
-      a,
-      b
-    };
-  });
-  const totalWeight = stats.reduce((s, c) => s + c.weight, 0);
-  return stats.map((c) => {
-    const proportional = totalWeight === 0 ? 0 : Math.round(c.weight / totalWeight * opts.budget);
-    return {
-      variantId: c.variantId,
-      scenarioId: c.scenarioId,
-      count: Math.max(0, proportional),
-      reason: `Beta(${c.a.toFixed(1)},${c.b.toFixed(1)}) sample=${c.sampled.toFixed(3)} (target ${threshold})`
-    };
-  });
-}
-function observationsFromRunRecords(runs, opts = {}) {
-  const threshold = opts.passThreshold ?? 0.5;
-  const useHoldout = opts.useHoldout ?? true;
-  const out = [];
-  for (const r of runs) {
-    if (!r.scenarioId) continue;
-    const score = observedScore(r, useHoldout ? "holdout" : "search");
-    if (typeof score !== "number" || !Number.isFinite(score)) continue;
-    out.push({
-      variantId: r.candidateId,
-      scenarioId: r.scenarioId,
-      score,
-      pass: score >= threshold
-    });
-  }
-  return out;
-}
-function makeRng(seed) {
-  if (seed === void 0) return Math.random;
-  let s = seed >>> 0;
-  return () => {
-    s = s + 1831565813 >>> 0;
-    let t = s;
-    t = Math.imul(t ^ t >>> 15, t | 1);
-    t ^= t + Math.imul(t ^ t >>> 7, t | 61);
-    return ((t ^ t >>> 14) >>> 0) / 4294967296;
-  };
-}
-function sampleBeta(alpha, beta, rng) {
-  const a = Math.max(1, alpha);
-  const b = Math.max(1, beta);
-  const x = sampleGamma(a, rng);
-  const y = sampleGamma(b, rng);
-  return x / (x + y);
-}
-function sampleGamma(shape, rng) {
-  const d = shape - 1 / 3;
-  const c = 1 / Math.sqrt(9 * d);
-  while (true) {
-    let x;
-    let v;
-    do {
-      const u1 = rng() || 1e-12;
-      const u2 = rng() || 1e-12;
-      x = Math.sqrt(-2 * Math.log(u1)) * Math.cos(2 * Math.PI * u2);
-      v = 1 + c * x;
-    } while (v <= 0);
-    v = v * v * v;
-    const u = rng();
-    if (u < 1 - 0.0331 * x ** 4) return d * v;
-    if (Math.log(u) < 0.5 * x * x + d * (1 - v + Math.log(v))) return d * v;
-  }
-}
-
-export {
-  varianceBasedCurriculum,
-  thompsonCurriculum,
-  observationsFromRunRecords
-};
-//# sourceMappingURL=chunk-G7MGMCZD.js.map

package/dist/chunk-G7MGMCZD.js.map

@@ -1 +0,0 @@
-{"version":3,"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'\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. Default unset (Math.random). */\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(opts.seed)\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\nfunction makeRng(seed?: number): () => number {\n  if (seed === undefined) return Math.random\n  let s = seed >>> 0\n  return () => {\n    s = (s + 0x6d2b79f5) >>> 0\n    let t = s\n    t = Math.imul(t ^ (t >>> 15), t | 1)\n    t ^= t + Math.imul(t ^ (t >>> 7), t | 61)\n    return ((t ^ (t >>> 14)) >>> 0) / 4294967296\n  }\n}\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":"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","names":[]}

package/dist/chunk-GGE4NNQT.js

@@ -1,65 +0,0 @@
-// src/trace/redact.ts
-var DEFAULT_REDACTION_RULES = [
-  { id: "email", pattern: /\b[A-Z0-9._%+-]+@[A-Z0-9.-]+\.[A-Z]{2,}\b/gi },
-  { id: "ssn", pattern: /\b\d{3}-\d{2}-\d{4}\b/g },
-  { id: "credit-card", pattern: /\b(?:\d[ -]*?){13,16}\b/g },
-  { id: "phone-us", pattern: /\b(?:\+?1[-.\s]?)?\(?\d{3}\)?[-.\s]?\d{3}[-.\s]?\d{4}\b/g },
-  { id: "ipv4", pattern: /\b(?:\d{1,3}\.){3}\d{1,3}\b/g },
-  { id: "aws-access-key", pattern: /\bAKIA[0-9A-Z]{16}\b/g },
-  { id: "bearer", pattern: /\bBearer\s+[A-Za-z0-9._~+/=-]{10,}/gi },
-  { id: "sk-key", pattern: /\bsk-[A-Za-z0-9_-]{10,}\b/g },
-  {
-    id: "private-key-block",
-    pattern: /-----BEGIN (?:RSA |EC |OPENSSH |DSA )?PRIVATE KEY-----[\s\S]*?-----END[^-]*-----/g
-  }
-];
-var REDACTION_VERSION = "1.0.0";
-function redactString(input, rules = DEFAULT_REDACTION_RULES) {
-  const byRule = {};
-  let redactionCount = 0;
-  let output = input;
-  for (const rule of rules) {
-    let hits = 0;
-    output = output.replace(rule.pattern, () => {
-      hits++;
-      return rule.replacement ?? `[redacted:${rule.id}]`;
-    });
-    if (hits > 0) {
-      byRule[rule.id] = hits;
-      redactionCount += hits;
-    }
-  }
-  return { output, report: { redactionCount, byRule } };
-}
-function redactValue(value, rules = DEFAULT_REDACTION_RULES, report = { redactionCount: 0, byRule: {} }) {
-  if (typeof value === "string") {
-    const { output, report: r } = redactString(value, rules);
-    report.redactionCount += r.redactionCount;
-    for (const [k, v] of Object.entries(r.byRule)) {
-      report.byRule[k] = (report.byRule[k] ?? 0) + v;
-    }
-    return { value: output, report };
-  }
-  if (Array.isArray(value)) {
-    return {
-      value: value.map((v) => redactValue(v, rules, report).value),
-      report
-    };
-  }
-  if (value !== null && typeof value === "object") {
-    const next = {};
-    for (const [k, v] of Object.entries(value)) {
-      next[k] = redactValue(v, rules, report).value;
-    }
-    return { value: next, report };
-  }
-  return { value, report };
-}
-
-export {
-  DEFAULT_REDACTION_RULES,
-  REDACTION_VERSION,
-  redactString,
-  redactValue
-};
-//# sourceMappingURL=chunk-GGE4NNQT.js.map

package/dist/chunk-GGE4NNQT.js.map

@@ -1 +0,0 @@
-{"version":3,"sources":["../src/trace/redact.ts"],"sourcesContent":["/**\n * Redaction — remove PII / secrets from trace payloads before persist.\n *\n * Pre-persistence rules mean raw traces in storage are already scrubbed.\n * Unredacted variants (for debugging / post-mortems) live in a separate\n * storage layer with stricter access controls; this module only covers\n * the default scrub-then-persist path.\n *\n * Rules compose: pass an array of `RedactionRule`, each is applied in\n * order. Strings that match get replaced with a tagged sentinel so the\n * eval framework can count how many redactions happened per run\n * (surfaced via `redaction_applied` events).\n */\n\nexport interface RedactionRule {\n  id: string\n  pattern: RegExp\n  /** Replacement — e.g. '[PII:email]'. Defaults to `[redacted:{id}]`. */\n  replacement?: string\n}\n\nexport interface RedactionReport {\n  redactionCount: number\n  byRule: Record<string, number>\n}\n\n/** OWASP / common-sense defaults — extend per-domain. */\nexport const DEFAULT_REDACTION_RULES: RedactionRule[] = [\n  { id: 'email', pattern: /\\b[A-Z0-9._%+-]+@[A-Z0-9.-]+\\.[A-Z]{2,}\\b/gi },\n  { id: 'ssn', pattern: /\\b\\d{3}-\\d{2}-\\d{4}\\b/g },\n  { id: 'credit-card', pattern: /\\b(?:\\d[ -]*?){13,16}\\b/g },\n  { id: 'phone-us', pattern: /\\b(?:\\+?1[-.\\s]?)?\\(?\\d{3}\\)?[-.\\s]?\\d{3}[-.\\s]?\\d{4}\\b/g },\n  { id: 'ipv4', pattern: /\\b(?:\\d{1,3}\\.){3}\\d{1,3}\\b/g },\n  { id: 'aws-access-key', pattern: /\\bAKIA[0-9A-Z]{16}\\b/g },\n  { id: 'bearer', pattern: /\\bBearer\\s+[A-Za-z0-9._~+/=-]{10,}/gi },\n  { id: 'sk-key', pattern: /\\bsk-[A-Za-z0-9_-]{10,}\\b/g },\n  {\n    id: 'private-key-block',\n    pattern: /-----BEGIN (?:RSA |EC |OPENSSH |DSA )?PRIVATE KEY-----[\\s\\S]*?-----END[^-]*-----/g,\n  },\n]\n\nexport const REDACTION_VERSION = '1.0.0'\n\n/**\n * Redact a single string. Returns the new string and a per-rule count of\n * how many substitutions fired.\n */\nexport function redactString(\n  input: string,\n  rules: RedactionRule[] = DEFAULT_REDACTION_RULES,\n): { output: string; report: RedactionReport } {\n  const byRule: Record<string, number> = {}\n  let redactionCount = 0\n  let output = input\n  for (const rule of rules) {\n    let hits = 0\n    output = output.replace(rule.pattern, () => {\n      hits++\n      return rule.replacement ?? `[redacted:${rule.id}]`\n    })\n    if (hits > 0) {\n      byRule[rule.id] = hits\n      redactionCount += hits\n    }\n  }\n  return { output, report: { redactionCount, byRule } }\n}\n\n/**\n * Walk a JSON-ish value applying `redactString` to every string leaf.\n * Arrays and plain objects are recursed; other types pass through\n * untouched. Circular references throw — traces should be tree-shaped.\n */\nexport function redactValue(\n  value: unknown,\n  rules: RedactionRule[] = DEFAULT_REDACTION_RULES,\n  report: RedactionReport = { redactionCount: 0, byRule: {} },\n): { value: unknown; report: RedactionReport } {\n  if (typeof value === 'string') {\n    const { output, report: r } = redactString(value, rules)\n    report.redactionCount += r.redactionCount\n    for (const [k, v] of Object.entries(r.byRule)) {\n      report.byRule[k] = (report.byRule[k] ?? 0) + v\n    }\n    return { value: output, report }\n  }\n  if (Array.isArray(value)) {\n    return {\n      value: value.map((v) => redactValue(v, rules, report).value),\n      report,\n    }\n  }\n  if (value !== null && typeof value === 'object') {\n    const next: Record<string, unknown> = {}\n    for (const [k, v] of Object.entries(value)) {\n      next[k] = redactValue(v, rules, report).value\n    }\n    return { value: next, report }\n  }\n  return { value, report }\n}\n"],"mappings":";AA2BO,IAAM,0BAA2C;AAAA,EACtD,EAAE,IAAI,SAAS,SAAS,8CAA8C;AAAA,EACtE,EAAE,IAAI,OAAO,SAAS,yBAAyB;AAAA,EAC/C,EAAE,IAAI,eAAe,SAAS,2BAA2B;AAAA,EACzD,EAAE,IAAI,YAAY,SAAS,2DAA2D;AAAA,EACtF,EAAE,IAAI,QAAQ,SAAS,+BAA+B;AAAA,EACtD,EAAE,IAAI,kBAAkB,SAAS,wBAAwB;AAAA,EACzD,EAAE,IAAI,UAAU,SAAS,uCAAuC;AAAA,EAChE,EAAE,IAAI,UAAU,SAAS,6BAA6B;AAAA,EACtD;AAAA,IACE,IAAI;AAAA,IACJ,SAAS;AAAA,EACX;AACF;AAEO,IAAM,oBAAoB;AAM1B,SAAS,aACd,OACA,QAAyB,yBACoB;AAC7C,QAAM,SAAiC,CAAC;AACxC,MAAI,iBAAiB;AACrB,MAAI,SAAS;AACb,aAAW,QAAQ,OAAO;AACxB,QAAI,OAAO;AACX,aAAS,OAAO,QAAQ,KAAK,SAAS,MAAM;AAC1C;AACA,aAAO,KAAK,eAAe,aAAa,KAAK,EAAE;AAAA,IACjD,CAAC;AACD,QAAI,OAAO,GAAG;AACZ,aAAO,KAAK,EAAE,IAAI;AAClB,wBAAkB;AAAA,IACpB;AAAA,EACF;AACA,SAAO,EAAE,QAAQ,QAAQ,EAAE,gBAAgB,OAAO,EAAE;AACtD;AAOO,SAAS,YACd,OACA,QAAyB,yBACzB,SAA0B,EAAE,gBAAgB,GAAG,QAAQ,CAAC,EAAE,GACb;AAC7C,MAAI,OAAO,UAAU,UAAU;AAC7B,UAAM,EAAE,QAAQ,QAAQ,EAAE,IAAI,aAAa,OAAO,KAAK;AACvD,WAAO,kBAAkB,EAAE;AAC3B,eAAW,CAAC,GAAG,CAAC,KAAK,OAAO,QAAQ,EAAE,MAAM,GAAG;AAC7C,aAAO,OAAO,CAAC,KAAK,OAAO,OAAO,CAAC,KAAK,KAAK;AAAA,IAC/C;AACA,WAAO,EAAE,OAAO,QAAQ,OAAO;AAAA,EACjC;AACA,MAAI,MAAM,QAAQ,KAAK,GAAG;AACxB,WAAO;AAAA,MACL,OAAO,MAAM,IAAI,CAAC,MAAM,YAAY,GAAG,OAAO,MAAM,EAAE,KAAK;AAAA,MAC3D;AAAA,IACF;AAAA,EACF;AACA,MAAI,UAAU,QAAQ,OAAO,UAAU,UAAU;AAC/C,UAAM,OAAgC,CAAC;AACvC,eAAW,CAAC,GAAG,CAAC,KAAK,OAAO,QAAQ,KAAK,GAAG;AAC1C,WAAK,CAAC,IAAI,YAAY,GAAG,OAAO,MAAM,EAAE;AAAA,IAC1C;AACA,WAAO,EAAE,OAAO,MAAM,OAAO;AAAA,EAC/B;AACA,SAAO,EAAE,OAAO,OAAO;AACzB;","names":[]}

package/dist/chunk-H23X7XKK.js

@@ -1,181 +0,0 @@
-import {
-  ROLLOUT_SCHEMA,
-  assertMinted
-} from "./chunk-PC5DOSM7.js";
-import {
-  buildTrajectory
-} from "./chunk-RZTMDUO7.js";
-import {
-  runTaskScore
-} from "./chunk-56TAVBOK.js";
-import {
-  rolloutRewardFields,
-  scoreOrigin
-} from "./chunk-OIUOT4QD.js";
-import {
-  ValidationError
-} from "./chunk-ONWEPEDO.js";
-
-// src/rollout/mint.ts
-var asText = (v, scrub) => {
-  const s = typeof v === "string" ? v : JSON.stringify(v);
-  return scrub(s ?? "");
-};
-function projectStep(span, scrub) {
-  const base = {
-    kind: span.kind,
-    name: scrub(span.name),
-    status: span.status,
-    durationMs: span.endedAt !== void 0 ? span.endedAt - span.startedAt : void 0
-  };
-  if (span.kind === "llm") {
-    const llm = span;
-    const last = llm.messages[llm.messages.length - 1];
-    if (last) base.input = scrub(last.content);
-    if (llm.output !== void 0) base.output = scrub(llm.output);
-  } else if (span.kind === "tool") {
-    const tool = span;
-    base.input = asText(tool.args, scrub);
-    if (tool.result !== void 0) base.output = asText(tool.result, scrub);
-  }
-  return base;
-}
-function finalConversation(spans, scrub) {
-  const llms = spans.filter((s) => s.kind === "llm");
-  const last = llms[llms.length - 1];
-  if (!last) return [];
-  const messages = last.messages.map((m) => ({
-    role: m.role,
-    content: scrub(m.content)
-  }));
-  if (last.output !== void 0 && last.output !== "") {
-    messages.push({ role: "assistant", content: scrub(last.output) });
-  }
-  return messages;
-}
-var REWARD_SOURCE = {
-  holdout: "run-record/holdout-score",
-  search: "run-record/search-score",
-  unscored: "run-record/unscored"
-};
-function requireTaskScore(record) {
-  if (runTaskScore(record) === void 0) {
-    throw new ValidationError(`Cannot mint rollout for run ${record.runId}: task score is missing`);
-  }
-}
-var SPLIT_FROM_TAG = {
-  search: "search",
-  dev: "dev",
-  holdout: "holdout"
-};
-function mintLine(record, steps, messages, options, capturedAt, gap) {
-  requireTaskScore(record);
-  const rewardFields = rolloutRewardFields(record);
-  const uncaptured = record.costProvenance.kind === "uncaptured";
-  const terminalOutcome = record.terminalOutcome;
-  const isCompleted = terminalOutcome === "succeeded" || terminalOutcome === "failed";
-  const isTruncated = terminalOutcome === "cancelled" || terminalOutcome === "incomplete";
-  const terminalError = terminalOutcome === "failed" || terminalOutcome === "cancelled" || terminalOutcome === "incomplete" ? record.terminalFailureReason ?? `run ended ${terminalOutcome}` : null;
-  return assertMinted(
-    {
-      schema: ROLLOUT_SCHEMA,
-      rollout_id: record.runId,
-      parent_rollout_id: null,
-      run_id: record.runId,
-      experiment_id: record.experimentId,
-      candidate_id: record.candidateId,
-      generation: null,
-      candidate_index: null,
-      role: options.role ?? "agent",
-      task: {
-        suite: options.suite ?? record.experimentId,
-        instance_id: record.scenarioId,
-        split: SPLIT_FROM_TAG[record.splitTag],
-        seed: record.seed,
-        rep: 0
-      },
-      policy: {
-        harness: null,
-        harness_version: null,
-        model: record.model,
-        provider: null,
-        profile_commit: record.commitSha,
-        prompt_hash: record.promptHash,
-        config_hash: record.configHash,
-        agent_profile_cell_id: record.agentProfile?.cellId ?? null,
-        sampling: null
-      },
-      messages,
-      tool_defs: [],
-      ...steps.length > 0 ? { steps } : {},
-      outcome: {
-        ...rewardFields,
-        reward_source: REWARD_SOURCE[scoreOrigin(record)],
-        verdict: null,
-        // A verbatim bulk copy, deliberately UNFILTERED here. `outcome.raw`
-        // holds the per-layer verifier scores (`layer.*`) that the reward was
-        // derived from, so on a gated run this dict is the reward signal in
-        // component form — but filtering it at this call site is the pattern
-        // that has now leaked twice, because the next producer to write a
-        // reward-bearing field forgets. The gate is applied to the whole
-        // outcome once, in `assertMinted` below (`gateGamedOutcome`), which
-        // moves the block to `provenance.gated_evidence` when the run is gated
-        // and leaves it here untouched when it is not.
-        metrics: { ...record.outcome.raw },
-        is_completed: isCompleted,
-        is_truncated: isTruncated,
-        error: terminalError
-      },
-      cost: {
-        usd: uncaptured ? null : record.costUsd,
-        tokens_in: record.tokenUsage.input,
-        tokens_out: record.tokenUsage.output,
-        tokens_reasoning: record.tokenUsage.reasoning ?? null,
-        cache_read: record.tokenUsage.cached ?? null,
-        cache_write: record.tokenUsage.cacheWrite ?? null,
-        wall_s: Math.round(record.wallMs / 1e3)
-      },
-      artifacts: { patch_path: null, run_dir: null, transcript_ref: null },
-      provenance: {
-        captured_at: capturedAt,
-        capture: "mint",
-        ...gap !== void 0 ? { gap } : {}
-      }
-    },
-    `minted rollout line for run ${record.runId}`
-  );
-}
-async function mintRolloutRows(records, store, options = {}) {
-  const scrub = options.scrub ?? ((t) => t);
-  const capturedAt = (options.now?.() ?? /* @__PURE__ */ new Date()).toISOString();
-  const rows = [];
-  const missingTraces = [];
-  for (const record of records) {
-    const trajectory = await buildTrajectory(store, record.runId);
-    if (trajectory.steps.length === 0) {
-      missingTraces.push(record.runId);
-      rows.push(
-        mintLine(record, [], [], options, capturedAt, "no trace spans recorded for this runId")
-      );
-      continue;
-    }
-    let steps = trajectory.steps.map((s) => projectStep(s.span, scrub));
-    if (options.maxSteps !== void 0 && steps.length > options.maxSteps) {
-      const head = Math.ceil(options.maxSteps / 2);
-      const tail = options.maxSteps - head;
-      steps = [...steps.slice(0, head), ...steps.slice(steps.length - tail)];
-    }
-    const conversation = finalConversation(
-      trajectory.steps.map((s) => s.span),
-      scrub
-    );
-    const gap = conversation.length === 0 ? "trace has no llm spans \u2014 no conversation to inline" : void 0;
-    rows.push(mintLine(record, steps, conversation, options, capturedAt, gap));
-  }
-  return { rows, missingTraces };
-}
-
-export {
-  mintRolloutRows
-};
-//# sourceMappingURL=chunk-H23X7XKK.js.map

package/dist/chunk-H23X7XKK.js.map

@@ -1 +0,0 @@
-{"version":3,"sources":["../src/rollout/mint.ts"],"sourcesContent":["/**\n * Rollout minting — `tangle.rollout.v1` lines joined from the records the\n * substrate ALREADY keeps. There is no separate rollout store: a rollout\n * is the JOIN of a RunRecord (identity, provenance, cost, outcome) with\n * its trace (spans share `runId`), projected into the canonical line.\n *\n * Composition, not duplication:\n *   - identity/provenance     → `RunRecord` (candidateId, splitTag, agentProfile, hashes)\n *   - step structure          → `buildTrajectory` over the shared TraceStore\n *   - preference-pair export  → `feedbackTrajectoryToOptimizerRow` (feedback-trajectory.ts)\n *   - PRM / reward-model      → `reward-model-export.ts`\n *\n * Anti-Goodhart invariant: a run whose `outcome.realness.gated` is true is\n * never exported with a positive reward OR with any of the numbers that reward\n * was computed from. The gate travels into the training data (`reward` forced\n * to 0, `realness_gated: true`) and the whole outcome is transformed by\n * `gateGamedOutcome` inside `assertMinted` below, which relocates `metrics` and\n * `verdict` to `provenance.gated_evidence`. Mint returns\n * `MintedRolloutLine[]`: the brand the training exporters require, which only\n * this function, `readRolloutLedger`, and an explicit `assertMinted` can mint.\n *\n * A record carrying NEITHER split score is REJECTED (`ValidationError`), never\n * minted at 0 — \"nobody graded this\" is not the same claim as \"graded a total\n * failure\", and a trainer reading 0 learns the second. Lines that already\n * carry `reward: null` (interchange imports, existing ledgers) remain valid on\n * the wire; only the RunRecord→line door refuses.\n *\n * Records without spans become labeled GAP LINES (messages: [],\n * provenance.gap) — present in the output AND surfaced in\n * `missingTraces`; a capture gap is a finding, never a silent omission.\n */\n\nimport { ValidationError } from '../errors'\nimport { type RunRecord, runTaskScore } from '../run-record'\nimport type { LlmSpan, Message, Span, ToolSpan } from '../trace/schema'\nimport type { TraceStore } from '../trace/store'\nimport { buildTrajectory } from '../trajectory'\nimport { rolloutRewardFields, scoreOrigin } from './reward'\nimport {\n  assertMinted,\n  type ChatMessage,\n  type MintedRolloutLine,\n  ROLLOUT_SCHEMA,\n  type RolloutRole,\n  type RolloutSplit,\n  type RolloutStep,\n} from './schema'\n\n/** Redactor applied to every exported string (secrets, PII). Identity by default. */\nexport type RolloutScrubber = (text: string) => string\n\nexport interface MintRolloutOptions {\n  scrub?: RolloutScrubber\n  /** Cap steps per line (longest runs first drop middle steps). Default: no cap. */\n  maxSteps?: number\n  /** Role recorded on every minted line. Default 'agent' (a solo eval run). */\n  role?: RolloutRole\n  /** Task suite label. Default: the record's `experimentId`. */\n  suite?: string\n  /** Injected clock for deterministic output. */\n  now?: () => Date\n}\n\nexport interface MintRolloutResult {\n  rows: MintedRolloutLine[]\n  /** runIds that had a RunRecord but no spans — emitted as gap lines AND listed here. */\n  missingTraces: string[]\n}\n\nconst asText = (v: unknown, scrub: RolloutScrubber): string => {\n  const s = typeof v === 'string' ? v : JSON.stringify(v)\n  return scrub(s ?? '')\n}\n\nfunction projectStep(span: Span, scrub: RolloutScrubber): RolloutStep {\n  const base: RolloutStep = {\n    kind: span.kind,\n    name: scrub(span.name),\n    status: span.status,\n    durationMs: span.endedAt !== undefined ? span.endedAt - span.startedAt : undefined,\n  }\n  if (span.kind === 'llm') {\n    const llm = span as LlmSpan\n    const last = llm.messages[llm.messages.length - 1]\n    if (last) base.input = scrub(last.content)\n    if (llm.output !== undefined) base.output = scrub(llm.output)\n  } else if (span.kind === 'tool') {\n    const tool = span as ToolSpan\n    base.input = asText(tool.args, scrub)\n    if (tool.result !== undefined) base.output = asText(tool.result, scrub)\n  }\n  return base\n}\n\n/** The final llm span's history + output is the completed conversation. */\nfunction finalConversation(spans: Span[], scrub: RolloutScrubber): ChatMessage[] {\n  const llms = spans.filter((s): s is LlmSpan => s.kind === 'llm')\n  const last = llms[llms.length - 1]\n  if (!last) return []\n  const messages: ChatMessage[] = last.messages.map((m: Message) => ({\n    role: m.role,\n    content: scrub(m.content),\n  }))\n  if (last.output !== undefined && last.output !== '') {\n    messages.push({ role: 'assistant', content: scrub(last.output) })\n  }\n  return messages\n}\n\n// The reward derivations live in the leaf module `./reward` so gate and\n// reporting code can import them without dragging in the trace store; they are\n// re-exported here because the derivations shipped from this path.\nexport {\n  isRealnessGated,\n  observedScore,\n  observedSplitScore,\n  type ScoreOrigin,\n  type ScorePreference,\n  scoreOrigin,\n  trainingReward,\n  trainingScore,\n} from './reward'\n\nconst REWARD_SOURCE: Record<ReturnType<typeof scoreOrigin>, string> = {\n  holdout: 'run-record/holdout-score',\n  search: 'run-record/search-score',\n  unscored: 'run-record/unscored',\n}\n\n/**\n * The mint door refuses an execution-only record: a missing training label is\n * not a zero reward, and not a mintable line either. Lines that already carry\n * `reward: null` — interchange imports, existing ledgers — stay valid on the\n * wire and keep their labeled gap; this guard is only about the\n * RunRecord→line door, where the producer can still be told to go score the\n * run instead of shipping an unlabeled row.\n */\nfunction requireTaskScore(record: RunRecord): void {\n  if (runTaskScore(record) === undefined) {\n    throw new ValidationError(`Cannot mint rollout for run ${record.runId}: task score is missing`)\n  }\n}\n\nconst SPLIT_FROM_TAG: Record<RunRecord['splitTag'], RolloutSplit> = {\n  search: 'search',\n  dev: 'dev',\n  holdout: 'holdout',\n}\n\nfunction mintLine(\n  record: RunRecord,\n  steps: RolloutStep[],\n  messages: ChatMessage[],\n  options: MintRolloutOptions,\n  capturedAt: string,\n  gap?: string,\n): MintedRolloutLine {\n  // A missing task score is refused before anything is built: an\n  // execution-only record has no training label, and a missing label is\n  // neither a zero reward nor a mintable row.\n  requireTaskScore(record)\n  // `reward` and `realness_gated` come out of one call, so neither door into\n  // the waist can write one and forget the other.\n  const rewardFields = rolloutRewardFields(record)\n  const uncaptured = record.costProvenance.kind === 'uncaptured'\n  const terminalOutcome = record.terminalOutcome\n  const isCompleted = terminalOutcome === 'succeeded' || terminalOutcome === 'failed'\n  const isTruncated = terminalOutcome === 'cancelled' || terminalOutcome === 'incomplete'\n  const terminalError =\n    terminalOutcome === 'failed' ||\n    terminalOutcome === 'cancelled' ||\n    terminalOutcome === 'incomplete'\n      ? (record.terminalFailureReason ?? `run ended ${terminalOutcome}`)\n      : null\n  // `assertMinted` rather than a cast: mint is the producer the whole gate\n  // rests on, so it proves the line it just built is valid instead of asserting\n  // it by fiat. The brand is unforgeable precisely because nobody casts to it.\n  return assertMinted(\n    {\n      schema: ROLLOUT_SCHEMA,\n      rollout_id: record.runId,\n      parent_rollout_id: null,\n      run_id: record.runId,\n      experiment_id: record.experimentId,\n      candidate_id: record.candidateId,\n      generation: null,\n      candidate_index: null,\n      role: options.role ?? 'agent',\n      task: {\n        suite: options.suite ?? record.experimentId,\n        instance_id: record.scenarioId,\n        split: SPLIT_FROM_TAG[record.splitTag],\n        seed: record.seed,\n        rep: 0,\n      },\n      policy: {\n        harness: null,\n        harness_version: null,\n        model: record.model,\n        provider: null,\n        profile_commit: record.commitSha,\n        prompt_hash: record.promptHash,\n        config_hash: record.configHash,\n        agent_profile_cell_id: record.agentProfile?.cellId ?? null,\n        sampling: null,\n      },\n      messages,\n      tool_defs: [],\n      ...(steps.length > 0 ? { steps } : {}),\n      outcome: {\n        ...rewardFields,\n        reward_source: REWARD_SOURCE[scoreOrigin(record)],\n        verdict: null,\n        // A verbatim bulk copy, deliberately UNFILTERED here. `outcome.raw`\n        // holds the per-layer verifier scores (`layer.*`) that the reward was\n        // derived from, so on a gated run this dict is the reward signal in\n        // component form — but filtering it at this call site is the pattern\n        // that has now leaked twice, because the next producer to write a\n        // reward-bearing field forgets. The gate is applied to the whole\n        // outcome once, in `assertMinted` below (`gateGamedOutcome`), which\n        // moves the block to `provenance.gated_evidence` when the run is gated\n        // and leaves it here untouched when it is not.\n        metrics: { ...record.outcome.raw },\n        is_completed: isCompleted,\n        is_truncated: isTruncated,\n        error: terminalError,\n      },\n      cost: {\n        usd: uncaptured ? null : record.costUsd,\n        tokens_in: record.tokenUsage.input,\n        tokens_out: record.tokenUsage.output,\n        tokens_reasoning: record.tokenUsage.reasoning ?? null,\n        cache_read: record.tokenUsage.cached ?? null,\n        cache_write: record.tokenUsage.cacheWrite ?? null,\n        wall_s: Math.round(record.wallMs / 1000),\n      },\n      artifacts: { patch_path: null, run_dir: null, transcript_ref: null },\n      provenance: {\n        captured_at: capturedAt,\n        capture: 'mint',\n        ...(gap !== undefined ? { gap } : {}),\n      },\n    },\n    `minted rollout line for run ${record.runId}`,\n  )\n}\n\n/**\n * Join RunRecords with their traces into canonical rollout lines. Records\n * without spans are emitted as labeled gap lines and reported in\n * `missingTraces`. Execution-only records without a task score are rejected\n * because a missing training label is not a zero reward.\n */\nexport async function mintRolloutRows(\n  records: RunRecord[],\n  store: TraceStore,\n  options: MintRolloutOptions = {},\n): Promise<MintRolloutResult> {\n  const scrub = options.scrub ?? ((t) => t)\n  const capturedAt = (options.now?.() ?? new Date()).toISOString()\n  const rows: MintedRolloutLine[] = []\n  const missingTraces: string[] = []\n  for (const record of records) {\n    const trajectory = await buildTrajectory(store, record.runId)\n    if (trajectory.steps.length === 0) {\n      missingTraces.push(record.runId)\n      rows.push(\n        mintLine(record, [], [], options, capturedAt, 'no trace spans recorded for this runId'),\n      )\n      continue\n    }\n    let steps = trajectory.steps.map((s) => projectStep(s.span, scrub))\n    if (options.maxSteps !== undefined && steps.length > options.maxSteps) {\n      // Keep the head and tail — the middle of a long run is the least\n      // informative for outcome attribution.\n      const head = Math.ceil(options.maxSteps / 2)\n      const tail = options.maxSteps - head\n      steps = [...steps.slice(0, head), ...steps.slice(steps.length - tail)]\n    }\n    const conversation = finalConversation(\n      trajectory.steps.map((s) => s.span),\n      scrub,\n    )\n    const gap =\n      conversation.length === 0 ? 'trace has no llm spans — no conversation to inline' : undefined\n    rows.push(mintLine(record, steps, conversation, options, capturedAt, gap))\n  }\n  return { rows, missingTraces }\n}\n"],"mappings":"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","names":[]}

package/dist/chunk-HHWE3POT.js

@@ -1,94 +0,0 @@
-// src/trace/execution-tracks.ts
-function executionTrackByLane(lanes) {
-  const unique = /* @__PURE__ */ new Map();
-  for (const lane of lanes) {
-    const existing = unique.get(lane.key);
-    if (existing && !sameLane(existing, lane)) {
-      throw new Error(`execution lane '${lane.key}' has conflicting scope or timing`);
-    }
-    unique.set(lane.key, lane);
-  }
-  const trackByLane = /* @__PURE__ */ new Map();
-  const lanesByScope = /* @__PURE__ */ new Map();
-  for (const lane of unique.values()) {
-    const scoped = lanesByScope.get(lane.scopeKey) ?? [];
-    scoped.push(lane);
-    lanesByScope.set(lane.scopeKey, scoped);
-  }
-  for (const [scopeKey, scoped] of lanesByScope) {
-    if (scoped.some((lane) => lane.start === null && lane.end === null)) {
-      for (const lane of scoped) trackByLane.set(lane.key, trackId("lane", lane.key));
-      continue;
-    }
-    const incompleteKeys = /* @__PURE__ */ new Set();
-    const boundarySet = /* @__PURE__ */ new Set();
-    for (const lane of scoped) {
-      if (lane.start !== null && lane.end !== null && lane.end > lane.start) continue;
-      incompleteKeys.add(lane.key);
-      const boundary = lane.start ?? lane.end;
-      if (boundary !== null) boundarySet.add(boundary);
-      trackByLane.set(lane.key, trackId("lane", lane.key));
-    }
-    const boundaries = [...boundarySet].sort((a, b) => a - b);
-    const completeBySegment = /* @__PURE__ */ new Map();
-    for (const lane of scoped) {
-      if (incompleteKeys.has(lane.key)) continue;
-      const segment = upperBound(boundaries, lane.start);
-      const nextBoundary = boundaries[segment];
-      if (nextBoundary !== void 0 && nextBoundary < lane.end) {
-        trackByLane.set(lane.key, trackId("lane", lane.key));
-        continue;
-      }
-      const complete = completeBySegment.get(segment) ?? [];
-      complete.push(lane);
-      completeBySegment.set(segment, complete);
-    }
-    let serialTrack = 0;
-    for (const [, segment] of [...completeBySegment].sort(([a], [b]) => a - b)) {
-      const ordered = [...segment].sort(
-        (a, b) => a.start - b.start || a.end - b.end || a.key.localeCompare(b.key)
-      );
-      let component = [];
-      let componentEnd = Number.NEGATIVE_INFINITY;
-      const flush = () => {
-        if (component.length === 1) {
-          trackByLane.set(component[0].key, trackId("serial", scopeKey, serialTrack));
-        } else if (component.length > 1) {
-          for (const lane of component) trackByLane.set(lane.key, trackId("lane", lane.key));
-          serialTrack += 1;
-        }
-        component = [];
-        componentEnd = Number.NEGATIVE_INFINITY;
-      };
-      for (const lane of ordered) {
-        if (component.length > 0 && lane.start >= componentEnd) flush();
-        component.push(lane);
-        componentEnd = Math.max(componentEnd, lane.end);
-      }
-      flush();
-      serialTrack += 1;
-    }
-  }
-  return trackByLane;
-}
-function sameLane(a, b) {
-  return a.scopeKey === b.scopeKey && a.start === b.start && a.end === b.end;
-}
-function trackId(kind, key, index) {
-  return JSON.stringify(index === void 0 ? [kind, key] : [kind, key, index]);
-}
-function upperBound(sorted, target) {
-  let low = 0;
-  let high = sorted.length;
-  while (low < high) {
-    const middle = low + high >>> 1;
-    if (sorted[middle] <= target) low = middle + 1;
-    else high = middle;
-  }
-  return low;
-}
-
-export {
-  executionTrackByLane
-};
-//# sourceMappingURL=chunk-HHWE3POT.js.map

package/dist/chunk-HHWE3POT.js.map

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