@warlock.js/ai-panoptic 4.3.0

package/esm/exporters/console/format-span-line.mjs

@@ -0,0 +1,41 @@
+import { totalCostUsd } from "../utils/total-cost.mjs";
+
+//#region ../@warlock.js/ai-panoptic/src/exporters/console/format-span-line.ts
+/**
+* Render a single {@link TraceSpan} as one scannable console line:
+* `<status> <type> "<name>" — <duration>ms, <tokens> tok[, $<cost>]`.
+* `depth` controls leading indentation when printing a tree. Pure — no
+* side effects — so it is trivially testable and reused by both the
+* per-trace summary and the per-span streaming line.
+*
+* @example
+* formatSpanLine(span, 1);
+* // '  ok agent "router" — 1240ms, 470 tok, $0.0021'
+*/
+function formatSpanLine(span, depth = 0) {
+	const indent = "  ".repeat(depth);
+	const marker = statusMarker(span.status);
+	const cost = totalCostUsd(span.usage);
+	const costSuffix = cost === void 0 ? "" : `, $${cost.toFixed(4)}`;
+	let line = `${indent}${marker} ${span.type} "${span.name}" — ${span.duration}ms, ${span.usage.total} tok${costSuffix}`;
+	if (span.error) line += ` [${span.error.type}: ${span.error.message}]`;
+	return line;
+}
+/**
+* Short ASCII marker for a span's terminal status. Plain ASCII (no
+* emoji/color codes) so output stays clean in log aggregators and CI.
+*/
+function statusMarker(status) {
+	switch (status) {
+		case "completed": return "ok";
+		case "failed": return "ERR";
+		case "cancelled": return "cancel";
+		case "max-iterations": return "max-iter";
+		case "awaiting-input": return "await";
+		default: return status;
+	}
+}
+
+//#endregion
+export { formatSpanLine };
+//# sourceMappingURL=format-span-line.mjs.map

package/esm/exporters/console/format-span-line.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"format-span-line.mjs","names":[],"sources":["../../../../../../../../@warlock.js/ai-panoptic/src/exporters/console/format-span-line.ts"],"sourcesContent":["import type { TraceSpan } from \"../../contracts\";\nimport { totalCostUsd } from \"../utils\";\n\n/**\n * Render a single {@link TraceSpan} as one scannable console line:\n * `<status> <type> \"<name>\" — <duration>ms, <tokens> tok[, $<cost>]`.\n * `depth` controls leading indentation when printing a tree. Pure — no\n * side effects — so it is trivially testable and reused by both the\n * per-trace summary and the per-span streaming line.\n *\n * @example\n * formatSpanLine(span, 1);\n * // '  ok agent \"router\" — 1240ms, 470 tok, $0.0021'\n */\nexport function formatSpanLine(span: TraceSpan, depth = 0): string {\n  const indent = \"  \".repeat(depth);\n  const marker = statusMarker(span.status);\n  const cost = totalCostUsd(span.usage);\n  const costSuffix = cost === undefined ? \"\" : `, $${cost.toFixed(4)}`;\n\n  let line = `${indent}${marker} ${span.type} \"${span.name}\" — ${span.duration}ms, ${span.usage.total} tok${costSuffix}`;\n\n  if (span.error) {\n    line += ` [${span.error.type}: ${span.error.message}]`;\n  }\n\n  return line;\n}\n\n/**\n * Short ASCII marker for a span's terminal status. Plain ASCII (no\n * emoji/color codes) so output stays clean in log aggregators and CI.\n */\nfunction statusMarker(status: TraceSpan[\"status\"]): string {\n  switch (status) {\n    case \"completed\":\n      return \"ok\";\n    case \"failed\":\n      return \"ERR\";\n    case \"cancelled\":\n      return \"cancel\";\n    case \"max-iterations\":\n      return \"max-iter\";\n    case \"awaiting-input\":\n      return \"await\";\n    default:\n      return status;\n  }\n}\n"],"mappings":";;;;;;;;;;;;;;AAcA,SAAgB,eAAe,MAAiB,QAAQ,GAAW;CACjE,MAAM,SAAS,KAAK,OAAO,KAAK;CAChC,MAAM,SAAS,aAAa,KAAK,MAAM;CACvC,MAAM,OAAO,aAAa,KAAK,KAAK;CACpC,MAAM,aAAa,SAAS,SAAY,KAAK,MAAM,KAAK,QAAQ,CAAC;CAEjE,IAAI,OAAO,GAAG,SAAS,OAAO,GAAG,KAAK,KAAK,IAAI,KAAK,KAAK,MAAM,KAAK,SAAS,MAAM,KAAK,MAAM,MAAM,MAAM;CAE1G,IAAI,KAAK,OACP,QAAQ,KAAK,KAAK,MAAM,KAAK,IAAI,KAAK,MAAM,QAAQ;CAGtD,OAAO;AACT;;;;;AAMA,SAAS,aAAa,QAAqC;CACzD,QAAQ,QAAR;EACE,KAAK,aACH,OAAO;EACT,KAAK,UACH,OAAO;EACT,KAAK,aACH,OAAO;EACT,KAAK,kBACH,OAAO;EACT,KAAK,kBACH,OAAO;EACT,SACE,OAAO;CACX;AACF"}

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

@@ -0,0 +1,3 @@
+import { ConsoleExporterOptions, ConsoleLike } from "./console-exporter.type.mjs";
+import { consoleExporter } from "./console-exporter.mjs";
+import { formatSpanLine } from "./format-span-line.mjs";

package/esm/exporters/file/file-exporter.d.mts

@@ -0,0 +1,23 @@
+import { ExporterContract } from "../../contracts/exporter.contract.mjs";
+import { FileExporterOptions } from "./file-exporter.type.mjs";
+
+//#region ../@warlock.js/ai-panoptic/src/exporters/file/file-exporter.d.ts
+/**
+ * Zero-dependency {@link ExporterContract} that appends completed traces
+ * to a JSON-Lines file (one JSON record per line by default). Buffers in
+ * memory and flushes either every `flushEvery` traces or on an explicit
+ * `flush()` / `shutdown()`, so a batch of traces costs one append.
+ *
+ * Useful as a durable local sink (replay traces later, ship the file to
+ * a backend out of band) and as a test fixture for the pipeline without
+ * a vendor SDK.
+ *
+ * @example
+ * collector.use(fileExporter({ path: "storage/traces.jsonl" }));
+ * // on shutdown:
+ * await collector.shutdown(); // drains the buffer
+ */
+declare function fileExporter(options: FileExporterOptions): ExporterContract;
+//#endregion
+export { fileExporter };
+//# sourceMappingURL=file-exporter.d.mts.map

package/esm/exporters/file/file-exporter.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"file-exporter.d.mts","names":[],"sources":["../../../../../../../../@warlock.js/ai-panoptic/src/exporters/file/file-exporter.ts"],"mappings":";;;;;;;AAsBA;;;;;;;;AAA4E;;;;iBAA5D,YAAA,CAAa,OAAA,EAAS,mBAAA,GAAsB,gBAAgB"}

package/esm/exporters/file/file-exporter.mjs

@@ -0,0 +1,93 @@
+import { appendFile, mkdir } from "node:fs/promises";
+import { dirname } from "node:path";
+
+//#region ../@warlock.js/ai-panoptic/src/exporters/file/file-exporter.ts
+const EXPORTER_NAME = "file";
+/**
+* Zero-dependency {@link ExporterContract} that appends completed traces
+* to a JSON-Lines file (one JSON record per line by default). Buffers in
+* memory and flushes either every `flushEvery` traces or on an explicit
+* `flush()` / `shutdown()`, so a batch of traces costs one append.
+*
+* Useful as a durable local sink (replay traces later, ship the file to
+* a backend out of band) and as a test fixture for the pipeline without
+* a vendor SDK.
+*
+* @example
+* collector.use(fileExporter({ path: "storage/traces.jsonl" }));
+* // on shutdown:
+* await collector.shutdown(); // drains the buffer
+*/
+function fileExporter(options) {
+	const writer = new FileTraceWriter(options);
+	return {
+		name: EXPORTER_NAME,
+		async export(trace) {
+			await writer.add(trace);
+		},
+		async flush() {
+			await writer.flush();
+		},
+		async shutdown() {
+			await writer.flush();
+		}
+	};
+}
+/**
+* Internal buffered writer for {@link fileExporter}. Owns the pending
+* trace buffer and the directory-created guard across the exporter's
+* lifetime; kept unexported so callers only ever see the factory.
+*/
+var FileTraceWriter = class {
+	constructor(options) {
+		this.buffer = [];
+		this.directoryReady = false;
+		this.path = options.path;
+		this.flushEvery = Math.max(1, options.flushEvery ?? 1);
+		this.pretty = options.pretty ?? false;
+	}
+	/**
+	* Buffer one trace and flush when the buffer reaches `flushEvery`.
+	*/
+	async add(trace) {
+		this.buffer.push({
+			type: "trace",
+			exportedAt: (/* @__PURE__ */ new Date()).toISOString(),
+			trace
+		});
+		if (this.buffer.length >= this.flushEvery) await this.flush();
+	}
+	/**
+	* Serialize and append every buffered record, then clear the buffer.
+	* No-op when nothing is pending so callers can flush defensively.
+	*/
+	async flush() {
+		if (this.buffer.length === 0) return;
+		const pending = this.buffer;
+		this.buffer = [];
+		await this.ensureDirectory();
+		const payload = pending.map((record) => this.serialize(record)).join("");
+		await appendFile(this.path, payload, "utf8");
+	}
+	/**
+	* Create the parent directory once, lazily, on the first write. Stores
+	* a guard so subsequent flushes skip the syscall.
+	*/
+	async ensureDirectory() {
+		if (this.directoryReady) return;
+		await mkdir(dirname(this.path), { recursive: true });
+		this.directoryReady = true;
+	}
+	/**
+	* Render one record as a newline-terminated JSON string. Pretty mode
+	* indents for human reading; compact mode keeps the file valid JSON
+	* Lines (exactly one record per physical line).
+	*/
+	serialize(record) {
+		return `${this.pretty ? JSON.stringify(record, void 0, 2) : JSON.stringify(record)}\n`;
+	}
+};
+
+//#endregion
+export { fileExporter };
+//# sourceMappingURL=file-exporter.mjs.map

package/esm/exporters/file/file-exporter.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"file-exporter.mjs","names":[],"sources":["../../../../../../../../@warlock.js/ai-panoptic/src/exporters/file/file-exporter.ts"],"sourcesContent":["import { appendFile, mkdir } from \"node:fs/promises\";\nimport { dirname } from \"node:path\";\nimport type { ExporterContract, Trace } from \"../../contracts\";\nimport type { FileExporterOptions, TraceRecord } from \"./file-exporter.type\";\n\nconst EXPORTER_NAME = \"file\";\n\n/**\n * Zero-dependency {@link ExporterContract} that appends completed traces\n * to a JSON-Lines file (one JSON record per line by default). Buffers in\n * memory and flushes either every `flushEvery` traces or on an explicit\n * `flush()` / `shutdown()`, so a batch of traces costs one append.\n *\n * Useful as a durable local sink (replay traces later, ship the file to\n * a backend out of band) and as a test fixture for the pipeline without\n * a vendor SDK.\n *\n * @example\n * collector.use(fileExporter({ path: \"storage/traces.jsonl\" }));\n * // on shutdown:\n * await collector.shutdown(); // drains the buffer\n */\nexport function fileExporter(options: FileExporterOptions): ExporterContract {\n  const writer = new FileTraceWriter(options);\n\n  return {\n    name: EXPORTER_NAME,\n    async export(trace: Trace): Promise<void> {\n      await writer.add(trace);\n    },\n    async flush(): Promise<void> {\n      await writer.flush();\n    },\n    async shutdown(): Promise<void> {\n      await writer.flush();\n    },\n  };\n}\n\n/**\n * Internal buffered writer for {@link fileExporter}. Owns the pending\n * trace buffer and the directory-created guard across the exporter's\n * lifetime; kept unexported so callers only ever see the factory.\n */\nclass FileTraceWriter {\n  private readonly path: string;\n  private readonly flushEvery: number;\n  private readonly pretty: boolean;\n  private buffer: TraceRecord[] = [];\n  private directoryReady = false;\n\n  public constructor(options: FileExporterOptions) {\n    this.path = options.path;\n    this.flushEvery = Math.max(1, options.flushEvery ?? 1);\n    this.pretty = options.pretty ?? false;\n  }\n\n  /**\n   * Buffer one trace and flush when the buffer reaches `flushEvery`.\n   */\n  public async add(trace: Trace): Promise<void> {\n    this.buffer.push({\n      type: \"trace\",\n      exportedAt: new Date().toISOString(),\n      trace,\n    });\n\n    if (this.buffer.length >= this.flushEvery) {\n      await this.flush();\n    }\n  }\n\n  /**\n   * Serialize and append every buffered record, then clear the buffer.\n   * No-op when nothing is pending so callers can flush defensively.\n   */\n  public async flush(): Promise<void> {\n    if (this.buffer.length === 0) {\n      return;\n    }\n\n    const pending = this.buffer;\n    this.buffer = [];\n\n    await this.ensureDirectory();\n\n    const payload = pending.map((record) => this.serialize(record)).join(\"\");\n\n    await appendFile(this.path, payload, \"utf8\");\n  }\n\n  /**\n   * Create the parent directory once, lazily, on the first write. Stores\n   * a guard so subsequent flushes skip the syscall.\n   */\n  private async ensureDirectory(): Promise<void> {\n    if (this.directoryReady) {\n      return;\n    }\n\n    await mkdir(dirname(this.path), { recursive: true });\n    this.directoryReady = true;\n  }\n\n  /**\n   * Render one record as a newline-terminated JSON string. Pretty mode\n   * indents for human reading; compact mode keeps the file valid JSON\n   * Lines (exactly one record per physical line).\n   */\n  private serialize(record: TraceRecord): string {\n    const json = this.pretty\n      ? JSON.stringify(record, undefined, 2)\n      : JSON.stringify(record);\n\n    return `${json}\\n`;\n  }\n}\n"],"mappings":";;;;AAKA,MAAM,gBAAgB;;;;;;;;;;;;;;;;AAiBtB,SAAgB,aAAa,SAAgD;CAC3E,MAAM,SAAS,IAAI,gBAAgB,OAAO;CAE1C,OAAO;EACL,MAAM;EACN,MAAM,OAAO,OAA6B;GACxC,MAAM,OAAO,IAAI,KAAK;EACxB;EACA,MAAM,QAAuB;GAC3B,MAAM,OAAO,MAAM;EACrB;EACA,MAAM,WAA0B;GAC9B,MAAM,OAAO,MAAM;EACrB;CACF;AACF;;;;;;AAOA,IAAM,kBAAN,MAAsB;CAOpB,AAAO,YAAY,SAA8B;gBAHjB,CAAC;wBACR;EAGvB,KAAK,OAAO,QAAQ;EACpB,KAAK,aAAa,KAAK,IAAI,GAAG,QAAQ,cAAc,CAAC;EACrD,KAAK,SAAS,QAAQ,UAAU;CAClC;;;;CAKA,MAAa,IAAI,OAA6B;EAC5C,KAAK,OAAO,KAAK;GACf,MAAM;GACN,6BAAY,IAAI,KAAK,EAAC,CAAC,YAAY;GACnC;EACF,CAAC;EAED,IAAI,KAAK,OAAO,UAAU,KAAK,YAC7B,MAAM,KAAK,MAAM;CAErB;;;;;CAMA,MAAa,QAAuB;EAClC,IAAI,KAAK,OAAO,WAAW,GACzB;EAGF,MAAM,UAAU,KAAK;EACrB,KAAK,SAAS,CAAC;EAEf,MAAM,KAAK,gBAAgB;EAE3B,MAAM,UAAU,QAAQ,KAAK,WAAW,KAAK,UAAU,MAAM,CAAC,CAAC,CAAC,KAAK,EAAE;EAEvE,MAAM,WAAW,KAAK,MAAM,SAAS,MAAM;CAC7C;;;;;CAMA,MAAc,kBAAiC;EAC7C,IAAI,KAAK,gBACP;EAGF,MAAM,MAAM,QAAQ,KAAK,IAAI,GAAG,EAAE,WAAW,KAAK,CAAC;EACnD,KAAK,iBAAiB;CACxB;;;;;;CAOA,AAAQ,UAAU,QAA6B;EAK7C,OAAO,GAJM,KAAK,SACd,KAAK,UAAU,QAAQ,QAAW,CAAC,IACnC,KAAK,UAAU,MAAM,EAEV;CACjB;AACF"}

package/esm/exporters/file/file-exporter.type.d.mts

@@ -0,0 +1,39 @@
+import { Trace } from "../../contracts/trace.type.mjs";
+//#region ../@warlock.js/ai-panoptic/src/exporters/file/file-exporter.type.d.ts
+/**
+ * One JSON-Lines record the {@link fileExporter} appends per trace. A
+ * thin envelope around {@link Trace} carrying the wire-format `type` and
+ * the time the line was written, so a downstream reader can tell records
+ * apart and order them without re-deriving anything from the payload.
+ */
+type TraceRecord = {
+  /** Discriminator for the record format — always `"trace"` today. */type: "trace"; /** ISO-8601 timestamp the exporter wrote this record. */
+  exportedAt: string; /** The completed trace, verbatim. */
+  trace: Trace;
+};
+/**
+ * Options for {@link fileExporter}.
+ */
+type FileExporterOptions = {
+  /**
+   * Absolute or cwd-relative path of the JSON-Lines file traces are
+   * appended to. The parent directory is created on first write if
+   * missing. Required.
+   */
+  path: string;
+  /**
+   * Flush the in-memory buffer to disk once it reaches this many traces.
+   * Lower values mean more frequent, smaller writes; higher values batch
+   * for throughput. Defaults to `1` (write every trace immediately).
+   */
+  flushEvery?: number;
+  /**
+   * Pretty-print each record across multiple lines instead of one
+   * compact JSON line. Defaults to `false` — compact keeps the file
+   * valid JSON Lines (one record per line).
+   */
+  pretty?: boolean;
+};
+//#endregion
+export { FileExporterOptions, TraceRecord };
+//# sourceMappingURL=file-exporter.type.d.mts.map

package/esm/exporters/file/file-exporter.type.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"file-exporter.type.d.mts","names":[],"sources":["../../../../../../../../@warlock.js/ai-panoptic/src/exporters/file/file-exporter.type.ts"],"mappings":";;;;;AAQA;;;KAAY,WAAA;EAEV,oEAAA,IAAA,WAIA;EAFA,UAAA,UAEY;EAAZ,KAAA,EAAO,KAAK;AAAA;;;;KAMF,mBAAA;EAYV;;;AAMM;;EAZN,IAAA;;;;;;EAMA,UAAA;;;;;;EAMA,MAAA;AAAA"}

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

@@ -0,0 +1,2 @@
+import { FileExporterOptions, TraceRecord } from "./file-exporter.type.mjs";
+import { fileExporter } from "./file-exporter.mjs";

package/esm/exporters/index.d.mts

@@ -0,0 +1,12 @@
+import { ConsoleExporterOptions, ConsoleLike } from "./console/console-exporter.type.mjs";
+import { consoleExporter } from "./console/console-exporter.mjs";
+import { formatSpanLine } from "./console/format-span-line.mjs";
+import { FileExporterOptions, TraceRecord } from "./file/file-exporter.type.mjs";
+import { fileExporter } from "./file/file-exporter.mjs";
+import { LangfuseClientLike, LangfuseExporterOptions, LangfuseObservationBody, LangfuseObservationEndBody, LangfuseObservationLevel, LangfuseObservationLike, LangfuseTraceBody, LangfuseTraceLike, LangfuseUsageBody } from "./langfuse/langfuse-exporter.type.mjs";
+import { langfuseExporter } from "./langfuse/langfuse-exporter.mjs";
+import { OtelExporterOptions } from "./otel/otel-exporter.type.mjs";
+import { otelExporter } from "./otel/otel-exporter.mjs";
+import { AttributeValue, GEN_AI_ATTRIBUTES, WARLOCK_ATTRIBUTES, toGenAiAttributes } from "./utils/gen-ai-attributes.mjs";
+import { totalCostUsd } from "./utils/total-cost.mjs";
+import { walkSpans } from "./utils/walk-spans.mjs";

package/esm/exporters/index.mjs

@@ -0,0 +1,12 @@
+import { walkSpans } from "./utils/walk-spans.mjs";
+import { totalCostUsd } from "./utils/total-cost.mjs";
+import { GEN_AI_ATTRIBUTES, WARLOCK_ATTRIBUTES, toGenAiAttributes } from "./utils/gen-ai-attributes.mjs";
+import { formatSpanLine } from "./console/format-span-line.mjs";
+import { consoleExporter } from "./console/console-exporter.mjs";
+import { fileExporter } from "./file/file-exporter.mjs";
+import { langfuseExporter } from "./langfuse/langfuse-exporter.mjs";
+import "./langfuse/index.mjs";
+import { otelExporter } from "./otel/otel-exporter.mjs";
+import "./otel/index.mjs";
+
+export {  };

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

@@ -0,0 +1,2 @@
+import { LangfuseClientLike, LangfuseExporterOptions, LangfuseObservationBody, LangfuseObservationEndBody, LangfuseObservationLevel, LangfuseObservationLike, LangfuseTraceBody, LangfuseTraceLike, LangfuseUsageBody } from "./langfuse-exporter.type.mjs";
+import { langfuseExporter } from "./langfuse-exporter.mjs";

package/esm/exporters/langfuse/index.mjs

@@ -0,0 +1,3 @@
+import { langfuseExporter } from "./langfuse-exporter.mjs";
+
+export {  };

package/esm/exporters/langfuse/langfuse-exporter.d.mts

@@ -0,0 +1,27 @@
+import { ExporterContract } from "../../contracts/exporter.contract.mjs";
+import { LangfuseExporterOptions } from "./langfuse-exporter.type.mjs";
+
+//#region ../@warlock.js/ai-panoptic/src/exporters/langfuse/langfuse-exporter.d.ts
+/**
+ * {@link ExporterContract} that maps Panoptic traces onto Langfuse
+ * traces and observations. Lazily imports `langfuse` so it stays an
+ * OPTIONAL peer — importing this module never forces the SDK to be
+ * installed, and a missing SDK surfaces as a curated "install this"
+ * error when the exporter first needs to build a client.
+ *
+ * The root {@link TraceSpan} becomes a Langfuse trace; each descendant
+ * becomes a nested observation — a `generation` when it produced tokens
+ * (LLM-backed agents, supervisors), otherwise a plain `span` (tools,
+ * callbacks). Timing, status, version, and rolled-up `usage` are mapped
+ * 1:1; the rest of the GenAI attributes ride along as observation
+ * metadata.
+ *
+ * @example
+ * collector.use(langfuseExporter({ publicKey: "pk-...", secretKey: "sk-..." }));
+ * // or reuse an existing client:
+ * collector.use(langfuseExporter({ client: myLangfuse }));
+ */
+declare function langfuseExporter(options: LangfuseExporterOptions): ExporterContract;
+//#endregion
+export { langfuseExporter };
+//# sourceMappingURL=langfuse-exporter.d.mts.map

package/esm/exporters/langfuse/langfuse-exporter.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"langfuse-exporter.d.mts","names":[],"sources":["../../../../../../../../@warlock.js/ai-panoptic/src/exporters/langfuse/langfuse-exporter.ts"],"mappings":";;;;;;;AA+EA;;;;;;;;AAAoF;;;;;;;;iBAApE,gBAAA,CAAiB,OAAA,EAAS,uBAAA,GAA0B,gBAAgB"}

package/esm/exporters/langfuse/langfuse-exporter.mjs

@@ -0,0 +1,158 @@
+import { toGenAiAttributes } from "../utils/gen-ai-attributes.mjs";
+
+//#region ../@warlock.js/ai-panoptic/src/exporters/langfuse/langfuse-exporter.ts
+const EXPORTER_NAME = "langfuse";
+let LangfuseSdk;
+let isModuleExists = null;
+let loadingPromise;
+const LANGFUSE_INSTALL_INSTRUCTIONS = `
+The Panoptic Langfuse exporter requires the langfuse package.
+Install it with:
+
+  npm install langfuse
+
+Or with your preferred package manager:
+
+  pnpm add langfuse
+  yarn add langfuse
+`.trim();
+/**
+* Settle the lazy import of `langfuse` once, concurrency-safe. Only
+* needed when the caller did not pass a ready `client`. A bare `catch`
+* flips the flag to `false`; the curated install string surfaces at use
+* time, never a raw module-resolution stack trace.
+*/
+function loadLangfuse() {
+	if (isModuleExists !== null) return Promise.resolve();
+	if (loadingPromise) return loadingPromise;
+	loadingPromise = (async () => {
+		try {
+			LangfuseSdk = await import("langfuse");
+			isModuleExists = true;
+		} catch {
+			isModuleExists = false;
+		}
+	})();
+	return loadingPromise;
+}
+/**
+* {@link ExporterContract} that maps Panoptic traces onto Langfuse
+* traces and observations. Lazily imports `langfuse` so it stays an
+* OPTIONAL peer — importing this module never forces the SDK to be
+* installed, and a missing SDK surfaces as a curated "install this"
+* error when the exporter first needs to build a client.
+*
+* The root {@link TraceSpan} becomes a Langfuse trace; each descendant
+* becomes a nested observation — a `generation` when it produced tokens
+* (LLM-backed agents, supervisors), otherwise a plain `span` (tools,
+* callbacks). Timing, status, version, and rolled-up `usage` are mapped
+* 1:1; the rest of the GenAI attributes ride along as observation
+* metadata.
+*
+* @example
+* collector.use(langfuseExporter({ publicKey: "pk-...", secretKey: "sk-..." }));
+* // or reuse an existing client:
+* collector.use(langfuseExporter({ client: myLangfuse }));
+*/
+function langfuseExporter(options) {
+	let client = options.client;
+	if (!client) loadLangfuse();
+	const resolveClient = async () => {
+		if (client) return client;
+		await loadLangfuse();
+		if (!isModuleExists) throw new Error(LANGFUSE_INSTALL_INSTRUCTIONS);
+		client = new LangfuseSdk.Langfuse({
+			publicKey: options.publicKey,
+			secretKey: options.secretKey,
+			baseUrl: options.baseUrl
+		});
+		return client;
+	};
+	return {
+		name: EXPORTER_NAME,
+		async export(trace) {
+			emitTrace(await resolveClient(), trace);
+		},
+		async flush() {
+			if (!client) return;
+			await client.flushAsync();
+		},
+		async shutdown() {
+			if (!client) return;
+			await client.shutdownAsync();
+		}
+	};
+}
+/**
+* Create the Langfuse trace from the root span, then recurse the
+* children into nested observations.
+*/
+function emitTrace(client, trace) {
+	const root = trace.root;
+	const langfuseTrace = client.trace({
+		id: root.traceId,
+		name: root.name,
+		sessionId: trace.sessionId,
+		version: root.version,
+		timestamp: new Date(root.startedAt),
+		metadata: toGenAiAttributes(root)
+	});
+	for (const child of root.children) emitObservation(langfuseTrace, child);
+}
+/**
+* Map one {@link TraceSpan} onto a Langfuse observation under `parent`,
+* then recurse its children. Token-producing spans become
+* `generation`s; everything else becomes a plain `span`.
+*/
+function emitObservation(parent, span) {
+	const body = {
+		id: span.spanId,
+		name: span.name,
+		startTime: new Date(span.startedAt),
+		endTime: new Date(span.endedAt),
+		level: toLevel(span),
+		statusMessage: span.error?.message,
+		version: span.version,
+		metadata: toGenAiAttributes(span)
+	};
+	let observation;
+	if (producedTokens(span)) {
+		body.usage = {
+			input: span.usage.input,
+			output: span.usage.output,
+			total: span.usage.total,
+			unit: "TOKENS"
+		};
+		observation = parent.generation(body);
+	} else observation = parent.span(body);
+	for (const child of span.children) emitObservation(observation, child);
+	observation.end({ endTime: body.endTime });
+}
+/**
+* A span counts as an LLM `generation` when it metered any tokens. Pure
+* tools/callbacks contribute zero own-cost and map to plain spans.
+*
+* **Known limitation.** `TraceSpan.usage` is the ROLLED-UP usage (this
+* node's own cost plus the sum of its children), not own-usage — the
+* core `BaseReport` exposes no separate own-usage field, so a composite
+* node (e.g. an agent that itself made no model call but whose tool
+* children did) is classified as a `generation` on its children's
+* tokens. We cannot classify on own-usage until the report shape carries
+* it; the rolled-up `usage` block emitted on such a generation therefore
+* double-counts tokens already attributed to descendant observations.
+*/
+function producedTokens(span) {
+	return span.usage.total > 0;
+}
+/**
+* Map the Panoptic span status onto a Langfuse observation level —
+* failed/cancelled spans surface as `ERROR`, everything else `DEFAULT`.
+*/
+function toLevel(span) {
+	if (span.status === "failed" || span.status === "cancelled") return "ERROR";
+	return "DEFAULT";
+}
+
+//#endregion
+export { langfuseExporter };
+//# sourceMappingURL=langfuse-exporter.mjs.map

package/esm/exporters/langfuse/langfuse-exporter.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"langfuse-exporter.mjs","names":[],"sources":["../../../../../../../../@warlock.js/ai-panoptic/src/exporters/langfuse/langfuse-exporter.ts"],"sourcesContent":["import type { ExporterContract, Trace, TraceSpan } from \"../../contracts\";\nimport { toGenAiAttributes } from \"../utils\";\nimport type {\n  LangfuseClientLike,\n  LangfuseExporterOptions,\n  LangfuseObservationBody,\n  LangfuseObservationLevel,\n  LangfuseObservationLike,\n  LangfuseTraceLike,\n} from \"./langfuse-exporter.type\";\n\nconst EXPORTER_NAME = \"langfuse\";\n\n// ============================================================\n// Lazily-loaded langfuse SDK (OPTIONAL peer)\n// ============================================================\n\nlet LangfuseSdk: typeof import(\"langfuse\");\nlet isModuleExists: boolean | null = null;\nlet loadingPromise: Promise<void> | undefined;\n\nconst LANGFUSE_INSTALL_INSTRUCTIONS = `\nThe Panoptic Langfuse exporter requires the langfuse package.\nInstall it with:\n\n  npm install langfuse\n\nOr with your preferred package manager:\n\n  pnpm add langfuse\n  yarn add langfuse\n`.trim();\n\n/**\n * Settle the lazy import of `langfuse` once, concurrency-safe. Only\n * needed when the caller did not pass a ready `client`. A bare `catch`\n * flips the flag to `false`; the curated install string surfaces at use\n * time, never a raw module-resolution stack trace.\n */\nfunction loadLangfuse(): Promise<void> {\n  if (isModuleExists !== null) {\n    return Promise.resolve();\n  }\n\n  if (loadingPromise) {\n    return loadingPromise;\n  }\n\n  loadingPromise = (async () => {\n    try {\n      LangfuseSdk = await import(\"langfuse\");\n      isModuleExists = true;\n    } catch {\n      isModuleExists = false;\n    }\n  })();\n\n  return loadingPromise;\n}\n\n/**\n * {@link ExporterContract} that maps Panoptic traces onto Langfuse\n * traces and observations. Lazily imports `langfuse` so it stays an\n * OPTIONAL peer — importing this module never forces the SDK to be\n * installed, and a missing SDK surfaces as a curated \"install this\"\n * error when the exporter first needs to build a client.\n *\n * The root {@link TraceSpan} becomes a Langfuse trace; each descendant\n * becomes a nested observation — a `generation` when it produced tokens\n * (LLM-backed agents, supervisors), otherwise a plain `span` (tools,\n * callbacks). Timing, status, version, and rolled-up `usage` are mapped\n * 1:1; the rest of the GenAI attributes ride along as observation\n * metadata.\n *\n * @example\n * collector.use(langfuseExporter({ publicKey: \"pk-...\", secretKey: \"sk-...\" }));\n * // or reuse an existing client:\n * collector.use(langfuseExporter({ client: myLangfuse }));\n */\nexport function langfuseExporter(options: LangfuseExporterOptions): ExporterContract {\n  let client: LangfuseClientLike | undefined = options.client;\n\n  if (!client) {\n    loadLangfuse();\n  }\n\n  const resolveClient = async (): Promise<LangfuseClientLike> => {\n    if (client) {\n      return client;\n    }\n\n    await loadLangfuse();\n\n    if (!isModuleExists) {\n      throw new Error(LANGFUSE_INSTALL_INSTRUCTIONS);\n    }\n\n    client = new LangfuseSdk.Langfuse({\n      publicKey: options.publicKey,\n      secretKey: options.secretKey,\n      baseUrl: options.baseUrl,\n    }) as unknown as LangfuseClientLike;\n\n    return client;\n  };\n\n  return {\n    name: EXPORTER_NAME,\n    async export(trace: Trace): Promise<void> {\n      const activeClient = await resolveClient();\n      emitTrace(activeClient, trace);\n    },\n    async flush(): Promise<void> {\n      if (!client) {\n        return;\n      }\n\n      await client.flushAsync();\n    },\n    async shutdown(): Promise<void> {\n      if (!client) {\n        return;\n      }\n\n      await client.shutdownAsync();\n    },\n  };\n}\n\n/**\n * Create the Langfuse trace from the root span, then recurse the\n * children into nested observations.\n */\nfunction emitTrace(client: LangfuseClientLike, trace: Trace): void {\n  const root = trace.root;\n\n  const langfuseTrace = client.trace({\n    id: root.traceId,\n    name: root.name,\n    sessionId: trace.sessionId,\n    version: root.version,\n    timestamp: new Date(root.startedAt),\n    metadata: toGenAiAttributes(root),\n  });\n\n  for (const child of root.children) {\n    emitObservation(langfuseTrace, child);\n  }\n}\n\n/**\n * Map one {@link TraceSpan} onto a Langfuse observation under `parent`,\n * then recurse its children. Token-producing spans become\n * `generation`s; everything else becomes a plain `span`.\n */\nfunction emitObservation(\n  parent: LangfuseTraceLike | LangfuseObservationLike,\n  span: TraceSpan,\n): void {\n  const body: LangfuseObservationBody = {\n    id: span.spanId,\n    name: span.name,\n    startTime: new Date(span.startedAt),\n    endTime: new Date(span.endedAt),\n    level: toLevel(span),\n    statusMessage: span.error?.message,\n    version: span.version,\n    metadata: toGenAiAttributes(span),\n  };\n\n  let observation: LangfuseObservationLike;\n\n  if (producedTokens(span)) {\n    body.usage = {\n      input: span.usage.input,\n      output: span.usage.output,\n      total: span.usage.total,\n      unit: \"TOKENS\",\n    };\n    observation = parent.generation(body);\n  } else {\n    observation = parent.span(body);\n  }\n\n  for (const child of span.children) {\n    emitObservation(observation, child);\n  }\n\n  // Explicitly end the observation. The body already carries `endTime`,\n  // so this is idempotent — but the SDK only finalizes (and flushes) an\n  // observation on `end()`, so without it long-lived clients can leave\n  // observations open. Safe against the local `LangfuseObservationLike`\n  // shape, which declares `end(body?)`.\n  observation.end({ endTime: body.endTime });\n}\n\n/**\n * A span counts as an LLM `generation` when it metered any tokens. Pure\n * tools/callbacks contribute zero own-cost and map to plain spans.\n *\n * **Known limitation.** `TraceSpan.usage` is the ROLLED-UP usage (this\n * node's own cost plus the sum of its children), not own-usage — the\n * core `BaseReport` exposes no separate own-usage field, so a composite\n * node (e.g. an agent that itself made no model call but whose tool\n * children did) is classified as a `generation` on its children's\n * tokens. We cannot classify on own-usage until the report shape carries\n * it; the rolled-up `usage` block emitted on such a generation therefore\n * double-counts tokens already attributed to descendant observations.\n */\nfunction producedTokens(span: TraceSpan): boolean {\n  return span.usage.total > 0;\n}\n\n/**\n * Map the Panoptic span status onto a Langfuse observation level —\n * failed/cancelled spans surface as `ERROR`, everything else `DEFAULT`.\n */\nfunction toLevel(span: TraceSpan): LangfuseObservationLevel {\n  if (span.status === \"failed\" || span.status === \"cancelled\") {\n    return \"ERROR\";\n  }\n\n  return \"DEFAULT\";\n}\n"],"mappings":";;;AAWA,MAAM,gBAAgB;AAMtB,IAAI;AACJ,IAAI,iBAAiC;AACrC,IAAI;AAEJ,MAAM,gCAAgC;;;;;;;;;;EAUpC,KAAK;;;;;;;AAQP,SAAS,eAA8B;CACrC,IAAI,mBAAmB,MACrB,OAAO,QAAQ,QAAQ;CAGzB,IAAI,gBACF,OAAO;CAGT,kBAAkB,YAAY;EAC5B,IAAI;GACF,cAAc,MAAM,OAAO;GAC3B,iBAAiB;EACnB,QAAQ;GACN,iBAAiB;EACnB;CACF,EAAC,CAAE;CAEH,OAAO;AACT;;;;;;;;;;;;;;;;;;;;AAqBA,SAAgB,iBAAiB,SAAoD;CACnF,IAAI,SAAyC,QAAQ;CAErD,IAAI,CAAC,QACH,aAAa;CAGf,MAAM,gBAAgB,YAAyC;EAC7D,IAAI,QACF,OAAO;EAGT,MAAM,aAAa;EAEnB,IAAI,CAAC,gBACH,MAAM,IAAI,MAAM,6BAA6B;EAG/C,SAAS,IAAI,YAAY,SAAS;GAChC,WAAW,QAAQ;GACnB,WAAW,QAAQ;GACnB,SAAS,QAAQ;EACnB,CAAC;EAED,OAAO;CACT;CAEA,OAAO;EACL,MAAM;EACN,MAAM,OAAO,OAA6B;GAExC,UAAU,MADiB,cAAc,GACjB,KAAK;EAC/B;EACA,MAAM,QAAuB;GAC3B,IAAI,CAAC,QACH;GAGF,MAAM,OAAO,WAAW;EAC1B;EACA,MAAM,WAA0B;GAC9B,IAAI,CAAC,QACH;GAGF,MAAM,OAAO,cAAc;EAC7B;CACF;AACF;;;;;AAMA,SAAS,UAAU,QAA4B,OAAoB;CACjE,MAAM,OAAO,MAAM;CAEnB,MAAM,gBAAgB,OAAO,MAAM;EACjC,IAAI,KAAK;EACT,MAAM,KAAK;EACX,WAAW,MAAM;EACjB,SAAS,KAAK;EACd,WAAW,IAAI,KAAK,KAAK,SAAS;EAClC,UAAU,kBAAkB,IAAI;CAClC,CAAC;CAED,KAAK,MAAM,SAAS,KAAK,UACvB,gBAAgB,eAAe,KAAK;AAExC;;;;;;AAOA,SAAS,gBACP,QACA,MACM;CACN,MAAM,OAAgC;EACpC,IAAI,KAAK;EACT,MAAM,KAAK;EACX,WAAW,IAAI,KAAK,KAAK,SAAS;EAClC,SAAS,IAAI,KAAK,KAAK,OAAO;EAC9B,OAAO,QAAQ,IAAI;EACnB,eAAe,KAAK,OAAO;EAC3B,SAAS,KAAK;EACd,UAAU,kBAAkB,IAAI;CAClC;CAEA,IAAI;CAEJ,IAAI,eAAe,IAAI,GAAG;EACxB,KAAK,QAAQ;GACX,OAAO,KAAK,MAAM;GAClB,QAAQ,KAAK,MAAM;GACnB,OAAO,KAAK,MAAM;GAClB,MAAM;EACR;EACA,cAAc,OAAO,WAAW,IAAI;CACtC,OACE,cAAc,OAAO,KAAK,IAAI;CAGhC,KAAK,MAAM,SAAS,KAAK,UACvB,gBAAgB,aAAa,KAAK;CAQpC,YAAY,IAAI,EAAE,SAAS,KAAK,QAAQ,CAAC;AAC3C;;;;;;;;;;;;;;AAeA,SAAS,eAAe,MAA0B;CAChD,OAAO,KAAK,MAAM,QAAQ;AAC5B;;;;;AAMA,SAAS,QAAQ,MAA2C;CAC1D,IAAI,KAAK,WAAW,YAAY,KAAK,WAAW,aAC9C,OAAO;CAGT,OAAO;AACT"}

package/esm/exporters/langfuse/langfuse-exporter.type.d.mts

@@ -0,0 +1,90 @@
+//#region ../@warlock.js/ai-panoptic/src/exporters/langfuse/langfuse-exporter.type.d.ts
+/**
+ * Minimal structural view of the parts of the `langfuse` SDK the
+ * exporter actually calls. Declared locally (rather than importing the
+ * SDK's own types) so this module type-checks even when `langfuse` is
+ * not installed — it is an OPTIONAL peer, lazily imported at runtime.
+ * The shape tracks Langfuse SDK v3: a client creates a trace, a trace
+ * creates nested `span` / `generation` observations, and the client is
+ * drained with `flushAsync` / `shutdownAsync`.
+ */
+type LangfuseClientLike = {
+  trace(body: LangfuseTraceBody): LangfuseTraceLike;
+  flushAsync(): Promise<unknown>;
+  shutdownAsync(): Promise<unknown>;
+};
+/**
+ * A Langfuse trace handle — creates nested observations and carries the
+ * trace-level metadata Panoptic maps the root span onto.
+ */
+type LangfuseTraceLike = {
+  span(body: LangfuseObservationBody): LangfuseObservationLike;
+  generation(body: LangfuseObservationBody): LangfuseObservationLike;
+};
+/**
+ * A Langfuse observation handle (span or generation) — nests further
+ * children and is closed with `end()`.
+ */
+type LangfuseObservationLike = {
+  span(body: LangfuseObservationBody): LangfuseObservationLike;
+  generation(body: LangfuseObservationBody): LangfuseObservationLike;
+  end(body?: LangfuseObservationEndBody): unknown;
+};
+/** Subset of the Langfuse trace-creation body Panoptic populates. */
+type LangfuseTraceBody = {
+  id?: string;
+  name?: string;
+  sessionId?: string;
+  version?: string;
+  timestamp?: Date;
+  metadata?: Record<string, unknown>;
+};
+/** Subset of the Langfuse observation-creation body Panoptic populates. */
+type LangfuseObservationBody = {
+  id?: string;
+  name?: string;
+  startTime?: Date;
+  endTime?: Date;
+  level?: LangfuseObservationLevel;
+  statusMessage?: string;
+  version?: string;
+  usage?: LangfuseUsageBody;
+  metadata?: Record<string, unknown>;
+};
+/** Body accepted by `observation.end()`. */
+type LangfuseObservationEndBody = {
+  endTime?: Date;
+  level?: LangfuseObservationLevel;
+  statusMessage?: string;
+};
+/** Langfuse usage block (`input`/`output`/`total` token counts). */
+type LangfuseUsageBody = {
+  input?: number;
+  output?: number;
+  total?: number;
+  unit?: "TOKENS";
+};
+/** Langfuse observation severity levels. */
+type LangfuseObservationLevel = "DEFAULT" | "DEBUG" | "WARNING" | "ERROR";
+/**
+ * Options for {@link langfuseExporter}.
+ *
+ * Either pass an already-constructed Langfuse `client`, or pass the
+ * credentials and let the exporter construct one lazily (so `langfuse`
+ * stays an optional peer that is only imported when this exporter is
+ * actually used).
+ */
+type LangfuseExporterOptions = {
+  /**
+   * A pre-built Langfuse client (any object matching
+   * {@link LangfuseClientLike}, including a real `Langfuse` instance).
+   * When supplied, the exporter never imports the SDK itself.
+   */
+  client?: LangfuseClientLike; /** Langfuse public key — used to construct a client when `client` is omitted. */
+  publicKey?: string; /** Langfuse secret key — used to construct a client when `client` is omitted. */
+  secretKey?: string; /** Langfuse host base URL. Optional; defaults to the SDK's own default. */
+  baseUrl?: string;
+};
+//#endregion
+export { LangfuseClientLike, LangfuseExporterOptions, LangfuseObservationBody, LangfuseObservationEndBody, LangfuseObservationLevel, LangfuseObservationLike, LangfuseTraceBody, LangfuseTraceLike, LangfuseUsageBody };
+//# sourceMappingURL=langfuse-exporter.type.d.mts.map

package/esm/exporters/langfuse/langfuse-exporter.type.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"langfuse-exporter.type.d.mts","names":[],"sources":["../../../../../../../../@warlock.js/ai-panoptic/src/exporters/langfuse/langfuse-exporter.type.ts"],"mappings":";;AASA;;;;;;;;KAAY,kBAAA;EACV,KAAA,CAAM,IAAA,EAAM,iBAAA,GAAoB,iBAAA;EAChC,UAAA,IAAc,OAAA;EACd,aAAA,IAAiB,OAAA;AAAA;;;;;KAOP,iBAAA;EACV,IAAA,CAAK,IAAA,EAAM,uBAAA,GAA0B,uBAAA;EACrC,UAAA,CAAW,IAAA,EAAM,uBAAA,GAA0B,uBAAA;AAAA;;;;;KAOjC,uBAAA;EACV,IAAA,CAAK,IAAA,EAAM,uBAAA,GAA0B,uBAAA;EACrC,UAAA,CAAW,IAAA,EAAM,uBAAA,GAA0B,uBAAA;EAC3C,GAAA,CAAI,IAAA,GAAO,0BAAA;AAAA;;KAID,iBAAA;EACV,EAAA;EACA,IAAA;EACA,SAAA;EACA,OAAA;EACA,SAAA,GAAY,IAAA;EACZ,QAAA,GAAW,MAAM;AAAA;;KAIP,uBAAA;EACV,EAAA;EACA,IAAA;EACA,SAAA,GAAY,IAAA;EACZ,OAAA,GAAU,IAAA;EACV,KAAA,GAAQ,wBAAA;EACR,aAAA;EACA,OAAA;EACA,KAAA,GAAQ,iBAAA;EACR,QAAA,GAAW,MAAA;AAAA;;KAID,0BAAA;EACV,OAAA,GAAU,IAAA;EACV,KAAA,GAAQ,wBAAwB;EAChC,aAAA;AAAA;;KAIU,iBAAA;EACV,KAAA;EACA,MAAA;EACA,KAAA;EACA,IAAA;AAAA;;KAIU,wBAAA;;;;;;;;;KAUA,uBAAA;EAtCA;;;;;EA4CV,MAAA,GAAS,kBAAkB,EApCnB;EAsCR,SAAA,WArCiB;EAuCjB,SAAA,WA/CA;EAiDA,OAAA;AAAA"}

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

@@ -0,0 +1,2 @@
+import { OtelExporterOptions } from "./otel-exporter.type.mjs";
+import { otelExporter } from "./otel-exporter.mjs";

package/esm/exporters/otel/index.mjs

@@ -0,0 +1,3 @@
+import { otelExporter } from "./otel-exporter.mjs";
+
+export {  };

package/esm/exporters/otel/otel-exporter.d.mts

@@ -0,0 +1,29 @@
+import { ExporterContract } from "../../contracts/exporter.contract.mjs";
+import { OtelExporterOptions } from "./otel-exporter.type.mjs";
+
+//#region ../@warlock.js/ai-panoptic/src/exporters/otel/otel-exporter.d.ts
+/**
+ * {@link ExporterContract} that maps Panoptic traces onto OpenTelemetry
+ * spans following the GenAI semantic conventions (`gen_ai.*`
+ * attributes). Lazily imports `@opentelemetry/api` so it stays an
+ * OPTIONAL peer — importing this module never forces the SDK to be
+ * installed, and a missing SDK surfaces as a curated "install this"
+ * error on first `export`, not a boot-time stack trace.
+ *
+ * The exporter emits onto a `Tracer` you supply (or fetches one from the
+ * globally registered provider). It never configures the SDK — wiring a
+ * `TracerProvider`, processors, and span exporters is the host app's
+ * job, exactly as with any other OTel instrumentation.
+ *
+ * Each {@link TraceSpan} becomes one OTel span with the source span's
+ * start/end times and parent relationship reconstructed, so the emitted
+ * tree matches the original execution tree.
+ *
+ * @example
+ * // app already set up @opentelemetry/sdk-trace-base + a provider
+ * collector.use(otelExporter({ tracerName: "my-app", system: "openai" }));
+ */
+declare function otelExporter(options?: OtelExporterOptions): ExporterContract;
+//#endregion
+export { otelExporter };
+//# sourceMappingURL=otel-exporter.d.mts.map

package/esm/exporters/otel/otel-exporter.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"otel-exporter.d.mts","names":[],"sources":["../../../../../../../../@warlock.js/ai-panoptic/src/exporters/otel/otel-exporter.ts"],"mappings":";;;;;;;AAiFA;;;;;;;;AAAiF;;;;;;;;;;iBAAjE,YAAA,CAAa,OAAA,GAAS,mBAAA,GAA2B,gBAAgB"}