@tangle-network/agent-eval 0.144.11 → 0.144.13

package/dist/paired-promotion-decision-B6zJ3gYM.d.ts

@@ -1,114 +0,0 @@
-import { y as PairedBootstrapResult } from "./statistics-D6Uebe_4.js";
-//#region src/paired-promotion-decision.d.ts
-/** Which paired estimator produced the deciding interval. */
-type PairedDecisionStatistic = 'paired_risk_difference' | 'mean_bootstrap' | 'median_bootstrap';
-/** Which test carried the decision, given the estimator and the sample size. */
-type PairedDecisionMethod = 'score-interval' | 'bootstrap-ci' | 'exact-sign';
-/** McNemar's exact paired-binary evidence, on the two-point path only. */
-interface PairedMcNemarEvidence {
-  /** Discordant pairs the treatment won. */
-  b: number;
-  /** Discordant pairs the control won. */
-  c: number;
-  /** b + c — the only pairs carrying information. */
-  nDiscordant: number;
-  /** Two-sided exact p-value. */
-  pValue: number;
-}
-interface PairedPromotionDecisionOptions {
-  /** Smallest candidate-minus-baseline delta that counts as improvement, in the
-   *  caller's native units. May be negative (a noninferiority margin). Default 0. */
-  threshold?: number;
-  /** Confidence level. Default 0.95. */
-  confidence?: number;
-  /** Bootstrap resamples, on the paths where a bootstrap decides. Default 2000. */
-  resamples?: number;
-  /** Deterministic bootstrap seed. Omitted ⇒ derived from the deltas. */
-  seed?: number;
-  /** Caller-required paired observations. The exact test may impose a higher
-   *  minimum; the effective one is reported as `minimumPairs`. */
-  minPairs?: number;
-  /**
-   * `'mean'` (default) routes by SHAPE: a two-point (pass/fail) outcome on any
-   * encoding decides on the score interval, everything else on the mean
-   * bootstrap. `'median'` forces the median bootstrap on every input, including
-   * shapes where it is structurally blind — kept for callers who want outlier
-   * robustness on genuinely continuous outcomes and accept that cost.
-   */
-  statistic?: 'mean' | 'median';
-}
-interface PairedPromotionDecision {
-  /** Paired observations supplied. */
-  n: number;
-  /** Threshold the interval was judged against, native units. */
-  threshold: number;
-  confidence: number;
-  statistic: PairedDecisionStatistic;
-  method: PairedDecisionMethod;
-  /** Common positive level of a two-point outcome ({0,1} ⇒ 1, {0,100} ⇒ 100),
-   *  or null when the outcome is not two-point. Non-null is exactly the
-   *  condition for the `paired_risk_difference` path, and it is the factor
-   *  `delta` / `low` / `high` were rescaled by. */
-  binaryScale: number | null;
-  /** Exact-tie fraction over the paired deltas; null when there are no pairs. */
-  tieFraction: number | null;
-  /** Point estimate of the DECIDING statistic, in the caller's native units. */
-  delta: number;
-  /** Lower bound of the DECIDING interval, native units. */
-  low: number;
-  /** Upper bound of the DECIDING interval, native units. */
-  high: number;
-  /** The bootstrap that decided, or null when the score interval did. Callers
-   *  that need a bootstrap as a diagnostic on the two-point path compute their
-   *  own — it is not computed here, so the binary path costs no resamples. */
-  bootstrap: PairedBootstrapResult | null;
-  /** McNemar's exact evidence, or null off the two-point path. */
-  mcnemar: PairedMcNemarEvidence | null;
-  /** Exact one-sided sign-test p-value on the small-sample bootstrap path;
-   *  null otherwise. */
-  pValue: number | null;
-  /** Effective observation minimum after accounting for confidence. */
-  minimumPairs: number;
-  /** n >= minimumPairs. */
-  sufficient: boolean;
-  /** The deciding interval is zero-width or non-finite — no evidence in either
-   *  direction, so it cannot clear any threshold on evidence. */
-  indeterminate: boolean;
-  /** McNemar's exact test refuses at a non-negative threshold. */
-  exactTestVetoes: boolean;
-  /** The deciding interval clears the threshold, ignoring the other two guards. */
-  clearsThreshold: boolean;
-  /** `sufficient && !indeterminate && clearsThreshold && !exactTestVetoes` —
-   *  the whole rule. */
-  promote: boolean;
-  /** What `delta` measures, for a reason string. */
-  label: 'success-rate' | 'mean' | 'median';
-  /** Why a zero-width interval is zero-width; empty when it is not. */
-  indeterminateCause: string;
-  /** Sentence naming the test when the exact sign test decided; else empty. */
-  methodDetail: string;
-}
-/** The shape facts that pick the estimator, without computing an interval. */
-interface PairedDecisionShape {
-  statistic: PairedDecisionStatistic;
-  /** Common positive level of a two-point outcome; null when not two-point. */
-  binaryScale: number | null;
-  /** Exact-tie fraction over the paired deltas; null when there are no pairs. */
-  tieFraction: number | null;
-}
-/**
- * Which estimator {@link decidePairedPromotion} would use on this data, and the
- * shape facts behind it — for callers that must report the shape on a path
- * where no interval is computed at all (an early rejection, or zero pairs).
- * Cheap: no bootstrap, no interval.
- */
-declare function pairedDecisionShape(before: number[], after: number[], statistic?: 'mean' | 'median'): PairedDecisionShape;
-/**
- * Decide whether a paired candidate-minus-baseline delta clears a promotion
- * threshold. `before` is the baseline arm, `after` the candidate arm, paired by
- * position. Throws on unequal lengths.
- */
-declare function decidePairedPromotion(before: number[], after: number[], options?: PairedPromotionDecisionOptions): PairedPromotionDecision;
-//#endregion
-export { PairedPromotionDecision as a, pairedDecisionShape as c, PairedMcNemarEvidence as i, PairedDecisionShape as n, PairedPromotionDecisionOptions as o, PairedDecisionStatistic as r, decidePairedPromotion as s, PairedDecisionMethod as t };
-//# sourceMappingURL=paired-promotion-decision-B6zJ3gYM.d.ts.map

package/dist/paired-promotion-decision-B6zJ3gYM.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"paired-promotion-decision-B6zJ3gYM.d.ts","names":[],"sources":["../src/paired-promotion-decision.ts"],"mappings":";;;KA2DY;;KAMA;;UAGK;;EAEf;;EAEA;;EAEA;;EAEA;;UAGe;;;EAGf;;EAEA;;EAEA;;EAEA;;;EAGA;;;;;;;;EAQA;;UAGe;;EAEf;;EAEA;EACA;EACA,WAAW;EACX,QAAQ;;;;;EAKR;;EAEA;;EAEA;;EAEA;;EAEA;;;;EAIA,WAAW;;EAEX,SAAS;;;EAGT;;EAEA;;EAEA;;;EAGA;;EAEA;;EAEA;;;EAGA;;EAEA;;EAEA;;EAEA;;;UAIe;EACf,WAAW;;EAEX;;EAEA;;;;;;;;iBASc,oBACd,kBACA,iBACA,gCACC;;;;;;iBAiBa,sBACd,kBACA,iBACA,UAAS,iCACR"}

package/dist/prime-protocol-BfSalTfR.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"prime-protocol-BfSalTfR.js","names":[],"sources":["../src/analyst/equal-terms.ts","../src/analyst/prime-protocol.ts"],"sourcesContent":["import { ValidationError } from '../errors'\n\n/**\n * The terms every declarative-arm comparison must hold equal before any\n * per-kind check runs. Arm kinds (analyst definitions, repair arms) extend\n * the comparison with their own fields; the refusals here are the floor.\n */\nexport interface DeclarativeArmTerms {\n  readonly id: string\n  /** Bounded repair turns the arm earns on a malformed reply. */\n  readonly repairTurns: number\n}\n\nexport interface EqualDeclarativeTerms {\n  readonly ids: readonly string[]\n  readonly repairTurns: number\n}\n\n/**\n * Refuses a comparison whose arms are not on equal terms: an empty set, a\n * duplicated id, or unequal repair turns — a retry is a second sample the\n * other arms never got. `noun` names the arm kind in every message so a\n * refusal reads in the caller's vocabulary.\n */\nexport function assertEqualDeclarativeTerms(\n  noun: string,\n  terms: ReadonlyArray<DeclarativeArmTerms>,\n): EqualDeclarativeTerms {\n  if (terms.length === 0) {\n    throw new ValidationError(`a ${noun} comparison needs at least one ${noun}`)\n  }\n  const ids = terms.map((term) => term.id)\n  const duplicate = ids.find((id, index) => ids.indexOf(id) !== index)\n  if (duplicate !== undefined) {\n    throw new ValidationError(`${noun} '${duplicate}' is declared twice`)\n  }\n  const repairTurns = terms[0]!.repairTurns\n  const unequal = terms.find((term) => term.repairTurns !== repairTurns)\n  if (unequal) {\n    throw new ValidationError(\n      `${noun} '${unequal.id}' gets ${unequal.repairTurns} bounded repair turns and ` +\n        `${noun} '${terms[0]!.id}' gets ${repairTurns}; a retry is a second sample ` +\n        'the other arms never got',\n    )\n  }\n  return { ids, repairTurns }\n}\n","import { createHash } from 'node:crypto'\nimport type { CustomTokenPricing } from '../cost-ledger'\nimport type { PrimeBridgeTransport, PrimeBridgeTransportResult } from './prime-bridge-transport'\nimport type { ReplyContract, ReplyRowDecoded } from './reply-contract'\nimport type { AnalystUsageReceipt } from './types'\n\n/**\n * The prime analyst protocol: a one-shot RLM reached through an\n * OpenAI-compatible bridge, given the whole trajectory inline because it has no\n * REPL and no trace tools, answering in one fenced JSON block of short strings.\n *\n * This module owns every part of that protocol that does not depend on what the\n * rows MEAN: prompt and contract composition, the bounded repair turn, reply\n * extraction, row decoding order, the render-measure-fall-back-fail-loud\n * projection ladder, usage normalization, and the protocol identity digest.\n *\n * The cut: the core speaks RAW ROWS and never names a finding type. It knows a\n * prime reply carries an `answer` string plus an array of rows under a named\n * field, and that each row is decoded by a caller-supplied function. Consumers\n * — the CodeTraceBench benchmark runner here, a span-grounded trace analyzer\n * elsewhere — map decoded rows into their own finding shape on the way out. So\n * nothing in this file may import a block type, a finding type, or a trace\n * store, and no consumer needs another copy of the protocol.\n */\n\n// ── Reply contract ───────────────────────────────────────────────────\n\n/**\n * The prime reply grammar is the general analyst reply contract: these aliases\n * keep every prime-protocol consumer compiling against the shared type in\n * ./reply-contract. The exchange below reads the base fields (`rowsField`,\n * contract lines, `decodeRow`, `maxRows`); the strict-envelope knobs serve\n * one-shot JSON arms and are inert here.\n */\nexport type PrimeRowDecoded<TRow> = ReplyRowDecoded<TRow>\n\nexport type PrimeReplyContract<TRow> = ReplyContract<TRow>\n\n// ── Prompt composition ───────────────────────────────────────────────\n\nexport interface PrimePromptSpec {\n  question: string\n  /** Task definition spliced under a `TASK DEFINITION:` heading. Omit when the question is the whole task. */\n  taskDefinition?: string\n  contractLines: readonly string[]\n  /** Line introducing the trajectory, e.g. `TRAJECTORY (trace_id X; 12 assistant step spans; ...):`. */\n  trajectoryHeader: string\n  renderedTrajectory: string\n  /** Material appended after the trajectory, e.g. the final-verification spans. */\n  trailer?: string\n}\n\nexport function buildPrimePrompt(spec: PrimePromptSpec): string {\n  return [\n    `QUESTION: ${spec.question}`,\n    '',\n    ...(spec.taskDefinition === undefined ? [] : ['TASK DEFINITION:', spec.taskDefinition, '']),\n    ...spec.contractLines,\n    '',\n    spec.trajectoryHeader,\n    spec.renderedTrajectory,\n    ...(spec.trailer === undefined ? [] : ['', spec.trailer]),\n  ].join('\\n')\n}\n\nexport interface PrimeRepairPromptSpec {\n  defect: string\n  previousReply: string\n  repairContractLines: readonly string[]\n}\n\n/** Carries the malformed reply and the contract — never the trajectory. */\nexport function buildPrimeRepairPrompt(spec: PrimeRepairPromptSpec): string {\n  return [\n    'Your previous reply to a trace-analysis task was structurally malformed and could not be parsed',\n    `(${spec.defect}). Below is your previous reply verbatim. Re-emit ONLY the corrected JSON — one`,\n    'fenced ```json block, no other text, no tools. The JSON object has exactly two fields:',\n    ...spec.repairContractLines,\n    '',\n    'PREVIOUS REPLY:',\n    spec.previousReply,\n  ].join('\\n')\n}\n\n// ── Reply extraction ─────────────────────────────────────────────────\n\n/**\n * Recover the reply's JSON object.\n *\n * Distinct from `extractJsonPayload` in ../llm-client, which serves a response\n * that DECLARES a JSON root and therefore must not scan onward. A prime reply\n * is prose plus a fenced block, and when the model emits several fences the\n * last one is its answer — so fences are scanned in reverse, and only then is a\n * brace-to-brace slice tried.\n */\nexport function extractPrimeJsonObject(text: string): Record<string, unknown> | null {\n  const direct = parsePrimeJsonObject(text)\n  if (direct) return direct\n  const fenced = [...text.matchAll(/```(?:json)?\\s*\\n?([\\s\\S]*?)```/g)]\n  for (let index = fenced.length - 1; index >= 0; index -= 1) {\n    const candidate = parsePrimeJsonObject(fenced[index]![1]!)\n    if (candidate) return candidate\n  }\n  const start = text.indexOf('{')\n  const end = text.lastIndexOf('}')\n  if (start >= 0 && end > start) {\n    const candidate = parsePrimeJsonObject(text.slice(start, end + 1))\n    if (candidate) return candidate\n  }\n  return null\n}\n\n/** Why the reply cannot be read as a prime answer, or null when it can. */\nexport function primeReplyDefect(\n  parsed: Record<string, unknown> | null,\n  rowsField: string,\n): string | null {\n  if (parsed === null) return 'no parseable JSON object'\n  if (!Array.isArray(parsed[rowsField])) return `JSON has no \"${rowsField}\" array`\n  return null\n}\n\nfunction parsePrimeJsonObject(text: string): Record<string, unknown> | null {\n  try {\n    const value: unknown = JSON.parse(text.trim())\n    return typeof value === 'object' && value !== null && !Array.isArray(value)\n      ? (value as Record<string, unknown>)\n      : null\n  } catch {\n    return null\n  }\n}\n\n// ── Usage ────────────────────────────────────────────────────────────\n\n/**\n * Token accounting exactly as the bridge reported it. Lossless on purpose: a\n * side the bridge did not report stays null rather than becoming a zero, and a\n * side it DID report survives even when its partner is missing.\n */\nexport interface PrimeRawUsage {\n  /**\n   * Model-usage records the bridge observed. NOT a count of bridge round trips:\n   * one prime turn routes several internal model calls, so a single turn\n   * typically reports 3-5.\n   */\n  calls: number | null\n  /** Prompt tokens the bridge reported; null when it reported none. */\n  inputTokens: number | null\n  /** Completion tokens the bridge reported; null when it reported none. */\n  outputTokens: number | null\n  /**\n   * True when the bridge DERIVED the counts (from character lengths) because\n   * the backend reported no usage of its own. Pricing derived counts produces a\n   * guess about a guess, which a reader must be able to tell apart from a\n   * rate-estimated cost over exact tokens.\n   */\n  bridgeEstimated: boolean\n}\n\nexport function emptyPrimeRawUsage(): PrimeRawUsage {\n  return { calls: null, inputTokens: null, outputTokens: null, bridgeEstimated: false }\n}\n\n/** Read the bridge's OpenAI-shaped `usage` object. */\nexport function normalizePrimeUsage(raw: unknown): PrimeRawUsage {\n  if (typeof raw !== 'object' || raw === null) return emptyPrimeRawUsage()\n  const record = raw as Record<string, unknown>\n  return {\n    calls: tokenCountOrNull(record.model_requests),\n    inputTokens: tokenCountOrNull(record.prompt_tokens),\n    outputTokens: tokenCountOrNull(record.completion_tokens),\n    bridgeEstimated: record.estimated === true,\n  }\n}\n\n/**\n * Sum two turns. Each side poisons independently: two turns that both report\n * input and neither report output yield a real input total beside a null\n * output, because discarding a measured count is as wrong as inventing one.\n */\nexport function mergePrimeRawUsage(a: PrimeRawUsage, b: PrimeRawUsage): PrimeRawUsage {\n  return {\n    calls: sumOrNull(a.calls, b.calls),\n    inputTokens: sumOrNull(a.inputTokens, b.inputTokens),\n    outputTokens: sumOrNull(a.outputTokens, b.outputTokens),\n    bridgeEstimated: a.bridgeEstimated || b.bridgeEstimated,\n  }\n}\n\nfunction sumOrNull(a: number | null, b: number | null): number | null {\n  return a !== null && b !== null ? a + b : null\n}\n\nfunction tokenCountOrNull(value: unknown): number | null {\n  return typeof value === 'number' && Number.isSafeInteger(value) && value >= 0 ? value : null\n}\n\n/**\n * Bind raw prime usage to agent-eval's typed receipt.\n *\n * `RunTokenUsage.input` and `.output` are non-nullable, so a one-sided count\n * cannot round-trip through `tokens` without writing a zero nobody measured.\n * The complete-accounting field therefore stays null, the reported side is\n * carried verbatim in `partialTokens`, and its price becomes the receipt's\n * `knownCostUsd` lower bound.\n *\n * Only agent-eval calls this; consumers with no pricing table read\n * `PrimeRawUsage` directly.\n */\nexport function analystUsageReceiptFromPrimeUsage(\n  usage: PrimeRawUsage,\n  pricing: CustomTokenPricing,\n): AnalystUsageReceipt {\n  const { calls, inputTokens, outputTokens, bridgeEstimated } = usage\n  const estimatedTokens = bridgeEstimated ? { tokensEstimated: true } : {}\n  if (inputTokens !== null && outputTokens !== null) {\n    return {\n      calls,\n      tokens: { input: inputTokens, output: outputTokens },\n      cost: { kind: 'estimated', usd: priceTokens(inputTokens, outputTokens, pricing) },\n      ...estimatedTokens,\n    }\n  }\n  if (inputTokens === null && outputTokens === null) {\n    return { calls, tokens: null, cost: { kind: 'uncaptured', usd: null }, ...estimatedTokens }\n  }\n  return {\n    calls,\n    tokens: null,\n    partialTokens: { input: inputTokens, output: outputTokens },\n    cost: { kind: 'uncaptured', usd: null },\n    knownCostUsd: priceTokens(inputTokens ?? 0, outputTokens ?? 0, pricing),\n    ...estimatedTokens,\n  }\n}\n\nfunction priceTokens(input: number, output: number, pricing: CustomTokenPricing): number {\n  return (input * pricing.inputUsdPerMillion + output * pricing.outputUsdPerMillion) / 1_000_000\n}\n\n// ── Two-turn exchange ────────────────────────────────────────────────\n\n/**\n * Why an exchange ended without a readable reply. `deadline` and `aborted` are\n * separate members from `transport` on purpose: a model that ran past its\n * deadline, a caller who cancelled, and a bridge that refused the connection\n * demand three different responses, and a record that conflates them cannot be\n * acted on.\n */\nexport type PrimeFailure =\n  | {\n      kind: 'transport' | 'unparseable-json' | 'no-content' | 'deadline' | 'malformed-reply'\n      message: string\n    }\n  | { kind: 'http-status'; message: string; status: number; bodySnippet: string }\n  | { kind: 'aborted'; message: string; cause: unknown }\n\nexport interface PrimeRepairState {\n  attempted: boolean\n  /** Null when no repair turn ran, or when the repair turn never returned a reply. */\n  succeeded: boolean | null\n}\n\n/** One completed bridge turn. A turn that failed produces no record. */\nexport interface PrimeTurnRecord {\n  turn: 'first' | 'repair'\n  usage: PrimeRawUsage\n  /** The reply's `usage` object verbatim; null when the bridge sent none. */\n  rawUsage: unknown\n}\n\nexport interface PrimeRejectedRow {\n  index: number\n  reason: string\n}\n\nexport type PrimeExchangeOutcome<TRow> =\n  | {\n      ok: true\n      /** The reply's `answer` field; null when absent or not a string. */\n      answer: string | null\n      rows: TRow[]\n      rejected: PrimeRejectedRow[]\n      /** Rows the model reported, before decoding or the count cap. */\n      reportedRows: number\n      /** Valid rows dropped by `contract.maxRows`. */\n      overflow: number\n      usage: PrimeRawUsage\n      turns: PrimeTurnRecord[]\n      repair: PrimeRepairState\n      reply: string\n    }\n  | {\n      ok: false\n      failure: PrimeFailure\n      usage: PrimeRawUsage\n      turns: PrimeTurnRecord[]\n      repair: PrimeRepairState\n      /** The last reply received, when one arrived — the diagnostic artifact for a malformed case. */\n      reply?: string\n    }\n\nexport interface PrimeExchangeOptions<TRow> {\n  contract: PrimeReplyContract<TRow>\n  prompt: string\n  transport: PrimeBridgeTransport\n  /** Full endpoint, e.g. `http://localhost:4181/v1/chat/completions`. */\n  url: string\n  model: string\n  /** Deadline for ONE turn. Prime analyses routinely exceed five minutes. */\n  timeoutMs: number\n  /** Whether a structurally malformed reply gets one bounded repair turn. */\n  repair: boolean\n  signal?: AbortSignal\n}\n\n/**\n * Run the protocol: one call, one bounded repair turn on a structurally\n * malformed reply, then decode. Zero valid rows from a well-formed reply is an\n * honest null, not a failure.\n */\nexport async function runPrimeExchange<TRow>(\n  options: PrimeExchangeOptions<TRow>,\n): Promise<PrimeExchangeOutcome<TRow>> {\n  const { contract } = options\n  const turns: PrimeTurnRecord[] = []\n  const repair: PrimeRepairState = { attempted: false, succeeded: null }\n\n  const first = await callPrimeTurn(options, options.prompt)\n  if (!first.ok) {\n    return { ok: false, failure: first.failure, usage: mergeTurns(turns), turns, repair }\n  }\n  turns.push({ turn: 'first', usage: first.usage, rawUsage: first.rawUsage })\n\n  let reply = first.content\n  let parsed = extractPrimeJsonObject(reply)\n  let defect = primeReplyDefect(parsed, contract.rowsField)\n\n  if (defect !== null && options.repair) {\n    repair.attempted = true\n    const second = await callPrimeTurn(\n      options,\n      buildPrimeRepairPrompt({\n        defect,\n        previousReply: reply,\n        repairContractLines: contract.repairContractLines,\n      }),\n    )\n    if (!second.ok) {\n      return { ok: false, failure: second.failure, usage: mergeTurns(turns), turns, repair, reply }\n    }\n    turns.push({ turn: 'repair', usage: second.usage, rawUsage: second.rawUsage })\n    reply = second.content\n    parsed = extractPrimeJsonObject(reply)\n    defect = primeReplyDefect(parsed, contract.rowsField)\n    repair.succeeded = defect === null\n  }\n\n  const usage = mergeTurns(turns)\n  if (defect !== null) {\n    return {\n      ok: false,\n      failure: {\n        kind: 'malformed-reply',\n        message: `${defect} in prime reply${repair.attempted ? ' even after the bounded repair turn' : ''}`,\n      },\n      usage,\n      turns,\n      repair,\n      reply,\n    }\n  }\n\n  const rawRows = parsed![contract.rowsField] as unknown[]\n  const rows: TRow[] = []\n  const rejected: PrimeRejectedRow[] = []\n  let overflow = 0\n  rawRows.forEach((row, index) => {\n    const decoded = contract.decodeRow(row, index)\n    if (!decoded.ok) {\n      rejected.push({ index, reason: decoded.reason })\n      return\n    }\n    // Shape before count: a malformed row must never consume an accepted slot.\n    if (contract.maxRows !== undefined && rows.length >= contract.maxRows) {\n      overflow += 1\n      return\n    }\n    rows.push(decoded.row)\n  })\n  const answer = parsed!.answer\n  return {\n    ok: true,\n    answer: typeof answer === 'string' ? answer : null,\n    rows,\n    rejected,\n    reportedRows: rawRows.length,\n    overflow,\n    usage,\n    turns,\n    repair,\n    reply,\n  }\n}\n\ntype PrimeTurnOutcome =\n  | { ok: true; content: string; usage: PrimeRawUsage; rawUsage: unknown }\n  | { ok: false; failure: PrimeFailure }\n\nasync function callPrimeTurn<TRow>(\n  options: PrimeExchangeOptions<TRow>,\n  content: string,\n): Promise<PrimeTurnOutcome> {\n  const { transport, url, model, timeoutMs, signal } = options\n  const controller = new AbortController()\n  const forwardAbort = () => controller.abort(signal?.reason)\n  if (signal?.aborted) controller.abort(signal.reason)\n  else signal?.addEventListener('abort', forwardAbort, { once: true })\n  const deadline = setTimeout(() => controller.abort(), timeoutMs)\n  let result: PrimeBridgeTransportResult\n  try {\n    result = await transport({\n      url,\n      body: { model, messages: [{ role: 'user', content }] },\n      signal: controller.signal,\n    })\n  } catch (error) {\n    if (signal?.aborted) {\n      return {\n        ok: false,\n        failure: {\n          kind: 'aborted',\n          message: 'prime exchange cancelled by the caller',\n          cause: error,\n        },\n      }\n    }\n    if (controller.signal.aborted) {\n      return {\n        ok: false,\n        failure: { kind: 'deadline', message: `bridge call exceeded ${timeoutMs}ms` },\n      }\n    }\n    return {\n      ok: false,\n      failure: {\n        kind: 'transport',\n        message: `bridge transport failure: ${error instanceof Error ? error.message : String(error)}`,\n      },\n    }\n  } finally {\n    clearTimeout(deadline)\n    signal?.removeEventListener('abort', forwardAbort)\n  }\n\n  if (result.status !== 200) {\n    const bodySnippet = result.text.slice(0, 500)\n    return {\n      ok: false,\n      failure: {\n        kind: 'http-status',\n        message: `bridge HTTP ${result.status}: ${bodySnippet}`,\n        status: result.status,\n        bodySnippet,\n      },\n    }\n  }\n  let response: unknown\n  try {\n    response = JSON.parse(result.text)\n  } catch {\n    return {\n      ok: false,\n      failure: {\n        kind: 'unparseable-json',\n        message: `bridge returned unparseable JSON (${result.text.length} bytes)`,\n      },\n    }\n  }\n  const replyContent = primeReplyContent(response)\n  if (replyContent === null) {\n    return {\n      ok: false,\n      failure: { kind: 'no-content', message: 'bridge reply carries no message content' },\n    }\n  }\n  const rawUsage = primeReplyUsage(response)\n  return { ok: true, content: replyContent, usage: normalizePrimeUsage(rawUsage), rawUsage }\n}\n\n/**\n * Fold from the FIRST turn, never from an empty receipt: an all-null identity\n * would poison every side it merged with and erase counts the bridge reported.\n */\nfunction mergeTurns(turns: readonly PrimeTurnRecord[]): PrimeRawUsage {\n  if (turns.length === 0) return emptyPrimeRawUsage()\n  return turns\n    .slice(1)\n    .reduce<PrimeRawUsage>((total, turn) => mergePrimeRawUsage(total, turn.usage), turns[0]!.usage)\n}\n\nfunction primeReplyContent(response: unknown): string | null {\n  if (typeof response !== 'object' || response === null) return null\n  const choices = (response as { choices?: unknown }).choices\n  if (!Array.isArray(choices) || choices.length === 0) return null\n  const message = (choices[0] as { message?: unknown })?.message\n  if (typeof message !== 'object' || message === null) return null\n  const content = (message as { content?: unknown }).content\n  return typeof content === 'string' && content.length > 0 ? content : null\n}\n\nfunction primeReplyUsage(response: unknown): unknown {\n  if (typeof response !== 'object' || response === null) return null\n  return (response as { usage?: unknown }).usage ?? null\n}\n\n// ── Trajectory projection ────────────────────────────────────────────\n\n/**\n * Where the inlined trajectory comes from. The protocol needs only two moves —\n * fetch it all, or fetch a reduced version — so no store, artifact path, or\n * span type enters the shared signature.\n */\nexport interface PrimeProjectionSource<TItem> {\n  /** The full projection, or null when the source declares itself oversized. */\n  full(): Promise<readonly TItem[] | null>\n  /** A reduced projection of the same material. */\n  capped(): Promise<readonly TItem[]>\n  /** How `capped` reduces, named for the failure message, e.g. `per-attribute cap 1200`. */\n  cappedDescription: string\n}\n\nexport interface PrimeProjectionDelivery {\n  mode: 'inline-json'\n  fetch: 'full' | 'capped'\n  renderedChars: number\n}\n\nexport type PrimeProjectionOutcome<TItem> =\n  | {\n      ok: true\n      items: readonly TItem[]\n      rendered: string\n      delivery: PrimeProjectionDelivery\n    }\n  | { ok: false; reason: string; renderedChars: number }\n\n/**\n * Render, measure, fall back to the capped projection, re-measure, fail loud.\n *\n * Inline is the only delivery prime has, so an oversized trajectory is a\n * refusal rather than a silent truncation: dropping spans would understate the\n * trajectory and the analyst would answer a question about a different run.\n */\nexport async function projectPrimeTrajectory<TItem>(\n  source: PrimeProjectionSource<TItem>,\n  limits: { maxInlineChars: number },\n): Promise<PrimeProjectionOutcome<TItem>> {\n  let fetch: PrimeProjectionDelivery['fetch'] = 'full'\n  let items = await source.full()\n  if (items === null) {\n    fetch = 'capped'\n    items = await source.capped()\n  }\n  let rendered = JSON.stringify(items)\n  if (rendered.length > limits.maxInlineChars && fetch === 'full') {\n    fetch = 'capped'\n    items = await source.capped()\n    rendered = JSON.stringify(items)\n  }\n  if (rendered.length > limits.maxInlineChars) {\n    return {\n      ok: false,\n      reason: `trajectory renders to ${rendered.length} chars even at ${source.cappedDescription}; inline delivery impossible`,\n      renderedChars: rendered.length,\n    }\n  }\n  return {\n    ok: true,\n    items,\n    rendered,\n    delivery: { mode: 'inline-json', fetch, renderedChars: rendered.length },\n  }\n}\n\n// ── Protocol identity ────────────────────────────────────────────────\n\nexport interface PrimeProtocolIdentity {\n  question: string\n  taskDefinition?: string\n  contractLines: readonly string[]\n  repairContractLines: readonly string[]\n  /** Numeric limits the contract states, e.g. row and width caps. */\n  limits: Readonly<Record<string, number>>\n}\n\n/**\n * Digest of everything a consumer can send to the bridge under the prime\n * protocol, recorded per observation so a prime result names the exact contract\n * that produced it.\n *\n * Computed over the ACTUALLY composed contract, so two consumers that both\n * stamp `analyst_id: 'prime'` while asking materially different questions get\n * different digests by construction. That is what makes 'prime' a reproducible\n * claim rather than a label.\n */\nexport function primeProtocolSha256(identity: PrimeProtocolIdentity): string {\n  return createHash('sha256')\n    .update(\n      JSON.stringify({\n        kind: 'prime-analyst-protocol',\n        question: identity.question,\n        taskPrompt: identity.taskDefinition ?? null,\n        outputContract: identity.contractLines,\n        repairContract: buildPrimeRepairPrompt({\n          defect: '<defect>',\n          previousReply: '<previous-reply>',\n          repairContractLines: identity.repairContractLines,\n        }),\n        limits: identity.limits,\n      }),\n    )\n    .digest('hex')\n}\n"],"mappings":"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"}

package/dist/promotion-policy-Ckjhzg_4.d.ts

@@ -1,289 +0,0 @@
-import { R as Scenario, h as GateContext, p as Gate, v as GateResult } from "./types-BnjdJ70P.js";
-import { y as PairedBootstrapResult } from "./statistics-D6Uebe_4.js";
-import { i as PairedMcNemarEvidence, r as PairedDecisionStatistic, t as PairedDecisionMethod } from "./paired-promotion-decision-B6zJ3gYM.js";
-//#region src/campaign/gates/power-preflight.d.ts
-/**
- * Power preflight — "can this budget detect the effect you are hunting?"
- *
- * The failure it prevents (measured, twice): a live prompt-improvement campaign ran
- * 333 sandbox cells over 5.6 hours and produced a +0.08 holdout lift the ship gate
- * (paired bootstrap, CI.low > 0.05) could not distinguish from zero — because at
- * that holdout size and worker variance the MINIMUM DETECTABLE lift was larger than
- * any effect a prompt change plausibly produces. The budget was spent learning what
- * a 30-second calculation on the baseline cells already knew. No eval framework we
- * know of surfaces this; every underpowered improvement run everywhere ends in an
- * uninformative "hold".
- *
- * Model: the ship rule is `CI.low(paired Δ) > deltaThreshold`. Approximating the
- * bootstrap CI as normal, `CI.low ≈ effect − z·sd_Δ/√n`, so the smallest shippable
- * true effect is `MDE = deltaThreshold + z·sd_Δ/√n`. The paired-delta SD is unknown
- * before the candidate exists; we bound it by the zero-correlation case
- * `sd_Δ ≤ √2·sd_baseline` — a CONSERVATIVE (upper) MDE, which is the correct
- * direction for a warning. Pairing is per cell (`scenario:rep`), so reps multiply n.
- *
- * Standalone by design: feed it any baseline composites (a `gate:'none'` run, a
- * live-proof table) BEFORE budgeting the real search; `selfImprove` also attaches
- * it to every result and warns when the run was structurally unable to ship.
- */
-interface PowerPreflightOptions {
-  /** Per-cell baseline composites on the HOLDOUT scenarios (one per scenario:rep cell). */
-  baselineComposites: number[];
-  /** Paired observations the budgeted comparison will produce
-   *  (holdout scenarios × reps). Defaults to `baselineComposites.length`. */
-  pairedN?: number;
-  /** The ship gate's effect-size threshold. Default 0.05 (defaultProductionGate). */
-  deltaThreshold?: number;
-  /** CI confidence the gate uses. Default 0.95. */
-  confidence?: number;
-  /** True when the holdout is scored by the SAME judge/scorer family as the gate
-   *  (selfImprove's default composition — one judge scores everything). Under a
-   *  shared channel, raising paired n reduces only the IDIOSYNCRATIC noise share;
-   *  systematic judge bias is untouched, so the MDE here is a lower bound and the
-   *  only full debiaser is an independent second scoring channel
-   *  (recursive-self-improvement S1c, closed form in EXP-023 P0). Default false. */
-  sharedScorerChannel?: boolean;
-}
-interface PowerPreflight {
-  /** Paired observations the comparison will have. */
-  n: number;
-  /** Baseline per-cell composite standard deviation (the variance the effect must beat). */
-  sd: number;
-  /** Minimum detectable lift: the smallest TRUE effect the gate could ship at this budget. */
-  mde: number;
-  /** Baseline holdout composite mean. */
-  baselineMean: number;
-  /** Headroom to a perfect 1.0 composite (the largest achievable lift on a [0,1] judge). */
-  headroom: number;
-  /** True when even the largest achievable effect (headroom) is below the MDE —
-   *  the run is structurally unable to ship regardless of proposal quality.
-   *  Only asserted for [0,1]-scaled judges (see `scaleAssumed`). */
-  underpowered: boolean;
-  /** True when composites look [0,1]-scaled; headroom/underpowered are only
-   *  meaningful under that convention (0-100 judges get mde/sd/n but no verdict). */
-  scaleAssumed: boolean;
-  deltaThreshold: number;
-  confidence: number;
-  /** Set when the holdout shares the gate's scoring channel: more cells cannot
-   *  buy back systematic judge bias — treat the MDE as a lower bound. */
-  sharedChannelCaveat?: string;
-  /** One actionable sentence for humans and logs. */
-  recommendation: string;
-}
-/** Estimate the minimum detectable lift a paired-holdout improvement run can
- *  ship at a given budget, from the baseline holdout composites — call it BEFORE
- *  spending a search to learn whether the effect you are hunting is even
- *  observable at this holdout size and worker variance. */
-declare function powerPreflight(opts: PowerPreflightOptions): PowerPreflight;
-//#endregion
-//#region src/pareto.d.ts
-/**
- * Pareto frontier — multi-objective optimization over candidate runs.
- *
- * Lifted from ADC pareto.ts and blueprint-agent frontier.ts. When you're
- * trading off (cost, latency, quality) or (passRate, tokenBudget,
- * ttfb), you rarely have a single "winner" — you have a set of
- * non-dominated candidates. This module exposes:
- *
- *   - `paretoFrontier`: filter a set of candidates to the non-dominated ones
- *   - `dominates`: does A dominate B across all objectives?
- *
- * Each objective is declared with a direction: 'maximize' (higher=better)
- * or 'minimize' (lower=better). Candidates are any object; pass an
- * `objective(candidate)` accessor.
- */
-type Direction = 'maximize' | 'minimize';
-interface Objective<T> {
-  /** Stable label used in reports. */
-  name: string;
-  direction: Direction;
-  value: (candidate: T) => number;
-}
-interface ParetoResult<T> {
-  frontier: T[];
-  dominated: T[];
-  /** Index map: frontier[i] dominates each of dominatedBy[i]. */
-  dominanceMap: Array<{
-    dominator: T;
-    dominated: T[];
-  }>;
-}
-/** Does candidate A weakly dominate B — strictly better on at least one objective and no worse on any? */
-declare function dominates<T>(a: T, b: T, objectives: Objective<T>[]): boolean;
-/**
- * Compute the non-dominated frontier. Candidates with NaN/Infinity on any
- * objective are excluded (can't rank them). A candidate enters the frontier
- * iff no other candidate dominates it.
- */
-declare function paretoFrontier<T>(candidates: T[], objectives: Objective<T>[]): ParetoResult<T>;
-/**
- * Weighted-sum scalarisation. Use as a tie-break / single-winner selector
- * when callers don't want to consume a frontier. Each objective contributes
- * its normalised value (0..1 via min-max across the candidate pool) times
- * its weight; missing weights default to 1/N.
- *
- * Direction is honoured automatically — `minimize` axes have their values
- * inverted before scaling so "higher scalar = better" always holds.
- */
-declare function scalarScore<T>(candidates: T[], objectives: Objective<T>[], options?: {
-  weights?: Partial<Record<string, number>>;
-}): Array<{
-  candidate: T;
-  score: number;
-}>;
-/**
- * NSGA-II crowding distance — secondary sort for ties on the frontier.
- *
- * When the Pareto front collapses to a single point (or many candidates tie
- * on dominance), naive selection picks arbitrarily and the population
- * degenerates over generations. NSGA-II preserves diversity by preferring
- * candidates with more empty space around them on the frontier.
- *
- * Returns an array of `{ candidate, distance }` in the SAME order as the
- * input. Higher distance = more isolated = should be preferred when
- * preserving diversity.
- */
-declare function crowdingDistance<T>(candidates: T[], objectives: Objective<T>[]): Array<{
-  candidate: T;
-  distance: number;
-}>;
-/**
- * Pareto frontier with tie-break by crowding distance — the canonical
- * NSGA-II selection step. Returns the frontier sorted by descending crowding
- * distance so callers can `.slice(0, k)` to pick K diverse winners.
- */
-declare function paretoFrontierWithCrowding<T>(candidates: T[], objectives: Objective<T>[]): Array<{
-  candidate: T;
-  distance: number;
-}>;
-//#endregion
-//#region src/campaign/gates/promotion-policy.d.ts
-/** Where an objective's per-cell scalar comes from. `composite` reads the
- *  judge's composite; `dimension` reads a named per-dimension score. */
-type ObjectiveSource = {
-  kind: 'composite';
-} | {
-  kind: 'dimension';
-  dimension: string;
-};
-interface PromotionObjective {
-  /** Stable label used in reports + `contributingGates`. */
-  name: string;
-  source: ObjectiveSource;
-  /** 'maximize' (quality dims) or 'minimize' (error/risk/length dims). Orients
-   *  the paired delta so a positive bootstrap always means "candidate better". */
-  direction: Direction;
-  /** The good-direction paired-delta CI lower bound must EXCEED this to count
-   *  as a significant gain on this axis. Interpreted in the judge's native
-   *  scale. Default 0 (⇒ "confidently better"). */
-  gainThreshold?: number;
-  /** A floor breach (regression) is declared when the good-direction CI lower
-   *  bound is below −floorTolerance, or when the exact small-sample test proves
-   *  a drop past it. When omitted it auto-scales off observed magnitudes
-   *  (0.05 on [0,1], 5 on 0-100), matching `dimensionRegressions`. */
-  floorTolerance?: number;
-}
-/** Per-axis verdict from the good-direction paired bootstrap. */
-type AxisVerdict = 'improved' | 'regressed' | 'flat' | 'few_runs';
-interface AxisEvidence {
-  name: string;
-  source: ObjectiveSource;
-  direction: Direction;
-  /** Paired bootstrap on the GOOD-DIRECTION delta (oriented by `direction`):
-   *  a positive value means the candidate is better on this axis.
-   *
-   *  DIAGNOSTIC on a pass/fail axis: there the verdict is decided on Tango's
-   *  score interval instead, because a percentile bootstrap over a three-atom
-   *  delta lattice is not a valid interval at the nonzero margin `floorTolerance`
-   *  and `gainThreshold` create. `ci` carries the interval that decided. */
-  bootstrap: PairedBootstrapResult;
-  /** Which paired statistic `bootstrap.low`/`.high` bracket. `'mean'` unless the
-   *  caller asked for the median — on a pass/fail axis the median and its whole
-   *  CI are pinned at 0 by tie domination and can see neither a gain nor a
-   *  regression. `bootstrap.median` still carries the median point estimate. */
-  bootstrapStatistic: 'median' | 'mean';
-  /** The interval the axis verdict was actually decided on, good-direction and
-   *  in the axis's native units. */
-  ci: {
-    low: number;
-    high: number;
-  };
-  /** Which estimator produced `ci`. */
-  decisionStatistic: PairedDecisionStatistic;
-  /** McNemar's exact evidence on a pass/fail axis; null otherwise. */
-  mcnemar: PairedMcNemarEvidence | null;
-  /** `ci` has zero width — no evidence in either direction, so the axis is
-   *  neither improved nor regressed however the point estimate sits. */
-  indeterminate: boolean;
-  /** Paired observations contributing to this axis. */
-  n: number;
-  minimumRequired: number;
-  decisionMethod: PairedDecisionMethod;
-  gainThreshold: number;
-  floorTolerance: number;
-  verdict: AxisVerdict;
-}
-interface EvidenceVector {
-  /** One entry per objective — NOTHING averaged across axes. */
-  axes: AxisEvidence[];
-  /** Smallest paired n across axes that produced observations — the binding
-   *  evidence-sufficiency constraint. 0 when no axis produced observations. */
-  minN: number;
-  /** Aggregate per-side cost from the gate context (a constraint input, not a
-   *  CI axis — see the module header). */
-  cost: {
-    candidate: number;
-    baseline: number;
-  };
-}
-/** A promotion strategy: a pure function from the evidence vector to a verdict.
- *  Many policies can run over the same `EvidenceVector` and disagree — that's
- *  the point (competing strategies, shared evidence). */
-type PromotionPolicy = (ev: EvidenceVector) => GateResult;
-interface BuildEvidenceVectorOptions {
-  /** Minimum paired observations before an axis can claim significance; below
-   *  it the axis is `few_runs`. The exact small-sample test may require more
-   *  observations at the selected confidence. */
-  minProductiveRuns?: number;
-  /** Confidence level for every axis bootstrap. Default 0.95. */
-  confidence?: number;
-  /** Bootstrap resamples. Default 2000. */
-  resamples?: number;
-  /** Fixed bootstrap seed for a deterministic, reproducible verdict. Default 1337. */
-  seed?: number;
-  /** Paired statistic every axis CI is computed on. Default `'mean'` — see
-   *  {@link DECISION_PAIRED_DELTA_STATISTIC} for why the median is not. */
-  statistic?: 'mean' | 'median';
-}
-/**
- * The Evidence Bus. For each objective, pair candidate vs baseline by full
- * cellId and bootstrap a CI on the good-direction paired delta. Reuses the
- * exact `pairHoldout` + `pairedBootstrap` machinery the held-out gate uses, so
- * a single source of truth governs pairing granularity + scale handling.
- */
-declare function buildEvidenceVector<TArtifact, TScenario extends Scenario>(ctx: GateContext<TArtifact, TScenario>, objectives: PromotionObjective[], opts?: BuildEvidenceVectorOptions): EvidenceVector;
-/**
- * The default strategy: symmetric multi-objective Pareto significance. Ship iff
- * the candidate weakly dominates the baseline at the confidence level — no axis
- * credibly worse AND ≥1 axis credibly better. Floor breach on any axis → hold
- * (anti-Goodhart, dominates everything). Insufficient evidence on any axis →
- * need_more_work. Statistically equivalent → hold (never ship noise).
- */
-declare const paretoPolicy: PromotionPolicy;
-interface ParetoSignificanceGateOptions extends BuildEvidenceVectorOptions {
-  /** The objective vector. Every axis is both a gain source and a safety floor. */
-  objectives: PromotionObjective[];
-  /** Strategy applied to the evidence vector. Default `paretoPolicy`. Override
-   *  to run a stricter/looser strategy over the SAME bus (competing policies). */
-  policy?: PromotionPolicy;
-  /** Override the gate name in reports. */
-  name?: string;
-}
-/**
- * Wrap the bus + a policy as a `Gate`. Plugs into the existing
- * `runImprovementLoop({ gate })` slot and composes via `composeGate`; default
- * loop behavior is unchanged because consumers opt in by passing this gate.
- */
-declare function paretoSignificanceGate<TArtifact = unknown, TScenario extends Scenario = Scenario>(options: ParetoSignificanceGateOptions): Gate<TArtifact, TScenario>;
-//#endregion
-export { powerPreflight as S, paretoFrontier as _, ObjectiveSource as a, PowerPreflight as b, PromotionPolicy as c, paretoSignificanceGate as d, Direction as f, dominates as g, crowdingDistance as h, EvidenceVector as i, buildEvidenceVector as l, ParetoResult as m, AxisVerdict as n, ParetoSignificanceGateOptions as o, Objective as p, BuildEvidenceVectorOptions as r, PromotionObjective as s, AxisEvidence as t, paretoPolicy as u, paretoFrontierWithCrowding as v, PowerPreflightOptions as x, scalarScore as y };
-//# sourceMappingURL=promotion-policy-Ckjhzg_4.d.ts.map

package/dist/promotion-policy-Ckjhzg_4.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"promotion-policy-Ckjhzg_4.d.ts","names":[],"sources":["../src/campaign/gates/power-preflight.ts","../src/pareto.ts","../src/campaign/gates/promotion-policy.ts"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;UAwBiB;;EAEf;;;EAGA;;EAEA;;EAEA;;;;;;;EAOA;;UAGe;;EAEf;;EAEA;;EAEA;;EAEA;;EAEA;;;;EAIA;;;EAGA;EACA;EACA;;;EAGA;;EAEA;;;;;;iBAec,eAAe,MAAM,wBAAwB;;;;;;;;;;;;;;;;;;KClEjD;UAEK,UAAU;;EAEzB;EACA,WAAW;EACX,QAAQ,WAAW;;UAGJ,aAAa;EAC5B,UAAU;EACV,WAAW;;EAEX,cAAc;IAAQ,WAAW;IAAG,WAAW;;;;iBAIjC,UAAU,GAAG,GAAG,GAAG,GAAG,GAAG,YAAY,UAAU;;;;;;iBAmB/C,eAAe,GAAG,YAAY,KAAK,YAAY,UAAU,OAAO,aAAa;;;;;;;;;;iBA4B7E,YAAY,GAC1B,YAAY,KACZ,YAAY,UAAU,MACtB;EAAW,UAAU,QAAQ;IAC5B;EAAQ,WAAW;EAAG;;;;;;;;;;;;;;iBAyCT,iBAAiB,GAC/B,YAAY,KACZ,YAAY,UAAU,OACrB;EAAQ,WAAW;EAAG;;;;;;;iBA6BT,2BAA2B,GACzC,YAAY,KACZ,YAAY,UAAU,OACrB;EAAQ,WAAW;EAAG;;;;;;KCtHb;EAAoB;;EAAwB;EAAmB;;UAE1D;;EAEf;EACA,QAAQ;;;EAGR,WAAW;;;;EAIX;;;;;EAKA;;;KAIU;UAEK;EACf;EACA,QAAQ;EACR,WAAW;;;;;;;;EAQX,WAAW;;;;;EAKX;;;EAGA;IAAM;IAAa;;;EAEnB,mBAAmB;;EAEnB,SAAS;;;EAGT;;EAEA;EACA;EACA,gBAAgB;EAChB;EACA;EACA,SAAS;;UAGM;;EAEf,MAAM;;;EAGN;;;EAGA;IAAQ;IAAmB;;;;;;KAMjB,mBAAmB,IAAI,mBAAmB;UAErC;;;;EAIf;;EAEA;;EAEA;;EAEA;;;EAGA;;;;;;;;iBASc,oBAAoB,WAAW,kBAAkB,UAC/D,KAAK,YAAY,WAAW,YAC5B,YAAY,sBACZ,OAAM,6BACL;;;;;;;;cAwIU,cAAc;UAiFV,sCAAsC;;EAErD,YAAY;;;EAGZ,SAAS;;EAET;;;;;;;iBAQc,uBAAuB,qBAAqB,kBAAkB,WAAW,UACvF,SAAS,gCACR,KAAK,WAAW"}