@warlock.js/ai-panoptic 5.31.0 → 5.33.0

package/esm/exporters/utils/gen-ai-attributes.d.mts

@@ -1,4 +1,5 @@
 import { TraceSpan } from "../../contracts/trace.type.mjs";
+import "../../contracts/index.mjs";
 //#region ../../packages/ai-panoptic/src/exporters/utils/gen-ai-attributes.d.ts
 /**
  * Subset of the OpenTelemetry GenAI semantic-convention attribute keys
@@ -8,15 +9,17 @@ import { TraceSpan } from "../../contracts/trace.type.mjs";
  *
  * @see https://opentelemetry.io/docs/specs/semconv/gen-ai/
  */
-declare const GEN_AI_ATTRIBUTES: {
+export declare const GEN_AI_ATTRIBUTES: {
   readonly operationName: "gen_ai.operation.name";
   readonly system: "gen_ai.system";
   readonly requestModel: "gen_ai.request.model";
   readonly responseModel: "gen_ai.response.model";
   readonly usageInputTokens: "gen_ai.usage.input_tokens";
   readonly usageOutputTokens: "gen_ai.usage.output_tokens";
-  readonly conversationId: "gen_ai.conversation.id"; /** Captured prompt/input (set only under content capture). */
-  readonly prompt: "gen_ai.prompt"; /** Captured completion/output (set only under content capture). */
+  readonly conversationId: "gen_ai.conversation.id";
+  /** Captured prompt/input (set only under content capture). */
+  readonly prompt: "gen_ai.prompt";
+  /** Captured completion/output (set only under content capture). */
   readonly completion: "gen_ai.completion";
 };
 /**
@@ -24,7 +27,7 @@ declare const GEN_AI_ATTRIBUTES: {
  * equivalent. Namespaced under `warlock.*` so they never collide with a
  * future `gen_ai.*` key the spec might add.
  */
-declare const WARLOCK_ATTRIBUTES: {
+export declare const WARLOCK_ATTRIBUTES: {
   readonly reportType: "warlock.report.type";
   readonly version: "warlock.version";
   readonly durationMs: "warlock.duration_ms";
@@ -38,7 +41,7 @@ declare const WARLOCK_ATTRIBUTES: {
  * GenAI attributes are scalars; the framework's free-form
  * `TraceSpan.attributes` may also carry these.
  */
-type AttributeValue = string | number | boolean;
+export type AttributeValue = string | number | boolean;
 /**
  * Project a {@link TraceSpan} onto the OpenTelemetry GenAI
  * semantic-convention attribute set.
@@ -61,7 +64,6 @@ type AttributeValue = string | number | boolean;
  * const attributes = toGenAiAttributes(span);
  * // { "gen_ai.usage.input_tokens": 150, "gen_ai.usage.output_tokens": 320, ... }
  */
-declare function toGenAiAttributes(span: TraceSpan): Record<string, AttributeValue>;
+export declare function toGenAiAttributes(span: TraceSpan): Record<string, AttributeValue>;
 //#endregion
-export { AttributeValue, GEN_AI_ATTRIBUTES, WARLOCK_ATTRIBUTES, toGenAiAttributes };
 //# sourceMappingURL=gen-ai-attributes.d.mts.map

package/esm/exporters/utils/gen-ai-attributes.d.mts.map

@@ -1 +1 @@
-{"version":3,"file":"gen-ai-attributes.d.mts","names":[],"sources":["../../../../../../../../../packages/ai-panoptic/src/exporters/utils/gen-ai-attributes.ts"],"mappings":";;;;;AAWA;;;;;cAAa,iBAAA;EAAA;;;;;;;oCAmBA;EAAA;;;;;;;cAAA,kBAAA;EAAA;;;;;;;;AAea;AAwB1B;;;;AAxB0B,KAAd,cAAA;;;;;;;;;AAwBqE;;;;;;;;;;;;;;iBAAjE,iBAAA,CAAkB,IAAA,EAAM,SAAA,GAAY,MAAA,SAAe,cAAA"}
+{"version":3,"file":"gen-ai-attributes.d.mts","names":[],"sources":["../../../../../../../../../packages/ai-panoptic/src/exporters/utils/gen-ai-attributes.ts"],"mappings":";;;;;;;;;;;qBAWa;WACX;WACA;WACA;WACA;WACA;WACA;WACA;;WAEA;;WAEA;;;;;;;qBAQW;WACX;WACA;WACA;WACA;WACA;WACA;WACA;;;;;;;YAQU;;;;;;;;;;;;;;;;;;;;;;;wBAwBI,kBAAkB,MAAM,YAAY,eAAe"}

package/esm/exporters/utils/index.d.mts

@@ -1,3 +1,4 @@
 import { AttributeValue, GEN_AI_ATTRIBUTES, WARLOCK_ATTRIBUTES, toGenAiAttributes } from "./gen-ai-attributes.mjs";
 import { totalCostUsd } from "./total-cost.mjs";
-import { walkSpans } from "./walk-spans.mjs";
+import { walkSpans } from "./walk-spans.mjs";
+export { type AttributeValue, GEN_AI_ATTRIBUTES, WARLOCK_ATTRIBUTES, toGenAiAttributes, totalCostUsd, walkSpans };

package/esm/exporters/utils/index.mjs

@@ -2,4 +2,4 @@ import { walkSpans } from "./walk-spans.mjs";
 import { totalCostUsd } from "./total-cost.mjs";
 import { GEN_AI_ATTRIBUTES, WARLOCK_ATTRIBUTES, toGenAiAttributes } from "./gen-ai-attributes.mjs";
 
-export {  };
+export { GEN_AI_ATTRIBUTES, WARLOCK_ATTRIBUTES, toGenAiAttributes, totalCostUsd, walkSpans };

package/esm/exporters/utils/total-cost.d.mts

@@ -1,5 +1,4 @@
 import { Usage } from "@warlock.js/ai";
-
 //#region ../../packages/ai-panoptic/src/exporters/utils/total-cost.d.ts
 /**
  * Collapse a {@link Usage.cost} breakdown into a single USD scalar by
@@ -12,7 +11,6 @@ import { Usage } from "@warlock.js/ai";
  * totalCostUsd({ input: 1, output: 2, total: 3, cost: { input: 0.01, output: 0.04 } });
  * // => 0.05
  */
-declare function totalCostUsd(usage: Usage): number | undefined;
+export declare function totalCostUsd(usage: Usage): number | undefined;
 //#endregion
-export { totalCostUsd };
 //# sourceMappingURL=total-cost.d.mts.map

package/esm/exporters/utils/total-cost.d.mts.map

@@ -1 +1 @@
-{"version":3,"file":"total-cost.d.mts","names":[],"sources":["../../../../../../../../../packages/ai-panoptic/src/exporters/utils/total-cost.ts"],"mappings":";;;;;AAaA;;;;AAAyC;;;;;iBAAzB,YAAA,CAAa,KAAY,EAAL,KAAK"}
+{"version":3,"file":"total-cost.d.mts","names":[],"sources":["../../../../../../../../../packages/ai-panoptic/src/exporters/utils/total-cost.ts"],"mappings":";;;;;;;;;;;;;wBAagB,aAAa,OAAO"}

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

@@ -1,4 +1,5 @@
 import { TraceSpan } from "../../contracts/trace.type.mjs";
+import "../../contracts/index.mjs";
 //#region ../../packages/ai-panoptic/src/exporters/utils/walk-spans.d.ts
 /**
  * Depth-first pre-order traversal of a {@link TraceSpan} tree, yielding
@@ -12,7 +13,6 @@ import { TraceSpan } from "../../contracts/trace.type.mjs";
  *   emit(span);
  * }
  */
-declare function walkSpans(root: TraceSpan): Generator<TraceSpan>;
+export declare function walkSpans(root: TraceSpan): Generator<TraceSpan>;
 //#endregion
-export { walkSpans };
 //# sourceMappingURL=walk-spans.d.mts.map

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

@@ -1 +1 @@
-{"version":3,"file":"walk-spans.d.mts","names":[],"sources":["../../../../../../../../../packages/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":["../../../../../../../../../packages/ai-panoptic/src/exporters/utils/walk-spans.ts"],"mappings":";;;;;;;;;;;;;;;wBAciB,UAAU,MAAM,YAAY,UAAU"}

package/esm/index.d.mts

@@ -1,12 +1,15 @@
 import { Trace, TraceSpan, TraceSpanError } from "./contracts/trace.type.mjs";
 import { ExporterContract } from "./contracts/exporter.contract.mjs";
 import { CollectorContract } from "./contracts/collector.contract.mjs";
+import "./contracts/index.mjs";
 import { ContentCaptureOptions, ContentRedactor } from "./collector/content-capture.type.mjs";
 import { CollectorOptions, ExporterErrorHandler, createCollector } from "./collector/collector.mjs";
 import { reportToTrace } from "./collector/report-to-trace.mjs";
 import { reportToSpan } from "./collector/report-to-span.mjs";
 import { extractSpanAttributes } from "./collector/extract-span-attributes.mjs";
 import { normalizeError } from "./collector/normalize-error.mjs";
+import { TraceListener, subscribeTraces } from "./collector/trace-subscriptions.mjs";
+import "./collector/index.mjs";
 import { TraceAggregate } from "./store/trace-aggregate.type.mjs";
 import { TraceQuery } from "./store/trace-query.type.mjs";
 import { TraceStoreContract } from "./store/trace-store.contract.mjs";
@@ -14,6 +17,7 @@ import { CacheDriverInput, CacheTraceStoreHandle, CacheTraceStoreOptions, create
 import { InMemoryTraceStoreOptions, createInMemoryTraceStore } from "./store/in-memory-trace-store.mjs";
 import { matchTrace } from "./store/match-trace.mjs";
 import { emptyUsage, sumUsage } from "./store/sum-usage.mjs";
+import "./store/index.mjs";
 import { ConsoleExporterOptions, ConsoleLike } from "./exporters/console/console-exporter.type.mjs";
 import { consoleExporter } from "./exporters/console/console-exporter.mjs";
 import { formatSpanLine } from "./exporters/console/format-span-line.mjs";
@@ -27,18 +31,23 @@ import { otelExporter } from "./exporters/otel/otel-exporter.mjs";
 import { AttributeValue, GEN_AI_ATTRIBUTES, WARLOCK_ATTRIBUTES, toGenAiAttributes } from "./exporters/utils/gen-ai-attributes.mjs";
 import { totalCostUsd } from "./exporters/utils/total-cost.mjs";
 import { walkSpans } from "./exporters/utils/walk-spans.mjs";
+import "./exporters/index.mjs";
 import { CompletedEventPayload, PanopticTarget } from "./panoptic/panoptic-target.type.mjs";
 import { Panoptic, PanopticOptions } from "./panoptic/panoptic.type.mjs";
 import { panoptic } from "./panoptic/panoptic.mjs";
 import { createPanopticMiddleware } from "./panoptic/panoptic-middleware.mjs";
+import "./panoptic/index.mjs";
 import { EvaluateConfig, EvaluateVerdict } from "./evaluate/evaluate.type.mjs";
 import { evaluateSystemPrompt } from "./evaluate/evaluate-system-prompt.mjs";
 import { extractLastSystemPrompt } from "./evaluate/extract-last-system-prompt.mjs";
 import { findSpanById } from "./evaluate/find-span-by-id.mjs";
+import "./evaluate/index.mjs";
 import { DashboardHandle, DashboardOptions } from "./dashboard/dashboard.type.mjs";
 import { dashboard } from "./dashboard/dashboard.mjs";
 import { NO_PROMPT_KEY, NO_SESSION_KEY, NO_TYPE_KEY, PromptGroup, SessionGroup, TraceFilter, TypeGroup, TypeStat, aggregateByType, filterTraces, groupByPrompt, groupBySession, groupByType, heatIntensity, matchesFilter, maxNodeCost, percentile, rollupCost, traceCost, tracePromptKey } from "./dashboard/trace-filter.mjs";
+import "./dashboard/index.mjs";
 import { PanopticConfig } from "./config/panoptic-config.type.mjs";
 import { applyPanopticConfig } from "./config/apply-panoptic-config.mjs";
-export { type AttributeValue, type CacheDriverInput, type CacheTraceStoreHandle, type CacheTraceStoreOptions, type CollectorContract, type CollectorOptions, type CompletedEventPayload, type ConsoleExporterOptions, type ConsoleLike, type ContentCaptureOptions, type ContentRedactor, type DashboardHandle, type DashboardOptions, type EvaluateConfig, type EvaluateVerdict, type ExporterContract, type ExporterErrorHandler, type FileExporterOptions, GEN_AI_ATTRIBUTES, type InMemoryTraceStoreOptions, type LangfuseClientLike, type LangfuseExporterOptions, type LangfuseObservationBody, type LangfuseObservationEndBody, type LangfuseObservationLevel, type LangfuseObservationLike, type LangfuseTraceBody, type LangfuseTraceLike, type LangfuseUsageBody, NO_PROMPT_KEY, NO_SESSION_KEY, NO_TYPE_KEY, type OtelExporterOptions, type Panoptic, type PanopticConfig, type PanopticOptions, type PanopticTarget, type PromptGroup, type SessionGroup, type Trace, type TraceAggregate, type TraceFilter, type TraceQuery, type TraceRecord, type TraceSpan, type TraceSpanError, type TraceStoreContract, type TypeGroup, type TypeStat, WARLOCK_ATTRIBUTES, aggregateByType, applyPanopticConfig, consoleExporter, createCacheTraceStore, createCollector, createInMemoryTraceStore, createPanopticMiddleware, dashboard, emptyUsage, evaluateSystemPrompt, extractLastSystemPrompt, extractSpanAttributes, fileExporter, filterTraces, findSpanById, formatSpanIO, formatSpanLine, groupByPrompt, groupBySession, groupByType, heatIntensity, langfuseExporter, matchTrace, matchesFilter, maxNodeCost, normalizeError, otelExporter, panoptic, percentile, reportToSpan, reportToTrace, rollupCost, sumUsage, toGenAiAttributes, totalCostUsd, traceCost, tracePromptKey, walkSpans };
+import "./config/index.mjs";
+export { type AttributeValue, type CacheDriverInput, type CacheTraceStoreHandle, type CacheTraceStoreOptions, type CollectorContract, type CollectorOptions, type CompletedEventPayload, type ConsoleExporterOptions, type ConsoleLike, type ContentCaptureOptions, type ContentRedactor, type DashboardHandle, type DashboardOptions, type EvaluateConfig, type EvaluateVerdict, type ExporterContract, type ExporterErrorHandler, type FileExporterOptions, GEN_AI_ATTRIBUTES, type InMemoryTraceStoreOptions, type LangfuseClientLike, type LangfuseExporterOptions, type LangfuseObservationBody, type LangfuseObservationEndBody, type LangfuseObservationLevel, type LangfuseObservationLike, type LangfuseTraceBody, type LangfuseTraceLike, type LangfuseUsageBody, NO_PROMPT_KEY, NO_SESSION_KEY, NO_TYPE_KEY, type OtelExporterOptions, type Panoptic, type PanopticConfig, type PanopticOptions, type PanopticTarget, type PromptGroup, type SessionGroup, type Trace, type TraceAggregate, type TraceFilter, type TraceListener, type TraceQuery, type TraceRecord, type TraceSpan, type TraceSpanError, type TraceStoreContract, type TypeGroup, type TypeStat, WARLOCK_ATTRIBUTES, aggregateByType, applyPanopticConfig, consoleExporter, createCacheTraceStore, createCollector, createInMemoryTraceStore, createPanopticMiddleware, dashboard, emptyUsage, evaluateSystemPrompt, extractLastSystemPrompt, extractSpanAttributes, fileExporter, filterTraces, findSpanById, formatSpanIO, formatSpanLine, groupByPrompt, groupBySession, groupByType, heatIntensity, langfuseExporter, matchTrace, matchesFilter, maxNodeCost, normalizeError, otelExporter, panoptic, percentile, reportToSpan, reportToTrace, rollupCost, subscribeTraces, sumUsage, toGenAiAttributes, totalCostUsd, traceCost, tracePromptKey, walkSpans };
 import "./config/panoptic-config.type.mjs";

package/esm/index.mjs

@@ -3,6 +3,7 @@ import { normalizeError } from "./collector/normalize-error.mjs";
 import { extractSpanAttributes } from "./collector/extract-span-attributes.mjs";
 import { reportToSpan } from "./collector/report-to-span.mjs";
 import { reportToTrace } from "./collector/report-to-trace.mjs";
+import { subscribeTraces } from "./collector/trace-subscriptions.mjs";
 import { createCollector } from "./collector/collector.mjs";
 import "./collector/index.mjs";
 import { matchTrace } from "./store/match-trace.mjs";
@@ -33,4 +34,4 @@ import { applyPanopticConfig } from "./config/apply-panoptic-config.mjs";
 import "./config/index.mjs";
 import "./register.mjs";
 
-export { GEN_AI_ATTRIBUTES, NO_PROMPT_KEY, NO_SESSION_KEY, NO_TYPE_KEY, WARLOCK_ATTRIBUTES, aggregateByType, applyPanopticConfig, consoleExporter, createCacheTraceStore, createCollector, createInMemoryTraceStore, createPanopticMiddleware, dashboard, emptyUsage, evaluateSystemPrompt, extractLastSystemPrompt, extractSpanAttributes, fileExporter, filterTraces, findSpanById, formatSpanIO, formatSpanLine, groupByPrompt, groupBySession, groupByType, heatIntensity, langfuseExporter, matchTrace, matchesFilter, maxNodeCost, normalizeError, otelExporter, panoptic, percentile, reportToSpan, reportToTrace, rollupCost, sumUsage, toGenAiAttributes, totalCostUsd, traceCost, tracePromptKey, walkSpans };
+export { GEN_AI_ATTRIBUTES, NO_PROMPT_KEY, NO_SESSION_KEY, NO_TYPE_KEY, WARLOCK_ATTRIBUTES, aggregateByType, applyPanopticConfig, consoleExporter, createCacheTraceStore, createCollector, createInMemoryTraceStore, createPanopticMiddleware, dashboard, emptyUsage, evaluateSystemPrompt, extractLastSystemPrompt, extractSpanAttributes, fileExporter, filterTraces, findSpanById, formatSpanIO, formatSpanLine, groupByPrompt, groupBySession, groupByType, heatIntensity, langfuseExporter, matchTrace, matchesFilter, maxNodeCost, normalizeError, otelExporter, panoptic, percentile, reportToSpan, reportToTrace, rollupCost, subscribeTraces, sumUsage, toGenAiAttributes, totalCostUsd, traceCost, tracePromptKey, walkSpans };

package/esm/panoptic/index.d.mts

@@ -1,4 +1,5 @@
 import { CompletedEventPayload, PanopticTarget } from "./panoptic-target.type.mjs";
 import { Panoptic, PanopticOptions } from "./panoptic.type.mjs";
 import { panoptic } from "./panoptic.mjs";
-import { createPanopticMiddleware } from "./panoptic-middleware.mjs";
+import { createPanopticMiddleware } from "./panoptic-middleware.mjs";
+export { type CompletedEventPayload, type Panoptic, type PanopticOptions, type PanopticTarget, createPanopticMiddleware, panoptic };

package/esm/panoptic/index.mjs

@@ -1,4 +1,4 @@
 import { createPanopticMiddleware } from "./panoptic-middleware.mjs";
 import { panoptic } from "./panoptic.mjs";
 
-export {  };
+export { createPanopticMiddleware, panoptic };

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

@@ -1,6 +1,5 @@
 import { CollectorContract } from "../contracts/collector.contract.mjs";
 import { AgentMiddleware } from "@warlock.js/ai";
-
 //#region ../../packages/ai-panoptic/src/panoptic/panoptic-middleware.d.ts
 /**
  * Build an {@link AgentMiddleware} that feeds a collector from the
@@ -32,7 +31,6 @@ import { AgentMiddleware } from "@warlock.js/ai";
  * @param name - stable middleware name (kebab-case). Defaults to
  *   `"panoptic"`.
  */
-declare function createPanopticMiddleware(collector: CollectorContract, name?: string): AgentMiddleware;
+export declare function createPanopticMiddleware(collector: CollectorContract, name?: string): AgentMiddleware;
 //#endregion
-export { createPanopticMiddleware };
 //# sourceMappingURL=panoptic-middleware.d.mts.map

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

@@ -1 +1 @@
-{"version":3,"file":"panoptic-middleware.d.mts","names":[],"sources":["../../../../../../../../packages/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":["../../../../../../../../packages/ai-panoptic/src/panoptic/panoptic-middleware.ts"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;wBAiCgB,yBACd,WAAW,mBACX,gBACC"}

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

@@ -1,5 +1,4 @@
 import { BaseReport, BaseResult } from "@warlock.js/ai";
-
 //#region ../../packages/ai-panoptic/src/panoptic/panoptic-target.type.d.ts
 /**
  * The minimal completed-event payload Panoptic reads off any primitive's
@@ -10,8 +9,9 @@ import { BaseReport, BaseResult } from "@warlock.js/ai";
  * `*.completed` still fires). Reading the report off this single event is
  * therefore enough to capture every run regardless of outcome.
  */
-type CompletedEventPayload = {
-  /** The finalized result of the run; carries the full `report` tree. */result: BaseResult & {
+export type CompletedEventPayload = {
+  /** The finalized result of the run; carries the full `report` tree. */
+  result: BaseResult & {
     report: BaseReport;
   };
 };
@@ -34,7 +34,7 @@ type CompletedEventPayload = {
  * const sub = panoptic({ exporters: [consoleExporter()] });
  * const detach = sub.attach(agent); // agent is a PanopticTarget
  */
-type PanopticTarget = {
+export type PanopticTarget = {
   /**
    * Stable identifier of the primitive. Used only for diagnostics
    * (Panoptic never branches behavior on it). Present on every core
@@ -49,5 +49,4 @@ type PanopticTarget = {
   on(event: string, handler: (payload: unknown) => void): () => void;
 };
 //#endregion
-export { CompletedEventPayload, PanopticTarget };
 //# sourceMappingURL=panoptic-target.type.d.mts.map

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

@@ -1 +1 @@
-{"version":3,"file":"panoptic-target.type.d.mts","names":[],"sources":["../../../../../../../../packages/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":["../../../../../../../../packages/ai-panoptic/src/panoptic/panoptic-target.type.ts"],"mappings":";;;;;;;;;;;YAWY;;EAEV,QAAQ;IAAe,QAAQ;;;;;;;;;;;;;;;;;;;;;;YAsBrB;;;;;;WAMD;;;;;;EAMT,GAAG,eAAe,UAAU"}

package/esm/panoptic/panoptic.d.mts

@@ -1,5 +1,4 @@
 import { Panoptic, PanopticOptions } from "./panoptic.type.mjs";
-
 //#region ../../packages/ai-panoptic/src/panoptic/panoptic.d.ts
 /**
  * Create a Panoptic subscriber — the one-call entry point that wires the
@@ -31,7 +30,6 @@ import { Panoptic, PanopticOptions } from "./panoptic.type.mjs";
  * const result = await orchestrator.execute(input, { sessionId });
  * await observe.collect(result.report);
  */
-declare function panoptic(options?: PanopticOptions): Panoptic;
+export declare function panoptic(options?: PanopticOptions): Panoptic;
 //#endregion
-export { panoptic };
 //# sourceMappingURL=panoptic.d.mts.map

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

@@ -1 +1 @@
-{"version":3,"file":"panoptic.d.mts","names":[],"sources":["../../../../../../../../packages/ai-panoptic/src/panoptic/panoptic.ts"],"mappings":";;;;;AA8LA;;;;;;;;AAAiE;;;;;;;;;;;;;;;;;;;;iBAAjD,QAAA,CAAS,OAAA,GAAS,eAAA,GAAuB,QAAQ"}
+{"version":3,"file":"panoptic.d.mts","names":[],"sources":["../../../../../../../../packages/ai-panoptic/src/panoptic/panoptic.ts"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;wBA8LgB,SAAS,UAAS,kBAAuB"}

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

@@ -5,7 +5,6 @@ import { ContentRedactor } from "../collector/content-capture.type.mjs";
 import { ExporterErrorHandler } from "../collector/collector.mjs";
 import { PanopticTarget } from "./panoptic-target.type.mjs";
 import { AgentMiddleware, BaseReport } from "@warlock.js/ai";
-
 //#region ../../packages/ai-panoptic/src/panoptic/panoptic.type.d.ts
 /**
  * Options for the {@link panoptic} subscriber factory.
@@ -15,7 +14,7 @@ import { AgentMiddleware, BaseReport } from "@warlock.js/ai";
  * a pre-built collector (e.g. one that already has a store registered);
  * any `exporters` supplied are registered onto it as well.
  */
-type PanopticOptions = {
+export type PanopticOptions = {
   /**
    * Exporters to register on the collector. Each is deduped by
    * `ExporterContract.name` (registering the same exporter twice is a
@@ -92,8 +91,9 @@ type PanopticOptions = {
  * All three converge on the same collector, so a trace flows to every
  * registered exporter exactly once per run.
  */
-type Panoptic = {
-  /** The underlying collector — exposed for `use()`, `toTrace()`, etc. */readonly collector: CollectorContract;
+export type Panoptic = {
+  /** The underlying collector — exposed for `use()`, `toTrace()`, etc. */
+  readonly collector: CollectorContract;
   /**
    * Register another exporter on the collector. Returns `this` for
    * chaining; mirrors `CollectorContract.use`.
@@ -123,10 +123,11 @@ type Panoptic = {
    * Pure projection of a report into a {@link Trace} without dispatching
    * — passthrough to `CollectorContract.toTrace`.
    */
-  toTrace(report: BaseReport): Trace; /** Flush every registered exporter that supports it. */
-  flush(): Promise<void>; /** Flush and shut down every registered exporter. */
+  toTrace(report: BaseReport): Trace;
+  /** Flush every registered exporter that supports it. */
+  flush(): Promise<void>;
+  /** Flush and shut down every registered exporter. */
   shutdown(): Promise<void>;
 };
 //#endregion
-export { Panoptic, PanopticOptions };
 //# sourceMappingURL=panoptic.type.d.mts.map

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

@@ -1 +1 @@
-{"version":3,"file":"panoptic.type.d.mts","names":[],"sources":["../../../../../../../../packages/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":["../../../../../../../../packages/ai-panoptic/src/panoptic/panoptic.type.ts"],"mappings":";;;;;;;;;;;;;;;;YAgBY;;;;;;EAMV,YAAY;;;;;;;EAOZ,YAAY;;;;;;;;;EASZ;;;;;;EAMA;;;;;;;;;;EAUA;;;;;;EAMA,gBAAgB;;;;;;EAMhB;;;;;;;;EAQA,UAAU;;;;;;;;;;;;;;;;;;;YAoBA;;WAED,WAAW;;;;;EAKpB,IAAI,UAAU,mBAAmB;;;;;;;EAOjC,OAAO,QAAQ;;;;;;;EAOf,cAAc;;;;;;EAMd,QAAQ,QAAQ,aAAa;;;;;EAK7B,QAAQ,QAAQ,aAAa;;EAE7B,SAAS;;EAET,YAAY"}

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

@@ -1,7 +1,6 @@
 import { ExporterContract } from "../contracts/exporter.contract.mjs";
 import { TraceStoreContract } from "./trace-store.contract.mjs";
 import { CacheDriver } from "@warlock.js/cache";
-
 //#region ../../packages/ai-panoptic/src/store/cache-trace-store.d.ts
 /**
  * A {@link CacheDriver} instance, or a (possibly async) factory that
@@ -14,11 +13,11 @@ import { CacheDriver } from "@warlock.js/cache";
  * driver's `get` / `set` / `remove` surface and is agnostic to the
  * concrete client + options of whichever driver backs it.
  */
-type CacheDriverInput = CacheDriver<any, any> | (() => CacheDriver<any, any> | Promise<CacheDriver<any, any>>);
+export type CacheDriverInput = CacheDriver<any, any> | (() => CacheDriver<any, any> | Promise<CacheDriver<any, any>>);
 /**
  * Options for {@link createCacheTraceStore}.
  */
-type CacheTraceStoreOptions = {
+export type CacheTraceStoreOptions = {
   /**
    * Key prefix every cache entry this store writes is namespaced under.
    * Per-trace keys are `${prefix}:trace:${traceId}`; the newest-first
@@ -38,7 +37,7 @@ type CacheTraceStoreOptions = {
  * plus a `ready()` to hydrate the in-memory mirror from the cache on
  * startup so traces survive a process restart.
  */
-type CacheTraceStoreHandle = TraceStoreContract & ExporterContract & {
+export type CacheTraceStoreHandle = TraceStoreContract & ExporterContract & {
   /**
    * Hydrate the in-memory mirror from the cache. Await once at startup
    * (the dashboard wiring does this for you) so previously-persisted
@@ -73,9 +72,8 @@ type CacheTraceStoreHandle = TraceStoreContract & ExporterContract & {
  * collector.use(store);     // fills as traces complete
  * const failed = store.query({ status: "failed" });
  */
-declare function createCacheTraceStore(cache: CacheDriverInput, options?: CacheTraceStoreOptions & {
+export declare function createCacheTraceStore(cache: CacheDriverInput, options?: CacheTraceStoreOptions & {
   onError?: (error: unknown) => void;
 }): CacheTraceStoreHandle;
 //#endregion
-export { CacheDriverInput, CacheTraceStoreHandle, CacheTraceStoreOptions, createCacheTraceStore };
 //# sourceMappingURL=cache-trace-store.d.mts.map

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

@@ -1 +1 @@
-{"version":3,"file":"cache-trace-store.d.mts","names":[],"sources":["../../../../../../../../packages/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;EA8YU;;;;;EAxYV,QAAQ;AAAA;;;;;;;KAwYE,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":["../../../../../../../../packages/ai-panoptic/src/store/cache-trace-store.ts"],"mappings":";;;;;;;;;;;;;;;YAoBY,mBAIR,+BAEO,wBAAwB,QAAQ;;;;YAK/B;;;;;;EAMV;;;;;;EAMA;;;;;;;;YAwYU,wBAAwB,qBAClC;;;;;;EAME,SAAS;;;;;;;;;;;;;;;;;;;;;;;;;;;;;wBA8BG,sBACd,OAAO,kBACP,UAAS;EAA2B,WAAW;IAC9C"}

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

@@ -224,10 +224,7 @@ var CacheTraceStore = class {
 			case "incomplete":
 				aggregate.failed += 1;
 				break;
-			case "cancelled":
-				aggregate.cancelled += 1;
-				break;
-			default: break;
+			case "cancelled": aggregate.cancelled += 1;
 		}
 	}
 	/**

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

@@ -1 +1 @@
-{"version":3,"file":"cache-trace-store.mjs","names":[],"sources":["../../../../../../../../packages/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        ? (\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          )()\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      // An incomplete agent run (its answer was cut off) errored.\n      case \"failed\":\n      case \"incomplete\": {\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":["../../../../../../../../packages/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        ? (\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          )()\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      // An incomplete agent run (its answer was cut off) errored.\n      case \"failed\":\n      case \"incomplete\": {\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,11 +1,10 @@
 import { ExporterContract } from "../contracts/exporter.contract.mjs";
 import { TraceStoreContract } from "./trace-store.contract.mjs";
-
 //#region ../../packages/ai-panoptic/src/store/in-memory-trace-store.d.ts
 /**
  * Options for {@link createInMemoryTraceStore}.
  */
-type InMemoryTraceStoreOptions = {
+export type InMemoryTraceStoreOptions = {
   /**
    * Maximum number of traces to retain. When set and exceeded, the
    * oldest-ingested trace is evicted (insertion-order FIFO) so the
@@ -26,7 +25,6 @@ type InMemoryTraceStoreOptions = {
  * const recentFailures = store.query({ status: "failed" });
  * const sessionSpend = store.aggregate({ sessionId });
  */
-declare function createInMemoryTraceStore(options?: InMemoryTraceStoreOptions): TraceStoreContract & ExporterContract;
+export declare function createInMemoryTraceStore(options?: InMemoryTraceStoreOptions): TraceStoreContract & ExporterContract;
 //#endregion
-export { InMemoryTraceStoreOptions, createInMemoryTraceStore };
 //# sourceMappingURL=in-memory-trace-store.d.mts.map

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

@@ -1 +1 @@
-{"version":3,"file":"in-memory-trace-store.d.mts","names":[],"sources":["../../../../../../../../packages/ai-panoptic/src/store/in-memory-trace-store.ts"],"mappings":";;;;;;AAWA;KAAY,yBAAA;;;AAOF;AAsLV;;;EAtLE,QAAQ;AAAA;;;;;;;;;AAwL8B;;;;iBAFxB,wBAAA,CACd,OAAA,GAAU,yBAAA,GACT,kBAAA,GAAqB,gBAAA"}
+{"version":3,"file":"in-memory-trace-store.d.mts","names":[],"sources":["../../../../../../../../packages/ai-panoptic/src/store/in-memory-trace-store.ts"],"mappings":";;;;;;YAWY;;;;;;;EAOV;;;;;;;;;;;;;;wBAsLc,yBACd,UAAU,4BACT,qBAAqB"}

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

@@ -94,10 +94,7 @@ var InMemoryTraceStore = class {
 			case "incomplete":
 				aggregate.failed += 1;
 				break;
-			case "cancelled":
-				aggregate.cancelled += 1;
-				break;
-			default: break;
+			case "cancelled": aggregate.cancelled += 1;
 		}
 	}
 	/**

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

@@ -1 +1 @@
-{"version":3,"file":"in-memory-trace-store.mjs","names":[],"sources":["../../../../../../../../packages/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. An `incomplete` agent run\n   * (its answer was cut off) errored, so it counts as `failed`.\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      case \"incomplete\": {\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(\n  options?: InMemoryTraceStoreOptions,\n): 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;;;;;;;;;CAUA,AAAQ,YAAY,WAA2B,OAAoB;EACjE,QAAQ,MAAM,KAAK,QAAnB;GACE,KAAK;IACH,UAAU,aAAa;IACvB;GAGF,KAAK;GACL,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,yBACd,SACuC;CACvC,OAAO,IAAI,mBAAmB,OAAO;AACvC"}
+{"version":3,"file":"in-memory-trace-store.mjs","names":[],"sources":["../../../../../../../../packages/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. An `incomplete` agent run\n   * (its answer was cut off) errored, so it counts as `failed`.\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      case \"incomplete\": {\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(\n  options?: InMemoryTraceStoreOptions,\n): 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;;;;;;;;;CAUA,AAAQ,YAAY,WAA2B,OAAoB;EACjE,QAAQ,MAAM,KAAK,QAAnB;GACE,KAAK;IACH,UAAU,aAAa;IACvB;GAGF,KAAK;GACL,KAAK;IACH,UAAU,UAAU;IACpB;GAGF,KAAK,aACH,UAAU,aAAa;EAO3B;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,yBACd,SACuC;CACvC,OAAO,IAAI,mBAAmB,OAAO;AACvC"}

package/esm/store/index.d.mts

@@ -4,4 +4,5 @@ import { TraceStoreContract } from "./trace-store.contract.mjs";
 import { CacheDriverInput, CacheTraceStoreHandle, CacheTraceStoreOptions, createCacheTraceStore } from "./cache-trace-store.mjs";
 import { InMemoryTraceStoreOptions, createInMemoryTraceStore } from "./in-memory-trace-store.mjs";
 import { matchTrace } from "./match-trace.mjs";
-import { emptyUsage, sumUsage } from "./sum-usage.mjs";
+import { emptyUsage, sumUsage } from "./sum-usage.mjs";
+export { type CacheDriverInput, type CacheTraceStoreHandle, type CacheTraceStoreOptions, type InMemoryTraceStoreOptions, type TraceAggregate, type TraceQuery, type TraceStoreContract, createCacheTraceStore, createInMemoryTraceStore, emptyUsage, matchTrace, sumUsage };

package/esm/store/index.mjs

@@ -3,4 +3,4 @@ import { emptyUsage, sumUsage } from "./sum-usage.mjs";
 import { createCacheTraceStore } from "./cache-trace-store.mjs";
 import { createInMemoryTraceStore } from "./in-memory-trace-store.mjs";
 
-export {  };
+export { createCacheTraceStore, createInMemoryTraceStore, emptyUsage, matchTrace, sumUsage };