loggily 0.7.0 → 0.8.0

package/dist/metrics.d.mts

@@ -1,48 +1,2 @@
-import { d as SpanRecorder, t as ConditionalLogger, u as SpanRecord } from "./core-DAFH-huv.mjs";
-
-//#region src/metrics.d.ts
-interface SpanStats {
-  count: number;
-  min: number;
-  max: number;
-  mean: number;
-  p50: number;
-  p95: number;
-  p99: number;
-  total: number;
-}
-interface MetricsCollector extends SpanRecorder {
-  /** Get stats for a specific span namespace */
-  stats(name: string): SpanStats | undefined;
-  /** Get stats for all recorded namespaces */
-  all(): Map<string, SpanStats>;
-  /** Format a human-readable summary */
-  summary(): string;
-  /** Reset all collected data */
-  reset(): void;
-}
-declare function createMetricsCollector(maxEntries?: number): MetricsCollector;
-/** Get aggregated span stats (from ambient collector). */
-declare function spanStats(): Map<string, SpanStats>;
-/** Get the ambient collector's formatted summary. */
-declare function spanSummary(): string;
-/** Reset the ambient collector. */
-declare function resetSpanStats(): void;
-/**
- * Compose a logger with a metrics collector.
- * Returns a curried wrapper: `withMetrics(collector?)(logger)`
- *
- * - No arg: uses the built-in ambient collector
- * - Custom collector: records to your collector
- * - Stackable: `withMetrics(a)(withMetrics(b)(logger))` fans out to both
- *
- * @example
- * ```typescript
- * const log = withMetrics()(createLogger("myapp"))
- * const log = withMetrics(myCollector)(createLogger("myapp"))
- * ```
- */
-declare function withMetrics(collector?: SpanRecorder): (logger: ConditionalLogger) => ConditionalLogger;
-//#endregion
-export { MetricsCollector, type SpanRecord, type SpanRecorder, SpanStats, createMetricsCollector, resetSpanStats, spanStats, spanSummary, withMetrics };
-//# sourceMappingURL=metrics.d.mts.map
+import { G as SpanStats, K as createMetricsCollector, W as MetricsCollector, d as SpanRecord, f as SpanRecorder, q as withMetrics } from "./core-Dm2PQUoS.mjs";
+export { MetricsCollector, SpanRecord, SpanRecorder, SpanStats, createMetricsCollector, withMetrics };

package/dist/metrics.mjs

@@ -1,23 +1,4 @@
-import { r as _setAmbientRecorder } from "./core-Du3sIje6.mjs";
 //#region src/metrics.ts
-/**
-* Metrics collection for loggily spans.
-*
-* Two modes:
-* - **Ambient**: import this module → spans auto-record when TRACE is active
-* - **Explicit**: `withMetrics(collector?)(logger)` for custom collection
-*
-* @example
-* ```typescript
-* import { spanStats } from "loggily/metrics"
-* // TRACE=myapp bun run app
-* // → on exit: spanStats() returns aggregated p50/p95/p99
-*
-* // Custom collector:
-* import { withMetrics, createMetricsCollector } from "loggily/metrics"
-* const log = withMetrics()(createLogger("myapp"))
-* ```
-*/
 function percentile(sorted, p) {
 	if (sorted.length === 0) return 0;
 	return sorted[Math.min(Math.floor(sorted.length * p), sorted.length - 1)];
@@ -68,38 +49,23 @@ function createMetricsCollector(maxEntries = 1e3) {
 		}
 	};
 }
-const _ambient = createMetricsCollector();
-_setAmbientRecorder(_ambient);
-/** Get aggregated span stats (from ambient collector). */
-function spanStats() {
-	return _ambient.all();
-}
-/** Get the ambient collector's formatted summary. */
-function spanSummary() {
-	return _ambient.summary();
-}
-/** Reset the ambient collector. */
-function resetSpanStats() {
-	_ambient.reset();
-}
 /**
 * Compose a logger with a metrics collector.
-* Returns a curried wrapper: `withMetrics(collector?)(logger)`
+* Returns a curried wrapper: `withMetrics(collector)(logger)`
 *
-* - No arg: uses the built-in ambient collector
-* - Custom collector: records to your collector
-* - Stackable: `withMetrics(a)(withMetrics(b)(logger))` fans out to both
+* Records span duration to the provided collector on span disposal.
+* Stackable: `withMetrics(a)(withMetrics(b)(logger))` fans out to both.
 *
 * @example
 * ```typescript
-* const log = withMetrics()(createLogger("myapp"))
-* const log = withMetrics(myCollector)(createLogger("myapp"))
+* const collector = createMetricsCollector()
+* const log = withMetrics(collector)(createLogger("myapp"))
 * ```
 */
 function withMetrics(collector) {
-	const recorder = collector ?? _ambient;
 	return (logger) => {
 		return new Proxy(logger, { get(target, prop) {
+			if (prop === "metrics") return collector;
 			if (prop === "span") {
 				const originalSpan = target.span;
 				if (!originalSpan) return void 0;
@@ -108,7 +74,7 @@ function withMetrics(collector) {
 					const originalDispose = span[Symbol.dispose];
 					span[Symbol.dispose] = () => {
 						originalDispose.call(span);
-						if (span.spanData?.duration != null) recorder.recordSpan({
+						if (span.spanData?.duration != null) collector.recordSpan({
 							name: span.name,
 							durationMs: span.spanData.duration
 						});
@@ -116,15 +82,19 @@ function withMetrics(collector) {
 					return span;
 				};
 			}
+			if (prop === "child") return (namespaceOrContext, childProps) => {
+				const child = target.child(namespaceOrContext, childProps);
+				return withMetrics(collector)(child);
+			};
 			if (prop === "logger") return (namespace, childProps) => {
 				const child = target.logger(namespace, childProps);
-				return withMetrics(recorder)(child);
+				return withMetrics(collector)(child);
 			};
 			return target[prop];
 		} });
 	};
 }
 //#endregion
-export { createMetricsCollector, resetSpanStats, spanStats, spanSummary, withMetrics };
+export { createMetricsCollector, withMetrics };
 
 //# sourceMappingURL=metrics.mjs.map

package/dist/metrics.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"metrics.mjs","names":[],"sources":["../src/metrics.ts"],"sourcesContent":["/**\n * Metrics collection for loggily spans.\n *\n * Two modes:\n * - **Ambient**: import this module → spans auto-record when TRACE is active\n * - **Explicit**: `withMetrics(collector?)(logger)` for custom collection\n *\n * @example\n * ```typescript\n * import { spanStats } from \"loggily/metrics\"\n * // TRACE=myapp bun run app\n * // → on exit: spanStats() returns aggregated p50/p95/p99\n *\n * // Custom collector:\n * import { withMetrics, createMetricsCollector } from \"loggily/metrics\"\n * const log = withMetrics()(createLogger(\"myapp\"))\n * ```\n */\n\nimport {\n  type SpanRecorder,\n  type SpanRecord,\n  type ConditionalLogger,\n  type Logger,\n  type LazyProps,\n  type SpanLogger,\n  _setAmbientRecorder,\n  spansAreEnabled,\n} from \"./core.js\"\n\nexport type { SpanRecorder, SpanRecord }\n\n// ============ Stats ============\n\nexport interface SpanStats {\n  count: number\n  min: number\n  max: number\n  mean: number\n  p50: number\n  p95: number\n  p99: number\n  total: number\n}\n\nfunction percentile(sorted: number[], p: number): number {\n  if (sorted.length === 0) return 0\n  const idx = Math.min(Math.floor(sorted.length * p), sorted.length - 1)\n  return sorted[idx]!\n}\n\nfunction computeStats(durations: number[]): SpanStats {\n  const sorted = [...durations].sort((a, b) => a - b)\n  const total = sorted.reduce((sum, d) => sum + d, 0)\n  return {\n    count: sorted.length,\n    min: sorted[0] ?? 0,\n    max: sorted[sorted.length - 1] ?? 0,\n    mean: sorted.length > 0 ? total / sorted.length : 0,\n    p50: percentile(sorted, 0.5),\n    p95: percentile(sorted, 0.95),\n    p99: percentile(sorted, 0.99),\n    total,\n  }\n}\n\n// ============ Collector ============\n\nexport interface MetricsCollector extends SpanRecorder {\n  /** Get stats for a specific span namespace */\n  stats(name: string): SpanStats | undefined\n  /** Get stats for all recorded namespaces */\n  all(): Map<string, SpanStats>\n  /** Format a human-readable summary */\n  summary(): string\n  /** Reset all collected data */\n  reset(): void\n}\n\nexport function createMetricsCollector(maxEntries = 1000): MetricsCollector {\n  const store = new Map<string, number[]>()\n\n  return {\n    recordSpan(data: SpanRecord): void {\n      let arr = store.get(data.name)\n      if (!arr) {\n        arr = []\n        store.set(data.name, arr)\n      }\n      arr.push(data.durationMs)\n      // Bound memory: keep last N entries per namespace\n      if (arr.length > maxEntries) arr.shift()\n    },\n\n    stats(name: string): SpanStats | undefined {\n      const arr = store.get(name)\n      if (!arr || arr.length === 0) return undefined\n      return computeStats(arr)\n    },\n\n    all(): Map<string, SpanStats> {\n      const result = new Map<string, SpanStats>()\n      for (const [name, durations] of store) {\n        if (durations.length > 0) result.set(name, computeStats(durations))\n      }\n      return result\n    },\n\n    summary(): string {\n      const entries = [...this.all().entries()]\n      if (entries.length === 0) return \"(no span data)\"\n      const lines = entries.map(\n        ([name, s]) =>\n          `${name}: ${s.count} spans, mean=${s.mean.toFixed(1)}ms, p50=${s.p50.toFixed(1)}ms, p95=${s.p95.toFixed(1)}ms, p99=${s.p99.toFixed(1)}ms`,\n      )\n      return lines.join(\"\\n\")\n    },\n\n    reset(): void {\n      store.clear()\n    },\n  }\n}\n\n// ============ Ambient Collector ============\n\nconst _ambient = createMetricsCollector()\n\n// Auto-activate ambient recording.\n// Always set — the cost is one ?.recordSpan() call per span (negligible).\n// The TRACE gate already controls whether spans are *created* at all.\n_setAmbientRecorder(_ambient)\n\n/** Get aggregated span stats (from ambient collector). */\nexport function spanStats(): Map<string, SpanStats> {\n  return _ambient.all()\n}\n\n/** Get the ambient collector's formatted summary. */\nexport function spanSummary(): string {\n  return _ambient.summary()\n}\n\n/** Reset the ambient collector. */\nexport function resetSpanStats(): void {\n  _ambient.reset()\n}\n\n// ============ withMetrics ============\n\n/**\n * Compose a logger with a metrics collector.\n * Returns a curried wrapper: `withMetrics(collector?)(logger)`\n *\n * - No arg: uses the built-in ambient collector\n * - Custom collector: records to your collector\n * - Stackable: `withMetrics(a)(withMetrics(b)(logger))` fans out to both\n *\n * @example\n * ```typescript\n * const log = withMetrics()(createLogger(\"myapp\"))\n * const log = withMetrics(myCollector)(createLogger(\"myapp\"))\n * ```\n */\nexport function withMetrics(collector?: SpanRecorder): (logger: ConditionalLogger) => ConditionalLogger {\n  const recorder = collector ?? _ambient\n\n  return (logger: ConditionalLogger): ConditionalLogger => {\n    // Wrap the logger's span method to intercept disposal\n    return new Proxy(logger, {\n      get(target, prop: string | symbol) {\n        if (prop === \"span\") {\n          const originalSpan = target.span\n          if (!originalSpan) return undefined // TRACE off — preserve ?.  behavior\n          return (namespace?: string, props?: LazyProps): SpanLogger => {\n            const span = originalSpan.call(target, namespace, props)\n            // Wrap disposal to record to our collector\n            const originalDispose = (span as unknown as { [Symbol.dispose]: () => void })[Symbol.dispose]\n            ;(span as unknown as { [Symbol.dispose]: () => void })[Symbol.dispose] = () => {\n              originalDispose.call(span)\n              // After original disposal computed duration, record it\n              if (span.spanData?.duration != null) {\n                recorder.recordSpan({ name: span.name, durationMs: span.spanData.duration })\n              }\n            }\n            return span\n          }\n        }\n        if (prop === \"logger\") {\n          // Child loggers inherit the metrics wrapper\n          return (namespace?: string, childProps?: Record<string, unknown>): Logger => {\n            const child = target.logger(namespace, childProps)\n            // Re-wrap the child — withMetrics(recorder) applied recursively\n            return withMetrics(recorder)(child as unknown as ConditionalLogger) as unknown as Logger\n          }\n        }\n        return (target as unknown as Record<string | symbol, unknown>)[prop]\n      },\n    })\n  }\n}\n"],"mappings":"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"}
+{"version":3,"file":"metrics.mjs","names":[],"sources":["../src/metrics.ts"],"sourcesContent":["/**\n * Metrics collection for loggily spans.\n *\n * Explicit only: `withMetrics(collector)(logger)` for custom collection.\n *\n * @example\n * ```typescript\n * import { withMetrics, createMetricsCollector } from \"loggily/metrics\"\n * const collector = createMetricsCollector()\n * const log = withMetrics(collector)(createLogger(\"myapp\"))\n * ```\n */\n\nimport {\n  type SpanRecorder,\n  type SpanRecord,\n  type ConditionalLogger,\n  type Logger,\n  type LazyProps,\n  type SpanLogger,\n} from \"./core.js\"\n\nexport type { SpanRecorder, SpanRecord }\n\n// ============ Stats ============\n\nexport interface SpanStats {\n  count: number\n  min: number\n  max: number\n  mean: number\n  p50: number\n  p95: number\n  p99: number\n  total: number\n}\n\nfunction percentile(sorted: number[], p: number): number {\n  if (sorted.length === 0) return 0\n  const idx = Math.min(Math.floor(sorted.length * p), sorted.length - 1)\n  return sorted[idx]!\n}\n\nfunction computeStats(durations: number[]): SpanStats {\n  const sorted = [...durations].sort((a, b) => a - b)\n  const total = sorted.reduce((sum, d) => sum + d, 0)\n  return {\n    count: sorted.length,\n    min: sorted[0] ?? 0,\n    max: sorted[sorted.length - 1] ?? 0,\n    mean: sorted.length > 0 ? total / sorted.length : 0,\n    p50: percentile(sorted, 0.5),\n    p95: percentile(sorted, 0.95),\n    p99: percentile(sorted, 0.99),\n    total,\n  }\n}\n\n// ============ Collector ============\n\nexport interface MetricsCollector extends SpanRecorder {\n  /** Get stats for a specific span namespace */\n  stats(name: string): SpanStats | undefined\n  /** Get stats for all recorded namespaces */\n  all(): Map<string, SpanStats>\n  /** Format a human-readable summary */\n  summary(): string\n  /** Reset all collected data */\n  reset(): void\n}\n\nexport function createMetricsCollector(maxEntries = 1000): MetricsCollector {\n  const store = new Map<string, number[]>()\n\n  return {\n    recordSpan(data: SpanRecord): void {\n      let arr = store.get(data.name)\n      if (!arr) {\n        arr = []\n        store.set(data.name, arr)\n      }\n      arr.push(data.durationMs)\n      // Bound memory: keep last N entries per namespace\n      if (arr.length > maxEntries) arr.shift()\n    },\n\n    stats(name: string): SpanStats | undefined {\n      const arr = store.get(name)\n      if (!arr || arr.length === 0) return undefined\n      return computeStats(arr)\n    },\n\n    all(): Map<string, SpanStats> {\n      const result = new Map<string, SpanStats>()\n      for (const [name, durations] of store) {\n        if (durations.length > 0) result.set(name, computeStats(durations))\n      }\n      return result\n    },\n\n    summary(): string {\n      const entries = [...this.all().entries()]\n      if (entries.length === 0) return \"(no span data)\"\n      const lines = entries.map(\n        ([name, s]) =>\n          `${name}: ${s.count} spans, mean=${s.mean.toFixed(1)}ms, p50=${s.p50.toFixed(1)}ms, p95=${s.p95.toFixed(1)}ms, p99=${s.p99.toFixed(1)}ms`,\n      )\n      return lines.join(\"\\n\")\n    },\n\n    reset(): void {\n      store.clear()\n    },\n  }\n}\n\n// ============ withMetrics ============\n\n/**\n * Compose a logger with a metrics collector.\n * Returns a curried wrapper: `withMetrics(collector)(logger)`\n *\n * Records span duration to the provided collector on span disposal.\n * Stackable: `withMetrics(a)(withMetrics(b)(logger))` fans out to both.\n *\n * @example\n * ```typescript\n * const collector = createMetricsCollector()\n * const log = withMetrics(collector)(createLogger(\"myapp\"))\n * ```\n */\nexport function withMetrics(collector: SpanRecorder): (logger: ConditionalLogger) => ConditionalLogger {\n  return (logger: ConditionalLogger): ConditionalLogger => {\n    // Wrap the logger's span method to intercept disposal\n    return new Proxy(logger, {\n      get(target, prop: string | symbol) {\n        if (prop === \"metrics\") {\n          return collector\n        }\n        if (prop === \"span\") {\n          const originalSpan = target.span\n          if (!originalSpan) return undefined // TRACE off — preserve ?.  behavior\n          return (namespace?: string, props?: LazyProps): SpanLogger => {\n            const span = originalSpan.call(target, namespace, props)\n            // Wrap disposal to record to our collector\n            const originalDispose = (span as unknown as { [Symbol.dispose]: () => void })[Symbol.dispose]\n            ;(span as unknown as { [Symbol.dispose]: () => void })[Symbol.dispose] = () => {\n              originalDispose.call(span)\n              // After original disposal computed duration, record it\n              if (span.spanData?.duration != null) {\n                collector.recordSpan({ name: span.name, durationMs: span.spanData.duration })\n              }\n            }\n            return span\n          }\n        }\n        if (prop === \"child\") {\n          return (\n            namespaceOrContext?: string | Record<string, unknown>,\n            childProps?: Record<string, unknown>,\n          ): ConditionalLogger => {\n            const child = target.child(namespaceOrContext as string, childProps)\n            return withMetrics(collector)(child)\n          }\n        }\n        if (prop === \"logger\") {\n          // Child loggers inherit the metrics wrapper\n          return (namespace?: string, childProps?: Record<string, unknown>): Logger => {\n            const child = target.logger(namespace, childProps)\n            // Re-wrap the child — withMetrics(collector) applied recursively\n            return withMetrics(collector)(child as unknown as ConditionalLogger) as unknown as Logger\n          }\n        }\n        return (target as unknown as Record<string | symbol, unknown>)[prop]\n      },\n    })\n  }\n}\n"],"mappings":";AAqCA,SAAS,WAAW,QAAkB,GAAmB;AACvD,KAAI,OAAO,WAAW,EAAG,QAAO;AAEhC,QAAO,OADK,KAAK,IAAI,KAAK,MAAM,OAAO,SAAS,EAAE,EAAE,OAAO,SAAS,EAAE;;AAIxE,SAAS,aAAa,WAAgC;CACpD,MAAM,SAAS,CAAC,GAAG,UAAU,CAAC,MAAM,GAAG,MAAM,IAAI,EAAE;CACnD,MAAM,QAAQ,OAAO,QAAQ,KAAK,MAAM,MAAM,GAAG,EAAE;AACnD,QAAO;EACL,OAAO,OAAO;EACd,KAAK,OAAO,MAAM;EAClB,KAAK,OAAO,OAAO,SAAS,MAAM;EAClC,MAAM,OAAO,SAAS,IAAI,QAAQ,OAAO,SAAS;EAClD,KAAK,WAAW,QAAQ,GAAI;EAC5B,KAAK,WAAW,QAAQ,IAAK;EAC7B,KAAK,WAAW,QAAQ,IAAK;EAC7B;EACD;;AAgBH,SAAgB,uBAAuB,aAAa,KAAwB;CAC1E,MAAM,wBAAQ,IAAI,KAAuB;AAEzC,QAAO;EACL,WAAW,MAAwB;GACjC,IAAI,MAAM,MAAM,IAAI,KAAK,KAAK;AAC9B,OAAI,CAAC,KAAK;AACR,UAAM,EAAE;AACR,UAAM,IAAI,KAAK,MAAM,IAAI;;AAE3B,OAAI,KAAK,KAAK,WAAW;AAEzB,OAAI,IAAI,SAAS,WAAY,KAAI,OAAO;;EAG1C,MAAM,MAAqC;GACzC,MAAM,MAAM,MAAM,IAAI,KAAK;AAC3B,OAAI,CAAC,OAAO,IAAI,WAAW,EAAG,QAAO,KAAA;AACrC,UAAO,aAAa,IAAI;;EAG1B,MAA8B;GAC5B,MAAM,yBAAS,IAAI,KAAwB;AAC3C,QAAK,MAAM,CAAC,MAAM,cAAc,MAC9B,KAAI,UAAU,SAAS,EAAG,QAAO,IAAI,MAAM,aAAa,UAAU,CAAC;AAErE,UAAO;;EAGT,UAAkB;GAChB,MAAM,UAAU,CAAC,GAAG,KAAK,KAAK,CAAC,SAAS,CAAC;AACzC,OAAI,QAAQ,WAAW,EAAG,QAAO;AAKjC,UAJc,QAAQ,KACnB,CAAC,MAAM,OACN,GAAG,KAAK,IAAI,EAAE,MAAM,eAAe,EAAE,KAAK,QAAQ,EAAE,CAAC,UAAU,EAAE,IAAI,QAAQ,EAAE,CAAC,UAAU,EAAE,IAAI,QAAQ,EAAE,CAAC,UAAU,EAAE,IAAI,QAAQ,EAAE,CAAC,IACzI,CACY,KAAK,KAAK;;EAGzB,QAAc;AACZ,SAAM,OAAO;;EAEhB;;;;;;;;;;;;;;;AAkBH,SAAgB,YAAY,WAA2E;AACrG,SAAQ,WAAiD;AAEvD,SAAO,IAAI,MAAM,QAAQ,EACvB,IAAI,QAAQ,MAAuB;AACjC,OAAI,SAAS,UACX,QAAO;AAET,OAAI,SAAS,QAAQ;IACnB,MAAM,eAAe,OAAO;AAC5B,QAAI,CAAC,aAAc,QAAO,KAAA;AAC1B,YAAQ,WAAoB,UAAkC;KAC5D,MAAM,OAAO,aAAa,KAAK,QAAQ,WAAW,MAAM;KAExD,MAAM,kBAAmB,KAAqD,OAAO;AACnF,UAAqD,OAAO,iBAAiB;AAC7E,sBAAgB,KAAK,KAAK;AAE1B,UAAI,KAAK,UAAU,YAAY,KAC7B,WAAU,WAAW;OAAE,MAAM,KAAK;OAAM,YAAY,KAAK,SAAS;OAAU,CAAC;;AAGjF,YAAO;;;AAGX,OAAI,SAAS,QACX,SACE,oBACA,eACsB;IACtB,MAAM,QAAQ,OAAO,MAAM,oBAA8B,WAAW;AACpE,WAAO,YAAY,UAAU,CAAC,MAAM;;AAGxC,OAAI,SAAS,SAEX,SAAQ,WAAoB,eAAiD;IAC3E,MAAM,QAAQ,OAAO,OAAO,WAAW,WAAW;AAElD,WAAO,YAAY,UAAU,CAAC,MAAsC;;AAGxE,UAAQ,OAAuD;KAElE,CAAC"}

package/dist/otel.d.mts

@@ -0,0 +1,63 @@
+import { f as Stage } from "./pipeline-Cl9-wCmt.mjs";
+
+//#region src/otel.d.ts
+interface OtelApi {
+  logs?: {
+    getLoggerProvider(): {
+      getLogger(name: string): {
+        emit(record: {
+          severityNumber: number;
+          severityText: string;
+          body: string;
+          attributes: Record<string, unknown>;
+          timestamp: number[];
+        }): void;
+      };
+    };
+  };
+  trace?: {
+    getTracerProvider(): {
+      getTracer(name: string): {
+        startSpan(name: string, options?: {
+          startTime: number[];
+          attributes: Record<string, unknown>;
+        }): {
+          end(endTime?: number[]): void;
+          setAttribute(key: string, value: unknown): void;
+          setStatus(status: {
+            code: number;
+            message?: string;
+          }): void;
+        };
+      };
+    };
+  };
+}
+interface OtelBridgeOptions {
+  /** The @opentelemetry/api module. Pass the import to avoid require() in ESM. */
+  api?: OtelApi;
+  /** Logger name for OTLP LogRecords (default: "loggily") */
+  loggerName?: string;
+  /** Tracer name for OTLP Spans (default: "loggily") */
+  tracerName?: string;
+  /** Whether to forward log events (default: true) */
+  logs?: boolean;
+  /** Whether to forward span events (default: true) */
+  spans?: boolean;
+}
+/**
+ * Create a Stage that forwards loggily events to OpenTelemetry.
+ *
+ * Pass the @opentelemetry/api module via options.api:
+ *
+ * ```ts
+ * import * as otelApi from "@opentelemetry/api"
+ * const log = createLogger("myapp", [toOtel({ api: otelApi }), console])
+ * ```
+ *
+ * Events pass through unchanged (the stage is transparent).
+ */
+declare function toOtel(options?: OtelBridgeOptions): Stage;
+//#endregion
+export { OtelBridgeOptions, toOtel };
+//# sourceMappingURL=otel.d.mts.map

package/dist/otel.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"otel.d.mts","names":[],"sources":["../src/otel.ts"],"mappings":";;;UAeU,OAAA;EACR,IAAA;IACE,iBAAA;MACE,SAAA,CAAU,IAAA;QACR,IAAA,CAAK,MAAA;UACH,cAAA;UACA,YAAA;UACA,IAAA;UACA,UAAA,EAAY,MAAA;UACZ,SAAA;QAAA;MAAA;IAAA;EAAA;EAKR,KAAA;IACE,iBAAA;MACE,SAAA,CAAU,IAAA;QACR,SAAA,CACE,IAAA,UACA,OAAA;UACE,SAAA;UACA,UAAA,EAAY,MAAA;QAAA;UAGd,GAAA,CAAI,OAAA;UACJ,YAAA,CAAa,GAAA,UAAa,KAAA;UAC1B,SAAA,CAAU,MAAA;YAAU,IAAA;YAAc,OAAA;UAAA;QAAA;MAAA;IAAA;EAAA;AAAA;AAAA,UAqB3B,iBAAA;EAET;EAAN,GAAA,GAAM,OAAA;EAIN;EAFA,UAAA;EAMA;EAJA,UAAA;EAIK;EAFL,IAAA;EAiBoB;EAfpB,KAAA;AAAA;;;;;;;;;;;;;iBAec,MAAA,CAAO,OAAA,GAAS,iBAAA,GAAyB,KAAA"}

package/dist/otel.mjs

@@ -0,0 +1,82 @@
+//#region src/otel.ts
+const SEVERITY_MAP = {
+	trace: {
+		number: 1,
+		text: "TRACE"
+	},
+	debug: {
+		number: 5,
+		text: "DEBUG"
+	},
+	info: {
+		number: 9,
+		text: "INFO"
+	},
+	warn: {
+		number: 13,
+		text: "WARN"
+	},
+	error: {
+		number: 17,
+		text: "ERROR"
+	}
+};
+function msToHrTime(ms) {
+	return [Math.floor(ms / 1e3), ms % 1e3 * 1e6];
+}
+/**
+* Create a Stage that forwards loggily events to OpenTelemetry.
+*
+* Pass the @opentelemetry/api module via options.api:
+*
+* ```ts
+* import * as otelApi from "@opentelemetry/api"
+* const log = createLogger("myapp", [toOtel({ api: otelApi }), console])
+* ```
+*
+* Events pass through unchanged (the stage is transparent).
+*/
+function toOtel(options = {}) {
+	const { api: otelApi = null, loggerName = "loggily", tracerName = "loggily", logs: forwardLogs = true, spans: forwardSpans = true } = options;
+	function forwardLog(event) {
+		const logsApi = otelApi?.logs;
+		if (!logsApi) return;
+		const severity = SEVERITY_MAP[event.level] ?? SEVERITY_MAP.info;
+		logsApi.getLoggerProvider().getLogger(loggerName).emit({
+			severityNumber: severity.number,
+			severityText: severity.text,
+			body: event.message,
+			attributes: {
+				"loggily.namespace": event.namespace,
+				...event.props
+			},
+			timestamp: msToHrTime(event.time)
+		});
+	}
+	function forwardSpan(event) {
+		const traceApi = otelApi?.trace;
+		if (!traceApi) return;
+		const tracer = traceApi.getTracerProvider().getTracer(tracerName);
+		const startTime = msToHrTime(event.time - event.duration);
+		const span = tracer.startSpan(event.name, {
+			startTime,
+			attributes: {
+				"loggily.namespace": event.namespace,
+				"loggily.span_id": event.spanId,
+				"loggily.trace_id": event.traceId,
+				...event.props
+			}
+		});
+		if (event.parentId) span.setAttribute("loggily.parent_id", event.parentId);
+		span.end(msToHrTime(event.time));
+	}
+	return (event) => {
+		if (forwardLogs && event.kind === "log") forwardLog(event);
+		if (forwardSpans && event.kind === "span") forwardSpan(event);
+		return event;
+	};
+}
+//#endregion
+export { toOtel };
+
+//# sourceMappingURL=otel.mjs.map

package/dist/otel.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"otel.mjs","names":[],"sources":["../src/otel.ts"],"sourcesContent":["/**\n * loggily/otel — OpenTelemetry bridge\n *\n * Maps loggily LogEvent/SpanEvent to OpenTelemetry SDK calls.\n * Requires @opentelemetry/api as a peer dependency.\n *\n * Usage:\n *   import * as otelApi from \"@opentelemetry/api\"\n *   import { toOtel } from \"loggily/otel\"\n *   const log = createLogger(\"myapp\", [toOtel({ api: otelApi }), console])\n */\n\nimport type { Event, LogEvent, SpanEvent, Stage } from \"./pipeline.js\"\n\n// OpenTelemetry API types (peer dep — imported at runtime)\ninterface OtelApi {\n  logs?: {\n    getLoggerProvider(): {\n      getLogger(name: string): {\n        emit(record: {\n          severityNumber: number\n          severityText: string\n          body: string\n          attributes: Record<string, unknown>\n          timestamp: number[]\n        }): void\n      }\n    }\n  }\n  trace?: {\n    getTracerProvider(): {\n      getTracer(name: string): {\n        startSpan(\n          name: string,\n          options?: {\n            startTime: number[]\n            attributes: Record<string, unknown>\n          },\n        ): {\n          end(endTime?: number[]): void\n          setAttribute(key: string, value: unknown): void\n          setStatus(status: { code: number; message?: string }): void\n        }\n      }\n    }\n  }\n}\n\nconst SEVERITY_MAP: Record<string, { number: number; text: string }> = {\n  trace: { number: 1, text: \"TRACE\" },\n  debug: { number: 5, text: \"DEBUG\" },\n  info: { number: 9, text: \"INFO\" },\n  warn: { number: 13, text: \"WARN\" },\n  error: { number: 17, text: \"ERROR\" },\n}\n\nfunction msToHrTime(ms: number): [number, number] {\n  const seconds = Math.floor(ms / 1000)\n  const nanos = (ms % 1000) * 1_000_000\n  return [seconds, nanos]\n}\n\nexport interface OtelBridgeOptions {\n  /** The @opentelemetry/api module. Pass the import to avoid require() in ESM. */\n  api?: OtelApi\n  /** Logger name for OTLP LogRecords (default: \"loggily\") */\n  loggerName?: string\n  /** Tracer name for OTLP Spans (default: \"loggily\") */\n  tracerName?: string\n  /** Whether to forward log events (default: true) */\n  logs?: boolean\n  /** Whether to forward span events (default: true) */\n  spans?: boolean\n}\n\n/**\n * Create a Stage that forwards loggily events to OpenTelemetry.\n *\n * Pass the @opentelemetry/api module via options.api:\n *\n * ```ts\n * import * as otelApi from \"@opentelemetry/api\"\n * const log = createLogger(\"myapp\", [toOtel({ api: otelApi }), console])\n * ```\n *\n * Events pass through unchanged (the stage is transparent).\n */\nexport function toOtel(options: OtelBridgeOptions = {}): Stage {\n  const {\n    api: otelApi = null,\n    loggerName = \"loggily\",\n    tracerName = \"loggily\",\n    logs: forwardLogs = true,\n    spans: forwardSpans = true,\n  } = options\n\n  function forwardLog(event: LogEvent): void {\n    const logsApi = otelApi?.logs\n    if (!logsApi) return\n\n    const severity = SEVERITY_MAP[event.level] ?? SEVERITY_MAP.info!\n    const logger = logsApi.getLoggerProvider().getLogger(loggerName)\n    logger.emit({\n      severityNumber: severity.number,\n      severityText: severity.text,\n      body: event.message,\n      attributes: {\n        \"loggily.namespace\": event.namespace,\n        ...event.props,\n      },\n      timestamp: msToHrTime(event.time),\n    })\n  }\n\n  function forwardSpan(event: SpanEvent): void {\n    const traceApi = otelApi?.trace\n    if (!traceApi) return\n\n    const tracer = traceApi.getTracerProvider().getTracer(tracerName)\n    const startTime = msToHrTime(event.time - event.duration)\n    const span = tracer.startSpan(event.name, {\n      startTime,\n      attributes: {\n        \"loggily.namespace\": event.namespace,\n        \"loggily.span_id\": event.spanId,\n        \"loggily.trace_id\": event.traceId,\n        ...event.props,\n      },\n    })\n    if (event.parentId) {\n      span.setAttribute(\"loggily.parent_id\", event.parentId)\n    }\n    span.end(msToHrTime(event.time))\n  }\n\n  return (event: Event): Event => {\n    if (forwardLogs && event.kind === \"log\") forwardLog(event)\n    if (forwardSpans && event.kind === \"span\") forwardSpan(event)\n    return event // transparent — pass through\n  }\n}\n"],"mappings":";AAgDA,MAAM,eAAiE;CACrE,OAAO;EAAE,QAAQ;EAAG,MAAM;EAAS;CACnC,OAAO;EAAE,QAAQ;EAAG,MAAM;EAAS;CACnC,MAAM;EAAE,QAAQ;EAAG,MAAM;EAAQ;CACjC,MAAM;EAAE,QAAQ;EAAI,MAAM;EAAQ;CAClC,OAAO;EAAE,QAAQ;EAAI,MAAM;EAAS;CACrC;AAED,SAAS,WAAW,IAA8B;AAGhD,QAAO,CAFS,KAAK,MAAM,KAAK,IAAK,EACtB,KAAK,MAAQ,IACL;;;;;;;;;;;;;;AA4BzB,SAAgB,OAAO,UAA6B,EAAE,EAAS;CAC7D,MAAM,EACJ,KAAK,UAAU,MACf,aAAa,WACb,aAAa,WACb,MAAM,cAAc,MACpB,OAAO,eAAe,SACpB;CAEJ,SAAS,WAAW,OAAuB;EACzC,MAAM,UAAU,SAAS;AACzB,MAAI,CAAC,QAAS;EAEd,MAAM,WAAW,aAAa,MAAM,UAAU,aAAa;AAC5C,UAAQ,mBAAmB,CAAC,UAAU,WAAW,CACzD,KAAK;GACV,gBAAgB,SAAS;GACzB,cAAc,SAAS;GACvB,MAAM,MAAM;GACZ,YAAY;IACV,qBAAqB,MAAM;IAC3B,GAAG,MAAM;IACV;GACD,WAAW,WAAW,MAAM,KAAK;GAClC,CAAC;;CAGJ,SAAS,YAAY,OAAwB;EAC3C,MAAM,WAAW,SAAS;AAC1B,MAAI,CAAC,SAAU;EAEf,MAAM,SAAS,SAAS,mBAAmB,CAAC,UAAU,WAAW;EACjE,MAAM,YAAY,WAAW,MAAM,OAAO,MAAM,SAAS;EACzD,MAAM,OAAO,OAAO,UAAU,MAAM,MAAM;GACxC;GACA,YAAY;IACV,qBAAqB,MAAM;IAC3B,mBAAmB,MAAM;IACzB,oBAAoB,MAAM;IAC1B,GAAG,MAAM;IACV;GACF,CAAC;AACF,MAAI,MAAM,SACR,MAAK,aAAa,qBAAqB,MAAM,SAAS;AAExD,OAAK,IAAI,WAAW,MAAM,KAAK,CAAC;;AAGlC,SAAQ,UAAwB;AAC9B,MAAI,eAAe,MAAM,SAAS,MAAO,YAAW,MAAM;AAC1D,MAAI,gBAAgB,MAAM,SAAS,OAAQ,aAAY,MAAM;AAC7D,SAAO"}

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

@@ -0,0 +1,73 @@
+//#region src/pipeline.d.ts
+type OutputLogLevel = "trace" | "debug" | "info" | "warn" | "error";
+type LogLevel = OutputLogLevel | "silent";
+type LogFormat = "console" | "json";
+type LogEvent = {
+  kind: "log";
+  time: number;
+  namespace: string;
+  level: OutputLogLevel;
+  message: string;
+  props?: Record<string, unknown>;
+};
+type SpanEvent = {
+  kind: "span";
+  time: number;
+  namespace: string;
+  name: string;
+  duration: number;
+  props?: Record<string, unknown>;
+  spanId: string;
+  traceId: string;
+  parentId: string | null;
+};
+type Event = LogEvent | SpanEvent;
+type Stage = (event: Event) => Event | null | void;
+declare const LOG_LEVEL_PRIORITY: Record<LogLevel, number>;
+/** Serialize Error.cause chains up to a max depth */
+declare function serializeCause(cause: unknown, maxDepth?: number): unknown;
+declare function safeStringify(value: unknown): string;
+type NsFilter = (namespace: string) => boolean;
+interface Pipeline {
+  dispatch: (event: Event) => void;
+  level: LogLevel;
+  dispose: () => void;
+}
+/** A writable sink — any object with a write method. Receives raw Event objects by default. */
+interface Writable {
+  write: (data: any) => any;
+  /** Set to false to receive formatted strings instead of raw Event objects (default: true) */
+  objectMode?: boolean;
+}
+/** Config keys that set scope for subsequent siblings */
+interface ConfigObject {
+  level?: LogLevel;
+  ns?: string | string[];
+  format?: LogFormat;
+  spans?: boolean;
+  /** Enable per-logger metrics collection. Creates a MetricsCollector accessible via `log.metrics`. */
+  metrics?: boolean;
+  /** ID format for trace/span IDs: "simple" (default) or "w3c" (W3C Trace Context) */
+  idFormat?: "simple" | "w3c";
+  /** Head-based sampling rate for new traces: 0.0 (none) to 1.0 (all, default) */
+  sampleRate?: number;
+}
+/** File output descriptor */
+interface FileDescriptor extends ConfigObject {
+  file: string;
+}
+/** OTEL output descriptor (Phase 4) */
+interface OtelDescriptor extends ConfigObject {
+  otel: Record<string, unknown>;
+}
+/** A single element in a createLogger config array */
+type ConfigElement = ConfigObject | FileDescriptor | OtelDescriptor | Console | "console" | "stderr" | Stage | Writable | ConfigElement[];
+interface ScopeConfig {
+  level: LogLevel;
+  ns: NsFilter | null;
+  format: LogFormat;
+}
+declare function buildPipeline(elements: ConfigElement[], parentConfig?: Partial<ScopeConfig>): Pipeline;
+//#endregion
+export { LOG_LEVEL_PRIORITY as a, LogLevel as c, SpanEvent as d, Stage as f, serializeCause as g, safeStringify as h, FileDescriptor as i, OutputLogLevel as l, buildPipeline as m, ConfigObject as n, LogEvent as o, Writable as p, Event as r, LogFormat as s, ConfigElement as t, Pipeline as u };
+//# sourceMappingURL=pipeline-Cl9-wCmt.d.mts.map

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

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

package/dist/worker.d.mts

@@ -1,4 +1,5 @@
-import { i as Logger } from "./core-DAFH-huv.mjs";
+import { t as ConditionalLogger } from "./core-Dm2PQUoS.mjs";
+import { d as SpanEvent, f as Stage, o as LogEvent, r as Event } from "./pipeline-Cl9-wCmt.mjs";
 
 //#region src/worker.d.ts
 /** Message sent from worker to main thread for console output */
@@ -9,59 +10,29 @@ interface WorkerConsoleMessage {
   args: unknown[];
   timestamp: number;
 }
-/** Message sent from worker to main thread for structured log output */
-interface WorkerLogMessage {
-  type: "log";
-  level: "trace" | "debug" | "info" | "warn" | "error";
-  namespace: string;
-  message: string;
-  data?: Record<string, unknown>;
-  timestamp: number;
-}
-/** Message sent from worker to main thread for span events */
-interface WorkerSpanMessage {
-  type: "span";
-  event: "start" | "end";
-  namespace: string;
-  spanId: string;
-  traceId: string;
-  parentId: string | null;
-  startTime: number;
-  endTime?: number;
-  duration?: number;
-  props: Record<string, unknown>;
-  spanData: Record<string, unknown>;
-  timestamp: number;
-}
-/** Union type for all worker messages */
-type WorkerMessage = WorkerConsoleMessage | WorkerLogMessage | WorkerSpanMessage;
+/** Type guard for LogEvent (structured log from worker) */
+declare function isWorkerLogEvent(msg: unknown): msg is LogEvent;
+/** Type guard for SpanEvent (span from worker) */
+declare function isWorkerSpanEvent(msg: unknown): msg is SpanEvent;
+/** Type guard for any pipeline Event (log or span) */
+declare function isWorkerEvent(msg: unknown): msg is Event;
 /** Type guard for WorkerConsoleMessage */
 declare function isWorkerConsoleMessage(msg: unknown): msg is WorkerConsoleMessage;
-/** Type guard for WorkerLogMessage */
-declare function isWorkerLogMessage(msg: unknown): msg is WorkerLogMessage;
-/** Type guard for WorkerSpanMessage */
-declare function isWorkerSpanMessage(msg: unknown): msg is WorkerSpanMessage;
-/** Type guard for any worker message */
-declare function isWorkerMessage(msg: unknown): msg is WorkerMessage;
+/** Type guard for any worker message (console or pipeline event) */
+declare function isWorkerMessage(msg: unknown): msg is WorkerConsoleMessage | Event;
 type PostMessageFn = (message: WorkerConsoleMessage) => void;
 /**
- * Forward console.* calls from worker to main thread.
- *
- * Monkey-patches console methods to send messages via postMessage.
- * Call this at the start of your worker script.
+ * Forward console.* calls from worker to main thread via postMessage.
  *
- * @param postMessage - The worker's postMessage function
- * @param namespace - Optional namespace for log messages (e.g., "km:worker:parse")
+ * Monkey-patches console methods. postMessage uses structuredClone,
+ * which handles most values natively. If cloning fails (functions,
+ * symbols), falls back to original console.
  *
  * @example
  * ```typescript
- * // At top of worker file:
  * import { forwardConsole } from "loggily/worker"
  * forwardConsole(postMessage, "km:worker:parse")
- *
- * // Now all console.* calls are forwarded:
  * console.log("processing", { file: "test.md" })
- * console.error(new Error("failed"))
  * ```
  */
 declare function forwardConsole(postMessage: PostMessageFn, namespace?: string): void;
@@ -70,25 +41,24 @@ declare function forwardConsole(postMessage: PostMessageFn, namespace?: string):
  * Call this if you need to disable console forwarding.
  */
 declare function restoreConsole(): void;
-type PostMessageAnyFn = (message: WorkerMessage) => void;
-/** Reset worker ID counters (for testing) */
-declare function resetWorkerIds(): void;
-interface WorkerLoggerOptions {
-  /** Parent span ID for nested spans */
-  parentSpanId?: string | null;
-  /** Trace ID for distributed tracing */
-  traceId?: string | null;
-}
 /**
- * Create a logger instance for use in a worker thread.
+ * 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.
+ */
+declare function workerTransportStage(postMessage: (msg: unknown) => void): Stage;
+/**
+ * Create a logger for use in a worker thread.
  *
- * All log calls and span events are forwarded to the main thread via postMessage.
- * The main thread should use createWorkerLogHandler to process these messages.
+ * 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
- * @param options - Optional configuration
  *
  * @example
  * ```typescript
@@ -96,22 +66,53 @@ interface WorkerLoggerOptions {
  *
  * const log = createWorkerLogger(postMessage, "km:worker:parse")
  *
- * log.info("starting parse", { file: "test.md" })
+ * log.info?.("starting parse", { file: "test.md" })
  *
  * {
- *   using span = log.span("process")
- *   span.info("processing...")
- *   span.spanData.lineCount = 100
+ *   using span = log.span?.("process")
+ *   span.info?.("processing...")
+ *   span.spanData.count = 100
  * }
  * // Span end event automatically sent to main thread
  * ```
  */
-declare function createWorkerLogger(postMessage: PostMessageAnyFn, namespace: string, props?: Record<string, unknown>, options?: WorkerLoggerOptions): Logger;
+declare function createWorkerLogger(postMessage: (msg: unknown) => void, namespace: string, props?: Record<string, unknown>): ConditionalLogger;
+/**
+ * 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
+ */
+declare function handleWorkerEvents(target: ConditionalLogger | {
+  dispatch(event: Event): void;
+}): (msg: unknown) => void;
+/**
+ * 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)
+ * ```
+ */
+declare function createWorkerLogHandler(): (message: unknown) => void;
 interface WorkerConsoleHandlerOptions {
   /** Default namespace if message doesn't include one */
   defaultNamespace?: string;
   /** Custom logger to use (defaults to creating one with the namespace) */
-  logger?: Logger;
+  logger?: {
+    name: string;
+    dispatch(event: Event): void;
+  };
 }
 /**
  * Create a handler for worker console messages.
@@ -132,42 +133,11 @@ interface WorkerConsoleHandlerOptions {
  * worker.onmessage = (e) => {
  *   if (e.data.type === "console") {
  *     handleConsole(e.data)
- *   } else {
- *     // Handle other message types
  *   }
  * }
  * ```
  */
 declare function createWorkerConsoleHandler(options?: WorkerConsoleHandlerOptions): (message: WorkerConsoleMessage) => void;
-interface WorkerLogHandlerOptions {
-  /** @deprecated Span output is now controlled by TRACE env var */
-  enableSpans?: boolean;
-}
-/**
- * Create a handler for worker logger messages (logs and spans).
- *
- * Use this on the main thread to receive and output messages from workers
- * that use createWorkerLogger.
- *
- * @param options - Handler options
- * @returns Handler function to call with worker messages
- *
- * @example
- * ```typescript
- * import { createWorkerLogHandler, isWorkerMessage } from "loggily/worker"
- *
- * const handleLog = createWorkerLogHandler()
- *
- * worker.onmessage = (e) => {
- *   if (isWorkerMessage(e.data)) {
- *     handleLog(e.data)
- *   } else {
- *     // Handle other message types
- *   }
- * }
- * ```
- */
-declare function createWorkerLogHandler(options?: WorkerLogHandlerOptions): (message: WorkerMessage) => void;
 //#endregion
-export { WorkerConsoleHandlerOptions, WorkerConsoleMessage, WorkerLogHandlerOptions, WorkerLogMessage, WorkerMessage, WorkerSpanMessage, createWorkerConsoleHandler, createWorkerLogHandler, createWorkerLogger, forwardConsole, isWorkerConsoleMessage, isWorkerLogMessage, isWorkerMessage, isWorkerSpanMessage, resetWorkerIds, restoreConsole };
+export { WorkerConsoleHandlerOptions, WorkerConsoleMessage, createWorkerConsoleHandler, createWorkerLogHandler, createWorkerLogger, forwardConsole, handleWorkerEvents, isWorkerConsoleMessage, isWorkerEvent, isWorkerLogEvent, isWorkerMessage, isWorkerSpanEvent, restoreConsole, workerTransportStage };
 //# sourceMappingURL=worker.d.mts.map