@tangle-network/agent-eval 0.216.0 → 0.216.1

package/dist/{store-tool-spans-DR1SrCLK.d.ts → store-tool-spans-DdCSPa7C.d.ts}

@@ -1,149 +1,13 @@
+import { a as CostLedgerHandle } from "./cost-ledger-Jk62OBfF.js";
 import { r as CaptureIntegrityError } from "./errors-DEE6u6ot.js";
-import { c as CostLedgerHandle } from "./cost-ledger-CO7UyEcQ.js";
 import { C as ToolSpan } from "./schema-2g7trUwH.js";
-import { d as RunTokenUsage } from "./run-record-D1Hw-Jml.js";
-import { $ as DatasetOverview, J as SpanSourceReader, X as TraceAnalysisStore, Z as TraceAnalysisStoreContext, a as AnalystFinding, ct as TraceAnalystSpan, ft as ViewSpansResult, m as AnalystUsageReceipt, mt as ViewTraceResult, nt as SearchSpanResult, rt as SearchTraceResult, st as TraceAnalystFilters, tt as QueryTracesPage } from "./types-oKRhQAde.js";
-import { et as ProviderRedactor, rt as RawProviderSink } from "./types-DBZ7keha.js";
+import { d as RunTokenUsage } from "./run-record-C1E24G2A.js";
+import { $ as DatasetOverview, J as SpanSourceReader, X as TraceAnalysisStore, Z as TraceAnalysisStoreContext, a as AnalystFinding, ct as TraceAnalystSpan, ft as ViewSpansResult, m as AnalystUsageReceipt, mt as ViewTraceResult, nt as SearchSpanResult, rt as SearchTraceResult, st as TraceAnalystFilters, tt as QueryTracesPage } from "./types-C1tnkEgM.js";
+import { X as RawProviderSink, q as ProviderRedactor } from "./types-C02qtnG8.js";
 import { i as SearchArtifactRef } from "./search-ledger-types-p2xKfiDJ.js";
 import { s as TraceStore } from "./store-C4avFjIi.js";
-import { a as TraceAnalystLimits, i as TraceAnalysisEngineResult, n as TraceAnalysisEngine } from "./engine-C_zNWfM8.js";
-import { t as TraceToolGroupName } from "./tool-groups-mcxOXVlb.js";
-//#region src/trace/extract-usage.d.ts
-type ExtractedUsage = RunTokenUsage;
-type SseUsageMode = 'cumulative' | 'delta';
-interface ExtractUsageFromSseOptions {
-  /** Provider usage events are cumulative snapshots unless explicitly marked as deltas. */
-  mode?: SseUsageMode;
-}
-/**
- * Pull `{ input, output, cached?, cacheWrite? }` from a parsed response
- * body. Accepts a top-level `usage` object (the common case) or a body that IS
- * the usage object. Returns null only when none of those categories is present.
- */
-declare function extractUsage(body: unknown): ExtractedUsage | null;
-/**
- * Extract token usage from a complete SSE response body using the shared SSE
- * frame parser. Cumulative snapshots are the fail-safe default because summing
- * them inflates billing; callers with explicit delta events opt into `mode: 'delta'`.
- */
-declare function extractUsageFromSse(text: string, options?: ExtractUsageFromSseOptions): ExtractedUsage | null;
-/**
- * Extract usage from an HTTP `Response` without consuming the caller's body:
- * clones, reads the text, and tries the JSON parser first, then the SSE
- * accumulator. Best-effort — returns null on any read/parse miss so a usage tee
- * never takes down the underlying call.
- */
-declare function extractUsageFromResponse(response: Response, sseOptions?: ExtractUsageFromSseOptions): Promise<ExtractedUsage | null>;
-//#endregion
-//#region src/trace/capture-fetch.d.ts
-interface CaptureFetchContext {
-  /** Logical run id stamped on every captured event. Required — without it
-   *  the raw events can't be paired with their parent `Run`. */
-  runId: string;
-  /** Optional logical span id (enables span-level sink filtering). */
-  spanId?: string;
-  /** Resolved base URL (normalised, no trailing slash). Used for the event's
-   *  `baseUrl` and for endpoint-path extraction. */
-  baseUrl: string;
-  /** Model id the caller intends to invoke. Stamped on every event. */
-  model: string;
-  /** Provider override. When omitted, `providerFromBaseUrl(baseUrl)`. */
-  provider?: string;
-}
-interface CaptureFetchOptions {
-  /** Override the capture-time redactor. Default `defaultProviderRedactor`. */
-  redactor?: ProviderRedactor;
-  /** Cap on captured response-body bytes; beyond it the body is truncated and
-   *  `body_truncated` is added to `redactedFields`. Default 2 MiB. */
-  responseBodyByteCap?: number;
-  /** When true, a sink-write failure propagates to the caller. Default false
-   *  — capture is best-effort so a sink failure never kills the LLM call. */
-  failClosed?: boolean;
-  /**
-   * Invoked with the token usage parsed off each successful response (JSON or
-   * SSE), keyed by the captured context. Lets a caller fold usage → cost without
-   * re-cloning the response themselves. Not called when the response carries no
-   * usage. Best-effort: a throw here is swallowed (it never kills the LLM call)
-   * unless `failClosed` is set.
-   */
-  onUsage?: (usage: ExtractedUsage, ctx: CaptureFetchContext) => void;
-  /** How repeated SSE usage events should be reconciled. Default `cumulative`. */
-  sseUsageMode?: SseUsageMode;
-}
-declare function captureFetchToRawSink(fetch: typeof globalThis.fetch, sink: RawProviderSink, ctx: CaptureFetchContext, opts?: CaptureFetchOptions): typeof globalThis.fetch;
-//#endregion
-//#region src/trace/otel.d.ts
-declare const OTEL_AGENT_EVAL_SCOPE: {
-  name: string;
-  version: string;
-};
-interface OtlpSpan {
-  traceId: string;
-  spanId: string;
-  parentSpanId?: string;
-  name: string;
-  kind: number;
-  startTimeUnixNano: string;
-  endTimeUnixNano: string;
-  attributes: Array<{
-    key: string;
-    value: {
-      stringValue?: string;
-      intValue?: string;
-      doubleValue?: number;
-      boolValue?: boolean;
-    };
-  }>;
-  events?: Array<{
-    timeUnixNano: string;
-    name: string;
-    attributes?: OtlpSpan['attributes'];
-  }>;
-  status?: {
-    code: number;
-    message?: string;
-  };
-}
-interface OtlpResourceSpans {
-  resource: {
-    attributes: OtlpSpan['attributes'];
-  };
-  scopeSpans: Array<{
-    scope: typeof OTEL_AGENT_EVAL_SCOPE;
-    spans: OtlpSpan[];
-  }>;
-}
-interface OtlpExport {
-  resourceSpans: OtlpResourceSpans[];
-}
-/** Export a single run's spans + events in OTLP/JSON. */
-declare function exportRunAsOtlp(store: TraceStore, runId: string, resourceAttrs?: Record<string, string | number | boolean>): Promise<OtlpExport>;
-//#endregion
-//#region src/trace/otlp-flat.d.ts
-type OtlpStatusCode = 'STATUS_CODE_OK' | 'STATUS_CODE_ERROR' | 'STATUS_CODE_UNSET';
-interface OtlpFlatLine {
-  trace_id: string;
-  span_id: string;
-  parent_span_id: string | null;
-  name: string;
-  kind: string;
-  start_time: string;
-  end_time: string;
-  status: {
-    code: OtlpStatusCode;
-    message?: string;
-  };
-  resource: {
-    attributes: Record<string, unknown>;
-  };
-  attributes: Record<string, unknown>;
-  events?: Array<{
-    name: string;
-    timeUnixNano?: string;
-    attributes?: Record<string, unknown>;
-  }>;
-}
-//#endregion
+import { a as TraceAnalystLimits, i as TraceAnalysisEngineResult, n as TraceAnalysisEngine } from "./engine-3A_4jOlI.js";
+import { t as TraceToolGroupName } from "./tool-groups-C3NEcdCM.js";
 //#region src/trace-analyst/analyst.d.ts
 interface AnalyzeTracesInput {
   question: string;
@@ -300,7 +164,54 @@ declare function scoreTraceInsightReadiness(context: TraceInsightContext): Trace
 declare function defaultTraceInsightPanel(): TraceInsightPanelRole[];
 declare function buildTraceInsightPrompt(input: TraceInsightPromptInput): string;
 //#endregion
-//#region src/trace-analyst/store-otlp.d.ts
+//#region src/trace/otel.d.ts
+declare const OTEL_AGENT_EVAL_SCOPE: {
+  name: string;
+  version: string;
+};
+interface OtlpSpan {
+  traceId: string;
+  spanId: string;
+  parentSpanId?: string;
+  name: string;
+  kind: number;
+  startTimeUnixNano: string;
+  endTimeUnixNano: string;
+  attributes: Array<{
+    key: string;
+    value: {
+      stringValue?: string;
+      intValue?: string;
+      doubleValue?: number;
+      boolValue?: boolean;
+    };
+  }>;
+  events?: Array<{
+    timeUnixNano: string;
+    name: string;
+    attributes?: OtlpSpan['attributes'];
+  }>;
+  status?: {
+    code: number;
+    message?: string;
+  };
+}
+interface OtlpResourceSpans {
+  resource: {
+    attributes: OtlpSpan['attributes'];
+  };
+  scopeSpans: Array<{
+    scope: typeof OTEL_AGENT_EVAL_SCOPE;
+    spans: OtlpSpan[];
+  }>;
+}
+interface OtlpExport {
+  resourceSpans: OtlpResourceSpans[];
+}
+/** Export a single run's spans + events in OTLP/JSON. */
+declare function exportRunAsOtlp(store: TraceStore, runId: string, resourceAttrs?: Record<string, string | number | boolean>): Promise<OtlpExport>;
+//#endregion
+//#region src/trace-analyst/store-otlp-buffered.d.ts
 interface ToolSpansToTraceAnalysisStoreOptions {
   /** Authorized original-record lookup, exposed only when supplied. */
   sourceReader?: SpanSourceReader;
@@ -313,21 +224,6 @@ interface ToolSpansToTraceAnalysisStoreOptions {
   /** Override the per-match text budget. */
   perMatchTextBudget?: number;
 }
-/** Budgets and authorized source access shared by canonical span-record stores. */
-type SpanRecordsToTraceAnalysisStoreOptions = ToolSpansToTraceAnalysisStoreOptions;
-type BufferedTraceStoreOptions = ToolSpansToTraceAnalysisStoreOptions;
-interface OtlpFileTraceStoreOptions extends BufferedTraceStoreOptions {
-  /** Path to the OTLP-JSONL file. */
-  path: string;
-  /**
-   * Hard ceiling on the trace file size in bytes. The store reads the
-   * whole file into one Buffer and indexes it in memory, so an
-   * unbounded file OOMs the process. Above this size the store fails
-   * loud with `TraceFileTooLargeError` instead of degrading silently.
-   * Default 256 MiB.
-   */
-  maxFileBytes?: number;
-}
 declare abstract class BufferedTraceStore implements TraceAnalysisStore {
   readonly readSpanSource?: SpanSourceReader;
   private readonly perAttributeViewBudget;
@@ -338,7 +234,7 @@ declare abstract class BufferedTraceStore implements TraceAnalysisStore {
   private indexTask?;
   private bufferValue?;
   private bufferTask?;
-  constructor(opts: BufferedTraceStoreOptions);
+  constructor(opts: ToolSpansToTraceAnalysisStoreOptions);
   hasTrace(trace_id: string, context?: TraceAnalysisStoreContext): Promise<boolean>;
   hasSpans(opts: {
     trace_id: string;
@@ -386,6 +282,22 @@ declare abstract class BufferedTraceStore implements TraceAnalysisStore {
   private buildOversizedSummary;
   private scanSpanForMatches;
 }
+//#endregion
+//#region src/trace-analyst/store-otlp.d.ts
+interface OtlpFileTraceStoreOptions extends ToolSpansToTraceAnalysisStoreOptions {
+  /** Path to the OTLP-JSONL file. */
+  path: string;
+  /**
+   * Hard ceiling on the trace file size in bytes. The store reads the
+   * whole file into one Buffer and indexes it in memory, so an
+   * unbounded file OOMs the process. Above this size the store fails
+   * loud with `TraceFileTooLargeError` instead of degrading silently.
+   * Default 256 MiB.
+   */
+  maxFileBytes?: number;
+}
+/** Budgets and authorized source access shared by canonical span-record stores. */
+type SpanRecordsToTraceAnalysisStoreOptions = ToolSpansToTraceAnalysisStoreOptions;
 declare class OtlpFileTraceStore extends BufferedTraceStore {
   private readonly path;
   private readonly maxFileBytes;
@@ -404,6 +316,95 @@ declare function spanRecordsToTraceAnalysisStore(records: readonly TraceAnalystS
 /** Build the bounded trace store directly from OpenInference JSONL text. */
 declare function otlpTextToTraceAnalysisStore(text: string, opts?: ToolSpansToTraceAnalysisStoreOptions): TraceAnalysisStore;
 //#endregion
+//#region src/trace/extract-usage.d.ts
+type ExtractedUsage = RunTokenUsage;
+type SseUsageMode = 'cumulative' | 'delta';
+interface ExtractUsageFromSseOptions {
+  /** Provider usage events are cumulative snapshots unless explicitly marked as deltas. */
+  mode?: SseUsageMode;
+}
+/**
+ * Pull `{ input, output, cached?, cacheWrite? }` from a parsed response
+ * body. Accepts a top-level `usage` object (the common case) or a body that IS
+ * the usage object. Returns null only when none of those categories is present.
+ */
+declare function extractUsage(body: unknown): ExtractedUsage | null;
+/**
+ * Extract token usage from a complete SSE response body using the shared SSE
+ * frame parser. Cumulative snapshots are the fail-safe default because summing
+ * them inflates billing; callers with explicit delta events opt into `mode: 'delta'`.
+ */
+declare function extractUsageFromSse(text: string, options?: ExtractUsageFromSseOptions): ExtractedUsage | null;
+/**
+ * Extract usage from an HTTP `Response` without consuming the caller's body:
+ * clones, reads the text, and tries the JSON parser first, then the SSE
+ * accumulator. Best-effort — returns null on any read/parse miss so a usage tee
+ * never takes down the underlying call.
+ */
+declare function extractUsageFromResponse(response: Response, sseOptions?: ExtractUsageFromSseOptions): Promise<ExtractedUsage | null>;
+//#endregion
+//#region src/trace/otlp-flat.d.ts
+type OtlpStatusCode = 'STATUS_CODE_OK' | 'STATUS_CODE_ERROR' | 'STATUS_CODE_UNSET';
+interface OtlpFlatLine {
+  trace_id: string;
+  span_id: string;
+  parent_span_id: string | null;
+  name: string;
+  kind: string;
+  start_time: string;
+  end_time: string;
+  status: {
+    code: OtlpStatusCode;
+    message?: string;
+  };
+  resource: {
+    attributes: Record<string, unknown>;
+  };
+  attributes: Record<string, unknown>;
+  events?: Array<{
+    name: string;
+    timeUnixNano?: string;
+    attributes?: Record<string, unknown>;
+  }>;
+}
+//#endregion
+//#region src/trace/capture-fetch.d.ts
+interface CaptureFetchContext {
+  /** Logical run id stamped on every captured event. Required — without it
+   *  the raw events can't be paired with their parent `Run`. */
+  runId: string;
+  /** Optional logical span id (enables span-level sink filtering). */
+  spanId?: string;
+  /** Resolved base URL (normalised, no trailing slash). Used for the event's
+   *  `baseUrl` and for endpoint-path extraction. */
+  baseUrl: string;
+  /** Model id the caller intends to invoke. Stamped on every event. */
+  model: string;
+  /** Provider override. When omitted, `providerFromBaseUrl(baseUrl)`. */
+  provider?: string;
+}
+interface CaptureFetchOptions {
+  /** Override the capture-time redactor. Default `defaultProviderRedactor`. */
+  redactor?: ProviderRedactor;
+  /** Cap on captured response-body bytes; beyond it the body is truncated and
+   *  `body_truncated` is added to `redactedFields`. Default 2 MiB. */
+  responseBodyByteCap?: number;
+  /** When true, a sink-write failure propagates to the caller. Default false
+   *  — capture is best-effort so a sink failure never kills the LLM call. */
+  failClosed?: boolean;
+  /**
+   * Invoked with the token usage parsed off each successful response (JSON or
+   * SSE), keyed by the captured context. Lets a caller fold usage → cost without
+   * re-cloning the response themselves. Not called when the response carries no
+   * usage. Best-effort: a throw here is swallowed (it never kills the LLM call)
+   * unless `failClosed` is set.
+   */
+  onUsage?: (usage: ExtractedUsage, ctx: CaptureFetchContext) => void;
+  /** How repeated SSE usage events should be reconciled. Default `cumulative`. */
+  sseUsageMode?: SseUsageMode;
+}
+declare function captureFetchToRawSink(fetch: typeof globalThis.fetch, sink: RawProviderSink, ctx: CaptureFetchContext, opts?: CaptureFetchOptions): typeof globalThis.fetch;
+//#endregion
 //#region src/trace-analyst/store-tool-spans.d.ts
 /** Missing tool spans cannot distinguish a tool-free run from broken capture. */
 declare class ToolTraceMissingError extends CaptureIntegrityError {
@@ -415,5 +416,5 @@ declare class ToolTraceMissingError extends CaptureIntegrityError {
  */
 declare function toolSpansToTraceAnalysisStore(spans: readonly ToolSpan[] | null | undefined, options?: ToolSpansToTraceAnalysisStoreOptions): TraceAnalysisStore;
 //#endregion
-export { scoreTraceInsightReadiness as A, OtlpSpan as B, describeTraceInsightScope as C, isTraceInsightAttribution as D, isTraceInsightArtifact as E, analyzeTraces as F, ExtractUsageFromSseOptions as G, CaptureFetchContext as H, OtlpFlatLine as I, extractUsage as J, ExtractedUsage as K, OTEL_AGENT_EVAL_SCOPE as L, AnalyzeTracesInput as M, AnalyzeTracesOptions as N, isTraceInsightEvidence as O, AnalyzeTracesResult as P, OtlpExport as R, defaultTraceInsightPanel as S, inferDomainKeywords as T, CaptureFetchOptions as U, exportRunAsOtlp as V, captureFetchToRawSink as W, extractUsageFromSse as X, extractUsageFromResponse as Y, TraceInsightReadiness as _, SpanRecordsToTraceAnalysisStoreOptions as a, buildTraceInsightContext as b, spanRecordsToTraceAnalysisStore as c, TraceInsightEvidence as d, TraceInsightFinding as f, TraceInsightQuestion as g, TraceInsightQualityGate as h, OtlpFileTraceStoreOptions as i, tokenizeDomainWords as j, planTraceInsightQuestions as k, TraceInsightAttribution as l, TraceInsightPromptInput as m, toolSpansToTraceAnalysisStore as n, ToolSpansToTraceAnalysisStoreOptions as o, TraceInsightPanelRole as p, SseUsageMode as q, OtlpFileTraceStore as r, otlpTextToTraceAnalysisStore as s, ToolTraceMissingError as t, TraceInsightContext as u, TraceInsightSuite as v, domainEvidencePattern as w, buildTraceInsightPrompt as x, TraceInsightTask as y, OtlpResourceSpans as z };
-//# sourceMappingURL=store-tool-spans-DR1SrCLK.d.ts.map
+export { TraceInsightQualityGate as A, inferDomainKeywords as B, exportRunAsOtlp as C, TraceInsightFinding as D, TraceInsightEvidence as E, buildTraceInsightContext as F, scoreTraceInsightReadiness as G, isTraceInsightAttribution as H, buildTraceInsightPrompt as I, AnalyzeTracesOptions as J, tokenizeDomainWords as K, defaultTraceInsightPanel as L, TraceInsightReadiness as M, TraceInsightSuite as N, TraceInsightPanelRole as O, TraceInsightTask as P, describeTraceInsightScope as R, OtlpSpan as S, TraceInsightContext as T, isTraceInsightEvidence as U, isTraceInsightArtifact as V, planTraceInsightQuestions as W, analyzeTraces as X, AnalyzeTracesResult as Y, spanRecordsToTraceAnalysisStore as _, captureFetchToRawSink as a, OtlpExport as b, ExtractedUsage as c, extractUsageFromResponse as d, extractUsageFromSse as f, otlpTextToTraceAnalysisStore as g, SpanRecordsToTraceAnalysisStoreOptions as h, CaptureFetchOptions as i, TraceInsightQuestion as j, TraceInsightPromptInput as k, SseUsageMode as l, OtlpFileTraceStoreOptions as m, toolSpansToTraceAnalysisStore as n, OtlpFlatLine as o, OtlpFileTraceStore as p, AnalyzeTracesInput as q, CaptureFetchContext as r, ExtractUsageFromSseOptions as s, ToolTraceMissingError as t, extractUsage as u, ToolSpansToTraceAnalysisStoreOptions as v, TraceInsightAttribution as w, OtlpResourceSpans as x, OTEL_AGENT_EVAL_SCOPE as y, domainEvidencePattern as z };
+//# sourceMappingURL=store-tool-spans-DdCSPa7C.d.ts.map

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

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

package/dist/storyboard/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","names":[],"sources":["../../src/storyboard/code-edit.ts","../../src/storyboard/index.ts"],"mappings":";;;iBAuBiB;;EAEf;EACA;EACA;;EAEA;;;EAGA;EACA;EACA;EACA;EACA;;;wBA6Dc,iBAAiB,MAAM,OAAO;;wBAwB9B,iBAAiB,gBAAgB,SAAS;;;wBAS1C,uBACd,YAAY,YACZ,gBAAgB,SACf;EAAQ,OAAO;EAAO,MAAM;;;;;wBAgBf,kBAAkB,MAAM;iBAiBvB;;EAEf;;EAEA;;EAEA;;;;;;;;;wBAUc,wBACd,iBAAiB,kBAAkB,YACnC,OAAM;;;;YCjKI;;;YAmBA;EACN;EAAoB;EAAa;;EACjC;EAAiB;EAAc;EAAiB;;EAChD;EAAc;EAAc;;EAC5B;EAAc;EAAc;;EAC5B;EAAkB;EAAiB;;EAEnC;EACA;EACA;EACA;EACA;EACA;;EAEA;EAAe;;EACf;;iBAEW;EACf,MAAM;;EAEN;;EAEA;;EAEA,QAAQ;;EAER;;EAEA;EACA;EACA;;iBAGe;;EAEf;;;;;;;;;;wBAiTc,uBACd,gBAAgB,QAChB,OAAM,gBACL;YA8CS;iBAiBK;EACf,WAAW;EACX;EACA;;EAEA,QAAQ;EACR;EACA;;iBAGe;EACf;EACA;EACA,QAAQ;;iBAGO;;EAEf;;EAEA;;;;;;;wBAkCc,kBACd,iBAAiB,iBACjB,OAAM,iBACL;;wBA4Ja,yBAAyB,YAAY;iBAwBpC;;EAEf;;;;;;;;;wBAUc,qBAAqB,YAAY,YAAY,OAAM"}
+{"version":3,"file":"index.d.ts","names":[],"sources":["../../src/storyboard/code-edit.ts","../../src/storyboard/index.ts"],"mappings":";;;iBAuBiB;;EAEf;EACA;EACA;;EAEA;;;EAGA;EACA;EACA;EACA;EACA;;;wBA6Dc,iBAAiB,MAAM,OAAO;;wBAwB9B,iBAAiB,gBAAgB,SAAS;;;wBAS1C,uBACd,YAAY,YACZ,gBAAgB,SACf;EAAQ,OAAO;EAAO,MAAM;;;;;wBAgBf,kBAAkB,MAAM;iBAiBvB;;EAEf;;EAEA;;EAEA;;;;;;;;;wBAUc,wBACd,iBAAiB,kBAAkB,YACnC,OAAM;;;;YChKI;;;YAmBA;EACN;EAAoB;EAAa;;EACjC;EAAiB;EAAc;EAAiB;;EAChD;EAAc;EAAc;;EAC5B;EAAc;EAAc;;EAC5B;EAAkB;EAAiB;;EAEnC;EACA;EACA;EACA;EACA;EACA;;EAEA;EAAe;;EACf;;iBAEW;EACf,MAAM;;EAEN;;EAEA;;EAEA,QAAQ;;EAER;;EAEA;EACA;EACA;;iBAGe;;EAEf;;;;;;;;;;wBAiTc,uBACd,gBAAgB,QAChB,OAAM,gBACL;YA8CS;iBAiBK;EACf,WAAW;EACX;EACA;;EAEA,QAAQ;EACR;EACA;;iBAGe;EACf;EACA;EACA,QAAQ;;iBAGO;;EAEf;;EAEA;;;;;;;wBAkCc,kBACd,iBAAiB,iBACjB,OAAM,iBACL;;wBAoJa,yBAAyB,YAAY;iBAwBpC;;EAEf;;;;;;;;;wBAUc,qBAAqB,YAAY,YAAY,OAAM"}

package/dist/storyboard/index.js

@@ -1,3 +1,4 @@
+import { t as escapeHtml } from "../reporting-html-Kvlc8oMt.js";
 //#region src/storyboard/code-edit.ts
 const EDIT_TOOLS = /(edit|write|patch|apply|str_replace|create.*file|save|insert|update.*file|multi_edit)/i;
 function languageOf(path) {
@@ -227,6 +228,25 @@ function renderCodeAnimationHtml(source, opts = {}) {
 }
 //#endregion
 //#region src/storyboard/index.ts
+/**
+* Storyboard — compile a raw agent trace into a small set of meaningful scenes,
+* then render them as a shareable, watchable replay.
+*
+*   Span[] → SemanticEvent[] → Storyboard{scenes} → { markdown | html }
+*
+* The trace is the source of truth; the storyboard is the IR; markdown/html
+* (and, in a consumer package, Remotion/MP4) are compiled targets. Everything
+* here is PURE — same spans in, same bytes out (no clock/random) — so a run's
+* replay is deterministic and diffable.
+*
+* Crucially, every scene carries a modality-typed VISUAL extracted from the
+* span — a browser/computer screenshot, a code diff, a terminal command +
+* output, file content, an API request/response, or reasoning prose — so no
+* matter what the agent did, the replay SHOWS it, not just narrates it. The
+* reducer is rules-based; an LLM pass can refine titles/summaries later, but
+* the structure + visuals do not depend on one. Renderers that need a browser
+* (Remotion, React) live in consumers; this module only emits strings.
+*/
 function str(v) {
 	return typeof v === "string" && v.length > 0 ? v : void 0;
 }
@@ -648,9 +668,6 @@ function mmss(ms) {
 function truncate(s, max) {
 	return s.length <= max ? s : `${s.slice(0, Math.max(0, max - 1))}…`;
 }
-function escapeHtml(s) {
-	return s.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;").replace(/"/g, "&quot;");
-}
 /** A short modality tag for the markdown shot list. */
 function visualMarkdown(v) {
 	switch (v.type) {