loggily 0.6.2 → 0.8.0

package/dist/worker.mjs

@@ -0,0 +1,297 @@
+import { a as baseCreateLogger, j as withSpans, s as createLogger, v as pipe } from "./core-B3pox577.mjs";
+//#region src/worker.ts
+/**
+* Worker Thread Logger/Console Forwarding
+*
+* Pipeline-based worker logging: worker loggers use a postMessage transport
+* so events flow through the main thread's pipeline for output.
+*
+* ## Structured Logger (Recommended)
+*
+* @example Worker side:
+* ```typescript
+* import { createWorkerLogger } from "loggily/worker"
+* const log = createWorkerLogger(postMessage, "km:worker:parse")
+*
+* log.info?.("processing", { file: "test.md" })
+* {
+*   using span = log.span?.("parse")
+*   // ... work ...
+*   span.spanData.lines = 100
+* }
+* ```
+*
+* @example Main thread side:
+* ```typescript
+* import { createWorkerLogHandler } from "loggily/worker"
+*
+* const handleLog = createWorkerLogHandler()
+* worker.onmessage = (e) => handleLog(e.data)
+* ```
+*
+* ## Console Forwarding (Simple)
+*
+* @example Worker side:
+* ```typescript
+* import { forwardConsole } from "loggily/worker"
+* forwardConsole(postMessage)
+*
+* console.log("message")  // Forwarded to main thread
+* ```
+*/
+/** Type guard for LogEvent (structured log from worker) */
+function isWorkerLogEvent(msg) {
+	return typeof msg === "object" && msg?.kind === "log";
+}
+/** Type guard for SpanEvent (span from worker) */
+function isWorkerSpanEvent(msg) {
+	return typeof msg === "object" && msg?.kind === "span";
+}
+/** Type guard for any pipeline Event (log or span) */
+function isWorkerEvent(msg) {
+	return isWorkerLogEvent(msg) || isWorkerSpanEvent(msg);
+}
+/** Type guard for WorkerConsoleMessage */
+function isWorkerConsoleMessage(msg) {
+	return typeof msg === "object" && msg?.type === "console" && typeof msg.level === "string" && Array.isArray(msg.args);
+}
+/** Type guard for any worker message (console or pipeline event) */
+function isWorkerMessage(msg) {
+	return isWorkerConsoleMessage(msg) || isWorkerEvent(msg);
+}
+/** Store original console methods for restoration */
+let originalConsole = null;
+/**
+* Forward console.* calls from worker to main thread via postMessage.
+*
+* Monkey-patches console methods. postMessage uses structuredClone,
+* which handles most values natively. If cloning fails (functions,
+* symbols), falls back to original console.
+*
+* @example
+* ```typescript
+* import { forwardConsole } from "loggily/worker"
+* forwardConsole(postMessage, "km:worker:parse")
+* console.log("processing", { file: "test.md" })
+* ```
+*/
+function forwardConsole(postMessage, namespace) {
+	if (!originalConsole) originalConsole = { ...console };
+	for (const level of [
+		"log",
+		"debug",
+		"info",
+		"warn",
+		"error",
+		"trace"
+	]) console[level] = (...args) => {
+		try {
+			postMessage({
+				type: "console",
+				level,
+				namespace,
+				args: args.map((a) => typeof a === "function" ? `[Function: ${a.name || "anonymous"}]` : typeof a === "symbol" ? a.toString() : a instanceof Error ? {
+					name: a.name,
+					message: a.message,
+					stack: a.stack
+				} : a),
+				timestamp: Date.now()
+			});
+		} catch {
+			originalConsole?.[level](...args);
+		}
+	};
+}
+/**
+* Restore original console methods.
+* Call this if you need to disable console forwarding.
+*/
+function restoreConsole() {
+	if (originalConsole) {
+		Object.assign(console, originalConsole);
+		originalConsole = null;
+	}
+}
+/**
+* Create a pipeline stage that forwards events via postMessage.
+*
+* Events are plain JSON objects that survive structuredClone natively.
+* The stage consumes events (returns null) so nothing is output locally.
+* The main thread uses handleWorkerEvents() or createWorkerLogHandler()
+* to dispatch them through a local logger pipeline.
+*/
+function workerTransportStage(postMessage) {
+	return (event) => {
+		try {
+			postMessage(event);
+		} catch {
+			try {
+				postMessage(JSON.parse(JSON.stringify(event)));
+			} catch {}
+		}
+		return null;
+	};
+}
+/**
+* Create a logger for use in a worker thread.
+*
+* All log and span events are forwarded to the main thread via postMessage.
+* The main thread should use createWorkerLogHandler() to process these messages.
+*
+* @param postMessage - The worker's postMessage function
+* @param namespace - Logger namespace (e.g., "km:worker:parse")
+* @param props - Optional initial props
+*
+* @example
+* ```typescript
+* import { createWorkerLogger } from "loggily/worker"
+*
+* const log = createWorkerLogger(postMessage, "km:worker:parse")
+*
+* log.info?.("starting parse", { file: "test.md" })
+*
+* {
+*   using span = log.span?.("process")
+*   span.info?.("processing...")
+*   span.spanData.count = 100
+* }
+* // Span end event automatically sent to main thread
+* ```
+*/
+function createWorkerLogger(postMessage, namespace, props) {
+	const config = [{ level: "trace" }, workerTransportStage(postMessage)];
+	const logger = pipe(baseCreateLogger, withSpans())(namespace, config);
+	return props ? logger.child(props) : logger;
+}
+/**
+* Create a handler that dispatches worker events to a target logger.
+*
+* Use this when you have a specific logger to dispatch through.
+*
+* @param target - Logger or object with dispatch method
+* @returns Handler function to call with worker messages
+*/
+function handleWorkerEvents(target) {
+	return (msg) => {
+		if (typeof msg !== "object" || msg === null) return;
+		const event = msg;
+		if (event.kind === "log" || event.kind === "span") target.dispatch(msg);
+	};
+}
+/**
+* Create a zero-config handler for worker logger messages.
+*
+* Automatically creates loggers per-namespace. For console messages,
+* formats args and dispatches through a logger.
+*
+* @returns Handler function to call with any worker message
+*
+* @example
+* ```typescript
+* import { createWorkerLogHandler } from "loggily/worker"
+*
+* const handleLog = createWorkerLogHandler()
+* worker.onmessage = (e) => handleLog(e.data)
+* ```
+*/
+function createWorkerLogHandler() {
+	const loggers = /* @__PURE__ */ new Map();
+	function getLogger(namespace) {
+		let logger = loggers.get(namespace);
+		if (!logger) {
+			logger = createLogger(namespace);
+			loggers.set(namespace, logger);
+		}
+		return logger;
+	}
+	return (message) => {
+		if (isWorkerEvent(message)) getLogger(message.namespace).dispatch(message);
+		else if (isWorkerConsoleMessage(message)) {
+			const logger = getLogger(message.namespace || "worker");
+			const { message: msg, data } = formatConsoleArgs(message.args);
+			dispatchToLogger(logger, message.level, msg, data);
+		}
+	};
+}
+/** Safely stringify a value, handling circular refs and BigInt */
+function safeStringify(value) {
+	try {
+		return JSON.stringify(value);
+	} catch {
+		return String(value);
+	}
+}
+/** Format console args into a message string and optional data object */
+function formatConsoleArgs(args) {
+	const message = args.length === 0 ? "" : args.length === 1 && typeof args[0] === "string" ? args[0] : args.map((a) => typeof a === "string" ? a : safeStringify(a)).join(" ");
+	const lastArg = args[args.length - 1];
+	return {
+		message,
+		data: args.length > 1 && typeof lastArg === "object" && lastArg !== null && !Array.isArray(lastArg) ? lastArg : void 0
+	};
+}
+/** Dispatch a message to a logger at the given console level */
+function dispatchToLogger(logger, level, message, data) {
+	switch (level) {
+		case "trace":
+			logger.trace?.(message, data);
+			break;
+		case "debug":
+			logger.debug?.(message, data);
+			break;
+		case "info":
+		case "log":
+			logger.info?.(message, data);
+			break;
+		case "warn":
+			logger.warn?.(message, data);
+			break;
+		case "error":
+			logger.error?.(message, data);
+			break;
+	}
+}
+/**
+* Create a handler for worker console messages.
+*
+* Use this on the main thread to receive and output messages from workers.
+*
+* @param options - Handler options
+* @returns Handler function to call with worker messages
+*
+* @example
+* ```typescript
+* import { createWorkerConsoleHandler } from "loggily/worker"
+*
+* const handleConsole = createWorkerConsoleHandler({
+*   defaultNamespace: "km:worker:parse"
+* })
+*
+* worker.onmessage = (e) => {
+*   if (e.data.type === "console") {
+*     handleConsole(e.data)
+*   }
+* }
+* ```
+*/
+function createWorkerConsoleHandler(options = {}) {
+	const loggers = /* @__PURE__ */ new Map();
+	function getLogger(namespace) {
+		const ns = namespace || options.defaultNamespace || "worker";
+		let logger = loggers.get(ns);
+		if (!logger) {
+			logger = options.logger ? options.logger : createLogger(ns);
+			loggers.set(ns, logger);
+		}
+		return logger;
+	}
+	return (message) => {
+		const logger = getLogger(message.namespace);
+		const { message: msg, data } = formatConsoleArgs(message.args);
+		dispatchToLogger(logger, message.level, msg, data);
+	};
+}
+//#endregion
+export { createWorkerConsoleHandler, createWorkerLogHandler, createWorkerLogger, forwardConsole, handleWorkerEvents, isWorkerConsoleMessage, isWorkerEvent, isWorkerLogEvent, isWorkerMessage, isWorkerSpanEvent, restoreConsole, workerTransportStage };
+
+//# sourceMappingURL=worker.mjs.map

package/dist/worker.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"worker.mjs","names":[],"sources":["../src/worker.ts"],"sourcesContent":["/**\n * Worker Thread Logger/Console Forwarding\n *\n * Pipeline-based worker logging: worker loggers use a postMessage transport\n * so events flow through the main thread's pipeline for output.\n *\n * ## Structured Logger (Recommended)\n *\n * @example Worker side:\n * ```typescript\n * import { createWorkerLogger } from \"loggily/worker\"\n * const log = createWorkerLogger(postMessage, \"km:worker:parse\")\n *\n * log.info?.(\"processing\", { file: \"test.md\" })\n * {\n *   using span = log.span?.(\"parse\")\n *   // ... work ...\n *   span.spanData.lines = 100\n * }\n * ```\n *\n * @example Main thread side:\n * ```typescript\n * import { createWorkerLogHandler } from \"loggily/worker\"\n *\n * const handleLog = createWorkerLogHandler()\n * worker.onmessage = (e) => handleLog(e.data)\n * ```\n *\n * ## Console Forwarding (Simple)\n *\n * @example Worker side:\n * ```typescript\n * import { forwardConsole } from \"loggily/worker\"\n * forwardConsole(postMessage)\n *\n * console.log(\"message\")  // Forwarded to main thread\n * ```\n */\n\nimport { createLogger, baseCreateLogger, pipe, withSpans, type ConditionalLogger } from \"./core.js\"\nimport type { Event, LogEvent, SpanEvent, Stage, ConfigElement } from \"./pipeline.js\"\n\n// ============ Console Message Type ============\n\n/** Message sent from worker to main thread for console output */\nexport interface WorkerConsoleMessage {\n  type: \"console\"\n  level: \"log\" | \"debug\" | \"info\" | \"warn\" | \"error\" | \"trace\"\n  namespace?: string\n  args: unknown[]\n  timestamp: number\n}\n\n// ============ Type Guards ============\n\n/** Type guard for LogEvent (structured log from worker) */\nexport function isWorkerLogEvent(msg: unknown): msg is LogEvent {\n  return typeof msg === \"object\" && (msg as LogEvent)?.kind === \"log\"\n}\n\n/** Type guard for SpanEvent (span from worker) */\nexport function isWorkerSpanEvent(msg: unknown): msg is SpanEvent {\n  return typeof msg === \"object\" && (msg as SpanEvent)?.kind === \"span\"\n}\n\n/** Type guard for any pipeline Event (log or span) */\nexport function isWorkerEvent(msg: unknown): msg is Event {\n  return isWorkerLogEvent(msg) || isWorkerSpanEvent(msg)\n}\n\n/** Type guard for WorkerConsoleMessage */\nexport function isWorkerConsoleMessage(msg: unknown): msg is WorkerConsoleMessage {\n  return (\n    typeof msg === \"object\" &&\n    (msg as WorkerConsoleMessage)?.type === \"console\" &&\n    typeof (msg as WorkerConsoleMessage).level === \"string\" &&\n    Array.isArray((msg as WorkerConsoleMessage).args)\n  )\n}\n\n/** Type guard for any worker message (console or pipeline event) */\nexport function isWorkerMessage(msg: unknown): msg is WorkerConsoleMessage | Event {\n  return isWorkerConsoleMessage(msg) || isWorkerEvent(msg)\n}\n\n// ============ Worker Side: Console Forwarding ============\n\ntype PostMessageFn = (message: WorkerConsoleMessage) => void\n\n/** Store original console methods for restoration */\nlet originalConsole: typeof console | null = null\n\n/**\n * Forward console.* calls from worker to main thread via postMessage.\n *\n * Monkey-patches console methods. postMessage uses structuredClone,\n * which handles most values natively. If cloning fails (functions,\n * symbols), falls back to original console.\n *\n * @example\n * ```typescript\n * import { forwardConsole } from \"loggily/worker\"\n * forwardConsole(postMessage, \"km:worker:parse\")\n * console.log(\"processing\", { file: \"test.md\" })\n * ```\n */\nexport function forwardConsole(postMessage: PostMessageFn, namespace?: string): void {\n  if (!originalConsole) {\n    originalConsole = { ...console }\n  }\n\n  for (const level of [\"log\", \"debug\", \"info\", \"warn\", \"error\", \"trace\"] as const) {\n    console[level] = (...args: unknown[]) => {\n      try {\n        // Sanitize non-cloneable values before postMessage (structuredClone rejects them)\n        const safe = args.map((a) =>\n          typeof a === \"function\"\n            ? `[Function: ${a.name || \"anonymous\"}]`\n            : typeof a === \"symbol\"\n              ? a.toString()\n              : a instanceof Error\n                ? { name: a.name, message: a.message, stack: a.stack }\n                : a,\n        )\n        postMessage({ type: \"console\", level, namespace, args: safe, timestamp: Date.now() })\n      } catch {\n        originalConsole?.[level](...args)\n      }\n    }\n  }\n}\n\n/**\n * Restore original console methods.\n * Call this if you need to disable console forwarding.\n */\nexport function restoreConsole(): void {\n  if (originalConsole) {\n    Object.assign(console, originalConsole)\n    originalConsole = null\n  }\n}\n\n// ============ Worker Side: Pipeline Transport ============\n\n/**\n * Create a pipeline stage that forwards events via postMessage.\n *\n * Events are plain JSON objects that survive structuredClone natively.\n * The stage consumes events (returns null) so nothing is output locally.\n * The main thread uses handleWorkerEvents() or createWorkerLogHandler()\n * to dispatch them through a local logger pipeline.\n */\nexport function workerTransportStage(postMessage: (msg: unknown) => void): Stage {\n  return (event: Event): null => {\n    try {\n      postMessage(event)\n    } catch {\n      // If postMessage fails (non-cloneable), try with JSON round-trip\n      try {\n        postMessage(JSON.parse(JSON.stringify(event)))\n      } catch {\n        // Silently drop -- worker can't communicate\n      }\n    }\n    return null // Consume the event (no local output)\n  }\n}\n\n/**\n * Create a logger for use in a worker thread.\n *\n * All log and span events are forwarded to the main thread via postMessage.\n * The main thread should use createWorkerLogHandler() to process these messages.\n *\n * @param postMessage - The worker's postMessage function\n * @param namespace - Logger namespace (e.g., \"km:worker:parse\")\n * @param props - Optional initial props\n *\n * @example\n * ```typescript\n * import { createWorkerLogger } from \"loggily/worker\"\n *\n * const log = createWorkerLogger(postMessage, \"km:worker:parse\")\n *\n * log.info?.(\"starting parse\", { file: \"test.md\" })\n *\n * {\n *   using span = log.span?.(\"process\")\n *   span.info?.(\"processing...\")\n *   span.spanData.count = 100\n * }\n * // Span end event automatically sent to main thread\n * ```\n */\nexport function createWorkerLogger(\n  postMessage: (msg: unknown) => void,\n  namespace: string,\n  props?: Record<string, unknown>,\n): ConditionalLogger {\n  const transport = workerTransportStage(postMessage)\n  const config: ConfigElement[] = [{ level: \"trace\" as const }, transport]\n  const factory = pipe(baseCreateLogger, withSpans())\n  const logger = factory(namespace, config)\n  return props ? logger.child(props) : logger\n}\n\n// ============ Main Thread Side: Event Handling ============\n\n/**\n * Create a handler that dispatches worker events to a target logger.\n *\n * Use this when you have a specific logger to dispatch through.\n *\n * @param target - Logger or object with dispatch method\n * @returns Handler function to call with worker messages\n */\nexport function handleWorkerEvents(\n  target: ConditionalLogger | { dispatch(event: Event): void },\n): (msg: unknown) => void {\n  return (msg: unknown) => {\n    if (typeof msg !== \"object\" || msg === null) return\n    const event = msg as Record<string, unknown>\n    if (event.kind === \"log\" || event.kind === \"span\") {\n      target.dispatch(msg as Event)\n    }\n  }\n}\n\n/**\n * Create a zero-config handler for worker logger messages.\n *\n * Automatically creates loggers per-namespace. For console messages,\n * formats args and dispatches through a logger.\n *\n * @returns Handler function to call with any worker message\n *\n * @example\n * ```typescript\n * import { createWorkerLogHandler } from \"loggily/worker\"\n *\n * const handleLog = createWorkerLogHandler()\n * worker.onmessage = (e) => handleLog(e.data)\n * ```\n */\nexport function createWorkerLogHandler(): (message: unknown) => void {\n  const loggers = new Map<string, ConditionalLogger>()\n\n  function getLogger(namespace: string): ConditionalLogger {\n    let logger = loggers.get(namespace)\n    if (!logger) {\n      logger = createLogger(namespace)\n      loggers.set(namespace, logger)\n    }\n    return logger\n  }\n\n  return (message: unknown) => {\n    if (isWorkerEvent(message)) {\n      const logger = getLogger(message.namespace)\n      logger.dispatch(message)\n    } else if (isWorkerConsoleMessage(message)) {\n      const logger = getLogger(message.namespace || \"worker\")\n      const { message: msg, data } = formatConsoleArgs(message.args)\n      dispatchToLogger(logger, message.level, msg, data)\n    }\n  }\n}\n\n// ============ Main Thread Side: Console Handler ============\n\nexport interface WorkerConsoleHandlerOptions {\n  /** Default namespace if message doesn't include one */\n  defaultNamespace?: string\n  /** Custom logger to use (defaults to creating one with the namespace) */\n  logger?: { name: string; dispatch(event: Event): void }\n}\n\n/** Safely stringify a value, handling circular refs and BigInt */\nfunction safeStringify(value: unknown): string {\n  try {\n    return JSON.stringify(value)\n  } catch {\n    return String(value)\n  }\n}\n\n/** Format console args into a message string and optional data object */\nfunction formatConsoleArgs(args: unknown[]): { message: string; data: Record<string, unknown> | undefined } {\n  const message =\n    args.length === 0\n      ? \"\"\n      : args.length === 1 && typeof args[0] === \"string\"\n        ? args[0]\n        : args.map((a) => (typeof a === \"string\" ? a : safeStringify(a))).join(\" \")\n\n  const lastArg = args[args.length - 1]\n  const data =\n    args.length > 1 && typeof lastArg === \"object\" && lastArg !== null && !Array.isArray(lastArg)\n      ? (lastArg as Record<string, unknown>)\n      : undefined\n\n  return { message, data }\n}\n\n/** Dispatch a message to a logger at the given console level */\nfunction dispatchToLogger(\n  logger: ConditionalLogger,\n  level: \"log\" | \"debug\" | \"info\" | \"warn\" | \"error\" | \"trace\",\n  message: string,\n  data?: Record<string, unknown>,\n): void {\n  switch (level) {\n    case \"trace\":\n      logger.trace?.(message, data)\n      break\n    case \"debug\":\n      logger.debug?.(message, data)\n      break\n    case \"info\":\n    case \"log\":\n      logger.info?.(message, data)\n      break\n    case \"warn\":\n      logger.warn?.(message, data)\n      break\n    case \"error\":\n      logger.error?.(message, data)\n      break\n  }\n}\n\n/**\n * Create a handler for worker console messages.\n *\n * Use this on the main thread to receive and output messages from workers.\n *\n * @param options - Handler options\n * @returns Handler function to call with worker messages\n *\n * @example\n * ```typescript\n * import { createWorkerConsoleHandler } from \"loggily/worker\"\n *\n * const handleConsole = createWorkerConsoleHandler({\n *   defaultNamespace: \"km:worker:parse\"\n * })\n *\n * worker.onmessage = (e) => {\n *   if (e.data.type === \"console\") {\n *     handleConsole(e.data)\n *   }\n * }\n * ```\n */\nexport function createWorkerConsoleHandler(\n  options: WorkerConsoleHandlerOptions = {},\n): (message: WorkerConsoleMessage) => void {\n  const loggers = new Map<string, ConditionalLogger>()\n\n  function getLogger(namespace?: string): ConditionalLogger {\n    const ns = namespace || options.defaultNamespace || \"worker\"\n\n    let logger = loggers.get(ns)\n    if (!logger) {\n      logger = options.logger ? (options.logger as ConditionalLogger) : createLogger(ns)\n      loggers.set(ns, logger)\n    }\n    return logger\n  }\n\n  return (message: WorkerConsoleMessage) => {\n    const logger = getLogger(message.namespace)\n    const { message: msg, data } = formatConsoleArgs(message.args)\n    dispatchToLogger(logger, message.level, msg, data)\n  }\n}\n"],"mappings":"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"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "loggily",
-  "version": "0.6.2",
+  "version": "0.8.0",
   "description": "Debugs, logs, and spans — one API. Disabled logs skip argument evaluation entirely via optional chaining. ~3KB, zero dependencies.",
   "keywords": [
     "browser",
@@ -19,7 +19,7 @@
     "typescript",
     "zero-dependency"
   ],
-  "homepage": "https://beorn.codes/loggily/",
+  "homepage": "https://loggily.dev/",
   "bugs": {
     "url": "https://github.com/beorn/loggily/issues"
   },
@@ -29,33 +29,69 @@
     "type": "git",
     "url": "https://github.com/beorn/loggily.git"
   },
-  "type": "module",
   "files": [
     "dist"
   ],
+  "type": "module",
   "exports": {
     ".": {
+      "browser": {
+        "types": "./dist/index.browser.d.mts",
+        "import": "./dist/index.browser.mjs"
+      },
       "types": "./dist/index.d.mts",
       "import": "./dist/index.mjs"
+    },
+    "./worker": {
+      "types": "./dist/worker.d.mts",
+      "import": "./dist/worker.mjs"
+    },
+    "./metrics": {
+      "types": "./dist/metrics.d.mts",
+      "import": "./dist/metrics.mjs"
+    },
+    "./context": {
+      "types": "./dist/context.d.mts",
+      "import": "./dist/context.mjs"
+    },
+    "./otel": {
+      "types": "./dist/otel.d.mts",
+      "import": "./dist/otel.mjs"
     }
   },
   "publishConfig": {
     "access": "public"
   },
-  "tsdown": {
-    "entry": "src/index.ts",
-    "format": "esm",
-    "dts": true,
-    "clean": true
-  },
   "devDependencies": {
     "@types/node": "^25.5.0",
+    "mitata": "^1.0.34",
     "tsdown": "^0.21.7",
     "vitepress": "^1.6.4",
     "vitepress-enrich": "^0.4.0",
     "vitepress-plugin-llms": "^1.12.0",
     "vitest": "^4.1.1"
   },
+  "peerDependencies": {
+    "@opentelemetry/api": ">=1.0.0"
+  },
+  "peerDependenciesMeta": {
+    "@opentelemetry/api": {
+      "optional": true
+    }
+  },
+  "tsdown": {
+    "clean": true,
+    "dts": true,
+    "entry": [
+      "src/index.ts",
+      "src/index.browser.ts",
+      "src/worker.ts",
+      "src/metrics.ts",
+      "src/context.ts",
+      "src/otel.ts"
+    ],
+    "format": "esm"
+  },
   "engines": {
     "bun": ">=1.0",
     "node": ">=23.6.0"

package/dist/index.d.mts.map

@@ -1 +0,0 @@
-{"version":3,"file":"index.d.mts","names":[],"sources":["../src/core.ts","../src/file-writer.ts","../src/tracing.ts"],"mappings":"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"}