@warlock.js/ai-panoptic 4.8.2 → 4.9.1

package/esm/exporters/utils/walk-spans.d.mts.map

@@ -1 +1 @@
-{"version":3,"file":"walk-spans.d.mts","names":[],"sources":["../../../../../../../../@warlock.js/ai-panoptic/src/exporters/utils/walk-spans.ts"],"mappings":";;;;;AAcA;;;;;;;;;iBAAiB,SAAA,CAAU,IAAA,EAAM,SAAA,GAAY,SAAA,CAAU,SAAA"}
+{"version":3,"file":"walk-spans.d.mts","names":[],"sources":["../../../../../../../../ai-panoptic/src/exporters/utils/walk-spans.ts"],"mappings":";;;;;AAcA;;;;;;;;;iBAAiB,SAAA,CAAU,IAAA,EAAM,SAAA,GAAY,SAAA,CAAU,SAAA"}

package/esm/exporters/utils/walk-spans.mjs

@@ -1,4 +1,4 @@
-//#region ../@warlock.js/ai-panoptic/src/exporters/utils/walk-spans.ts
+//#region ../ai-panoptic/src/exporters/utils/walk-spans.ts
 /**
 * Depth-first pre-order traversal of a {@link TraceSpan} tree, yielding
 * the root first and then each descendant in `children` (invocation)

package/esm/exporters/utils/walk-spans.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"walk-spans.mjs","names":[],"sources":["../../../../../../../../@warlock.js/ai-panoptic/src/exporters/utils/walk-spans.ts"],"sourcesContent":["import type { TraceSpan } from \"../../contracts\";\n\n/**\n * Depth-first pre-order traversal of a {@link TraceSpan} tree, yielding\n * the root first and then each descendant in `children` (invocation)\n * order. Exporters that emit a flat span stream — OpenTelemetry, the\n * console table — walk the tree once with this instead of re-writing the\n * recursion in every exporter.\n *\n * @example\n * for (const span of walkSpans(trace.root)) {\n *   emit(span);\n * }\n */\nexport function* walkSpans(root: TraceSpan): Generator<TraceSpan> {\n  yield root;\n\n  for (const child of root.children) {\n    yield* walkSpans(child);\n  }\n}\n"],"mappings":";;;;;;;;;;;;;AAcA,UAAiB,UAAU,MAAuC;CAChE,MAAM;CAEN,KAAK,MAAM,SAAS,KAAK,UACvB,OAAO,UAAU,KAAK;AAE1B"}
+{"version":3,"file":"walk-spans.mjs","names":[],"sources":["../../../../../../../../ai-panoptic/src/exporters/utils/walk-spans.ts"],"sourcesContent":["import type { TraceSpan } from \"../../contracts\";\n\n/**\n * Depth-first pre-order traversal of a {@link TraceSpan} tree, yielding\n * the root first and then each descendant in `children` (invocation)\n * order. Exporters that emit a flat span stream — OpenTelemetry, the\n * console table — walk the tree once with this instead of re-writing the\n * recursion in every exporter.\n *\n * @example\n * for (const span of walkSpans(trace.root)) {\n *   emit(span);\n * }\n */\nexport function* walkSpans(root: TraceSpan): Generator<TraceSpan> {\n  yield root;\n\n  for (const child of root.children) {\n    yield* walkSpans(child);\n  }\n}\n"],"mappings":";;;;;;;;;;;;;AAcA,UAAiB,UAAU,MAAuC;CAChE,MAAM;CAEN,KAAK,MAAM,SAAS,KAAK,UACvB,OAAO,UAAU,KAAK;AAE1B"}

package/esm/panoptic/panoptic-middleware.d.mts

@@ -1,7 +1,7 @@
 import { CollectorContract } from "../contracts/collector.contract.mjs";
 import { AgentMiddleware } from "@warlock.js/ai";
 
-//#region ../@warlock.js/ai-panoptic/src/panoptic/panoptic-middleware.d.ts
+//#region ../ai-panoptic/src/panoptic/panoptic-middleware.d.ts
 /**
  * Build an {@link AgentMiddleware} that feeds a collector from the
  * `execute`- and `supervisor`-level hooks. An alternative wiring to event

package/esm/panoptic/panoptic-middleware.d.mts.map

@@ -1 +1 @@
-{"version":3,"file":"panoptic-middleware.d.mts","names":[],"sources":["../../../../../../../@warlock.js/ai-panoptic/src/panoptic/panoptic-middleware.ts"],"mappings":";;;;;;AAiCA;;;;;;;;;AAGkB;;;;;;;;;;;;;;;;;;;iBAHF,wBAAA,CACd,SAAA,EAAW,iBAAA,EACX,IAAA,YACC,eAAe"}
+{"version":3,"file":"panoptic-middleware.d.mts","names":[],"sources":["../../../../../../../ai-panoptic/src/panoptic/panoptic-middleware.ts"],"mappings":";;;;;;AAiCA;;;;;;;;;AAGkB;;;;;;;;;;;;;;;;;;;iBAHF,wBAAA,CACd,SAAA,EAAW,iBAAA,EACX,IAAA,YACC,eAAe"}

package/esm/panoptic/panoptic-middleware.mjs

@@ -1,4 +1,4 @@
-//#region ../@warlock.js/ai-panoptic/src/panoptic/panoptic-middleware.ts
+//#region ../ai-panoptic/src/panoptic/panoptic-middleware.ts
 /**
 * Build an {@link AgentMiddleware} that feeds a collector from the
 * `execute`- and `supervisor`-level hooks. An alternative wiring to event

package/esm/panoptic/panoptic-middleware.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"panoptic-middleware.mjs","names":[],"sources":["../../../../../../../@warlock.js/ai-panoptic/src/panoptic/panoptic-middleware.ts"],"sourcesContent":["import type { AgentMiddleware } from \"@warlock.js/ai\";\nimport type { CollectorContract } from \"../contracts/collector.contract\";\n\n/**\n * Build an {@link AgentMiddleware} that feeds a collector from the\n * `execute`- and `supervisor`-level hooks. An alternative wiring to event\n * subscription for apps that already compose cross-cutting concerns\n * through the agent middleware pipeline (`[cache, budget, guardrail,\n * observability]`). Declaring both hook maps lets a single middleware\n * object work uniformly on agents (which fire the `execute` map) and\n * supervisors (which fire the `supervisor` map) — registering it on a\n * supervisor would otherwise install and collect nothing silently.\n *\n * Both terminal paths are covered on each surface:\n * - `after` — fires on a run that produced a result. A run can complete\n *   with `result.error` populated (the engine still calls `after`), so\n *   the report AND the envelope error are collected; the error type and\n *   message land on the root span.\n * - `onError` — fires when the run threw before assembling a result. The\n *   error carries the partial result's report on its envelope; when\n *   present it is collected, with the error itself threaded onto the\n *   root span so failed runs still produce a trace.\n *\n * The hooks never return a value, so they never mutate the agent's /\n * supervisor's result. The `collect` call is fire-and-forget relative to\n * the run — the collector isolates exporter failures internally, and we\n * additionally swallow any rejection here so an observability fault can\n * never surface on the run's hot path.\n *\n * @param collector - the collector traces are fed into.\n * @param name - stable middleware name (kebab-case). Defaults to\n *   `\"panoptic\"`.\n */\nexport function createPanopticMiddleware(\n  collector: CollectorContract,\n  name = \"panoptic\",\n): AgentMiddleware {\n  const collectReport = (report: unknown, rootError?: unknown): void => {\n    if (!isReport(report)) {\n      return;\n    }\n\n    void collector.collect(report, rootError).catch(() => {\n      // Swallow — the collector already isolates exporter failures; this\n      // guard keeps an observability fault off the run's hot path.\n    });\n  };\n\n  const onResult = (result: unknown): void => {\n    // A run can complete with `result.error` populated (`after` still\n    // fires); thread that envelope error onto the root span.\n    collectReport(\n      (result as { report?: unknown }).report,\n      (result as { error?: unknown }).error,\n    );\n  };\n\n  const onError = (error: unknown): void => {\n    // A failed run's report rides on the error envelope when the engine\n    // built one before throwing; collect it so failures trace, threading\n    // the error itself onto the root span.\n    collectReport((error as { report?: unknown }).report, error);\n  };\n\n  const terminalHooks = {\n    after(_ctx: unknown, result: unknown) {\n      onResult(result);\n    },\n    onError(_ctx: unknown, error: unknown) {\n      onError(error);\n    },\n  };\n\n  return {\n    name,\n    execute: terminalHooks as AgentMiddleware[\"execute\"],\n    supervisor: terminalHooks as AgentMiddleware[\"supervisor\"],\n  };\n}\n\n/**\n * Narrow an unknown value to a `BaseReport`-shaped object. Structural\n * (checks the lineage fields the collector reads) so it accepts any\n * primitive's report subtype without importing each concrete type.\n */\nfunction isReport(value: unknown): value is import(\"@warlock.js/ai\").BaseReport {\n  return (\n    typeof value === \"object\" &&\n    value !== null &&\n    typeof (value as { runId?: unknown }).runId === \"string\" &&\n    typeof (value as { rootRunId?: unknown }).rootRunId === \"string\"\n  );\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAiCA,SAAgB,yBACd,WACA,OAAO,YACU;CACjB,MAAM,iBAAiB,QAAiB,cAA8B;EACpE,IAAI,CAAC,SAAS,MAAM,GAClB;EAGF,AAAK,UAAU,QAAQ,QAAQ,SAAS,CAAC,CAAC,YAAY,CAGtD,CAAC;CACH;CAEA,MAAM,YAAY,WAA0B;EAG1C,cACG,OAAgC,QAChC,OAA+B,KAClC;CACF;CAEA,MAAM,WAAW,UAAyB;EAIxC,cAAe,MAA+B,QAAQ,KAAK;CAC7D;CAEA,MAAM,gBAAgB;EACpB,MAAM,MAAe,QAAiB;GACpC,SAAS,MAAM;EACjB;EACA,QAAQ,MAAe,OAAgB;GACrC,QAAQ,KAAK;EACf;CACF;CAEA,OAAO;EACL;EACA,SAAS;EACT,YAAY;CACd;AACF;;;;;;AAOA,SAAS,SAAS,OAA8D;CAC9E,OACE,OAAO,UAAU,YACjB,UAAU,QACV,OAAQ,MAA8B,UAAU,YAChD,OAAQ,MAAkC,cAAc;AAE5D"}
+{"version":3,"file":"panoptic-middleware.mjs","names":[],"sources":["../../../../../../../ai-panoptic/src/panoptic/panoptic-middleware.ts"],"sourcesContent":["import type { AgentMiddleware } from \"@warlock.js/ai\";\nimport type { CollectorContract } from \"../contracts/collector.contract\";\n\n/**\n * Build an {@link AgentMiddleware} that feeds a collector from the\n * `execute`- and `supervisor`-level hooks. An alternative wiring to event\n * subscription for apps that already compose cross-cutting concerns\n * through the agent middleware pipeline (`[cache, budget, guardrail,\n * observability]`). Declaring both hook maps lets a single middleware\n * object work uniformly on agents (which fire the `execute` map) and\n * supervisors (which fire the `supervisor` map) — registering it on a\n * supervisor would otherwise install and collect nothing silently.\n *\n * Both terminal paths are covered on each surface:\n * - `after` — fires on a run that produced a result. A run can complete\n *   with `result.error` populated (the engine still calls `after`), so\n *   the report AND the envelope error are collected; the error type and\n *   message land on the root span.\n * - `onError` — fires when the run threw before assembling a result. The\n *   error carries the partial result's report on its envelope; when\n *   present it is collected, with the error itself threaded onto the\n *   root span so failed runs still produce a trace.\n *\n * The hooks never return a value, so they never mutate the agent's /\n * supervisor's result. The `collect` call is fire-and-forget relative to\n * the run — the collector isolates exporter failures internally, and we\n * additionally swallow any rejection here so an observability fault can\n * never surface on the run's hot path.\n *\n * @param collector - the collector traces are fed into.\n * @param name - stable middleware name (kebab-case). Defaults to\n *   `\"panoptic\"`.\n */\nexport function createPanopticMiddleware(\n  collector: CollectorContract,\n  name = \"panoptic\",\n): AgentMiddleware {\n  const collectReport = (report: unknown, rootError?: unknown): void => {\n    if (!isReport(report)) {\n      return;\n    }\n\n    void collector.collect(report, rootError).catch(() => {\n      // Swallow — the collector already isolates exporter failures; this\n      // guard keeps an observability fault off the run's hot path.\n    });\n  };\n\n  const onResult = (result: unknown): void => {\n    // A run can complete with `result.error` populated (`after` still\n    // fires); thread that envelope error onto the root span.\n    collectReport(\n      (result as { report?: unknown }).report,\n      (result as { error?: unknown }).error,\n    );\n  };\n\n  const onError = (error: unknown): void => {\n    // A failed run's report rides on the error envelope when the engine\n    // built one before throwing; collect it so failures trace, threading\n    // the error itself onto the root span.\n    collectReport((error as { report?: unknown }).report, error);\n  };\n\n  const terminalHooks = {\n    after(_ctx: unknown, result: unknown) {\n      onResult(result);\n    },\n    onError(_ctx: unknown, error: unknown) {\n      onError(error);\n    },\n  };\n\n  return {\n    name,\n    execute: terminalHooks as AgentMiddleware[\"execute\"],\n    supervisor: terminalHooks as AgentMiddleware[\"supervisor\"],\n  };\n}\n\n/**\n * Narrow an unknown value to a `BaseReport`-shaped object. Structural\n * (checks the lineage fields the collector reads) so it accepts any\n * primitive's report subtype without importing each concrete type.\n */\nfunction isReport(value: unknown): value is import(\"@warlock.js/ai\").BaseReport {\n  return (\n    typeof value === \"object\" &&\n    value !== null &&\n    typeof (value as { runId?: unknown }).runId === \"string\" &&\n    typeof (value as { rootRunId?: unknown }).rootRunId === \"string\"\n  );\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAiCA,SAAgB,yBACd,WACA,OAAO,YACU;CACjB,MAAM,iBAAiB,QAAiB,cAA8B;EACpE,IAAI,CAAC,SAAS,MAAM,GAClB;EAGF,AAAK,UAAU,QAAQ,QAAQ,SAAS,CAAC,CAAC,YAAY,CAGtD,CAAC;CACH;CAEA,MAAM,YAAY,WAA0B;EAG1C,cACG,OAAgC,QAChC,OAA+B,KAClC;CACF;CAEA,MAAM,WAAW,UAAyB;EAIxC,cAAe,MAA+B,QAAQ,KAAK;CAC7D;CAEA,MAAM,gBAAgB;EACpB,MAAM,MAAe,QAAiB;GACpC,SAAS,MAAM;EACjB;EACA,QAAQ,MAAe,OAAgB;GACrC,QAAQ,KAAK;EACf;CACF;CAEA,OAAO;EACL;EACA,SAAS;EACT,YAAY;CACd;AACF;;;;;;AAOA,SAAS,SAAS,OAA8D;CAC9E,OACE,OAAO,UAAU,YACjB,UAAU,QACV,OAAQ,MAA8B,UAAU,YAChD,OAAQ,MAAkC,cAAc;AAE5D"}

package/esm/panoptic/panoptic-target.type.d.mts

@@ -1,6 +1,6 @@
 import { BaseReport, BaseResult } from "@warlock.js/ai";
 
-//#region ../@warlock.js/ai-panoptic/src/panoptic/panoptic-target.type.d.ts
+//#region ../ai-panoptic/src/panoptic/panoptic-target.type.d.ts
 /**
  * The minimal completed-event payload Panoptic reads off any primitive's
  * terminal `*.completed` event. Every core `@warlock.js/ai` primitive

package/esm/panoptic/panoptic-target.type.d.mts.map

@@ -1 +1 @@
-{"version":3,"file":"panoptic-target.type.d.mts","names":[],"sources":["../../../../../../../@warlock.js/ai-panoptic/src/panoptic/panoptic-target.type.ts"],"mappings":";;;;;AAWA;;;;;;;KAAY,qBAAA;EAE+B,uEAAzC,MAAA,EAAQ,UAAA;IAAe,MAAA,EAAQ,UAAU;EAAA;AAAA;;;;;;;;AAkCY;;;;;;;;;;;;KAZ3C,cAAA;;;;;;WAMD,IAAA;;;;;;EAMT,EAAA,CAAG,KAAA,UAAe,OAAA,GAAU,OAAA;AAAA"}
+{"version":3,"file":"panoptic-target.type.d.mts","names":[],"sources":["../../../../../../../ai-panoptic/src/panoptic/panoptic-target.type.ts"],"mappings":";;;;;AAWA;;;;;;;KAAY,qBAAA;EAE+B,uEAAzC,MAAA,EAAQ,UAAA;IAAe,MAAA,EAAQ,UAAU;EAAA;AAAA;;;;;;;;AAkCY;;;;;;;;;;;;KAZ3C,cAAA;;;;;;WAMD,IAAA;;;;;;EAMT,EAAA,CAAG,KAAA,UAAe,OAAA,GAAU,OAAA;AAAA"}

package/esm/panoptic/panoptic.d.mts

@@ -1,6 +1,6 @@
 import { Panoptic, PanopticOptions } from "./panoptic.type.mjs";
 
-//#region ../@warlock.js/ai-panoptic/src/panoptic/panoptic.d.ts
+//#region ../ai-panoptic/src/panoptic/panoptic.d.ts
 /**
  * Create a Panoptic subscriber — the one-call entry point that wires the
  * observability pipeline. Pass the exporters you want and Panoptic

package/esm/panoptic/panoptic.d.mts.map

@@ -1 +1 @@
-{"version":3,"file":"panoptic.d.mts","names":[],"sources":["../../../../../../../@warlock.js/ai-panoptic/src/panoptic/panoptic.ts"],"mappings":";;;;;AA+LA;;;;;;;;AAAiE;;;;;;;;;;;;;;;;;;;;iBAAjD,QAAA,CAAS,OAAA,GAAS,eAAA,GAAuB,QAAQ"}
+{"version":3,"file":"panoptic.d.mts","names":[],"sources":["../../../../../../../ai-panoptic/src/panoptic/panoptic.ts"],"mappings":";;;;;AA+LA;;;;;;;;AAAiE;;;;;;;;;;;;;;;;;;;;iBAAjD,QAAA,CAAS,OAAA,GAAS,eAAA,GAAuB,QAAQ"}

package/esm/panoptic/panoptic.mjs

@@ -1,7 +1,7 @@
 import { createCollector } from "../collector/collector.mjs";
 import { createPanopticMiddleware } from "./panoptic-middleware.mjs";
 
-//#region ../@warlock.js/ai-panoptic/src/panoptic/panoptic.ts
+//#region ../ai-panoptic/src/panoptic/panoptic.ts
 /**
 * Terminal `*.completed` events of every core primitive that carries the
 * finalized `result` (and therefore the `report` tree). These fire once

package/esm/panoptic/panoptic.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"panoptic.mjs","names":[],"sources":["../../../../../../../@warlock.js/ai-panoptic/src/panoptic/panoptic.ts"],"sourcesContent":["import type { AgentMiddleware, BaseReport } from \"@warlock.js/ai\";\nimport { createCollector } from \"../collector/collector\";\nimport type { CollectorContract } from \"../contracts/collector.contract\";\nimport type { ExporterContract } from \"../contracts/exporter.contract\";\nimport type { Trace } from \"../contracts/trace.type\";\nimport { createPanopticMiddleware } from \"./panoptic-middleware\";\nimport type { CompletedEventPayload, PanopticTarget } from \"./panoptic-target.type\";\nimport type { Panoptic, PanopticOptions } from \"./panoptic.type\";\n\n/**\n * Terminal `*.completed` events of every core primitive that carries the\n * finalized `result` (and therefore the `report` tree). These fire once\n * per run regardless of outcome — the matching `*.error` event fires\n * first on failure, then `*.completed` still fires — so subscribing here\n * captures completed, failed, and cancelled runs alike.\n *\n * The orchestrator is intentionally absent: its `orchestrator.turn.*`\n * events carry only session identity, not a result. Collect an\n * orchestrator turn via {@link Panoptic.collect} with\n * `result.report` instead.\n */\nconst DEFAULT_COMPLETED_EVENTS = [\n  \"agent.completed\",\n  \"workflow.completed\",\n  \"supervisor.completed\",\n] as const;\n\n/**\n * The Panoptic subscriber — binds a collector + its exporters to the\n * three feed paths (events, middleware, direct). Instantiated via\n * {@link panoptic}; callers never see `new`.\n */\nclass PanopticSubscriber implements Panoptic {\n  public readonly collector: CollectorContract;\n\n  private readonly completedEvents: string[];\n\n  private readonly middlewareName: string;\n\n  public constructor(options: PanopticOptions = {}) {\n    this.collector =\n      options.collector ??\n      createCollector({\n        captureContent: options.captureContent,\n        redactContent: options.redactContent,\n        fullHistory: options.fullHistory,\n        onError: options.onError,\n      });\n\n    for (const exporter of options.exporters ?? []) {\n      this.collector.use(exporter);\n    }\n\n    this.completedEvents =\n      options.completedEvents ?? [...DEFAULT_COMPLETED_EVENTS];\n    this.middlewareName = options.middlewareName ?? \"panoptic\";\n  }\n\n  public use(exporter: ExporterContract): Panoptic {\n    this.collector.use(exporter);\n\n    return this;\n  }\n\n  public attach(target: PanopticTarget): () => void {\n    const unsubscribes: Array<() => void> = [];\n\n    for (const event of this.completedEvents) {\n      const unsubscribe = target.on(event, (payload) => {\n        this.handleCompleted(payload);\n      });\n\n      unsubscribes.push(unsubscribe);\n    }\n\n    return () => {\n      for (const unsubscribe of unsubscribes) {\n        unsubscribe();\n      }\n    };\n  }\n\n  public middleware(): AgentMiddleware {\n    return createPanopticMiddleware(this.collector, this.middlewareName);\n  }\n\n  public async collect(report: BaseReport): Promise<void> {\n    await this.collector.collect(report);\n  }\n\n  public toTrace(report: BaseReport): Trace {\n    return this.collector.toTrace(report);\n  }\n\n  public async flush(): Promise<void> {\n    await this.collector.flush();\n  }\n\n  public async shutdown(): Promise<void> {\n    await this.collector.shutdown();\n  }\n\n  /**\n   * Project one terminal `*.completed` payload's report into the\n   * collector. The fan-out is fire-and-forget relative to the emitting\n   * run: the core swallows handler errors, the collector isolates\n   * exporter failures, and we additionally guard the rejection here so an\n   * observability fault never escapes the event handler.\n   */\n  private handleCompleted(payload: unknown): void {\n    const report = readReport(payload);\n\n    if (!report) {\n      return;\n    }\n\n    // The failing run's typed error lives on the result envelope\n    // (`BaseResult.error`), never on the report tree — thread it so a\n    // failed root span carries its error type/message.\n    const rootError = readResultError(payload);\n\n    void this.collector.collect(report, rootError).catch(() => {\n      // Swallow — see the JSDoc above. Never surface on the run.\n    });\n  }\n}\n\n/**\n * Read the envelope error off a primitive's completed-event payload\n * (`{ result: { error } }`). The error rides on the result envelope, not\n * the report tree, so the collector needs it separately to populate a\n * failed root span. Returns `undefined` when the run succeeded.\n */\nfunction readResultError(payload: unknown): unknown {\n  const result = (payload as Partial<CompletedEventPayload>)?.result;\n\n  return (result as { error?: unknown })?.error;\n}\n\n/**\n * Read the `report` tree off a primitive's completed-event payload.\n * Structural (no concrete-type import) so it accepts every primitive's\n * result subtype; returns `undefined` when the payload isn't the\n * expected `{ result: { report } }` shape.\n */\nfunction readReport(payload: unknown): BaseReport | undefined {\n  const result = (payload as Partial<CompletedEventPayload>)?.result;\n  const report = (result as { report?: unknown })?.report;\n\n  if (\n    typeof report === \"object\" &&\n    report !== null &&\n    typeof (report as { runId?: unknown }).runId === \"string\" &&\n    typeof (report as { rootRunId?: unknown }).rootRunId === \"string\"\n  ) {\n    return report as BaseReport;\n  }\n\n  return undefined;\n}\n\n/**\n * Create a Panoptic subscriber — the one-call entry point that wires the\n * observability pipeline. Pass the exporters you want and Panoptic\n * builds a collector, registers them, and hands back a subscriber you can\n * `attach()` to any agent/workflow/supervisor, install as agent\n * `middleware()`, or feed reports to directly with `collect()`.\n *\n * @example\n * // Attach to a primitive's event stream (captures every run):\n * const observe = panoptic({\n *   exporters: [consoleExporter(), otelExporter({ tracerName: \"app\" })],\n * });\n *\n * const agent = ai.agent({ model });\n * const detach = observe.attach(agent);\n *\n * await agent.execute(\"Summarize this\");\n * // ...later, on shutdown:\n * await observe.shutdown();\n *\n * @example\n * // Or wire it through the agent middleware pipeline:\n * const observe = panoptic({ exporters: [langfuseExporter({ ... })] });\n * const agent = ai.agent({ model, middleware: [observe.middleware()] });\n *\n * @example\n * // Orchestrator turns carry no result-bearing event — collect directly:\n * const result = await orchestrator.execute(input, { sessionId });\n * await observe.collect(result.report);\n */\nexport function panoptic(options: PanopticOptions = {}): Panoptic {\n  return new PanopticSubscriber(options);\n}\n"],"mappings":";;;;;;;;;;;;;;;;AAqBA,MAAM,2BAA2B;CAC/B;CACA;CACA;AACF;;;;;;AAOA,IAAM,qBAAN,MAA6C;CAC3C,AAAgB;CAEhB,AAAiB;CAEjB,AAAiB;CAEjB,AAAO,YAAY,UAA2B,CAAC,GAAG;EAChD,KAAK,YACH,QAAQ,aACR,gBAAgB;GACd,gBAAgB,QAAQ;GACxB,eAAe,QAAQ;GACvB,aAAa,QAAQ;GACrB,SAAS,QAAQ;EACnB,CAAC;EAEH,KAAK,MAAM,YAAY,QAAQ,aAAa,CAAC,GAC3C,KAAK,UAAU,IAAI,QAAQ;EAG7B,KAAK,kBACH,QAAQ,mBAAmB,CAAC,GAAG,wBAAwB;EACzD,KAAK,iBAAiB,QAAQ,kBAAkB;CAClD;CAEA,AAAO,IAAI,UAAsC;EAC/C,KAAK,UAAU,IAAI,QAAQ;EAE3B,OAAO;CACT;CAEA,AAAO,OAAO,QAAoC;EAChD,MAAM,eAAkC,CAAC;EAEzC,KAAK,MAAM,SAAS,KAAK,iBAAiB;GACxC,MAAM,cAAc,OAAO,GAAG,QAAQ,YAAY;IAChD,KAAK,gBAAgB,OAAO;GAC9B,CAAC;GAED,aAAa,KAAK,WAAW;EAC/B;EAEA,aAAa;GACX,KAAK,MAAM,eAAe,cACxB,YAAY;EAEhB;CACF;CAEA,AAAO,aAA8B;EACnC,OAAO,yBAAyB,KAAK,WAAW,KAAK,cAAc;CACrE;CAEA,MAAa,QAAQ,QAAmC;EACtD,MAAM,KAAK,UAAU,QAAQ,MAAM;CACrC;CAEA,AAAO,QAAQ,QAA2B;EACxC,OAAO,KAAK,UAAU,QAAQ,MAAM;CACtC;CAEA,MAAa,QAAuB;EAClC,MAAM,KAAK,UAAU,MAAM;CAC7B;CAEA,MAAa,WAA0B;EACrC,MAAM,KAAK,UAAU,SAAS;CAChC;;;;;;;;CASA,AAAQ,gBAAgB,SAAwB;EAC9C,MAAM,SAAS,WAAW,OAAO;EAEjC,IAAI,CAAC,QACH;EAMF,MAAM,YAAY,gBAAgB,OAAO;EAEzC,AAAK,KAAK,UAAU,QAAQ,QAAQ,SAAS,CAAC,CAAC,YAAY,CAE3D,CAAC;CACH;AACF;;;;;;;AAQA,SAAS,gBAAgB,SAA2B;CAGlD,QAFgB,SAA4C,OAE9C,EAA0B;AAC1C;;;;;;;AAQA,SAAS,WAAW,SAA0C;CAE5D,MAAM,UADU,SAA4C,OACtC,EAA2B;CAEjD,IACE,OAAO,WAAW,YAClB,WAAW,QACX,OAAQ,OAA+B,UAAU,YACjD,OAAQ,OAAmC,cAAc,UAEzD,OAAO;AAIX;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAgCA,SAAgB,SAAS,UAA2B,CAAC,GAAa;CAChE,OAAO,IAAI,mBAAmB,OAAO;AACvC"}
+{"version":3,"file":"panoptic.mjs","names":[],"sources":["../../../../../../../ai-panoptic/src/panoptic/panoptic.ts"],"sourcesContent":["import type { AgentMiddleware, BaseReport } from \"@warlock.js/ai\";\nimport { createCollector } from \"../collector/collector\";\nimport type { CollectorContract } from \"../contracts/collector.contract\";\nimport type { ExporterContract } from \"../contracts/exporter.contract\";\nimport type { Trace } from \"../contracts/trace.type\";\nimport { createPanopticMiddleware } from \"./panoptic-middleware\";\nimport type { CompletedEventPayload, PanopticTarget } from \"./panoptic-target.type\";\nimport type { Panoptic, PanopticOptions } from \"./panoptic.type\";\n\n/**\n * Terminal `*.completed` events of every core primitive that carries the\n * finalized `result` (and therefore the `report` tree). These fire once\n * per run regardless of outcome — the matching `*.error` event fires\n * first on failure, then `*.completed` still fires — so subscribing here\n * captures completed, failed, and cancelled runs alike.\n *\n * The orchestrator is intentionally absent: its `orchestrator.turn.*`\n * events carry only session identity, not a result. Collect an\n * orchestrator turn via {@link Panoptic.collect} with\n * `result.report` instead.\n */\nconst DEFAULT_COMPLETED_EVENTS = [\n  \"agent.completed\",\n  \"workflow.completed\",\n  \"supervisor.completed\",\n] as const;\n\n/**\n * The Panoptic subscriber — binds a collector + its exporters to the\n * three feed paths (events, middleware, direct). Instantiated via\n * {@link panoptic}; callers never see `new`.\n */\nclass PanopticSubscriber implements Panoptic {\n  public readonly collector: CollectorContract;\n\n  private readonly completedEvents: string[];\n\n  private readonly middlewareName: string;\n\n  public constructor(options: PanopticOptions = {}) {\n    this.collector =\n      options.collector ??\n      createCollector({\n        captureContent: options.captureContent,\n        redactContent: options.redactContent,\n        fullHistory: options.fullHistory,\n        onError: options.onError,\n      });\n\n    for (const exporter of options.exporters ?? []) {\n      this.collector.use(exporter);\n    }\n\n    this.completedEvents =\n      options.completedEvents ?? [...DEFAULT_COMPLETED_EVENTS];\n    this.middlewareName = options.middlewareName ?? \"panoptic\";\n  }\n\n  public use(exporter: ExporterContract): Panoptic {\n    this.collector.use(exporter);\n\n    return this;\n  }\n\n  public attach(target: PanopticTarget): () => void {\n    const unsubscribes: Array<() => void> = [];\n\n    for (const event of this.completedEvents) {\n      const unsubscribe = target.on(event, (payload) => {\n        this.handleCompleted(payload);\n      });\n\n      unsubscribes.push(unsubscribe);\n    }\n\n    return () => {\n      for (const unsubscribe of unsubscribes) {\n        unsubscribe();\n      }\n    };\n  }\n\n  public middleware(): AgentMiddleware {\n    return createPanopticMiddleware(this.collector, this.middlewareName);\n  }\n\n  public async collect(report: BaseReport): Promise<void> {\n    await this.collector.collect(report);\n  }\n\n  public toTrace(report: BaseReport): Trace {\n    return this.collector.toTrace(report);\n  }\n\n  public async flush(): Promise<void> {\n    await this.collector.flush();\n  }\n\n  public async shutdown(): Promise<void> {\n    await this.collector.shutdown();\n  }\n\n  /**\n   * Project one terminal `*.completed` payload's report into the\n   * collector. The fan-out is fire-and-forget relative to the emitting\n   * run: the core swallows handler errors, the collector isolates\n   * exporter failures, and we additionally guard the rejection here so an\n   * observability fault never escapes the event handler.\n   */\n  private handleCompleted(payload: unknown): void {\n    const report = readReport(payload);\n\n    if (!report) {\n      return;\n    }\n\n    // The failing run's typed error lives on the result envelope\n    // (`BaseResult.error`), never on the report tree — thread it so a\n    // failed root span carries its error type/message.\n    const rootError = readResultError(payload);\n\n    void this.collector.collect(report, rootError).catch(() => {\n      // Swallow — see the JSDoc above. Never surface on the run.\n    });\n  }\n}\n\n/**\n * Read the envelope error off a primitive's completed-event payload\n * (`{ result: { error } }`). The error rides on the result envelope, not\n * the report tree, so the collector needs it separately to populate a\n * failed root span. Returns `undefined` when the run succeeded.\n */\nfunction readResultError(payload: unknown): unknown {\n  const result = (payload as Partial<CompletedEventPayload>)?.result;\n\n  return (result as { error?: unknown })?.error;\n}\n\n/**\n * Read the `report` tree off a primitive's completed-event payload.\n * Structural (no concrete-type import) so it accepts every primitive's\n * result subtype; returns `undefined` when the payload isn't the\n * expected `{ result: { report } }` shape.\n */\nfunction readReport(payload: unknown): BaseReport | undefined {\n  const result = (payload as Partial<CompletedEventPayload>)?.result;\n  const report = (result as { report?: unknown })?.report;\n\n  if (\n    typeof report === \"object\" &&\n    report !== null &&\n    typeof (report as { runId?: unknown }).runId === \"string\" &&\n    typeof (report as { rootRunId?: unknown }).rootRunId === \"string\"\n  ) {\n    return report as BaseReport;\n  }\n\n  return undefined;\n}\n\n/**\n * Create a Panoptic subscriber — the one-call entry point that wires the\n * observability pipeline. Pass the exporters you want and Panoptic\n * builds a collector, registers them, and hands back a subscriber you can\n * `attach()` to any agent/workflow/supervisor, install as agent\n * `middleware()`, or feed reports to directly with `collect()`.\n *\n * @example\n * // Attach to a primitive's event stream (captures every run):\n * const observe = panoptic({\n *   exporters: [consoleExporter(), otelExporter({ tracerName: \"app\" })],\n * });\n *\n * const agent = ai.agent({ model });\n * const detach = observe.attach(agent);\n *\n * await agent.execute(\"Summarize this\");\n * // ...later, on shutdown:\n * await observe.shutdown();\n *\n * @example\n * // Or wire it through the agent middleware pipeline:\n * const observe = panoptic({ exporters: [langfuseExporter({ ... })] });\n * const agent = ai.agent({ model, middleware: [observe.middleware()] });\n *\n * @example\n * // Orchestrator turns carry no result-bearing event — collect directly:\n * const result = await orchestrator.execute(input, { sessionId });\n * await observe.collect(result.report);\n */\nexport function panoptic(options: PanopticOptions = {}): Panoptic {\n  return new PanopticSubscriber(options);\n}\n"],"mappings":";;;;;;;;;;;;;;;;AAqBA,MAAM,2BAA2B;CAC/B;CACA;CACA;AACF;;;;;;AAOA,IAAM,qBAAN,MAA6C;CAC3C,AAAgB;CAEhB,AAAiB;CAEjB,AAAiB;CAEjB,AAAO,YAAY,UAA2B,CAAC,GAAG;EAChD,KAAK,YACH,QAAQ,aACR,gBAAgB;GACd,gBAAgB,QAAQ;GACxB,eAAe,QAAQ;GACvB,aAAa,QAAQ;GACrB,SAAS,QAAQ;EACnB,CAAC;EAEH,KAAK,MAAM,YAAY,QAAQ,aAAa,CAAC,GAC3C,KAAK,UAAU,IAAI,QAAQ;EAG7B,KAAK,kBACH,QAAQ,mBAAmB,CAAC,GAAG,wBAAwB;EACzD,KAAK,iBAAiB,QAAQ,kBAAkB;CAClD;CAEA,AAAO,IAAI,UAAsC;EAC/C,KAAK,UAAU,IAAI,QAAQ;EAE3B,OAAO;CACT;CAEA,AAAO,OAAO,QAAoC;EAChD,MAAM,eAAkC,CAAC;EAEzC,KAAK,MAAM,SAAS,KAAK,iBAAiB;GACxC,MAAM,cAAc,OAAO,GAAG,QAAQ,YAAY;IAChD,KAAK,gBAAgB,OAAO;GAC9B,CAAC;GAED,aAAa,KAAK,WAAW;EAC/B;EAEA,aAAa;GACX,KAAK,MAAM,eAAe,cACxB,YAAY;EAEhB;CACF;CAEA,AAAO,aAA8B;EACnC,OAAO,yBAAyB,KAAK,WAAW,KAAK,cAAc;CACrE;CAEA,MAAa,QAAQ,QAAmC;EACtD,MAAM,KAAK,UAAU,QAAQ,MAAM;CACrC;CAEA,AAAO,QAAQ,QAA2B;EACxC,OAAO,KAAK,UAAU,QAAQ,MAAM;CACtC;CAEA,MAAa,QAAuB;EAClC,MAAM,KAAK,UAAU,MAAM;CAC7B;CAEA,MAAa,WAA0B;EACrC,MAAM,KAAK,UAAU,SAAS;CAChC;;;;;;;;CASA,AAAQ,gBAAgB,SAAwB;EAC9C,MAAM,SAAS,WAAW,OAAO;EAEjC,IAAI,CAAC,QACH;EAMF,MAAM,YAAY,gBAAgB,OAAO;EAEzC,AAAK,KAAK,UAAU,QAAQ,QAAQ,SAAS,CAAC,CAAC,YAAY,CAE3D,CAAC;CACH;AACF;;;;;;;AAQA,SAAS,gBAAgB,SAA2B;CAGlD,QAFgB,SAA4C,OAE9C,EAA0B;AAC1C;;;;;;;AAQA,SAAS,WAAW,SAA0C;CAE5D,MAAM,UADU,SAA4C,OACtC,EAA2B;CAEjD,IACE,OAAO,WAAW,YAClB,WAAW,QACX,OAAQ,OAA+B,UAAU,YACjD,OAAQ,OAAmC,cAAc,UAEzD,OAAO;AAIX;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAgCA,SAAgB,SAAS,UAA2B,CAAC,GAAa;CAChE,OAAO,IAAI,mBAAmB,OAAO;AACvC"}

package/esm/panoptic/panoptic.type.d.mts

@@ -6,7 +6,7 @@ import { ExporterErrorHandler } from "../collector/collector.mjs";
 import { PanopticTarget } from "./panoptic-target.type.mjs";
 import { AgentMiddleware, BaseReport } from "@warlock.js/ai";
 
-//#region ../@warlock.js/ai-panoptic/src/panoptic/panoptic.type.d.ts
+//#region ../ai-panoptic/src/panoptic/panoptic.type.d.ts
 /**
  * Options for the {@link panoptic} subscriber factory.
  *

package/esm/panoptic/panoptic.type.d.mts.map

@@ -1 +1 @@
-{"version":3,"file":"panoptic.type.d.mts","names":[],"sources":["../../../../../../../@warlock.js/ai-panoptic/src/panoptic/panoptic.type.ts"],"mappings":";;;;;;;;;;;AAgBA;;;;;;KAAY,eAAA;EA0DoB;;;;;EApD9B,SAAA,GAAY,gBAAA;EAgBZ;;;;;;EATA,SAAA,GAAY,iBAAA;EA6CF;;AAAoB;AAoBhC;;;;;EAxDE,eAAA;EAsEe;;;;;EAhEf,cAAA;EAoFS;;;;;;;;;EA1ET,cAAA;EAsDA;;;;;EAhDA,aAAA,GAAgB,eAAA;EA6DA;;;;;EAvDhB,WAAA;EA4D6B;;;;;;AAIV;EAxDnB,OAAA,GAAU,oBAAA;AAAA;;;;;;;;;;;;;;;;;;KAoBA,QAAA;mFAED,SAAA,EAAW,iBAAA;;;;;EAKpB,GAAA,CAAI,QAAA,EAAU,gBAAA,GAAmB,QAAA;;;;;;;EAOjC,MAAA,CAAO,MAAA,EAAQ,cAAA;;;;;;;EAOf,UAAA,IAAc,eAAA;;;;;;EAMd,OAAA,CAAQ,MAAA,EAAQ,UAAA,GAAa,OAAA;;;;;EAK7B,OAAA,CAAQ,MAAA,EAAQ,UAAA,GAAa,KAAA;EAE7B,KAAA,IAAS,OAAA;EAET,QAAA,IAAY,OAAA;AAAA"}
+{"version":3,"file":"panoptic.type.d.mts","names":[],"sources":["../../../../../../../ai-panoptic/src/panoptic/panoptic.type.ts"],"mappings":";;;;;;;;;;;AAgBA;;;;;;KAAY,eAAA;EA0DoB;;;;;EApD9B,SAAA,GAAY,gBAAA;EAgBZ;;;;;;EATA,SAAA,GAAY,iBAAA;EA6CF;;AAAoB;AAoBhC;;;;;EAxDE,eAAA;EAsEe;;;;;EAhEf,cAAA;EAoFS;;;;;;;;;EA1ET,cAAA;EAsDA;;;;;EAhDA,aAAA,GAAgB,eAAA;EA6DA;;;;;EAvDhB,WAAA;EA4D6B;;;;;;AAIV;EAxDnB,OAAA,GAAU,oBAAA;AAAA;;;;;;;;;;;;;;;;;;KAoBA,QAAA;mFAED,SAAA,EAAW,iBAAA;;;;;EAKpB,GAAA,CAAI,QAAA,EAAU,gBAAA,GAAmB,QAAA;;;;;;;EAOjC,MAAA,CAAO,MAAA,EAAQ,cAAA;;;;;;;EAOf,UAAA,IAAc,eAAA;;;;;;EAMd,OAAA,CAAQ,MAAA,EAAQ,UAAA,GAAa,OAAA;;;;;EAK7B,OAAA,CAAQ,MAAA,EAAQ,UAAA,GAAa,KAAA;EAE7B,KAAA,IAAS,OAAA;EAET,QAAA,IAAY,OAAA;AAAA"}

package/esm/register.mjs

@@ -1,7 +1,7 @@
 import { applyPanopticConfig } from "./config/apply-panoptic-config.mjs";
 import { getAIConfig, onConfigApplied } from "@warlock.js/ai";
 
-//#region ../@warlock.js/ai-panoptic/src/register.ts
+//#region ../ai-panoptic/src/register.ts
 onConfigApplied((config) => {
 	applyPanopticConfig(config.panoptic);
 });

package/esm/register.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"register.mjs","names":[],"sources":["../../../../../../@warlock.js/ai-panoptic/src/register.ts"],"sourcesContent":["import { getAIConfig, onConfigApplied } from \"@warlock.js/ai\";\nimport { applyPanopticConfig } from \"./config/apply-panoptic-config\";\n\n// Side-effect wiring. Importing `@warlock.js/ai-panoptic` (even bare,\n// `import \"@warlock.js/ai-panoptic\"`) subscribes panoptic to the core\n// config seam so a later `ai.config({ panoptic })` wires the collector +\n// dashboard onto the observe registry — without app code calling\n// `applyPanopticConfig` by hand.\n//\n// 1. React to every future `ai.config(...)` merge.\nonConfigApplied((config) => {\n  applyPanopticConfig(config.panoptic);\n});\n\n// 2. Catch config that was applied BEFORE this import ran (e.g. the app\n//    called `ai.config({ panoptic })` and only then imported panoptic).\napplyPanopticConfig(getAIConfig().panoptic);\n"],"mappings":";;;;AAUA,iBAAiB,WAAW;CAC1B,oBAAoB,OAAO,QAAQ;AACrC,CAAC;AAID,oBAAoB,YAAY,CAAC,CAAC,QAAQ"}
+{"version":3,"file":"register.mjs","names":[],"sources":["../../../../../../ai-panoptic/src/register.ts"],"sourcesContent":["import { getAIConfig, onConfigApplied } from \"@warlock.js/ai\";\nimport { applyPanopticConfig } from \"./config/apply-panoptic-config\";\n\n// Side-effect wiring. Importing `@warlock.js/ai-panoptic` (even bare,\n// `import \"@warlock.js/ai-panoptic\"`) subscribes panoptic to the core\n// config seam so a later `ai.config({ panoptic })` wires the collector +\n// dashboard onto the observe registry — without app code calling\n// `applyPanopticConfig` by hand.\n//\n// 1. React to every future `ai.config(...)` merge.\nonConfigApplied((config) => {\n  applyPanopticConfig(config.panoptic);\n});\n\n// 2. Catch config that was applied BEFORE this import ran (e.g. the app\n//    called `ai.config({ panoptic })` and only then imported panoptic).\napplyPanopticConfig(getAIConfig().panoptic);\n"],"mappings":";;;;AAUA,iBAAiB,WAAW;CAC1B,oBAAoB,OAAO,QAAQ;AACrC,CAAC;AAID,oBAAoB,YAAY,CAAC,CAAC,QAAQ"}

package/esm/store/cache-trace-store.d.mts

@@ -2,7 +2,7 @@ import { ExporterContract } from "../contracts/exporter.contract.mjs";
 import { TraceStoreContract } from "./trace-store.contract.mjs";
 import { CacheDriver } from "@warlock.js/cache";
 
-//#region ../@warlock.js/ai-panoptic/src/store/cache-trace-store.d.ts
+//#region ../ai-panoptic/src/store/cache-trace-store.d.ts
 /**
  * A {@link CacheDriver} instance, or a (possibly async) factory that
  * yields one on first use. The factory form lets production defer an

package/esm/store/cache-trace-store.d.mts.map

@@ -1 +1 @@
-{"version":3,"file":"cache-trace-store.d.mts","names":[],"sources":["../../../../../../../@warlock.js/ai-panoptic/src/store/cache-trace-store.ts"],"mappings":";;;;;;;AAoBA;;;;;;;;;KAAY,gBAAA,GAIR,WAAA,oBAEO,WAAA,aAAwB,OAAA,CAAQ,WAAA;;;;KAK/B,sBAAA;EAL0C;AAKtD;;;;EAME,MAAA;EA0YU;;;;;EApYV,QAAQ;AAAA;;;;;;;KAoYE,qBAAA,GAAwB,kBAAA,GAClC,gBAAA;EAoCc;;;;;EA9BZ,KAAA,IAAS,OAAA;AAAA;;;;;;;;;;AAiCW;;;;;;;;;;;;;;;;;;iBAHR,qBAAA,CACd,KAAA,EAAO,gBAAA,EACP,OAAA,GAAS,sBAAA;EAA2B,OAAA,IAAW,KAAA;AAAA,IAC9C,qBAAA"}
+{"version":3,"file":"cache-trace-store.d.mts","names":[],"sources":["../../../../../../../ai-panoptic/src/store/cache-trace-store.ts"],"mappings":";;;;;;;AAoBA;;;;;;;;;KAAY,gBAAA,GAIR,WAAA,oBAEO,WAAA,aAAwB,OAAA,CAAQ,WAAA;;;;KAK/B,sBAAA;EAL0C;AAKtD;;;;EAME,MAAA;EA0YU;;;;;EApYV,QAAQ;AAAA;;;;;;;KAoYE,qBAAA,GAAwB,kBAAA,GAClC,gBAAA;EAoCc;;;;;EA9BZ,KAAA,IAAS,OAAA;AAAA;;;;;;;;;;AAiCW;;;;;;;;;;;;;;;;;;iBAHR,qBAAA,CACd,KAAA,EAAO,gBAAA,EACP,OAAA,GAAS,sBAAA;EAA2B,OAAA,IAAW,KAAA;AAAA,IAC9C,qBAAA"}

package/esm/store/cache-trace-store.mjs

@@ -1,7 +1,7 @@
 import { matchTrace } from "./match-trace.mjs";
 import { emptyUsage, sumUsage } from "./sum-usage.mjs";
 
-//#region ../@warlock.js/ai-panoptic/src/store/cache-trace-store.ts
+//#region ../ai-panoptic/src/store/cache-trace-store.ts
 const DEFAULT_PREFIX = "panoptic";
 /**
 * Cache-backed {@link TraceStoreContract} with a **write-through** design

package/esm/store/cache-trace-store.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"cache-trace-store.mjs","names":[],"sources":["../../../../../../../@warlock.js/ai-panoptic/src/store/cache-trace-store.ts"],"sourcesContent":["import type { CacheDriver } from \"@warlock.js/cache\";\nimport type { ExporterContract } from \"../contracts/exporter.contract\";\nimport type { Trace } from \"../contracts/trace.type\";\nimport { matchTrace } from \"./match-trace\";\nimport { emptyUsage, sumUsage } from \"./sum-usage\";\nimport type { TraceAggregate } from \"./trace-aggregate.type\";\nimport type { TraceQuery } from \"./trace-query.type\";\nimport type { TraceStoreContract } from \"./trace-store.contract\";\n\n/**\n * A {@link CacheDriver} instance, or a (possibly async) factory that\n * yields one on first use. The factory form lets production defer an\n * expensive connect (e.g. the Redis handshake) until the first trace is\n * actually written, and keeps the dashboard wiring free of a live driver\n * at module-import time.\n *\n * Typed `CacheDriver<any, any>` because the store only ever touches the\n * driver's `get` / `set` / `remove` surface and is agnostic to the\n * concrete client + options of whichever driver backs it.\n */\nexport type CacheDriverInput =\n  // The store is driver-agnostic; it only uses get/set/remove, so the\n  // concrete client/options generics are intentionally unconstrained.\n  // eslint-disable-next-line @typescript-eslint/no-explicit-any\n  | CacheDriver<any, any>\n  // eslint-disable-next-line @typescript-eslint/no-explicit-any\n  | (() => CacheDriver<any, any> | Promise<CacheDriver<any, any>>);\n\n/**\n * Options for {@link createCacheTraceStore}.\n */\nexport type CacheTraceStoreOptions = {\n  /**\n   * Key prefix every cache entry this store writes is namespaced under.\n   * Per-trace keys are `${prefix}:trace:${traceId}`; the newest-first\n   * index lives at `${prefix}:index`. Default `\"panoptic\"`.\n   */\n  prefix?: string;\n  /**\n   * Maximum number of traces to retain. When set and exceeded, the\n   * oldest-ingested trace is evicted from both the cache and the in-memory\n   * mirror (insertion-order FIFO). Absent / `0` = unbounded.\n   */\n  capacity?: number;\n};\n\n/** One entry in the persisted newest-first index. */\ntype IndexEntry = {\n  /** The trace's `traceId` — the suffix of its `${prefix}:trace:` key. */\n  id: string;\n  /**\n   * Monotonic insertion order from an internal counter — NOT a wall clock.\n   * Used only to keep the index in stable insertion order across a restart\n   * so FIFO eviction stays honest.\n   */\n  addedAt: number;\n};\n\nconst DEFAULT_PREFIX = \"panoptic\";\n\n/**\n * Cache-backed {@link TraceStoreContract} with a **write-through** design\n * that reconciles the synchronous store contract with an asynchronous\n * cache driver.\n *\n * **How the sync/async tension is resolved.** The contract's `get` /\n * `query` / `aggregate` / `size` are synchronous (the dashboard polls them\n * on every request and the in-memory store answers instantly). A cache\n * driver is async. So this store keeps an **in-memory read mirror** — the\n * same insertion-ordered `Map<traceId, Trace>` the in-memory store uses —\n * and serves every read from it synchronously. Writes go **through** to the\n * cache: `add` updates the mirror immediately, then asynchronously persists\n * the trace + index to the cache (errors are swallowed via an optional\n * `onError` hook so a flaky cache never throws into the collector's hot\n * path). On process restart, {@link CacheTraceStore.ready} re-hydrates the\n * mirror from the cache so traces survive the restart.\n *\n * **Durability is best-effort.** Reads never wait on the cache; the mirror\n * is the source of truth at runtime and the cache is the durable backing\n * store. A write that the cache rejects is still visible in the mirror for\n * the life of the process — it just won't survive a restart.\n *\n * **Lazy driver resolution.** The driver (or its async factory) is resolved\n * on first use and memoized, so a production deployment can defer the Redis\n * connect until the first trace is collected, and the dashboard can be\n * wired with a factory at import time without a live connection.\n *\n * Doubles as an {@link ExporterContract} (`export` ≡ `add`), so it drops\n * straight into a collector via `collector.use(store)`.\n *\n * Instantiated via {@link createCacheTraceStore}; callers never see `new`.\n */\nclass CacheTraceStore implements TraceStoreContract, ExporterContract {\n  /** Stable exporter id so a collector can dedupe / log this sink. */\n  public readonly name = \"cache-trace-store\";\n\n  /**\n   * In-memory read mirror keyed by `traceId`. A `Map` preserves insertion\n   * order, which newest-first `query` ordering and FIFO eviction both rely\n   * on. Every read is served from here synchronously.\n   */\n  private readonly mirror = new Map<string, Trace>();\n\n  private readonly prefix: string;\n\n  private readonly capacity: number;\n\n  /**\n   * Monotonic insertion counter — the source of `IndexEntry.addedAt`.\n   * Deliberately NOT `Date.now()`: an internal counter guarantees a stable\n   * total order for the index even when many traces land in the same\n   * millisecond.\n   */\n  private addCounter = 0;\n\n  /** The optional input — a driver, a factory, or `undefined`. */\n  private readonly input: CacheDriverInput;\n\n  // The store is driver-agnostic; only get/set/remove are used.\n  // eslint-disable-next-line @typescript-eslint/no-explicit-any\n  private resolvedDriver?: CacheDriver<any, any>;\n\n  // eslint-disable-next-line @typescript-eslint/no-explicit-any\n  private driverPending?: Promise<CacheDriver<any, any>>;\n\n  private readonly onError?: (error: unknown) => void;\n\n  public constructor(\n    input: CacheDriverInput,\n    options: CacheTraceStoreOptions & { onError?: (error: unknown) => void } = {},\n  ) {\n    this.input = input;\n    this.prefix = options.prefix ?? DEFAULT_PREFIX;\n    this.capacity = options.capacity ?? 0;\n    this.onError = options.onError;\n  }\n\n  public get size(): number {\n    return this.mirror.size;\n  }\n\n  /**\n   * Hydrate the in-memory mirror from the cache. Idempotent-safe to call\n   * once at startup (the dashboard / config wiring awaits it). Reads the\n   * persisted index, fetches each referenced trace, and replays them into\n   * the mirror in insertion order so newest-first ordering + eviction stay\n   * correct after a restart. A cache failure is routed to `onError` and\n   * leaves the mirror empty rather than throwing.\n   */\n  public async ready(): Promise<void> {\n    try {\n      const driver = await this.resolveDriver();\n      const index = await driver.get<IndexEntry[]>(this.indexKey());\n\n      if (!Array.isArray(index)) {\n        return;\n      }\n\n      // Oldest-first replay so the mirror's insertion order matches the\n      // original ingestion order.\n      const ordered = [...index].sort((left, right) => left.addedAt - right.addedAt);\n\n      for (const entry of ordered) {\n        const trace = await driver.get<Trace>(this.traceKey(entry.id));\n\n        if (trace !== null && trace !== undefined) {\n          this.mirror.delete(trace.traceId);\n          this.mirror.set(trace.traceId, trace);\n        }\n\n        if (entry.addedAt >= this.addCounter) {\n          this.addCounter = entry.addedAt + 1;\n        }\n      }\n\n      this.evictOverflow();\n    } catch (error) {\n      this.reportError(error);\n    }\n  }\n\n  public add(trace: Trace): void {\n    // Mirror update is synchronous and authoritative for runtime reads.\n    this.mirror.delete(trace.traceId);\n    this.mirror.set(trace.traceId, trace);\n\n    const addedAt = this.addCounter;\n    this.addCounter += 1;\n\n    const evicted = this.evictOverflow();\n\n    // Write through to the cache fire-and-forget; reads never wait on this.\n    void this.persist(trace, addedAt, evicted);\n  }\n\n  /**\n   * `ExporterContract.export` — a collector dispatches a completed trace\n   * here, which is exactly an `add`.\n   */\n  public export(trace: Trace): void {\n    this.add(trace);\n  }\n\n  public get(traceId: string): Trace | undefined {\n    return this.mirror.get(traceId);\n  }\n\n  public query(filter?: TraceQuery): Trace[] {\n    const matched: Trace[] = [];\n\n    for (const trace of this.mirror.values()) {\n      if (matchTrace(trace, filter)) {\n        matched.push(trace);\n      }\n    }\n\n    return this.sortNewestFirst(matched);\n  }\n\n  public aggregate(filter?: TraceQuery): TraceAggregate {\n    const aggregate: TraceAggregate = {\n      traces: 0,\n      completed: 0,\n      failed: 0,\n      cancelled: 0,\n      usage: emptyUsage(),\n      totalDuration: 0,\n    };\n\n    for (const trace of this.mirror.values()) {\n      if (!matchTrace(trace, filter)) {\n        continue;\n      }\n\n      aggregate.traces += 1;\n      aggregate.totalDuration += trace.duration;\n      aggregate.usage = sumUsage(aggregate.usage, trace.usage);\n\n      this.countStatus(aggregate, trace);\n    }\n\n    if (aggregate.usage.cost !== undefined) {\n      aggregate.cost = aggregate.usage.cost;\n    }\n\n    return aggregate;\n  }\n\n  public clear(): void {\n    const ids = [...this.mirror.keys()];\n    this.mirror.clear();\n\n    void this.purge(ids);\n  }\n\n  /**\n   * Persist one trace + the rebuilt index to the cache, optionally removing\n   * a trace evicted by the capacity cap. Best-effort: any cache failure is\n   * routed to `onError`, never thrown — the mirror already reflects the\n   * write so runtime reads are unaffected.\n   */\n  private async persist(\n    trace: Trace,\n    addedAt: number,\n    evictedId: string | undefined,\n  ): Promise<void> {\n    try {\n      const driver = await this.resolveDriver();\n\n      await driver.set(this.traceKey(trace.traceId), trace);\n\n      if (evictedId !== undefined) {\n        await driver.remove(this.traceKey(evictedId));\n      }\n\n      await driver.set(this.indexKey(), this.buildIndex(addedAt));\n    } catch (error) {\n      this.reportError(error);\n    }\n  }\n\n  /** Best-effort removal of every persisted trace + the index on `clear`. */\n  private async purge(ids: string[]): Promise<void> {\n    try {\n      const driver = await this.resolveDriver();\n\n      for (const id of ids) {\n        await driver.remove(this.traceKey(id));\n      }\n\n      await driver.remove(this.indexKey());\n    } catch (error) {\n      this.reportError(error);\n    }\n  }\n\n  /**\n   * Rebuild the newest-first index from the current mirror. The mirror's\n   * `Map` iteration is oldest-first insertion order; we walk it and assign\n   * `addedAt` from the surviving counter span so the persisted order\n   * matches the in-memory one. The freshest entry uses `latestAddedAt`.\n   */\n  private buildIndex(latestAddedAt: number): IndexEntry[] {\n    const ids = [...this.mirror.keys()];\n    const base = latestAddedAt - (ids.length - 1);\n\n    return ids.map((id, offset) => ({ id, addedAt: base + offset }));\n  }\n\n  /**\n   * Resolve the driver once and memoize. Supports a bare driver, a sync\n   * factory, and an async factory. Concurrent first-callers share one\n   * in-flight resolution.\n   */\n  // eslint-disable-next-line @typescript-eslint/no-explicit-any\n  private async resolveDriver(): Promise<CacheDriver<any, any>> {\n    if (this.resolvedDriver !== undefined) {\n      return this.resolvedDriver;\n    }\n\n    if (this.driverPending !== undefined) {\n      return this.driverPending;\n    }\n\n    const candidate =\n      typeof this.input === \"function\"\n        ? (this.input as () =>\n            // eslint-disable-next-line @typescript-eslint/no-explicit-any\n            | CacheDriver<any, any>\n            // eslint-disable-next-line @typescript-eslint/no-explicit-any\n            | Promise<CacheDriver<any, any>>)()\n        : this.input;\n\n    this.driverPending = Promise.resolve(candidate);\n\n    try {\n      this.resolvedDriver = await this.driverPending;\n\n      return this.resolvedDriver;\n    } finally {\n      this.driverPending = undefined;\n    }\n  }\n\n  /** `${prefix}:trace:${traceId}` — the per-trace cache key. */\n  private traceKey(traceId: string): string {\n    return `${this.prefix}:trace:${traceId}`;\n  }\n\n  /** `${prefix}:index` — the newest-first index cache key. */\n  private indexKey(): string {\n    return `${this.prefix}:index`;\n  }\n\n  /** Route a swallowed cache error to the optional handler. */\n  private reportError(error: unknown): void {\n    if (this.onError !== undefined) {\n      this.onError(error);\n    }\n  }\n\n  /**\n   * Increment the matching terminal-status counter for one trace.\n   * Mirrors the in-memory store: non-terminal statuses are counted in\n   * `traces` but tracked by none of the three headline counters.\n   */\n  private countStatus(aggregate: TraceAggregate, trace: Trace): void {\n    switch (trace.root.status) {\n      case \"completed\": {\n        aggregate.completed += 1;\n        break;\n      }\n\n      case \"failed\": {\n        aggregate.failed += 1;\n        break;\n      }\n\n      case \"cancelled\": {\n        aggregate.cancelled += 1;\n        break;\n      }\n\n      default: {\n        break;\n      }\n    }\n  }\n\n  /**\n   * Sort matched traces newest-started first. A copy is sorted so the\n   * mirror's insertion order (which eviction depends on) is never disturbed.\n   */\n  private sortNewestFirst(traces: Trace[]): Trace[] {\n    return traces.sort((left, right) => Date.parse(right.startedAt) - Date.parse(left.startedAt));\n  }\n\n  /**\n   * Evict oldest-inserted traces from the mirror until within `capacity`.\n   * Returns the id of the single evicted trace (the common case — one `add`\n   * pushes at most one over the cap) so the caller can remove it from the\n   * cache too. No-op + `undefined` when unbounded or within the cap.\n   */\n  private evictOverflow(): string | undefined {\n    if (this.capacity <= 0) {\n      return undefined;\n    }\n\n    let evicted: string | undefined;\n\n    while (this.mirror.size > this.capacity) {\n      const oldest = this.mirror.keys().next().value;\n\n      if (oldest === undefined) {\n        return evicted;\n      }\n\n      this.mirror.delete(oldest);\n      evicted = oldest;\n    }\n\n    return evicted;\n  }\n}\n\n/**\n * The concrete store type returned by {@link createCacheTraceStore} — the\n * standard {@link TraceStoreContract} + {@link ExporterContract} surface,\n * plus a `ready()` to hydrate the in-memory mirror from the cache on\n * startup so traces survive a process restart.\n */\nexport type CacheTraceStoreHandle = TraceStoreContract &\n  ExporterContract & {\n    /**\n     * Hydrate the in-memory mirror from the cache. Await once at startup\n     * (the dashboard wiring does this for you) so previously-persisted\n     * traces are queryable after a restart.\n     */\n    ready(): Promise<void>;\n  };\n\n/**\n * Create a cache-backed trace store. Reads are served synchronously from an\n * in-memory mirror; writes go through to the cache, and {@link\n * CacheTraceStoreHandle.ready} re-hydrates the mirror on startup so traces\n * survive a restart. See {@link CacheTraceStore} for the full write-through\n * design.\n *\n * @param cache a {@link CacheDriver}, or a (possibly async) factory that\n *   yields one on first use — resolved lazily and memoized so a production\n *   Redis connect can be deferred until the first trace is collected.\n * @param options `prefix` (default `\"panoptic\"`), `capacity` (FIFO cap),\n *   and an optional `onError` hook for swallowed cache write failures.\n *\n * @example\n * import { RedisCacheDriver } from \"@warlock.js/cache\";\n *\n * // Lazy async factory — defers the Redis connect until first use.\n * const store = createCacheTraceStore(async () => {\n *   const driver = new RedisCacheDriver();\n *   await driver.connect();\n *   return driver;\n * });\n *\n * await store.ready();      // hydrate from a prior run\n * collector.use(store);     // fills as traces complete\n * const failed = store.query({ status: \"failed\" });\n */\nexport function createCacheTraceStore(\n  cache: CacheDriverInput,\n  options: CacheTraceStoreOptions & { onError?: (error: unknown) => void } = {},\n): CacheTraceStoreHandle {\n  return new CacheTraceStore(cache, options);\n}\n"],"mappings":"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"}
+{"version":3,"file":"cache-trace-store.mjs","names":[],"sources":["../../../../../../../ai-panoptic/src/store/cache-trace-store.ts"],"sourcesContent":["import type { CacheDriver } from \"@warlock.js/cache\";\nimport type { ExporterContract } from \"../contracts/exporter.contract\";\nimport type { Trace } from \"../contracts/trace.type\";\nimport { matchTrace } from \"./match-trace\";\nimport { emptyUsage, sumUsage } from \"./sum-usage\";\nimport type { TraceAggregate } from \"./trace-aggregate.type\";\nimport type { TraceQuery } from \"./trace-query.type\";\nimport type { TraceStoreContract } from \"./trace-store.contract\";\n\n/**\n * A {@link CacheDriver} instance, or a (possibly async) factory that\n * yields one on first use. The factory form lets production defer an\n * expensive connect (e.g. the Redis handshake) until the first trace is\n * actually written, and keeps the dashboard wiring free of a live driver\n * at module-import time.\n *\n * Typed `CacheDriver<any, any>` because the store only ever touches the\n * driver's `get` / `set` / `remove` surface and is agnostic to the\n * concrete client + options of whichever driver backs it.\n */\nexport type CacheDriverInput =\n  // The store is driver-agnostic; it only uses get/set/remove, so the\n  // concrete client/options generics are intentionally unconstrained.\n  // eslint-disable-next-line @typescript-eslint/no-explicit-any\n  | CacheDriver<any, any>\n  // eslint-disable-next-line @typescript-eslint/no-explicit-any\n  | (() => CacheDriver<any, any> | Promise<CacheDriver<any, any>>);\n\n/**\n * Options for {@link createCacheTraceStore}.\n */\nexport type CacheTraceStoreOptions = {\n  /**\n   * Key prefix every cache entry this store writes is namespaced under.\n   * Per-trace keys are `${prefix}:trace:${traceId}`; the newest-first\n   * index lives at `${prefix}:index`. Default `\"panoptic\"`.\n   */\n  prefix?: string;\n  /**\n   * Maximum number of traces to retain. When set and exceeded, the\n   * oldest-ingested trace is evicted from both the cache and the in-memory\n   * mirror (insertion-order FIFO). Absent / `0` = unbounded.\n   */\n  capacity?: number;\n};\n\n/** One entry in the persisted newest-first index. */\ntype IndexEntry = {\n  /** The trace's `traceId` — the suffix of its `${prefix}:trace:` key. */\n  id: string;\n  /**\n   * Monotonic insertion order from an internal counter — NOT a wall clock.\n   * Used only to keep the index in stable insertion order across a restart\n   * so FIFO eviction stays honest.\n   */\n  addedAt: number;\n};\n\nconst DEFAULT_PREFIX = \"panoptic\";\n\n/**\n * Cache-backed {@link TraceStoreContract} with a **write-through** design\n * that reconciles the synchronous store contract with an asynchronous\n * cache driver.\n *\n * **How the sync/async tension is resolved.** The contract's `get` /\n * `query` / `aggregate` / `size` are synchronous (the dashboard polls them\n * on every request and the in-memory store answers instantly). A cache\n * driver is async. So this store keeps an **in-memory read mirror** — the\n * same insertion-ordered `Map<traceId, Trace>` the in-memory store uses —\n * and serves every read from it synchronously. Writes go **through** to the\n * cache: `add` updates the mirror immediately, then asynchronously persists\n * the trace + index to the cache (errors are swallowed via an optional\n * `onError` hook so a flaky cache never throws into the collector's hot\n * path). On process restart, {@link CacheTraceStore.ready} re-hydrates the\n * mirror from the cache so traces survive the restart.\n *\n * **Durability is best-effort.** Reads never wait on the cache; the mirror\n * is the source of truth at runtime and the cache is the durable backing\n * store. A write that the cache rejects is still visible in the mirror for\n * the life of the process — it just won't survive a restart.\n *\n * **Lazy driver resolution.** The driver (or its async factory) is resolved\n * on first use and memoized, so a production deployment can defer the Redis\n * connect until the first trace is collected, and the dashboard can be\n * wired with a factory at import time without a live connection.\n *\n * Doubles as an {@link ExporterContract} (`export` ≡ `add`), so it drops\n * straight into a collector via `collector.use(store)`.\n *\n * Instantiated via {@link createCacheTraceStore}; callers never see `new`.\n */\nclass CacheTraceStore implements TraceStoreContract, ExporterContract {\n  /** Stable exporter id so a collector can dedupe / log this sink. */\n  public readonly name = \"cache-trace-store\";\n\n  /**\n   * In-memory read mirror keyed by `traceId`. A `Map` preserves insertion\n   * order, which newest-first `query` ordering and FIFO eviction both rely\n   * on. Every read is served from here synchronously.\n   */\n  private readonly mirror = new Map<string, Trace>();\n\n  private readonly prefix: string;\n\n  private readonly capacity: number;\n\n  /**\n   * Monotonic insertion counter — the source of `IndexEntry.addedAt`.\n   * Deliberately NOT `Date.now()`: an internal counter guarantees a stable\n   * total order for the index even when many traces land in the same\n   * millisecond.\n   */\n  private addCounter = 0;\n\n  /** The optional input — a driver, a factory, or `undefined`. */\n  private readonly input: CacheDriverInput;\n\n  // The store is driver-agnostic; only get/set/remove are used.\n  // eslint-disable-next-line @typescript-eslint/no-explicit-any\n  private resolvedDriver?: CacheDriver<any, any>;\n\n  // eslint-disable-next-line @typescript-eslint/no-explicit-any\n  private driverPending?: Promise<CacheDriver<any, any>>;\n\n  private readonly onError?: (error: unknown) => void;\n\n  public constructor(\n    input: CacheDriverInput,\n    options: CacheTraceStoreOptions & { onError?: (error: unknown) => void } = {},\n  ) {\n    this.input = input;\n    this.prefix = options.prefix ?? DEFAULT_PREFIX;\n    this.capacity = options.capacity ?? 0;\n    this.onError = options.onError;\n  }\n\n  public get size(): number {\n    return this.mirror.size;\n  }\n\n  /**\n   * Hydrate the in-memory mirror from the cache. Idempotent-safe to call\n   * once at startup (the dashboard / config wiring awaits it). Reads the\n   * persisted index, fetches each referenced trace, and replays them into\n   * the mirror in insertion order so newest-first ordering + eviction stay\n   * correct after a restart. A cache failure is routed to `onError` and\n   * leaves the mirror empty rather than throwing.\n   */\n  public async ready(): Promise<void> {\n    try {\n      const driver = await this.resolveDriver();\n      const index = await driver.get<IndexEntry[]>(this.indexKey());\n\n      if (!Array.isArray(index)) {\n        return;\n      }\n\n      // Oldest-first replay so the mirror's insertion order matches the\n      // original ingestion order.\n      const ordered = [...index].sort((left, right) => left.addedAt - right.addedAt);\n\n      for (const entry of ordered) {\n        const trace = await driver.get<Trace>(this.traceKey(entry.id));\n\n        if (trace !== null && trace !== undefined) {\n          this.mirror.delete(trace.traceId);\n          this.mirror.set(trace.traceId, trace);\n        }\n\n        if (entry.addedAt >= this.addCounter) {\n          this.addCounter = entry.addedAt + 1;\n        }\n      }\n\n      this.evictOverflow();\n    } catch (error) {\n      this.reportError(error);\n    }\n  }\n\n  public add(trace: Trace): void {\n    // Mirror update is synchronous and authoritative for runtime reads.\n    this.mirror.delete(trace.traceId);\n    this.mirror.set(trace.traceId, trace);\n\n    const addedAt = this.addCounter;\n    this.addCounter += 1;\n\n    const evicted = this.evictOverflow();\n\n    // Write through to the cache fire-and-forget; reads never wait on this.\n    void this.persist(trace, addedAt, evicted);\n  }\n\n  /**\n   * `ExporterContract.export` — a collector dispatches a completed trace\n   * here, which is exactly an `add`.\n   */\n  public export(trace: Trace): void {\n    this.add(trace);\n  }\n\n  public get(traceId: string): Trace | undefined {\n    return this.mirror.get(traceId);\n  }\n\n  public query(filter?: TraceQuery): Trace[] {\n    const matched: Trace[] = [];\n\n    for (const trace of this.mirror.values()) {\n      if (matchTrace(trace, filter)) {\n        matched.push(trace);\n      }\n    }\n\n    return this.sortNewestFirst(matched);\n  }\n\n  public aggregate(filter?: TraceQuery): TraceAggregate {\n    const aggregate: TraceAggregate = {\n      traces: 0,\n      completed: 0,\n      failed: 0,\n      cancelled: 0,\n      usage: emptyUsage(),\n      totalDuration: 0,\n    };\n\n    for (const trace of this.mirror.values()) {\n      if (!matchTrace(trace, filter)) {\n        continue;\n      }\n\n      aggregate.traces += 1;\n      aggregate.totalDuration += trace.duration;\n      aggregate.usage = sumUsage(aggregate.usage, trace.usage);\n\n      this.countStatus(aggregate, trace);\n    }\n\n    if (aggregate.usage.cost !== undefined) {\n      aggregate.cost = aggregate.usage.cost;\n    }\n\n    return aggregate;\n  }\n\n  public clear(): void {\n    const ids = [...this.mirror.keys()];\n    this.mirror.clear();\n\n    void this.purge(ids);\n  }\n\n  /**\n   * Persist one trace + the rebuilt index to the cache, optionally removing\n   * a trace evicted by the capacity cap. Best-effort: any cache failure is\n   * routed to `onError`, never thrown — the mirror already reflects the\n   * write so runtime reads are unaffected.\n   */\n  private async persist(\n    trace: Trace,\n    addedAt: number,\n    evictedId: string | undefined,\n  ): Promise<void> {\n    try {\n      const driver = await this.resolveDriver();\n\n      await driver.set(this.traceKey(trace.traceId), trace);\n\n      if (evictedId !== undefined) {\n        await driver.remove(this.traceKey(evictedId));\n      }\n\n      await driver.set(this.indexKey(), this.buildIndex(addedAt));\n    } catch (error) {\n      this.reportError(error);\n    }\n  }\n\n  /** Best-effort removal of every persisted trace + the index on `clear`. */\n  private async purge(ids: string[]): Promise<void> {\n    try {\n      const driver = await this.resolveDriver();\n\n      for (const id of ids) {\n        await driver.remove(this.traceKey(id));\n      }\n\n      await driver.remove(this.indexKey());\n    } catch (error) {\n      this.reportError(error);\n    }\n  }\n\n  /**\n   * Rebuild the newest-first index from the current mirror. The mirror's\n   * `Map` iteration is oldest-first insertion order; we walk it and assign\n   * `addedAt` from the surviving counter span so the persisted order\n   * matches the in-memory one. The freshest entry uses `latestAddedAt`.\n   */\n  private buildIndex(latestAddedAt: number): IndexEntry[] {\n    const ids = [...this.mirror.keys()];\n    const base = latestAddedAt - (ids.length - 1);\n\n    return ids.map((id, offset) => ({ id, addedAt: base + offset }));\n  }\n\n  /**\n   * Resolve the driver once and memoize. Supports a bare driver, a sync\n   * factory, and an async factory. Concurrent first-callers share one\n   * in-flight resolution.\n   */\n  // eslint-disable-next-line @typescript-eslint/no-explicit-any\n  private async resolveDriver(): Promise<CacheDriver<any, any>> {\n    if (this.resolvedDriver !== undefined) {\n      return this.resolvedDriver;\n    }\n\n    if (this.driverPending !== undefined) {\n      return this.driverPending;\n    }\n\n    const candidate =\n      typeof this.input === \"function\"\n        ? (this.input as () =>\n            // eslint-disable-next-line @typescript-eslint/no-explicit-any\n            | CacheDriver<any, any>\n            // eslint-disable-next-line @typescript-eslint/no-explicit-any\n            | Promise<CacheDriver<any, any>>)()\n        : this.input;\n\n    this.driverPending = Promise.resolve(candidate);\n\n    try {\n      this.resolvedDriver = await this.driverPending;\n\n      return this.resolvedDriver;\n    } finally {\n      this.driverPending = undefined;\n    }\n  }\n\n  /** `${prefix}:trace:${traceId}` — the per-trace cache key. */\n  private traceKey(traceId: string): string {\n    return `${this.prefix}:trace:${traceId}`;\n  }\n\n  /** `${prefix}:index` — the newest-first index cache key. */\n  private indexKey(): string {\n    return `${this.prefix}:index`;\n  }\n\n  /** Route a swallowed cache error to the optional handler. */\n  private reportError(error: unknown): void {\n    if (this.onError !== undefined) {\n      this.onError(error);\n    }\n  }\n\n  /**\n   * Increment the matching terminal-status counter for one trace.\n   * Mirrors the in-memory store: non-terminal statuses are counted in\n   * `traces` but tracked by none of the three headline counters.\n   */\n  private countStatus(aggregate: TraceAggregate, trace: Trace): void {\n    switch (trace.root.status) {\n      case \"completed\": {\n        aggregate.completed += 1;\n        break;\n      }\n\n      case \"failed\": {\n        aggregate.failed += 1;\n        break;\n      }\n\n      case \"cancelled\": {\n        aggregate.cancelled += 1;\n        break;\n      }\n\n      default: {\n        break;\n      }\n    }\n  }\n\n  /**\n   * Sort matched traces newest-started first. A copy is sorted so the\n   * mirror's insertion order (which eviction depends on) is never disturbed.\n   */\n  private sortNewestFirst(traces: Trace[]): Trace[] {\n    return traces.sort((left, right) => Date.parse(right.startedAt) - Date.parse(left.startedAt));\n  }\n\n  /**\n   * Evict oldest-inserted traces from the mirror until within `capacity`.\n   * Returns the id of the single evicted trace (the common case — one `add`\n   * pushes at most one over the cap) so the caller can remove it from the\n   * cache too. No-op + `undefined` when unbounded or within the cap.\n   */\n  private evictOverflow(): string | undefined {\n    if (this.capacity <= 0) {\n      return undefined;\n    }\n\n    let evicted: string | undefined;\n\n    while (this.mirror.size > this.capacity) {\n      const oldest = this.mirror.keys().next().value;\n\n      if (oldest === undefined) {\n        return evicted;\n      }\n\n      this.mirror.delete(oldest);\n      evicted = oldest;\n    }\n\n    return evicted;\n  }\n}\n\n/**\n * The concrete store type returned by {@link createCacheTraceStore} — the\n * standard {@link TraceStoreContract} + {@link ExporterContract} surface,\n * plus a `ready()` to hydrate the in-memory mirror from the cache on\n * startup so traces survive a process restart.\n */\nexport type CacheTraceStoreHandle = TraceStoreContract &\n  ExporterContract & {\n    /**\n     * Hydrate the in-memory mirror from the cache. Await once at startup\n     * (the dashboard wiring does this for you) so previously-persisted\n     * traces are queryable after a restart.\n     */\n    ready(): Promise<void>;\n  };\n\n/**\n * Create a cache-backed trace store. Reads are served synchronously from an\n * in-memory mirror; writes go through to the cache, and {@link\n * CacheTraceStoreHandle.ready} re-hydrates the mirror on startup so traces\n * survive a restart. See {@link CacheTraceStore} for the full write-through\n * design.\n *\n * @param cache a {@link CacheDriver}, or a (possibly async) factory that\n *   yields one on first use — resolved lazily and memoized so a production\n *   Redis connect can be deferred until the first trace is collected.\n * @param options `prefix` (default `\"panoptic\"`), `capacity` (FIFO cap),\n *   and an optional `onError` hook for swallowed cache write failures.\n *\n * @example\n * import { RedisCacheDriver } from \"@warlock.js/cache\";\n *\n * // Lazy async factory — defers the Redis connect until first use.\n * const store = createCacheTraceStore(async () => {\n *   const driver = new RedisCacheDriver();\n *   await driver.connect();\n *   return driver;\n * });\n *\n * await store.ready();      // hydrate from a prior run\n * collector.use(store);     // fills as traces complete\n * const failed = store.query({ status: \"failed\" });\n */\nexport function createCacheTraceStore(\n  cache: CacheDriverInput,\n  options: CacheTraceStoreOptions & { onError?: (error: unknown) => void } = {},\n): CacheTraceStoreHandle {\n  return new CacheTraceStore(cache, options);\n}\n"],"mappings":"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"}

package/esm/store/in-memory-trace-store.d.mts

@@ -1,7 +1,7 @@
 import { ExporterContract } from "../contracts/exporter.contract.mjs";
 import { TraceStoreContract } from "./trace-store.contract.mjs";
 
-//#region ../@warlock.js/ai-panoptic/src/store/in-memory-trace-store.d.ts
+//#region ../ai-panoptic/src/store/in-memory-trace-store.d.ts
 /**
  * Options for {@link createInMemoryTraceStore}.
  */

package/esm/store/in-memory-trace-store.d.mts.map

@@ -1 +1 @@
-{"version":3,"file":"in-memory-trace-store.d.mts","names":[],"sources":["../../../../../../../@warlock.js/ai-panoptic/src/store/in-memory-trace-store.ts"],"mappings":";;;;;;AAWA;KAAY,yBAAA;;;AAOF;AAoLV;;;EApLE,QAAQ;AAAA;;;;;;;;;AAoL0G;;;;iBAApG,wBAAA,CAAyB,OAAA,GAAU,yBAAA,GAA4B,kBAAA,GAAqB,gBAAA"}
+{"version":3,"file":"in-memory-trace-store.d.mts","names":[],"sources":["../../../../../../../ai-panoptic/src/store/in-memory-trace-store.ts"],"mappings":";;;;;;AAWA;KAAY,yBAAA;;;AAOF;AAoLV;;;EApLE,QAAQ;AAAA;;;;;;;;;AAoL0G;;;;iBAApG,wBAAA,CAAyB,OAAA,GAAU,yBAAA,GAA4B,kBAAA,GAAqB,gBAAA"}

package/esm/store/in-memory-trace-store.mjs

@@ -1,7 +1,7 @@
 import { matchTrace } from "./match-trace.mjs";
 import { emptyUsage, sumUsage } from "./sum-usage.mjs";
 
-//#region ../@warlock.js/ai-panoptic/src/store/in-memory-trace-store.ts
+//#region ../ai-panoptic/src/store/in-memory-trace-store.ts
 /**
 * In-memory {@link TraceStoreContract} that doubles as an
 * {@link ExporterContract} — register it on a collector

package/esm/store/in-memory-trace-store.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"in-memory-trace-store.mjs","names":[],"sources":["../../../../../../../@warlock.js/ai-panoptic/src/store/in-memory-trace-store.ts"],"sourcesContent":["import type { ExporterContract } from \"../contracts/exporter.contract\";\nimport type { Trace } from \"../contracts/trace.type\";\nimport { matchTrace } from \"./match-trace\";\nimport { emptyUsage, sumUsage } from \"./sum-usage\";\nimport type { TraceAggregate } from \"./trace-aggregate.type\";\nimport type { TraceQuery } from \"./trace-query.type\";\nimport type { TraceStoreContract } from \"./trace-store.contract\";\n\n/**\n * Options for {@link createInMemoryTraceStore}.\n */\nexport type InMemoryTraceStoreOptions = {\n  /**\n   * Maximum number of traces to retain. When set and exceeded, the\n   * oldest-ingested trace is evicted (insertion-order FIFO) so the\n   * store stays bounded for long-lived processes. Absent / `0` =\n   * unbounded (keep everything until `clear`).\n   */\n  capacity?: number;\n};\n\n/**\n * In-memory {@link TraceStoreContract} that doubles as an\n * {@link ExporterContract} — register it on a collector\n * (`collector.use(store)`) and it fills as traces complete, then query\n * or aggregate it after the fact.\n *\n * Backed by an insertion-ordered `Map` keyed by `traceId`, giving O(1)\n * `get` / `add` / overwrite and O(n) scans for `query` / `aggregate`\n * (the price of an in-memory store with no secondary indexes — fine for\n * the dev/test and modest-volume runtime use this targets). When a\n * `capacity` is configured, ingesting past the cap evicts the oldest\n * trace.\n *\n * Instantiated fresh per store via {@link createInMemoryTraceStore};\n * callers never see `new`.\n */\nclass InMemoryTraceStore implements TraceStoreContract, ExporterContract {\n  /** Stable exporter id so a collector can dedupe / log this sink. */\n  public readonly name = \"in-memory-trace-store\";\n\n  /**\n   * Retained traces keyed by `traceId`. A `Map` preserves insertion\n   * order, which is what FIFO eviction and newest-first `query` ordering\n   * both rely on.\n   */\n  private readonly traces = new Map<string, Trace>();\n\n  private readonly capacity: number;\n\n  public constructor(options?: InMemoryTraceStoreOptions) {\n    this.capacity = options?.capacity ?? 0;\n  }\n\n  public get size(): number {\n    return this.traces.size;\n  }\n\n  public add(trace: Trace): void {\n    // Re-insert so an overwrite also refreshes insertion position —\n    // keeps \"oldest\" honest for FIFO eviction.\n    this.traces.delete(trace.traceId);\n    this.traces.set(trace.traceId, trace);\n\n    this.evictOverflow();\n  }\n\n  /**\n   * `ExporterContract.export` — a collector dispatches a completed\n   * trace here, which is exactly an `add`. Lets the store be wired into\n   * a collector as a sink without an adapter.\n   */\n  public export(trace: Trace): void {\n    this.add(trace);\n  }\n\n  public get(traceId: string): Trace | undefined {\n    return this.traces.get(traceId);\n  }\n\n  public query(filter?: TraceQuery): Trace[] {\n    const matched: Trace[] = [];\n\n    for (const trace of this.traces.values()) {\n      if (matchTrace(trace, filter)) {\n        matched.push(trace);\n      }\n    }\n\n    return this.sortNewestFirst(matched);\n  }\n\n  public aggregate(filter?: TraceQuery): TraceAggregate {\n    const aggregate: TraceAggregate = {\n      traces: 0,\n      completed: 0,\n      failed: 0,\n      cancelled: 0,\n      usage: emptyUsage(),\n      totalDuration: 0,\n    };\n\n    for (const trace of this.traces.values()) {\n      if (!matchTrace(trace, filter)) {\n        continue;\n      }\n\n      aggregate.traces += 1;\n      aggregate.totalDuration += trace.duration;\n      aggregate.usage = sumUsage(aggregate.usage, trace.usage);\n\n      this.countStatus(aggregate, trace);\n    }\n\n    if (aggregate.usage.cost !== undefined) {\n      aggregate.cost = aggregate.usage.cost;\n    }\n\n    return aggregate;\n  }\n\n  public clear(): void {\n    this.traces.clear();\n  }\n\n  /**\n   * Increment the matching terminal-status counter for one trace.\n   * Non-terminal statuses (`awaiting-input`, `max-iterations`) are\n   * counted in `traces` but tracked by none of the three headline\n   * counters — intentional, those three answer the common\n   * \"succeeded / errored / aborted\" question.\n   */\n  private countStatus(aggregate: TraceAggregate, trace: Trace): void {\n    switch (trace.root.status) {\n      case \"completed\": {\n        aggregate.completed += 1;\n        break;\n      }\n\n      case \"failed\": {\n        aggregate.failed += 1;\n        break;\n      }\n\n      case \"cancelled\": {\n        aggregate.cancelled += 1;\n        break;\n      }\n\n      default: {\n        break;\n      }\n    }\n  }\n\n  /**\n   * Sort matched traces newest-started first. A copy is sorted so the\n   * underlying insertion order (which eviction depends on) is never\n   * disturbed.\n   */\n  private sortNewestFirst(traces: Trace[]): Trace[] {\n    return traces.sort((left, right) => Date.parse(right.startedAt) - Date.parse(left.startedAt));\n  }\n\n  /**\n   * Evict oldest-inserted traces until the store is within `capacity`.\n   * No-op when unbounded. The `Map` iterator yields keys in insertion\n   * order, so the first key is always the oldest.\n   */\n  private evictOverflow(): void {\n    if (this.capacity <= 0) {\n      return;\n    }\n\n    while (this.traces.size > this.capacity) {\n      const oldest = this.traces.keys().next().value;\n\n      if (oldest === undefined) {\n        return;\n      }\n\n      this.traces.delete(oldest);\n    }\n  }\n}\n\n/**\n * Create an in-memory trace store. Optionally bound it with `capacity`\n * for long-lived processes; leave it unset for dev/test where you want\n * every trace retained.\n *\n * @example\n * const store = createInMemoryTraceStore({ capacity: 1000 });\n * collector.use(store);\n * // later:\n * const recentFailures = store.query({ status: \"failed\" });\n * const sessionSpend = store.aggregate({ sessionId });\n */\nexport function createInMemoryTraceStore(options?: InMemoryTraceStoreOptions): TraceStoreContract & ExporterContract {\n  return new InMemoryTraceStore(options);\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;AAqCA,IAAM,qBAAN,MAAyE;;CAEvE,AAAgB,OAAO;;;;;;CAOvB,AAAiB,yBAAS,IAAI,IAAmB;CAEjD,AAAiB;CAEjB,AAAO,YAAY,SAAqC;EACtD,KAAK,WAAW,SAAS,YAAY;CACvC;CAEA,IAAW,OAAe;EACxB,OAAO,KAAK,OAAO;CACrB;CAEA,AAAO,IAAI,OAAoB;EAG7B,KAAK,OAAO,OAAO,MAAM,OAAO;EAChC,KAAK,OAAO,IAAI,MAAM,SAAS,KAAK;EAEpC,KAAK,cAAc;CACrB;;;;;;CAOA,AAAO,OAAO,OAAoB;EAChC,KAAK,IAAI,KAAK;CAChB;CAEA,AAAO,IAAI,SAAoC;EAC7C,OAAO,KAAK,OAAO,IAAI,OAAO;CAChC;CAEA,AAAO,MAAM,QAA8B;EACzC,MAAM,UAAmB,CAAC;EAE1B,KAAK,MAAM,SAAS,KAAK,OAAO,OAAO,GACrC,IAAI,WAAW,OAAO,MAAM,GAC1B,QAAQ,KAAK,KAAK;EAItB,OAAO,KAAK,gBAAgB,OAAO;CACrC;CAEA,AAAO,UAAU,QAAqC;EACpD,MAAM,YAA4B;GAChC,QAAQ;GACR,WAAW;GACX,QAAQ;GACR,WAAW;GACX,OAAO,WAAW;GAClB,eAAe;EACjB;EAEA,KAAK,MAAM,SAAS,KAAK,OAAO,OAAO,GAAG;GACxC,IAAI,CAAC,WAAW,OAAO,MAAM,GAC3B;GAGF,UAAU,UAAU;GACpB,UAAU,iBAAiB,MAAM;GACjC,UAAU,QAAQ,SAAS,UAAU,OAAO,MAAM,KAAK;GAEvD,KAAK,YAAY,WAAW,KAAK;EACnC;EAEA,IAAI,UAAU,MAAM,SAAS,QAC3B,UAAU,OAAO,UAAU,MAAM;EAGnC,OAAO;CACT;CAEA,AAAO,QAAc;EACnB,KAAK,OAAO,MAAM;CACpB;;;;;;;;CASA,AAAQ,YAAY,WAA2B,OAAoB;EACjE,QAAQ,MAAM,KAAK,QAAnB;GACE,KAAK;IACH,UAAU,aAAa;IACvB;GAGF,KAAK;IACH,UAAU,UAAU;IACpB;GAGF,KAAK;IACH,UAAU,aAAa;IACvB;GAGF,SACE;EAEJ;CACF;;;;;;CAOA,AAAQ,gBAAgB,QAA0B;EAChD,OAAO,OAAO,MAAM,MAAM,UAAU,KAAK,MAAM,MAAM,SAAS,IAAI,KAAK,MAAM,KAAK,SAAS,CAAC;CAC9F;;;;;;CAOA,AAAQ,gBAAsB;EAC5B,IAAI,KAAK,YAAY,GACnB;EAGF,OAAO,KAAK,OAAO,OAAO,KAAK,UAAU;GACvC,MAAM,SAAS,KAAK,OAAO,KAAK,CAAC,CAAC,KAAK,CAAC,CAAC;GAEzC,IAAI,WAAW,QACb;GAGF,KAAK,OAAO,OAAO,MAAM;EAC3B;CACF;AACF;;;;;;;;;;;;;AAcA,SAAgB,yBAAyB,SAA4E;CACnH,OAAO,IAAI,mBAAmB,OAAO;AACvC"}
+{"version":3,"file":"in-memory-trace-store.mjs","names":[],"sources":["../../../../../../../ai-panoptic/src/store/in-memory-trace-store.ts"],"sourcesContent":["import type { ExporterContract } from \"../contracts/exporter.contract\";\nimport type { Trace } from \"../contracts/trace.type\";\nimport { matchTrace } from \"./match-trace\";\nimport { emptyUsage, sumUsage } from \"./sum-usage\";\nimport type { TraceAggregate } from \"./trace-aggregate.type\";\nimport type { TraceQuery } from \"./trace-query.type\";\nimport type { TraceStoreContract } from \"./trace-store.contract\";\n\n/**\n * Options for {@link createInMemoryTraceStore}.\n */\nexport type InMemoryTraceStoreOptions = {\n  /**\n   * Maximum number of traces to retain. When set and exceeded, the\n   * oldest-ingested trace is evicted (insertion-order FIFO) so the\n   * store stays bounded for long-lived processes. Absent / `0` =\n   * unbounded (keep everything until `clear`).\n   */\n  capacity?: number;\n};\n\n/**\n * In-memory {@link TraceStoreContract} that doubles as an\n * {@link ExporterContract} — register it on a collector\n * (`collector.use(store)`) and it fills as traces complete, then query\n * or aggregate it after the fact.\n *\n * Backed by an insertion-ordered `Map` keyed by `traceId`, giving O(1)\n * `get` / `add` / overwrite and O(n) scans for `query` / `aggregate`\n * (the price of an in-memory store with no secondary indexes — fine for\n * the dev/test and modest-volume runtime use this targets). When a\n * `capacity` is configured, ingesting past the cap evicts the oldest\n * trace.\n *\n * Instantiated fresh per store via {@link createInMemoryTraceStore};\n * callers never see `new`.\n */\nclass InMemoryTraceStore implements TraceStoreContract, ExporterContract {\n  /** Stable exporter id so a collector can dedupe / log this sink. */\n  public readonly name = \"in-memory-trace-store\";\n\n  /**\n   * Retained traces keyed by `traceId`. A `Map` preserves insertion\n   * order, which is what FIFO eviction and newest-first `query` ordering\n   * both rely on.\n   */\n  private readonly traces = new Map<string, Trace>();\n\n  private readonly capacity: number;\n\n  public constructor(options?: InMemoryTraceStoreOptions) {\n    this.capacity = options?.capacity ?? 0;\n  }\n\n  public get size(): number {\n    return this.traces.size;\n  }\n\n  public add(trace: Trace): void {\n    // Re-insert so an overwrite also refreshes insertion position —\n    // keeps \"oldest\" honest for FIFO eviction.\n    this.traces.delete(trace.traceId);\n    this.traces.set(trace.traceId, trace);\n\n    this.evictOverflow();\n  }\n\n  /**\n   * `ExporterContract.export` — a collector dispatches a completed\n   * trace here, which is exactly an `add`. Lets the store be wired into\n   * a collector as a sink without an adapter.\n   */\n  public export(trace: Trace): void {\n    this.add(trace);\n  }\n\n  public get(traceId: string): Trace | undefined {\n    return this.traces.get(traceId);\n  }\n\n  public query(filter?: TraceQuery): Trace[] {\n    const matched: Trace[] = [];\n\n    for (const trace of this.traces.values()) {\n      if (matchTrace(trace, filter)) {\n        matched.push(trace);\n      }\n    }\n\n    return this.sortNewestFirst(matched);\n  }\n\n  public aggregate(filter?: TraceQuery): TraceAggregate {\n    const aggregate: TraceAggregate = {\n      traces: 0,\n      completed: 0,\n      failed: 0,\n      cancelled: 0,\n      usage: emptyUsage(),\n      totalDuration: 0,\n    };\n\n    for (const trace of this.traces.values()) {\n      if (!matchTrace(trace, filter)) {\n        continue;\n      }\n\n      aggregate.traces += 1;\n      aggregate.totalDuration += trace.duration;\n      aggregate.usage = sumUsage(aggregate.usage, trace.usage);\n\n      this.countStatus(aggregate, trace);\n    }\n\n    if (aggregate.usage.cost !== undefined) {\n      aggregate.cost = aggregate.usage.cost;\n    }\n\n    return aggregate;\n  }\n\n  public clear(): void {\n    this.traces.clear();\n  }\n\n  /**\n   * Increment the matching terminal-status counter for one trace.\n   * Non-terminal statuses (`awaiting-input`, `max-iterations`) are\n   * counted in `traces` but tracked by none of the three headline\n   * counters — intentional, those three answer the common\n   * \"succeeded / errored / aborted\" question.\n   */\n  private countStatus(aggregate: TraceAggregate, trace: Trace): void {\n    switch (trace.root.status) {\n      case \"completed\": {\n        aggregate.completed += 1;\n        break;\n      }\n\n      case \"failed\": {\n        aggregate.failed += 1;\n        break;\n      }\n\n      case \"cancelled\": {\n        aggregate.cancelled += 1;\n        break;\n      }\n\n      default: {\n        break;\n      }\n    }\n  }\n\n  /**\n   * Sort matched traces newest-started first. A copy is sorted so the\n   * underlying insertion order (which eviction depends on) is never\n   * disturbed.\n   */\n  private sortNewestFirst(traces: Trace[]): Trace[] {\n    return traces.sort((left, right) => Date.parse(right.startedAt) - Date.parse(left.startedAt));\n  }\n\n  /**\n   * Evict oldest-inserted traces until the store is within `capacity`.\n   * No-op when unbounded. The `Map` iterator yields keys in insertion\n   * order, so the first key is always the oldest.\n   */\n  private evictOverflow(): void {\n    if (this.capacity <= 0) {\n      return;\n    }\n\n    while (this.traces.size > this.capacity) {\n      const oldest = this.traces.keys().next().value;\n\n      if (oldest === undefined) {\n        return;\n      }\n\n      this.traces.delete(oldest);\n    }\n  }\n}\n\n/**\n * Create an in-memory trace store. Optionally bound it with `capacity`\n * for long-lived processes; leave it unset for dev/test where you want\n * every trace retained.\n *\n * @example\n * const store = createInMemoryTraceStore({ capacity: 1000 });\n * collector.use(store);\n * // later:\n * const recentFailures = store.query({ status: \"failed\" });\n * const sessionSpend = store.aggregate({ sessionId });\n */\nexport function createInMemoryTraceStore(options?: InMemoryTraceStoreOptions): TraceStoreContract & ExporterContract {\n  return new InMemoryTraceStore(options);\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;AAqCA,IAAM,qBAAN,MAAyE;;CAEvE,AAAgB,OAAO;;;;;;CAOvB,AAAiB,yBAAS,IAAI,IAAmB;CAEjD,AAAiB;CAEjB,AAAO,YAAY,SAAqC;EACtD,KAAK,WAAW,SAAS,YAAY;CACvC;CAEA,IAAW,OAAe;EACxB,OAAO,KAAK,OAAO;CACrB;CAEA,AAAO,IAAI,OAAoB;EAG7B,KAAK,OAAO,OAAO,MAAM,OAAO;EAChC,KAAK,OAAO,IAAI,MAAM,SAAS,KAAK;EAEpC,KAAK,cAAc;CACrB;;;;;;CAOA,AAAO,OAAO,OAAoB;EAChC,KAAK,IAAI,KAAK;CAChB;CAEA,AAAO,IAAI,SAAoC;EAC7C,OAAO,KAAK,OAAO,IAAI,OAAO;CAChC;CAEA,AAAO,MAAM,QAA8B;EACzC,MAAM,UAAmB,CAAC;EAE1B,KAAK,MAAM,SAAS,KAAK,OAAO,OAAO,GACrC,IAAI,WAAW,OAAO,MAAM,GAC1B,QAAQ,KAAK,KAAK;EAItB,OAAO,KAAK,gBAAgB,OAAO;CACrC;CAEA,AAAO,UAAU,QAAqC;EACpD,MAAM,YAA4B;GAChC,QAAQ;GACR,WAAW;GACX,QAAQ;GACR,WAAW;GACX,OAAO,WAAW;GAClB,eAAe;EACjB;EAEA,KAAK,MAAM,SAAS,KAAK,OAAO,OAAO,GAAG;GACxC,IAAI,CAAC,WAAW,OAAO,MAAM,GAC3B;GAGF,UAAU,UAAU;GACpB,UAAU,iBAAiB,MAAM;GACjC,UAAU,QAAQ,SAAS,UAAU,OAAO,MAAM,KAAK;GAEvD,KAAK,YAAY,WAAW,KAAK;EACnC;EAEA,IAAI,UAAU,MAAM,SAAS,QAC3B,UAAU,OAAO,UAAU,MAAM;EAGnC,OAAO;CACT;CAEA,AAAO,QAAc;EACnB,KAAK,OAAO,MAAM;CACpB;;;;;;;;CASA,AAAQ,YAAY,WAA2B,OAAoB;EACjE,QAAQ,MAAM,KAAK,QAAnB;GACE,KAAK;IACH,UAAU,aAAa;IACvB;GAGF,KAAK;IACH,UAAU,UAAU;IACpB;GAGF,KAAK;IACH,UAAU,aAAa;IACvB;GAGF,SACE;EAEJ;CACF;;;;;;CAOA,AAAQ,gBAAgB,QAA0B;EAChD,OAAO,OAAO,MAAM,MAAM,UAAU,KAAK,MAAM,MAAM,SAAS,IAAI,KAAK,MAAM,KAAK,SAAS,CAAC;CAC9F;;;;;;CAOA,AAAQ,gBAAsB;EAC5B,IAAI,KAAK,YAAY,GACnB;EAGF,OAAO,KAAK,OAAO,OAAO,KAAK,UAAU;GACvC,MAAM,SAAS,KAAK,OAAO,KAAK,CAAC,CAAC,KAAK,CAAC,CAAC;GAEzC,IAAI,WAAW,QACb;GAGF,KAAK,OAAO,OAAO,MAAM;EAC3B;CACF;AACF;;;;;;;;;;;;;AAcA,SAAgB,yBAAyB,SAA4E;CACnH,OAAO,IAAI,mBAAmB,OAAO;AACvC"}

package/esm/store/match-trace.d.mts

@@ -1,7 +1,7 @@
 import { Trace } from "../contracts/trace.type.mjs";
 import { TraceQuery } from "./trace-query.type.mjs";
 
-//#region ../@warlock.js/ai-panoptic/src/store/match-trace.d.ts
+//#region ../ai-panoptic/src/store/match-trace.d.ts
 /**
  * Test whether one trace satisfies a {@link TraceQuery}. Every declared
  * filter field must match (logical AND); absent fields are ignored, so

package/esm/store/match-trace.d.mts.map

@@ -1 +1 @@
-{"version":3,"file":"match-trace.d.mts","names":[],"sources":["../../../../../../../@warlock.js/ai-panoptic/src/store/match-trace.ts"],"mappings":";;;;;;AAiBA;;;;;;;;;AAA4D;;iBAA5C,UAAA,CAAW,KAAA,EAAO,KAAA,EAAO,MAAA,GAAS,UAAU"}
+{"version":3,"file":"match-trace.d.mts","names":[],"sources":["../../../../../../../ai-panoptic/src/store/match-trace.ts"],"mappings":";;;;;;AAiBA;;;;;;;;;AAA4D;;iBAA5C,UAAA,CAAW,KAAA,EAAO,KAAA,EAAO,MAAA,GAAS,UAAU"}

package/esm/store/match-trace.mjs

@@ -1,4 +1,4 @@
-//#region ../@warlock.js/ai-panoptic/src/store/match-trace.ts
+//#region ../ai-panoptic/src/store/match-trace.ts
 /**
 * Test whether one trace satisfies a {@link TraceQuery}. Every declared
 * filter field must match (logical AND); absent fields are ignored, so

package/esm/store/match-trace.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"match-trace.mjs","names":[],"sources":["../../../../../../../@warlock.js/ai-panoptic/src/store/match-trace.ts"],"sourcesContent":["import type { ReportStatus } from \"@warlock.js/ai\";\nimport type { Trace } from \"../contracts/trace.type\";\nimport type { TraceQuery } from \"./trace-query.type\";\n\n/**\n * Test whether one trace satisfies a {@link TraceQuery}. Every declared\n * filter field must match (logical AND); absent fields are ignored, so\n * an empty / undefined filter matches every trace.\n *\n * Time bounds compare against the trace's root `startedAt`, parsed to\n * an epoch once per call, inclusive on both ends. Status accepts a\n * single value or an array (membership test). Identity fields are exact\n * string equality.\n *\n * Pure — used by the store's `query` and `aggregate` so both share one\n * matching definition.\n */\nexport function matchTrace(trace: Trace, filter?: TraceQuery): boolean {\n  if (!filter) {\n    return true;\n  }\n\n  if (filter.traceId !== undefined && trace.traceId !== filter.traceId) {\n    return false;\n  }\n\n  if (filter.sessionId !== undefined && trace.sessionId !== filter.sessionId) {\n    return false;\n  }\n\n  if (filter.status !== undefined && !statusMatches(trace.root.status, filter.status)) {\n    return false;\n  }\n\n  const startedAt = Date.parse(trace.startedAt);\n\n  if (filter.startedAfter !== undefined && startedAt < toEpoch(filter.startedAfter)) {\n    return false;\n  }\n\n  if (filter.startedBefore !== undefined && startedAt > toEpoch(filter.startedBefore)) {\n    return false;\n  }\n\n  return true;\n}\n\n/**\n * Membership test for the status filter — true when `status` equals the\n * single wanted value, or is one of the wanted array.\n */\nfunction statusMatches(status: ReportStatus, wanted: ReportStatus | ReportStatus[]): boolean {\n  if (Array.isArray(wanted)) {\n    return wanted.includes(status);\n  }\n\n  return status === wanted;\n}\n\n/**\n * Normalize a time bound (ISO string or `Date`) to epoch milliseconds\n * for comparison against a parsed `startedAt`.\n */\nfunction toEpoch(bound: string | Date): number {\n  if (bound instanceof Date) {\n    return bound.getTime();\n  }\n\n  return Date.parse(bound);\n}\n"],"mappings":";;;;;;;;;;;;;;AAiBA,SAAgB,WAAW,OAAc,QAA8B;CACrE,IAAI,CAAC,QACH,OAAO;CAGT,IAAI,OAAO,YAAY,UAAa,MAAM,YAAY,OAAO,SAC3D,OAAO;CAGT,IAAI,OAAO,cAAc,UAAa,MAAM,cAAc,OAAO,WAC/D,OAAO;CAGT,IAAI,OAAO,WAAW,UAAa,CAAC,cAAc,MAAM,KAAK,QAAQ,OAAO,MAAM,GAChF,OAAO;CAGT,MAAM,YAAY,KAAK,MAAM,MAAM,SAAS;CAE5C,IAAI,OAAO,iBAAiB,UAAa,YAAY,QAAQ,OAAO,YAAY,GAC9E,OAAO;CAGT,IAAI,OAAO,kBAAkB,UAAa,YAAY,QAAQ,OAAO,aAAa,GAChF,OAAO;CAGT,OAAO;AACT;;;;;AAMA,SAAS,cAAc,QAAsB,QAAgD;CAC3F,IAAI,MAAM,QAAQ,MAAM,GACtB,OAAO,OAAO,SAAS,MAAM;CAG/B,OAAO,WAAW;AACpB;;;;;AAMA,SAAS,QAAQ,OAA8B;CAC7C,IAAI,iBAAiB,MACnB,OAAO,MAAM,QAAQ;CAGvB,OAAO,KAAK,MAAM,KAAK;AACzB"}
+{"version":3,"file":"match-trace.mjs","names":[],"sources":["../../../../../../../ai-panoptic/src/store/match-trace.ts"],"sourcesContent":["import type { ReportStatus } from \"@warlock.js/ai\";\nimport type { Trace } from \"../contracts/trace.type\";\nimport type { TraceQuery } from \"./trace-query.type\";\n\n/**\n * Test whether one trace satisfies a {@link TraceQuery}. Every declared\n * filter field must match (logical AND); absent fields are ignored, so\n * an empty / undefined filter matches every trace.\n *\n * Time bounds compare against the trace's root `startedAt`, parsed to\n * an epoch once per call, inclusive on both ends. Status accepts a\n * single value or an array (membership test). Identity fields are exact\n * string equality.\n *\n * Pure — used by the store's `query` and `aggregate` so both share one\n * matching definition.\n */\nexport function matchTrace(trace: Trace, filter?: TraceQuery): boolean {\n  if (!filter) {\n    return true;\n  }\n\n  if (filter.traceId !== undefined && trace.traceId !== filter.traceId) {\n    return false;\n  }\n\n  if (filter.sessionId !== undefined && trace.sessionId !== filter.sessionId) {\n    return false;\n  }\n\n  if (filter.status !== undefined && !statusMatches(trace.root.status, filter.status)) {\n    return false;\n  }\n\n  const startedAt = Date.parse(trace.startedAt);\n\n  if (filter.startedAfter !== undefined && startedAt < toEpoch(filter.startedAfter)) {\n    return false;\n  }\n\n  if (filter.startedBefore !== undefined && startedAt > toEpoch(filter.startedBefore)) {\n    return false;\n  }\n\n  return true;\n}\n\n/**\n * Membership test for the status filter — true when `status` equals the\n * single wanted value, or is one of the wanted array.\n */\nfunction statusMatches(status: ReportStatus, wanted: ReportStatus | ReportStatus[]): boolean {\n  if (Array.isArray(wanted)) {\n    return wanted.includes(status);\n  }\n\n  return status === wanted;\n}\n\n/**\n * Normalize a time bound (ISO string or `Date`) to epoch milliseconds\n * for comparison against a parsed `startedAt`.\n */\nfunction toEpoch(bound: string | Date): number {\n  if (bound instanceof Date) {\n    return bound.getTime();\n  }\n\n  return Date.parse(bound);\n}\n"],"mappings":";;;;;;;;;;;;;;AAiBA,SAAgB,WAAW,OAAc,QAA8B;CACrE,IAAI,CAAC,QACH,OAAO;CAGT,IAAI,OAAO,YAAY,UAAa,MAAM,YAAY,OAAO,SAC3D,OAAO;CAGT,IAAI,OAAO,cAAc,UAAa,MAAM,cAAc,OAAO,WAC/D,OAAO;CAGT,IAAI,OAAO,WAAW,UAAa,CAAC,cAAc,MAAM,KAAK,QAAQ,OAAO,MAAM,GAChF,OAAO;CAGT,MAAM,YAAY,KAAK,MAAM,MAAM,SAAS;CAE5C,IAAI,OAAO,iBAAiB,UAAa,YAAY,QAAQ,OAAO,YAAY,GAC9E,OAAO;CAGT,IAAI,OAAO,kBAAkB,UAAa,YAAY,QAAQ,OAAO,aAAa,GAChF,OAAO;CAGT,OAAO;AACT;;;;;AAMA,SAAS,cAAc,QAAsB,QAAgD;CAC3F,IAAI,MAAM,QAAQ,MAAM,GACtB,OAAO,OAAO,SAAS,MAAM;CAG/B,OAAO,WAAW;AACpB;;;;;AAMA,SAAS,QAAQ,OAA8B;CAC7C,IAAI,iBAAiB,MACnB,OAAO,MAAM,QAAQ;CAGvB,OAAO,KAAK,MAAM,KAAK;AACzB"}

package/esm/store/sum-usage.d.mts

@@ -1,6 +1,6 @@
 import { Usage } from "@warlock.js/ai";
 
-//#region ../@warlock.js/ai-panoptic/src/store/sum-usage.d.ts
+//#region ../ai-panoptic/src/store/sum-usage.d.ts
 /**
  * Fold a child {@link Usage} into a running accumulator. Token channels
  * (`input` / `output` / `total`) always sum; the optional cache /

package/esm/store/sum-usage.d.mts.map

@@ -1 +1 @@
-{"version":3,"file":"sum-usage.d.mts","names":[],"sources":["../../../../../../../@warlock.js/ai-panoptic/src/store/sum-usage.ts"],"mappings":";;;;;AAsBA;;;;;;;;;;;;;;AAAgE;AAoChE;;;iBApCgB,QAAA,CAAS,WAAA,EAAa,KAAA,EAAO,IAAA,EAAM,KAAA,GAAQ,KAAA;AAoCxB;;;;;;AAAA,iBAAnB,UAAA,IAAc,KAAK"}
+{"version":3,"file":"sum-usage.d.mts","names":[],"sources":["../../../../../../../ai-panoptic/src/store/sum-usage.ts"],"mappings":";;;;;AAsBA;;;;;;;;;;;;;;AAAgE;AAoChE;;;iBApCgB,QAAA,CAAS,WAAA,EAAa,KAAA,EAAO,IAAA,EAAM,KAAA,GAAQ,KAAA;AAoCxB;;;;;;AAAA,iBAAnB,UAAA,IAAc,KAAK"}

package/esm/store/sum-usage.mjs

@@ -1,6 +1,6 @@
 import { accumulateCost } from "@warlock.js/ai";
 
-//#region ../@warlock.js/ai-panoptic/src/store/sum-usage.ts
+//#region ../ai-panoptic/src/store/sum-usage.ts
 /**
 * Fold a child {@link Usage} into a running accumulator. Token channels
 * (`input` / `output` / `total`) always sum; the optional cache /

package/esm/store/sum-usage.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"sum-usage.mjs","names":[],"sources":["../../../../../../../@warlock.js/ai-panoptic/src/store/sum-usage.ts"],"sourcesContent":["import { accumulateCost, type Usage } from \"@warlock.js/ai\";\n\n/**\n * Fold a child {@link Usage} into a running accumulator. Token channels\n * (`input` / `output` / `total`) always sum; the optional cache /\n * reasoning channels (`cachedTokens` / `cacheWriteTokens` /\n * `reasoningTokens`) sum only when at least one side reported them, so\n * a provider that never meters a channel doesn't fabricate a `0` for\n * it. The `cost` breakdown is merged with the core framework's\n * {@link accumulateCost}, keeping cost-rollup semantics identical to a\n * native report tree — an unpriced contributor never erases a priced\n * one.\n *\n * Pure: returns a fresh `Usage`, never mutates either argument. Seed an\n * aggregation with {@link emptyUsage}.\n *\n * @example\n * let total = emptyUsage();\n * for (const trace of traces) {\n *   total = sumUsage(total, trace.usage);\n * }\n */\nexport function sumUsage(accumulator: Usage, next: Usage): Usage {\n  const merged: Usage = {\n    input: accumulator.input + next.input,\n    output: accumulator.output + next.output,\n    total: accumulator.total + next.total,\n  };\n\n  const cachedTokens = sumOptional(accumulator.cachedTokens, next.cachedTokens);\n  if (cachedTokens !== undefined) {\n    merged.cachedTokens = cachedTokens;\n  }\n\n  const cacheWriteTokens = sumOptional(accumulator.cacheWriteTokens, next.cacheWriteTokens);\n  if (cacheWriteTokens !== undefined) {\n    merged.cacheWriteTokens = cacheWriteTokens;\n  }\n\n  const reasoningTokens = sumOptional(accumulator.reasoningTokens, next.reasoningTokens);\n  if (reasoningTokens !== undefined) {\n    merged.reasoningTokens = reasoningTokens;\n  }\n\n  const cost = accumulateCost(accumulator.cost, next.cost);\n  if (cost !== undefined) {\n    merged.cost = cost;\n  }\n\n  return merged;\n}\n\n/**\n * A zero-valued {@link Usage} to seed an aggregation. Only the required\n * token channels are set; optional channels stay absent until a\n * contributor reports them, preserving the \"never reported\" vs\n * \"reported as 0\" distinction.\n */\nexport function emptyUsage(): Usage {\n  return {\n    input: 0,\n    output: 0,\n    total: 0,\n  };\n}\n\n/**\n * Add two optional token counts, treating either side's `undefined` as\n * zero — but return `undefined` when both are absent, so an unreported\n * channel stays unreported rather than collapsing to `0`.\n */\nfunction sumOptional(accumulator: number | undefined, next: number | undefined): number | undefined {\n  if (accumulator === undefined && next === undefined) {\n    return undefined;\n  }\n\n  return (accumulator ?? 0) + (next ?? 0);\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;AAsBA,SAAgB,SAAS,aAAoB,MAAoB;CAC/D,MAAM,SAAgB;EACpB,OAAO,YAAY,QAAQ,KAAK;EAChC,QAAQ,YAAY,SAAS,KAAK;EAClC,OAAO,YAAY,QAAQ,KAAK;CAClC;CAEA,MAAM,eAAe,YAAY,YAAY,cAAc,KAAK,YAAY;CAC5E,IAAI,iBAAiB,QACnB,OAAO,eAAe;CAGxB,MAAM,mBAAmB,YAAY,YAAY,kBAAkB,KAAK,gBAAgB;CACxF,IAAI,qBAAqB,QACvB,OAAO,mBAAmB;CAG5B,MAAM,kBAAkB,YAAY,YAAY,iBAAiB,KAAK,eAAe;CACrF,IAAI,oBAAoB,QACtB,OAAO,kBAAkB;CAG3B,MAAM,OAAO,eAAe,YAAY,MAAM,KAAK,IAAI;CACvD,IAAI,SAAS,QACX,OAAO,OAAO;CAGhB,OAAO;AACT;;;;;;;AAQA,SAAgB,aAAoB;CAClC,OAAO;EACL,OAAO;EACP,QAAQ;EACR,OAAO;CACT;AACF;;;;;;AAOA,SAAS,YAAY,aAAiC,MAA8C;CAClG,IAAI,gBAAgB,UAAa,SAAS,QACxC;CAGF,QAAQ,eAAe,MAAM,QAAQ;AACvC"}
+{"version":3,"file":"sum-usage.mjs","names":[],"sources":["../../../../../../../ai-panoptic/src/store/sum-usage.ts"],"sourcesContent":["import { accumulateCost, type Usage } from \"@warlock.js/ai\";\n\n/**\n * Fold a child {@link Usage} into a running accumulator. Token channels\n * (`input` / `output` / `total`) always sum; the optional cache /\n * reasoning channels (`cachedTokens` / `cacheWriteTokens` /\n * `reasoningTokens`) sum only when at least one side reported them, so\n * a provider that never meters a channel doesn't fabricate a `0` for\n * it. The `cost` breakdown is merged with the core framework's\n * {@link accumulateCost}, keeping cost-rollup semantics identical to a\n * native report tree — an unpriced contributor never erases a priced\n * one.\n *\n * Pure: returns a fresh `Usage`, never mutates either argument. Seed an\n * aggregation with {@link emptyUsage}.\n *\n * @example\n * let total = emptyUsage();\n * for (const trace of traces) {\n *   total = sumUsage(total, trace.usage);\n * }\n */\nexport function sumUsage(accumulator: Usage, next: Usage): Usage {\n  const merged: Usage = {\n    input: accumulator.input + next.input,\n    output: accumulator.output + next.output,\n    total: accumulator.total + next.total,\n  };\n\n  const cachedTokens = sumOptional(accumulator.cachedTokens, next.cachedTokens);\n  if (cachedTokens !== undefined) {\n    merged.cachedTokens = cachedTokens;\n  }\n\n  const cacheWriteTokens = sumOptional(accumulator.cacheWriteTokens, next.cacheWriteTokens);\n  if (cacheWriteTokens !== undefined) {\n    merged.cacheWriteTokens = cacheWriteTokens;\n  }\n\n  const reasoningTokens = sumOptional(accumulator.reasoningTokens, next.reasoningTokens);\n  if (reasoningTokens !== undefined) {\n    merged.reasoningTokens = reasoningTokens;\n  }\n\n  const cost = accumulateCost(accumulator.cost, next.cost);\n  if (cost !== undefined) {\n    merged.cost = cost;\n  }\n\n  return merged;\n}\n\n/**\n * A zero-valued {@link Usage} to seed an aggregation. Only the required\n * token channels are set; optional channels stay absent until a\n * contributor reports them, preserving the \"never reported\" vs\n * \"reported as 0\" distinction.\n */\nexport function emptyUsage(): Usage {\n  return {\n    input: 0,\n    output: 0,\n    total: 0,\n  };\n}\n\n/**\n * Add two optional token counts, treating either side's `undefined` as\n * zero — but return `undefined` when both are absent, so an unreported\n * channel stays unreported rather than collapsing to `0`.\n */\nfunction sumOptional(accumulator: number | undefined, next: number | undefined): number | undefined {\n  if (accumulator === undefined && next === undefined) {\n    return undefined;\n  }\n\n  return (accumulator ?? 0) + (next ?? 0);\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;AAsBA,SAAgB,SAAS,aAAoB,MAAoB;CAC/D,MAAM,SAAgB;EACpB,OAAO,YAAY,QAAQ,KAAK;EAChC,QAAQ,YAAY,SAAS,KAAK;EAClC,OAAO,YAAY,QAAQ,KAAK;CAClC;CAEA,MAAM,eAAe,YAAY,YAAY,cAAc,KAAK,YAAY;CAC5E,IAAI,iBAAiB,QACnB,OAAO,eAAe;CAGxB,MAAM,mBAAmB,YAAY,YAAY,kBAAkB,KAAK,gBAAgB;CACxF,IAAI,qBAAqB,QACvB,OAAO,mBAAmB;CAG5B,MAAM,kBAAkB,YAAY,YAAY,iBAAiB,KAAK,eAAe;CACrF,IAAI,oBAAoB,QACtB,OAAO,kBAAkB;CAG3B,MAAM,OAAO,eAAe,YAAY,MAAM,KAAK,IAAI;CACvD,IAAI,SAAS,QACX,OAAO,OAAO;CAGhB,OAAO;AACT;;;;;;;AAQA,SAAgB,aAAoB;CAClC,OAAO;EACL,OAAO;EACP,QAAQ;EACR,OAAO;CACT;AACF;;;;;;AAOA,SAAS,YAAY,aAAiC,MAA8C;CAClG,IAAI,gBAAgB,UAAa,SAAS,QACxC;CAGF,QAAQ,eAAe,MAAM,QAAQ;AACvC"}

package/esm/store/trace-aggregate.type.d.mts

@@ -1,6 +1,6 @@
 import { ModelPricing, Usage } from "@warlock.js/ai";
 
-//#region ../@warlock.js/ai-panoptic/src/store/trace-aggregate.type.d.ts
+//#region ../ai-panoptic/src/store/trace-aggregate.type.d.ts
 /**
  * Rolled-up usage + cost across a set of stored traces, returned by the
  * trace store's `aggregate`. Answers the headline observability

package/esm/store/trace-aggregate.type.d.mts.map

@@ -1 +1 @@
-{"version":3,"file":"trace-aggregate.type.d.mts","names":[],"sources":["../../../../../../../@warlock.js/ai-panoptic/src/store/trace-aggregate.type.ts"],"mappings":";;;;;AA0BA;;;;;;;;;;;;;;AAwBe;;;;;;;;KAxBH,cAAA;+CAEV,MAAA;EAEA,SAAA;EAEA,MAAA;EAEA,SAAA;;;;;;;EAOA,KAAA,EAAO,KAAA;;;;;;;EAOP,IAAA,GAAO,YAAY;EAEnB,aAAA;AAAA"}
+{"version":3,"file":"trace-aggregate.type.d.mts","names":[],"sources":["../../../../../../../ai-panoptic/src/store/trace-aggregate.type.ts"],"mappings":";;;;;AA0BA;;;;;;;;;;;;;;AAwBe;;;;;;;;KAxBH,cAAA;+CAEV,MAAA;EAEA,SAAA;EAEA,MAAA;EAEA,SAAA;;;;;;;EAOA,KAAA,EAAO,KAAA;;;;;;;EAOP,IAAA,GAAO,YAAY;EAEnB,aAAA;AAAA"}

package/esm/store/trace-query.type.d.mts

@@ -1,6 +1,6 @@
 import { ReportStatus } from "@warlock.js/ai";
 
-//#region ../@warlock.js/ai-panoptic/src/store/trace-query.type.d.ts
+//#region ../ai-panoptic/src/store/trace-query.type.d.ts
 /**
  * Filter passed to the trace store's `query` / `aggregate`. Every field
  * is optional and ANDed together — an absent field is "don't care", so

package/esm/store/trace-query.type.d.mts.map

@@ -1 +1 @@
-{"version":3,"file":"trace-query.type.d.mts","names":[],"sources":["../../../../../../../@warlock.js/ai-panoptic/src/store/trace-query.type.ts"],"mappings":";;;;;AAsBA;;;;;;;;;;;;;;;;;;KAAY,UAAA;EAmBmB;;;;EAd7B,OAAA;;;;;EAKA,SAAA;;;;;EAKA,MAAA,GAAS,YAAA,GAAe,YAAA;EAExB,YAAA,YAAwB,IAAA;EAExB,aAAA,YAAyB,IAAA;AAAA"}
+{"version":3,"file":"trace-query.type.d.mts","names":[],"sources":["../../../../../../../ai-panoptic/src/store/trace-query.type.ts"],"mappings":";;;;;AAsBA;;;;;;;;;;;;;;;;;;KAAY,UAAA;EAmBmB;;;;EAd7B,OAAA;;;;;EAKA,SAAA;;;;;EAKA,MAAA,GAAS,YAAA,GAAe,YAAA;EAExB,YAAA,YAAwB,IAAA;EAExB,aAAA,YAAyB,IAAA;AAAA"}

package/esm/store/trace-store.contract.d.mts

@@ -2,7 +2,7 @@ import { Trace } from "../contracts/trace.type.mjs";
 import { TraceAggregate } from "./trace-aggregate.type.mjs";
 import { TraceQuery } from "./trace-query.type.mjs";
 
-//#region ../@warlock.js/ai-panoptic/src/store/trace-store.contract.d.ts
+//#region ../ai-panoptic/src/store/trace-store.contract.d.ts
 /**
  * Contract for a Panoptic trace store — a queryable sink that retains
  * collected {@link Trace}s so an app can answer observability questions

package/esm/store/trace-store.contract.d.mts.map

@@ -1 +1 @@
-{"version":3,"file":"trace-store.contract.d.mts","names":[],"sources":["../../../../../../../@warlock.js/ai-panoptic/src/store/trace-store.contract.ts"],"mappings":";;;;;;;AA2BA;;;;;;;;;;;;;;;;;;;;;UAAiB,kBAAA;EAqBI;;;;;EAfnB,GAAA,CAAI,KAAA,EAAO,KAAA;EAqBN;EAlBL,GAAA,CAAI,OAAA,WAAkB,KAAA;;;;;EAMtB,KAAA,CAAM,MAAA,GAAS,UAAA,GAAa,KAAA;;;;;EAM5B,SAAA,CAAU,MAAA,GAAS,UAAA,GAAa,cAAA;;WAGvB,IAAA;;EAGT,KAAA;AAAA"}
+{"version":3,"file":"trace-store.contract.d.mts","names":[],"sources":["../../../../../../../ai-panoptic/src/store/trace-store.contract.ts"],"mappings":";;;;;;;AA2BA;;;;;;;;;;;;;;;;;;;;;UAAiB,kBAAA;EAqBI;;;;;EAfnB,GAAA,CAAI,KAAA,EAAO,KAAA;EAqBN;EAlBL,GAAA,CAAI,OAAA,WAAkB,KAAA;;;;;EAMtB,KAAA,CAAM,MAAA,GAAS,UAAA,GAAa,KAAA;;;;;EAM5B,SAAA,CAAU,MAAA,GAAS,UAAA,GAAa,cAAA;;WAGvB,IAAA;;EAGT,KAAA;AAAA"}

package/package.json

@@ -21,12 +21,12 @@
   "peerDependencies": {
     "@opentelemetry/api": "*",
     "@opentelemetry/sdk-trace-base": "*",
-    "@warlock.js/ai": "4.8.2",
-    "@warlock.js/cache": "4.8.2",
-    "@warlock.js/logger": "4.8.2",
+    "@warlock.js/ai": "4.9.1",
+    "@warlock.js/cache": "4.9.1",
+    "@warlock.js/logger": "4.9.1",
     "langfuse": "*"
   },
-  "version": "4.8.2",
+  "version": "4.9.1",
   "main": "./cjs/index.cjs",
   "module": "./esm/index.mjs",
   "types": "./esm/index.d.mts",