loggily 0.6.2 → 0.7.0

package/README.md

@@ -2,21 +2,21 @@
 
 **Clarity without the clutter.**
 
-Debugs, logs, and spans — one API.
+Debugs, logs, and spans -- one API.
 
 [![Tests](https://github.com/beorn/loggily/actions/workflows/test.yml/badge.svg)](https://github.com/beorn/loggily/actions/workflows/test.yml)
 [![npm version](https://img.shields.io/npm/v/loggily.svg)](https://www.npmjs.com/package/loggily)
 [![size](https://img.shields.io/bundlephobia/minzip/loggily)](https://bundlephobia.com/package/loggily)
 [![MIT License](https://img.shields.io/badge/license-MIT-green.svg)](LICENSE)
 
-Most apps end up with three logging tools: `debug` for local troubleshooting, a JSON logger like Pino for production, and ad-hoc timers or a tracing SDK for performance. Three APIs, three configs, three output formats.
+Most apps end up with three logging tools: `debug` for local troubleshooting, a JSON logger for production, and ad-hoc timers or a tracing SDK for performance. Three APIs, three configs, three output formats.
 
 Loggily replaces all three with one namespace tree and one output pipeline. Pure TypeScript, zero dependencies, ~3 KB.
 
 ```typescript
 import { createLogger } from "loggily"
 
-const log = createLogger("myapp")
+const log = createLogger("myapp", [{ level: "debug" }, console])
 
 log.info?.("server started", { port: 3000 })
 log.debug?.("cache hit", { key: "user:42" })
@@ -63,26 +63,42 @@ In benchmarks with expensive disabled log arguments, this is [~22x faster](https
 npm install loggily
 ```
 
-| Requirement | Version |
-|---|---|
-| Node.js | >= 23.6 |
-| Bun | 1.0+ |
-| TypeScript | 5.2+ for `using`; `.end()` works on any version |
-| Module format | ESM-only |
-| Browser | Supported via conditional export |
+| Requirement   | Version                                         |
+| ------------- | ----------------------------------------------- |
+| Node.js       | >= 23.6                                         |
+| Bun           | 1.0+                                            |
+| TypeScript    | 5.2+ for `using`; `.end()` works on any version |
+| Module format | ESM-only                                        |
+| Browser       | Supported via conditional export                |
 
 Loggily uses `Symbol.dispose` (TC39 Explicit Resource Management) for span cleanup, which requires a modern runtime.
 
 ## Features
 
-- **Namespace hierarchy** — organize logs with `:` separators. `DEBUG=myapp:db` shows only database output, just like the `debug` package.
-- **Lightweight spans** — time any operation with `using span = log.span("name")`. Automatic duration, parent-child tracking, and trace IDs.
-- **Dev & production** — colorized console in development, structured JSON in production. Same code, zero config.
-- **Child context** — `log.child({ requestId })` adds structured fields to every message in the chain.
-- **Automatic async context** — enable `AsyncLocalStorage`-based propagation and every log in a request's async chain inherits trace/span IDs without passing loggers around.
-- **Lazy messages** — `log.debug?.(() => expensiveString())` skips the function entirely when disabled.
-- **File writer** — `addWriter()` + `createFileWriter()` for buffered file output.
-- **Worker threads** — forward logs from workers to the main thread with full type safety.
+- **Config pipeline** -- second arg to `createLogger` is a config array: objects configure (`{ level, ns, format }`), arrays branch, values write. Pass `console` for terminal output, `{ file: "/path" }` for file output, or functions for custom stages.
+- **Namespace hierarchy** -- organize logs with `:` separators. `DEBUG=myapp:db` shows only database output, compatible with the same patterns as the `debug` package.
+- **Lightweight spans** -- time any operation with `using span = log.span("name")`. Automatic duration, parent-child tracking, and trace IDs.
+- **Dev & production** -- colorized console in development, structured JSON in production. Same code, zero config.
+- **Child context** -- `log.child({ requestId })` adds structured fields to every message in the chain.
+- **Automatic async context** -- enable `AsyncLocalStorage`-based propagation and every log in a request's async chain inherits trace/span IDs without passing loggers around.
+- **Lazy messages** -- `log.debug?.(() => expensiveString())` skips the function entirely when disabled.
+- **Error overloads** -- `log.error?.(err)`, `log.error?.(err, "msg")`, and `log.error?.(err, "msg", data)`.
+- **Worker threads** -- forward logs from workers to the main thread with full type safety.
+
+### Config Array
+
+```typescript
+import { createLogger } from "loggily"
+
+// Objects configure, arrays branch, values write
+const log = createLogger("myapp", [
+  { level: "debug", ns: "-sql" },
+  console,
+  { file: "/tmp/app.log", level: "error", format: "json" },
+])
+```
+
+When no config array is provided, loggily reads `LOG_LEVEL`, `DEBUG`, `LOG_FORMAT`, and `NODE_ENV` from the environment.
 
 ### Spans
 
@@ -96,20 +112,46 @@ Loggily uses `Symbol.dispose` (TC39 Explicit Resource Management) for span clean
 
 // Without `using` — call .end() manually
 const span = log.span("db:query")
-try { /* ... */ } finally { span.end() }
+try {
+  /* ... */
+} finally {
+  span.end()
+}
 ```
 
 ### Common configuration
 
-| Variable | Example | Effect |
-|---|---|---|
-| `DEBUG` | `myapp:db,-myapp:sql` | Namespace filter (same syntax as the `debug` package) |
-| `LOG_LEVEL` | `debug`, `info`, `warn` | Minimum output level |
-| `LOG_FORMAT` | `console`, `json` | Override output format |
-| `TRACE` | `1` or namespace prefixes | Enable span output |
+| Variable     | Example                   | Effect                                                 |
+| ------------ | ------------------------- | ------------------------------------------------------ |
+| `DEBUG`      | `myapp:db,-myapp:sql`     | Namespace filter (compatible with the `debug` package) |
+| `LOG_LEVEL`  | `debug`, `info`, `warn`   | Minimum output level                                   |
+| `LOG_FORMAT` | `console`, `json`         | Override output format                                 |
+| `TRACE`      | `1` or namespace prefixes | Enable span output                                     |
 
 See the [full environment variable reference](https://beorn.codes/loggily/api/configuration).
 
+### Types
+
+Key types exported for power users:
+
+| Type                | Description                                                      |
+| ------------------- | ---------------------------------------------------------------- |
+| `LogEvent`          | A log message event (kind, level, namespace, message, props)     |
+| `SpanEvent`         | A span timing event (kind, namespace, duration, spanId, traceId) |
+| `Event`             | `LogEvent \| SpanEvent`                                          |
+| `Stage`             | `(event: Event) => Event \| null \| void`                        |
+| `Pipeline`          | `{ dispatch, level, dispose }`                                   |
+| `ConditionalLogger` | Logger with `?.`-compatible methods                              |
+
+`buildPipeline()` and `defaultPipeline()` are exported for direct pipeline construction.
+
+## Compatibility
+
+- **`DEBUG=` compatible** -- uses the same namespace filter patterns as the `debug` package
+- **Works with Pino transports** -- custom stage functions can forward events to any sink
+- **W3C Trace Context** -- `traceparent()` generates standard trace headers
+- **OpenTelemetry compatible** -- span events include `spanId`, `traceId`, `parentId`
+
 ## Why this exists
 
 Loggily was built while developing a terminal UI where disabled debug logs inside the render loop were eating frame time. No existing logger solved the "disabled calls should cost nothing" problem at the language level, so `?.` became the foundation.
@@ -118,15 +160,15 @@ Loggily was built while developing a terminal UI where disabled debug logs insid
 
 ## When not to use Loggily
 
-- **You need the absolute fastest structured logger with a transport ecosystem.** Use [Pino](https://getpino.io/) for worker-thread transports, custom serializers, and log rotation.
-- **You need distributed tracing with vendor exporters and auto-instrumentation.** Use [OpenTelemetry](https://opentelemetry.io/).
+- **You need worker-thread transport pipelines with log rotation and dozens of plugins.** [Pino](https://getpino.io/) has a mature transport ecosystem for this.
+- **You need distributed tracing with vendor exporters and auto-instrumentation.** [OpenTelemetry](https://opentelemetry.io/) is the industry standard.
 
 ## Documentation
 
-- **[Get Started](https://beorn.codes/loggily/guide/journey)** — progressive guide from first log to full observability
-- **[Full docs site](https://beorn.codes/loggily/)** — guides, API reference, migration guides
-- [Comparison](https://beorn.codes/loggily/guide/comparison) — vs Pino, Winston, Bunyan, debug
-- [Migration from debug](https://beorn.codes/loggily/guide/migration-from-debug) — step-by-step migration guide
+- **[Get Started](https://beorn.codes/loggily/guide/journey)** -- progressive guide from first log to full observability
+- **[Full docs site](https://beorn.codes/loggily/)** -- guides, API reference, migration guides
+- [Comparison](https://beorn.codes/loggily/guide/comparison) -- what Loggily does, compatibility, when to use something else
+- [Migration from debug](https://beorn.codes/loggily/guide/migration-from-debug) -- step-by-step migration guide
 
 ## License
 

package/dist/context.d.mts

@@ -0,0 +1,91 @@
+//#region src/context.d.ts
+/**
+ * AsyncLocalStorage-based context propagation for loggily — Node.js/Bun only.
+ *
+ * Separated from core logger to allow tree-shaking in browser bundles.
+ * When enabled, new spans automatically parent to the current context span,
+ * and writeLog() auto-tags with trace_id/span_id from context.
+ *
+ * @example
+ * ```typescript
+ * import { enableContextPropagation, getCurrentSpan } from "loggily/context"
+ *
+ * enableContextPropagation()
+ *
+ * const log = createLogger("myapp")
+ * {
+ *   using span = log.span("request")
+ *   // All logs and child spans within this async context
+ *   // automatically inherit trace_id and span_id
+ *   log.info("inside span") // auto-tagged with trace_id, span_id
+ *
+ *   const current = getCurrentSpan()
+ *   // current === { spanId: "sp_1", traceId: "tr_1", parentId: null }
+ * }
+ * ```
+ */
+/** Minimal span context stored in AsyncLocalStorage */
+interface SpanContext {
+  readonly spanId: string;
+  readonly traceId: string;
+  readonly parentId: string | null;
+}
+/**
+ * Enable AsyncLocalStorage-based context propagation.
+ * Once enabled, new spans automatically parent to the current context span,
+ * and log messages are auto-tagged with trace_id/span_id.
+ *
+ * **Node.js/Bun only** — not available in browser environments.
+ */
+declare function enableContextPropagation(): void;
+/**
+ * Disable context propagation.
+ * Existing spans continue to work, but new spans won't auto-parent.
+ */
+declare function disableContextPropagation(): void;
+/** Check if context propagation is enabled */
+declare function isContextPropagationEnabled(): boolean;
+/**
+ * Get the current span context from AsyncLocalStorage.
+ * Returns null if no span is active in the current async context,
+ * or if context propagation is not enabled.
+ */
+declare function getCurrentSpan(): SpanContext | null;
+/**
+ * Enter a span context for the remainder of the current synchronous execution
+ * and any async operations started from it. Used by the logger when creating
+ * spans with `using` — since `using` doesn't wrap user code in a callback,
+ * `enterWith()` is the right primitive.
+ *
+ * Captures the full previous SpanContext snapshot so it can be restored
+ * exactly on exit, even with non-LIFO end() ordering.
+ *
+ * @internal
+ */
+declare function enterSpanContext(spanId: string, traceId: string, parentId: string | null): void;
+/**
+ * Restore the previous span context (called when a span ends).
+ * Restores the exact SpanContext snapshot captured at enter time,
+ * preventing corruption from non-LIFO end() ordering.
+ *
+ * @internal
+ */
+declare function exitSpanContext(spanId: string): void;
+/**
+ * Run a function within a span context.
+ * Used for explicit context scoping (e.g., in request handlers).
+ *
+ * @param context - The span context to set
+ * @param fn - The function to run within the context
+ * @returns The return value of fn
+ */
+declare function runInSpanContext<T>(context: SpanContext, fn: () => T): T;
+/**
+ * Get the context tags (trace_id, span_id) for the current async context.
+ * Used by writeLog() to auto-tag log messages.
+ * Returns empty object if context propagation is disabled or no span is active.
+ */
+declare function getContextTags(): Record<string, string>;
+//#endregion
+export { SpanContext, disableContextPropagation, enableContextPropagation, enterSpanContext, exitSpanContext, getContextTags, getCurrentSpan, isContextPropagationEnabled, runInSpanContext };
+//# sourceMappingURL=context.d.mts.map

package/dist/context.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"context.d.mts","names":[],"sources":["../src/context.ts"],"mappings":";;AAgCA;;;;;;;;;AA2BA;;;;;AAuBA;;;;;AAMA;;;;;AASA;AAAA,UAjEiB,WAAA;EAAA,SACN,MAAA;EAAA,SACA,OAAA;EAAA,SACA,QAAA;AAAA;;;;;;;;iBAwBK,wBAAA,CAAA;AAuEhB;;;;AAAA,iBAhDgB,yBAAA,CAAA;AAsEhB;AAAA,iBAhEgB,2BAAA,CAAA;;;;;;iBASA,cAAA,CAAA,GAAkB,WAAA;;;;;;;;;AAiElC;;;iBAjDgB,gBAAA,CAAiB,MAAA,UAAgB,OAAA,UAAiB,QAAA;;;;;;;;iBAiBlD,eAAA,CAAgB,MAAA;;;;;;;;;iBAsBhB,gBAAA,GAAA,CAAoB,OAAA,EAAS,WAAA,EAAa,EAAA,QAAU,CAAA,GAAI,CAAA;;;;;;iBAUxD,cAAA,CAAA,GAAkB,MAAA"}

package/dist/context.mjs

@@ -0,0 +1,145 @@
+import { i as _setContextHooks, n as _clearContextHooks } from "./core-Du3sIje6.mjs";
+import { AsyncLocalStorage } from "node:async_hooks";
+//#region src/context.ts
+/**
+* AsyncLocalStorage-based context propagation for loggily — Node.js/Bun only.
+*
+* Separated from core logger to allow tree-shaking in browser bundles.
+* When enabled, new spans automatically parent to the current context span,
+* and writeLog() auto-tags with trace_id/span_id from context.
+*
+* @example
+* ```typescript
+* import { enableContextPropagation, getCurrentSpan } from "loggily/context"
+*
+* enableContextPropagation()
+*
+* const log = createLogger("myapp")
+* {
+*   using span = log.span("request")
+*   // All logs and child spans within this async context
+*   // automatically inherit trace_id and span_id
+*   log.info("inside span") // auto-tagged with trace_id, span_id
+*
+*   const current = getCurrentSpan()
+*   // current === { spanId: "sp_1", traceId: "tr_1", parentId: null }
+* }
+* ```
+*/
+let storage = null;
+let contextEnabled = false;
+/**
+* Map from spanId → the SpanContext that was active when the span was entered.
+* Used to restore the exact previous context on exit, avoiding corruption
+* from non-LIFO end() ordering.
+*/
+const previousContexts = /* @__PURE__ */ new Map();
+/**
+* Enable AsyncLocalStorage-based context propagation.
+* Once enabled, new spans automatically parent to the current context span,
+* and log messages are auto-tagged with trace_id/span_id.
+*
+* **Node.js/Bun only** — not available in browser environments.
+*/
+function enableContextPropagation() {
+	if (!storage) storage = new AsyncLocalStorage();
+	contextEnabled = true;
+	_setContextHooks({
+		getContextTags,
+		getContextParent() {
+			const span = getCurrentSpan();
+			if (!span) return null;
+			return {
+				spanId: span.spanId,
+				traceId: span.traceId
+			};
+		},
+		enterContext: enterSpanContext,
+		exitContext: exitSpanContext
+	});
+}
+/**
+* Disable context propagation.
+* Existing spans continue to work, but new spans won't auto-parent.
+*/
+function disableContextPropagation() {
+	contextEnabled = false;
+	_clearContextHooks();
+}
+/** Check if context propagation is enabled */
+function isContextPropagationEnabled() {
+	return contextEnabled;
+}
+/**
+* Get the current span context from AsyncLocalStorage.
+* Returns null if no span is active in the current async context,
+* or if context propagation is not enabled.
+*/
+function getCurrentSpan() {
+	if (!contextEnabled || !storage) return null;
+	return storage.getStore() ?? null;
+}
+/**
+* Enter a span context for the remainder of the current synchronous execution
+* and any async operations started from it. Used by the logger when creating
+* spans with `using` — since `using` doesn't wrap user code in a callback,
+* `enterWith()` is the right primitive.
+*
+* Captures the full previous SpanContext snapshot so it can be restored
+* exactly on exit, even with non-LIFO end() ordering.
+*
+* @internal
+*/
+function enterSpanContext(spanId, traceId, parentId) {
+	if (!contextEnabled || !storage) return;
+	const previous = storage.getStore() ?? null;
+	previousContexts.set(spanId, previous);
+	storage.enterWith({
+		spanId,
+		traceId,
+		parentId
+	});
+}
+/**
+* Restore the previous span context (called when a span ends).
+* Restores the exact SpanContext snapshot captured at enter time,
+* preventing corruption from non-LIFO end() ordering.
+*
+* @internal
+*/
+function exitSpanContext(spanId) {
+	if (!contextEnabled || !storage) return;
+	const previous = previousContexts.get(spanId);
+	previousContexts.delete(spanId);
+	if (previous) storage.enterWith(previous);
+	else storage.enterWith(void 0);
+}
+/**
+* Run a function within a span context.
+* Used for explicit context scoping (e.g., in request handlers).
+*
+* @param context - The span context to set
+* @param fn - The function to run within the context
+* @returns The return value of fn
+*/
+function runInSpanContext(context, fn) {
+	if (!contextEnabled || !storage) return fn();
+	return storage.run(context, fn);
+}
+/**
+* Get the context tags (trace_id, span_id) for the current async context.
+* Used by writeLog() to auto-tag log messages.
+* Returns empty object if context propagation is disabled or no span is active.
+*/
+function getContextTags() {
+	const span = getCurrentSpan();
+	if (!span) return {};
+	return {
+		trace_id: span.traceId,
+		span_id: span.spanId
+	};
+}
+//#endregion
+export { disableContextPropagation, enableContextPropagation, enterSpanContext, exitSpanContext, getContextTags, getCurrentSpan, isContextPropagationEnabled, runInSpanContext };
+
+//# sourceMappingURL=context.mjs.map

package/dist/context.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"context.mjs","names":[],"sources":["../src/context.ts"],"sourcesContent":["/**\n * AsyncLocalStorage-based context propagation for loggily — Node.js/Bun only.\n *\n * Separated from core logger to allow tree-shaking in browser bundles.\n * When enabled, new spans automatically parent to the current context span,\n * and writeLog() auto-tags with trace_id/span_id from context.\n *\n * @example\n * ```typescript\n * import { enableContextPropagation, getCurrentSpan } from \"loggily/context\"\n *\n * enableContextPropagation()\n *\n * const log = createLogger(\"myapp\")\n * {\n *   using span = log.span(\"request\")\n *   // All logs and child spans within this async context\n *   // automatically inherit trace_id and span_id\n *   log.info(\"inside span\") // auto-tagged with trace_id, span_id\n *\n *   const current = getCurrentSpan()\n *   // current === { spanId: \"sp_1\", traceId: \"tr_1\", parentId: null }\n * }\n * ```\n */\n\nimport { AsyncLocalStorage } from \"node:async_hooks\"\nimport { _setContextHooks, _clearContextHooks } from \"./core.js\"\n\n// ============ Types ============\n\n/** Minimal span context stored in AsyncLocalStorage */\nexport interface SpanContext {\n  readonly spanId: string\n  readonly traceId: string\n  readonly parentId: string | null\n}\n\n// ============ State ============\n\nlet storage: AsyncLocalStorage<SpanContext> | null = null\nlet contextEnabled = false\n\n/**\n * Map from spanId → the SpanContext that was active when the span was entered.\n * Used to restore the exact previous context on exit, avoiding corruption\n * from non-LIFO end() ordering.\n */\nconst previousContexts = new Map<string, SpanContext | null>()\n\n// ============ API ============\n\n/**\n * Enable AsyncLocalStorage-based context propagation.\n * Once enabled, new spans automatically parent to the current context span,\n * and log messages are auto-tagged with trace_id/span_id.\n *\n * **Node.js/Bun only** — not available in browser environments.\n */\nexport function enableContextPropagation(): void {\n  if (!storage) {\n    storage = new AsyncLocalStorage<SpanContext>()\n  }\n  contextEnabled = true\n\n  // Register hooks with core.ts\n  _setContextHooks({\n    getContextTags,\n    getContextParent() {\n      const span = getCurrentSpan()\n      if (!span) return null\n      return { spanId: span.spanId, traceId: span.traceId }\n    },\n    enterContext: enterSpanContext,\n    exitContext: exitSpanContext,\n  })\n}\n\n/**\n * Disable context propagation.\n * Existing spans continue to work, but new spans won't auto-parent.\n */\nexport function disableContextPropagation(): void {\n  contextEnabled = false\n  _clearContextHooks()\n}\n\n/** Check if context propagation is enabled */\nexport function isContextPropagationEnabled(): boolean {\n  return contextEnabled\n}\n\n/**\n * Get the current span context from AsyncLocalStorage.\n * Returns null if no span is active in the current async context,\n * or if context propagation is not enabled.\n */\nexport function getCurrentSpan(): SpanContext | null {\n  if (!contextEnabled || !storage) return null\n  return storage.getStore() ?? null\n}\n\n/**\n * Enter a span context for the remainder of the current synchronous execution\n * and any async operations started from it. Used by the logger when creating\n * spans with `using` — since `using` doesn't wrap user code in a callback,\n * `enterWith()` is the right primitive.\n *\n * Captures the full previous SpanContext snapshot so it can be restored\n * exactly on exit, even with non-LIFO end() ordering.\n *\n * @internal\n */\nexport function enterSpanContext(spanId: string, traceId: string, parentId: string | null): void {\n  if (!contextEnabled || !storage) return\n\n  // Capture the full previous context before overwriting\n  const previous = storage.getStore() ?? null\n  previousContexts.set(spanId, previous)\n\n  storage.enterWith({ spanId, traceId, parentId })\n}\n\n/**\n * Restore the previous span context (called when a span ends).\n * Restores the exact SpanContext snapshot captured at enter time,\n * preventing corruption from non-LIFO end() ordering.\n *\n * @internal\n */\nexport function exitSpanContext(spanId: string): void {\n  if (!contextEnabled || !storage) return\n\n  const previous = previousContexts.get(spanId)\n  previousContexts.delete(spanId)\n\n  if (previous) {\n    storage.enterWith(previous)\n  } else {\n    // No previous context — exit entirely\n    storage.enterWith(undefined as unknown as SpanContext)\n  }\n}\n\n/**\n * Run a function within a span context.\n * Used for explicit context scoping (e.g., in request handlers).\n *\n * @param context - The span context to set\n * @param fn - The function to run within the context\n * @returns The return value of fn\n */\nexport function runInSpanContext<T>(context: SpanContext, fn: () => T): T {\n  if (!contextEnabled || !storage) return fn()\n  return storage.run(context, fn)\n}\n\n/**\n * Get the context tags (trace_id, span_id) for the current async context.\n * Used by writeLog() to auto-tag log messages.\n * Returns empty object if context propagation is disabled or no span is active.\n */\nexport function getContextTags(): Record<string, string> {\n  const span = getCurrentSpan()\n  if (!span) return {}\n  return {\n    trace_id: span.traceId,\n    span_id: span.spanId,\n  }\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;AAwCA,IAAI,UAAiD;AACrD,IAAI,iBAAiB;;;;;;AAOrB,MAAM,mCAAmB,IAAI,KAAiC;;;;;;;;AAW9D,SAAgB,2BAAiC;AAC/C,KAAI,CAAC,QACH,WAAU,IAAI,mBAAgC;AAEhD,kBAAiB;AAGjB,kBAAiB;EACf;EACA,mBAAmB;GACjB,MAAM,OAAO,gBAAgB;AAC7B,OAAI,CAAC,KAAM,QAAO;AAClB,UAAO;IAAE,QAAQ,KAAK;IAAQ,SAAS,KAAK;IAAS;;EAEvD,cAAc;EACd,aAAa;EACd,CAAC;;;;;;AAOJ,SAAgB,4BAAkC;AAChD,kBAAiB;AACjB,qBAAoB;;;AAItB,SAAgB,8BAAuC;AACrD,QAAO;;;;;;;AAQT,SAAgB,iBAAqC;AACnD,KAAI,CAAC,kBAAkB,CAAC,QAAS,QAAO;AACxC,QAAO,QAAQ,UAAU,IAAI;;;;;;;;;;;;;AAc/B,SAAgB,iBAAiB,QAAgB,SAAiB,UAA+B;AAC/F,KAAI,CAAC,kBAAkB,CAAC,QAAS;CAGjC,MAAM,WAAW,QAAQ,UAAU,IAAI;AACvC,kBAAiB,IAAI,QAAQ,SAAS;AAEtC,SAAQ,UAAU;EAAE;EAAQ;EAAS;EAAU,CAAC;;;;;;;;;AAUlD,SAAgB,gBAAgB,QAAsB;AACpD,KAAI,CAAC,kBAAkB,CAAC,QAAS;CAEjC,MAAM,WAAW,iBAAiB,IAAI,OAAO;AAC7C,kBAAiB,OAAO,OAAO;AAE/B,KAAI,SACF,SAAQ,UAAU,SAAS;KAG3B,SAAQ,UAAU,KAAA,EAAoC;;;;;;;;;;AAY1D,SAAgB,iBAAoB,SAAsB,IAAgB;AACxE,KAAI,CAAC,kBAAkB,CAAC,QAAS,QAAO,IAAI;AAC5C,QAAO,QAAQ,IAAI,SAAS,GAAG;;;;;;;AAQjC,SAAgB,iBAAyC;CACvD,MAAM,OAAO,gBAAgB;AAC7B,KAAI,CAAC,KAAM,QAAO,EAAE;AACpB,QAAO;EACL,UAAU,KAAK;EACf,SAAS,KAAK;EACf"}

package/dist/core-DAFH-huv.d.mts

@@ -0,0 +1,199 @@
+//#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>;
+declare function safeStringify(value: unknown): string;
+type NsFilter = (namespace: string) => boolean;
+interface Pipeline {
+  dispatch: (event: Event) => void;
+  level: LogLevel;
+  dispose: () => void;
+}
+interface ScopeConfig {
+  level: LogLevel;
+  ns: NsFilter | null;
+  format: LogFormat;
+}
+declare function buildPipeline(elements: unknown[], parentConfig?: Partial<ScopeConfig>): Pipeline;
+declare function defaultPipeline(): Pipeline;
+//#endregion
+//#region src/core.d.ts
+interface SpanRecord {
+  readonly name: string;
+  readonly durationMs: number;
+}
+interface SpanRecorder {
+  recordSpan(data: SpanRecord): void;
+}
+/** @internal */
+declare let _ambientRecorder: SpanRecorder | null;
+declare function _setAmbientRecorder(recorder: SpanRecorder | null): void;
+type LazyMessage = string | (() => string);
+type LazyProps = Record<string, unknown> | (() => Record<string, unknown>);
+interface SpanData {
+  readonly id: string;
+  readonly traceId: string;
+  readonly parentId: string | null;
+  readonly startTime: number;
+  readonly endTime: number | null;
+  readonly duration: number | null;
+  [key: string]: unknown;
+}
+interface Logger {
+  readonly name: string;
+  readonly props: Readonly<Record<string, unknown>>;
+  readonly spanData: SpanData | null;
+  trace(message: LazyMessage, data?: Record<string, unknown>): void;
+  debug(message: LazyMessage, data?: Record<string, unknown>): void;
+  info(message: LazyMessage, data?: Record<string, unknown>): void;
+  warn(message: LazyMessage, data?: Record<string, unknown>): void;
+  error(message: LazyMessage, data?: Record<string, unknown>): void;
+  error(error: Error, data?: Record<string, unknown>): void;
+  error(error: Error, message: string, data?: Record<string, unknown>): void;
+  logger(namespace?: string, props?: Record<string, unknown>): ConditionalLogger;
+  span(namespace?: string, props?: LazyProps): SpanLogger;
+  child(context: Record<string, unknown>): ConditionalLogger;
+  /** @deprecated Use .logger() instead for namespace-based children */
+  child(context: string): ConditionalLogger;
+  end(): void;
+}
+interface SpanLogger extends Logger, Disposable {
+  readonly spanData: SpanData & {
+    [key: string]: unknown;
+  };
+}
+interface ConditionalLogger {
+  readonly name: string;
+  readonly props: Readonly<Record<string, unknown>>;
+  readonly spanData: SpanData | null;
+  trace?: (message: LazyMessage, data?: Record<string, unknown>) => void;
+  debug?: (message: LazyMessage, data?: Record<string, unknown>) => void;
+  info?: (message: LazyMessage, data?: Record<string, unknown>) => void;
+  warn?: (message: LazyMessage, data?: Record<string, unknown>) => void;
+  error?: {
+    (message: LazyMessage, data?: Record<string, unknown>): void;
+    (error: Error, data?: Record<string, unknown>): void;
+    (error: Error, message: string, data?: Record<string, unknown>): void;
+  };
+  logger(namespace?: string, props?: Record<string, unknown>): ConditionalLogger;
+  span(namespace?: string, props?: LazyProps): SpanLogger;
+  child(context: Record<string, unknown>): ConditionalLogger;
+  child(context: string): ConditionalLogger;
+  end(): void;
+}
+declare function resetIds(): void;
+/** @internal */
+declare function _setContextHooks(hooks: {
+  getContextTags: () => Record<string, string>;
+  getContextParent: () => {
+    spanId: string;
+    traceId: string;
+  } | null;
+  enterContext: (spanId: string, traceId: string, parentId: string | null) => void;
+  exitContext: (spanId: string) => void;
+}): void;
+/** @internal */
+declare function _clearContextHooks(): void;
+interface SpanDataFields {
+  id: string;
+  traceId: string;
+  parentId: string | null;
+  startTime: number;
+  endTime: number | null;
+  duration: number | null;
+}
+declare function createSpanDataProxy(getFields: () => SpanDataFields, attrs: Record<string, unknown>): SpanData;
+declare function startCollecting(): void;
+declare function stopCollecting(): SpanData[];
+declare function getCollectedSpans(): SpanData[];
+declare function clearCollectedSpans(): void;
+/**
+ * Create a logger.
+ *
+ * @param name - Logger namespace (e.g., 'myapp', 'myapp:db')
+ * @param config - Optional config array. Objects configure, arrays branch, values write.
+ *
+ * @example
+ * // Zero config (reads LOG_LEVEL, DEBUG, LOG_FORMAT from env)
+ * const log = createLogger('myapp')
+ *
+ * @example
+ * // Configured pipeline
+ * const log = createLogger('myapp', [
+ *   { level: 'debug', ns: '-sql' },
+ *   console,
+ *   { file: '/tmp/app.log', level: 'info', format: 'json' },
+ * ])
+ */
+declare function createLogger(name: string, config?: unknown[]): ConditionalLogger;
+type LoggerFactory = (name: string, config?: unknown[]) => ConditionalLogger;
+type LoggerPlugin = (factory: LoggerFactory) => LoggerFactory;
+/**
+ * Compose a custom createLogger with plugins.
+ *
+ * @example
+ * import { createLogger as base, compose } from "loggily"
+ * import withSentry from "@sentry/loggily"
+ *
+ * const createLogger = compose(base, withSentry({ dsn: "..." }))
+ * const log = createLogger("myapp")
+ */
+declare function compose(base: LoggerFactory, ...plugins: LoggerPlugin[]): LoggerFactory;
+/** @deprecated Use createLogger config array: createLogger("x", [{ level }, console]) */
+declare function setLogLevel(level: LogLevel): void;
+/** @deprecated Level is per-logger in v2 */
+declare function getLogLevel(): LogLevel;
+/** @deprecated Use TRACE=1 env var */
+declare function enableSpans(): void;
+/** @deprecated */
+declare function disableSpans(): void;
+/** @deprecated */
+declare function spansAreEnabled(): boolean;
+/** @deprecated Use TRACE=namespace env var */
+declare function setTraceFilter(namespaces: string[] | null): void;
+/** @deprecated */
+declare function getTraceFilter(): string[] | null;
+/** @deprecated Use DEBUG=namespace env var or { ns } in config array */
+declare function setDebugFilter(namespaces: string[] | null): void;
+/** @deprecated */
+declare function getDebugFilter(): string[] | null;
+/** @deprecated Use { format } in config array */
+declare function setLogFormat(format: LogFormat): void;
+/** @deprecated */
+declare function getLogFormat(): LogFormat;
+/** @deprecated Omit console from config array instead */
+declare function setSuppressConsole(value: boolean): void;
+type OutputMode = "console" | "stderr" | "writers-only";
+/** @deprecated Use config array */
+declare function setOutputMode(_mode: OutputMode): void;
+/** @deprecated */
+declare function getOutputMode(): OutputMode;
+/** @deprecated Pass writers in config array instead */
+declare function addWriter(writer: (formatted: string, level: string) => void): () => void;
+/** @deprecated Spans dispatch through the pipeline automatically */
+declare function writeSpan(namespace: string, duration: number, attrs: Record<string, unknown>): void;
+//#endregion
+export { setDebugFilter as A, Event as B, getCollectedSpans as C, getOutputMode as D, getLogLevel as E, setTraceFilter as F, OutputLogLevel as G, LogEvent as H, spansAreEnabled as I, Stage as J, Pipeline as K, startCollecting as L, setLogLevel as M, setOutputMode as N, getTraceFilter as O, setSuppressConsole as P, stopCollecting as R, enableSpans as S, getLogFormat as T, LogFormat as U, LOG_LEVEL_PRIORITY as V, LogLevel as W, defaultPipeline as X, buildPipeline as Y, safeStringify as Z, clearCollectedSpans as _, LoggerFactory as a, createSpanDataProxy as b, SpanData as c, SpanRecorder as d, _ambientRecorder as f, addWriter as g, _setContextHooks as h, Logger as i, setLogFormat as j, resetIds as k, SpanLogger as l, _setAmbientRecorder as m, LazyMessage as n, LoggerPlugin as o, _clearContextHooks as p, SpanEvent as q, LazyProps as r, OutputMode as s, ConditionalLogger as t, SpanRecord as u, compose as v, getDebugFilter as w, disableSpans as x, createLogger as y, writeSpan as z };
+//# sourceMappingURL=core-DAFH-huv.d.mts.map

package/dist/core-DAFH-huv.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"core-DAFH-huv.d.mts","names":[],"sources":["../src/pipeline.ts","../src/core.ts"],"mappings":";KAKY,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;AAAA,iBA2BxB,aAAA,CAAc,KAAA;AAAA,KA+ElB,QAAA,IAAY,SAAA;AAAA,UA8EP,QAAA;EACf,QAAA,GAAW,KAAA,EAAO,KAAA;EAClB,KAAA,EAAO,QAAA;EACP,OAAA;AAAA;AAAA,UAqCQ,WAAA;EACR,KAAA,EAAO,QAAA;EACP,EAAA,EAAI,QAAA;EACJ,MAAA,EAAQ,SAAA;AAAA;AAAA,iBAGM,aAAA,CAAc,QAAA,aAAqB,YAAA,GAAe,OAAA,CAAQ,WAAA,IAAe,QAAA;AAAA,iBA4HzE,eAAA,CAAA,GAAmB,QAAA;;;UC9VlB,UAAA;EAAA,SACN,IAAA;EAAA,SACA,UAAA;AAAA;AAAA,UAGM,YAAA;EACf,UAAA,CAAW,IAAA,EAAM,UAAA;AAAA;;YAIR,gBAAA,EAAkB,YAAA;AAAA,iBACb,mBAAA,CAAoB,QAAA,EAAU,YAAA;AAAA,KAMlC,WAAA;AAAA,KACA,SAAA,GAAY,MAAA,2BAAiC,MAAA;AAAA,UAExC,QAAA;EAAA,SACN,EAAA;EAAA,SACA,OAAA;EAAA,SACA,QAAA;EAAA,SACA,SAAA;EAAA,SACA,OAAA;EAAA,SACA,QAAA;EAAA,CACR,GAAA;AAAA;AAAA,UAGc,MAAA;EAAA,SACN,IAAA;EAAA,SACA,KAAA,EAAO,QAAA,CAAS,MAAA;EAAA,SAChB,QAAA,EAAU,QAAA;EAEnB,KAAA,CAAM,OAAA,EAAS,WAAA,EAAa,IAAA,GAAO,MAAA;EACnC,KAAA,CAAM,OAAA,EAAS,WAAA,EAAa,IAAA,GAAO,MAAA;EACnC,IAAA,CAAK,OAAA,EAAS,WAAA,EAAa,IAAA,GAAO,MAAA;EAClC,IAAA,CAAK,OAAA,EAAS,WAAA,EAAa,IAAA,GAAO,MAAA;EAClC,KAAA,CAAM,OAAA,EAAS,WAAA,EAAa,IAAA,GAAO,MAAA;EACnC,KAAA,CAAM,KAAA,EAAO,KAAA,EAAO,IAAA,GAAO,MAAA;EAC3B,KAAA,CAAM,KAAA,EAAO,KAAA,EAAO,OAAA,UAAiB,IAAA,GAAO,MAAA;EAE5C,MAAA,CAAO,SAAA,WAAoB,KAAA,GAAQ,MAAA,oBAA0B,iBAAA;EAC7D,IAAA,CAAK,SAAA,WAAoB,KAAA,GAAQ,SAAA,GAAY,UAAA;EAC7C,KAAA,CAAM,OAAA,EAAS,MAAA,oBAA0B,iBAAA;EDrDf;ECuD1B,KAAA,CAAM,OAAA,WAAkB,iBAAA;EACxB,GAAA;AAAA;AAAA,UAGe,UAAA,SAAmB,MAAA,EAAQ,UAAA;EAAA,SACjC,QAAA,EAAU,QAAA;IAAA,CAAc,GAAA;EAAA;AAAA;AAAA,UAKlB,iBAAA;EAAA,SACN,IAAA;EAAA,SACA,KAAA,EAAO,QAAA,CAAS,MAAA;EAAA,SAChB,QAAA,EAAU,QAAA;EAEnB,KAAA,IAAS,OAAA,EAAS,WAAA,EAAa,IAAA,GAAO,MAAA;EACtC,KAAA,IAAS,OAAA,EAAS,WAAA,EAAa,IAAA,GAAO,MAAA;EACtC,IAAA,IAAQ,OAAA,EAAS,WAAA,EAAa,IAAA,GAAO,MAAA;EACrC,IAAA,IAAQ,OAAA,EAAS,WAAA,EAAa,IAAA,GAAO,MAAA;EACrC,KAAA;IAAA,CACG,OAAA,EAAS,WAAA,EAAa,IAAA,GAAO,MAAA;IAAA,CAC7B,KAAA,EAAO,KAAA,EAAO,IAAA,GAAO,MAAA;IAAA,CACrB,KAAA,EAAO,KAAA,EAAO,OAAA,UAAiB,IAAA,GAAO,MAAA;EAAA;EAGzC,MAAA,CAAO,SAAA,WAAoB,KAAA,GAAQ,MAAA,oBAA0B,iBAAA;EAC7D,IAAA,CAAK,SAAA,WAAoB,KAAA,GAAQ,SAAA,GAAY,UAAA;EAC7C,KAAA,CAAM,OAAA,EAAS,MAAA,oBAA0B,iBAAA;EACzC,KAAA,CAAM,OAAA,WAAkB,iBAAA;EACxB,GAAA;AAAA;AAAA,iBAOc,QAAA,CAAA;;iBAYA,gBAAA,CAAiB,KAAA;EAC/B,cAAA,QAAsB,MAAA;EACtB,gBAAA;IAA0B,MAAA;IAAgB,OAAA;EAAA;EAC1C,YAAA,GAAe,MAAA,UAAgB,OAAA,UAAiB,QAAA;EAChD,WAAA,GAAc,MAAA;AAAA;;iBASA,kBAAA,CAAA;AAAA,UASN,cAAA;EACR,EAAA;EACA,OAAA;EACA,QAAA;EACA,SAAA;EACA,OAAA;EACA,QAAA;AAAA;AAAA,iBAGc,mBAAA,CAAoB,SAAA,QAAiB,cAAA,EAAgB,KAAA,EAAO,MAAA,oBAA0B,QAAA;AAAA,iBAwBtF,eAAA,CAAA;AAAA,iBAKA,cAAA,CAAA,GAAkB,QAAA;AAAA,iBAKlB,iBAAA,CAAA,GAAqB,QAAA;AAAA,iBAIrB,mBAAA,CAAA;;;;;;;;;;AD0LhB;;;;;;;;AC9VA;iBA6agB,YAAA,CAAa,IAAA,UAAc,MAAA,eAAqB,iBAAA;AAAA,KAQpD,aAAA,IAAiB,IAAA,UAAc,MAAA,iBAAuB,iBAAA;AAAA,KACtD,YAAA,IAAgB,OAAA,EAAS,aAAA,KAAkB,aAAA;;AAjbvD;;;;;;;;;iBA6bgB,OAAA,CAAQ,IAAA,EAAM,aAAA,KAAkB,OAAA,EAAS,YAAA,KAAiB,aAAA;;iBAa1D,WAAA,CAAY,KAAA,EAAO,QAAA;;iBAKnB,WAAA,CAAA,GAAe,QAAA;AAzc/B;AAAA,iBA8cgB,WAAA,CAAA;;iBAKA,YAAA,CAAA;;iBAKA,eAAA,CAAA;;iBAKA,cAAA,CAAe,UAAA;;iBASf,cAAA,CAAA;AA/dhB;AAAA,iBAoegB,cAAA,CAAe,UAAA;;iBASf,cAAA,CAAA;;iBAKA,YAAA,CAAa,MAAA,EAAQ,SAAA;;iBAKrB,YAAA,CAAA,GAAgB,SAAA;;iBAKhB,kBAAA,CAAmB,KAAA;AAAA,KAIvB,UAAA;;iBAGI,aAAA,CAAc,KAAA,EAAO,UAAA;;iBAGrB,aAAA,CAAA,GAAiB,UAAA;;iBAKjB,SAAA,CAAU,MAAA,GAAS,SAAA,UAAmB,KAAA;;iBAStC,SAAA,CAAU,SAAA,UAAmB,QAAA,UAAkB,KAAA,EAAO,MAAA"}