loggily 0.8.0 → 0.10.1

package/dist/worker.mjs.map

@@ -1 +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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"}
+{"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 {\n  createLogger,\n  baseCreateLogger,\n  pipe,\n  withSpans,\n  type ConditionalLogger,\n} from \"./core.js\"\nimport type {\n  Event,\n  LogEvent,\n  SpanEvent,\n  Stage,\n  ConfigElement,\n} 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(\n  msg: unknown,\n): 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(\n  msg: unknown,\n): 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(\n  postMessage: PostMessageFn,\n  namespace?: string,\n): void {\n  if (!originalConsole) {\n    originalConsole = { ...console }\n  }\n\n  for (const level of [\n    \"log\",\n    \"debug\",\n    \"info\",\n    \"warn\",\n    \"error\",\n    \"trace\",\n  ] 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({\n          type: \"console\",\n          level,\n          namespace,\n          args: safe,\n          timestamp: Date.now(),\n        })\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(\n  postMessage: (msg: unknown) => void,\n): 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[]): {\n  message: string\n  data: Record<string, unknown> | undefined\n} {\n  const message =\n    args.length === 0\n      ? \"\"\n      : args.length === 1 && typeof args[0] === \"string\"\n        ? args[0]\n        : args\n            .map((a) => (typeof a === \"string\" ? a : safeStringify(a)))\n            .join(\" \")\n\n  const lastArg = args[args.length - 1]\n  const data =\n    args.length > 1 &&\n    typeof lastArg === \"object\" &&\n    lastArg !== null &&\n    !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\n        ? (options.logger as ConditionalLogger)\n        : 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.8.0",
+  "version": "0.10.1",
   "description": "Debugs, logs, and spans — one API. Disabled logs skip argument evaluation entirely via optional chaining. ~3KB, zero dependencies.",
   "keywords": [
     "browser",
@@ -65,11 +65,13 @@
   "devDependencies": {
     "@types/node": "^25.5.0",
     "mitata": "^1.0.34",
+    "oxfmt": "0.38.0",
     "tsdown": "^0.21.7",
     "vitepress": "^1.6.4",
     "vitepress-enrich": "^0.4.0",
     "vitepress-plugin-llms": "^1.12.0",
-    "vitest": "^4.1.1"
+    "vitest": "^4.1.1",
+    "typescript": "^5.9.0"
   },
   "peerDependencies": {
     "@opentelemetry/api": ">=1.0.0"
@@ -102,6 +104,8 @@
     "test": "bunx --bun vitest run",
     "docs:dev": "vitepress dev docs",
     "docs:build": "vitepress build docs",
-    "docs:preview": "vitepress preview docs"
+    "docs:preview": "vitepress preview docs",
+    "fmt": "oxfmt .",
+    "fmt:check": "oxfmt --check ."
   }
 }

package/dist/core-B3pox577.mjs.map

@@ -1 +0,0 @@
-{"version":3,"file":"core-B3pox577.mjs","names":["_process","pc","_withMetrics","_createMetricsCollector"],"sources":["../src/colors.ts","../src/file-writer.ts","../src/tracing.ts","../src/pipeline.ts","../src/core.ts"],"sourcesContent":["/**\n * Vendored ANSI color functions — replaces picocolors dependency.\n * Supports NO_COLOR, FORCE_COLOR, and TTY detection.\n */\n\nconst _process = typeof process !== \"undefined\" ? process : undefined\n\nconst enabled =\n  _process?.env?.[\"FORCE_COLOR\"] !== undefined && _process?.env?.[\"FORCE_COLOR\"] !== \"0\"\n    ? true\n    : _process?.env?.[\"NO_COLOR\"] !== undefined\n      ? false\n      : (_process?.stdout?.isTTY ?? false)\n\nfunction wrap(open: string, close: string): (str: string) => string {\n  if (!enabled) return (str) => str\n  return (str) => open + str + close\n}\n\nexport const colors = {\n  dim: wrap(\"\\x1b[2m\", \"\\x1b[22m\"),\n  blue: wrap(\"\\x1b[34m\", \"\\x1b[39m\"),\n  yellow: wrap(\"\\x1b[33m\", \"\\x1b[39m\"),\n  red: wrap(\"\\x1b[31m\", \"\\x1b[39m\"),\n  magenta: wrap(\"\\x1b[35m\", \"\\x1b[39m\"),\n  cyan: wrap(\"\\x1b[36m\", \"\\x1b[39m\"),\n}\n","/**\n * File writer for loggily — Node.js/Bun only.\n *\n * Separated from core logger to allow tree-shaking in browser bundles.\n * Uses dynamic import(\"node:fs\") to avoid static dependency on Node APIs.\n */\n\nimport { openSync, writeSync, closeSync } from \"node:fs\"\n\n/** Options for creating an async buffered file writer */\nexport interface FileWriterOptions {\n  /** Buffer size threshold in bytes before flushing (default: 4096) */\n  bufferSize?: number\n  /** Flush interval in milliseconds (default: 100) */\n  flushInterval?: number\n}\n\n/** An async buffered file writer with automatic flushing */\nexport interface FileWriter {\n  /** Write a line to the buffer (appends newline) */\n  write(line: string): void\n  /** Flush the buffer immediately */\n  flush(): void\n  /** Close the writer and flush remaining buffer */\n  close(): void\n}\n\n/**\n * Create an async buffered file writer for log output.\n * Buffers writes and flushes on size threshold or interval.\n * Registers a process.on('exit') handler to flush remaining buffer.\n *\n * **Node.js/Bun only** — not available in browser environments.\n *\n * @param filePath - Path to the log file (opened in append mode)\n * @param options - Buffer size and flush interval configuration\n * @returns FileWriter with write, flush, and close methods\n *\n * @example\n * const writer = createFileWriter('/tmp/app.log')\n * const unsubscribe = addWriter((formatted) => writer.write(formatted))\n *\n * // On shutdown:\n * unsubscribe()\n * writer.close()\n */\nexport function createFileWriter(filePath: string, options: FileWriterOptions = {}): FileWriter {\n  const bufferSize = options.bufferSize ?? 4096\n  const flushInterval = options.flushInterval ?? 100\n\n  let buffer = \"\"\n  let fd: number | null = null\n  let timer: ReturnType<typeof setInterval> | null = null\n  let closed = false\n\n  // Open file in append mode\n  fd = openSync(filePath, \"a\")\n\n  /** Flush buffer contents to disk synchronously */\n  function flush(): void {\n    if (buffer.length === 0 || fd === null) return\n    const data = buffer\n    writeSync(fd, data)\n    buffer = \"\"\n  }\n\n  // Set up periodic flush\n  timer = setInterval(flush, flushInterval)\n  // Don't let the timer keep the process alive\n  if (timer && typeof timer === \"object\" && \"unref\" in timer) {\n    ;(timer as { unref(): void }).unref()\n  }\n\n  // Flush on process exit to avoid data loss\n  const exitHandler = (): void => flush()\n  process.on(\"exit\", exitHandler)\n\n  return {\n    write(line: string): void {\n      if (closed) return\n      buffer += line + \"\\n\"\n      if (buffer.length >= bufferSize) {\n        flush()\n      }\n    },\n\n    flush,\n\n    close(): void {\n      if (closed) return\n      closed = true\n      if (timer !== null) {\n        clearInterval(timer)\n        timer = null\n      }\n      try {\n        flush()\n      } catch {\n        // Swallow flush errors during close — data loss is unavoidable\n        // at this point, but we must still release the fd and exit handler.\n      } finally {\n        if (fd !== null) {\n          closeSync(fd)\n          fd = null\n        }\n        process.removeListener(\"exit\", exitHandler)\n      }\n    },\n  }\n}\n","/**\n * Distributed tracing utilities for loggily.\n *\n * Provides W3C-compatible trace/span ID generation, traceparent header formatting,\n * and head-based sampling. All features are opt-in and don't break the existing API.\n */\n\nimport type { SpanData } from \"./core.js\"\n\n// ============ ID Format ============\n\n/** Supported ID formats */\nexport type IdFormat = \"simple\" | \"w3c\"\n\nlet currentIdFormat: IdFormat = \"simple\"\n\n/**\n * Set the ID format for new spans and traces.\n * - \"simple\": sp_1, sp_2, tr_1, tr_2 (default, lightweight)\n * - \"w3c\": 32-char hex trace ID, 16-char hex span ID (W3C Trace Context compatible)\n *\n * @deprecated Use the `TRACE_ID_FORMAT` env var or `{ idFormat: \"w3c\" }` in the config array instead.\n */\nexport function setIdFormat(format: IdFormat): void {\n  currentIdFormat = format\n}\n\n/**\n * Get the current ID format.\n *\n * @deprecated Use the `TRACE_ID_FORMAT` env var or `{ idFormat: \"w3c\" }` in the config array instead.\n */\nexport function getIdFormat(): IdFormat {\n  return currentIdFormat\n}\n\n// Simple format counters (used by core.ts via the generator functions)\nlet simpleSpanCounter = 0\nlet simpleTraceCounter = 0\n\n/** Generate a hex string of the given byte length using crypto.randomUUID */\nfunction randomHex(bytes: number): string {\n  // crypto.randomUUID() gives us 32 hex chars (128 bits) after removing dashes\n  // For 16 bytes (32 hex chars) we use one UUID, for 8 bytes (16 hex chars) we take a slice\n  const uuid = crypto.randomUUID().replace(/-/g, \"\")\n  return uuid.slice(0, bytes * 2)\n}\n\n/** Generate a span ID according to the current format */\nexport function generateSpanId(): string {\n  if (currentIdFormat === \"w3c\") {\n    return randomHex(8) // 16-char hex\n  }\n  return `sp_${(++simpleSpanCounter).toString(36)}`\n}\n\n/** Generate a trace ID according to the current format */\nexport function generateTraceId(): string {\n  if (currentIdFormat === \"w3c\") {\n    return randomHex(16) // 32-char hex\n  }\n  return `tr_${(++simpleTraceCounter).toString(36)}`\n}\n\n/** Reset ID counters (for testing) */\nexport function resetIdCounters(): void {\n  simpleSpanCounter = 0\n  simpleTraceCounter = 0\n}\n\n// ============ W3C Traceparent ============\n\n/** Options for traceparent header formatting */\nexport interface TraceparentOptions {\n  /** Whether this span is sampled. Defaults to true for backwards compatibility. */\n  sampled?: boolean\n}\n\n/**\n * Format a W3C traceparent header from span data.\n *\n * Format: `{version}-{trace-id}-{span-id}-{trace-flags}`\n * - version: \"00\" (current W3C spec version)\n * - trace-id: 32 hex chars (128 bits)\n * - span-id: 16 hex chars (64 bits)\n * - trace-flags: \"01\" (sampled) or \"00\" (not sampled)\n *\n * Works with both simple and W3C ID formats. Simple IDs are zero-padded to spec length.\n *\n * @param spanData - Span data with id and traceId\n * @param options - Optional settings (sampled flag). Defaults to sampled=true.\n * @returns W3C traceparent header string\n *\n * @example\n * ```typescript\n * const span = log.span(\"http-request\")\n * const header = traceparent(span.spanData)\n * // → \"00-a1b2c3d4e5f6a7b8c9d0e1f2a3b4c5d6-1a2b3c4d5e6f7a8b-01\"\n * fetch(url, { headers: { traceparent: header } })\n * ```\n */\nexport function traceparent(spanData: SpanData, options?: TraceparentOptions): string {\n  const traceId = padHex(spanData.traceId, 32)\n  const spanId = padHex(spanData.id, 16)\n  const flags = (options?.sampled ?? true) ? \"01\" : \"00\"\n  return `00-${traceId}-${spanId}-${flags}`\n}\n\n/** Pad or hash an ID to the specified hex length */\nfunction padHex(id: string, length: number): string {\n  // If it's already the right length and looks like hex, use as-is\n  if (id.length === length && /^[0-9a-f]+$/.test(id)) {\n    return id\n  }\n\n  // For simple IDs (sp_1, tr_1), create a deterministic hex representation\n  // by encoding the string as hex bytes, zero-padded to the target length\n  let hex = \"\"\n  for (let i = 0; i < id.length; i++) {\n    hex += id.charCodeAt(i).toString(16).padStart(2, \"0\")\n  }\n  // Pad or truncate to target length\n  return hex.padStart(length, \"0\").slice(-length)\n}\n\n// ============ Sampling ============\n\nlet sampleRate = 1.0\n\n/**\n * Set the head-based sampling rate for new traces.\n * Applied at trace creation — all spans within a sampled trace are kept.\n *\n * @deprecated Use the `TRACE_SAMPLE_RATE` env var or `{ sampleRate: 0.1 }` in the config array instead.\n * @param rate - Sampling rate from 0.0 (sample nothing) to 1.0 (sample everything, default)\n */\nexport function setSampleRate(rate: number): void {\n  if (rate < 0 || rate > 1) {\n    throw new Error(`Sample rate must be between 0.0 and 1.0, got ${rate}`)\n  }\n  sampleRate = rate\n}\n\n/**\n * Get the current sampling rate.\n *\n * @deprecated Use the `TRACE_SAMPLE_RATE` env var or `{ sampleRate: 0.1 }` in the config array instead.\n */\nexport function getSampleRate(): number {\n  return sampleRate\n}\n\n/**\n * Determine whether a new trace should be sampled.\n * Called at trace creation time (head-based sampling).\n */\nexport function shouldSample(): boolean {\n  if (sampleRate >= 1.0) return true\n  if (sampleRate <= 0.0) return false\n  return Math.random() < sampleRate\n}\n","import { colors as pc } from \"./colors.js\"\nimport { createFileWriter } from \"./file-writer.js\"\nimport { setIdFormat, setSampleRate } from \"./tracing.js\"\nimport type { IdFormat } from \"./tracing.js\"\n\n// ============ Types ============\n\nexport type OutputLogLevel = \"trace\" | \"debug\" | \"info\" | \"warn\" | \"error\"\nexport type LogLevel = OutputLogLevel | \"silent\"\nexport type LogFormat = \"console\" | \"json\"\n\nexport type LogEvent = {\n  kind: \"log\"\n  time: number\n  namespace: string\n  level: OutputLogLevel\n  message: string\n  props?: Record<string, unknown>\n}\n\nexport type SpanEvent = {\n  kind: \"span\"\n  time: number\n  namespace: string\n  name: string\n  duration: number\n  props?: Record<string, unknown>\n  spanId: string\n  traceId: string\n  parentId: string | null\n}\n\nexport type Event = LogEvent | SpanEvent\nexport type Stage = (event: Event) => Event | null | void\n\n// ============ Level Priority ============\n\nexport const LOG_LEVEL_PRIORITY: Record<LogLevel, number> = {\n  trace: 0,\n  debug: 1,\n  info: 2,\n  warn: 3,\n  error: 4,\n  silent: 5,\n}\n\n// ============ Runtime Detection ============\n\nconst _process = typeof process !== \"undefined\" ? process : undefined\n\nfunction getEnv(key: string): string | undefined {\n  return _process?.env?.[key]\n}\n\nfunction writeStderr(text: string): void {\n  if (_process?.stderr?.write) {\n    _process.stderr.write(text + \"\\n\")\n  } else {\n    console.error(text)\n  }\n}\n\n// ============ Formatting ============\n\n/** Serialize Error.cause chains up to a max depth */\nexport function serializeCause(cause: unknown, maxDepth: number = 3): unknown {\n  if (maxDepth <= 0 || cause === undefined || cause === null) return undefined\n  if (cause instanceof Error) {\n    const result: Record<string, unknown> = {\n      name: cause.name,\n      message: cause.message,\n      stack: cause.stack,\n    }\n    if ((cause as { code?: string }).code) result.code = (cause as { code?: string }).code\n    if (cause.cause !== undefined) {\n      result.cause = serializeCause(cause.cause, maxDepth - 1)\n    }\n    return result\n  }\n  // Non-Error cause (spec allows any value)\n  return cause\n}\n\nexport function safeStringify(value: unknown): string {\n  const seen = new WeakSet()\n  return JSON.stringify(value, (_key, val) => {\n    if (typeof val === \"bigint\") return val.toString()\n    if (typeof val === \"symbol\") return val.toString()\n    if (val instanceof Error) {\n      const result: Record<string, unknown> = { message: val.message, stack: val.stack, name: val.name }\n      if ((val as { code?: string }).code) result.code = (val as { code?: string }).code\n      if (val.cause !== undefined) result.cause = serializeCause(val.cause)\n      return result\n    }\n    if (typeof val === \"object\" && val !== null) {\n      if (seen.has(val)) return \"[Circular]\"\n      seen.add(val)\n    }\n    return val\n  })\n}\n\nexport function formatConsoleEvent(event: Event): string {\n  const time = pc.dim(new Date(event.time).toISOString().split(\"T\")[1]?.split(\".\")[0] || \"\")\n  const ns = pc.cyan(event.namespace)\n\n  if (event.kind === \"span\") {\n    const message = `(${event.duration}ms)`\n    let output = `${time} ${pc.magenta(\"SPAN\")} ${ns} ${message}`\n    if (event.props && Object.keys(event.props).length > 0) {\n      output += ` ${pc.dim(safeStringify(event.props))}`\n    }\n    return output\n  }\n\n  let levelStr: string\n  switch (event.level) {\n    case \"trace\":\n      levelStr = pc.dim(\"TRACE\")\n      break\n    case \"debug\":\n      levelStr = pc.dim(\"DEBUG\")\n      break\n    case \"info\":\n      levelStr = pc.blue(\"INFO\")\n      break\n    case \"warn\":\n      levelStr = pc.yellow(\"WARN\")\n      break\n    case \"error\":\n      levelStr = pc.red(\"ERROR\")\n      break\n  }\n\n  let output = `${time} ${levelStr} ${ns} ${event.message}`\n  if (event.props && Object.keys(event.props).length > 0) {\n    output += ` ${pc.dim(safeStringify(event.props))}`\n  }\n  return output\n}\n\nexport function formatJSONEvent(event: Event): string {\n  if (event.kind === \"span\") {\n    return safeStringify({\n      time: new Date(event.time).toISOString(),\n      level: \"span\",\n      name: event.namespace,\n      msg: `(${event.duration}ms)`,\n      duration: event.duration,\n      span_id: event.spanId,\n      trace_id: event.traceId,\n      parent_id: event.parentId,\n      ...event.props,\n    })\n  }\n\n  return safeStringify({\n    time: new Date(event.time).toISOString(),\n    level: event.level,\n    name: event.namespace,\n    msg: event.message,\n    ...event.props,\n  })\n}\n\n// ============ Namespace Filter ============\n\nexport type NsFilter = (namespace: string) => boolean\n\nfunction matchesPattern(namespace: string, pattern: string): boolean {\n  if (pattern === \"*\") return true\n  if (pattern.endsWith(\":*\")) {\n    const prefix = pattern.slice(0, -2)\n    return namespace === prefix || namespace.startsWith(prefix + \":\")\n  }\n  return namespace === pattern || namespace.startsWith(pattern + \":\")\n}\n\nexport function parseNsFilter(ns: string | string[]): NsFilter {\n  const patterns = typeof ns === \"string\" ? ns.split(\",\").map((s) => s.trim()) : ns\n  const includes: string[] = []\n  const excludes: string[] = []\n\n  for (const p of patterns) {\n    if (p.startsWith(\"-\")) {\n      excludes.push(p.slice(1))\n    } else {\n      includes.push(p)\n    }\n  }\n\n  return (namespace: string): boolean => {\n    for (const exc of excludes) {\n      if (matchesPattern(namespace, exc)) return false\n    }\n    if (includes.length > 0) {\n      for (const inc of includes) {\n        if (matchesPattern(namespace, inc)) return true\n      }\n      return false\n    }\n    return true\n  }\n}\n\n// ============ Console Output ============\n\n/**\n * Write formatted text to console using the appropriate log level.\n *\n * IMPORTANT: We use Function.bind() to preserve caller source locations in\n * browser DevTools. When you click a log line in DevTools, it shows where\n * YOUR code called log.info?.(), not where pipeline.ts called console.info().\n * DO NOT replace bind() with direct console.info(text) calls — it breaks\n * source location tracking in browsers.\n */\nexport function writeToConsole(text: string, event: Event): void {\n  if (event.kind === \"span\") {\n    writeStderr(text)\n    return\n  }\n  // bind() preserves the call site in browser DevTools source maps.\n  // The bound function is immediately invoked — bind() just ensures the\n  // DevTools stack trace points to the user's code, not this file.\n  switch (event.level) {\n    case \"trace\":\n    case \"debug\":\n      Function.prototype.bind.call(console.debug, console, text)()\n      break\n    case \"info\":\n      Function.prototype.bind.call(console.info, console, text)()\n      break\n    case \"warn\":\n      Function.prototype.bind.call(console.warn, console, text)()\n      break\n    case \"error\":\n      Function.prototype.bind.call(console.error, console, text)()\n      break\n  }\n}\n\n// ============ Sinks ============\n\nfunction createConsoleSink(format: LogFormat): (event: Event) => void {\n  const formatter = format === \"json\" ? formatJSONEvent : formatConsoleEvent\n  return (event: Event) => writeToConsole(formatter(event), event)\n}\n\nfunction createFileSink(path: string, format: LogFormat): { write: (event: Event) => void; dispose: () => void } {\n  const writer = createFileWriter(path)\n  const formatter = format === \"json\" ? formatJSONEvent : formatConsoleEvent\n  return {\n    write: (event: Event) => writer.write(formatter(event)),\n    dispose: () => writer.close(),\n  }\n}\n\nfunction isNodeStream(obj: unknown): boolean {\n  return typeof obj === \"object\" && obj !== null && (\"_write\" in obj || \"writable\" in obj || \"fd\" in obj)\n}\n\nfunction createWritableSink(writable: Writable, format: LogFormat): (event: Event) => void {\n  // Node.js streams (process.stderr, fs streams) default to string mode\n  // Plain { write } objects default to object mode (raw Events)\n  const useObjectMode = writable.objectMode ?? !isNodeStream(writable)\n  if (!useObjectMode) {\n    const formatter = format === \"json\" ? formatJSONEvent : formatConsoleEvent\n    return (event: Event) => writable.write(formatter(event) + \"\\n\")\n  }\n  return (event: Event) => writable.write(event)\n}\n\n// ============ Pipeline ============\n\nexport interface Pipeline {\n  dispatch: (event: Event) => void\n  level: LogLevel\n  dispose: () => void\n}\n\ninterface Output {\n  levelPriority: number\n  nsFilter: NsFilter | null\n  write: (event: Event) => void\n  dispose?: () => void\n}\n\n// ============ Discrimination ============\n\nconst VALID_CONFIG_KEYS = new Set([\"level\", \"ns\", \"format\", \"spans\", \"metrics\", \"idFormat\", \"sampleRate\"])\nconst SINK_KEYS = new Set([\"file\", \"otel\"])\n\nfunction isPojo(obj: unknown): obj is Record<string, unknown> {\n  if (typeof obj !== \"object\" || obj === null) return false\n  const proto = Object.getPrototypeOf(obj)\n  return proto === Object.prototype || proto === null\n}\n\nfunction isWritable(obj: unknown): obj is Writable {\n  return (\n    typeof obj === \"object\" &&\n    obj !== null &&\n    \"write\" in obj &&\n    typeof (obj as Record<string, unknown>).write === \"function\"\n  )\n}\n\nfunction isValidLogLevel(val: unknown): val is LogLevel {\n  return typeof val === \"string\" && val in LOG_LEVEL_PRIORITY\n}\n\n// ============ Config Types ============\n\n/** A writable sink — any object with a write method. Receives raw Event objects by default. */\nexport interface Writable {\n  // eslint-disable-next-line @typescript-eslint/no-explicit-any\n  write: (data: any) => any\n  /** Set to false to receive formatted strings instead of raw Event objects (default: true) */\n  objectMode?: boolean\n}\n\n/** Config keys that set scope for subsequent siblings */\nexport interface ConfigObject {\n  level?: LogLevel\n  ns?: string | string[]\n  format?: LogFormat\n  spans?: boolean\n  /** Enable per-logger metrics collection. Creates a MetricsCollector accessible via `log.metrics`. */\n  metrics?: boolean\n  /** ID format for trace/span IDs: \"simple\" (default) or \"w3c\" (W3C Trace Context) */\n  idFormat?: \"simple\" | \"w3c\"\n  /** Head-based sampling rate for new traces: 0.0 (none) to 1.0 (all, default) */\n  sampleRate?: number\n}\n\n/** File output descriptor */\nexport interface FileDescriptor extends ConfigObject {\n  file: string\n}\n\n/** OTEL output descriptor (Phase 4) */\nexport interface OtelDescriptor extends ConfigObject {\n  otel: Record<string, unknown>\n}\n\n/** A single element in a createLogger config array */\nexport type ConfigElement =\n  | ConfigObject\n  | FileDescriptor\n  | OtelDescriptor\n  | Console\n  | \"console\"\n  | \"stderr\"\n  | Stage\n  | Writable\n  | ConfigElement[]\n\n// ============ Build Pipeline ============\n\ninterface ScopeConfig {\n  level: LogLevel\n  ns: NsFilter | null\n  format: LogFormat\n}\n\nexport function buildPipeline(elements: ConfigElement[], parentConfig?: Partial<ScopeConfig>): Pipeline {\n  const config: ScopeConfig = {\n    level: parentConfig?.level ?? readEnvLevel(),\n    ns: parentConfig?.ns ?? readEnvNs(),\n    format: parentConfig?.format ?? readEnvFormat(),\n  }\n  // Spans always pass through explicit pipelines. { spans: false } to opt out.\n  // The defaultPipeline handles TRACE env var gating separately.\n  let spansEnabled = true\n\n  const stages: Stage[] = []\n  const outputs: Output[] = []\n  const branches: Pipeline[] = []\n  const disposables: (() => void)[] = []\n\n  for (const element of elements) {\n    // 1. Array → branch\n    if (Array.isArray(element)) {\n      const branch = buildPipeline(element as ConfigElement[], { ...config })\n      branches.push(branch)\n      disposables.push(() => branch.dispose())\n      continue\n    }\n\n    // 2. console (literal or \"console\" string) → console sink (check before function — console is function-like)\n    if (element === console || element === \"console\") {\n      outputs.push({\n        levelPriority: LOG_LEVEL_PRIORITY[config.level],\n        nsFilter: config.ns,\n        write: createConsoleSink(config.format),\n      })\n      continue\n    }\n\n    // 3. Function → stage\n    if (typeof element === \"function\") {\n      stages.push(element as Stage)\n      continue\n    }\n\n    // 4. Writable ({ write }) → writable sink (checked BEFORE POJO so { write: fn } works)\n    if (isWritable(element)) {\n      outputs.push({\n        levelPriority: LOG_LEVEL_PRIORITY[config.level],\n        nsFilter: config.ns,\n        write: createWritableSink(element, config.format),\n      })\n      continue\n    }\n\n    // 5. POJO → scope config or output descriptor\n    if (isPojo(element)) {\n      const obj = element\n      const keys = Object.keys(obj)\n\n      const hasSinkKey = keys.some((k) => SINK_KEYS.has(k))\n      const hasUnknownKey = keys.some((k) => !VALID_CONFIG_KEYS.has(k) && !SINK_KEYS.has(k))\n\n      if (hasUnknownKey) {\n        const unknown = keys.find((k) => !VALID_CONFIG_KEYS.has(k) && !SINK_KEYS.has(k))\n        throw new Error(\n          `loggily: unknown config key \"${unknown}\" in config object. Valid keys: ${[...VALID_CONFIG_KEYS, ...SINK_KEYS].join(\", \")}`,\n        )\n      }\n\n      if (hasSinkKey) {\n        if (typeof obj.file === \"string\") {\n          const outputLevel = isValidLogLevel(obj.level) ? obj.level : config.level\n          const outputNs = obj.ns ? parseNsFilter(obj.ns as string | string[]) : config.ns\n          const outputFormat = (obj.format as LogFormat) ?? config.format\n          const sink = createFileSink(obj.file, outputFormat)\n          disposables.push(sink.dispose)\n          outputs.push({\n            levelPriority: LOG_LEVEL_PRIORITY[outputLevel],\n            nsFilter: outputNs,\n            write: sink.write,\n            dispose: sink.dispose,\n          })\n        }\n        if (obj.otel !== undefined) {\n          throw new Error(\"loggily: OTEL sink is not yet implemented. See loggily/otel for the planned bridge.\")\n        }\n        continue\n      }\n\n      // Scope config — update inherited config\n      if (isValidLogLevel(obj.level)) config.level = obj.level\n      if (obj.ns !== undefined) config.ns = parseNsFilter(obj.ns as string | string[])\n      if (obj.format === \"console\" || obj.format === \"json\") config.format = obj.format\n      if (obj.spans === true) spansEnabled = true\n      if (obj.spans === false) spansEnabled = false\n      if (obj.idFormat === \"simple\" || obj.idFormat === \"w3c\") setIdFormat(obj.idFormat)\n      if (typeof obj.sampleRate === \"number\") setSampleRate(obj.sampleRate)\n      continue\n    }\n\n    // 6. String \"stderr\" → stderr sink\n    if (element === \"stderr\" && typeof process !== \"undefined\") {\n      outputs.push({\n        levelPriority: LOG_LEVEL_PRIORITY[config.level],\n        nsFilter: config.ns,\n        write: createWritableSink(process.stderr as unknown as Writable, config.format),\n      })\n      continue\n    }\n\n    throw new Error(\n      `loggily: unsupported config element of type \"${typeof element}\". ` +\n        'Config arrays accept: objects (config), arrays (branches), functions (stages), console, \"console\", or writables ({ write }).',\n    )\n  }\n\n  const dispatch = (event: Event): void => {\n    // Span gate: { spans: false } disables span output for this pipeline\n    if (event.kind === \"span\" && !spansEnabled) return\n\n    let e: Event = event\n    for (const stage of stages) {\n      const result = stage(e)\n      if (result === null) return\n      if (result !== undefined) e = result\n    }\n    for (const output of outputs) {\n      if (e.kind === \"log\" && LOG_LEVEL_PRIORITY[e.level] < output.levelPriority) continue\n      if (output.nsFilter && !output.nsFilter(e.namespace)) continue\n      output.write(e)\n    }\n    for (const branch of branches) {\n      branch.dispatch(e)\n    }\n  }\n\n  return {\n    dispatch,\n    level: config.level,\n    dispose: () => {\n      for (const d of disposables) d()\n    },\n  }\n}\n\n// ============ Env Var Readers (exported for withEnvDefaults plugin) ============\n\nexport function readEnvLevel(): LogLevel {\n  const env = getEnv(\"LOG_LEVEL\")?.toLowerCase()\n  let level: LogLevel =\n    env === \"trace\" || env === \"debug\" || env === \"info\" || env === \"warn\" || env === \"error\" || env === \"silent\"\n      ? env\n      : \"info\"\n\n  const debugEnv = getEnv(\"DEBUG\")\n  if (debugEnv && LOG_LEVEL_PRIORITY[level] > LOG_LEVEL_PRIORITY.debug) {\n    level = \"debug\"\n  }\n\n  return level\n}\n\n/**\n * Namespace-aware level: only bumps to debug if the namespace matches the DEBUG filter.\n * This enables zero-overhead conditional gating — `log.debug?.()` returns undefined\n * for namespaces outside the DEBUG filter, skipping argument evaluation entirely.\n */\nexport function readEnvLevelForNamespace(namespace: string): LogLevel {\n  const env = getEnv(\"LOG_LEVEL\")?.toLowerCase()\n  const baseLevel: LogLevel =\n    env === \"trace\" || env === \"debug\" || env === \"info\" || env === \"warn\" || env === \"error\" || env === \"silent\"\n      ? env\n      : \"info\"\n\n  const debugEnv = getEnv(\"DEBUG\")\n  if (debugEnv && LOG_LEVEL_PRIORITY[baseLevel] > LOG_LEVEL_PRIORITY.debug) {\n    // DEBUG is set and would bump level — check if this namespace matches\n    const nsFilter = readEnvNs()\n    if (nsFilter && nsFilter(namespace)) {\n      return \"debug\" // namespace matches DEBUG filter — bump to debug\n    }\n    // Namespace doesn't match — keep the configured level\n    return baseLevel\n  }\n\n  return baseLevel\n}\n\nexport function readEnvNs(): NsFilter | null {\n  const debugEnv = getEnv(\"DEBUG\")\n  if (!debugEnv) return null\n\n  const parts = debugEnv.split(\",\").map((s) => s.trim())\n  return parseNsFilter(parts)\n}\n\nexport function readEnvFormat(): LogFormat {\n  const envFormat = getEnv(\"LOG_FORMAT\")?.toLowerCase()\n  if (envFormat === \"json\") return \"json\"\n  if (envFormat === \"console\") return \"console\"\n  if (getEnv(\"TRACE_FORMAT\") === \"json\") return \"json\"\n  if (getEnv(\"NODE_ENV\") === \"production\") return \"json\"\n  return \"console\"\n}\n\nexport function readEnvTrace(): { enabled: boolean; filter: NsFilter | null } {\n  const traceEnv = getEnv(\"TRACE\")\n  if (!traceEnv) return { enabled: false, filter: null }\n  if (traceEnv === \"1\" || traceEnv === \"true\") return { enabled: true, filter: null }\n  const prefixes = traceEnv.split(\",\").map((s) => s.trim())\n  return {\n    enabled: true,\n    filter: (namespace: string) => {\n      for (const prefix of prefixes) {\n        if (matchesPattern(namespace, prefix)) return true\n      }\n      return false\n    },\n  }\n}\n","/**\n * loggily v2 — Structured logging with spans\n *\n * One import. Objects configure. Arrays branch. Values write.\n *\n * @example\n * const log = createLogger('myapp')\n * log.info?.('starting')\n *\n * @example\n * const log = createLogger('myapp', [\n *   { level: 'debug', ns: '-sql' },\n *   console,\n *   { file: '/tmp/app.log', level: 'info', format: 'json' },\n * ])\n * log.info?.('server started', { port: 3000 })\n */\n\nimport {\n  type Event,\n  type LogEvent,\n  type SpanEvent,\n  type Pipeline,\n  type Stage,\n  type LogLevel,\n  type OutputLogLevel,\n  type LogFormat,\n  type NsFilter,\n  type ConfigElement,\n  LOG_LEVEL_PRIORITY,\n  buildPipeline,\n  safeStringify,\n  serializeCause,\n  readEnvLevel,\n  readEnvLevelForNamespace,\n  readEnvNs,\n  readEnvFormat,\n  readEnvTrace,\n  writeToConsole,\n  formatConsoleEvent,\n  formatJSONEvent,\n} from \"./pipeline.js\"\n\nimport { createMetricsCollector as _createMetricsCollector, withMetrics as _withMetrics } from \"./metrics.js\"\n\nexport type { Event, LogEvent, SpanEvent, Stage, LogLevel, OutputLogLevel, LogFormat, ConfigElement }\nexport { LOG_LEVEL_PRIORITY, safeStringify }\n\n// ============ Metrics ============\n\nexport interface SpanRecord {\n  readonly name: string\n  readonly durationMs: number\n}\n\nexport interface SpanRecorder {\n  recordSpan(data: SpanRecord): void\n}\n\n// ============ Types ============\n\nexport type LazyMessage = string | (() => string)\nexport type LazyProps = Record<string, unknown> | (() => Record<string, unknown>)\n\nexport interface SpanData {\n  readonly id: string\n  readonly traceId: string\n  readonly parentId: string | null\n  readonly startTime: number\n  readonly endTime: number | null\n  readonly duration: number | null\n  [key: string]: unknown\n}\n\nexport interface Logger extends Disposable {\n  readonly name: string\n  readonly props: Readonly<Record<string, unknown>>\n  readonly level: LogLevel\n\n  dispatch(event: Event): void\n\n  trace(message: LazyMessage, data?: Record<string, unknown>): void\n  debug(message: LazyMessage, data?: Record<string, unknown>): void\n  info(message: LazyMessage, data?: Record<string, unknown>): void\n  warn(message: LazyMessage, data?: Record<string, unknown>): void\n  error(message: LazyMessage, data?: Record<string, unknown>): void\n  error(error: Error, data?: Record<string, unknown>): void\n  error(error: Error, message: string, data?: Record<string, unknown>): void\n\n  /** @deprecated Use .child() */\n  logger(namespace?: string, props?: Record<string, unknown>): ConditionalLogger\n  span(namespace?: string, props?: LazyProps): SpanLogger\n  child(namespace: string, props?: Record<string, unknown>): ConditionalLogger\n  child(context: Record<string, unknown>): ConditionalLogger\n  end(): void\n}\n\nexport interface SpanLogger extends ConditionalLogger, Disposable {\n  readonly spanData: SpanData & { [key: string]: unknown }\n}\n\n// ============ ConditionalLogger ============\n\nexport interface ConditionalLogger extends Disposable {\n  readonly name: string\n  readonly props: Readonly<Record<string, unknown>>\n  readonly level: LogLevel\n\n  /** Metrics collector, present when `{ metrics: true }` is in config or `withMetrics()` was applied */\n  readonly metrics?: import(\"./metrics.js\").MetricsCollector\n\n  dispatch(event: Event): void\n\n  trace?: (message: LazyMessage, data?: Record<string, unknown>) => void\n  debug?: (message: LazyMessage, data?: Record<string, unknown>) => void\n  info?: (message: LazyMessage, data?: Record<string, unknown>) => void\n  warn?: (message: LazyMessage, data?: Record<string, unknown>) => void\n  error?: {\n    (message: LazyMessage, data?: Record<string, unknown>): void\n    (error: Error, data?: Record<string, unknown>): void\n    (error: Error, message: string, data?: Record<string, unknown>): void\n  }\n\n  /** @deprecated Use .child() */\n  logger(namespace?: string, props?: Record<string, unknown>): ConditionalLogger\n  span?(namespace?: string, props?: LazyProps): SpanLogger\n  child(namespace: string, props?: Record<string, unknown>): ConditionalLogger\n  child(context: Record<string, unknown>): ConditionalLogger\n  end(): void\n}\n\n// ============ ID Generation ============\n\nimport {\n  generateSpanId,\n  generateTraceId,\n  resetIdCounters,\n  shouldSample,\n  setIdFormat,\n  setSampleRate,\n} from \"./tracing.js\"\nimport type { IdFormat } from \"./tracing.js\"\n\nexport function resetIds(): void {\n  resetIdCounters()\n}\n\n// ============ Context Propagation Hooks ============\n\nlet _getContextTags: (() => Record<string, string>) | null = null\nlet _getContextParent: (() => { spanId: string; traceId: string } | null) | null = null\nlet _enterContext: ((spanId: string, traceId: string, parentId: string | null) => void) | null = null\nlet _exitContext: ((spanId: string) => void) | null = null\n\n/** @internal */\nexport function _setContextHooks(hooks: {\n  getContextTags: () => Record<string, string>\n  getContextParent: () => { spanId: string; traceId: string } | null\n  enterContext: (spanId: string, traceId: string, parentId: string | null) => void\n  exitContext: (spanId: string) => void\n}): void {\n  _getContextTags = hooks.getContextTags\n  _getContextParent = hooks.getContextParent\n  _enterContext = hooks.enterContext\n  _exitContext = hooks.exitContext\n}\n\n/** @internal */\nexport function _clearContextHooks(): void {\n  _getContextTags = null\n  _getContextParent = null\n  _enterContext = null\n  _exitContext = null\n}\n\n// ============ SpanData Proxy ============\n\ninterface SpanDataFields {\n  id: string\n  traceId: string\n  parentId: string | null\n  startTime: number\n  endTime: number | null\n  duration: number | null\n}\n\nexport function createSpanDataProxy(getFields: () => SpanDataFields, attrs: Record<string, unknown>): SpanData {\n  const READONLY_KEYS = new Set([\"id\", \"traceId\", \"parentId\", \"startTime\", \"endTime\", \"duration\"])\n  return new Proxy(attrs, {\n    get(_target, prop) {\n      if (READONLY_KEYS.has(prop as string)) {\n        return getFields()[prop as keyof SpanDataFields]\n      }\n      return attrs[prop as string]\n    },\n    set(_target, prop, value) {\n      if (READONLY_KEYS.has(prop as string)) {\n        return false\n      }\n      attrs[prop as string] = value\n      return true\n    },\n  }) as SpanData\n}\n\n// ============ Span Collection ============\n\nconst collectedSpans: SpanData[] = []\nlet collectSpans = false\n\nexport function startCollecting(): void {\n  collectSpans = true\n  collectedSpans.length = 0\n}\n\nexport function stopCollecting(): SpanData[] {\n  collectSpans = false\n  return [...collectedSpans]\n}\n\nexport function getCollectedSpans(): SpanData[] {\n  return [...collectedSpans]\n}\n\nexport function clearCollectedSpans(): void {\n  collectedSpans.length = 0\n}\n\n// ============ Implementation ============\n\nfunction resolveMessage(msg: LazyMessage): string {\n  return typeof msg === \"function\" ? msg() : msg\n}\n\ninterface MutableSpanData {\n  id: string\n  traceId: string\n  parentId: string | null\n  startTime: number\n  endTime: number | null\n  duration: number | null\n  attrs: Record<string, unknown>\n}\n\nfunction createLoggerImpl(name: string, props: Record<string, unknown>, pipeline: Pipeline): Logger {\n  const emitLog = (\n    level: OutputLogLevel,\n    msgOrError: LazyMessage | Error,\n    dataOrMsg?: Record<string, unknown> | string,\n    extraData?: Record<string, unknown>,\n  ): void => {\n    let message: string\n    let data: Record<string, unknown> | undefined\n\n    if (msgOrError instanceof Error) {\n      const err = msgOrError\n      const contextTags = _getContextTags?.() ?? {}\n      if (typeof dataOrMsg === \"string\") {\n        message = dataOrMsg\n        data = {\n          ...contextTags,\n          ...props,\n          ...extraData,\n          error_type: err.name,\n          error_message: err.message,\n          error_stack: err.stack,\n          error_code: (err as { code?: string }).code,\n          error_cause: err.cause !== undefined ? serializeCause(err.cause) : undefined,\n        }\n      } else {\n        message = err.message\n        data = {\n          ...contextTags,\n          ...props,\n          ...(dataOrMsg as Record<string, unknown>),\n          error_type: err.name,\n          error_stack: err.stack,\n          error_code: (err as { code?: string }).code,\n          error_cause: err.cause !== undefined ? serializeCause(err.cause) : undefined,\n        }\n      }\n    } else {\n      message = resolveMessage(msgOrError)\n      const contextTags = _getContextTags?.()\n      data =\n        contextTags && Object.keys(contextTags).length > 0\n          ? { ...contextTags, ...props, ...(dataOrMsg as Record<string, unknown>) }\n          : Object.keys(props).length > 0 || dataOrMsg\n            ? { ...props, ...(dataOrMsg as Record<string, unknown>) }\n            : undefined\n    }\n\n    const event: LogEvent = {\n      kind: \"log\",\n      time: Date.now(),\n      namespace: name,\n      level,\n      message,\n      props: data,\n    }\n    pipeline.dispatch(event)\n  }\n\n  const logger: Logger = {\n    name,\n    props: Object.freeze({ ...props }),\n\n    get level(): LogLevel {\n      return pipeline.level\n    },\n\n    dispatch(event: Event): void {\n      pipeline.dispatch(event)\n    },\n\n    [Symbol.dispose](): void {\n      pipeline.dispose()\n    },\n\n    trace: (msg, data) => emitLog(\"trace\", msg, data),\n    debug: (msg, data) => emitLog(\"debug\", msg, data),\n    info: (msg, data) => emitLog(\"info\", msg, data),\n    warn: (msg, data) => emitLog(\"warn\", msg, data),\n    error: (\n      msgOrError: LazyMessage | Error,\n      dataOrMsg?: Record<string, unknown> | string,\n      extraData?: Record<string, unknown>,\n    ) => emitLog(\"error\", msgOrError, dataOrMsg, extraData),\n\n    /** @deprecated Use .child() instead */\n    logger(namespace?: string, childProps?: Record<string, unknown>): ConditionalLogger {\n      return this.child(namespace ?? \"\", childProps)\n    },\n\n    span(_namespace?: string, _childProps?: LazyProps): SpanLogger {\n      throw new Error(\n        \"loggily: span() requires the withSpans() plugin. Use pipe(baseCreateLogger, withSpans()) or the default createLogger.\",\n      )\n    },\n\n    child(\n      namespaceOrContext?: string | Record<string, unknown>,\n      childProps?: Record<string, unknown>,\n    ): ConditionalLogger {\n      if (typeof namespaceOrContext === \"string\") {\n        const childName = namespaceOrContext ? `${name}:${namespaceOrContext}` : name\n        const mergedProps = { ...props, ...childProps }\n        return wrapConditional(createLoggerImpl(childName, mergedProps, pipeline), () => pipeline.level)\n      }\n      // Object -> context fields, same namespace\n      return wrapConditional(\n        createLoggerImpl(name, { ...props, ...namespaceOrContext }, pipeline),\n        () => pipeline.level,\n      )\n    },\n\n    end(): void {\n      // no-op for non-span loggers\n    },\n  }\n\n  return logger\n}\n\n// ============ ConditionalLogger Proxy ============\n\nfunction wrapConditional(logger: Logger, getLevel: () => LogLevel): ConditionalLogger {\n  return new Proxy(logger as ConditionalLogger, {\n    get(target, prop: string | symbol) {\n      if (typeof prop === \"string\" && prop in LOG_LEVEL_PRIORITY && prop !== \"silent\") {\n        if (LOG_LEVEL_PRIORITY[prop as keyof typeof LOG_LEVEL_PRIORITY] < LOG_LEVEL_PRIORITY[getLevel()]) {\n          return undefined\n        }\n      }\n      // span is optional on ConditionalLogger: return undefined if base impl is the error-thrower\n      if (prop === \"span\") {\n        const val = (target as unknown as Record<string | symbol, unknown>)[prop]\n        // If span is the default error-throwing stub, return undefined (making it optional)\n        if (val === baseSpanStub) return undefined\n        return val\n      }\n      return (target as unknown as Record<string | symbol, unknown>)[prop]\n    },\n  })\n}\n\n// Sentinel reference for detecting the base span stub\nconst baseSpanStub = function baseSpanStub(_namespace?: string, _childProps?: LazyProps): SpanLogger {\n  throw new Error(\n    \"loggily: span() requires the withSpans() plugin. Use pipe(baseCreateLogger, withSpans()) or the default createLogger.\",\n  )\n}\n\n// ============ withSpans Plugin ============\n\n/**\n * Plugin: adds span creation capability to loggers.\n * Without this plugin, `.span` is undefined on ConditionalLogger.\n * Included by default in `createLogger`.\n */\nexport function withSpans(): LoggerPlugin {\n  return (factory, _ctx) => {\n    return (name, configOrProps?) => {\n      const logger = factory(name, configOrProps)\n      return augmentWithSpans(logger, null, null, true)\n    }\n  }\n}\n\ninterface SpanState {\n  parentSpanId: string | null\n  traceId: string | null\n  traceSampled: boolean\n}\n\nfunction augmentWithSpans(\n  logger: ConditionalLogger,\n  parentSpanId: string | null,\n  traceId: string | null,\n  traceSampled: boolean,\n): ConditionalLogger {\n  const spanState: SpanState = { parentSpanId, traceId, traceSampled }\n\n  return new Proxy(logger, {\n    get(target, prop: string | symbol) {\n      if (prop === \"span\") {\n        return createSpanMethod(target, spanState)\n      }\n      if (prop === \"child\") {\n        return function child(\n          namespaceOrContext?: string | Record<string, unknown>,\n          childProps?: Record<string, unknown>,\n        ): ConditionalLogger {\n          const childLogger = target.child(namespaceOrContext as string, childProps)\n          // Child loggers inherit span state (parent/trace context)\n          return augmentWithSpans(childLogger, spanState.parentSpanId, spanState.traceId, spanState.traceSampled)\n        }\n      }\n      if (prop === \"logger\") {\n        return function logger(namespace?: string, childProps?: Record<string, unknown>): ConditionalLogger {\n          const childLogger = target.logger(namespace, childProps)\n          return augmentWithSpans(childLogger, spanState.parentSpanId, spanState.traceId, spanState.traceSampled)\n        }\n      }\n      return (target as unknown as Record<string | symbol, unknown>)[prop]\n    },\n  })\n}\n\nfunction createSpanMethod(\n  logger: ConditionalLogger,\n  spanState: SpanState,\n): (namespace?: string, childProps?: LazyProps) => SpanLogger {\n  return (namespace?: string, childProps?: LazyProps): SpanLogger => {\n    const childName = namespace ? `${logger.name}:${namespace}` : logger.name\n    const resolvedChildProps = typeof childProps === \"function\" ? childProps() : childProps\n    const mergedProps = { ...logger.props, ...resolvedChildProps }\n    const newSpanId = generateSpanId()\n\n    let resolvedParentId = spanState.parentSpanId\n    let resolvedTraceId = spanState.traceId\n\n    if (!resolvedParentId && _getContextParent) {\n      const ctxParent = _getContextParent()\n      if (ctxParent) {\n        resolvedParentId = ctxParent.spanId\n        resolvedTraceId = resolvedTraceId || ctxParent.traceId\n      }\n    }\n\n    const isNewTrace = !resolvedTraceId\n    const finalTraceId = resolvedTraceId || generateTraceId()\n    const sampled = isNewTrace ? shouldSample() : spanState.traceSampled\n\n    const newSpanData: MutableSpanData = {\n      id: newSpanId,\n      traceId: finalTraceId,\n      parentId: resolvedParentId,\n      startTime: Date.now(),\n      endTime: null,\n      duration: null,\n      attrs: {},\n    }\n\n    // Create a child logger for the span to emit logs through\n    const childLogger = logger.child(namespace ?? \"\", resolvedChildProps)\n    // Augment the child with span capability, setting this span as parent\n    const spanAugmented = augmentWithSpans(childLogger, newSpanId, finalTraceId, sampled)\n\n    _enterContext?.(newSpanId, finalTraceId, resolvedParentId)\n\n    const disposeSpan = () => {\n      if (newSpanData.endTime !== null) return\n\n      newSpanData.endTime = Date.now()\n      newSpanData.duration = newSpanData.endTime - newSpanData.startTime\n\n      if (collectSpans) {\n        collectedSpans.push(\n          createSpanDataProxy(\n            () => ({\n              id: newSpanData.id,\n              traceId: newSpanData.traceId,\n              parentId: newSpanData.parentId,\n              startTime: newSpanData.startTime,\n              endTime: newSpanData.endTime,\n              duration: newSpanData.duration,\n            }),\n            { ...newSpanData.attrs },\n          ),\n        )\n      }\n\n      _exitContext?.(newSpanId)\n      if (sampled) {\n        const spanEvent: SpanEvent = {\n          kind: \"span\",\n          time: newSpanData.endTime,\n          namespace: childName,\n          name: childName,\n          duration: newSpanData.duration,\n          props: {\n            ...mergedProps,\n            ...newSpanData.attrs,\n          },\n          spanId: newSpanData.id,\n          traceId: newSpanData.traceId,\n          parentId: newSpanData.parentId,\n        }\n        logger.dispatch(spanEvent)\n      }\n    }\n\n    const spanDataProxy = createSpanDataProxy(\n      () => ({\n        id: newSpanData.id,\n        traceId: newSpanData.traceId,\n        parentId: newSpanData.parentId,\n        startTime: newSpanData.startTime,\n        endTime: newSpanData.endTime,\n        duration:\n          newSpanData.endTime !== null\n            ? newSpanData.endTime - newSpanData.startTime\n            : Date.now() - newSpanData.startTime,\n      }),\n      newSpanData.attrs,\n    )\n\n    // Build the SpanLogger by overlaying span-specific properties onto the augmented child.\n    // Allow Symbol.dispose to be overridden (withMetrics wraps it).\n    let currentDispose = disposeSpan\n    const spanLogger = new Proxy(spanAugmented as unknown as SpanLogger, {\n      get(target, prop: string | symbol) {\n        if (prop === \"spanData\") return spanDataProxy\n        if (prop === Symbol.dispose) return currentDispose\n        if (prop === \"end\") {\n          return () => {\n            if (newSpanData.endTime === null) {\n              currentDispose()\n            }\n          }\n        }\n        if (prop === \"name\") return childName\n        if (prop === \"props\") return Object.freeze({ ...mergedProps })\n        return (target as unknown as Record<string | symbol, unknown>)[prop]\n      },\n      set(_target, prop: string | symbol, value: unknown) {\n        if (prop === Symbol.dispose) {\n          currentDispose = value as () => void\n          return true\n        }\n        return false\n      },\n    })\n\n    return spanLogger\n  }\n}\n\n// ============ Public API ============\n\n// ============ Base createLogger ============\n\n/**\n * Base createLogger — requires a config array.\n * Use the default `createLogger` export (with `withEnvDefaults`) for zero-config.\n *\n * Note: loggers from baseCreateLogger do NOT have `.span()` capability.\n * Use `pipe(baseCreateLogger, withSpans())` or the default `createLogger` for spans.\n */\nexport function baseCreateLogger(\n  name: string,\n  configOrProps?: ConfigElement[] | Record<string, unknown>,\n): ConditionalLogger {\n  let pipeline: Pipeline\n  let props: Record<string, unknown> = {}\n\n  if (Array.isArray(configOrProps)) {\n    pipeline = buildPipeline(configOrProps)\n  } else if (configOrProps && typeof configOrProps === \"object\") {\n    props = configOrProps as Record<string, unknown>\n    pipeline = buildPipeline([\"console\"])\n  } else {\n    pipeline = buildPipeline([\"console\"])\n  }\n\n  const logger = createLoggerImpl(name, props, pipeline)\n  // Replace the span method with the sentinel stub so wrapConditional can detect it\n  ;(logger as unknown as Record<string, unknown>).span = baseSpanStub\n  return wrapConditional(logger, () => pipeline.level)\n}\n\n// ============ Compose ============\n\nexport type LoggerFactory = (\n  name: string,\n  configOrProps?: ConfigElement[] | Record<string, unknown>,\n) => ConditionalLogger\n\nexport interface PluginCtx {\n  [key: string]: unknown\n}\n\nexport type LoggerPlugin = (factory: LoggerFactory, ctx: PluginCtx) => LoggerFactory\n\nexport function pipe(base: LoggerFactory, ...plugins: LoggerPlugin[]): LoggerFactory {\n  const ctx: PluginCtx = {}\n  return plugins.reduce((factory, plugin) => plugin(factory, ctx), base)\n}\n\n// ============ withEnvDefaults Plugin ============\n\nconst _process = typeof process !== \"undefined\" ? process : undefined\nconst _env = _process?.env ?? ({} as Record<string, string | undefined>)\n\n// Env config — read fresh each dispatch (process.env access is ~ns, parsing is trivial)\nfunction currentLevel(): LogLevel {\n  return readEnvLevel()\n}\nfunction currentNs(): NsFilter | null {\n  return readEnvNs()\n}\nfunction currentFormat(): LogFormat {\n  return readEnvFormat()\n}\nfunction currentTrace(): { enabled: boolean; filter: NsFilter | null } {\n  return readEnvTrace()\n}\n\n// Runtime state for legacy addWriter/setSuppressConsole\nconst _writers: Array<(formatted: string, level: string) => void> = []\nlet _suppressConsole = false\n\n// File writer factory — set by index.ts (avoids node:fs in core.ts for browser compat)\nlet _logFileWriterFactory: ((path: string) => { write: (s: string) => void; close: () => void }) | null = null\n/** @internal */\nexport function _setLogFileWriterFactory(factory: typeof _logFileWriterFactory): void {\n  _logFileWriterFactory = factory\n}\n\n/**\n * Plugin: read defaults from environment variables (LOG_LEVEL, DEBUG, LOG_FORMAT, TRACE, LOG_FILE).\n * Included by default. Omit to disable env-var behavior entirely.\n *\n * When no config array is given, provides console output + env-var-based config.\n * When a config array IS given, env vars are already used as defaults by buildPipeline.\n * Legacy setters (setLogLevel, addWriter, etc.) affect loggers created without explicit config.\n */\nexport function withEnvDefaults(): LoggerPlugin {\n  return (factory, _ctx) => (name, configOrProps?) => {\n    // Apply tracing env vars (once per logger creation, idempotent)\n    const envIdFormat = _env.TRACE_ID_FORMAT?.toLowerCase()\n    if (envIdFormat === \"simple\" || envIdFormat === \"w3c\") {\n      setIdFormat(envIdFormat as IdFormat)\n    }\n    const envSampleRate = _env.TRACE_SAMPLE_RATE\n    if (envSampleRate !== undefined) {\n      const rate = Number.parseFloat(envSampleRate)\n      if (!Number.isNaN(rate) && rate >= 0 && rate <= 1) {\n        setSampleRate(rate)\n      }\n    }\n\n    // Explicit config array — pass through, buildPipeline reads env defaults\n    if (Array.isArray(configOrProps)) return factory(name, configOrProps)\n\n    // No config array — use env-dynamic pipeline.\n    // Pass a config array through the factory so all upstream plugins get applied,\n    // with a stage that delegates to the env pipeline for dynamic dispatch.\n    const envPipeline = createEnvPipeline()\n    const envStage: ConfigElement = (event: Event) => {\n      envPipeline.dispatch(event)\n      return null // consume the event (env pipeline handles all output)\n    }\n\n    // Props are passed as the first config element to include them in log output\n    if (configOrProps && typeof configOrProps === \"object\") {\n      // Object props — create logger with props + env pipeline\n      // We need to pass props AND a config array. But factory only accepts one or the other.\n      // Solution: create via factory with config array, then the child() with props.\n      const logger = factory(name, [{ level: \"trace\" as LogLevel }, envStage])\n      return applyNamespaceGating(logger.child(configOrProps as Record<string, unknown>))\n    }\n\n    return applyNamespaceGating(factory(name, [{ level: \"trace\" as LogLevel }, envStage]))\n  }\n}\n\n/**\n * Wrap a logger so that conditional method gating is namespace-aware.\n * When DEBUG=myapp:db, only loggers whose namespace matches get debug enabled.\n * Without this, all loggers get debug because readEnvLevel() bumps globally.\n */\nfunction applyNamespaceGating(logger: ConditionalLogger): ConditionalLogger {\n  return new Proxy(logger, {\n    get(target, prop: string | symbol) {\n      if (typeof prop === \"string\" && prop in LOG_LEVEL_PRIORITY && prop !== \"silent\") {\n        const nsLevel = readEnvLevelForNamespace(target.name)\n        if (LOG_LEVEL_PRIORITY[prop as keyof typeof LOG_LEVEL_PRIORITY] < LOG_LEVEL_PRIORITY[nsLevel]) {\n          return undefined\n        }\n      }\n      return (target as unknown as Record<string | symbol, unknown>)[prop]\n    },\n  })\n}\n\nfunction createEnvPipeline(): Pipeline {\n  const disposables: (() => void)[] = []\n  const logFile = _env.LOG_FILE\n  let fileSink: ((event: Event) => void) | null = null\n  if (logFile && _logFileWriterFactory) {\n    const writer = _logFileWriterFactory(logFile)\n    fileSink = (event: Event) => {\n      const fmt = currentFormat() === \"json\" ? formatJSONEvent : formatConsoleEvent\n      writer.write(fmt(event))\n    }\n    disposables.push(() => writer.close())\n  }\n\n  const dispatch = (event: Event): void => {\n    if (event.kind === \"log\" && LOG_LEVEL_PRIORITY[event.level] < LOG_LEVEL_PRIORITY[currentLevel()]) return\n    if (event.kind === \"span\") {\n      const trace = currentTrace()\n      if (!trace.enabled) return\n      if (trace.filter && !trace.filter(event.namespace)) return\n    }\n    const ns = currentNs()\n    if (ns && !ns(event.namespace)) return\n\n    const formatter = currentFormat() === \"json\" ? formatJSONEvent : formatConsoleEvent\n    const text = formatter(event)\n    const lvl = event.kind === \"log\" ? event.level : \"span\"\n\n    for (const w of _writers) w(text, lvl)\n    if (!_suppressConsole) writeToConsole(text, event)\n    fileSink?.(event)\n  }\n\n  return {\n    dispatch,\n    get level() {\n      return currentLevel()\n    },\n    dispose: () => {\n      for (const d of disposables) d()\n    },\n  }\n}\n\n// ============ withConfigMetrics Plugin ============\n\n/**\n * Plugin: when `{ metrics: true }` appears in the config array, automatically\n * creates a MetricsCollector and applies withMetrics to the logger.\n * The collector is accessible via `logger.metrics`.\n */\nexport function withConfigMetrics(): LoggerPlugin {\n  return (factory, _ctx) => {\n    return (name, configOrProps?) => {\n      const logger = factory(name, configOrProps)\n\n      // Only scan config arrays, not props objects\n      if (!Array.isArray(configOrProps)) return logger\n\n      // Check if any config object has metrics: true (flat scan, not into branches)\n      const hasMetrics = configOrProps.some(\n        (el) =>\n          typeof el === \"object\" &&\n          el !== null &&\n          !Array.isArray(el) &&\n          \"metrics\" in el &&\n          (el as Record<string, unknown>).metrics === true,\n      )\n\n      if (!hasMetrics) return logger\n\n      const collector = _createMetricsCollector()\n      return _withMetrics(collector)(logger)\n    }\n  }\n}\n\n/** Default createLogger — includes withEnvDefaults + withSpans + withConfigMetrics. */\nexport const createLogger: LoggerFactory = pipe(baseCreateLogger, withEnvDefaults(), withSpans(), withConfigMetrics())\n\n/** Test helper — all levels, console output. */\nexport function createTestLogger(name: string): ConditionalLogger {\n  return pipe(baseCreateLogger, withSpans())(name, [{ level: \"trace\" }, \"console\"])\n}\n\n// ============ Legacy Setters ============\n\n/** @deprecated Use config array */\nexport function setLogLevel(level: LogLevel): void {\n  _env.LOG_LEVEL = level\n}\nexport function getLogLevel(): LogLevel {\n  return currentLevel()\n}\nexport function enableSpans(): void {\n  _env.TRACE = \"1\"\n}\nexport function disableSpans(): void {\n  delete _env.TRACE\n}\nexport function spansAreEnabled(): boolean {\n  return !!_env.TRACE\n}\nexport function setTraceFilter(namespaces: string[] | null): void {\n  if (!namespaces || namespaces.length === 0) delete _env.TRACE\n  else _env.TRACE = namespaces.join(\",\")\n}\nexport function getTraceFilter(): string[] | null {\n  return _env.TRACE ? _env.TRACE.split(\",\") : null\n}\nexport function setDebugFilter(namespaces: string[] | null): void {\n  if (!namespaces || namespaces.length === 0) delete _env.DEBUG\n  else _env.DEBUG = namespaces.join(\",\")\n}\nexport function getDebugFilter(): string[] | null {\n  return _env.DEBUG ? _env.DEBUG.split(\",\") : null\n}\nexport function setLogFormat(format: LogFormat): void {\n  _env.LOG_FORMAT = format\n}\nexport function getLogFormat(): LogFormat {\n  return currentFormat()\n}\nexport function setSuppressConsole(value: boolean): void {\n  _suppressConsole = value\n}\nexport type OutputMode = \"console\" | \"stderr\" | \"writers-only\"\nexport function setOutputMode(_mode: OutputMode): void {\n  throw new Error(\n    'loggily: setOutputMode() is removed in v2. Use config arrays: omit console from array for writers-only, use \"stderr\" for stderr mode.',\n  )\n}\nexport function getOutputMode(): OutputMode {\n  return \"console\"\n}\nexport function addWriter(writer: (formatted: string, level: string) => void): () => void {\n  _writers.push(writer)\n  return () => {\n    const i = _writers.indexOf(writer)\n    if (i !== -1) _writers.splice(i, 1)\n  }\n}\nexport function writeSpan(namespace: string, duration: number, attrs: Record<string, unknown>): void {\n  createEnvPipeline().dispatch({\n    kind: \"span\",\n    time: Date.now(),\n    namespace,\n    name: namespace,\n    duration,\n    props: attrs,\n    spanId: (attrs.span_id as string) ?? \"\",\n    traceId: (attrs.trace_id as string) ?? \"\",\n    parentId: (attrs.parent_id as string | null) ?? null,\n  })\n}\n"],"mappings":"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"}

package/dist/core-Dm2PQUoS.d.mts.map

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

package/dist/file-writer-DtaY8Njt.d.mts.map

@@ -1 +0,0 @@
-{"version":3,"file":"file-writer-DtaY8Njt.d.mts","names":[],"sources":["../src/tracing.ts","../src/file-writer.ts"],"mappings":";;;;KAYY,QAAA;;;;;AAoBZ;;;iBATgB,WAAA,CAAY,MAAA,EAAQ,QAAA;;AAkDpC;;;;iBAzCgB,WAAA,CAAA,GAAe,QAAA;;UAyCd,kBAAA;EA4B2D;EA1B1E,OAAA;AAAA;;;;;AAyEF;;;;;;;;AC1IA;;;;;AAQA;;;;;;iBDmFgB,WAAA,CAAY,QAAA,EAAU,QAAA,EAAU,OAAA,GAAU,kBAAA;;;;ACvD1D;;;;iBD0FgB,aAAA,CAAc,IAAA;;;;;;iBAYd,aAAA,CAAA;;;;;;AAxIhB;;;;UCFiB,iBAAA;EDaD;ECXd,UAAA;;EAEA,aAAA;AAAA;ADkBF;AAAA,UCdiB,UAAA;;EAEf,KAAA,CAAM,IAAA;EDY+B;ECVrC,KAAA;EDmDiC;ECjDjC,KAAA;AAAA;;AD6EF;;;;;;;;;;AAmCA;;;;;AAYA;;;iBCtGgB,gBAAA,CAAiB,QAAA,UAAkB,OAAA,GAAS,iBAAA,GAAyB,UAAA"}

package/dist/pipeline-Cl9-wCmt.d.mts.map

@@ -1 +0,0 @@
-{"version":3,"file":"pipeline-Cl9-wCmt.d.mts","names":[],"sources":["../src/pipeline.ts"],"mappings":";KAOY,cAAA;AAAA,KACA,QAAA,GAAW,cAAA;AAAA,KACX,SAAA;AAAA,KAEA,QAAA;EACV,IAAA;EACA,IAAA;EACA,SAAA;EACA,KAAA,EAAO,cAAA;EACP,OAAA;EACA,KAAA,GAAQ,MAAA;AAAA;AAAA,KAGE,SAAA;EACV,IAAA;EACA,IAAA;EACA,SAAA;EACA,IAAA;EACA,QAAA;EACA,KAAA,GAAQ,MAAA;EACR,MAAA;EACA,OAAA;EACA,QAAA;AAAA;AAAA,KAGU,KAAA,GAAQ,QAAA,GAAW,SAAA;AAAA,KACnB,KAAA,IAAS,KAAA,EAAO,KAAA,KAAU,KAAA;AAAA,cAIzB,kBAAA,EAAoB,MAAA,CAAO,QAAA;;iBA4BxB,cAAA,CAAe,KAAA,WAAgB,QAAA;AAAA,iBAkB/B,aAAA,CAAc,KAAA;AAAA,KAoFlB,QAAA,IAAY,SAAA;AAAA,UA2GP,QAAA;EACf,QAAA,GAAW,KAAA,EAAO,KAAA;EAClB,KAAA,EAAO,QAAA;EACP,OAAA;AAAA;;UAqCe,QAAA;EAEf,KAAA,GAAQ,IAAA;EA5R8B;EA8RtC,UAAA;AAAA;;UAIe,YAAA;EACf,KAAA,GAAQ,QAAA;EACR,EAAA;EACA,MAAA,GAAS,SAAA;EACT,KAAA;EArSyC;EAuSzC,OAAA;EA5RD;EA8RC,QAAA;EArS+B;EAuS/B,UAAA;AAAA;;UAIe,cAAA,SAAuB,YAAA;EACtC,IAAA;AAAA;AA9PF;AAAA,UAkQiB,cAAA,SAAuB,YAAA;EACtC,IAAA,EAAM,MAAA;AAAA;;KAII,aAAA,GACR,YAAA,GACA,cAAA,GACA,cAAA,GACA,OAAA,0BAGA,KAAA,GACA,QAAA,GACA,aAAA;AAAA,UAIM,WAAA;EACR,KAAA,EAAO,QAAA;EACP,EAAA,EAAI,QAAA;EACJ,MAAA,EAAQ,SAAA;AAAA;AAAA,iBAGM,aAAA,CAAc,QAAA,EAAU,aAAA,IAAiB,YAAA,GAAe,OAAA,CAAQ,WAAA,IAAe,QAAA"}