@namzu/sdk 27.1.0 → 29.0.0

package/dist/utils/log/attributes.d.ts

@@ -0,0 +1,17 @@
+type AttributeValue = string | number | boolean | readonly (string | number | boolean)[];
+type AttributeKey = `namzu.${string}` | `gen_ai.${string}` | `service.${string}` | `exception.${string}`;
+/**
+ * A namespaced, shape-safe attribute bag. Deliberately NOT
+ * `Partial<Record<...>>`: `Partial` would type every property as
+ * `AttributeValue | undefined`, and this repo's tsconfig does not set
+ * `exactOptionalPropertyTypes` — so a `Partial` version would let
+ * `{ 'namzu.x.y': undefined }` compile, an attribute that is present and
+ * holds nothing. Plain `Record` over a template-literal key domain does not
+ * require every possible key to appear — there is no finite set of keys to
+ * require — so dropping `Partial` costs a caller nothing: it still supplies
+ * only the keys it has, and gains that an explicit `undefined` is rejected
+ * the same way `null` and a nested object already are.
+ */
+export type LogAttributes = Readonly<Record<AttributeKey, AttributeValue>>;
+export {};
+//# sourceMappingURL=attributes.d.ts.map

package/dist/utils/log/attributes.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"attributes.d.ts","sourceRoot":"","sources":["../../../src/utils/log/attributes.ts"],"names":[],"mappings":"AA0BA,KAAK,cAAc,GAAG,MAAM,GAAG,MAAM,GAAG,OAAO,GAAG,SAAS,CAAC,MAAM,GAAG,MAAM,GAAG,OAAO,CAAC,EAAE,CAAA;AAExF,KAAK,YAAY,GACd,SAAS,MAAM,EAAE,GACjB,UAAU,MAAM,EAAE,GAClB,WAAW,MAAM,EAAE,GACnB,aAAa,MAAM,EAAE,CAAA;AAExB;;;;;;;;;;;GAWG;AACH,MAAM,MAAM,aAAa,GAAG,QAAQ,CAAC,MAAM,CAAC,YAAY,EAAE,cAAc,CAAC,CAAC,CAAA"}

package/dist/utils/log/attributes.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=attributes.js.map

package/dist/utils/log/attributes.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"attributes.js","sourceRoot":"","sources":["../../../src/utils/log/attributes.ts"],"names":[],"mappings":""}

package/dist/utils/log/caps.d.ts

@@ -0,0 +1,27 @@
+import type { LogRecord, MutableLogSinkCounters } from './types.js';
+export declare const MAX_ATTRIBUTES = 64;
+export declare const MAX_VALUE_BYTES: number;
+export declare const MAX_RECORD_BYTES: number;
+/**
+ * At most 64 attributes. Excess keys are dropped in ascending key order —
+ * the same deterministic rule `capTotalSize` uses below, so a reader who has
+ * learned one learns both.
+ */
+export declare function capAttributeCount(record: LogRecord, counters: MutableLogSinkCounters): LogRecord;
+/**
+ * Each string attribute value truncated at 8 KiB, tail replaced by
+ * `…[truncated N bytes]` inside the value — self-describing, so no extra
+ * flag field is minted for something the value already says about itself.
+ */
+export declare function truncateValues(record: LogRecord, counters: MutableLogSinkCounters): LogRecord;
+/**
+ * Total serialized record ≤ 16 KiB. Per-value and per-count caps are
+ * independently satisfiable by a record with many small attributes, so this
+ * is the last line and measures the whole record, not one dimension of it.
+ * Attributes are dropped in ascending key order until it fits, and
+ * `namzu.log.truncated = true` is set on what remains — the marker a
+ * downstream reader needs to tell "this record is smaller than what was
+ * logged" from "this is genuinely all there was".
+ */
+export declare function capTotalSize(record: LogRecord, counters: MutableLogSinkCounters): LogRecord;
+//# sourceMappingURL=caps.d.ts.map

package/dist/utils/log/caps.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"caps.d.ts","sourceRoot":"","sources":["../../../src/utils/log/caps.ts"],"names":[],"mappings":"AAWA,OAAO,KAAK,EAAE,SAAS,EAAE,sBAAsB,EAAE,MAAM,YAAY,CAAA;AAEnE,eAAO,MAAM,cAAc,KAAK,CAAA;AAChC,eAAO,MAAM,eAAe,QAAW,CAAA;AACvC,eAAO,MAAM,gBAAgB,QAAY,CAAA;AAEzC;;;;GAIG;AACH,wBAAgB,iBAAiB,CAAC,MAAM,EAAE,SAAS,EAAE,QAAQ,EAAE,sBAAsB,GAAG,SAAS,CAchG;AAED;;;;GAIG;AACH,wBAAgB,cAAc,CAAC,MAAM,EAAE,SAAS,EAAE,QAAQ,EAAE,sBAAsB,GAAG,SAAS,CAkB7F;AAsBD;;;;;;;;GAQG;AACH,wBAAgB,YAAY,CAAC,MAAM,EAAE,SAAS,EAAE,QAAQ,EAAE,sBAAsB,GAAG,SAAS,CAqB3F"}

package/dist/utils/log/caps.js

@@ -0,0 +1,107 @@
+// Cardinality and size caps, enforced once at the pipeline boundary — not
+// per sink, and not left to whichever sink happens to serialize the record.
+// A prose rule here would not survive the first attribute added under
+// deadline; these are type-and-code boundaries a caller cannot route around
+// by picking a different sink.
+//
+// Order matters and is fixed by createLogger: redact, THEN cap. Truncating
+// first could slice a secret in half and ship the surviving fragment: a
+// `[REDACTED:label]` placeholder is short and never needs truncating itself,
+// but half of a real key still leaks half a key.
+export const MAX_ATTRIBUTES = 64;
+export const MAX_VALUE_BYTES = 8 * 1024;
+export const MAX_RECORD_BYTES = 16 * 1024;
+/**
+ * At most 64 attributes. Excess keys are dropped in ascending key order —
+ * the same deterministic rule `capTotalSize` uses below, so a reader who has
+ * learned one learns both.
+ */
+export function capAttributeCount(record, counters) {
+    const keys = Object.keys(record.attributes);
+    if (keys.length <= MAX_ATTRIBUTES)
+        return record;
+    const dropCount = keys.length - MAX_ATTRIBUTES;
+    const dropped = new Set([...keys].sort().slice(0, dropCount));
+    const attributes = {};
+    for (const key of keys) {
+        if (!dropped.has(key))
+            attributes[key] = record.attributes[key];
+    }
+    counters.attributesDropped += dropCount;
+    return { ...record, attributes };
+}
+/**
+ * Each string attribute value truncated at 8 KiB, tail replaced by
+ * `…[truncated N bytes]` inside the value — self-describing, so no extra
+ * flag field is minted for something the value already says about itself.
+ */
+export function truncateValues(record, counters) {
+    let changed = false;
+    const attributes = {};
+    for (const [key, value] of Object.entries(record.attributes)) {
+        if (typeof value !== 'string') {
+            attributes[key] = value;
+            continue;
+        }
+        const [text, wasTruncated] = truncateToByteLength(value, MAX_VALUE_BYTES);
+        attributes[key] = text;
+        if (wasTruncated) {
+            changed = true;
+            counters.valuesTruncated++;
+        }
+    }
+    return changed ? { ...record, attributes } : record;
+}
+function truncateToByteLength(value, maxBytes) {
+    const totalBytes = Buffer.byteLength(value, 'utf8');
+    if (totalBytes <= maxBytes)
+        return [value, false];
+    // Walk by Unicode codepoint, not UTF-16 code unit, so the cut point never
+    // lands inside a surrogate pair — splitting one produces an unpaired
+    // surrogate that some JSON readers choke on or silently mangle.
+    let kept = '';
+    let bytes = 0;
+    for (const ch of value) {
+        const chBytes = Buffer.byteLength(ch, 'utf8');
+        if (bytes + chBytes > maxBytes)
+            break;
+        kept += ch;
+        bytes += chBytes;
+    }
+    const removedBytes = totalBytes - bytes;
+    return [`${kept}…[truncated ${removedBytes} bytes]`, true];
+}
+/**
+ * Total serialized record ≤ 16 KiB. Per-value and per-count caps are
+ * independently satisfiable by a record with many small attributes, so this
+ * is the last line and measures the whole record, not one dimension of it.
+ * Attributes are dropped in ascending key order until it fits, and
+ * `namzu.log.truncated = true` is set on what remains — the marker a
+ * downstream reader needs to tell "this record is smaller than what was
+ * logged" from "this is genuinely all there was".
+ */
+export function capTotalSize(record, counters) {
+    if (serializedByteLength(record) <= MAX_RECORD_BYTES)
+        return record;
+    const sortedKeys = Object.keys(record.attributes).sort();
+    for (let dropCount = 1; dropCount <= sortedKeys.length; dropCount++) {
+        const keptKeys = sortedKeys.slice(dropCount);
+        const attributes = {};
+        for (const key of keptKeys)
+            attributes[key] = record.attributes[key];
+        const candidate = { ...record, attributes };
+        if (keptKeys.length === 0 || serializedByteLength(candidate) <= MAX_RECORD_BYTES) {
+            counters.recordsTruncated++;
+            return { ...record, attributes: { ...attributes, 'namzu.log.truncated': true } };
+        }
+    }
+    // Unreachable: the final iteration of the loop above always has
+    // `keptKeys.length === 0` and returns from inside it. Kept as a typed
+    // fallback rather than a non-null assertion on the loop's last candidate.
+    counters.recordsTruncated++;
+    return { ...record, attributes: { 'namzu.log.truncated': true } };
+}
+function serializedByteLength(record) {
+    return Buffer.byteLength(JSON.stringify(record), 'utf8');
+}
+//# sourceMappingURL=caps.js.map

package/dist/utils/log/caps.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"caps.js","sourceRoot":"","sources":["../../../src/utils/log/caps.ts"],"names":[],"mappings":"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"}

package/dist/utils/log/create-logger.d.ts

@@ -0,0 +1,28 @@
+import type { Logger } from '../logger.js';
+import { type LogSinkCounters, type LoggerOptions, type MutableLogSinkCounters } from './types.js';
+export type CreatedLogger = Logger & {
+    readonly counters: LogSinkCounters;
+};
+export declare function newCounters(): MutableLogSinkCounters;
+/**
+ * `shared` lets several loggers write through ONE counter set.
+ *
+ * Without it the counters answer a question nobody asks. `getRootLogger()`
+ * resolves per call and builds a fresh logger each time, so every count it
+ * accumulated died with the expression that read it -- the five fields were
+ * incremented on every record in the process and read by nothing, which is
+ * `declared-but-undriven` with a comment above it promising `namzu doctor`
+ * would read them. `installProcessSink` now owns one set for the process,
+ * and that promise is discharged rather than deleted.
+ */
+export declare function createLogger(options: LoggerOptions, shared?: MutableLogSinkCounters): CreatedLogger;
+/**
+ * A logger that discards everything, countably. Every call is accepted (the
+ * level is `debug`, the widest threshold), and every accepted call is routed
+ * to `NOOP_SINK` and counted as dropped — a host holding `NOOP_LOGGER` can
+ * still tell "N calls happened and were discarded" from "N calls never
+ * happened", which a logger that filtered everything out at `silent` could
+ * not: a filtered call never reaches dispatch and is never counted at all.
+ */
+export declare const NOOP_LOGGER: CreatedLogger;
+//# sourceMappingURL=create-logger.d.ts.map

package/dist/utils/log/create-logger.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"create-logger.d.ts","sourceRoot":"","sources":["../../../src/utils/log/create-logger.ts"],"names":[],"mappings":"AAgBA,OAAO,KAAK,EAAc,MAAM,EAAE,MAAM,cAAc,CAAA;AAKtD,OAAO,EAKN,KAAK,eAAe,EACpB,KAAK,aAAa,EAClB,KAAK,sBAAsB,EAG3B,MAAM,YAAY,CAAA;AAWnB,MAAM,MAAM,aAAa,GAAG,MAAM,GAAG;IAAE,QAAQ,CAAC,QAAQ,EAAE,eAAe,CAAA;CAAE,CAAA;AAE3E,wBAAgB,WAAW,IAAI,sBAAsB,CAEpD;AAED;;;;;;;;;;GAUG;AACH,wBAAgB,YAAY,CAC3B,OAAO,EAAE,aAAa,EACtB,MAAM,CAAC,EAAE,sBAAsB,GAC7B,aAAa,CAEf;AAwHD;;;;;;;GAOG;AACH,eAAO,MAAM,WAAW,EAAE,aAKxB,CAAA"}

package/dist/utils/log/create-logger.js

@@ -0,0 +1,168 @@
+// The pipeline: builds a record from a call, runs it through redaction and
+// the size caps, then dispatches to the configured sink — catching whatever
+// that sink does, because a host sink is arbitrary code the kernel does not
+// control.
+//
+// `createLogger` returns a plain `Logger` with one extra, non-Logger
+// property (`counters`) riding along on the same object. That is a
+// deliberate choice over a `{ logger, counters }` pair: the returned value
+// still satisfies `logger?: Logger` at every existing call site with no
+// unwrapping, while a caller that wants to observe the pipeline reads
+// `.counters` off the same reference. That caller is now real: LOG-06's
+// `logging.pipeline` doctor check. It could not have been while every
+// `getRootLogger()` built a logger with its own counters — see `shared`
+// below and `utils/__tests__/log-counters-are-process-wide.test.ts`.
+import { getActiveSpanContext } from '../../telemetry/runtime-accessors.js';
+import { capAttributeCount, capTotalSize, truncateValues } from './caps.js';
+import { errorAttributes } from './exception.js';
+import { redactRecord } from './redact.js';
+import { NOOP_SINK } from './sinks.js';
+import { ERR_ATTRIBUTE, EVENT_NAME_ATTRIBUTE, SCOPE_ATTRIBUTE, } from './types.js';
+const SEVERITY_RANK = { debug: 0, info: 1, warn: 2, error: 3 };
+const LEVEL_RANK = { ...SEVERITY_RANK, silent: 4 };
+const SEVERITY_NUMBER = {
+    debug: 5,
+    info: 9,
+    warn: 13,
+    error: 17,
+};
+export function newCounters() {
+    return { dropped: 0, redacted: 0, attributesDropped: 0, valuesTruncated: 0, recordsTruncated: 0 };
+}
+/**
+ * `shared` lets several loggers write through ONE counter set.
+ *
+ * Without it the counters answer a question nobody asks. `getRootLogger()`
+ * resolves per call and builds a fresh logger each time, so every count it
+ * accumulated died with the expression that read it -- the five fields were
+ * incremented on every record in the process and read by nothing, which is
+ * `declared-but-undriven` with a comment above it promising `namzu doctor`
+ * would read them. `installProcessSink` now owns one set for the process,
+ * and that promise is discharged rather than deleted.
+ */
+export function createLogger(options, shared) {
+    return build(options, shared ?? newCounters(), {});
+}
+function build(options, counters, bound) {
+    function emit(severityText, body, data) {
+        // Read per record, off the shared mutable holder — never resolved once
+        // and captured in this closure. Today's `Logger.child()` bakes its level
+        // in exactly that way, which is why three module-scope loggers in the
+        // skills/plugin loaders are frozen at `info` forever and unreachable by
+        // any later `configureLogger` call.
+        if (SEVERITY_RANK[severityText] < LEVEL_RANK[options.level.current])
+            return;
+        const now = Date.now();
+        // Promote the two reserved keys before anything else touches
+        // `attributes` — redact/cap below only ever see the caller's real
+        // attributes, never the event name or the raw thrown value a second
+        // time under a second spelling. `err` maps through `errorAttributes`
+        // (bounded, cycle-safe cause walk — see ./exception.ts) rather than
+        // being copied verbatim: the whole point of the reserved key is that
+        // the THROWN VALUE reaches the mapper, not a string a call site
+        // already built with `toErrorMessage` and so already lost the stack
+        // and cause off of.
+        const merged = { ...bound, ...data };
+        const { [EVENT_NAME_ATTRIBUTE]: rawEventName, [ERR_ATTRIBUTE]: rawErr, ...attributes } = merged;
+        // Computed here, before redact/cap run, so `exception.stacktrace` gets
+        // exactly the same treatment as an attribute any call site set by
+        // hand — see the redaction-pipeline test planting a secret inside a
+        // NESTED cause's message specifically to pin this ordering. `rawErr`
+        // wins over a same-named `exception.*` key set by hand: once a call
+        // site hands over the real thrown value, that value is the
+        // authoritative source, not whatever text a caller pre-computed
+        // before this reserved key existed.
+        const attributesWithException = rawErr !== undefined ? { ...attributes, ...errorAttributes(rawErr) } : attributes;
+        // Resolved HERE, at emit time, off the live `@opentelemetry/api` global —
+        // never once at `createLogger` construction and captured in this
+        // closure. `telemetry/metrics.ts` documents the construction-time
+        // version of this mistake already happening once, for a meter: a bag
+        // that captured the no-op instance at construction stayed no-op for the
+        // rest of the process even after a real one registered later.
+        // `undefined` with no telemetry configured — see `getActiveSpanContext`'s
+        // own doc for why that is the default, not a case this file detects.
+        const spanContext = getActiveSpanContext();
+        let record = {
+            timestamp: now,
+            observedTimestamp: now,
+            severityNumber: SEVERITY_NUMBER[severityText],
+            severityText,
+            body,
+            scope: { name: options.scope },
+            resource: options.resource,
+            attributes: attributesWithException,
+            ...(typeof rawEventName === 'string' ? { eventName: rawEventName } : {}),
+            // All three or none: a trace id with no span id would be a
+            // half-address (see `LogRecord.traceId`'s doc).
+            ...(spanContext
+                ? {
+                    traceId: spanContext.traceId,
+                    spanId: spanContext.spanId,
+                    traceFlags: spanContext.traceFlags,
+                }
+                : {}),
+        };
+        // Order matters: redact BEFORE capping. Truncating a value first could
+        // slice a secret in half and ship the surviving fragment; the
+        // `[REDACTED:label]` placeholder redaction leaves behind is short and
+        // never needs truncating itself.
+        record = redactRecord(record, counters);
+        record = capAttributeCount(record, counters);
+        record = truncateValues(record, counters);
+        record = capTotalSize(record, counters);
+        dispatch(record);
+    }
+    function dispatch(record) {
+        if (options.sink === NOOP_SINK) {
+            counters.dropped++;
+            return;
+        }
+        try {
+            options.sink.emit(record);
+        }
+        catch {
+            // A host sink is arbitrary code the kernel does not control. The old
+            // direct `process.stderr.write` implementation could never throw into
+            // an in-flight run; a naive seam here would introduce that failure
+            // mode for the first time — a broken sink aborting, say, a
+            // tool-completion path. Never rethrown, never logged through the same
+            // sink that just failed — counted instead, so a doctor check can
+            // surface a sink that is silently eating every record.
+            counters.dropped++;
+        }
+    }
+    return {
+        debug: (message, data) => emit('debug', message, data),
+        info: (message, data) => emit('info', message, data),
+        warn: (message, data) => emit('warn', message, data),
+        error: (message, data) => emit('error', message, data),
+        child: (context) => {
+            // The one context key that changes a PROPERTY OF THE LOGGER
+            // (`options.scope`) rather than joining `bound` as an ordinary
+            // attribute — see `SCOPE_ATTRIBUTE`'s own doc comment in `./types.js`.
+            // Stripped out of `rest` before merging, for the same reason
+            // `EVENT_NAME_ATTRIBUTE` is stripped out of `attributes` above: an
+            // attribute and a property carrying the same value would be the same
+            // name spelled two ways in one record.
+            const { [SCOPE_ATTRIBUTE]: scopeOverride, ...rest } = context;
+            const nextOptions = typeof scopeOverride === 'string' ? { ...options, scope: scopeOverride } : options;
+            return build(nextOptions, counters, { ...bound, ...rest });
+        },
+        counters,
+    };
+}
+/**
+ * A logger that discards everything, countably. Every call is accepted (the
+ * level is `debug`, the widest threshold), and every accepted call is routed
+ * to `NOOP_SINK` and counted as dropped — a host holding `NOOP_LOGGER` can
+ * still tell "N calls happened and were discarded" from "N calls never
+ * happened", which a logger that filtered everything out at `silent` could
+ * not: a filtered call never reaches dispatch and is never counted at all.
+ */
+export const NOOP_LOGGER = createLogger({
+    sink: NOOP_SINK,
+    level: { current: 'debug' },
+    resource: { 'service.name': '@namzu/sdk' },
+    scope: 'namzu.noop',
+});
+//# sourceMappingURL=create-logger.js.map

package/dist/utils/log/create-logger.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"create-logger.js","sourceRoot":"","sources":["../../../src/utils/log/create-logger.ts"],"names":[],"mappings":"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"}

package/dist/utils/log/exception.d.ts

@@ -0,0 +1,11 @@
+import type { LogAttributes } from './attributes.js';
+/**
+ * `exception.type` / `exception.message` / `exception.stacktrace` for a
+ * thrown value. `causeDepth` overrides the default bound above — exposed
+ * for tests, not because a production call site should ordinarily need a
+ * different one.
+ */
+export declare function errorAttributes(err: unknown, opts?: {
+    readonly causeDepth?: number;
+}): LogAttributes;
+//# sourceMappingURL=exception.d.ts.map

package/dist/utils/log/exception.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"exception.d.ts","sourceRoot":"","sources":["../../../src/utils/log/exception.ts"],"names":[],"mappings":"AAuBA,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,iBAAiB,CAAA;AAkBpD;;;;;GAKG;AACH,wBAAgB,eAAe,CAC9B,GAAG,EAAE,OAAO,EACZ,IAAI,CAAC,EAAE;IAAE,QAAQ,CAAC,UAAU,CAAC,EAAE,MAAM,CAAA;CAAE,GACrC,aAAa,CAQf"}

package/dist/utils/log/exception.js

@@ -0,0 +1,108 @@
+// Maps a thrown value to the exception.* attributes the OTel Logs Data
+// Model reserves for it — exception.type / exception.message /
+// exception.stacktrace — walking a `cause` chain the way a terminal
+// `console.error` would: newest frame first, oldest cause last.
+//
+// Two things this file deliberately does NOT do:
+//
+//  - It does not redact anything itself. `redactRecord` (../log/redact.ts)
+//    runs over every attribute value unconditionally, once, at the record
+//    boundary — stack text included. A second scan here would be a second
+//    place to keep LOG_SECRET_PATTERNS in sync with, and the whole point of
+//    a record-boundary scan is that nothing gets to opt out of it by
+//    running earlier.
+//  - It does not license re-attaching `cause` where it was deliberately
+//    dropped. `provider/errors.ts` refuses to keep one on a classified
+//    provider error on purpose — a vendor SDK's error message (and so its
+//    own `cause`, when the vendor wraps a transport error) can carry a
+//    credential the upstream echoed back, and "a `cause` survives every
+//    logger that serializes an error chain" is exactly the property this
+//    file exists to provide. Being able to walk a `cause` safely is not the
+//    same claim as every `cause` being safe to attach in the first place;
+//    see that file's own doc comment and docs/conventions/index.md.
+/**
+ * How many `cause` hops past the thrown value itself get folded into
+ * `exception.stacktrace`. Four, not "as many as there are": an ordinary
+ * retry-then-fallback call stack in this codebase is a handful of layers
+ * deep, but nothing stops a caller from building a cause chain as long as
+ * it likes, and walking all of it turns one log call into an unbounded
+ * string build ahead of the 8 KiB per-value cap (caps.ts) that would
+ * otherwise be the only thing catching it. The bound is enforced here,
+ * explicitly, rather than left to that cap truncating mid-frame with no
+ * indication anything was cut.
+ */
+const DEFAULT_CAUSE_DEPTH = 4;
+/** What a thrown non-`Error` still needs a name for. */
+const UNKNOWN_EXCEPTION_TYPE = 'UnknownError';
+/**
+ * `exception.type` / `exception.message` / `exception.stacktrace` for a
+ * thrown value. `causeDepth` overrides the default bound above — exposed
+ * for tests, not because a production call site should ordinarily need a
+ * different one.
+ */
+export function errorAttributes(err, opts) {
+    const maxDepth = opts?.causeDepth ?? DEFAULT_CAUSE_DEPTH;
+    const { type, message } = describe(err);
+    return {
+        'exception.type': type,
+        'exception.message': message,
+        'exception.stacktrace': buildStacktrace(err, maxDepth),
+    };
+}
+function describe(value) {
+    if (value instanceof Error) {
+        return { type: value.name || UNKNOWN_EXCEPTION_TYPE, message: value.message };
+    }
+    if (typeof value === 'object' && value !== null) {
+        return { type: UNKNOWN_EXCEPTION_TYPE, message: safeStringify(value) };
+    }
+    return { type: UNKNOWN_EXCEPTION_TYPE, message: String(value) };
+}
+function safeStringify(value) {
+    try {
+        return JSON.stringify(value);
+    }
+    catch {
+        // A circular non-Error thrown value. `String()` on a plain object gives
+        // '[object Object]' — unhelpful, but the one thing this function must
+        // never do is itself throw from inside a logging call.
+        return String(value);
+    }
+}
+/**
+ * `err`'s own stack (or a `type: message` line when there is none) followed
+ * by each `.cause`'s, newest first, bounded by `maxDepth` hops. Stops early
+ * — WITH a note saying so, per refuse-do-not-degrade — on a cycle or on
+ * reaching the bound with more chain left to walk. Never loops: every value
+ * this function visits is added to `seen` before the value after it is even
+ * read, so a self-referencing `cause` is caught on the very next hop rather
+ * than by exhausting the depth bound.
+ */
+function buildStacktrace(err, maxDepth) {
+    const seen = new Set([err]);
+    const frames = [frameText(err)];
+    let cursor = err instanceof Error ? err.cause : undefined;
+    let depth = 0;
+    while (cursor !== undefined && cursor !== null) {
+        if (seen.has(cursor)) {
+            frames.push(`Caused by: [cause chain cycle detected at depth ${depth + 1} — stopped]`);
+            return frames.join('\n');
+        }
+        if (depth >= maxDepth) {
+            frames.push(`Caused by: [cause chain truncated at depth ${maxDepth} — deeper causes not walked]`);
+            return frames.join('\n');
+        }
+        seen.add(cursor);
+        frames.push(`Caused by: ${frameText(cursor)}`);
+        depth++;
+        cursor = cursor instanceof Error ? cursor.cause : undefined;
+    }
+    return frames.join('\n');
+}
+function frameText(value) {
+    if (value instanceof Error) {
+        return value.stack ?? `${value.name || UNKNOWN_EXCEPTION_TYPE}: ${value.message}`;
+    }
+    return String(value);
+}
+//# sourceMappingURL=exception.js.map

package/dist/utils/log/exception.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"exception.js","sourceRoot":"","sources":["../../../src/utils/log/exception.ts"],"names":[],"mappings":"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"}

package/dist/utils/log/index.d.ts

@@ -0,0 +1,7 @@
+export type { LevelFilter, LogRecord, LogSink, LogSinkCounters, Resource, Severity, } from './types.js';
+export type { LogAttributes } from './attributes.js';
+export { createLogger, NOOP_LOGGER } from './create-logger.js';
+export { installProcessSink } from './process-sink.js';
+export { jsonLinesSink, NOOP_SINK, prettySink } from './sinks.js';
+export { EVENT_NAME_ATTRIBUTE, SCOPE_ATTRIBUTE } from './types.js';
+//# sourceMappingURL=index.d.ts.map

package/dist/utils/log/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/utils/log/index.ts"],"names":[],"mappings":"AAKA,YAAY,EACX,WAAW,EACX,SAAS,EACT,OAAO,EACP,eAAe,EACf,QAAQ,EACR,QAAQ,GACR,MAAM,YAAY,CAAA;AACnB,YAAY,EAAE,aAAa,EAAE,MAAM,iBAAiB,CAAA;AACpD,OAAO,EAAE,YAAY,EAAE,WAAW,EAAE,MAAM,oBAAoB,CAAA;AAC9D,OAAO,EAAE,kBAAkB,EAAE,MAAM,mBAAmB,CAAA;AACtD,OAAO,EAAE,aAAa,EAAE,SAAS,EAAE,UAAU,EAAE,MAAM,YAAY,CAAA;AAOjE,OAAO,EAAE,oBAAoB,EAAE,eAAe,EAAE,MAAM,YAAY,CAAA"}

package/dist/utils/log/index.js

@@ -0,0 +1,15 @@
+// The LogSink seam. `../logger.ts` keeps `Logger`, `LogContext`,
+// `getRootLogger` and `configureLogger` completely unchanged (now
+// `@deprecated`) — this directory is the additive replacement described in
+// docs/conventions and the observability docs page once those land.
+export { createLogger, NOOP_LOGGER } from './create-logger.js';
+export { installProcessSink } from './process-sink.js';
+export { jsonLinesSink, NOOP_SINK, prettySink } from './sinks.js';
+// A value export, not a type — sits beside the type re-exports above rather
+// than folded into that block, because `export type { ... }` cannot carry a
+// runtime const. `EVENT_NAME_ATTRIBUTE` is how a host OUTSIDE this package
+// (the CLI's boot narrative, NZ-BOOT-05) names an event without duplicating
+// the reserved key `createLogger` promotes off of — see the doc comment on
+// the constant itself in `./types.js`.
+export { EVENT_NAME_ATTRIBUTE, SCOPE_ATTRIBUTE } from './types.js';
+//# sourceMappingURL=index.js.map

package/dist/utils/log/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../../src/utils/log/index.ts"],"names":[],"mappings":"AAAA,iEAAiE;AACjE,kEAAkE;AAClE,2EAA2E;AAC3E,oEAAoE;AAWpE,OAAO,EAAE,YAAY,EAAE,WAAW,EAAE,MAAM,oBAAoB,CAAA;AAC9D,OAAO,EAAE,kBAAkB,EAAE,MAAM,mBAAmB,CAAA;AACtD,OAAO,EAAE,aAAa,EAAE,SAAS,EAAE,UAAU,EAAE,MAAM,YAAY,CAAA;AACjE,4EAA4E;AAC5E,4EAA4E;AAC5E,2EAA2E;AAC3E,4EAA4E;AAC5E,2EAA2E;AAC3E,uCAAuC;AACvC,OAAO,EAAE,oBAAoB,EAAE,eAAe,EAAE,MAAM,YAAY,CAAA"}

package/dist/utils/log/process-sink.d.ts

@@ -0,0 +1,28 @@
+import type { LevelFilter, LogSink, LogSinkCounters, MutableLogSinkCounters } from './types.js';
+export declare function installProcessSink(sink: LogSink, level: LevelFilter, opts?: {
+    readonly replace?: boolean;
+}): void;
+/** The installed destination, or `undefined` when nobody claimed the process. */
+export declare function getProcessSink(): {
+    readonly sink: LogSink;
+    readonly level: LevelFilter;
+    readonly counters: LogSinkCounters;
+} | undefined;
+/**
+ * The mutable counter set the installed destination writes through.
+ *
+ * Internal: a reader wants {@link getProcessSink}'s readonly view. This
+ * exists so `getRootLogger`'s bridge can hand the SAME object to every
+ * logger it builds, which is what makes the totals process-wide rather
+ * than per-call.
+ */
+export declare function getProcessSinkCounters(): MutableLogSinkCounters | undefined;
+/**
+ * Test-only: forget the installed sink.
+ *
+ * Production must never call this — the refusal above is the whole contract,
+ * and a reset that production could reach would let a second caller take the
+ * destination by clearing the first one rather than by saying `replace`.
+ */
+export declare function __resetProcessSinkForTests(): void;
+//# sourceMappingURL=process-sink.d.ts.map

package/dist/utils/log/process-sink.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"process-sink.d.ts","sourceRoot":"","sources":["../../../src/utils/log/process-sink.ts"],"names":[],"mappings":"AAYA,OAAO,KAAK,EAAE,WAAW,EAAE,OAAO,EAAE,eAAe,EAAE,sBAAsB,EAAE,MAAM,YAAY,CAAA;AAU/F,wBAAgB,kBAAkB,CACjC,IAAI,EAAE,OAAO,EACb,KAAK,EAAE,WAAW,EAClB,IAAI,GAAE;IAAE,QAAQ,CAAC,OAAO,CAAC,EAAE,OAAO,CAAA;CAAO,GACvC,IAAI,CAmBN;AAED,iFAAiF;AACjF,wBAAgB,cAAc,IAC3B;IAAE,QAAQ,CAAC,IAAI,EAAE,OAAO,CAAC;IAAC,QAAQ,CAAC,KAAK,EAAE,WAAW,CAAC;IAAC,QAAQ,CAAC,QAAQ,EAAE,eAAe,CAAA;CAAE,GAC3F,SAAS,CAEX;AAED;;;;;;;GAOG;AACH,wBAAgB,sBAAsB,IAAI,sBAAsB,GAAG,SAAS,CAE3E;AAED;;;;;;GAMG;AACH,wBAAgB,0BAA0B,IAAI,IAAI,CAEjD"}