@warlock.js/ai-panoptic 4.3.0

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

@@ -0,0 +1,21 @@
+import { Trace } from "../contracts/trace.type.mjs";
+import { TraceQuery } from "./trace-query.type.mjs";
+
+//#region ../@warlock.js/ai-panoptic/src/store/match-trace.d.ts
+/**
+ * Test whether one trace satisfies a {@link TraceQuery}. Every declared
+ * filter field must match (logical AND); absent fields are ignored, so
+ * an empty / undefined filter matches every trace.
+ *
+ * Time bounds compare against the trace's root `startedAt`, parsed to
+ * an epoch once per call, inclusive on both ends. Status accepts a
+ * single value or an array (membership test). Identity fields are exact
+ * string equality.
+ *
+ * Pure — used by the store's `query` and `aggregate` so both share one
+ * matching definition.
+ */
+declare function matchTrace(trace: Trace, filter?: TraceQuery): boolean;
+//#endregion
+export { matchTrace };
+//# sourceMappingURL=match-trace.d.mts.map

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

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

package/esm/store/match-trace.mjs

@@ -0,0 +1,44 @@
+//#region ../@warlock.js/ai-panoptic/src/store/match-trace.ts
+/**
+* Test whether one trace satisfies a {@link TraceQuery}. Every declared
+* filter field must match (logical AND); absent fields are ignored, so
+* an empty / undefined filter matches every trace.
+*
+* Time bounds compare against the trace's root `startedAt`, parsed to
+* an epoch once per call, inclusive on both ends. Status accepts a
+* single value or an array (membership test). Identity fields are exact
+* string equality.
+*
+* Pure — used by the store's `query` and `aggregate` so both share one
+* matching definition.
+*/
+function matchTrace(trace, filter) {
+	if (!filter) return true;
+	if (filter.traceId !== void 0 && trace.traceId !== filter.traceId) return false;
+	if (filter.sessionId !== void 0 && trace.sessionId !== filter.sessionId) return false;
+	if (filter.status !== void 0 && !statusMatches(trace.root.status, filter.status)) return false;
+	const startedAt = Date.parse(trace.startedAt);
+	if (filter.startedAfter !== void 0 && startedAt < toEpoch(filter.startedAfter)) return false;
+	if (filter.startedBefore !== void 0 && startedAt > toEpoch(filter.startedBefore)) return false;
+	return true;
+}
+/**
+* Membership test for the status filter — true when `status` equals the
+* single wanted value, or is one of the wanted array.
+*/
+function statusMatches(status, wanted) {
+	if (Array.isArray(wanted)) return wanted.includes(status);
+	return status === wanted;
+}
+/**
+* Normalize a time bound (ISO string or `Date`) to epoch milliseconds
+* for comparison against a parsed `startedAt`.
+*/
+function toEpoch(bound) {
+	if (bound instanceof Date) return bound.getTime();
+	return Date.parse(bound);
+}
+
+//#endregion
+export { matchTrace };
+//# sourceMappingURL=match-trace.mjs.map

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

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

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

@@ -0,0 +1,34 @@
+import { Usage } from "@warlock.js/ai";
+
+//#region ../@warlock.js/ai-panoptic/src/store/sum-usage.d.ts
+/**
+ * Fold a child {@link Usage} into a running accumulator. Token channels
+ * (`input` / `output` / `total`) always sum; the optional cache /
+ * reasoning channels (`cachedTokens` / `cacheWriteTokens` /
+ * `reasoningTokens`) sum only when at least one side reported them, so
+ * a provider that never meters a channel doesn't fabricate a `0` for
+ * it. The `cost` breakdown is merged with the core framework's
+ * {@link accumulateCost}, keeping cost-rollup semantics identical to a
+ * native report tree — an unpriced contributor never erases a priced
+ * one.
+ *
+ * Pure: returns a fresh `Usage`, never mutates either argument. Seed an
+ * aggregation with {@link emptyUsage}.
+ *
+ * @example
+ * let total = emptyUsage();
+ * for (const trace of traces) {
+ *   total = sumUsage(total, trace.usage);
+ * }
+ */
+declare function sumUsage(accumulator: Usage, next: Usage): Usage;
+/**
+ * A zero-valued {@link Usage} to seed an aggregation. Only the required
+ * token channels are set; optional channels stay absent until a
+ * contributor reports them, preserving the "never reported" vs
+ * "reported as 0" distinction.
+ */
+declare function emptyUsage(): Usage;
+//#endregion
+export { emptyUsage, sumUsage };
+//# sourceMappingURL=sum-usage.d.mts.map

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

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

package/esm/store/sum-usage.mjs

@@ -0,0 +1,65 @@
+import { accumulateCost } from "@warlock.js/ai";
+
+//#region ../@warlock.js/ai-panoptic/src/store/sum-usage.ts
+/**
+* Fold a child {@link Usage} into a running accumulator. Token channels
+* (`input` / `output` / `total`) always sum; the optional cache /
+* reasoning channels (`cachedTokens` / `cacheWriteTokens` /
+* `reasoningTokens`) sum only when at least one side reported them, so
+* a provider that never meters a channel doesn't fabricate a `0` for
+* it. The `cost` breakdown is merged with the core framework's
+* {@link accumulateCost}, keeping cost-rollup semantics identical to a
+* native report tree — an unpriced contributor never erases a priced
+* one.
+*
+* Pure: returns a fresh `Usage`, never mutates either argument. Seed an
+* aggregation with {@link emptyUsage}.
+*
+* @example
+* let total = emptyUsage();
+* for (const trace of traces) {
+*   total = sumUsage(total, trace.usage);
+* }
+*/
+function sumUsage(accumulator, next) {
+	const merged = {
+		input: accumulator.input + next.input,
+		output: accumulator.output + next.output,
+		total: accumulator.total + next.total
+	};
+	const cachedTokens = sumOptional(accumulator.cachedTokens, next.cachedTokens);
+	if (cachedTokens !== void 0) merged.cachedTokens = cachedTokens;
+	const cacheWriteTokens = sumOptional(accumulator.cacheWriteTokens, next.cacheWriteTokens);
+	if (cacheWriteTokens !== void 0) merged.cacheWriteTokens = cacheWriteTokens;
+	const reasoningTokens = sumOptional(accumulator.reasoningTokens, next.reasoningTokens);
+	if (reasoningTokens !== void 0) merged.reasoningTokens = reasoningTokens;
+	const cost = accumulateCost(accumulator.cost, next.cost);
+	if (cost !== void 0) merged.cost = cost;
+	return merged;
+}
+/**
+* A zero-valued {@link Usage} to seed an aggregation. Only the required
+* token channels are set; optional channels stay absent until a
+* contributor reports them, preserving the "never reported" vs
+* "reported as 0" distinction.
+*/
+function emptyUsage() {
+	return {
+		input: 0,
+		output: 0,
+		total: 0
+	};
+}
+/**
+* Add two optional token counts, treating either side's `undefined` as
+* zero — but return `undefined` when both are absent, so an unreported
+* channel stays unreported rather than collapsing to `0`.
+*/
+function sumOptional(accumulator, next) {
+	if (accumulator === void 0 && next === void 0) return;
+	return (accumulator ?? 0) + (next ?? 0);
+}
+
+//#endregion
+export { emptyUsage, sumUsage };
+//# sourceMappingURL=sum-usage.mjs.map

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

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

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

@@ -0,0 +1,51 @@
+import { ModelPricing, Usage } from "@warlock.js/ai";
+
+//#region ../@warlock.js/ai-panoptic/src/store/trace-aggregate.type.d.ts
+/**
+ * Rolled-up usage + cost across a set of stored traces, returned by the
+ * trace store's `aggregate`. Answers the headline observability
+ * questions — "how many runs, how many tokens, how much did it cost,
+ * how many failed" — for whatever slice a {@link
+ * import("./trace-query.type").TraceQuery} selected.
+ *
+ * `usage` sums the per-trace root `Usage` (already a rollup of own cost
+ * + children), so the totals reflect the entire run tree without
+ * re-walking spans. `cost` is the per-channel USD breakdown merged with
+ * the same `accumulateCost` logic the core framework uses to roll a
+ * report tree, so an unpriced trace never erases the cost of priced
+ * ones — `cost` stays `undefined` only when NO trace in the slice
+ * carried pricing.
+ *
+ * @example
+ * const stats = store.aggregate({ sessionId: "session-42" });
+ * console.log(`${stats.traces} runs, ${stats.usage.total} tokens`);
+ * const totalUsd =
+ *   (stats.cost?.input ?? 0) +
+ *   (stats.cost?.output ?? 0) +
+ *   (stats.cost?.cachedInput ?? 0) +
+ *   (stats.cost?.cachedOutput ?? 0);
+ */
+type TraceAggregate = {
+  /** Number of traces matched by the query. */traces: number; /** Count of matched traces whose root status was `"completed"`. */
+  completed: number; /** Count of matched traces whose root status was `"failed"`. */
+  failed: number; /** Count of matched traces whose root status was `"cancelled"`. */
+  cancelled: number;
+  /**
+   * Summed token usage across every matched trace. `input` / `output` /
+   * `total` always present (zero when no traces matched); the optional
+   * cache / reasoning channels are summed only when at least one trace
+   * reported them.
+   */
+  usage: Usage;
+  /**
+   * Merged per-channel USD cost across every matched trace, or
+   * `undefined` when no matched trace carried pricing. Same shape as
+   * `ModelPricing` so callers can read the input/output/cache split,
+   * not just one opaque number.
+   */
+  cost?: ModelPricing; /** Summed wall-clock duration in milliseconds across matched traces. */
+  totalDuration: number;
+};
+//#endregion
+export { TraceAggregate };
+//# sourceMappingURL=trace-aggregate.type.d.mts.map

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

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

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

@@ -0,0 +1,45 @@
+import { ReportStatus } from "@warlock.js/ai";
+
+//#region ../@warlock.js/ai-panoptic/src/store/trace-query.type.d.ts
+/**
+ * Filter passed to the trace store's `query` / `aggregate`. Every field
+ * is optional and ANDed together — an absent field is "don't care", so
+ * an empty filter matches every stored trace. Designed so the common
+ * observability questions ("everything for session X", "failed runs in
+ * the last hour", "this one run") express as a single object.
+ *
+ * Time bounds match against each trace's root `startedAt` (the wall
+ * clock the run began), inclusive on both ends, accepting either an
+ * ISO-8601 string or a `Date` so callers can pass whichever they hold.
+ *
+ * @example
+ * const failedToday = store.query({
+ *   status: "failed",
+ *   startedAfter: "2026-06-18T00:00:00.000Z",
+ * });
+ *
+ * @example
+ * const sessionSpend = store.aggregate({ sessionId: "session-42" });
+ */
+type TraceQuery = {
+  /**
+   * Match a single trace by its `traceId` (equals the root run's
+   * `runId`). The most specific filter — narrows to at most one trace.
+   */
+  traceId?: string;
+  /**
+   * Match every trace whose root carried this `sessionId`. The primary
+   * grouping dimension for conversation / request-scoped rollups.
+   */
+  sessionId?: string;
+  /**
+   * Match traces whose root terminal `status` equals this value, or any
+   * of these values when an array is given.
+   */
+  status?: ReportStatus | ReportStatus[]; /** Inclusive lower bound on the trace's root `startedAt`. */
+  startedAfter?: string | Date; /** Inclusive upper bound on the trace's root `startedAt`. */
+  startedBefore?: string | Date;
+};
+//#endregion
+export { TraceQuery };
+//# sourceMappingURL=trace-query.type.d.mts.map

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

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

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

@@ -0,0 +1,55 @@
+import { Trace } from "../contracts/trace.type.mjs";
+import { TraceAggregate } from "./trace-aggregate.type.mjs";
+import { TraceQuery } from "./trace-query.type.mjs";
+
+//#region ../@warlock.js/ai-panoptic/src/store/trace-store.contract.d.ts
+/**
+ * Contract for a Panoptic trace store — a queryable sink that retains
+ * collected {@link Trace}s so an app can answer observability questions
+ * after the fact: pull one run by id, list every run for a session,
+ * slice failed runs in a time window, or roll usage + cost across any
+ * of those slices.
+ *
+ * A store is itself a valid place for a `Collector` to fan out to: the
+ * in-memory implementation ({@link import("./in-memory-trace-store").createInMemoryTraceStore})
+ * doubles as an `ExporterContract`, so wiring it into a collector is a
+ * single `collector.use(store)` and the store fills as traces complete.
+ *
+ * **Retention is the implementation's concern.** This contract makes no
+ * promise about durability or eviction — the in-memory store keeps
+ * everything until `clear`, bounded only by an optional capacity cap.
+ *
+ * @example
+ * const store = createInMemoryTraceStore();
+ * collector.use(store);
+ * // later:
+ * const failed = store.query({ status: "failed" });
+ * const spend = store.aggregate({ sessionId });
+ */
+interface TraceStoreContract {
+  /**
+   * Ingest one finalized trace. Replaces any existing trace with the
+   * same `traceId` (re-collecting a run overwrites rather than
+   * duplicates).
+   */
+  add(trace: Trace): void;
+  /** Retrieve a single trace by its `traceId`, or `undefined` if absent. */
+  get(traceId: string): Trace | undefined;
+  /**
+   * Return every stored trace matching the filter, newest-started
+   * first. An empty filter returns all traces.
+   */
+  query(filter?: TraceQuery): Trace[];
+  /**
+   * Roll usage + cost (and status counts) across every trace matching
+   * the filter. An empty filter aggregates the whole store.
+   */
+  aggregate(filter?: TraceQuery): TraceAggregate;
+  /** Total number of traces currently retained. */
+  readonly size: number;
+  /** Remove every stored trace. */
+  clear(): void;
+}
+//#endregion
+export { TraceStoreContract };
+//# sourceMappingURL=trace-store.contract.d.mts.map

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

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