@tangle-network/agent-eval 0.216.0 → 0.217.1

package/dist/statistical-heldout-1Gbmex7v.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"statistical-heldout-1Gbmex7v.js","names":[],"sources":["../src/campaign/gates/statistical-heldout.ts"],"sourcesContent":["/**\n * Held-out inference pairs execution cells and judge identities before taking\n * means within registered independent units. Repetitions can improve a unit's\n * precision without increasing n. Ungrouped inference concerns independently\n * sampled execution cells conditional on a fixed scenario roster.\n *\n * The shared paired decision rule selects the estimator and statistical test.\n * Dimension reports retain missing coverage so required safety checks cannot\n * pass through absent evidence. Thresholds use the judge's native score scale.\n */\n\nimport {\n  decidePairedPromotion,\n  type PairedDecisionMethod,\n  type PairedDecisionStatistic,\n  type PairedMcNemarEvidence,\n  type PairedPromotionDecision,\n} from '../../paired-promotion-decision'\nimport {\n  DECISION_PAIRED_DELTA_STATISTIC,\n  type PairedBootstrapResult,\n  pairedBootstrap,\n} from '../../statistics'\nimport type { JudgeScore } from '../types'\n\n/** Tie fraction at/above which a gate annotates its verdict with the tie share.\n *  Tie-domination of the median bites structurally at >= 0.5 (the median is then\n *  0 by construction); 0.4 is a softer warn threshold that flags a run APPROACHING\n *  that regime, so an operator sees it before the median goes fully blind. */\nexport const TIE_WARN_FRACTION = 0.4\n\nexport interface PairedHoldout {\n  /** Baseline scalar per paired cell (same order as `after`/`cellIds`). */\n  before: number[]\n  /** Candidate scalar per paired cell. */\n  after: number[]\n  /** The full cellIds (`scenario:rep`) that paired, in order. */\n  cellIds: string[]\n}\n\n/** Campaign cell IDs append a numeric repetition after the scenario's full ID. */\nexport function scenarioIdFromCellId(cellId: string): string {\n  const separator = cellId.lastIndexOf(':')\n  const repetition = cellId.slice(separator + 1)\n  if (\n    separator < 1 ||\n    cellId.trim() !== cellId ||\n    !/^(0|[1-9]\\d*)$/.test(repetition) ||\n    !Number.isSafeInteger(Number(repetition))\n  ) {\n    throw new Error(`pairHoldout: malformed cellId '${cellId}'; expected scenarioId:rep`)\n  }\n  return cellId.slice(0, separator)\n}\n\n/** Preserve cell pairing before taking equal-weight independent-unit means. */\nexport function aggregatePairedHoldout(\n  paired: PairedHoldout,\n  independentUnitByScenarioId?: ReadonlyMap<string, string>,\n): { before: number[]; after: number[]; unitIds: string[] } {\n  if (\n    paired.before.length !== paired.after.length ||\n    paired.before.length !== paired.cellIds.length\n  ) {\n    throw new Error('aggregatePairedHoldout: scores and cellIds must have the same length')\n  }\n  if (new Set(paired.cellIds).size !== paired.cellIds.length) {\n    throw new Error('aggregatePairedHoldout: duplicate cellIds cannot count as new observations')\n  }\n  if (\n    paired.before.some((value) => !Number.isFinite(value)) ||\n    paired.after.some((value) => !Number.isFinite(value))\n  ) {\n    throw new Error('aggregatePairedHoldout: paired scores must be finite')\n  }\n  if (independentUnitByScenarioId === undefined) {\n    return { before: [...paired.before], after: [...paired.after], unitIds: [...paired.cellIds] }\n  }\n  const scenarioIds = paired.cellIds.map(scenarioIdFromCellId)\n  const groups = new Map<string, { before: number; after: number; n: number }>()\n  for (let i = 0; i < paired.cellIds.length; i++) {\n    const scenarioId = scenarioIds[i]!\n    const unitId = independentUnitByScenarioId.get(scenarioId)\n    if (typeof unitId !== 'string' || unitId.length === 0 || unitId.trim() !== unitId) {\n      throw new Error(\n        `aggregatePairedHoldout: missing independent unit for scenario '${scenarioId}'`,\n      )\n    }\n    const group = groups.get(unitId) ?? { before: 0, after: 0, n: 0 }\n    group.before += paired.before[i]!\n    group.after += paired.after[i]!\n    group.n += 1\n    groups.set(unitId, group)\n  }\n  const unitIds = [...groups.keys()].sort()\n  return {\n    before: unitIds.map((id) => groups.get(id)!.before / groups.get(id)!.n),\n    after: unitIds.map((id) => groups.get(id)!.after / groups.get(id)!.n),\n    unitIds,\n  }\n}\n\n/**\n * Pair candidate vs baseline holdout observations by FULL cellId. `select`\n * pulls the scalar from a cell's judge reports (composite, or a named\n * dimension); a cell contributes the mean of `select` across its judges. Cells\n * whose scenario is not in `scenarioIds`, or where `select` is undefined for\n * every judge on both sides, are skipped. The selected judge IDs must agree\n * within each pair. Throws when the two maps disagree on holdout cell IDs — a\n * load-bearing invariant: the baseline + winner holdout campaigns run the same\n * scenarios with the same seed base, so their cellIds MUST align; a mismatch\n * means a silent pairing bug, not a soft fallback.\n */\nexport function pairHoldout(\n  candidate: Map<string, Record<string, JudgeScore>>,\n  baseline: Map<string, Record<string, JudgeScore>>,\n  scenarioIds: Set<string>,\n  select: (s: JudgeScore) => number | undefined,\n): PairedHoldout {\n  const cellValues = (\n    byCell: Map<string, Record<string, JudgeScore>>,\n    cellId: string,\n  ): Map<string, number> => {\n    const scores = byCell.get(cellId)\n    const values = new Map<string, number>()\n    if (!scores) return values\n    for (const [judgeId, s] of Object.entries(scores)) {\n      if (s.failed === true) {\n        throw new Error(`pairHoldout: cell '${cellId}' contains a failed judge score`)\n      }\n      const v = select(s)\n      if (typeof v === 'number' && !Number.isFinite(v)) {\n        throw new Error(`pairHoldout: cell '${cellId}' contains a non-finite selected score`)\n      }\n      if (typeof v === 'number') values.set(judgeId, v)\n    }\n    return values\n  }\n\n  const inScope = (cellId: string) => scenarioIds.has(scenarioIdFromCellId(cellId))\n  const candCells = [...candidate.keys()].filter(inScope).sort()\n  const baseCells = [...baseline.keys()].filter(inScope).sort()\n  // Alignment invariant — the holdout campaigns share scenarios + seed, so the\n  // cell sets must be identical. Differ ⇒ a real pairing bug; fail loud.\n  if (candCells.length !== baseCells.length || candCells.some((c, i) => c !== baseCells[i])) {\n    throw new Error(\n      `pairHoldout: candidate/baseline holdout cells do not align — ` +\n        `candidate=[${candCells.join(',')}] baseline=[${baseCells.join(',')}]. ` +\n        `Both holdout campaigns must run the same scenarios with the same seed base.`,\n    )\n  }\n\n  const before: number[] = []\n  const after: number[] = []\n  const cellIds: string[] = []\n  for (const cellId of candCells) {\n    const b = cellValues(baseline, cellId)\n    const a = cellValues(candidate, cellId)\n    // A scalar absent on both sides means that dimension was not scored. A\n    // one-sided absence is asymmetric evidence loss, never a row to discard.\n    if (b.size === 0 && a.size === 0) continue\n    if (b.size === 0 || a.size === 0) {\n      throw new Error(`pairHoldout: cell '${cellId}' has a selected score on only one arm`)\n    }\n    if (b.size !== a.size || [...b.keys()].some((id) => !a.has(id))) {\n      throw new Error(`pairHoldout: cell '${cellId}' selected judge IDs do not align`)\n    }\n    const judgeIds = [...b.keys()].sort()\n    before.push(meanSelectedScores(judgeIds.map((id) => b.get(id)!)))\n    after.push(meanSelectedScores(judgeIds.map((id) => a.get(id)!)))\n    cellIds.push(cellId)\n  }\n  return { before, after, cellIds }\n}\n\nfunction meanSelectedScores(values: number[]): number {\n  const first = values[0]!\n  // Summing identical fractional scores can round their mean outside the\n  // declared binary support. An agreeing judge set preserves its exact value.\n  return values.every((value) => value === first)\n    ? first\n    : values.reduce((sum, value) => sum + value, 0) / values.length\n}\n\nexport interface HeldoutSignificance {\n  paired: PairedHoldout\n  /**\n   * The paired bootstrap on the requested statistic (MEAN by default — see the\n   * tie note on `heldoutSignificance`).\n   *\n   * DIAGNOSTIC, not necessarily the interval the verdict keyed on. On a\n   * two-point (pass/fail) outcome the decision routes to Tango's score interval\n   * instead, because a percentile bootstrap of the mean over a three-atom\n   * lattice is not a valid interval at a nonzero margin. Read\n   * `decision.low`/`decision.high` for the interval that actually decided, and\n   * `decisionStatistic` for which one it is.\n   */\n  bootstrap: PairedBootstrapResult\n  /** The MEDIAN paired-delta bootstrap, reported as a diagnostic. When many\n   *  scenarios are tied (both sides solve them), the median is pinned near 0\n   *  regardless of the mean lift — comparing the two exposes tie-domination. */\n  medianBootstrap: PairedBootstrapResult\n  /**\n   * The full promotion decision: which estimator the outcome's shape admits,\n   * the interval it produced, McNemar's exact veto on the two-point path, and\n   * whether the interval was zero-width (no evidence in either direction). The\n   * single source of `significant`.\n   */\n  decision: PairedPromotionDecision\n  /** Which paired estimator the verdict was decided on. */\n  decisionStatistic: PairedDecisionStatistic\n  /** McNemar's exact evidence on the two-point path; null otherwise. */\n  mcnemar: PairedMcNemarEvidence | null\n  /** Fraction of paired observations that are exact ties (|delta| < 1e-9). A\n   *  high tie fraction is WHY a median-based gate would have missed a real lift;\n   *  it is the observability the tie fix adds. */\n  tieFraction: number\n  /** Number of paired observation units, after configured aggregation. */\n  n: number\n  /** Original matched execution cells, before aggregation. */\n  pairedCellN: number\n  observationUnit: 'registered' | 'cell'\n  /** Registered unit IDs, or cell IDs on the ungrouped path. */\n  unitIds: string[]\n  /** Effective minimum for the requested target and chosen estimator. */\n  minimumRequired: number\n  /** Statistical method that carried the decision. */\n  decisionMethod: PairedDecisionMethod\n  /** Exact one-sided p-value on the small-sample path; otherwise null. */\n  pValue: number | null\n  /** True iff n >= minimumRequired, the DECIDING interval has nonzero width,\n   *  its lower bound clears the threshold, and McNemar's exact test does not\n   *  veto at a non-negative threshold. */\n  significant: boolean\n  /** Set when n < minimumRequired — too little evidence to claim significance. */\n  fewRuns: boolean\n}\n\nexport interface HeldoutSignificanceOptions {\n  deltaThreshold?: number\n  minProductiveRuns?: number\n  confidence?: number\n  resamples?: number\n  /** Fixed by default for a deterministic, reproducible gate verdict. */\n  seed?: number\n  statistic?: 'mean' | 'median'\n  /** Group full cell pairs into equal-weight independent units before inference. */\n  independentUnitByScenarioId?: ReadonlyMap<string, string>\n}\n\n/**\n * Significance of the held-out composite lift: ship only when the lower bound\n * of the interval the outcome's shape ADMITS exceeds `deltaThreshold` (default\n * 0 ⇒ \"confidently positive\"). Interpret `deltaThreshold` in the judge's native\n * scale.\n *\n * The decision is delegated whole to {@link decidePairedPromotion}, the one\n * copy of the rule (`src/paired-promotion-decision.ts`), which `HeldOutGate`\n * also calls. That module's header carries the measurements; the short version\n * is three guards a bare `bootstrap.low > threshold` does not have:\n *\n *   - a two-point (pass/fail) outcome decides on Tango's SCORE interval, the\n *     only paired-binary construction that stays valid at a nonzero margin;\n *   - McNemar's exact test VETOES at any non-negative threshold;\n *   - a ZERO-WIDTH interval is refused rather than promoted, in either\n *     direction — [0,0] clears every negative threshold and [g,g] clears every\n *     threshold below g, and both are an absence of evidence, not a result.\n *\n * Measured on this function before those guards landed, at a nominal 5 %:\n * 14.60 % false promotion at n = 40 on a paired-binary noninferiority boundary,\n * and 88.50 % at n = 6 under a bounded asymmetric null whose true mean paired\n * delta is exactly 0.\n *\n * Continuous mean targets require bootstrap eligibility. Explicit median\n * targets can use the exact sign test at its confidence-dependent minimum.\n */\nexport function heldoutSignificance(\n  paired: PairedHoldout,\n  opts: HeldoutSignificanceOptions = {},\n): HeldoutSignificance {\n  const deltaThreshold = opts.deltaThreshold ?? 0\n  const confidence = opts.confidence ?? 0.95\n  const resamples = opts.resamples ?? 2000\n  const seed = opts.seed ?? 1337\n  // DEFAULT to the MEAN paired delta, not the median. The median is destroyed by\n  // TIES: whenever both baseline and candidate solve a holdout scenario (a common\n  // case once the agent is decent — and INCREASINGLY common as you add holdout\n  // scenarios for statistical power), that scenario contributes delta 0. When\n  // >=50% of paired cells are ties the median is pinned at 0 regardless of a large,\n  // consistent lift on the rest, and the gate holds a genuinely better candidate.\n  // (Measured live, supervisor-lab run 6: 40 cells, 20 ties, MEAN +0.177, MEDIAN 0\n  // → false hold. Doubling the holdout for \"power\" made it WORSE by adding ties.)\n  // The mean equals the reported aggregate lift, ties correctly contribute 0\n  // without dominating, and it is the textbook paired-comparison estimator; the\n  // median is kept as a reported diagnostic. Callers wanting outlier-robustness at\n  // the cost of tie-blindness can still pass `statistic: 'median'`.\n  const statistic = opts.statistic ?? 'mean'\n  const observations = aggregatePairedHoldout(paired, opts.independentUnitByScenarioId)\n  const decision = decidePairedPromotion(observations.before, observations.after, {\n    confidence,\n    resamples,\n    statistic,\n    seed,\n    threshold: deltaThreshold,\n    minPairs: opts.minProductiveRuns,\n  })\n  // `decision.bootstrap` is null exactly when the score interval decided, so\n  // the requested-statistic bootstrap is computed here for the diagnostic\n  // field. Same two bootstraps as before on every path.\n  const bootstrap =\n    decision.bootstrap ??\n    pairedBootstrap(observations.before, observations.after, {\n      confidence,\n      resamples,\n      statistic,\n      seed,\n    })\n  const medianBootstrap =\n    statistic === 'median'\n      ? bootstrap\n      : pairedBootstrap(observations.before, observations.after, {\n          confidence,\n          resamples,\n          statistic: 'median',\n          seed,\n        })\n  const n = observations.before.length\n  let ties = 0\n  for (let i = 0; i < n; i += 1) {\n    const after = observations.after[i]!\n    const before = observations.before[i]!\n    if (Math.abs(after - before) < 1e-9) ties += 1\n  }\n  const tieFraction = n === 0 ? 0 : ties / n\n  return {\n    paired,\n    bootstrap,\n    medianBootstrap,\n    decision,\n    decisionStatistic: decision.statistic,\n    mcnemar: decision.mcnemar,\n    tieFraction,\n    n,\n    pairedCellN: paired.cellIds.length,\n    observationUnit: opts.independentUnitByScenarioId === undefined ? 'cell' : 'registered',\n    unitIds: observations.unitIds,\n    minimumRequired: decision.minimumPairs,\n    decisionMethod: decision.method,\n    pValue: decision.pValue,\n    significant: decision.promote,\n    fewRuns: !decision.sufficient,\n  }\n}\n\nexport interface DimensionRegression {\n  dimension: string\n  /** Paired bootstrap on (candidate − baseline). DIAGNOSTIC on a pass/fail\n   *  dimension, where `ci` carries the interval that decided instead. */\n  bootstrap: PairedBootstrapResult\n  /** Which paired statistic `bootstrap.low` is the lower bound of. `'mean'`\n   *  unless the caller asked for the median. `bootstrap.median` still carries\n   *  the median point estimate either way. */\n  bootstrapStatistic: 'median' | 'mean'\n  /** The interval `regressed` was decided on, in the dimension's native units. */\n  ci: { low: number; high: number }\n  /** Which estimator produced `ci`. */\n  decisionStatistic: PairedDecisionStatistic\n  /** McNemar's exact evidence on a pass/fail dimension; null otherwise. */\n  mcnemar: PairedMcNemarEvidence | null\n  /** `ci` has zero width — no evidence in either direction. */\n  indeterminate: boolean\n  /** The bootstrap lower bound is below negative tolerance, or the shared\n   *  paired test supports a drop exceeding tolerance. Missing coverage and\n   *  insufficient observations are reported separately. */\n  regressed: boolean\n  tolerance: number\n  n: number\n  pairedCellN: number\n  observationUnit: 'registered' | 'cell'\n  /** Statistical minimum for the configured independent observation unit. */\n  minimumRequired: number\n  fewRuns: boolean\n  /** Both arms lack this dimension on these otherwise matched execution cells. */\n  missingCellIds: string[]\n  /** Configured scenarios with no paired dimension measurement at all. */\n  missingScenarioIds: string[]\n}\n\n/** Detect the native scale of a set of scores: 0-100 when any magnitude clears\n *  1.5, else [0,1]. Used to auto-scale the regression tolerance so a default\n *  expressed for [0,1] is not silently a no-op on a 0-100 dimension. */\nexport function detectScale(values: number[]): 1 | 100 {\n  return values.some((v) => Math.abs(v) > 1.5) ? 100 : 1\n}\n\n/**\n * Report required-dimension evidence after full pairing and optional unit means.\n * A bootstrap floor breach or a shared paired test supporting a drop marks\n * regression. These two criteria are distinct; `ci` records the shared\n * estimator and `bootstrap` records the floor interval. Missing observations\n * and insufficient n remain explicit for the caller's evidence policy.\n * The default tolerance is 0.05 on [0,1] and 5 on a detected 0-100 scale.\n */\nexport function dimensionRegressions(\n  candidate: Map<string, Record<string, JudgeScore>>,\n  baseline: Map<string, Record<string, JudgeScore>>,\n  scenarioIds: Set<string>,\n  criticalDimensions: string[],\n  opts: {\n    tolerance?: number\n    confidence?: number\n    resamples?: number\n    seed?: number\n    /** Paired statistic the CI is computed on. Default `'mean'` — see\n     *  {@link DECISION_PAIRED_DELTA_STATISTIC} for why the median is not. */\n    statistic?: 'mean' | 'median'\n    independentUnitByScenarioId?: ReadonlyMap<string, string>\n    minProductiveRuns?: number\n  } = {},\n): DimensionRegression[] {\n  const out: DimensionRegression[] = []\n  const expectedCellIds = [...baseline.keys()]\n    .filter((cellId) => scenarioIds.has(scenarioIdFromCellId(cellId)))\n    .sort()\n  for (const dim of criticalDimensions) {\n    const paired = pairHoldout(candidate, baseline, scenarioIds, (s) => s.dimensions[dim])\n    if (paired.before.length === 0) continue // dimension not scored on this judge\n    const observations = aggregatePairedHoldout(paired, opts.independentUnitByScenarioId)\n    const measuredCells = new Set(paired.cellIds)\n    const measuredScenarios = new Set(paired.cellIds.map(scenarioIdFromCellId))\n    const tolerance = opts.tolerance ?? 0.05 * detectScale([...paired.before, ...paired.after])\n    const bootstrapStatistic = opts.statistic ?? DECISION_PAIRED_DELTA_STATISTIC\n    const shared = {\n      confidence: opts.confidence ?? 0.95,\n      resamples: opts.resamples ?? 2000,\n      statistic: bootstrapStatistic,\n      seed: opts.seed ?? 1337,\n      minPairs: opts.minProductiveRuns,\n    }\n    const guard = decidePairedPromotion(observations.before, observations.after, shared)\n    const regression = decidePairedPromotion(observations.after, observations.before, {\n      ...shared,\n      threshold: tolerance,\n    })\n    const bootstrap =\n      guard.bootstrap ?? pairedBootstrap(observations.before, observations.after, shared)\n    out.push({\n      dimension: dim,\n      bootstrap,\n      bootstrapStatistic,\n      ci: { low: guard.low, high: guard.high },\n      decisionStatistic: guard.statistic,\n      mcnemar: guard.mcnemar,\n      indeterminate: guard.indeterminate,\n      // Fires on EITHER burden of proof — see `floorBreached` in\n      // `promotion-policy.ts` for the same rule and the reasoning. The CI arm\n      // is the contract this interface and `default-production-gate`'s reason\n      // string both state (\"CI.low < -tolerance\"), read off the DECIDING\n      // interval; the exact-test arm adds the small-sample path where the\n      // bootstrap interval is descriptive only.\n      // The credible-worst-case arm stays on the BOOTSTRAP — see the same\n      // decision in `floorBreached` (`promotion-policy.ts`). On a pass/fail\n      // dimension the score interval is ±z²/(n+z²) even when every pair is\n      // concordant, so reading the floor off it would flag an unchanged safety\n      // dimension as regressed at any realistic n. The PROVEN-drop arm does use\n      // the shared rule, which is what closes the fail-open hole that mattered:\n      // a genuine pass/fail regression is now judged on an interval valid at\n      // the nonzero `tolerance`, instead of a bootstrap that is pinned wherever\n      // ties dominate.\n      regressed: bootstrap.low < -tolerance || regression.promote,\n      tolerance,\n      n: observations.before.length,\n      pairedCellN: paired.cellIds.length,\n      observationUnit: opts.independentUnitByScenarioId === undefined ? 'cell' : 'registered',\n      minimumRequired: guard.minimumPairs,\n      fewRuns: !guard.sufficient,\n      missingCellIds: expectedCellIds.filter((cellId) => !measuredCells.has(cellId)),\n      missingScenarioIds: [...scenarioIds].filter((id) => !measuredScenarios.has(id)).sort(),\n    })\n  }\n  return out\n}\n"],"mappings":"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"}

package/dist/statistical-heldout-BeR4bOdg.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"statistical-heldout-BeR4bOdg.d.ts","names":["_$__evidence_receipt0.EvidenceReceipt"],"sources":["../src/statistics/paired-binary.ts","../src/statistics/sequential-eprocess.ts","../src/experiment/final-evidence.ts","../src/attestation.ts","../src/experiment/evidence-receipt.ts","../src/experiment/campaign-evidence.ts","../src/pareto.ts","../src/campaign/gates/promotion-policy.ts","../src/campaign/gates/power-preflight.ts","../src/paired-arms.ts","../src/pre-registration.ts","../src/campaign/gates/sequential.ts","../src/campaign/gates/statistical-heldout.ts"],"mappings":"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"}

package/dist/steps-Bg5-KVx1.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"steps-Bg5-KVx1.d.ts","names":[],"sources":["../src/trajectory-replay/steps.ts"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;UAmCiB;;WAEN;WACA;;WAEA;;;iBAIK,wBAAwB;;;iBAQxB,uBAAuB;;;;;;;;iBAavB,uBAAuB;;;;;cAc1B;iBAEG,eAAe;;;;;;;;;;iBAaf,mBAAmB;iBAwBnB,cAAc;;cAOjB;;cAGA;;;;;;;;;;;KAaD;iBAQI,oBAAoB,6BAA6B;;;;iBAYjD,kBAAkB;;;;;;;UAYjB;WACN;WACA;WACA;aAA4B;;WAC5B;;UAGM;;WAEN,gBAAgB;;WAEhB;;;;;;;;;WASA;;WAEA;;WAEA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAmCK,oBAAoB,gBAAgB,2BAA2B;;;;;;;;;KAyCnE;WACG;WAA6B;;WAC7B;;WACA;WAA6B,QAAQ;;;;;;;;iBAQpC,qBACd,gBAAgB,2BACf;;;;;;;iBAiBa,oBAAoB,gBAAgB;;;;;;;;;iBAYpC,2BAA2B,SAAS"}

package/dist/store-otlp-DtB4Slsr.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"store-otlp-DtB4Slsr.js","names":[],"sources":["../src/trace-analyst/shared-abortable-task.ts","../src/trace-analyst/store-otlp.ts"],"sourcesContent":["export interface SharedAbortableTask<T> {\n  controller: AbortController\n  promise: Promise<T>\n  consumers: number\n  settled: boolean\n}\n\nexport function createSharedAbortableTask<T>(\n  factory: (signal: AbortSignal) => Promise<T>,\n): SharedAbortableTask<T> {\n  const controller = new AbortController()\n  const task: SharedAbortableTask<T> = {\n    controller,\n    promise: factory(controller.signal),\n    consumers: 0,\n    settled: false,\n  }\n  void task.promise.then(\n    () => {\n      task.settled = true\n    },\n    () => {\n      task.settled = true\n    },\n  )\n  return task\n}\n\nexport function waitForSharedTask<T>(\n  task: SharedAbortableTask<T>,\n  signal: AbortSignal | undefined,\n): Promise<T> {\n  signal?.throwIfAborted()\n  task.consumers += 1\n\n  return new Promise<T>((resolve, reject) => {\n    let finished = false\n    const finish = (callback: () => void): void => {\n      if (finished) return\n      finished = true\n      signal?.removeEventListener('abort', onAbort)\n      task.consumers -= 1\n      callback()\n    }\n    const onAbort = (): void => {\n      finish(() => {\n        reject(signal?.reason)\n        if (!task.settled && task.consumers === 0) {\n          task.controller.abort(signal?.reason)\n        }\n      })\n    }\n\n    signal?.addEventListener('abort', onAbort, { once: true })\n    task.promise.then(\n      (value) => finish(() => resolve(value)),\n      (error: unknown) => finish(() => reject(error)),\n    )\n    if (signal?.aborted) onAbort()\n  })\n}\n","/**\n * `OtlpFileTraceStore` — read-only OTLP-JSONL trace store for the\n * trace-analyst.\n *\n * Wire shape. Each line of the input file is one OTLP-shaped span. The\n * store understands flattened OTLP JSONL plus the OpenInference vocab.\n * We project upstream's full\n * span shape down to `TraceAnalystSpan` lazily — full materialisation\n * only happens for the spans the agent actually requests.\n *\n * Indexing. On first read the store builds an in-memory index keyed\n * by `trace_id` carrying:\n *   - byte offsets + lengths for each span line (for surgical reads\n *     without re-parsing the whole file)\n *   - a `TraceAnalystTraceSummary` rollup\n *   - sets of services / agents / models / tools / has_errors\n *   - byte size of the trace's JSONL slab\n *\n * Memory bound. The index keeps span metadata only — names, kinds,\n * offsets, status. Attribute payloads stay on disk until requested.\n * For a 50MB JSONL with 50k spans, the index is ~5MB.\n *\n * Concurrency. The store builds the index once on first read and\n * caches it. Subsequent reads reuse the index. The file is opened on\n * each read; we never hold a long-lived FD.\n */\n\nimport { readFile, stat } from 'node:fs/promises'\nimport type { RE2JS } from 're2js'\nimport { CaptureIntegrityError } from '../errors'\nimport {\n  SpanNotFoundError,\n  TraceAnalysisLimitError,\n  TraceAnalysisValidationError,\n  TraceFileMalformedError,\n  TraceFileMissingError,\n  TraceFileTooLargeError,\n  TraceNotFoundError,\n} from './errors'\nimport {\n  compareSpanTime,\n  extractOtlpAttributes,\n  projectOtlpFlatLine,\n  spanEpochMillis,\n} from './otlp-span'\nimport {\n  createSharedAbortableTask,\n  type SharedAbortableTask,\n  waitForSharedTask,\n} from './shared-abortable-task'\nimport {\n  compileSearchRegex,\n  TRACE_ANALYSIS_LIMITS,\n  type TraceAnalysisStore,\n  type TraceAnalysisStoreContext,\n  truncateForBudget,\n  validateInteger,\n} from './store'\nimport { bindSpanSourceReader } from './store-boundary'\nimport type { SpanSourceReader } from './store-contract'\nimport { traceSpanSchema } from './store-schemas'\nimport {\n  type DatasetOverview,\n  DEFAULT_TRACE_ANALYST_BUDGETS,\n  type ErrorCluster,\n  type QueryTracesPage,\n  type SearchSpanResult,\n  type SearchTraceResult,\n  type SpanMatchRecord,\n  type TraceAnalystFilters,\n  type TraceAnalystSpan,\n  type TraceAnalystSpanKind,\n  type TraceAnalystSpanStatus,\n  type TraceAnalystTraceSummary,\n  type ViewSpansResult,\n  type ViewTraceOversized,\n  type ViewTraceResult,\n} from './types'\n\n/** Lines indexed between event-loop yields. Bounded synchronous work per\n *  tick keeps the index build from starving other tasks on large files\n *  while staying coarse enough that the yields are cheap. */\nconst INDEX_YIELD_LINES = 5000\nconst SCAN_YIELD_ITEMS = 500\n\n/** Hand control back to the event loop without busy-waiting. */\nfunction yieldToEventLoop(): Promise<void> {\n  return new Promise((resolve) => setImmediate(resolve))\n}\n\nasync function scanCheckpoint(signal: AbortSignal | undefined, item: number): Promise<void> {\n  signal?.throwIfAborted()\n  if (item > 0 && item % SCAN_YIELD_ITEMS === 0) {\n    await yieldToEventLoop()\n    signal?.throwIfAborted()\n  }\n}\n\ninterface SpanIndexEntry {\n  span_id: string\n  parent_span_id: string | null\n  name: string\n  kind: TraceAnalystSpanKind\n  start_time: string\n  end_time: string\n  duration_ms: number\n  status: TraceAnalystSpanStatus\n  status_message: string | undefined\n  service_name: string | null\n  agent_name: string | null\n  model_name: string | null\n  tool_name: string | null\n  /** Byte offset in the raw JSONL file to the start of this span's line. */\n  line_byte_offset: number\n  /** Length of this line in bytes (excluding the trailing newline). */\n  line_byte_length: number\n}\n\ninterface TraceIndexEntry {\n  trace_id: string\n  service_name: string | null\n  agent_name: string | null\n  span_count: number\n  has_errors: boolean\n  start_time: string\n  end_time: string\n  duration_ms: number\n  raw_jsonl_bytes: number\n  agents: Set<string>\n  models: Set<string>\n  tools: Set<string>\n  spans: SpanIndexEntry[]\n  /** Sorted by line offset for stable iteration. */\n}\n\ninterface DatasetIndex {\n  byTrace: Map<string, TraceIndexEntry>\n  totalRawBytes: number\n  // Pre-computed sorted trace_ids for sample/query stability.\n  sortedTraceIds: string[]\n}\n\nexport interface ToolSpansToTraceAnalysisStoreOptions {\n  /** Authorized original-record lookup, exposed only when supplied. */\n  sourceReader?: SpanSourceReader\n  /** Override the discovery (`viewTrace`) per-attribute byte cap. */\n  perAttributeViewBudget?: number\n  /** Override the surgical (`viewSpans`) per-attribute byte cap. */\n  perAttributeSpanBudget?: number\n  /** Override the per-call ceiling that triggers oversized summaries. */\n  perCallByteCeiling?: number\n  /** Override the per-match text budget. */\n  perMatchTextBudget?: number\n}\n\n/** Budgets and authorized source access shared by canonical span-record stores. */\nexport type SpanRecordsToTraceAnalysisStoreOptions = ToolSpansToTraceAnalysisStoreOptions\n\ntype BufferedTraceStoreOptions = ToolSpansToTraceAnalysisStoreOptions\n\nexport interface OtlpFileTraceStoreOptions extends BufferedTraceStoreOptions {\n  /** Path to the OTLP-JSONL file. */\n  path: string\n  /**\n   * Hard ceiling on the trace file size in bytes. The store reads the\n   * whole file into one Buffer and indexes it in memory, so an\n   * unbounded file OOMs the process. Above this size the store fails\n   * loud with `TraceFileTooLargeError` instead of degrading silently.\n   * Default 256 MiB.\n   */\n  maxFileBytes?: number\n}\n\n/** Default ceiling for {@link OtlpFileTraceStoreOptions.maxFileBytes}. */\nexport const DEFAULT_MAX_TRACE_FILE_BYTES = 256 * 1024 * 1024\n\nabstract class BufferedTraceStore implements TraceAnalysisStore {\n  readonly readSpanSource?: SpanSourceReader\n  private readonly perAttributeViewBudget: number\n  private readonly perAttributeSpanBudget: number\n  private readonly perCallByteCeiling: number\n  private readonly perMatchTextBudget: number\n  private indexValue?: DatasetIndex\n  private indexTask?: SharedAbortableTask<DatasetIndex>\n  private bufferValue?: Buffer\n  private bufferTask?: SharedAbortableTask<Buffer>\n\n  constructor(opts: BufferedTraceStoreOptions) {\n    this.perAttributeViewBudget = validateInteger(\n      opts.perAttributeViewBudget ?? DEFAULT_TRACE_ANALYST_BUDGETS.perAttributeViewBudget,\n      'perAttributeViewBudget',\n      TRACE_ANALYSIS_LIMITS.minimumTextBudget,\n    )\n    this.perAttributeSpanBudget = validateInteger(\n      opts.perAttributeSpanBudget ?? DEFAULT_TRACE_ANALYST_BUDGETS.perAttributeSpanBudget,\n      'perAttributeSpanBudget',\n      TRACE_ANALYSIS_LIMITS.minimumTextBudget,\n    )\n    this.perCallByteCeiling = validateInteger(\n      opts.perCallByteCeiling ?? DEFAULT_TRACE_ANALYST_BUDGETS.perCallByteCeiling,\n      'perCallByteCeiling',\n      1,\n    )\n    this.perMatchTextBudget = validateInteger(\n      opts.perMatchTextBudget ?? DEFAULT_TRACE_ANALYST_BUDGETS.perMatchTextBudget,\n      'perMatchTextBudget',\n      TRACE_ANALYSIS_LIMITS.minimumTextBudget,\n    )\n    if (opts.sourceReader !== undefined) {\n      this.readSpanSource = bindSpanSourceReader(this, opts.sourceReader, {\n        perAttributeSpanBudget: this.perAttributeSpanBudget,\n        perCallByteCeiling: this.perCallByteCeiling,\n      })\n    }\n  }\n\n  // ─── Public API ────────────────────────────────────────────────────\n\n  async hasTrace(trace_id: string, context?: TraceAnalysisStoreContext): Promise<boolean> {\n    context?.signal?.throwIfAborted()\n    const idx = await this.index(context)\n    context?.signal?.throwIfAborted()\n    return idx.byTrace.has(trace_id)\n  }\n\n  async hasSpans(\n    opts: { trace_id: string; span_ids: readonly string[] },\n    context?: TraceAnalysisStoreContext,\n  ): Promise<string[]> {\n    context?.signal?.throwIfAborted()\n    const idx = await this.index(context)\n    const trace = idx.byTrace.get(opts.trace_id)\n    if (!trace) return []\n    const requested = new Set(opts.span_ids)\n    const found: string[] = []\n    for (let index = 0; index < trace.spans.length; index += 1) {\n      await scanCheckpoint(context?.signal, index)\n      const spanId = trace.spans[index]!.span_id\n      if (requested.has(spanId)) found.push(spanId)\n    }\n    return found\n  }\n\n  async getOverview(\n    filters?: TraceAnalystFilters,\n    context?: TraceAnalysisStoreContext,\n  ): Promise<DatasetOverview> {\n    const idx = await this.index(context)\n    const matched = await this.matchedTraces(idx, filters, context)\n\n    const services = new Set<string>()\n    const agents = new Set<string>()\n    const models = new Set<string>()\n    const tools = new Set<string>()\n    let rawBytes = 0\n    let earliest: string | null = null\n    let latest: string | null = null\n    let errorTraceCount = 0\n    let errorSpanCount = 0\n    const clusters = new Map<string, ErrorClusterAccumulator>()\n\n    let traceIndex = 0\n    for (const t of matched) {\n      await scanCheckpoint(context?.signal, traceIndex++)\n      if (t.service_name) services.add(t.service_name)\n      for (const agent of t.agents) agents.add(agent)\n      for (const m of t.models) models.add(m)\n      for (const tn of t.tools) tools.add(tn)\n      rawBytes += t.raw_jsonl_bytes\n      if (!earliest || compareSpanTime(t.start_time, earliest) < 0) earliest = t.start_time\n      if (!latest || compareSpanTime(t.end_time, latest) > 0) latest = t.end_time\n      if (t.has_errors) {\n        errorTraceCount += 1\n        let spanIndex = 0\n        for (const s of t.spans) {\n          await scanCheckpoint(context?.signal, spanIndex++)\n          if (s.status !== 'ERROR') continue\n          errorSpanCount += 1\n          accumulateErrorCluster(clusters, t.trace_id, s)\n        }\n      }\n    }\n\n    const sample_trace_ids = matched.slice(0, 20).map((t) => t.trace_id)\n    return {\n      total_traces: matched.length,\n      raw_jsonl_bytes: rawBytes,\n      services: [...services].sort(),\n      agents: [...agents].sort(),\n      models: [...models].sort(),\n      tool_names: [...tools].sort(),\n      sample_trace_ids,\n      errors: { trace_count: errorTraceCount, span_count: errorSpanCount },\n      error_clusters: finalizeErrorClusters(clusters, errorTraceCount),\n      time_range: earliest && latest ? { earliest, latest } : null,\n    }\n  }\n\n  async queryTraces(\n    opts: { filters?: TraceAnalystFilters; limit: number; offset?: number },\n    context?: TraceAnalysisStoreContext,\n  ): Promise<QueryTracesPage> {\n    const limit = validateInteger(\n      opts.limit,\n      'queryTraces.limit',\n      1,\n      TRACE_ANALYSIS_LIMITS.queryTraces,\n    )\n    const offset = validateInteger(opts.offset ?? 0, 'queryTraces.offset', 0)\n\n    const idx = await this.index(context)\n    const matched = await this.matchedTraces(idx, opts.filters, context)\n    const slice = matched.slice(offset, offset + limit)\n    return {\n      traces: slice.map((t) => this.toSummary(t)),\n      total: matched.length,\n      has_more: offset + slice.length < matched.length,\n    }\n  }\n\n  async countTraces(\n    filters?: TraceAnalystFilters,\n    context?: TraceAnalysisStoreContext,\n  ): Promise<number> {\n    const idx = await this.index(context)\n    const matched = await this.matchedTraces(idx, filters, context)\n    return matched.length\n  }\n\n  async viewTrace(\n    opts: { trace_id: string; per_attribute_byte_cap?: number },\n    context?: TraceAnalysisStoreContext,\n  ): Promise<ViewTraceResult> {\n    context?.signal?.throwIfAborted()\n    const idx = await this.index(context)\n    const trace = idx.byTrace.get(opts.trace_id)\n    if (!trace) {\n      throw new TraceNotFoundError(opts.trace_id)\n    }\n    const cap = validateInteger(\n      opts.per_attribute_byte_cap ?? this.perAttributeViewBudget,\n      'viewTrace.per_attribute_byte_cap',\n      1,\n    )\n\n    // Probe size first — if the materialised payload would exceed\n    // the per-call ceiling we return an oversized summary rather than\n    // blowing the agent's context.\n    const buf = await this.buffer(context)\n    const spans: TraceAnalystSpan[] = []\n    let runningBytes = 0\n    let span_response_bytes_max = 0\n    const counter: TruncationCounter = { value: 0 }\n    let spanIndex = 0\n    for (const s of trace.spans) {\n      await scanCheckpoint(context?.signal, spanIndex++)\n      const projected = this.projectSpan(buf, trace.trace_id, s, cap, counter)\n      const bytes = Buffer.byteLength(JSON.stringify(projected), 'utf8')\n      span_response_bytes_max = Math.max(span_response_bytes_max, bytes)\n      runningBytes += bytes\n      if (runningBytes > this.perCallByteCeiling) {\n        return {\n          trace_id: trace.trace_id,\n          oversized: this.buildOversizedSummary(trace, span_response_bytes_max),\n        }\n      }\n      spans.push(projected)\n    }\n    return { trace_id: trace.trace_id, spans }\n  }\n\n  async viewSpans(\n    opts: { trace_id: string; span_ids: readonly string[]; per_attribute_byte_cap?: number },\n    context?: TraceAnalysisStoreContext,\n  ): Promise<ViewSpansResult> {\n    context?.signal?.throwIfAborted()\n    const idx = await this.index(context)\n    const trace = idx.byTrace.get(opts.trace_id)\n    if (!trace) throw new TraceNotFoundError(opts.trace_id)\n    if (opts.span_ids.length < 1 || opts.span_ids.length > TRACE_ANALYSIS_LIMITS.viewSpans) {\n      throw new TraceAnalysisValidationError(\n        `viewSpans.span_ids must contain 1..${TRACE_ANALYSIS_LIMITS.viewSpans} ids, got ${opts.span_ids.length}`,\n      )\n    }\n    const cap = validateInteger(\n      opts.per_attribute_byte_cap ?? this.perAttributeSpanBudget,\n      'viewSpans.per_attribute_byte_cap',\n      1,\n    )\n\n    const requested = [...new Set(opts.span_ids)]\n    const wantSet = new Set(requested)\n    const foundById = new Map<string, SpanIndexEntry>()\n    for (let index = 0; index < trace.spans.length; index += 1) {\n      await scanCheckpoint(context?.signal, index)\n      const span = trace.spans[index]!\n      if (wantSet.has(span.span_id)) foundById.set(span.span_id, span)\n    }\n    const missing = requested.filter((id) => !foundById.has(id))\n\n    const buf = await this.buffer(context)\n    const spans: TraceAnalystSpan[] = []\n    let truncatedAttributeCount = 0\n    const omitted = new Set(requested.filter((id) => foundById.has(id)))\n    const buildResult = (): ViewSpansResult => ({\n      trace_id: trace.trace_id,\n      spans,\n      missing_span_ids: missing,\n      omitted_span_ids: requested.filter((id) => omitted.has(id)),\n      has_more: omitted.size > 0,\n      truncated_attribute_count: truncatedAttributeCount,\n    })\n    const metadataBytes = Buffer.byteLength(JSON.stringify(buildResult()), 'utf8')\n    if (metadataBytes > this.perCallByteCeiling) {\n      throw new TraceAnalysisLimitError(\n        'viewSpans',\n        metadataBytes,\n        this.perCallByteCeiling,\n        `viewSpans accounting requires ${metadataBytes} bytes, over the ${this.perCallByteCeiling}-byte response limit`,\n      )\n    }\n    let spanIndex = 0\n    let smallestRejectedBytes = Number.POSITIVE_INFINITY\n    for (const id of requested) {\n      await scanCheckpoint(context?.signal, spanIndex++)\n      const s = foundById.get(id)\n      if (!s) continue\n      const counter: TruncationCounter = { value: 0 }\n      const projected = this.projectSpan(buf, trace.trace_id, s, cap, counter)\n      spans.push(projected)\n      omitted.delete(id)\n      truncatedAttributeCount += counter.value\n      const responseBytes = Buffer.byteLength(JSON.stringify(buildResult()), 'utf8')\n      if (responseBytes <= this.perCallByteCeiling) {\n        continue\n      }\n      smallestRejectedBytes = Math.min(smallestRejectedBytes, responseBytes)\n      if (requested.length === 1) {\n        throw new TraceAnalysisLimitError(\n          'viewSpans',\n          responseBytes,\n          this.perCallByteCeiling,\n          `viewSpans cannot fit span ${JSON.stringify(id)} in the ${this.perCallByteCeiling}-byte response limit`,\n        )\n      }\n      spans.pop()\n      omitted.add(id)\n      truncatedAttributeCount -= counter.value\n    }\n    if (foundById.size > 0 && spans.length === 0) {\n      throw new TraceAnalysisLimitError(\n        'viewSpans',\n        smallestRejectedBytes,\n        this.perCallByteCeiling,\n        `viewSpans cannot fit one requested span in the ${this.perCallByteCeiling}-byte response limit`,\n      )\n    }\n    return buildResult()\n  }\n\n  async searchTrace(\n    opts: { trace_id: string; regex_pattern: string; max_matches?: number },\n    context?: TraceAnalysisStoreContext,\n  ): Promise<SearchTraceResult> {\n    const max_matches = validateInteger(\n      opts.max_matches ?? 50,\n      'searchTrace.max_matches',\n      1,\n      TRACE_ANALYSIS_LIMITS.searchMatches,\n    )\n    const idx = await this.index(context)\n    const trace = idx.byTrace.get(opts.trace_id)\n    if (!trace) throw new TraceNotFoundError(opts.trace_id)\n    const re = compileSearchRegex(opts.regex_pattern)\n\n    const buf = await this.buffer(context)\n    const hits: SpanMatchRecord[] = []\n    let hasMore = false\n    let spanIndex = 0\n    for (const s of trace.spans) {\n      await scanCheckpoint(context?.signal, spanIndex++)\n      const remaining = max_matches - hits.length\n      const localHits = await this.scanSpanForMatches(\n        buf,\n        trace.trace_id,\n        s,\n        re,\n        this.perMatchTextBudget,\n        remaining,\n        context,\n      )\n      for (const h of localHits.records) {\n        if (hits.length >= max_matches) break\n        hits.push(h)\n      }\n      if (localHits.hasMore) {\n        hasMore = true\n        break\n      }\n    }\n    return {\n      trace_id: trace.trace_id,\n      hits,\n      has_more: hasMore,\n    }\n  }\n\n  async searchSpan(\n    opts: { trace_id: string; span_id: string; regex_pattern: string; max_matches?: number },\n    context?: TraceAnalysisStoreContext,\n  ): Promise<SearchSpanResult> {\n    const max_matches = validateInteger(\n      opts.max_matches ?? 50,\n      'searchSpan.max_matches',\n      1,\n      TRACE_ANALYSIS_LIMITS.searchMatches,\n    )\n    const idx = await this.index(context)\n    const trace = idx.byTrace.get(opts.trace_id)\n    if (!trace) throw new TraceNotFoundError(opts.trace_id)\n    let span: SpanIndexEntry | undefined\n    for (let index = 0; index < trace.spans.length; index += 1) {\n      await scanCheckpoint(context?.signal, index)\n      const candidate = trace.spans[index]!\n      if (candidate.span_id === opts.span_id) {\n        span = candidate\n        break\n      }\n    }\n    if (!span) {\n      throw new SpanNotFoundError(opts.trace_id, opts.span_id)\n    }\n    const re = compileSearchRegex(opts.regex_pattern)\n    const buf = await this.buffer(context)\n    const localHits = await this.scanSpanForMatches(\n      buf,\n      trace.trace_id,\n      span,\n      re,\n      this.perMatchTextBudget,\n      max_matches,\n      context,\n    )\n    return {\n      trace_id: trace.trace_id,\n      span_id: span.span_id,\n      hits: localHits.records,\n      has_more: localHits.hasMore,\n    }\n  }\n\n  // ─── Index building ────────────────────────────────────────────────\n\n  /** Force the index to materialise. Useful to amortise startup cost\n   *  before the first agent call. */\n  async ensureIndexed(context?: TraceAnalysisStoreContext): Promise<void> {\n    await this.index(context)\n  }\n\n  private async buffer(context?: TraceAnalysisStoreContext): Promise<Buffer> {\n    context?.signal?.throwIfAborted()\n    if (this.bufferValue) return this.bufferValue\n    if (!this.bufferTask) {\n      const task = createSharedAbortableTask((signal) => this.readBuffer(signal))\n      this.bufferTask = task\n      void task.promise.then(\n        (value) => {\n          this.bufferValue = value\n          if (this.bufferTask === task) this.bufferTask = undefined\n        },\n        () => {\n          if (this.bufferTask === task) this.bufferTask = undefined\n        },\n      )\n    }\n    return waitForSharedTask(this.bufferTask, context?.signal)\n  }\n\n  protected abstract readBuffer(signal?: AbortSignal): Promise<Buffer>\n\n  protected abstract sourcePath(): string\n\n  protected projectRecord(raw: Record<string, unknown>): TraceAnalystSpan | null {\n    return projectOtlpFlatLine(raw)\n  }\n\n  private async index(context?: TraceAnalysisStoreContext): Promise<DatasetIndex> {\n    context?.signal?.throwIfAborted()\n    if (this.indexValue) return this.indexValue\n    if (!this.indexTask) {\n      const task = createSharedAbortableTask((signal) => this.buildIndex(signal))\n      this.indexTask = task\n      void task.promise.then(\n        (value) => {\n          this.indexValue = value\n          if (this.indexTask === task) this.indexTask = undefined\n        },\n        () => {\n          if (this.indexTask === task) this.indexTask = undefined\n        },\n      )\n    }\n    return waitForSharedTask(this.indexTask, context?.signal)\n  }\n\n  private async buildIndex(signal?: AbortSignal): Promise<DatasetIndex> {\n    // readGuarded surfaces missing/oversized files as typed errors.\n    const buf = await this.buffer({ signal })\n    signal?.throwIfAborted()\n\n    const byTrace = new Map<string, TraceIndexEntry>()\n    let cursor = 0\n    let lineNumber = 0\n    let sinceYield = 0\n    while (cursor < buf.length) {\n      lineNumber += 1\n      // Yield to the event loop every INDEX_YIELD_LINES lines so a huge\n      // file doesn't monopolise the thread for the whole index build.\n      if (++sinceYield >= INDEX_YIELD_LINES) {\n        sinceYield = 0\n        await yieldToEventLoop()\n        signal?.throwIfAborted()\n      }\n      const newlineIndex = buf.indexOf(0x0a, cursor) // \\n\n      const lineEnd = newlineIndex === -1 ? buf.length : newlineIndex\n      const lineLength = lineEnd - cursor\n      if (lineLength === 0) {\n        cursor = lineEnd + 1\n        continue\n      }\n      const lineSlice = buf.subarray(cursor, lineEnd).toString('utf8')\n      const lineOffset = cursor\n      cursor = lineEnd + 1\n\n      let parsed: unknown\n      try {\n        parsed = JSON.parse(lineSlice)\n      } catch (cause) {\n        throw new TraceFileMalformedError(this.sourcePath(), lineNumber, lineOffset, cause)\n      }\n      if (!parsed || typeof parsed !== 'object') {\n        throw new TraceFileMalformedError(this.sourcePath(), lineNumber, lineOffset)\n      }\n      const span = this.projectRecord(parsed as Record<string, unknown>)\n      if (!span) {\n        throw new TraceFileMalformedError(this.sourcePath(), lineNumber, lineOffset)\n      }\n\n      let entry = byTrace.get(span.trace_id)\n      if (!entry) {\n        entry = {\n          trace_id: span.trace_id,\n          service_name: span.service_name,\n          agent_name: span.agent_name,\n          span_count: 0,\n          has_errors: false,\n          start_time: span.start_time,\n          end_time: span.end_time,\n          duration_ms: 0,\n          raw_jsonl_bytes: 0,\n          agents: new Set(),\n          models: new Set(),\n          tools: new Set(),\n          spans: [],\n        }\n        byTrace.set(span.trace_id, entry)\n      } else {\n        // Pin the trace's service/agent to the first AGENT span we\n        // Prefer the first agent/service fields that appear in the trace.\n        if (!entry.service_name && span.service_name) entry.service_name = span.service_name\n        if (!entry.agent_name && span.agent_name) entry.agent_name = span.agent_name\n      }\n\n      const indexEntry: SpanIndexEntry = {\n        span_id: span.span_id,\n        parent_span_id: span.parent_span_id,\n        name: span.name,\n        kind: span.kind,\n        start_time: span.start_time,\n        end_time: span.end_time,\n        duration_ms: span.duration_ms,\n        status: span.status,\n        status_message: span.status_message,\n        service_name: span.service_name,\n        agent_name: span.agent_name,\n        model_name: span.model_name,\n        tool_name: span.tool_name,\n        line_byte_offset: lineOffset,\n        line_byte_length: lineLength,\n      }\n      entry.spans.push(indexEntry)\n      entry.span_count += 1\n      entry.raw_jsonl_bytes += lineLength + 1 // +1 newline byte\n      if (span.status === 'ERROR') entry.has_errors = true\n      if (compareSpanTime(span.start_time, entry.start_time) < 0) entry.start_time = span.start_time\n      if (compareSpanTime(span.end_time, entry.end_time) > 0) entry.end_time = span.end_time\n      if (span.agent_name) entry.agents.add(span.agent_name)\n      if (span.model_name) entry.models.add(span.model_name)\n      if (span.tool_name) entry.tools.add(span.tool_name)\n    }\n\n    // Compute trace duration once, sort spans by start time for\n    // stable iteration.\n    let totalRawBytes = 0\n    for (const t of byTrace.values()) {\n      signal?.throwIfAborted()\n      totalRawBytes += t.raw_jsonl_bytes\n      t.spans.sort(\n        (a, b) =>\n          compareSpanTime(a.start_time, b.start_time) || a.line_byte_offset - b.line_byte_offset,\n      )\n      // Duration is 0 unless BOTH bounds parse — a missing/garbage timestamp\n      // yields 0, never a NaN (→ null in JSON) or a bogus epoch-from-zero span.\n      const startMs = spanEpochMillis(t.start_time)\n      const endMs = spanEpochMillis(t.end_time)\n      t.duration_ms = startMs === null || endMs === null ? 0 : Math.max(0, endMs - startMs)\n    }\n    const sortedTraceIds = [...byTrace.keys()].sort()\n    signal?.throwIfAborted()\n\n    return { byTrace, totalRawBytes, sortedTraceIds }\n  }\n\n  // ─── Filter pipeline ───────────────────────────────────────────────\n\n  private async matchedTraces(\n    idx: DatasetIndex,\n    filters: TraceAnalystFilters | undefined,\n    context?: TraceAnalysisStoreContext,\n  ): Promise<TraceIndexEntry[]> {\n    context?.signal?.throwIfAborted()\n    const traces: TraceIndexEntry[] = []\n    for (let index = 0; index < idx.sortedTraceIds.length; index += 1) {\n      await scanCheckpoint(context?.signal, index)\n      const trace = idx.byTrace.get(idx.sortedTraceIds[index]!)\n      if (trace) traces.push(trace)\n    }\n    if (!filters) return traces\n\n    const indexedFiltered: TraceIndexEntry[] = []\n    for (let index = 0; index < traces.length; index += 1) {\n      await scanCheckpoint(context?.signal, index)\n      const t = traces[index]!\n      if (filters.has_errors !== undefined && t.has_errors !== filters.has_errors) continue\n      if (filters.service_names && filters.service_names.length > 0) {\n        if (!t.service_name || !filters.service_names.includes(t.service_name)) continue\n      }\n      if (filters.agent_names && filters.agent_names.length > 0) {\n        if (![...t.agents].some((agent) => filters.agent_names!.includes(agent))) continue\n      }\n      if (filters.model_names && filters.model_names.length > 0) {\n        if (![...t.models].some((m) => filters.model_names!.includes(m))) continue\n      }\n      if (filters.tool_names && filters.tool_names.length > 0) {\n        if (![...t.tools].some((tn) => filters.tool_names!.includes(tn))) continue\n      }\n      if (filters.start_time_after && t.start_time < filters.start_time_after) continue\n      if (filters.start_time_before && t.start_time > filters.start_time_before) continue\n      indexedFiltered.push(t)\n    }\n\n    if (!filters.regex_pattern) return indexedFiltered\n\n    // Opt-in raw-bytes scan — only over the already-narrowed set.\n    const re = compileSearchRegex(filters.regex_pattern)\n    const buf = await this.buffer(context)\n    const out: TraceIndexEntry[] = []\n    let traceIndex = 0\n    for (const t of indexedFiltered) {\n      await scanCheckpoint(context?.signal, traceIndex++)\n      let matched = false\n      let spanIndex = 0\n      for (const s of t.spans) {\n        await scanCheckpoint(context?.signal, spanIndex++)\n        const slice = buf.subarray(s.line_byte_offset, s.line_byte_offset + s.line_byte_length)\n        // Buffer.toString allocates; tolerate it because regex_pattern\n        // is opt-in. Future optimisation: byte-level fast-path for\n        // ASCII-only patterns.\n        if (re.test(slice.toString('utf8'))) {\n          matched = true\n          break\n        }\n      }\n      if (matched) out.push(t)\n    }\n    return out\n  }\n\n  private toSummary(t: TraceIndexEntry): TraceAnalystTraceSummary {\n    return {\n      trace_id: t.trace_id,\n      service_name: t.service_name,\n      agent_name: t.agent_name,\n      span_count: t.span_count,\n      has_errors: t.has_errors,\n      start_time: t.start_time,\n      end_time: t.end_time,\n      duration_ms: t.duration_ms,\n      raw_jsonl_bytes: t.raw_jsonl_bytes,\n      models: [...t.models].sort(),\n      tools: [...t.tools].sort(),\n    }\n  }\n\n  // ─── Span projection (lazy attribute reads) ────────────────────────\n\n  private projectSpan(\n    buf: Buffer,\n    trace_id: string,\n    s: SpanIndexEntry,\n    perAttrCap: number,\n    counter: TruncationCounter,\n  ): TraceAnalystSpan {\n    const slice = buf\n      .subarray(s.line_byte_offset, s.line_byte_offset + s.line_byte_length)\n      .toString('utf8')\n    let raw: Record<string, unknown> = {}\n    try {\n      const parsed = JSON.parse(slice)\n      if (parsed && typeof parsed === 'object') raw = parsed as Record<string, unknown>\n    } catch {\n      // Should not happen — index pre-validated.\n    }\n    const attrs = extractOtlpAttributes(raw)\n    const projected: Record<string, unknown> = {}\n    for (const [k, v] of Object.entries(attrs)) {\n      if (typeof v === 'string') {\n        const trunc = truncateForBudget(v, perAttrCap)\n        if (trunc !== v) counter.value += 1\n        projected[k] = trunc\n      } else if (Array.isArray(v) || (v && typeof v === 'object')) {\n        const json = JSON.stringify(v)\n        const trunc = truncateForBudget(json, perAttrCap)\n        if (trunc !== json) {\n          counter.value += 1\n          projected[k] = trunc\n        } else {\n          projected[k] = v\n        }\n      } else {\n        projected[k] = v\n      }\n    }\n    return {\n      trace_id,\n      span_id: s.span_id,\n      parent_span_id: s.parent_span_id,\n      name: s.name,\n      kind: s.kind,\n      start_time: s.start_time,\n      end_time: s.end_time,\n      duration_ms: s.duration_ms,\n      status: s.status,\n      status_message: s.status_message,\n      service_name: s.service_name,\n      agent_name: s.agent_name,\n      model_name: s.model_name,\n      tool_name: s.tool_name,\n      attributes: projected,\n    }\n  }\n\n  private buildOversizedSummary(\n    t: TraceIndexEntry,\n    span_response_bytes_max: number,\n  ): ViewTraceOversized {\n    const counts = new Map<string, number>()\n    let errorCount = 0\n    for (const s of t.spans) {\n      counts.set(s.name, (counts.get(s.name) ?? 0) + 1)\n      if (s.status === 'ERROR') errorCount += 1\n    }\n    const top = [...counts.entries()].sort((a, b) => b[1] - a[1]).slice(0, 20)\n    return {\n      span_count: t.span_count,\n      top_span_names: top,\n      span_response_bytes_max,\n      error_span_count: errorCount,\n    }\n  }\n\n  private async scanSpanForMatches(\n    buf: Buffer,\n    trace_id: string,\n    s: SpanIndexEntry,\n    re: RE2JS,\n    textBudget: number,\n    recordCap: number,\n    context?: TraceAnalysisStoreContext,\n  ): Promise<{ records: SpanMatchRecord[]; hasMore: boolean }> {\n    // We scan against the original raw JSONL slice for each span and\n    // record byte positions; the matched_text + context window is\n    // truncated to `textBudget` bytes per record so total tool output\n    // stays bounded even if hits cluster.\n    const slice = buf\n      .subarray(s.line_byte_offset, s.line_byte_offset + s.line_byte_length)\n      .toString('utf8')\n    const records: SpanMatchRecord[] = []\n    let hasMore = false\n    let matchIndex = 0\n    for (const match of re.matchAll(slice)) {\n      await scanCheckpoint(context?.signal, matchIndex++)\n      if (records.length >= recordCap) {\n        hasMore = true\n        break\n      }\n      const offset = match.index ?? 0\n      const before = slice.slice(Math.max(0, offset - textBudget / 2), offset)\n      const after = slice.slice(\n        offset + match[0].length,\n        offset + match[0].length + Math.floor(textBudget / 2),\n      )\n      records.push({\n        trace_id,\n        span_id: s.span_id,\n        span_name: s.name,\n        span_kind: s.kind,\n        attribute_path: bestAttributePathForOffset(slice, offset) ?? 'span.raw',\n        matched_text: truncateForBudget(match[0], textBudget),\n        context_before: truncateForBudget(before, textBudget),\n        context_after: truncateForBudget(after, textBudget),\n        match_offset: offset,\n      })\n    }\n    return { records, hasMore }\n  }\n}\n\nexport class OtlpFileTraceStore extends BufferedTraceStore {\n  private readonly path: string\n  private readonly maxFileBytes: number\n\n  constructor(opts: OtlpFileTraceStoreOptions) {\n    super(opts)\n    this.path = opts.path\n    this.maxFileBytes = validateInteger(\n      opts.maxFileBytes ?? DEFAULT_MAX_TRACE_FILE_BYTES,\n      'maxFileBytes',\n      1,\n    )\n  }\n\n  /** Stat-then-read so an oversized file fails loud before allocating the\n   *  source buffer. Missing files remain distinct from malformed traces. */\n  protected async readBuffer(signal?: AbortSignal): Promise<Buffer> {\n    signal?.throwIfAborted()\n    let stats: Awaited<ReturnType<typeof stat>>\n    try {\n      stats = await stat(this.path)\n    } catch (err) {\n      if ((err as NodeJS.ErrnoException)?.code === 'ENOENT') {\n        throw new TraceFileMissingError(this.path)\n      }\n      throw err\n    }\n    if (stats.size > this.maxFileBytes) {\n      throw new TraceFileTooLargeError(this.path, stats.size, this.maxFileBytes)\n    }\n    signal?.throwIfAborted()\n    return readFile(this.path, { signal })\n  }\n\n  protected sourcePath(): string {\n    return this.path\n  }\n}\n\nclass BufferTraceStore extends BufferedTraceStore {\n  constructor(\n    private readonly source: Buffer,\n    opts: BufferedTraceStoreOptions,\n  ) {\n    super(opts)\n  }\n\n  protected async readBuffer(signal?: AbortSignal): Promise<Buffer> {\n    signal?.throwIfAborted()\n    return this.source\n  }\n\n  protected sourcePath(): string {\n    return '<memory>'\n  }\n}\n\nclass SpanRecordTraceStore extends BufferTraceStore {\n  protected override projectRecord(raw: Record<string, unknown>): TraceAnalystSpan {\n    return traceSpanSchema.parse(raw)\n  }\n}\n\n/**\n * Snapshot canonical spans without reinterpreting their identifiers, kind, or duration.\n * Reads use the same indexed, bounded engine as the OTLP adapters. Raw byte counts\n * and searches refer to the canonical JSONL snapshot, not an external source artifact.\n */\nexport function spanRecordsToTraceAnalysisStore(\n  records: readonly TraceAnalystSpan[],\n  options: SpanRecordsToTraceAnalysisStoreOptions = {},\n): TraceAnalysisStore {\n  if (!records || records.length === 0) {\n    throw new CaptureIntegrityError('spanRecordsToTraceAnalysisStore: no span records supplied')\n  }\n  const seen = new Map<string, Set<string>>()\n  const lines = records.map((record, index) => {\n    try {\n      const span = traceSpanSchema.parse(record)\n      const traceSpans = seen.get(span.trace_id) ?? new Set<string>()\n      if (traceSpans.has(span.span_id)) {\n        throw new CaptureIntegrityError(\n          `spanRecordsToTraceAnalysisStore: duplicate span '${span.span_id}' in trace '${span.trace_id}'`,\n        )\n      }\n      traceSpans.add(span.span_id)\n      seen.set(span.trace_id, traceSpans)\n      return JSON.stringify(span)\n    } catch (cause) {\n      if (cause instanceof CaptureIntegrityError) throw cause\n      throw new CaptureIntegrityError(\n        `spanRecordsToTraceAnalysisStore: invalid span record at index ${index}`,\n        { cause },\n      )\n    }\n  })\n  return new SpanRecordTraceStore(Buffer.from(`${lines.join('\\n')}\\n`, 'utf8'), options)\n}\n\n/** Build the bounded trace store directly from OpenInference JSONL text. */\nexport function otlpTextToTraceAnalysisStore(\n  text: string,\n  opts: ToolSpansToTraceAnalysisStoreOptions = {},\n): TraceAnalysisStore {\n  if (!text.trim()) throw new CaptureIntegrityError('OTLP trace text must not be empty')\n  return new BufferTraceStore(Buffer.from(text, 'utf8'), opts)\n}\n\nexport function createOtlpBufferTraceStore(\n  source: Buffer,\n  options: ToolSpansToTraceAnalysisStoreOptions = {},\n): TraceAnalysisStore {\n  return new BufferTraceStore(source, options)\n}\n\nexport {\n  SpanNotFoundError,\n  TraceFileMalformedError,\n  TraceFileMissingError,\n  TraceFileTooLargeError,\n  TraceNotFoundError,\n} from './errors'\n\n// ─── OTLP shape readers ──────────────────────────────────────────────\n//\n// The per-line projection lives in `./otlp-span` so the index here and\n// `otlpToRunRecords` read the same vocabulary off the same parser.\n\n// Per-call truncation counter. Each public read that projects spans\n// owns one of these and threads it through projectSpan; a store-keyed\n// counter would let two concurrent reads on the same store report each\n// other's truncation counts.\ninterface TruncationCounter {\n  value: number\n}\n\n/** A `\"` at `idx` is a real JSON delimiter only when the run of `\\`\n *  immediately preceding it is even-length; an odd run means the quote\n *  is escaped (`\\\"`) and is part of a string value, not a boundary. */\nfunction isUnescapedQuote(slice: string, idx: number): boolean {\n  if (slice[idx] !== '\"') return false\n  let backslashes = 0\n  let b = idx - 1\n  while (b >= 0 && slice[b] === '\\\\') {\n    backslashes += 1\n    b -= 1\n  }\n  return backslashes % 2 === 0\n}\n\n/** Scan backwards from `from` (inclusive) for the nearest UNescaped `\"`.\n *  Returns its index, or -1 when none is found. */\nfunction prevUnescapedQuote(slice: string, from: number): number {\n  for (let i = from; i >= 0; i -= 1) {\n    if (slice[i] === '\"' && isUnescapedQuote(slice, i)) return i\n  }\n  return -1\n}\n\n/**\n * Best-effort: locate the JSON path for the substring at `offset` in\n * a single span's JSONL slice. The slice is '...,\"key\":\"value...\"' — we\n * walk back from `offset` to the value-opening quote, past the `:`, to\n * the key's closing then opening quote, skipping `\\\"`-escaped quotes that\n * live inside string values. Returns `null` when the offset doesn't fall\n * inside a recognisable string field.\n */\nfunction bestAttributePathForOffset(slice: string, offset: number): string | null {\n  // Value-opening quote: nearest unescaped '\"' at or before the offset.\n  const valueQuote = prevUnescapedQuote(slice, Math.min(offset, slice.length - 1))\n  if (valueQuote < 1) return null\n  // The ':' separating key and value sits before the value quote.\n  let j = valueQuote - 1\n  while (j >= 0 && slice[j] !== ':') j -= 1\n  if (j < 1) return null\n  // Key closing quote, then key opening quote — both unescaped.\n  const keyClose = prevUnescapedQuote(slice, j - 1)\n  if (keyClose < 1) return null\n  const keyOpen = prevUnescapedQuote(slice, keyClose - 1)\n  if (keyOpen < 0) return null\n  return slice.slice(keyOpen + 1, keyClose)\n}\n\n// ─── Error-cluster extraction ────────────────────────────────────────\n//\n// Deterministic failure-coverage population. The error-span loop in\n// getOverview already visits every ERROR span; bucketing them by a\n// normalized status_message signature turns \"N error spans\" into \"K\n// distinct failure modes\" — the checklist an analyst must close. No LLM.\n\nconst ERROR_CLUSTER_EXEMPLARS = 5\n\ninterface ErrorClusterAccumulator {\n  signature: string\n  sample: string\n  traceIds: Set<string>\n  spanIds: string[]\n  spanCount: number\n  spanNames: Map<string, number>\n  toolNames: Map<string, number>\n}\n\n/** Collapse volatile tokens so semantically identical failures share a key:\n *  hex/uuid ids → <id>, numbers → #, quoted/abs paths → <path>, durations →\n *  <dur>, whitespace collapsed. Empty/absent messages fall back to the span\n *  name so a no-message error still forms a real cluster. */\nfunction normalizeErrorSignature(message: string | undefined, spanName: string): string {\n  const raw = (message ?? '').trim()\n  const base = raw.length > 0 ? raw : `(${spanName || 'error'} — no message)`\n  const norm = base\n    .replace(/[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}/gi, '<id>')\n    .replace(/\\b[0-9a-f]{12,}\\b/gi, '<id>')\n    .replace(/(?:\\/[\\w.\\-@]+){2,}/g, '<path>')\n    .replace(/\\b\\d+(?:\\.\\d+)?(ms|s|m|h|kb|mb|gb)?\\b/gi, (_m, u) => (u ? `#${u}` : '#'))\n    .replace(/\\s+/g, ' ')\n    .trim()\n  return norm\n}\n\nfunction bump(map: Map<string, number>, key: string | null): void {\n  if (!key) return\n  map.set(key, (map.get(key) ?? 0) + 1)\n}\n\nfunction topKey(map: Map<string, number>): string | null {\n  let best: string | null = null\n  let bestN = 0\n  for (const [k, n] of map)\n    if (n > bestN) {\n      best = k\n      bestN = n\n    }\n  return best\n}\n\nfunction accumulateErrorCluster(\n  clusters: Map<string, ErrorClusterAccumulator>,\n  traceId: string,\n  span: SpanIndexEntry,\n): void {\n  const signature = normalizeErrorSignature(span.status_message, span.name)\n  let acc = clusters.get(signature)\n  if (!acc) {\n    acc = {\n      signature,\n      sample: span.status_message ?? span.name ?? '',\n      traceIds: new Set(),\n      spanIds: [],\n      spanCount: 0,\n      spanNames: new Map(),\n      toolNames: new Map(),\n    }\n    clusters.set(signature, acc)\n  }\n  acc.traceIds.add(traceId)\n  acc.spanCount += 1\n  if (acc.spanIds.length < ERROR_CLUSTER_EXEMPLARS && !acc.spanIds.includes(span.span_id)) {\n    acc.spanIds.push(span.span_id)\n  }\n  bump(acc.spanNames, span.name)\n  bump(acc.toolNames, span.tool_name)\n}\n\nfunction finalizeErrorClusters(\n  clusters: Map<string, ErrorClusterAccumulator>,\n  errorTraceCount: number,\n): ErrorCluster[] {\n  const out = [...clusters.values()].map(\n    (acc): ErrorCluster => ({\n      signature: acc.signature,\n      status_message_sample: acc.sample,\n      span_name: topKey(acc.spanNames),\n      tool_name: topKey(acc.toolNames),\n      trace_count: acc.traceIds.size,\n      span_count: acc.spanCount,\n      prevalence: errorTraceCount > 0 ? acc.traceIds.size / errorTraceCount : 0,\n      exemplar_trace_ids: [...acc.traceIds].slice(0, ERROR_CLUSTER_EXEMPLARS),\n      exemplar_span_ids: acc.spanIds.slice(0, ERROR_CLUSTER_EXEMPLARS),\n    }),\n  )\n  out.sort((a, b) => b.trace_count - a.trace_count || b.span_count - a.span_count)\n  return out\n}\n"],"mappings":";;;;AAOA,SAAgB,0BACd,SACwB;CACxB,MAAM,aAAa,IAAI,gBAAgB;CACvC,MAAM,OAA+B;EACnC;EACA,SAAS,QAAQ,WAAW,MAAM;EAClC,WAAW;EACX,SAAS;CACX;CACA,KAAU,QAAQ,WACV;EACJ,KAAK,UAAU;CACjB,SACM;EACJ,KAAK,UAAU;CACjB,CACF;CACA,OAAO;AACT;AAEA,SAAgB,kBACd,MACA,QACY;CACZ,QAAQ,eAAe;CACvB,KAAK,aAAa;CAElB,OAAO,IAAI,SAAY,SAAS,WAAW;EACzC,IAAI,WAAW;EACf,MAAM,UAAU,aAA+B;GAC7C,IAAI,UAAU;GACd,WAAW;GACX,QAAQ,oBAAoB,SAAS,OAAO;GAC5C,KAAK,aAAa;GAClB,SAAS;EACX;EACA,MAAM,gBAAsB;GAC1B,aAAa;IACX,OAAO,QAAQ,MAAM;IACrB,IAAI,CAAC,KAAK,WAAW,KAAK,cAAc,GACtC,KAAK,WAAW,MAAM,QAAQ,MAAM;GAExC,CAAC;EACH;EAEA,QAAQ,iBAAiB,SAAS,SAAS,EAAE,MAAM,KAAK,CAAC;EACzD,KAAK,QAAQ,MACV,UAAU,aAAa,QAAQ,KAAK,CAAC,IACrC,UAAmB,aAAa,OAAO,KAAK,CAAC,CAChD;EACA,IAAI,QAAQ,SAAS,QAAQ;CAC/B,CAAC;AACH;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;ACsBA,MAAM,oBAAoB;AAC1B,MAAM,mBAAmB;;AAGzB,SAAS,mBAAkC;CACzC,OAAO,IAAI,SAAS,YAAY,aAAa,OAAO,CAAC;AACvD;AAEA,eAAe,eAAe,QAAiC,MAA6B;CAC1F,QAAQ,eAAe;CACvB,IAAI,OAAO,KAAK,OAAO,qBAAqB,GAAG;EAC7C,MAAM,iBAAiB;EACvB,QAAQ,eAAe;CACzB;AACF;;AA8EA,MAAa,+BAA+B;AAE5C,IAAe,qBAAf,MAAgE;CAC9D;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CAEA,YAAY,MAAiC;EAC3C,KAAK,yBAAyB,gBAC5B,KAAK,0BAA0B,8BAA8B,wBAC7D,0BACA,sBAAsB,iBACxB;EACA,KAAK,yBAAyB,gBAC5B,KAAK,0BAA0B,8BAA8B,wBAC7D,0BACA,sBAAsB,iBACxB;EACA,KAAK,qBAAqB,gBACxB,KAAK,sBAAsB,8BAA8B,oBACzD,sBACA,CACF;EACA,KAAK,qBAAqB,gBACxB,KAAK,sBAAsB,8BAA8B,oBACzD,sBACA,sBAAsB,iBACxB;EACA,IAAI,KAAK,iBAAiB,KAAA,GACxB,KAAK,iBAAiB,qBAAqB,MAAM,KAAK,cAAc;GAClE,wBAAwB,KAAK;GAC7B,oBAAoB,KAAK;EAC3B,CAAC;CAEL;CAIA,MAAM,SAAS,UAAkB,SAAuD;EACtF,SAAS,QAAQ,eAAe;EAChC,MAAM,MAAM,MAAM,KAAK,MAAM,OAAO;EACpC,SAAS,QAAQ,eAAe;EAChC,OAAO,IAAI,QAAQ,IAAI,QAAQ;CACjC;CAEA,MAAM,SACJ,MACA,SACmB;EACnB,SAAS,QAAQ,eAAe;EAEhC,MAAM,SAAQ,MADI,KAAK,MAAM,OAAO,EAAA,CAClB,QAAQ,IAAI,KAAK,QAAQ;EAC3C,IAAI,CAAC,OAAO,OAAO,CAAC;EACpB,MAAM,YAAY,IAAI,IAAI,KAAK,QAAQ;EACvC,MAAM,QAAkB,CAAC;EACzB,KAAK,IAAI,QAAQ,GAAG,QAAQ,MAAM,MAAM,QAAQ,SAAS,GAAG;GAC1D,MAAM,eAAe,SAAS,QAAQ,KAAK;GAC3C,MAAM,SAAS,MAAM,MAAM,MAAM,CAAE;GACnC,IAAI,UAAU,IAAI,MAAM,GAAG,MAAM,KAAK,MAAM;EAC9C;EACA,OAAO;CACT;CAEA,MAAM,YACJ,SACA,SAC0B;EAC1B,MAAM,MAAM,MAAM,KAAK,MAAM,OAAO;EACpC,MAAM,UAAU,MAAM,KAAK,cAAc,KAAK,SAAS,OAAO;EAE9D,MAAM,2BAAW,IAAI,IAAY;EACjC,MAAM,yBAAS,IAAI,IAAY;EAC/B,MAAM,yBAAS,IAAI,IAAY;EAC/B,MAAM,wBAAQ,IAAI,IAAY;EAC9B,IAAI,WAAW;EACf,IAAI,WAA0B;EAC9B,IAAI,SAAwB;EAC5B,IAAI,kBAAkB;EACtB,IAAI,iBAAiB;EACrB,MAAM,2BAAW,IAAI,IAAqC;EAE1D,IAAI,aAAa;EACjB,KAAK,MAAM,KAAK,SAAS;GACvB,MAAM,eAAe,SAAS,QAAQ,YAAY;GAClD,IAAI,EAAE,cAAc,SAAS,IAAI,EAAE,YAAY;GAC/C,KAAK,MAAM,SAAS,EAAE,QAAQ,OAAO,IAAI,KAAK;GAC9C,KAAK,MAAM,KAAK,EAAE,QAAQ,OAAO,IAAI,CAAC;GACtC,KAAK,MAAM,MAAM,EAAE,OAAO,MAAM,IAAI,EAAE;GACtC,YAAY,EAAE;GACd,IAAI,CAAC,YAAY,gBAAgB,EAAE,YAAY,QAAQ,IAAI,GAAG,WAAW,EAAE;GAC3E,IAAI,CAAC,UAAU,gBAAgB,EAAE,UAAU,MAAM,IAAI,GAAG,SAAS,EAAE;GACnE,IAAI,EAAE,YAAY;IAChB,mBAAmB;IACnB,IAAI,YAAY;IAChB,KAAK,MAAM,KAAK,EAAE,OAAO;KACvB,MAAM,eAAe,SAAS,QAAQ,WAAW;KACjD,IAAI,EAAE,WAAW,SAAS;KAC1B,kBAAkB;KAClB,uBAAuB,UAAU,EAAE,UAAU,CAAC;IAChD;GACF;EACF;EAEA,MAAM,mBAAmB,QAAQ,MAAM,GAAG,EAAE,CAAC,CAAC,KAAK,MAAM,EAAE,QAAQ;EACnE,OAAO;GACL,cAAc,QAAQ;GACtB,iBAAiB;GACjB,UAAU,CAAC,GAAG,QAAQ,CAAC,CAAC,KAAK;GAC7B,QAAQ,CAAC,GAAG,MAAM,CAAC,CAAC,KAAK;GACzB,QAAQ,CAAC,GAAG,MAAM,CAAC,CAAC,KAAK;GACzB,YAAY,CAAC,GAAG,KAAK,CAAC,CAAC,KAAK;GAC5B;GACA,QAAQ;IAAE,aAAa;IAAiB,YAAY;GAAe;GACnE,gBAAgB,sBAAsB,UAAU,eAAe;GAC/D,YAAY,YAAY,SAAS;IAAE;IAAU;GAAO,IAAI;EAC1D;CACF;CAEA,MAAM,YACJ,MACA,SAC0B;EAC1B,MAAM,QAAQ,gBACZ,KAAK,OACL,qBACA,GACA,sBAAsB,WACxB;EACA,MAAM,SAAS,gBAAgB,KAAK,UAAU,GAAG,sBAAsB,CAAC;EAExE,MAAM,MAAM,MAAM,KAAK,MAAM,OAAO;EACpC,MAAM,UAAU,MAAM,KAAK,cAAc,KAAK,KAAK,SAAS,OAAO;EACnE,MAAM,QAAQ,QAAQ,MAAM,QAAQ,SAAS,KAAK;EAClD,OAAO;GACL,QAAQ,MAAM,KAAK,MAAM,KAAK,UAAU,CAAC,CAAC;GAC1C,OAAO,QAAQ;GACf,UAAU,SAAS,MAAM,SAAS,QAAQ;EAC5C;CACF;CAEA,MAAM,YACJ,SACA,SACiB;EACjB,MAAM,MAAM,MAAM,KAAK,MAAM,OAAO;EAEpC,QAAO,MADe,KAAK,cAAc,KAAK,SAAS,OAAO,EAAA,CAC/C;CACjB;CAEA,MAAM,UACJ,MACA,SAC0B;EAC1B,SAAS,QAAQ,eAAe;EAEhC,MAAM,SAAQ,MADI,KAAK,MAAM,OAAO,EAAA,CAClB,QAAQ,IAAI,KAAK,QAAQ;EAC3C,IAAI,CAAC,OACH,MAAM,IAAI,mBAAmB,KAAK,QAAQ;EAE5C,MAAM,MAAM,gBACV,KAAK,0BAA0B,KAAK,wBACpC,oCACA,CACF;EAKA,MAAM,MAAM,MAAM,KAAK,OAAO,OAAO;EACrC,MAAM,QAA4B,CAAC;EACnC,IAAI,eAAe;EACnB,IAAI,0BAA0B;EAC9B,MAAM,UAA6B,EAAE,OAAO,EAAE;EAC9C,IAAI,YAAY;EAChB,KAAK,MAAM,KAAK,MAAM,OAAO;GAC3B,MAAM,eAAe,SAAS,QAAQ,WAAW;GACjD,MAAM,YAAY,KAAK,YAAY,KAAK,MAAM,UAAU,GAAG,KAAK,OAAO;GACvE,MAAM,QAAQ,OAAO,WAAW,KAAK,UAAU,SAAS,GAAG,MAAM;GACjE,0BAA0B,KAAK,IAAI,yBAAyB,KAAK;GACjE,gBAAgB;GAChB,IAAI,eAAe,KAAK,oBACtB,OAAO;IACL,UAAU,MAAM;IAChB,WAAW,KAAK,sBAAsB,OAAO,uBAAuB;GACtE;GAEF,MAAM,KAAK,SAAS;EACtB;EACA,OAAO;GAAE,UAAU,MAAM;GAAU;EAAM;CAC3C;CAEA,MAAM,UACJ,MACA,SAC0B;EAC1B,SAAS,QAAQ,eAAe;EAEhC,MAAM,SAAQ,MADI,KAAK,MAAM,OAAO,EAAA,CAClB,QAAQ,IAAI,KAAK,QAAQ;EAC3C,IAAI,CAAC,OAAO,MAAM,IAAI,mBAAmB,KAAK,QAAQ;EACtD,IAAI,KAAK,SAAS,SAAS,KAAK,KAAK,SAAS,SAAS,sBAAsB,WAC3E,MAAM,IAAI,6BACR,sCAAsC,sBAAsB,UAAU,YAAY,KAAK,SAAS,QAClG;EAEF,MAAM,MAAM,gBACV,KAAK,0BAA0B,KAAK,wBACpC,oCACA,CACF;EAEA,MAAM,YAAY,CAAC,GAAG,IAAI,IAAI,KAAK,QAAQ,CAAC;EAC5C,MAAM,UAAU,IAAI,IAAI,SAAS;EACjC,MAAM,4BAAY,IAAI,IAA4B;EAClD,KAAK,IAAI,QAAQ,GAAG,QAAQ,MAAM,MAAM,QAAQ,SAAS,GAAG;GAC1D,MAAM,eAAe,SAAS,QAAQ,KAAK;GAC3C,MAAM,OAAO,MAAM,MAAM;GACzB,IAAI,QAAQ,IAAI,KAAK,OAAO,GAAG,UAAU,IAAI,KAAK,SAAS,IAAI;EACjE;EACA,MAAM,UAAU,UAAU,QAAQ,OAAO,CAAC,UAAU,IAAI,EAAE,CAAC;EAE3D,MAAM,MAAM,MAAM,KAAK,OAAO,OAAO;EACrC,MAAM,QAA4B,CAAC;EACnC,IAAI,0BAA0B;EAC9B,MAAM,UAAU,IAAI,IAAI,UAAU,QAAQ,OAAO,UAAU,IAAI,EAAE,CAAC,CAAC;EACnE,MAAM,qBAAsC;GAC1C,UAAU,MAAM;GAChB;GACA,kBAAkB;GAClB,kBAAkB,UAAU,QAAQ,OAAO,QAAQ,IAAI,EAAE,CAAC;GAC1D,UAAU,QAAQ,OAAO;GACzB,2BAA2B;EAC7B;EACA,MAAM,gBAAgB,OAAO,WAAW,KAAK,UAAU,YAAY,CAAC,GAAG,MAAM;EAC7E,IAAI,gBAAgB,KAAK,oBACvB,MAAM,IAAI,wBACR,aACA,eACA,KAAK,oBACL,iCAAiC,cAAc,mBAAmB,KAAK,mBAAmB,qBAC5F;EAEF,IAAI,YAAY;EAChB,IAAI,wBAAwB,OAAO;EACnC,KAAK,MAAM,MAAM,WAAW;GAC1B,MAAM,eAAe,SAAS,QAAQ,WAAW;GACjD,MAAM,IAAI,UAAU,IAAI,EAAE;GAC1B,IAAI,CAAC,GAAG;GACR,MAAM,UAA6B,EAAE,OAAO,EAAE;GAC9C,MAAM,YAAY,KAAK,YAAY,KAAK,MAAM,UAAU,GAAG,KAAK,OAAO;GACvE,MAAM,KAAK,SAAS;GACpB,QAAQ,OAAO,EAAE;GACjB,2BAA2B,QAAQ;GACnC,MAAM,gBAAgB,OAAO,WAAW,KAAK,UAAU,YAAY,CAAC,GAAG,MAAM;GAC7E,IAAI,iBAAiB,KAAK,oBACxB;GAEF,wBAAwB,KAAK,IAAI,uBAAuB,aAAa;GACrE,IAAI,UAAU,WAAW,GACvB,MAAM,IAAI,wBACR,aACA,eACA,KAAK,oBACL,6BAA6B,KAAK,UAAU,EAAE,EAAE,UAAU,KAAK,mBAAmB,qBACpF;GAEF,MAAM,IAAI;GACV,QAAQ,IAAI,EAAE;GACd,2BAA2B,QAAQ;EACrC;EACA,IAAI,UAAU,OAAO,KAAK,MAAM,WAAW,GACzC,MAAM,IAAI,wBACR,aACA,uBACA,KAAK,oBACL,kDAAkD,KAAK,mBAAmB,qBAC5E;EAEF,OAAO,YAAY;CACrB;CAEA,MAAM,YACJ,MACA,SAC4B;EAC5B,MAAM,cAAc,gBAClB,KAAK,eAAe,IACpB,2BACA,GACA,sBAAsB,aACxB;EAEA,MAAM,SAAQ,MADI,KAAK,MAAM,OAAO,EAAA,CAClB,QAAQ,IAAI,KAAK,QAAQ;EAC3C,IAAI,CAAC,OAAO,MAAM,IAAI,mBAAmB,KAAK,QAAQ;EACtD,MAAM,KAAK,mBAAmB,KAAK,aAAa;EAEhD,MAAM,MAAM,MAAM,KAAK,OAAO,OAAO;EACrC,MAAM,OAA0B,CAAC;EACjC,IAAI,UAAU;EACd,IAAI,YAAY;EAChB,KAAK,MAAM,KAAK,MAAM,OAAO;GAC3B,MAAM,eAAe,SAAS,QAAQ,WAAW;GACjD,MAAM,YAAY,cAAc,KAAK;GACrC,MAAM,YAAY,MAAM,KAAK,mBAC3B,KACA,MAAM,UACN,GACA,IACA,KAAK,oBACL,WACA,OACF;GACA,KAAK,MAAM,KAAK,UAAU,SAAS;IACjC,IAAI,KAAK,UAAU,aAAa;IAChC,KAAK,KAAK,CAAC;GACb;GACA,IAAI,UAAU,SAAS;IACrB,UAAU;IACV;GACF;EACF;EACA,OAAO;GACL,UAAU,MAAM;GAChB;GACA,UAAU;EACZ;CACF;CAEA,MAAM,WACJ,MACA,SAC2B;EAC3B,MAAM,cAAc,gBAClB,KAAK,eAAe,IACpB,0BACA,GACA,sBAAsB,aACxB;EAEA,MAAM,SAAQ,MADI,KAAK,MAAM,OAAO,EAAA,CAClB,QAAQ,IAAI,KAAK,QAAQ;EAC3C,IAAI,CAAC,OAAO,MAAM,IAAI,mBAAmB,KAAK,QAAQ;EACtD,IAAI;EACJ,KAAK,IAAI,QAAQ,GAAG,QAAQ,MAAM,MAAM,QAAQ,SAAS,GAAG;GAC1D,MAAM,eAAe,SAAS,QAAQ,KAAK;GAC3C,MAAM,YAAY,MAAM,MAAM;GAC9B,IAAI,UAAU,YAAY,KAAK,SAAS;IACtC,OAAO;IACP;GACF;EACF;EACA,IAAI,CAAC,MACH,MAAM,IAAI,kBAAkB,KAAK,UAAU,KAAK,OAAO;EAEzD,MAAM,KAAK,mBAAmB,KAAK,aAAa;EAChD,MAAM,MAAM,MAAM,KAAK,OAAO,OAAO;EACrC,MAAM,YAAY,MAAM,KAAK,mBAC3B,KACA,MAAM,UACN,MACA,IACA,KAAK,oBACL,aACA,OACF;EACA,OAAO;GACL,UAAU,MAAM;GAChB,SAAS,KAAK;GACd,MAAM,UAAU;GAChB,UAAU,UAAU;EACtB;CACF;;;CAMA,MAAM,cAAc,SAAoD;EACtE,MAAM,KAAK,MAAM,OAAO;CAC1B;CAEA,MAAc,OAAO,SAAsD;EACzE,SAAS,QAAQ,eAAe;EAChC,IAAI,KAAK,aAAa,OAAO,KAAK;EAClC,IAAI,CAAC,KAAK,YAAY;GACpB,MAAM,OAAO,2BAA2B,WAAW,KAAK,WAAW,MAAM,CAAC;GAC1E,KAAK,aAAa;GAClB,KAAU,QAAQ,MACf,UAAU;IACT,KAAK,cAAc;IACnB,IAAI,KAAK,eAAe,MAAM,KAAK,aAAa,KAAA;GAClD,SACM;IACJ,IAAI,KAAK,eAAe,MAAM,KAAK,aAAa,KAAA;GAClD,CACF;EACF;EACA,OAAO,kBAAkB,KAAK,YAAY,SAAS,MAAM;CAC3D;CAMA,cAAwB,KAAuD;EAC7E,OAAO,oBAAoB,GAAG;CAChC;CAEA,MAAc,MAAM,SAA4D;EAC9E,SAAS,QAAQ,eAAe;EAChC,IAAI,KAAK,YAAY,OAAO,KAAK;EACjC,IAAI,CAAC,KAAK,WAAW;GACnB,MAAM,OAAO,2BAA2B,WAAW,KAAK,WAAW,MAAM,CAAC;GAC1E,KAAK,YAAY;GACjB,KAAU,QAAQ,MACf,UAAU;IACT,KAAK,aAAa;IAClB,IAAI,KAAK,cAAc,MAAM,KAAK,YAAY,KAAA;GAChD,SACM;IACJ,IAAI,KAAK,cAAc,MAAM,KAAK,YAAY,KAAA;GAChD,CACF;EACF;EACA,OAAO,kBAAkB,KAAK,WAAW,SAAS,MAAM;CAC1D;CAEA,MAAc,WAAW,QAA6C;EAEpE,MAAM,MAAM,MAAM,KAAK,OAAO,EAAE,OAAO,CAAC;EACxC,QAAQ,eAAe;EAEvB,MAAM,0BAAU,IAAI,IAA6B;EACjD,IAAI,SAAS;EACb,IAAI,aAAa;EACjB,IAAI,aAAa;EACjB,OAAO,SAAS,IAAI,QAAQ;GAC1B,cAAc;GAGd,IAAI,EAAE,cAAc,mBAAmB;IACrC,aAAa;IACb,MAAM,iBAAiB;IACvB,QAAQ,eAAe;GACzB;GACA,MAAM,eAAe,IAAI,QAAQ,IAAM,MAAM;GAC7C,MAAM,UAAU,iBAAiB,KAAK,IAAI,SAAS;GACnD,MAAM,aAAa,UAAU;GAC7B,IAAI,eAAe,GAAG;IACpB,SAAS,UAAU;IACnB;GACF;GACA,MAAM,YAAY,IAAI,SAAS,QAAQ,OAAO,CAAC,CAAC,SAAS,MAAM;GAC/D,MAAM,aAAa;GACnB,SAAS,UAAU;GAEnB,IAAI;GACJ,IAAI;IACF,SAAS,KAAK,MAAM,SAAS;GAC/B,SAAS,OAAO;IACd,MAAM,IAAI,wBAAwB,KAAK,WAAW,GAAG,YAAY,YAAY,KAAK;GACpF;GACA,IAAI,CAAC,UAAU,OAAO,WAAW,UAC/B,MAAM,IAAI,wBAAwB,KAAK,WAAW,GAAG,YAAY,UAAU;GAE7E,MAAM,OAAO,KAAK,cAAc,MAAiC;GACjE,IAAI,CAAC,MACH,MAAM,IAAI,wBAAwB,KAAK,WAAW,GAAG,YAAY,UAAU;GAG7E,IAAI,QAAQ,QAAQ,IAAI,KAAK,QAAQ;GACrC,IAAI,CAAC,OAAO;IACV,QAAQ;KACN,UAAU,KAAK;KACf,cAAc,KAAK;KACnB,YAAY,KAAK;KACjB,YAAY;KACZ,YAAY;KACZ,YAAY,KAAK;KACjB,UAAU,KAAK;KACf,aAAa;KACb,iBAAiB;KACjB,wBAAQ,IAAI,IAAI;KAChB,wBAAQ,IAAI,IAAI;KAChB,uBAAO,IAAI,IAAI;KACf,OAAO,CAAC;IACV;IACA,QAAQ,IAAI,KAAK,UAAU,KAAK;GAClC,OAAO;IAGL,IAAI,CAAC,MAAM,gBAAgB,KAAK,cAAc,MAAM,eAAe,KAAK;IACxE,IAAI,CAAC,MAAM,cAAc,KAAK,YAAY,MAAM,aAAa,KAAK;GACpE;GAEA,MAAM,aAA6B;IACjC,SAAS,KAAK;IACd,gBAAgB,KAAK;IACrB,MAAM,KAAK;IACX,MAAM,KAAK;IACX,YAAY,KAAK;IACjB,UAAU,KAAK;IACf,aAAa,KAAK;IAClB,QAAQ,KAAK;IACb,gBAAgB,KAAK;IACrB,cAAc,KAAK;IACnB,YAAY,KAAK;IACjB,YAAY,KAAK;IACjB,WAAW,KAAK;IAChB,kBAAkB;IAClB,kBAAkB;GACpB;GACA,MAAM,MAAM,KAAK,UAAU;GAC3B,MAAM,cAAc;GACpB,MAAM,mBAAmB,aAAa;GACtC,IAAI,KAAK,WAAW,SAAS,MAAM,aAAa;GAChD,IAAI,gBAAgB,KAAK,YAAY,MAAM,UAAU,IAAI,GAAG,MAAM,aAAa,KAAK;GACpF,IAAI,gBAAgB,KAAK,UAAU,MAAM,QAAQ,IAAI,GAAG,MAAM,WAAW,KAAK;GAC9E,IAAI,KAAK,YAAY,MAAM,OAAO,IAAI,KAAK,UAAU;GACrD,IAAI,KAAK,YAAY,MAAM,OAAO,IAAI,KAAK,UAAU;GACrD,IAAI,KAAK,WAAW,MAAM,MAAM,IAAI,KAAK,SAAS;EACpD;EAIA,IAAI,gBAAgB;EACpB,KAAK,MAAM,KAAK,QAAQ,OAAO,GAAG;GAChC,QAAQ,eAAe;GACvB,iBAAiB,EAAE;GACnB,EAAE,MAAM,MACL,GAAG,MACF,gBAAgB,EAAE,YAAY,EAAE,UAAU,KAAK,EAAE,mBAAmB,EAAE,gBAC1E;GAGA,MAAM,UAAU,gBAAgB,EAAE,UAAU;GAC5C,MAAM,QAAQ,gBAAgB,EAAE,QAAQ;GACxC,EAAE,cAAc,YAAY,QAAQ,UAAU,OAAO,IAAI,KAAK,IAAI,GAAG,QAAQ,OAAO;EACtF;EACA,MAAM,iBAAiB,CAAC,GAAG,QAAQ,KAAK,CAAC,CAAC,CAAC,KAAK;EAChD,QAAQ,eAAe;EAEvB,OAAO;GAAE;GAAS;GAAe;EAAe;CAClD;CAIA,MAAc,cACZ,KACA,SACA,SAC4B;EAC5B,SAAS,QAAQ,eAAe;EAChC,MAAM,SAA4B,CAAC;EACnC,KAAK,IAAI,QAAQ,GAAG,QAAQ,IAAI,eAAe,QAAQ,SAAS,GAAG;GACjE,MAAM,eAAe,SAAS,QAAQ,KAAK;GAC3C,MAAM,QAAQ,IAAI,QAAQ,IAAI,IAAI,eAAe,MAAO;GACxD,IAAI,OAAO,OAAO,KAAK,KAAK;EAC9B;EACA,IAAI,CAAC,SAAS,OAAO;EAErB,MAAM,kBAAqC,CAAC;EAC5C,KAAK,IAAI,QAAQ,GAAG,QAAQ,OAAO,QAAQ,SAAS,GAAG;GACrD,MAAM,eAAe,SAAS,QAAQ,KAAK;GAC3C,MAAM,IAAI,OAAO;GACjB,IAAI,QAAQ,eAAe,KAAA,KAAa,EAAE,eAAe,QAAQ,YAAY;GAC7E,IAAI,QAAQ,iBAAiB,QAAQ,cAAc,SAAS,GACtD;QAAA,CAAC,EAAE,gBAAgB,CAAC,QAAQ,cAAc,SAAS,EAAE,YAAY,GAAG;GAAA;GAE1E,IAAI,QAAQ,eAAe,QAAQ,YAAY,SAAS,GAClD;QAAA,CAAC,CAAC,GAAG,EAAE,MAAM,CAAC,CAAC,MAAM,UAAU,QAAQ,YAAa,SAAS,KAAK,CAAC,GAAG;GAAA;GAE5E,IAAI,QAAQ,eAAe,QAAQ,YAAY,SAAS,GAClD;QAAA,CAAC,CAAC,GAAG,EAAE,MAAM,CAAC,CAAC,MAAM,MAAM,QAAQ,YAAa,SAAS,CAAC,CAAC,GAAG;GAAA;GAEpE,IAAI,QAAQ,cAAc,QAAQ,WAAW,SAAS,GAChD;QAAA,CAAC,CAAC,GAAG,EAAE,KAAK,CAAC,CAAC,MAAM,OAAO,QAAQ,WAAY,SAAS,EAAE,CAAC,GAAG;GAAA;GAEpE,IAAI,QAAQ,oBAAoB,EAAE,aAAa,QAAQ,kBAAkB;GACzE,IAAI,QAAQ,qBAAqB,EAAE,aAAa,QAAQ,mBAAmB;GAC3E,gBAAgB,KAAK,CAAC;EACxB;EAEA,IAAI,CAAC,QAAQ,eAAe,OAAO;EAGnC,MAAM,KAAK,mBAAmB,QAAQ,aAAa;EACnD,MAAM,MAAM,MAAM,KAAK,OAAO,OAAO;EACrC,MAAM,MAAyB,CAAC;EAChC,IAAI,aAAa;EACjB,KAAK,MAAM,KAAK,iBAAiB;GAC/B,MAAM,eAAe,SAAS,QAAQ,YAAY;GAClD,IAAI,UAAU;GACd,IAAI,YAAY;GAChB,KAAK,MAAM,KAAK,EAAE,OAAO;IACvB,MAAM,eAAe,SAAS,QAAQ,WAAW;IACjD,MAAM,QAAQ,IAAI,SAAS,EAAE,kBAAkB,EAAE,mBAAmB,EAAE,gBAAgB;IAItF,IAAI,GAAG,KAAK,MAAM,SAAS,MAAM,CAAC,GAAG;KACnC,UAAU;KACV;IACF;GACF;GACA,IAAI,SAAS,IAAI,KAAK,CAAC;EACzB;EACA,OAAO;CACT;CAEA,UAAkB,GAA8C;EAC9D,OAAO;GACL,UAAU,EAAE;GACZ,cAAc,EAAE;GAChB,YAAY,EAAE;GACd,YAAY,EAAE;GACd,YAAY,EAAE;GACd,YAAY,EAAE;GACd,UAAU,EAAE;GACZ,aAAa,EAAE;GACf,iBAAiB,EAAE;GACnB,QAAQ,CAAC,GAAG,EAAE,MAAM,CAAC,CAAC,KAAK;GAC3B,OAAO,CAAC,GAAG,EAAE,KAAK,CAAC,CAAC,KAAK;EAC3B;CACF;CAIA,YACE,KACA,UACA,GACA,YACA,SACkB;EAClB,MAAM,QAAQ,IACX,SAAS,EAAE,kBAAkB,EAAE,mBAAmB,EAAE,gBAAgB,CAAC,CACrE,SAAS,MAAM;EAClB,IAAI,MAA+B,CAAC;EACpC,IAAI;GACF,MAAM,SAAS,KAAK,MAAM,KAAK;GAC/B,IAAI,UAAU,OAAO,WAAW,UAAU,MAAM;EAClD,QAAQ,CAER;EACA,MAAM,QAAQ,sBAAsB,GAAG;EACvC,MAAM,YAAqC,CAAC;EAC5C,KAAK,MAAM,CAAC,GAAG,MAAM,OAAO,QAAQ,KAAK,GACvC,IAAI,OAAO,MAAM,UAAU;GACzB,MAAM,QAAQ,kBAAkB,GAAG,UAAU;GAC7C,IAAI,UAAU,GAAG,QAAQ,SAAS;GAClC,UAAU,KAAK;EACjB,OAAO,IAAI,MAAM,QAAQ,CAAC,KAAM,KAAK,OAAO,MAAM,UAAW;GAC3D,MAAM,OAAO,KAAK,UAAU,CAAC;GAC7B,MAAM,QAAQ,kBAAkB,MAAM,UAAU;GAChD,IAAI,UAAU,MAAM;IAClB,QAAQ,SAAS;IACjB,UAAU,KAAK;GACjB,OACE,UAAU,KAAK;EAEnB,OACE,UAAU,KAAK;EAGnB,OAAO;GACL;GACA,SAAS,EAAE;GACX,gBAAgB,EAAE;GAClB,MAAM,EAAE;GACR,MAAM,EAAE;GACR,YAAY,EAAE;GACd,UAAU,EAAE;GACZ,aAAa,EAAE;GACf,QAAQ,EAAE;GACV,gBAAgB,EAAE;GAClB,cAAc,EAAE;GAChB,YAAY,EAAE;GACd,YAAY,EAAE;GACd,WAAW,EAAE;GACb,YAAY;EACd;CACF;CAEA,sBACE,GACA,yBACoB;EACpB,MAAM,yBAAS,IAAI,IAAoB;EACvC,IAAI,aAAa;EACjB,KAAK,MAAM,KAAK,EAAE,OAAO;GACvB,OAAO,IAAI,EAAE,OAAO,OAAO,IAAI,EAAE,IAAI,KAAK,KAAK,CAAC;GAChD,IAAI,EAAE,WAAW,SAAS,cAAc;EAC1C;EACA,MAAM,MAAM,CAAC,GAAG,OAAO,QAAQ,CAAC,CAAC,CAAC,MAAM,GAAG,MAAM,EAAE,KAAK,EAAE,EAAE,CAAC,CAAC,MAAM,GAAG,EAAE;EACzE,OAAO;GACL,YAAY,EAAE;GACd,gBAAgB;GAChB;GACA,kBAAkB;EACpB;CACF;CAEA,MAAc,mBACZ,KACA,UACA,GACA,IACA,YACA,WACA,SAC2D;EAK3D,MAAM,QAAQ,IACX,SAAS,EAAE,kBAAkB,EAAE,mBAAmB,EAAE,gBAAgB,CAAC,CACrE,SAAS,MAAM;EAClB,MAAM,UAA6B,CAAC;EACpC,IAAI,UAAU;EACd,IAAI,aAAa;EACjB,KAAK,MAAM,SAAS,GAAG,SAAS,KAAK,GAAG;GACtC,MAAM,eAAe,SAAS,QAAQ,YAAY;GAClD,IAAI,QAAQ,UAAU,WAAW;IAC/B,UAAU;IACV;GACF;GACA,MAAM,SAAS,MAAM,SAAS;GAC9B,MAAM,SAAS,MAAM,MAAM,KAAK,IAAI,GAAG,SAAS,aAAa,CAAC,GAAG,MAAM;GACvE,MAAM,QAAQ,MAAM,MAClB,SAAS,MAAM,EAAE,CAAC,QAClB,SAAS,MAAM,EAAE,CAAC,SAAS,KAAK,MAAM,aAAa,CAAC,CACtD;GACA,QAAQ,KAAK;IACX;IACA,SAAS,EAAE;IACX,WAAW,EAAE;IACb,WAAW,EAAE;IACb,gBAAgB,2BAA2B,OAAO,MAAM,KAAK;IAC7D,cAAc,kBAAkB,MAAM,IAAI,UAAU;IACpD,gBAAgB,kBAAkB,QAAQ,UAAU;IACpD,eAAe,kBAAkB,OAAO,UAAU;IAClD,cAAc;GAChB,CAAC;EACH;EACA,OAAO;GAAE;GAAS;EAAQ;CAC5B;AACF;AAEA,IAAa,qBAAb,cAAwC,mBAAmB;CACzD;CACA;CAEA,YAAY,MAAiC;EAC3C,MAAM,IAAI;EACV,KAAK,OAAO,KAAK;EACjB,KAAK,eAAe,gBAClB,KAAK,gBAAA,WACL,gBACA,CACF;CACF;;;CAIA,MAAgB,WAAW,QAAuC;EAChE,QAAQ,eAAe;EACvB,IAAI;EACJ,IAAI;GACF,QAAQ,MAAM,KAAK,KAAK,IAAI;EAC9B,SAAS,KAAK;GACZ,IAAK,KAA+B,SAAS,UAC3C,MAAM,IAAI,sBAAsB,KAAK,IAAI;GAE3C,MAAM;EACR;EACA,IAAI,MAAM,OAAO,KAAK,cACpB,MAAM,IAAI,uBAAuB,KAAK,MAAM,MAAM,MAAM,KAAK,YAAY;EAE3E,QAAQ,eAAe;EACvB,OAAO,SAAS,KAAK,MAAM,EAAE,OAAO,CAAC;CACvC;CAEA,aAA+B;EAC7B,OAAO,KAAK;CACd;AACF;AAEA,IAAM,mBAAN,cAA+B,mBAAmB;CAE7B;CADnB,YACE,QACA,MACA;EACA,MAAM,IAAI;EAHO,KAAA,SAAA;CAInB;CAEA,MAAgB,WAAW,QAAuC;EAChE,QAAQ,eAAe;EACvB,OAAO,KAAK;CACd;CAEA,aAA+B;EAC7B,OAAO;CACT;AACF;AAEA,IAAM,uBAAN,cAAmC,iBAAiB;CAClD,cAAiC,KAAgD;EAC/E,OAAO,gBAAgB,MAAM,GAAG;CAClC;AACF;;;;;;AAOA,SAAgB,gCACd,SACA,UAAkD,CAAC,GAC/B;CACpB,IAAI,CAAC,WAAW,QAAQ,WAAW,GACjC,MAAM,IAAI,sBAAsB,2DAA2D;CAE7F,MAAM,uBAAO,IAAI,IAAyB;CAC1C,MAAM,QAAQ,QAAQ,KAAK,QAAQ,UAAU;EAC3C,IAAI;GACF,MAAM,OAAO,gBAAgB,MAAM,MAAM;GACzC,MAAM,aAAa,KAAK,IAAI,KAAK,QAAQ,qBAAK,IAAI,IAAY;GAC9D,IAAI,WAAW,IAAI,KAAK,OAAO,GAC7B,MAAM,IAAI,sBACR,oDAAoD,KAAK,QAAQ,cAAc,KAAK,SAAS,EAC/F;GAEF,WAAW,IAAI,KAAK,OAAO;GAC3B,KAAK,IAAI,KAAK,UAAU,UAAU;GAClC,OAAO,KAAK,UAAU,IAAI;EAC5B,SAAS,OAAO;GACd,IAAI,iBAAiB,uBAAuB,MAAM;GAClD,MAAM,IAAI,sBACR,iEAAiE,SACjE,EAAE,MAAM,CACV;EACF;CACF,CAAC;CACD,OAAO,IAAI,qBAAqB,OAAO,KAAK,GAAG,MAAM,KAAK,IAAI,EAAE,KAAK,MAAM,GAAG,OAAO;AACvF;;AAGA,SAAgB,6BACd,MACA,OAA6C,CAAC,GAC1B;CACpB,IAAI,CAAC,KAAK,KAAK,GAAG,MAAM,IAAI,sBAAsB,mCAAmC;CACrF,OAAO,IAAI,iBAAiB,OAAO,KAAK,MAAM,MAAM,GAAG,IAAI;AAC7D;AAEA,SAAgB,2BACd,QACA,UAAgD,CAAC,GAC7B;CACpB,OAAO,IAAI,iBAAiB,QAAQ,OAAO;AAC7C;;;;AA0BA,SAAS,iBAAiB,OAAe,KAAsB;CAC7D,IAAI,MAAM,SAAS,MAAK,OAAO;CAC/B,IAAI,cAAc;CAClB,IAAI,IAAI,MAAM;CACd,OAAO,KAAK,KAAK,MAAM,OAAO,MAAM;EAClC,eAAe;EACf,KAAK;CACP;CACA,OAAO,cAAc,MAAM;AAC7B;;;AAIA,SAAS,mBAAmB,OAAe,MAAsB;CAC/D,KAAK,IAAI,IAAI,MAAM,KAAK,GAAG,KAAK,GAC9B,IAAI,MAAM,OAAO,QAAO,iBAAiB,OAAO,CAAC,GAAG,OAAO;CAE7D,OAAO;AACT;;;;;;;;;AAUA,SAAS,2BAA2B,OAAe,QAA+B;CAEhF,MAAM,aAAa,mBAAmB,OAAO,KAAK,IAAI,QAAQ,MAAM,SAAS,CAAC,CAAC;CAC/E,IAAI,aAAa,GAAG,OAAO;CAE3B,IAAI,IAAI,aAAa;CACrB,OAAO,KAAK,KAAK,MAAM,OAAO,KAAK,KAAK;CACxC,IAAI,IAAI,GAAG,OAAO;CAElB,MAAM,WAAW,mBAAmB,OAAO,IAAI,CAAC;CAChD,IAAI,WAAW,GAAG,OAAO;CACzB,MAAM,UAAU,mBAAmB,OAAO,WAAW,CAAC;CACtD,IAAI,UAAU,GAAG,OAAO;CACxB,OAAO,MAAM,MAAM,UAAU,GAAG,QAAQ;AAC1C;AASA,MAAM,0BAA0B;;;;;AAgBhC,SAAS,wBAAwB,SAA6B,UAA0B;CACtF,MAAM,OAAO,WAAW,GAAA,CAAI,KAAK;CASjC,QARa,IAAI,SAAS,IAAI,MAAM,IAAI,YAAY,QAAQ,gBAAA,CAEzD,QAAQ,kEAAkE,MAAM,CAAC,CACjF,QAAQ,uBAAuB,MAAM,CAAC,CACtC,QAAQ,wBAAwB,QAAQ,CAAC,CACzC,QAAQ,4CAA4C,IAAI,MAAO,IAAI,IAAI,MAAM,GAAI,CAAC,CAClF,QAAQ,QAAQ,GAAG,CAAC,CACpB,KACO;AACZ;AAEA,SAAS,KAAK,KAA0B,KAA0B;CAChE,IAAI,CAAC,KAAK;CACV,IAAI,IAAI,MAAM,IAAI,IAAI,GAAG,KAAK,KAAK,CAAC;AACtC;AAEA,SAAS,OAAO,KAAyC;CACvD,IAAI,OAAsB;CAC1B,IAAI,QAAQ;CACZ,KAAK,MAAM,CAAC,GAAG,MAAM,KACnB,IAAI,IAAI,OAAO;EACb,OAAO;EACP,QAAQ;CACV;CACF,OAAO;AACT;AAEA,SAAS,uBACP,UACA,SACA,MACM;CACN,MAAM,YAAY,wBAAwB,KAAK,gBAAgB,KAAK,IAAI;CACxE,IAAI,MAAM,SAAS,IAAI,SAAS;CAChC,IAAI,CAAC,KAAK;EACR,MAAM;GACJ;GACA,QAAQ,KAAK,kBAAkB,KAAK,QAAQ;GAC5C,0BAAU,IAAI,IAAI;GAClB,SAAS,CAAC;GACV,WAAW;GACX,2BAAW,IAAI,IAAI;GACnB,2BAAW,IAAI,IAAI;EACrB;EACA,SAAS,IAAI,WAAW,GAAG;CAC7B;CACA,IAAI,SAAS,IAAI,OAAO;CACxB,IAAI,aAAa;CACjB,IAAI,IAAI,QAAQ,SAAS,2BAA2B,CAAC,IAAI,QAAQ,SAAS,KAAK,OAAO,GACpF,IAAI,QAAQ,KAAK,KAAK,OAAO;CAE/B,KAAK,IAAI,WAAW,KAAK,IAAI;CAC7B,KAAK,IAAI,WAAW,KAAK,SAAS;AACpC;AAEA,SAAS,sBACP,UACA,iBACgB;CAChB,MAAM,MAAM,CAAC,GAAG,SAAS,OAAO,CAAC,CAAC,CAAC,KAChC,SAAuB;EACtB,WAAW,IAAI;EACf,uBAAuB,IAAI;EAC3B,WAAW,OAAO,IAAI,SAAS;EAC/B,WAAW,OAAO,IAAI,SAAS;EAC/B,aAAa,IAAI,SAAS;EAC1B,YAAY,IAAI;EAChB,YAAY,kBAAkB,IAAI,IAAI,SAAS,OAAO,kBAAkB;EACxE,oBAAoB,CAAC,GAAG,IAAI,QAAQ,CAAC,CAAC,MAAM,GAAG,uBAAuB;EACtE,mBAAmB,IAAI,QAAQ,MAAM,GAAG,uBAAuB;CACjE,EACF;CACA,IAAI,MAAM,GAAG,MAAM,EAAE,cAAc,EAAE,eAAe,EAAE,aAAa,EAAE,UAAU;CAC/E,OAAO;AACT"}

package/dist/store-tool-spans-DR1SrCLK.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"store-tool-spans-DR1SrCLK.d.ts","names":[],"sources":["../src/trace/extract-usage.ts","../src/trace/capture-fetch.ts","../src/trace/otel.ts","../src/trace/otlp-flat.ts","../src/trace-analyst/analyst.ts","../src/trace-analyst/insights.ts","../src/trace-analyst/store-otlp.ts","../src/trace-analyst/store-tool-spans.ts"],"mappings":"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"}

package/dist/store-tool-spans-fZIigrpP.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"store-tool-spans-fZIigrpP.js","names":[],"sources":["../src/trace/capture-fetch.ts","../src/trace/otlp-encoding.ts","../src/trace/wire-ids.ts","../src/trace/otel.ts","../src/trace-analyst/prompts.ts","../src/trace-analyst/analyst.ts","../src/trace-analyst/insights.ts","../src/trace/otlp-flat.ts","../src/trace-analyst/store-tool-spans.ts"],"sourcesContent":["/**\n * Wrap a provider `fetch` and record request, response, and error events.\n *\n * The returned value is a plain `typeof fetch`. Capture is best-effort by\n * default; set `failClosed` when telemetry loss must stop the provider call.\n */\n\nimport {\n  type ExtractedUsage,\n  extractUsage,\n  extractUsageFromSse,\n  type SseUsageMode,\n} from './extract-usage'\nimport {\n  defaultProviderRedactor,\n  type ProviderRedactor,\n  providerFromBaseUrl,\n  type RawProviderDirection,\n  type RawProviderEvent,\n  type RawProviderSink,\n} from './raw-provider-sink'\n\nexport interface CaptureFetchContext {\n  /** Logical run id stamped on every captured event. Required — without it\n   *  the raw events can't be paired with their parent `Run`. */\n  runId: string\n  /** Optional logical span id (enables span-level sink filtering). */\n  spanId?: string\n  /** Resolved base URL (normalised, no trailing slash). Used for the event's\n   *  `baseUrl` and for endpoint-path extraction. */\n  baseUrl: string\n  /** Model id the caller intends to invoke. Stamped on every event. */\n  model: string\n  /** Provider override. When omitted, `providerFromBaseUrl(baseUrl)`. */\n  provider?: string\n}\n\nexport interface CaptureFetchOptions {\n  /** Override the capture-time redactor. Default `defaultProviderRedactor`. */\n  redactor?: ProviderRedactor\n  /** Cap on captured response-body bytes; beyond it the body is truncated and\n   *  `body_truncated` is added to `redactedFields`. Default 2 MiB. */\n  responseBodyByteCap?: number\n  /** When true, a sink-write failure propagates to the caller. Default false\n   *  — capture is best-effort so a sink failure never kills the LLM call. */\n  failClosed?: boolean\n  /**\n   * Invoked with the token usage parsed off each successful response (JSON or\n   * SSE), keyed by the captured context. Lets a caller fold usage → cost without\n   * re-cloning the response themselves. Not called when the response carries no\n   * usage. Best-effort: a throw here is swallowed (it never kills the LLM call)\n   * unless `failClosed` is set.\n   */\n  onUsage?: (usage: ExtractedUsage, ctx: CaptureFetchContext) => void\n  /** How repeated SSE usage events should be reconciled. Default `cumulative`. */\n  sseUsageMode?: SseUsageMode\n}\n\nconst DEFAULT_BODY_CAP = 2 * 1024 * 1024\n\nfunction headersToRecord(headers: Headers | undefined): Record<string, string> | undefined {\n  if (!headers) return undefined\n  const out: Record<string, string> = {}\n  headers.forEach((value, key) => {\n    out[key.toLowerCase()] = value\n  })\n  return Object.keys(out).length > 0 ? out : undefined\n}\n\nfunction parseMaybeJson(text: string): unknown {\n  if (text.length === 0) return undefined\n  try {\n    return JSON.parse(text)\n  } catch {\n    return text\n  }\n}\n\n/** Best-effort request-body read across the `fetch` input forms. */\nasync function readRequestBody(\n  input: RequestInfo | URL,\n  init: RequestInit | undefined,\n): Promise<unknown> {\n  if (typeof init?.body === 'string') return parseMaybeJson(init.body)\n  if (init?.body != null) return undefined // streams / FormData / Blob — not captured\n  if (input instanceof Request) {\n    try {\n      return parseMaybeJson(await input.clone().text())\n    } catch {\n      return undefined\n    }\n  }\n  return undefined\n}\n\nfunction endpointFromUrl(url: string, baseUrl: string): string {\n  const normalisedBase = baseUrl.replace(/\\/+$/, '')\n  if (url.startsWith(normalisedBase)) return url.slice(normalisedBase.length) || '/'\n  try {\n    return new URL(url).pathname\n  } catch {\n    return url\n  }\n}\n\nexport function captureFetchToRawSink(\n  fetch: typeof globalThis.fetch,\n  sink: RawProviderSink,\n  ctx: CaptureFetchContext,\n  opts: CaptureFetchOptions = {},\n): typeof globalThis.fetch {\n  const provider = ctx.provider ?? providerFromBaseUrl(ctx.baseUrl)\n  const redactor = opts.redactor ?? defaultProviderRedactor\n  const bodyCap = opts.responseBodyByteCap ?? DEFAULT_BODY_CAP\n  let warned = false\n\n  const baseEvent = (direction: RawProviderDirection, endpoint: string): RawProviderEvent => ({\n    eventId: crypto.randomUUID(),\n    runId: ctx.runId,\n    spanId: ctx.spanId,\n    provider,\n    model: ctx.model,\n    endpoint,\n    baseUrl: ctx.baseUrl,\n    attemptIndex: 0, // retries are re-invocations one layer up; documented in 0.x\n    direction,\n    timestamp: Date.now(),\n    redactedFields: [],\n  })\n\n  const record = async (event: RawProviderEvent): Promise<void> => {\n    try {\n      await sink.record(redactor(event))\n    } catch (err) {\n      if (opts.failClosed) throw err\n      if (!warned) {\n        warned = true\n        console.warn(\n          `captureFetchToRawSink: sink.record failed (capture is best-effort) — ${\n            err instanceof Error ? err.message : String(err)\n          }`,\n        )\n      }\n    }\n  }\n\n  return async (input: RequestInfo | URL, init?: RequestInit): Promise<Response> => {\n    const url =\n      typeof input === 'string' ? input : input instanceof URL ? input.toString() : input.url\n    const method = (init?.method ?? (input instanceof Request ? input.method : 'GET')).toUpperCase()\n    const endpoint = endpointFromUrl(url, ctx.baseUrl)\n\n    const reqHeaders = new Headers(\n      init?.headers ?? (input instanceof Request ? input.headers : undefined),\n    )\n    await record({\n      ...baseEvent('request', endpoint),\n      requestHeaders: { ...headersToRecord(reqHeaders), 'x-http-method': method },\n      requestBody: await readRequestBody(input, init),\n    })\n\n    const start = Date.now()\n    let response: Response\n    try {\n      response = await fetch(input, init)\n    } catch (err) {\n      await record({\n        ...baseEvent('error', endpoint),\n        durationMs: Date.now() - start,\n        errorMessage: err instanceof Error ? err.message : String(err),\n      })\n      throw err\n    }\n\n    // Read the body off a clone so the caller still consumes the original.\n    let responseBody: unknown\n    let rawText: string | undefined\n    const redactedFields: string[] = []\n    try {\n      rawText = await response.clone().text()\n      if (rawText.length > bodyCap) {\n        responseBody = rawText.slice(0, bodyCap)\n        redactedFields.push('body_truncated')\n      } else {\n        responseBody = parseMaybeJson(rawText)\n      }\n    } catch {\n      responseBody = undefined\n    }\n\n    if (opts.onUsage && rawText !== undefined) {\n      // Reuse the body already read for capture; no extra clone. JSON first,\n      // then SSE accumulation. A throw in the consumer's callback is swallowed\n      // (best-effort) unless failClosed is set — the LLM call must not die here.\n      try {\n        const parsedForUsage = parseMaybeJson(rawText)\n        const usage =\n          extractUsage(parsedForUsage) ??\n          (typeof parsedForUsage === 'string'\n            ? extractUsageFromSse(rawText, { mode: opts.sseUsageMode })\n            : null)\n        if (usage) opts.onUsage(usage, ctx)\n      } catch (err) {\n        if (opts.failClosed) throw err\n      }\n    }\n\n    await record({\n      ...baseEvent('response', endpoint),\n      durationMs: Date.now() - start,\n      statusCode: response.status,\n      responseHeaders: headersToRecord(response.headers),\n      responseBody,\n      redactedFields,\n    })\n\n    return response\n  }\n}\n","/**\n * The ONE encoding from this package's span values to OTLP wire values.\n *\n * Both exporters emit the same `OtlpSpan` shape, so an attribute typed as a\n * double by one and a string by the other would make the same run read\n * differently depending on which exporter produced it.\n */\n\n/** One OTLP `KeyValue`: the value is tagged with the protocol's type slot. */\nexport interface OtlpAttribute {\n  key: string\n  value: { stringValue?: string; intValue?: string; doubleValue?: number; boolValue?: boolean }\n}\n\n/** OTLP `KeyValue[]` for a flat attribute record. */\nexport function toOtlpAttributes(\n  record: Record<string, string | number | boolean>,\n): OtlpAttribute[] {\n  return Object.entries(record).map(([key, value]) => ({\n    key,\n    value:\n      typeof value === 'number'\n        ? Number.isInteger(value)\n          ? { intValue: value.toString() }\n          : { doubleValue: value }\n        : typeof value === 'boolean'\n          ? { boolValue: value }\n          : { stringValue: value },\n  }))\n}\n\n/** OTLP nanosecond timestamp, as the decimal string the protocol requires. */\nexport function msToUnixNano(ms: number): string {\n  return (BigInt(Math.floor(ms)) * 1_000_000n).toString()\n}\n","/**\n * The ONE mapping from agent-eval's human-readable ids (run ids, span labels)\n * to W3C/OTLP wire ids. Every exporter in this package MUST route through\n * these two functions — two exporters with private paddings once produced\n * DIFFERENT trace ids for the same run, and one emitted invalid hex embedding\n * the raw run id in the wire id (tangle-network/agent-runtime#694).\n *\n * Semantics:\n *  - an id that is ALREADY a valid W3C id passes through unchanged, so a\n *    trace id received from an inbound `traceparent` survives the round-trip\n *    and cross-process correlation is preserved;\n *  - anything else is derived with the contract's `deriveHexId`, the only\n *    legal derivation — deterministic, so every process that derives from the\n *    same human id mints the SAME wire id.\n */\n\nimport { deriveHexId, isW3CSpanId, isW3CTraceId } from '@tangle-network/agent-trace-contract'\n\n/** 32-hex W3C trace id for any id string. */\nexport function traceIdForWire(id: string): string {\n  return isW3CTraceId(id) ? id : deriveHexId(id, 16)\n}\n\n/** 16-hex W3C span id for any id string. */\nexport function spanIdForWire(id: string): string {\n  return isW3CSpanId(id) ? id : deriveHexId(id, 8)\n}\n","/**\n * OpenTelemetry JSON export — maps TraceSchema v1 to OTLP/JSON so\n * traces render natively in Jaeger / Honeycomb / Langfuse / Grafana.\n *\n * Wire format only. We do NOT depend on the @opentelemetry SDK — that\n * would drag in polyfills incompatible with Workers/Edge. Consumers\n * push the JSON to their collector of choice via HTTP.\n *\n * Reference: OTLP 1.3.2 (ResourceSpans / ScopeSpans / Span).\n */\n\nimport {\n  applyLlmSpanOtlpAttributes,\n  applyToolSpanOtlpAttributes,\n  OPENINFERENCE_SPAN_KIND,\n  traceSpanKindToOpenInferenceKind,\n} from './otlp-attributes'\nimport { msToUnixNano, toOtlpAttributes } from './otlp-encoding'\nimport type { Run, Span, TraceEvent } from './schema'\nimport type { TraceStore } from './store'\nimport { spanIdForWire, traceIdForWire } from './wire-ids'\n\nexport const OTEL_AGENT_EVAL_SCOPE = { name: '@tangle-network/agent-eval', version: '0.3.0' }\n\nexport interface OtlpSpan {\n  traceId: string\n  spanId: string\n  parentSpanId?: string\n  name: string\n  kind: number\n  startTimeUnixNano: string\n  endTimeUnixNano: string\n  attributes: Array<{\n    key: string\n    value: { stringValue?: string; intValue?: string; doubleValue?: number; boolValue?: boolean }\n  }>\n  events?: Array<{ timeUnixNano: string; name: string; attributes?: OtlpSpan['attributes'] }>\n  status?: { code: number; message?: string }\n}\n\nexport interface OtlpResourceSpans {\n  resource: { attributes: OtlpSpan['attributes'] }\n  scopeSpans: Array<{ scope: typeof OTEL_AGENT_EVAL_SCOPE; spans: OtlpSpan[] }>\n}\n\nexport interface OtlpExport {\n  resourceSpans: OtlpResourceSpans[]\n}\n\n/** Export a single run's spans + events in OTLP/JSON. */\nexport async function exportRunAsOtlp(\n  store: TraceStore,\n  runId: string,\n  resourceAttrs: Record<string, string | number | boolean> = {},\n): Promise<OtlpExport> {\n  const run = await store.getRun(runId)\n  if (!run) throw new Error(`run ${runId} not found`)\n  const spans = await store.spans({ runId })\n  const events = await store.events({ runId })\n  const eventsBySpan = new Map<string, TraceEvent[]>()\n  for (const e of events) {\n    if (!e.spanId) continue\n    const arr = eventsBySpan.get(e.spanId) ?? []\n    arr.push(e)\n    eventsBySpan.set(e.spanId, arr)\n  }\n  const traceId = runToTraceId(run)\n  const otlpSpans: OtlpSpan[] = spans.map((s) =>\n    spanToOtlp(s, traceId, eventsBySpan.get(s.spanId) ?? []),\n  )\n  return {\n    resourceSpans: [\n      {\n        resource: {\n          attributes: toOtlpAttributes({\n            'service.name': 'agent-eval',\n            'run.id': run.runId,\n            'run.scenario_id': run.scenarioId,\n            'run.variant_id': run.variantId ?? '',\n            'run.dataset_version': run.datasetVersion ?? '',\n            'run.code_sha': run.codeSha ?? '',\n            'run.model_fingerprint': run.modelFingerprint ?? '',\n            ...resourceAttrs,\n          }),\n        },\n        scopeSpans: [{ scope: OTEL_AGENT_EVAL_SCOPE, spans: otlpSpans }],\n      },\n    ],\n  }\n}\n\nfunction spanToOtlp(span: Span, traceId: string, events: TraceEvent[]): OtlpSpan {\n  const endedAt = span.endedAt ?? span.startedAt\n  return {\n    traceId,\n    spanId: spanIdForWire(span.spanId),\n    parentSpanId: span.parentSpanId ? spanIdForWire(span.parentSpanId) : undefined,\n    name: span.name,\n    kind: 1, // SPAN_KIND_INTERNAL\n    startTimeUnixNano: msToUnixNano(span.startedAt),\n    endTimeUnixNano: msToUnixNano(endedAt),\n    attributes: toOtlpAttributes(flattenSpanAttributes(span)),\n    events: events.map((e) => ({\n      timeUnixNano: msToUnixNano(e.timestamp),\n      name: e.kind,\n      attributes: toOtlpAttributes(flattenPayload(e.payload)),\n    })),\n    status: span.status === 'error' ? { code: 2, message: span.error } : { code: 1 },\n  }\n}\n\nfunction flattenSpanAttributes(span: Span): Record<string, string | number | boolean> {\n  const base: Record<string, string | number | boolean> = {}\n  if (span.attributes) {\n    for (const [k, v] of Object.entries(span.attributes)) {\n      if (typeof v === 'string' || typeof v === 'number' || typeof v === 'boolean') base[k] = v\n    }\n  }\n  base[OPENINFERENCE_SPAN_KIND] = traceSpanKindToOpenInferenceKind(span.kind)\n  if (span.kind === 'llm') {\n    applyLlmSpanOtlpAttributes(base, span)\n  } else if (span.kind === 'tool') {\n    applyToolSpanOtlpAttributes(base, span)\n  } else if (span.kind === 'retrieval') {\n    base['retrieval.query'] = span.query\n    base['retrieval.hits'] = span.hits.length\n  } else if (span.kind === 'judge') {\n    base['judge.id'] = span.judgeId\n    base['judge.dimension'] = span.dimension\n    base['judge.score'] = span.score\n    base['judge.target_span_id'] = span.targetSpanId\n  } else if (span.kind === 'sandbox') {\n    if (span.image) base['sandbox.image'] = span.image\n    if (span.exitCode !== undefined) base['sandbox.exit_code'] = span.exitCode\n    if (span.testsPassed !== undefined) base['sandbox.tests_passed'] = span.testsPassed\n    if (span.testsTotal !== undefined) base['sandbox.tests_total'] = span.testsTotal\n  }\n  return base\n}\n\nfunction flattenPayload(\n  payload: Record<string, unknown>,\n): Record<string, string | number | boolean> {\n  const out: Record<string, string | number | boolean> = {}\n  for (const [k, v] of Object.entries(payload)) {\n    if (typeof v === 'string' || typeof v === 'number' || typeof v === 'boolean') out[k] = v\n    else out[k] = JSON.stringify(v)\n  }\n  return out\n}\n\nfunction runToTraceId(run: Run): string {\n  return traceIdForWire(run.runId)\n}\n","/** General policy for recursive, evidence-backed trace analysis. */\n\nexport const TRACE_ANALYST_ACTOR_DESCRIPTION = `Answer the question by inspecting the OTLP trace dataset with the available tools.\n\n1. Call getDatasetOverview first. Use its real trace ids and dataset size to plan the investigation.\n2. Narrow with queryTraces and countTraces before scanning large payloads.\n3. For a small trace, use viewTrace. For a large trace, use searchTrace and then viewSpans or searchSpan.\n4. Never invent a trace id, span id, tool result, error, frequency, or final outcome.\n5. When a search reports has_more, refine the query before drawing a conclusion.\n6. Use llm_query only over evidence already loaded. A recursive query cannot inspect traces itself.\n7. Cite exact evidence URIs returned by the tools. Include a short exact excerpt when it supports the claim.\n8. Return no finding when the available evidence cannot support one.\n\nThe prose answer must directly answer the question and state important uncertainty.\nThe findings array contains only actionable or decision-relevant claims supported by inspected evidence.`\n\nexport const TRACE_ANALYST_ACTOR_DESCRIPTION_VERSION = 'trace-analyst-research-v1-2026-07-30'\n","import { randomUUID } from 'node:crypto'\nimport type {\n  TraceAnalysisEngine,\n  TraceAnalysisEngineResult,\n  TraceAnalystLimits,\n} from '../analyst/engine'\nimport { runTraceAnalyst } from '../analyst/kind-factory'\nimport type { TraceToolGroupName } from '../analyst/tool-groups'\nimport type { AnalystFinding, AnalystUsageReceipt } from '../analyst/types'\nimport type { CostLedgerHandle } from '../cost-ledger'\nimport { TRACE_ANALYST_ACTOR_DESCRIPTION, TRACE_ANALYST_ACTOR_DESCRIPTION_VERSION } from './prompts'\nimport type { TraceAnalysisStore } from './store'\nimport { OtlpFileTraceStore } from './store-otlp'\n\nexport interface AnalyzeTracesInput {\n  question: string\n  id?: string\n  description?: string\n  area?: string\n}\n\nexport type AnalyzeTracesResult = TraceAnalysisEngineResult\n\nexport interface AnalyzeTracesOptions {\n  /** OTLP JSONL path or a caller-owned store. */\n  source: string | TraceAnalysisStore\n  /** Recursive research engine. */\n  engine: TraceAnalysisEngine\n  /** Override the general trace-research policy. */\n  instructions?: string\n  /** Smallest tool set that can answer the question. Default: all. */\n  toolGroup?: TraceToolGroupName\n  limits?: Partial<TraceAnalystLimits>\n  runId?: string\n  budgetUsd?: number\n  costLedger?: CostLedgerHandle\n  costPhase?: string\n  priorFindings?: readonly AnalystFinding[]\n  upstreamFindings?: readonly AnalystFinding[]\n  recordUsage?: (receipt: AnalystUsageReceipt) => void\n  tags?: Record<string, string>\n  log?: (message: string, fields?: Record<string, unknown>) => void\n  signal?: AbortSignal\n}\n\n/**\n * Answer one question by recursively inspecting a trace store.\n *\n * The returned answer, cited findings, engine steps, call counts, and runtime\n * identity are one audit record. A direct one-shot model call is not used.\n */\nexport async function analyzeTraces(\n  input: AnalyzeTracesInput,\n  options: AnalyzeTracesOptions,\n): Promise<AnalyzeTracesResult> {\n  if (typeof input.question !== 'string' || !input.question.trim()) {\n    throw new TypeError('analyzeTraces: input.question must be a non-empty string')\n  }\n  const id = input.id?.trim() || 'trace-analysis'\n  const store =\n    typeof options.source === 'string'\n      ? new OtlpFileTraceStore({ path: options.source })\n      : options.source\n  if (store instanceof OtlpFileTraceStore) {\n    await store.ensureIndexed(options.signal ? { signal: options.signal } : undefined)\n  }\n\n  return runTraceAnalyst({\n    definition: {\n      id,\n      description:\n        input.description?.trim() ||\n        'Answers a caller-defined question by recursively inspecting trace evidence.',\n      area: input.area?.trim() || 'trace-analysis',\n      version: TRACE_ANALYST_ACTOR_DESCRIPTION_VERSION,\n      question: input.question,\n      instructions: options.instructions ?? TRACE_ANALYST_ACTOR_DESCRIPTION,\n      toolGroup: options.toolGroup ?? 'all',\n      limits: options.limits,\n    },\n    engine: options.engine,\n    store,\n    context: {\n      runId: options.runId ?? id,\n      correlationId: randomUUID(),\n      budgetUsd: options.budgetUsd,\n      costLedger: options.costLedger,\n      costPhase: options.costPhase ?? 'trace-analysis',\n      priorFindings: options.priorFindings,\n      upstreamFindings: options.upstreamFindings,\n      recordUsage: options.recordUsage,\n      tags: options.tags,\n      log: options.log,\n      signal: options.signal,\n    },\n  })\n}\n","import type { SearchArtifactRef } from '../campaign/search-ledger-types'\nimport { LEDGER_HASH_PATTERN } from '../ledger-core/canonical'\n\nexport interface TraceInsightTask {\n  id: string\n  name: string\n  prompt?: string\n  difficulty?: string\n  tags?: string[]\n  outcome?: string\n  score?: number\n  gaps?: string[]\n}\n\nexport interface TraceInsightSuite {\n  name: string\n  collectionId?: string\n  tasks: TraceInsightTask[]\n}\n\nexport interface TraceInsightFinding {\n  kind: string\n  severity?: string\n  taskIds: string[]\n  evidence?: string\n  proposedFixClass?: string\n  /** Narrative evidence remains a note; customer attribution uses byte-backed evidence only. */\n  attribution?: TraceInsightAttribution\n}\n\n/** A byte-backed observation. Locators are not identities; every link carries a digest. */\nexport interface TraceInsightEvidence {\n  subject: {\n    verticalId: string\n    taskId: string\n    cellId: string | null\n    attemptId: string | null\n    company: string | null\n    tool: string | null\n    toolRevision: string | null\n  }\n  artifacts: Record<\n    'seed' | 'task' | 'cell' | 'request' | 'response' | 'document' | 'controls' | 'binding',\n    SearchArtifactRef | null\n  >\n  spans: Array<{ traceId: string; spanId: string; artifact: SearchArtifactRef }>\n}\n\nexport type TraceInsightAttribution = TraceInsightEvidence &\n  (\n    | { outcome: 'unknown'; evidenceClass: 'unknown'; reasons: string[] }\n    | {\n        outcome: 'tool-failure'\n        evidenceClass: 'validated-request-response'\n        proof: SearchArtifactRef\n        authority: SearchArtifactRef\n      }\n    | {\n        outcome: 'documentation-failure'\n        evidenceClass: 'authoritative-execution'\n        documentation: 'stale' | 'contradictory'\n        proof: SearchArtifactRef\n        authority: SearchArtifactRef\n      }\n    | {\n        outcome: 'documentation-failure'\n        evidenceClass: 'paired-corrected-document'\n        proof: SearchArtifactRef\n        plan: SearchArtifactRef\n        comparisonId: string\n        correctedEvidence: SearchArtifactRef\n      }\n  )\n\nfunction evidenceRecord(value: unknown): value is Record<string, unknown> {\n  return value !== null && typeof value === 'object' && !Array.isArray(value)\n}\n\nfunction evidenceText(value: unknown): value is string {\n  return typeof value === 'string' && value.trim().length > 0\n}\n\n/** Structural validation only. The producer must verify bytes and execute the evidence rule. */\nexport function isTraceInsightArtifact(value: unknown): value is SearchArtifactRef {\n  if (\n    !evidenceRecord(value) ||\n    !evidenceText(value.role) ||\n    !evidenceText(value.uri) ||\n    typeof value.sha256 !== 'string' ||\n    !LEDGER_HASH_PATTERN.test(value.sha256) ||\n    !Number.isSafeInteger(value.byteLength) ||\n    (value.byteLength as number) < 0\n  )\n    return false\n  // Customer reports must not turn a locator into an executable link.\n  try {\n    const url = new URL(value.uri)\n    return ['https:', 'file:'].includes(url.protocol) && !url.username && !url.password\n  } catch {\n    return /^artifacts\\/[a-f0-9]{64}$/.test(value.uri)\n  }\n}\n\nexport function isTraceInsightEvidence(value: unknown): value is TraceInsightEvidence {\n  if (\n    !evidenceRecord(value) ||\n    !evidenceRecord(value.subject) ||\n    !evidenceRecord(value.artifacts) ||\n    !Array.isArray(value.spans)\n  )\n    return false\n  const subject = value.subject\n  if (!evidenceText(subject.verticalId) || !evidenceText(subject.taskId)) return false\n  for (const field of ['cellId', 'attemptId', 'company', 'tool', 'toolRevision']) {\n    if (subject[field] !== null && !evidenceText(subject[field])) return false\n  }\n  for (const role of [\n    'seed',\n    'task',\n    'cell',\n    'request',\n    'response',\n    'document',\n    'controls',\n    'binding',\n  ]) {\n    const artifact = value.artifacts[role]\n    if (artifact !== null && (!isTraceInsightArtifact(artifact) || artifact.role !== role))\n      return false\n  }\n  return value.spans.every(\n    (span) =>\n      evidenceRecord(span) &&\n      typeof span.traceId === 'string' &&\n      /^[a-f0-9]{32}$/.test(span.traceId) &&\n      !/^0+$/.test(span.traceId) &&\n      typeof span.spanId === 'string' &&\n      /^[a-f0-9]{16}$/.test(span.spanId) &&\n      !/^0+$/.test(span.spanId) &&\n      isTraceInsightArtifact(span.artifact) &&\n      span.artifact.role === 'span',\n  )\n}\n\nexport function isTraceInsightAttribution(value: unknown): value is TraceInsightAttribution {\n  if (!isTraceInsightEvidence(value)) return false\n  const attribution = value as TraceInsightEvidence & Record<string, unknown>\n  if (attribution.outcome === 'unknown') {\n    return (\n      attribution.evidenceClass === 'unknown' &&\n      Array.isArray(attribution.reasons) &&\n      attribution.reasons.length > 0 &&\n      attribution.reasons.every(evidenceText)\n    )\n  }\n  if (\n    Object.values(value.subject).some((entry) => entry === null) ||\n    Object.values(value.artifacts).some((artifact) => artifact === null) ||\n    value.spans.length === 0 ||\n    !isTraceInsightArtifact(attribution.proof)\n  )\n    return false\n  if (attribution.outcome === 'tool-failure') {\n    return (\n      attribution.evidenceClass === 'validated-request-response' &&\n      attribution.proof.role === 'execution' &&\n      isTraceInsightArtifact(attribution.authority) &&\n      attribution.authority.role === 'authority'\n    )\n  }\n  if (attribution.outcome !== 'documentation-failure') return false\n  if (attribution.evidenceClass === 'authoritative-execution') {\n    return (\n      (attribution.documentation === 'stale' || attribution.documentation === 'contradictory') &&\n      attribution.proof.role === 'execution' &&\n      isTraceInsightArtifact(attribution.authority) &&\n      attribution.authority.role === 'authority'\n    )\n  }\n  return (\n    attribution.evidenceClass === 'paired-corrected-document' &&\n    attribution.proof.role === 'publication' &&\n    isTraceInsightArtifact(attribution.plan) &&\n    attribution.plan.role === 'plan' &&\n    isTraceInsightArtifact(attribution.correctedEvidence) &&\n    attribution.correctedEvidence.role === 'binding' &&\n    evidenceText(attribution.comparisonId)\n  )\n}\n\nexport interface TraceInsightQuestion {\n  id: string\n  question: string\n  why: string\n}\n\nexport interface TraceInsightPanelRole {\n  id: string\n  name: string\n  responsibility: string\n}\n\nexport interface TraceInsightPromptInput {\n  suite: TraceInsightSuite\n  findings?: TraceInsightFinding[]\n  agent?: Record<string, unknown>\n  totals?: Record<string, unknown>\n  maxRepresentativeTraces?: number\n}\n\nexport interface TraceInsightContext {\n  suite: TraceInsightSuite\n  scope: string\n  keywords: string[]\n  questions: TraceInsightQuestion[]\n  panel: TraceInsightPanelRole[]\n  findings: TraceInsightFinding[]\n  agent: Record<string, unknown> | null\n  totals: Record<string, unknown> | null\n}\n\nexport interface TraceInsightQualityGate {\n  id: string\n  label: string\n  passed: boolean\n  severity: 'critical' | 'high' | 'medium' | 'low'\n  detail: string\n}\n\nexport interface TraceInsightReadiness {\n  score: number\n  grade: 'external-ready' | 'internal-review' | 'raw-analysis'\n  gates: TraceInsightQualityGate[]\n}\n\nconst DOMAIN_STOP_WORDS = new Set([\n  'and',\n  'advanced',\n  'app',\n  'build',\n  'create',\n  'easy',\n  'expert',\n  'extreme',\n  'for',\n  'from',\n  'hard',\n  'implementation',\n  'integrate',\n  'medium',\n  'project',\n  'task',\n  'the',\n  'this',\n  'with',\n  'workflow',\n])\n\nexport function tokenizeDomainWords(value: string): string[] {\n  return [...value.matchAll(/[A-Za-z][A-Za-z0-9.+#-]{2,}/g)]\n    .map((match) => match[0].toLowerCase())\n    .filter((word) => !DOMAIN_STOP_WORDS.has(word))\n}\n\nexport function inferDomainKeywords(suite: TraceInsightSuite): string[] {\n  const suiteWords = new Set(tokenizeDomainWords(`${suite.name} ${suite.collectionId ?? ''}`))\n  const source = [\n    suite.name,\n    suite.collectionId ?? '',\n    ...suite.tasks.flatMap((task) => [\n      task.id,\n      task.name,\n      task.prompt ?? '',\n      task.difficulty ?? '',\n      ...(task.tags ?? []),\n      ...(task.gaps ?? []),\n    ]),\n  ].join(' ')\n  const counts = new Map<string, number>()\n  for (const word of tokenizeDomainWords(source)) counts.set(word, (counts.get(word) ?? 0) + 1)\n  return [...counts.entries()]\n    .filter(([word, count]) => count >= 2 || suiteWords.has(word))\n    .sort((a, b) => b[1] - a[1] || a[0].localeCompare(b[0]))\n    .map(([word]) => word)\n    .slice(0, 18)\n}\n\nexport function domainEvidencePattern(keywords: string[]): RegExp {\n  const escaped = keywords\n    .filter((keyword) => keyword.length >= 3)\n    .map((keyword) => keyword.replace(/[.*+?^${}()|[\\]\\\\]/g, '\\\\$&'))\n  return escaped.length > 0\n    ? new RegExp(`(?<![A-Za-z0-9])(?:${escaped.join('|')})(?![A-Za-z0-9])`, 'i')\n    : /(?<![A-Za-z0-9])(?:sdk|api|css|dns|xml|provider|client|service|integration|webhook|transaction|auth|oauth|graphql|rest)(?![A-Za-z0-9])/i\n}\n\nexport function describeTraceInsightScope(suite: TraceInsightSuite): string {\n  const taskLabel =\n    suite.tasks.length === 1\n      ? '1 implementation task'\n      : `${suite.tasks.length} implementation tasks`\n  const tags = new Map<string, number>()\n  for (const task of suite.tasks) {\n    for (const tag of task.tags ?? []) tags.set(tag, (tags.get(tag) ?? 0) + 1)\n  }\n  const topTags = [...tags.entries()]\n    .sort((a, b) => b[1] - a[1] || a[0].localeCompare(b[0]))\n    .slice(0, 8)\n    .map(([tag]) => tag)\n  if (topTags.length > 0) return `${taskLabel} across ${topTags.join(', ')}.`\n  const difficulties = [\n    ...new Set(\n      suite.tasks.map((task) => task.difficulty).filter((value): value is string => Boolean(value)),\n    ),\n  ].join(', ')\n  return `${taskLabel} across ${difficulties || 'the selected benchmark scope'}.`\n}\n\nexport function planTraceInsightQuestions(input: TraceInsightPromptInput): TraceInsightQuestion[] {\n  const hasFailures = input.suite.tasks.some((task) => task.outcome && task.outcome !== 'satisfied')\n  const hasMultipleShots = input.suite.tasks.some((task) =>\n    (task.gaps ?? []).some((gap) => /shot|review|retry|continue/i.test(gap)),\n  )\n  const questions: TraceInsightQuestion[] = [\n    {\n      id: 'execution-path',\n      question: 'What did the worker actually do before the first meaningful implementation edit?',\n      why: 'Separates grounded execution from polished but shallow output.',\n    },\n    {\n      id: 'research-grounding',\n      question:\n        'Did the worker inspect docs, source, examples, or package references before committing to an implementation path?',\n      why: 'Identifies whether failures came from weak retrieval, weak examples, or premature coding.',\n    },\n    {\n      id: 'domain-proof',\n      question:\n        'Which tasks produced executable domain proof versus UI copy, placeholders, or inferred behavior?',\n      why: 'Keeps product-quality claims tied to concrete evidence.',\n    },\n    {\n      id: 'root-cause',\n      question:\n        'For each major failure cluster, is the likely root cause prompt/scaffold, docs/examples, SDK/API ergonomics, evaluator, runtime, or model behavior?',\n      why: 'Turns trace observations into actionable ownership.',\n    },\n    {\n      id: 'evidence-quality',\n      question:\n        'Which external-facing claims are directly supported by trace ids, span ids, verifier findings, reviewer notes, or generated code?',\n      why: 'Prevents unsupported customer-report conclusions.',\n    },\n  ]\n  if (hasMultipleShots) {\n    questions.push({\n      id: 'reviewer-lift',\n      question: 'Where did reviewer feedback improve score, stall, or regress across shots?',\n      why: 'Shows whether the driver loop is learning or merely repeating work.',\n    })\n  }\n  if (hasFailures) {\n    questions.push({\n      id: 'optimization-targets',\n      question:\n        'Which prompt, evaluator, scaffold, or workflow changes should feed the next GEPA/autoresearch optimization run?',\n      why: 'Connects benchmark evidence to the optimization loop.',\n    })\n  }\n  return questions\n}\n\nexport function buildTraceInsightContext(input: TraceInsightPromptInput): TraceInsightContext {\n  return {\n    suite: input.suite,\n    scope: describeTraceInsightScope(input.suite),\n    keywords: inferDomainKeywords(input.suite),\n    questions: planTraceInsightQuestions(input),\n    panel: defaultTraceInsightPanel(),\n    findings: input.findings ?? [],\n    agent: input.agent ?? null,\n    totals: input.totals ?? null,\n  }\n}\n\nexport function scoreTraceInsightReadiness(context: TraceInsightContext): TraceInsightReadiness {\n  const failedTasks = context.suite.tasks.filter(\n    (task) => task.outcome && task.outcome !== 'satisfied',\n  )\n  const findingTaskIds = new Set(context.findings.flatMap((finding) => finding.taskIds))\n  const failedTasksWithFindings = failedTasks.filter((task) => findingTaskIds.has(task.id))\n  const tasksWithGaps = context.suite.tasks.filter((task) => (task.gaps ?? []).length > 0)\n  const gates: TraceInsightQualityGate[] = [\n    {\n      id: 'domain-context',\n      label: 'Domain context inferred',\n      passed: context.keywords.length > 0,\n      severity: 'high',\n      detail:\n        context.keywords.length > 0\n          ? `${context.keywords.length} domain terms inferred: ${context.keywords.slice(0, 8).join(', ')}`\n          : 'No domain terms were inferred from suite, tasks, prompts, tags, or gaps.',\n    },\n    {\n      id: 'panel-coverage',\n      label: 'Analyst panel planned',\n      passed: context.panel.length >= 4 && context.questions.length >= 5,\n      severity: 'high',\n      detail: `${context.panel.length} panel roles and ${context.questions.length} investigation questions planned.`,\n    },\n    {\n      id: 'failure-coverage',\n      label: 'Failures mapped to findings',\n      passed:\n        failedTasks.length === 0 || failedTasksWithFindings.length / failedTasks.length >= 0.5,\n      severity: 'critical',\n      detail:\n        failedTasks.length === 0\n          ? 'No failed tasks in suite.'\n          : `${failedTasksWithFindings.length}/${failedTasks.length} failed tasks appear in finding clusters.`,\n    },\n    {\n      id: 'gap-evidence',\n      label: 'Task gaps captured',\n      passed: failedTasks.length === 0 || tasksWithGaps.length / failedTasks.length >= 0.5,\n      severity: 'medium',\n      detail: `${tasksWithGaps.length} tasks include explicit evaluator or analyst gaps.`,\n    },\n    {\n      id: 'attribution-evidence',\n      label: 'Evidence-classed customer findings',\n      passed:\n        failedTasks.every((task) =>\n          context.findings.some(\n            (finding) =>\n              finding.taskIds.includes(task.id) && finding.attribution?.subject.taskId === task.id,\n          ),\n        ) &&\n        context.findings.every(\n          (finding) =>\n            isTraceInsightAttribution(finding.attribution) &&\n            finding.taskIds.length === 1 &&\n            finding.taskIds[0] === finding.attribution.subject.taskId,\n        ),\n      severity: 'critical',\n      detail:\n        'Every finding needs an explicit evidence class and byte-backed links, or an explicit unknown; prose is not attribution evidence.',\n    },\n  ]\n  const penalty = gates.reduce((sum, gate) => {\n    if (gate.passed) return sum\n    if (gate.severity === 'critical') return sum + 35\n    if (gate.severity === 'high') return sum + 20\n    if (gate.severity === 'medium') return sum + 10\n    return sum + 5\n  }, 0)\n  const score = Math.max(0, Math.min(1, 1 - penalty / 100))\n  return {\n    score,\n    grade: score >= 0.9 ? 'external-ready' : score >= 0.7 ? 'internal-review' : 'raw-analysis',\n    gates,\n  }\n}\n\nexport function defaultTraceInsightPanel(): TraceInsightPanelRole[] {\n  return [\n    {\n      id: 'trace-forensics',\n      name: 'Trace Forensics',\n      responsibility:\n        'Reconstruct what the worker did in order, including research, edits, reviewer interventions, verifier feedback, and stop reason.',\n    },\n    {\n      id: 'root-cause',\n      name: 'Root Cause',\n      responsibility:\n        'Map failures to prompt/scaffold, docs/examples, SDK/API/product ergonomics, evaluator, runtime, or model behavior.',\n    },\n    {\n      id: 'optimization',\n      name: 'Optimization',\n      responsibility:\n        'Identify prompt, reviewer, evaluator, scaffold, and GEPA/autoresearch changes that should be tested next.',\n    },\n    {\n      id: 'external-evidence',\n      name: 'External Evidence',\n      responsibility:\n        'Separate customer-safe claims from internal harness findings and reject conclusions without task, trace, span, code, reviewer, or verifier evidence.',\n    },\n  ]\n}\n\nexport function buildTraceInsightPrompt(input: TraceInsightPromptInput): string {\n  const context = buildTraceInsightContext(input)\n  const maxRepresentativeTraces = input.maxRepresentativeTraces ?? 6\n  return `Analyze this benchmark run and produce evidence-backed trace intelligence.\n\nAudience:\n- internal AI/product leadership\n- possible customer-facing report for ${input.suite.name}\n\nInvestigation plan:\n${context.questions.map((item, index) => `${index + 1}. ${item.question} (${item.why})`).join('\\n')}\n\nAnalyst panel:\n${context.panel.map((role) => `- ${role.name}: ${role.responsibility}`).join('\\n')}\n\nIf the task branches are independent, use subagents for the panel roles above and aggregate their findings. Do not run a panel role unless its answer will change the final report.\n\nRequired output:\n1. Executive verdict: what this run proves and does not prove.\n2. The investigation questions you answered and the evidence used.\n3. Failure taxonomy: agent prompting, evaluator/harness, docs/examples, SDK/API/product integration, infra.\n4. Evidence-backed examples with trace ids/task ids and concrete verifier findings.\n5. Highest-ROI fixes for the benchmark harness, prompt/GEPA optimization, and customer-facing product/docs surface.\n6. What is safe for an external report versus what must stay internal.\n7. One rerun plan that would validate lift after optimization.\n\nBudget:\n- Inspect the dataset overview, the failure summary, and at most ${maxRepresentativeTraces} representative traces.\n- Prefer traces named in the failure summary over broad exploration.\n- Do not do exhaustive trace sweeps.\n- Return the final report as soon as the taxonomy and examples are supported.\n\nRun summary:\n${JSON.stringify(\n  {\n    suite: input.suite.name,\n    scope: context.scope,\n    inferredKeywords: context.keywords,\n    agent: context.agent,\n    totals: context.totals,\n    findings: context.findings.map((finding) => ({\n      kind: finding.kind,\n      severity: finding.severity,\n      taskCount: finding.taskIds.length,\n      proposedFixClass: finding.proposedFixClass,\n      attribution: finding.attribution,\n    })),\n    failures: input.suite.tasks\n      .filter((task) => task.outcome && task.outcome !== 'satisfied')\n      .map((task) => ({\n        task: task.id,\n        difficulty: task.difficulty,\n        outcome: task.outcome,\n        score: task.score,\n        gaps: task.gaps ?? [],\n      })),\n  },\n  null,\n  2,\n)}\n\nUse the trace tools. Do not invent facts. Cite task ids. Separate customer-facing claims from internal harness/model findings.\nCustomer attribution must preserve the supplied evidence class and artifact links. A narrative, regex label, observational rate, or document age is not causal evidence. Without validated request/response execution or a supported registered corrected-document comparison, report unknown; do not guess a failing company or tool.`\n}\n","/** Canonical flattened OTLP span shape shared by trace producers and readers. */\n\nimport type { SpanStatus } from './schema'\n\nexport type OtlpStatusCode = 'STATUS_CODE_OK' | 'STATUS_CODE_ERROR' | 'STATUS_CODE_UNSET'\n\nexport interface OtlpFlatLine {\n  trace_id: string\n  span_id: string\n  parent_span_id: string | null\n  name: string\n  kind: string\n  start_time: string\n  end_time: string\n  status: {\n    code: OtlpStatusCode\n    message?: string\n  }\n  resource: { attributes: Record<string, unknown> }\n  attributes: Record<string, unknown>\n  events?: Array<{ name: string; timeUnixNano?: string; attributes?: Record<string, unknown> }>\n}\n\nexport interface CreateOtlpFlatLineInput {\n  traceId: string\n  spanId: string\n  parentSpanId: string | null\n  name: string\n  kind: string\n  startTime: string\n  endTime: string\n  statusCode: OtlpStatusCode\n  statusMessage?: string\n  resource: OtlpFlatLine['resource']\n  attributes: Record<string, unknown>\n  events?: OtlpFlatLine['events']\n}\n\nexport function createOtlpFlatLine(input: CreateOtlpFlatLineInput): OtlpFlatLine {\n  return {\n    trace_id: input.traceId,\n    span_id: input.spanId,\n    parent_span_id: input.parentSpanId,\n    name: input.name,\n    kind: input.kind,\n    start_time: input.startTime,\n    end_time: input.endTime,\n    status: {\n      code: input.statusCode,\n      ...(input.statusMessage !== undefined ? { message: input.statusMessage } : {}),\n    },\n    resource: input.resource,\n    attributes: input.attributes,\n    ...(input.events && input.events.length > 0 ? { events: input.events } : {}),\n  }\n}\n\n/** Map the canonical trace status while letting each caller choose its legacy default. */\nexport function spanStatusToOtlp(\n  status: SpanStatus | undefined,\n  error: string | undefined,\n  defaultCode: OtlpStatusCode,\n): OtlpStatusCode {\n  if (status === 'error' || error) return 'STATUS_CODE_ERROR'\n  if (status === 'ok') return 'STATUS_CODE_OK'\n  return defaultCode\n}\n\n/** Convert epoch milliseconds, returning `undefined` for invalid or out-of-range values. */\nexport function epochMillisToIso(value: number): string | undefined {\n  if (!Number.isFinite(value)) return undefined\n  try {\n    return new Date(value).toISOString()\n  } catch {\n    return undefined\n  }\n}\n","import { CaptureIntegrityError } from '../errors'\nimport { applyToolSpanOtlpAttributes, OPENINFERENCE_SPAN_KIND } from '../trace/otlp-attributes'\nimport { createOtlpFlatLine, epochMillisToIso, spanStatusToOtlp } from '../trace/otlp-flat'\nimport type { ToolSpan } from '../trace/schema'\nimport type { TraceAnalysisStore } from './store'\nimport { createOtlpBufferTraceStore, type ToolSpansToTraceAnalysisStoreOptions } from './store-otlp'\n\n/** Missing tool spans cannot distinguish a tool-free run from broken capture. */\nexport class ToolTraceMissingError extends CaptureIntegrityError {\n  constructor() {\n    super('toolSpansToTraceAnalysisStore: no tool spans supplied; trace evidence is missing')\n  }\n}\n\n/**\n * Snapshot canonical tool spans into the read interface used by trace analysts.\n * One run becomes one trace while arguments, results, errors, and timing remain searchable.\n */\nexport function toolSpansToTraceAnalysisStore(\n  spans: readonly ToolSpan[] | null | undefined,\n  options: ToolSpansToTraceAnalysisStoreOptions = {},\n): TraceAnalysisStore {\n  if (!spans || spans.length === 0) throw new ToolTraceMissingError()\n\n  const seen = new Set<string>()\n  const lines = spans.map((span, index) => {\n    assertToolSpanIdentity(span, index)\n    const identity = `${span.runId}\\u0000${span.spanId}`\n    if (seen.has(identity)) {\n      throw new CaptureIntegrityError(\n        `toolSpansToTraceAnalysisStore: duplicate span '${span.spanId}' in run '${span.runId}'`,\n      )\n    }\n    seen.add(identity)\n\n    const attributes = { ...(span.attributes ?? {}) }\n    applyToolSpanOtlpAttributes(attributes, span)\n    attributes[OPENINFERENCE_SPAN_KIND] = 'TOOL'\n\n    const endedAt = span.endedAt ?? span.startedAt + (span.latencyMs ?? 0)\n    const line = createOtlpFlatLine({\n      traceId: span.runId,\n      spanId: span.spanId,\n      parentSpanId: span.parentSpanId ?? null,\n      name: span.name,\n      kind: 'SPAN_KIND_INTERNAL',\n      startTime: toolSpanTimeIso(span.startedAt, span.spanId, 'startedAt'),\n      endTime: toolSpanTimeIso(endedAt, span.spanId, 'endedAt'),\n      statusCode: spanStatusToOtlp(span.status, span.error, 'STATUS_CODE_UNSET'),\n      statusMessage: span.error,\n      resource: { attributes: {} },\n      attributes,\n    })\n    try {\n      return JSON.stringify(line)\n    } catch (cause) {\n      throw new CaptureIntegrityError(\n        `toolSpansToTraceAnalysisStore: span '${span.spanId}' in run '${span.runId}' is not JSON-serializable`,\n        { cause },\n      )\n    }\n  })\n\n  return createOtlpBufferTraceStore(Buffer.from(`${lines.join('\\n')}\\n`, 'utf8'), options)\n}\n\nfunction assertToolSpanIdentity(span: ToolSpan, index: number): void {\n  if (span.kind !== 'tool') {\n    throw new CaptureIntegrityError(\n      `toolSpansToTraceAnalysisStore: span at index ${index} has kind '${String(span.kind)}', not 'tool'`,\n    )\n  }\n  if (!span.runId || !span.spanId || !span.name || !span.toolName) {\n    throw new CaptureIntegrityError(\n      `toolSpansToTraceAnalysisStore: span at index ${index} is missing runId, spanId, name, or toolName`,\n    )\n  }\n  if (!Number.isFinite(span.startedAt)) {\n    throw new CaptureIntegrityError(\n      `toolSpansToTraceAnalysisStore: span '${span.spanId}' has invalid startedAt`,\n    )\n  }\n  if (span.endedAt !== undefined && !Number.isFinite(span.endedAt)) {\n    throw new CaptureIntegrityError(\n      `toolSpansToTraceAnalysisStore: span '${span.spanId}' has invalid endedAt`,\n    )\n  }\n  if (span.endedAt !== undefined && span.endedAt < span.startedAt) {\n    throw new CaptureIntegrityError(\n      `toolSpansToTraceAnalysisStore: span '${span.spanId}' ends before it starts`,\n    )\n  }\n  if (span.latencyMs !== undefined && (!Number.isFinite(span.latencyMs) || span.latencyMs < 0)) {\n    throw new CaptureIntegrityError(\n      `toolSpansToTraceAnalysisStore: span '${span.spanId}' has invalid latencyMs`,\n    )\n  }\n}\n\nfunction toolSpanTimeIso(value: number, spanId: string, field: string): string {\n  const iso = epochMillisToIso(value)\n  if (iso) return iso\n  throw new CaptureIntegrityError(\n    `toolSpansToTraceAnalysisStore: span '${spanId}' has invalid ${field}`,\n  )\n}\n"],"mappings":"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"}

package/dist/student-t-BQeKJx2N.js

@@ -1,39 +0,0 @@
-import { l as regularizedIncompleteBeta } from "./internal-CRHwS9iz.js";
-//#region src/math/student-t.ts
-/**
-* Student-t CDF via the regularized incomplete beta function.
-*/
-function studentTCdf(t, degreesOfFreedom) {
-	if (degreesOfFreedom <= 0) return .5;
-	const x = degreesOfFreedom / (degreesOfFreedom + t * t);
-	const beta = regularizedIncompleteBeta(x, degreesOfFreedom / 2, .5);
-	return t >= 0 ? 1 - .5 * beta : .5 * beta;
-}
-/**
-* Inverse Student-t CDF, solved against {@link studentTCdf}.
-*
-* The CDF is monotone, so bracket expansion followed by bisection is stable
-* across fractional degrees of freedom and does not need a separate
-* approximation with a different error profile.
-*/
-function studentTQuantile(probability, degreesOfFreedom) {
-	if (!Number.isFinite(probability) || probability < 0 || probability > 1) throw new RangeError(`studentTQuantile: probability must be in [0,1], got ${probability}`);
-	if (!Number.isFinite(degreesOfFreedom) || degreesOfFreedom <= 0) throw new RangeError(`studentTQuantile: degreesOfFreedom must be positive and finite, got ${degreesOfFreedom}`);
-	if (probability === 0) return Number.NEGATIVE_INFINITY;
-	if (probability === 1) return Number.POSITIVE_INFINITY;
-	if (probability === .5) return 0;
-	if (probability < .5) return -studentTQuantile(1 - probability, degreesOfFreedom);
-	let low = 0;
-	let high = 1;
-	while (studentTCdf(high, degreesOfFreedom) < probability) high *= 2;
-	for (let iteration = 0; iteration < 64; iteration++) {
-		const middle = (low + high) / 2;
-		if (studentTCdf(middle, degreesOfFreedom) < probability) low = middle;
-		else high = middle;
-	}
-	return (low + high) / 2;
-}
-//#endregion
-export { studentTQuantile as n, studentTCdf as t };
-
-//# sourceMappingURL=student-t-BQeKJx2N.js.map

package/dist/student-t-BQeKJx2N.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"student-t-BQeKJx2N.js","names":[],"sources":["../src/math/student-t.ts"],"sourcesContent":["import { regularizedIncompleteBeta } from './special-functions'\n\n/**\n * Student-t CDF via the regularized incomplete beta function.\n */\nexport function studentTCdf(t: number, degreesOfFreedom: number): number {\n  if (degreesOfFreedom <= 0) return 0.5\n\n  const x = degreesOfFreedom / (degreesOfFreedom + t * t)\n  const beta = regularizedIncompleteBeta(x, degreesOfFreedom / 2, 0.5)\n  return t >= 0 ? 1 - 0.5 * beta : 0.5 * beta\n}\n\n/**\n * Inverse Student-t CDF, solved against {@link studentTCdf}.\n *\n * The CDF is monotone, so bracket expansion followed by bisection is stable\n * across fractional degrees of freedom and does not need a separate\n * approximation with a different error profile.\n */\nexport function studentTQuantile(probability: number, degreesOfFreedom: number): number {\n  if (!Number.isFinite(probability) || probability < 0 || probability > 1) {\n    throw new RangeError(`studentTQuantile: probability must be in [0,1], got ${probability}`)\n  }\n  if (!Number.isFinite(degreesOfFreedom) || degreesOfFreedom <= 0) {\n    throw new RangeError(\n      `studentTQuantile: degreesOfFreedom must be positive and finite, got ${degreesOfFreedom}`,\n    )\n  }\n  if (probability === 0) return Number.NEGATIVE_INFINITY\n  if (probability === 1) return Number.POSITIVE_INFINITY\n  if (probability === 0.5) return 0\n  if (probability < 0.5) return -studentTQuantile(1 - probability, degreesOfFreedom)\n\n  let low = 0\n  let high = 1\n  while (studentTCdf(high, degreesOfFreedom) < probability) high *= 2\n  for (let iteration = 0; iteration < 64; iteration++) {\n    const middle = (low + high) / 2\n    if (studentTCdf(middle, degreesOfFreedom) < probability) low = middle\n    else high = middle\n  }\n  return (low + high) / 2\n}\n"],"mappings":";;;;;AAKA,SAAgB,YAAY,GAAW,kBAAkC;CACvE,IAAI,oBAAoB,GAAG,OAAO;CAElC,MAAM,IAAI,oBAAoB,mBAAmB,IAAI;CACrD,MAAM,OAAO,0BAA0B,GAAG,mBAAmB,GAAG,EAAG;CACnE,OAAO,KAAK,IAAI,IAAI,KAAM,OAAO,KAAM;AACzC;;;;;;;;AASA,SAAgB,iBAAiB,aAAqB,kBAAkC;CACtF,IAAI,CAAC,OAAO,SAAS,WAAW,KAAK,cAAc,KAAK,cAAc,GACpE,MAAM,IAAI,WAAW,uDAAuD,aAAa;CAE3F,IAAI,CAAC,OAAO,SAAS,gBAAgB,KAAK,oBAAoB,GAC5D,MAAM,IAAI,WACR,uEAAuE,kBACzE;CAEF,IAAI,gBAAgB,GAAG,OAAO,OAAO;CACrC,IAAI,gBAAgB,GAAG,OAAO,OAAO;CACrC,IAAI,gBAAgB,IAAK,OAAO;CAChC,IAAI,cAAc,IAAK,OAAO,CAAC,iBAAiB,IAAI,aAAa,gBAAgB;CAEjF,IAAI,MAAM;CACV,IAAI,OAAO;CACX,OAAO,YAAY,MAAM,gBAAgB,IAAI,aAAa,QAAQ;CAClE,KAAK,IAAI,YAAY,GAAG,YAAY,IAAI,aAAa;EACnD,MAAM,UAAU,MAAM,QAAQ;EAC9B,IAAI,YAAY,QAAQ,gBAAgB,IAAI,aAAa,MAAM;OAC1D,OAAO;CACd;CACA,QAAQ,MAAM,QAAQ;AACxB"}

package/dist/summary-report-C-CtItCN.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"summary-report-C-CtItCN.d.ts","names":[],"sources":["../src/held-out-gate.ts","../src/summary-report.ts"],"mappings":";;;;KAwIY;;;;;;;;UAiBK;;EAEf;;;EAGA;;;;EAIA;;EAEA;;EAEA;;;EAGA;;UAGe;;;;EAIf;;;;;EAKA;;;;;;;;;;;EAWA;;;;EAIA;;;EAGA;;EAEA;;EAEA;;;;EAIA;;;;;;;;;;;;;;;;;EAiBA;;;;;;;;;;;;;;EAcA;;;;KAKU,iBAAiB;UAEZ;;EAEf;;EAEA;;EAEA;;;;;;;;EAQA,iBAAiB;;;;;EAKjB,gBAAgB;;;;;EAKhB;;;;;;;;;EASA,gBAAgB;;;EAGhB;;;EAGA;IAAY;IAAa;;;;EAGzB;;;;;;;EAOA;IAAW;IAAW;IAAW;IAAqB;;;;;;EAKtD;;;;;EAKA;;EAEA;;EAEA;;EAEA;;EAEA;;;;;EAKA;;;EAGA;;;;;;;EAOA;;UAGe;;EAEf;;EAEA;;EAEA;;EAEA,UAAU;;EAEV;;EAEA,eAAe;;;;;;;cAQJ;mBACM;mBACA;mBACA;mBACA;mBACA;mBACA;mBACA;mBACA;mBACA;mBACA;EAEjB,YAAY,QAAQ;;;;EAoCpB,SAAS,WAAW,aAAa,UAAU,cAAc;;;;;;;UAsTjD;;;;UCzpBO;;;EAGf;;EAEA;;EAEA;;EAEA;;UAGe;EACf;EACA;EACA;EACA;EACA;;EAEA;;EAEA;;EAEA;;EAEA;;EAEA;;UAGe;EACf,MAAM;EACN;EACA;;EAEA;;;;;;;iBAQc,aAAa,MAAM,aAAa,OAAM,sBAA2B;UA6IhE;EACf;;EAEA;;EAEA;;EAEA;;;EAGA;;;EAGA;;UAGe;EACf;EACA;EACA,QAAQ;EACR;IAAQ;IAAc;;;;;;;;iBAQR,YACd,MAAM,aACN;EACE;EACA,gBAAgB,eAAe;IAEhC;UAsDc;;EAEf;;EAEA;;EAEA;;UAGe;EACf;EACA;EACA;EACA;;EAEA;;EAEA;;EAEA;EACA,MAAM;EACN;EACA;IAAM;IAAa;;;UAGJ;;EAEf;;EAEA;;EAEA;;EAEA;;EAEA;;;;;;;iBAQc,cACd,MAAM,aACN,qBACA,oBACA,OAAM,0BACL;KA8ES;;;;;;cAYC;UAEI;;EAEf;;EAEA;;EAEA;;EAEA;;EAEA;;;;;;;;;EASA;;;;;;;EAOA;IAAS;IAAa;;;;;;EAKtB;;;;;EAKA;;EAEA,gBAAgB,eAAe;;EAE/B,kBAAkB;;EAElB;;EAEA;;EAEA;;;;;;EAMA;;UAGe;EACf,UAAU;EACV;EACA;EACA;EACA;;UAGe;EACf;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;IAAU;IAAa;;;;;;;EAMvB;EACA;;;;;;;EAOA;EACA;EACA,OAAO;EACP,UAAU;EACV;;UAGe;;;;;EAKf;;EAEA;;EAEA;;EAEA;;EAEA;;UAGe;EACf;EACA;EACA;EACA;EACA;;;;;;EAMA;EACA;EACA;IAAQ;IAAa;;EACrB;EACA,gBAAgB;EAChB,YAAY;EACZ,SAAS;EACT;IACE,QAAQ;IACR,OAAO;;EAET,aAAa;EACb,kBAAkB;EAClB;EACA;;;;;;;;;;;;;;;;;;;;;iBAiIoB,eACpB,MAAM,aACN,OAAM,wBACL,QAAQ"}