@warlock.js/ai-panoptic 4.3.0

package/esm/panoptic/panoptic-middleware.mjs

@@ -0,0 +1,68 @@
+//#region ../@warlock.js/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
+* subscription for apps that already compose cross-cutting concerns
+* through the agent middleware pipeline (`[cache, budget, guardrail,
+* observability]`). Declaring both hook maps lets a single middleware
+* object work uniformly on agents (which fire the `execute` map) and
+* supervisors (which fire the `supervisor` map) — registering it on a
+* supervisor would otherwise install and collect nothing silently.
+*
+* Both terminal paths are covered on each surface:
+* - `after` — fires on a run that produced a result. A run can complete
+*   with `result.error` populated (the engine still calls `after`), so
+*   the report AND the envelope error are collected; the error type and
+*   message land on the root span.
+* - `onError` — fires when the run threw before assembling a result. The
+*   error carries the partial result's report on its envelope; when
+*   present it is collected, with the error itself threaded onto the
+*   root span so failed runs still produce a trace.
+*
+* The hooks never return a value, so they never mutate the agent's /
+* supervisor's result. The `collect` call is fire-and-forget relative to
+* the run — the collector isolates exporter failures internally, and we
+* additionally swallow any rejection here so an observability fault can
+* never surface on the run's hot path.
+*
+* @param collector - the collector traces are fed into.
+* @param name - stable middleware name (kebab-case). Defaults to
+*   `"panoptic"`.
+*/
+function createPanopticMiddleware(collector, name = "panoptic") {
+	const collectReport = (report, rootError) => {
+		if (!isReport(report)) return;
+		collector.collect(report, rootError).catch(() => {});
+	};
+	const onResult = (result) => {
+		collectReport(result.report, result.error);
+	};
+	const onError = (error) => {
+		collectReport(error.report, error);
+	};
+	const terminalHooks = {
+		after(_ctx, result) {
+			onResult(result);
+		},
+		onError(_ctx, error) {
+			onError(error);
+		}
+	};
+	return {
+		name,
+		execute: terminalHooks,
+		supervisor: terminalHooks
+	};
+}
+/**
+* Narrow an unknown value to a `BaseReport`-shaped object. Structural
+* (checks the lineage fields the collector reads) so it accepts any
+* primitive's report subtype without importing each concrete type.
+*/
+function isReport(value) {
+	return typeof value === "object" && value !== null && typeof value.runId === "string" && typeof value.rootRunId === "string";
+}
+
+//#endregion
+export { createPanopticMiddleware };
+//# sourceMappingURL=panoptic-middleware.mjs.map

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

@@ -0,0 +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"}

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

@@ -0,0 +1,53 @@
+import { BaseReport, BaseResult } from "@warlock.js/ai";
+
+//#region ../@warlock.js/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
+ * (agent, workflow, supervisor) emits a `*.completed` event carrying the
+ * full `result` — and the result always carries a `report` tree — even
+ * when the run failed (`agent.error` / `workflow.error` fire first, then
+ * `*.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 & {
+    report: BaseReport;
+  };
+};
+/**
+ * Structural shape of anything Panoptic can subscribe to — the
+ * `on(event, handler)` surface shared verbatim by every core
+ * `@warlock.js/ai` primitive (`AgentContract`, `WorkflowInstance`,
+ * `SupervisorContract`, `OrchestratorContract`).
+ *
+ * Kept intentionally structural (not an import of the concrete
+ * contracts) so {@link panoptic} attaches to any of the four primitives
+ * — and to user-defined executables that mirror the same surface —
+ * without Panoptic taking a hard dependency on each primitive's exact
+ * event-map generics. `on` returns an unsubscribe function in the core,
+ * so the subscriber can detach cleanly.
+ *
+ * @example
+ * // Every primitive satisfies this:
+ * const agent = ai.agent({ model });
+ * const sub = panoptic({ exporters: [consoleExporter()] });
+ * const detach = sub.attach(agent); // agent is a PanopticTarget
+ */
+type PanopticTarget = {
+  /**
+   * Stable identifier of the primitive. Used only for diagnostics
+   * (Panoptic never branches behavior on it). Present on every core
+   * primitive instance.
+   */
+  readonly name?: string;
+  /**
+   * Subscribe a handler to a single event name for the lifetime of the
+   * instance, returning an unsubscribe function. Mirrors the core 3-tier
+   * model's instance tier (`agent.on(...)`, `workflow.on(...)`, …).
+   */
+  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

@@ -0,0 +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"}

package/esm/panoptic/panoptic.d.mts

@@ -0,0 +1,37 @@
+import { Panoptic, PanopticOptions } from "./panoptic.type.mjs";
+
+//#region ../@warlock.js/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
+ * builds a collector, registers them, and hands back a subscriber you can
+ * `attach()` to any agent/workflow/supervisor, install as agent
+ * `middleware()`, or feed reports to directly with `collect()`.
+ *
+ * @example
+ * // Attach to a primitive's event stream (captures every run):
+ * const observe = panoptic({
+ *   exporters: [consoleExporter(), otelExporter({ tracerName: "app" })],
+ * });
+ *
+ * const agent = ai.agent({ model });
+ * const detach = observe.attach(agent);
+ *
+ * await agent.execute("Summarize this");
+ * // ...later, on shutdown:
+ * await observe.shutdown();
+ *
+ * @example
+ * // Or wire it through the agent middleware pipeline:
+ * const observe = panoptic({ exporters: [langfuseExporter({ ... })] });
+ * const agent = ai.agent({ model, middleware: [observe.middleware()] });
+ *
+ * @example
+ * // Orchestrator turns carry no result-bearing event — collect directly:
+ * const result = await orchestrator.execute(input, { sessionId });
+ * await observe.collect(result.report);
+ */
+declare function panoptic(options?: PanopticOptions): Panoptic;
+//#endregion
+export { panoptic };
+//# sourceMappingURL=panoptic.d.mts.map

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

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

package/esm/panoptic/panoptic.mjs

@@ -0,0 +1,134 @@
+import { createCollector } from "../collector/collector.mjs";
+import { createPanopticMiddleware } from "./panoptic-middleware.mjs";
+
+//#region ../@warlock.js/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
+* per run regardless of outcome — the matching `*.error` event fires
+* first on failure, then `*.completed` still fires — so subscribing here
+* captures completed, failed, and cancelled runs alike.
+*
+* The orchestrator is intentionally absent: its `orchestrator.turn.*`
+* events carry only session identity, not a result. Collect an
+* orchestrator turn via {@link Panoptic.collect} with
+* `result.report` instead.
+*/
+const DEFAULT_COMPLETED_EVENTS = [
+	"agent.completed",
+	"workflow.completed",
+	"supervisor.completed"
+];
+/**
+* The Panoptic subscriber — binds a collector + its exporters to the
+* three feed paths (events, middleware, direct). Instantiated via
+* {@link panoptic}; callers never see `new`.
+*/
+var PanopticSubscriber = class {
+	constructor(options = {}) {
+		this.collector = options.collector ?? createCollector();
+		for (const exporter of options.exporters ?? []) this.collector.use(exporter);
+		this.completedEvents = options.completedEvents ?? [...DEFAULT_COMPLETED_EVENTS];
+		this.middlewareName = options.middlewareName ?? "panoptic";
+	}
+	use(exporter) {
+		this.collector.use(exporter);
+		return this;
+	}
+	attach(target) {
+		const unsubscribes = [];
+		for (const event of this.completedEvents) {
+			const unsubscribe = target.on(event, (payload) => {
+				this.handleCompleted(payload);
+			});
+			unsubscribes.push(unsubscribe);
+		}
+		return () => {
+			for (const unsubscribe of unsubscribes) unsubscribe();
+		};
+	}
+	middleware() {
+		return createPanopticMiddleware(this.collector, this.middlewareName);
+	}
+	async collect(report) {
+		await this.collector.collect(report);
+	}
+	toTrace(report) {
+		return this.collector.toTrace(report);
+	}
+	async flush() {
+		await this.collector.flush();
+	}
+	async shutdown() {
+		await this.collector.shutdown();
+	}
+	/**
+	* Project one terminal `*.completed` payload's report into the
+	* collector. The fan-out is fire-and-forget relative to the emitting
+	* run: the core swallows handler errors, the collector isolates
+	* exporter failures, and we additionally guard the rejection here so an
+	* observability fault never escapes the event handler.
+	*/
+	handleCompleted(payload) {
+		const report = readReport(payload);
+		if (!report) return;
+		const rootError = readResultError(payload);
+		this.collector.collect(report, rootError).catch(() => {});
+	}
+};
+/**
+* Read the envelope error off a primitive's completed-event payload
+* (`{ result: { error } }`). The error rides on the result envelope, not
+* the report tree, so the collector needs it separately to populate a
+* failed root span. Returns `undefined` when the run succeeded.
+*/
+function readResultError(payload) {
+	return (payload?.result)?.error;
+}
+/**
+* Read the `report` tree off a primitive's completed-event payload.
+* Structural (no concrete-type import) so it accepts every primitive's
+* result subtype; returns `undefined` when the payload isn't the
+* expected `{ result: { report } }` shape.
+*/
+function readReport(payload) {
+	const report = (payload?.result)?.report;
+	if (typeof report === "object" && report !== null && typeof report.runId === "string" && typeof report.rootRunId === "string") return report;
+}
+/**
+* Create a Panoptic subscriber — the one-call entry point that wires the
+* observability pipeline. Pass the exporters you want and Panoptic
+* builds a collector, registers them, and hands back a subscriber you can
+* `attach()` to any agent/workflow/supervisor, install as agent
+* `middleware()`, or feed reports to directly with `collect()`.
+*
+* @example
+* // Attach to a primitive's event stream (captures every run):
+* const observe = panoptic({
+*   exporters: [consoleExporter(), otelExporter({ tracerName: "app" })],
+* });
+*
+* const agent = ai.agent({ model });
+* const detach = observe.attach(agent);
+*
+* await agent.execute("Summarize this");
+* // ...later, on shutdown:
+* await observe.shutdown();
+*
+* @example
+* // Or wire it through the agent middleware pipeline:
+* const observe = panoptic({ exporters: [langfuseExporter({ ... })] });
+* const agent = ai.agent({ model, middleware: [observe.middleware()] });
+*
+* @example
+* // Orchestrator turns carry no result-bearing event — collect directly:
+* const result = await orchestrator.execute(input, { sessionId });
+* await observe.collect(result.report);
+*/
+function panoptic(options = {}) {
+	return new PanopticSubscriber(options);
+}
+
+//#endregion
+export { panoptic };
+//# sourceMappingURL=panoptic.mjs.map

package/esm/panoptic/panoptic.mjs.map

@@ -0,0 +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 = options.collector ?? createCollector();\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;CAO3C,AAAO,YAAY,UAA2B,CAAC,GAAG;EAChD,KAAK,YAAY,QAAQ,aAAa,gBAAgB;EAEtD,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

@@ -0,0 +1,100 @@
+import { Trace } from "../contracts/trace.type.mjs";
+import { ExporterContract } from "../contracts/exporter.contract.mjs";
+import { CollectorContract } from "../contracts/collector.contract.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
+/**
+ * Options for the {@link panoptic} subscriber factory.
+ *
+ * The common case is `{ exporters: [...] }` — Panoptic creates its own
+ * collector and registers the exporters on it. Pass `collector` to reuse
+ * a pre-built collector (e.g. one that already has a store registered);
+ * any `exporters` supplied are registered onto it as well.
+ */
+type PanopticOptions = {
+  /**
+   * Exporters to register on the collector. Each is deduped by
+   * `ExporterContract.name` (registering the same exporter twice is a
+   * no-op). Optional — you can also `use()` exporters after construction.
+   */
+  exporters?: ExporterContract[];
+  /**
+   * Bring your own collector instead of letting Panoptic create one.
+   * When supplied, `exporters` are registered onto it; when omitted,
+   * Panoptic calls `createCollector()` internally. Inject this to share
+   * one collector across several subscribers or to pre-wire a store.
+   */
+  collector?: CollectorContract;
+  /**
+   * Names of the terminal `*.completed` events to subscribe to when
+   * {@link Panoptic.attach} is called. Defaults to the completed event of
+   * every core primitive — `agent.completed`, `workflow.completed`,
+   * `supervisor.completed`. Override to widen/narrow the surface (e.g.
+   * attach only to agents). Panoptic subscribes to each name and silently
+   * ignores the ones the target doesn't emit.
+   */
+  completedEvents?: string[];
+  /**
+   * Stable name reported by the middleware returned from
+   * {@link Panoptic.middleware}. Defaults to `"panoptic"`. Override when
+   * registering more than one Panoptic middleware on the same agent.
+   */
+  middlewareName?: string;
+};
+/**
+ * The subscriber returned by {@link panoptic}. Wraps a collector +
+ * exporters and offers three ways to feed it:
+ *
+ * - **{@link Panoptic.attach}** — subscribe to a primitive's terminal
+ *   `*.completed` events (the 3-tier model's instance tier) so every run
+ *   is captured automatically. Returns a detach function.
+ * - **{@link Panoptic.middleware}** — an `AgentMiddleware` that collects
+ *   each `agent.execute()` result from the `execute.after` / `onError`
+ *   hooks, for apps that prefer the middleware pipeline over events.
+ * - **{@link Panoptic.collect}** — feed a `BaseReport` directly (e.g. an
+ *   orchestrator turn's `result.report`, which has no result-bearing
+ *   completed event).
+ *
+ * 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;
+  /**
+   * Register another exporter on the collector. Returns `this` for
+   * chaining; mirrors `CollectorContract.use`.
+   */
+  use(exporter: ExporterContract): Panoptic;
+  /**
+   * Subscribe to a primitive's terminal completed events so every run it
+   * performs is collected automatically. Safe to call on agents,
+   * workflows, and supervisors. Returns a detach function that removes
+   * every listener this call added.
+   */
+  attach(target: PanopticTarget): () => void;
+  /**
+   * An `AgentMiddleware` that feeds the collector from the
+   * `execute`-level `after` / `onError` hooks — an alternative to
+   * {@link Panoptic.attach} for apps wiring observability through the
+   * middleware pipeline. The hooks never mutate the result.
+   */
+  middleware(): AgentMiddleware;
+  /**
+   * Feed a finalized root report straight into the collector. Use for
+   * primitives whose completed event carries no result (the
+   * orchestrator) or to collect a report captured out of band.
+   */
+  collect(report: BaseReport): Promise<void>;
+  /**
+   * 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. */
+  shutdown(): Promise<void>;
+};
+//#endregion
+export { Panoptic, PanopticOptions };
+//# sourceMappingURL=panoptic.type.d.mts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"panoptic.type.d.mts","names":[],"sources":["../../../../../../../@warlock.js/ai-panoptic/src/panoptic/panoptic.type.ts"],"mappings":";;;;;;;;;AAcA;;;;;;KAAY,eAAA;EAaE;;;;AAeE;EAtBd,SAAA,GAAY,gBAAA;EA0CM;;;;;;EAnClB,SAAA,GAAY,iBAAiB;EA8Db;;;;;;;;EArDhB,eAAA;EA4BoB;;;;;EAtBpB,cAAA;AAAA;;;;;;;;;;;;;;;;;AAwDmB;KApCT,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/store/in-memory-trace-store.d.mts

@@ -0,0 +1,32 @@
+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
+/**
+ * Options for {@link createInMemoryTraceStore}.
+ */
+type InMemoryTraceStoreOptions = {
+  /**
+   * Maximum number of traces to retain. When set and exceeded, the
+   * oldest-ingested trace is evicted (insertion-order FIFO) so the
+   * store stays bounded for long-lived processes. Absent / `0` =
+   * unbounded (keep everything until `clear`).
+   */
+  capacity?: number;
+};
+/**
+ * Create an in-memory trace store. Optionally bound it with `capacity`
+ * for long-lived processes; leave it unset for dev/test where you want
+ * every trace retained.
+ *
+ * @example
+ * const store = createInMemoryTraceStore({ capacity: 1000 });
+ * collector.use(store);
+ * // later:
+ * const recentFailures = store.query({ status: "failed" });
+ * const sessionSpend = store.aggregate({ sessionId });
+ */
+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

@@ -0,0 +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"}

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

@@ -0,0 +1,134 @@
+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
+/**
+* In-memory {@link TraceStoreContract} that doubles as an
+* {@link ExporterContract} — register it on a collector
+* (`collector.use(store)`) and it fills as traces complete, then query
+* or aggregate it after the fact.
+*
+* Backed by an insertion-ordered `Map` keyed by `traceId`, giving O(1)
+* `get` / `add` / overwrite and O(n) scans for `query` / `aggregate`
+* (the price of an in-memory store with no secondary indexes — fine for
+* the dev/test and modest-volume runtime use this targets). When a
+* `capacity` is configured, ingesting past the cap evicts the oldest
+* trace.
+*
+* Instantiated fresh per store via {@link createInMemoryTraceStore};
+* callers never see `new`.
+*/
+var InMemoryTraceStore = class {
+	constructor(options) {
+		this.name = "in-memory-trace-store";
+		this.traces = /* @__PURE__ */ new Map();
+		this.capacity = options?.capacity ?? 0;
+	}
+	get size() {
+		return this.traces.size;
+	}
+	add(trace) {
+		this.traces.delete(trace.traceId);
+		this.traces.set(trace.traceId, trace);
+		this.evictOverflow();
+	}
+	/**
+	* `ExporterContract.export` — a collector dispatches a completed
+	* trace here, which is exactly an `add`. Lets the store be wired into
+	* a collector as a sink without an adapter.
+	*/
+	export(trace) {
+		this.add(trace);
+	}
+	get(traceId) {
+		return this.traces.get(traceId);
+	}
+	query(filter) {
+		const matched = [];
+		for (const trace of this.traces.values()) if (matchTrace(trace, filter)) matched.push(trace);
+		return this.sortNewestFirst(matched);
+	}
+	aggregate(filter) {
+		const aggregate = {
+			traces: 0,
+			completed: 0,
+			failed: 0,
+			cancelled: 0,
+			usage: emptyUsage(),
+			totalDuration: 0
+		};
+		for (const trace of this.traces.values()) {
+			if (!matchTrace(trace, filter)) continue;
+			aggregate.traces += 1;
+			aggregate.totalDuration += trace.duration;
+			aggregate.usage = sumUsage(aggregate.usage, trace.usage);
+			this.countStatus(aggregate, trace);
+		}
+		if (aggregate.usage.cost !== void 0) aggregate.cost = aggregate.usage.cost;
+		return aggregate;
+	}
+	clear() {
+		this.traces.clear();
+	}
+	/**
+	* Increment the matching terminal-status counter for one trace.
+	* Non-terminal statuses (`awaiting-input`, `max-iterations`) are
+	* counted in `traces` but tracked by none of the three headline
+	* counters — intentional, those three answer the common
+	* "succeeded / errored / aborted" question.
+	*/
+	countStatus(aggregate, trace) {
+		switch (trace.root.status) {
+			case "completed":
+				aggregate.completed += 1;
+				break;
+			case "failed":
+				aggregate.failed += 1;
+				break;
+			case "cancelled":
+				aggregate.cancelled += 1;
+				break;
+			default: break;
+		}
+	}
+	/**
+	* Sort matched traces newest-started first. A copy is sorted so the
+	* underlying insertion order (which eviction depends on) is never
+	* disturbed.
+	*/
+	sortNewestFirst(traces) {
+		return traces.sort((left, right) => Date.parse(right.startedAt) - Date.parse(left.startedAt));
+	}
+	/**
+	* Evict oldest-inserted traces until the store is within `capacity`.
+	* No-op when unbounded. The `Map` iterator yields keys in insertion
+	* order, so the first key is always the oldest.
+	*/
+	evictOverflow() {
+		if (this.capacity <= 0) return;
+		while (this.traces.size > this.capacity) {
+			const oldest = this.traces.keys().next().value;
+			if (oldest === void 0) return;
+			this.traces.delete(oldest);
+		}
+	}
+};
+/**
+* Create an in-memory trace store. Optionally bound it with `capacity`
+* for long-lived processes; leave it unset for dev/test where you want
+* every trace retained.
+*
+* @example
+* const store = createInMemoryTraceStore({ capacity: 1000 });
+* collector.use(store);
+* // later:
+* const recentFailures = store.query({ status: "failed" });
+* const sessionSpend = store.aggregate({ sessionId });
+*/
+function createInMemoryTraceStore(options) {
+	return new InMemoryTraceStore(options);
+}
+
+//#endregion
+export { createInMemoryTraceStore };
+//# sourceMappingURL=in-memory-trace-store.mjs.map

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

@@ -0,0 +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;CAavE,AAAO,YAAY,SAAqC;cAXjC;gCAOG,IAAI,IAAmB;EAK/C,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/index.d.mts

@@ -0,0 +1,6 @@
+import { TraceAggregate } from "./trace-aggregate.type.mjs";
+import { TraceQuery } from "./trace-query.type.mjs";
+import { TraceStoreContract } from "./trace-store.contract.mjs";
+import { InMemoryTraceStoreOptions, createInMemoryTraceStore } from "./in-memory-trace-store.mjs";
+import { matchTrace } from "./match-trace.mjs";
+import { emptyUsage, sumUsage } from "./sum-usage.mjs";

package/esm/store/index.mjs

@@ -0,0 +1,5 @@
+import { matchTrace } from "./match-trace.mjs";
+import { emptyUsage, sumUsage } from "./sum-usage.mjs";
+import { createInMemoryTraceStore } from "./in-memory-trace-store.mjs";
+
+export {  };