react-native-nitro-logger 0.1.0

package/lib/module/privacy.js

@@ -0,0 +1,349 @@
+"use strict";
+
+/**
+ * The privacy layer, deliberately a single module.
+ *
+ * Marker inspection and redaction live together so that payload recovery
+ * stays closure-private. If `inspectMarker` were exported, anyone could deep
+ * import the compiled module and read back a `priv()` payload in production,
+ * which would defeat the whole no-reveal contract regardless of what the
+ * package entry point re-exports. Nothing here that can return a payload
+ * crosses the module boundary.
+ */
+
+/** What a redacted value renders as in a log line. */
+export const PRIVATE_PLACEHOLDER = '<private>';
+
+/** What a marker renders as if it is stringified directly (interpolated into
+ * a message, spread, inspected). Never the payload — a marker leaking its
+ * value through `String()` would defeat the whole contract. */
+const MARKER_PLACEHOLDER = '<redacted>';
+
+/**
+ * Metadata keys are structural, never data. Anything outside this shape is
+ * a sign a value was used as a key — the classic `patient123: …` leak.
+ *
+ * The enforcing RegExp is module-private and only its source is exported. A
+ * shared RegExp object is mutable: a consumer could assign an own `test`
+ * method or call `RegExp.prototype.compile` on it and silently disable key
+ * validation for the whole process. Callers that want to pre-check a key
+ * build their own from {@link METADATA_KEY_PATTERN_SOURCE}.
+ */
+const METADATA_KEY_PATTERN = /^[A-Za-z0-9._-]{1,64}$/;
+
+/** Source text of the key rule, for callers that want their own RegExp. */
+export const METADATA_KEY_PATTERN_SOURCE = '^[A-Za-z0-9._-]{1,64}$';
+function isValidMetadataKey(key) {
+  return METADATA_KEY_PATTERN.test(key);
+}
+
+/** Reserved key carrying the fixed diagnostic: how many entries this call
+ * dropped. A count only — never which keys, never why, never the values. */
+export const DROPPED_COUNT_KEY = 'droppedMetadataCount';
+
+/** Upper bound on catalog size. A hostile or accidental infinite iterable
+ * must not be able to hang the JS thread inside a logging config call. */
+export const MAX_CATALOG_SIZE = 4096;
+
+/** A value explicitly marked safe to render. Opaque: the payload lives in a
+ * module-private WeakMap, never on the object. */
+
+/** A value explicitly marked sensitive. Renders as `<private>` outside dev. */
+
+// Membership in these maps is the ONLY proof that an object is a marker.
+// A foreign lookalike — same shape, same toString — fails naturally because
+// it was never registered here, and no code outside this module can register
+// one. WeakMaps also keep the payload unreachable: there is no enumerable
+// field to spread, stringify, or inspect.
+const publicPayloads = new WeakMap();
+const privatePayloads = new WeakMap();
+const invalidMarkers = new WeakSet();
+
+/**
+ * Exactly the primitives the pipeline can render. Objects, arrays, proxies,
+ * functions, symbols, null/undefined, NaN and the infinities are all
+ * rejected — an object payload is the classic way PHI slips into a log.
+ */
+function isLogPrimitive(value) {
+  const kind = typeof value;
+  return kind === 'string' || kind === 'boolean' || kind === 'number' && Number.isFinite(value);
+}
+function createMarker() {
+  const marker = {};
+  const hide = (key, value) => {
+    Object.defineProperty(marker, key, {
+      value,
+      enumerable: false,
+      writable: false,
+      configurable: false
+    });
+  };
+  const placeholder = () => MARKER_PLACEHOLDER;
+  // Non-enumerable, so `{...marker}` and `Object.keys(marker)` see nothing.
+  hide('toString', placeholder);
+  hide('toJSON', placeholder);
+  hide(Symbol.toPrimitive, placeholder);
+  hide(Symbol.for('nodejs.util.inspect.custom'), placeholder);
+  hide(Symbol.toStringTag, 'RedactedLogValue');
+  return Object.freeze(marker);
+}
+
+/**
+ * Mark a value safe to render even under a `'private'` privacy default.
+ *
+ * The payload is validated here AND again at emit: `pub(patient as any)`
+ * must not smuggle an object past the primitive check. An invalid payload
+ * does not throw — logging never crashes the caller — it produces a marker
+ * that is dropped at emit and counted in the fixed diagnostic.
+ */
+export function pub(value) {
+  const marker = createMarker();
+  if (isLogPrimitive(value)) {
+    publicPayloads.set(marker, value);
+  } else {
+    invalidMarkers.add(marker);
+  }
+  return marker;
+}
+
+/** Mark a value sensitive: renders as `<private>` outside dev builds, even
+ * under a `'public'` privacy default. Same fail-closed validation as `pub`. */
+export function priv(value) {
+  const marker = createMarker();
+  if (isLogPrimitive(value)) {
+    privatePayloads.set(marker, value);
+  } else {
+    invalidMarkers.add(marker);
+  }
+  return marker;
+}
+
+/**
+ * Stands in for a value that could not be read when a snapshot was taken —
+ * a getter that threw while a scope was being constructed.
+ *
+ * It is registered as an invalid marker, so redaction drops it and counts
+ * it like any other rejected value. Without it the key would vanish at
+ * snapshot time and never appear in `droppedMetadataCount`, which is the
+ * one thing a silent drop must never do. It carries no payload.
+ */
+export const UNREADABLE_VALUE = (() => {
+  const marker = createMarker();
+  invalidMarkers.add(marker);
+  return marker;
+})();
+/** Module-private by design — see the note at the top of this file. */
+function inspectMarker(value) {
+  if (value === null || typeof value !== 'object') return null;
+  const candidate = value;
+  if (publicPayloads.has(candidate)) {
+    const payload = publicPayloads.get(candidate);
+    return isLogPrimitive(payload) ? {
+      kind: 'public',
+      payload
+    } : {
+      kind: 'invalid'
+    };
+  }
+  if (privatePayloads.has(candidate)) {
+    const payload = privatePayloads.get(candidate);
+    return isLogPrimitive(payload) ? {
+      kind: 'private',
+      payload
+    } : {
+      kind: 'invalid'
+    };
+  }
+  if (invalidMarkers.has(candidate)) return {
+    kind: 'invalid'
+  };
+  return null;
+}
+
+// The reveal branch exists only in dev builds. Metro substitutes a literal
+// for `__DEV__`, so in a release bundle the whole block — sentinel string
+// included — is dead code and gets stripped. M7's CI job greps the release
+// bundle for the sentinel to prove it.
+let revealBranchSentinel = '';
+
+/** True when private values may render as themselves: dev builds only.
+ * There is deliberately no runtime switch to turn this on in production. */
+function privateRevealAllowed() {
+  if (typeof __DEV__ !== 'undefined' && __DEV__) {
+    revealBranchSentinel = '__NITRO_LOGGER_PRIVATE_REVEAL__';
+    return true;
+  }
+  return false;
+}
+
+/** @internal Test/CI hook — non-empty only once the dev reveal branch ran.
+ * Returns a build-time marker, never a payload. */
+export function __revealBranchSentinel() {
+  return revealBranchSentinel;
+}
+
+// ── Configuration ───────────────────────────────────────────────────────────
+
+/**
+ * Coerce a caller-supplied privacy default. TypeScript's union is not a
+ * runtime guarantee — JS callers, JSON config, and `any` all reach here — so
+ * anything that is not exactly `'public'` or `'private'` resolves to
+ * `'private'`. Ambiguity must never resolve toward disclosure.
+ */
+export function normalizePrivacyDefault(value) {
+  return value === 'public' ? 'public' : 'private';
+}
+
+/**
+ * Build a catalog from caller-supplied input without trusting it. A
+ * non-iterable, an iterator that throws mid-way, a non-string entry, or an
+ * iterable longer than {@link MAX_CATALOG_SIZE} all yield an empty set: the
+ * caller's tighten-only intent is honored in the safest possible direction,
+ * and a runaway iterable cannot hang the JS thread.
+ */
+export function buildCatalog(keys) {
+  const result = new Set();
+  if (keys === null || typeof keys !== 'object') return result;
+  try {
+    // Bound on entries CONSUMED, not on set size: an iterator that yields
+    // the same valid key forever never grows the set, so a size-based bound
+    // would spin the JS thread indefinitely.
+    let consumed = 0;
+    for (const key of keys) {
+      if (++consumed > MAX_CATALOG_SIZE) return new Set();
+      if (typeof key !== 'string' || !isValidMetadataKey(key)) {
+        return new Set();
+      }
+      result.add(key);
+    }
+  } catch {
+    return new Set();
+  }
+  return result;
+}
+
+/**
+ * Whether an unconfigured catalog blocks everything.
+ *
+ * Under a `'private'` default — the telehealth/strict profile — the catalog
+ * is mandatory and fail-closed: rejecting computed keys is not enough, since
+ * a literal key like `patient123` is still PHI. With no catalog configured,
+ * no key is approved and all metadata drops. That is deliberate; it forces
+ * the app to declare its keys rather than failing open.
+ */
+function catalogRequired(settings) {
+  return settings.privacyDefault === 'private';
+}
+
+// ── Redaction ───────────────────────────────────────────────────────────────
+
+const DROP = {
+  kind: 'drop'
+};
+
+/** Record which source owns each of its keys, without reading any value. */
+function claimKeys(owner, source) {
+  if (!source) return;
+  let keys;
+  try {
+    keys = Object.keys(source);
+  } catch {
+    return;
+  }
+  for (const key of keys) {
+    owner.set(key, source);
+  }
+}
+function resolveValue(raw, settings) {
+  let visibility;
+  let payload;
+  const marker = inspectMarker(raw);
+  if (marker !== null) {
+    // A marker whose payload failed validation at construction or here —
+    // `pub(someObject as any)` — fails closed rather than rendering.
+    if (marker.kind === 'invalid') return DROP;
+    visibility = marker.kind;
+    payload = marker.payload;
+  } else if (isLogPrimitive(raw)) {
+    visibility = settings.privacyDefault;
+    payload = raw;
+  } else {
+    // Objects, arrays, proxies, functions, symbols, null, NaN, Infinity.
+    return DROP;
+  }
+  if (settings.redactAll) return {
+    kind: 'value',
+    value: PRIVATE_PLACEHOLDER
+  };
+  if (visibility === 'public') return {
+    kind: 'value',
+    value: payload
+  };
+  return {
+    kind: 'value',
+    value: privateRevealAllowed() ? payload : PRIVATE_PLACEHOLDER
+  };
+}
+
+/**
+ * Resolve caller metadata into what destinations may see.
+ *
+ * Takes metadata as ordered sources — a scope's defaults followed by the
+ * call site's — rather than a pre-merged object. Merging eagerly would read
+ * every value before any key was checked, which is exactly what this
+ * function exists to avoid: precedence is settled per key first, then the
+ * winning key is validated, and only a key that survives has its value read.
+ * A getter behind a malformed, reserved, or unapproved key therefore never
+ * runs, and neither does a getter the call site overrode.
+ *
+ * Every rejection — bad key, throwing getter, unsupported value —
+ * increments one count. The count is all that is reported: the diagnostic
+ * itself must not become the leak.
+ *
+ * The result is a frozen null-prototype object. A source whose keys cannot
+ * be enumerated at all (a Proxy with a throwing `ownKeys` trap) contributes
+ * nothing, since there is no key that could be safely counted or described.
+ */
+export function redactMetadata(scopeMetadata, callSiteMetadata, settings) {
+  // Two explicit positional sources rather than a collection. A container
+  // in the signature would itself be caller-controlled — a hostile array
+  // could throw from Symbol.iterator, iterate forever, or be a revoked
+  // Proxy — and guarding it is strictly more work than not having one.
+  const owner = new Map();
+  claimKeys(owner, scopeMetadata);
+  // Second wins on collision: the call site overrides the scope's default.
+  claimKeys(owner, callSiteMetadata);
+  if (owner.size === 0) return undefined;
+  const catalog = settings.keyCatalog;
+  const requireCatalog = catalogRequired(settings);
+  const result = Object.create(null);
+  let dropped = 0;
+  for (const [key, source] of owner) {
+    if (key === DROPPED_COUNT_KEY || !isValidMetadataKey(key)) {
+      dropped += 1;
+      continue;
+    }
+    if (catalog !== undefined ? !catalog.has(key) : requireCatalog) {
+      dropped += 1;
+      continue;
+    }
+
+    // Only now — after the key has earned it — is the value touched.
+    let raw;
+    try {
+      raw = source[key];
+    } catch {
+      dropped += 1;
+      continue;
+    }
+    const resolution = resolveValue(raw, settings);
+    if (resolution.kind === 'drop') {
+      dropped += 1;
+      continue;
+    }
+    result[key] = resolution.value;
+  }
+  if (dropped > 0) result[DROPPED_COUNT_KEY] = dropped;
+  return Object.freeze(result);
+}
+//# sourceMappingURL=privacy.js.map

package/lib/module/privacy.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["PRIVATE_PLACEHOLDER","MARKER_PLACEHOLDER","METADATA_KEY_PATTERN","METADATA_KEY_PATTERN_SOURCE","isValidMetadataKey","key","test","DROPPED_COUNT_KEY","MAX_CATALOG_SIZE","publicPayloads","WeakMap","privatePayloads","invalidMarkers","WeakSet","isLogPrimitive","value","kind","Number","isFinite","createMarker","marker","hide","Object","defineProperty","enumerable","writable","configurable","placeholder","Symbol","toPrimitive","for","toStringTag","freeze","pub","set","add","priv","UNREADABLE_VALUE","inspectMarker","candidate","has","payload","get","revealBranchSentinel","privateRevealAllowed","__DEV__","__revealBranchSentinel","normalizePrivacyDefault","buildCatalog","keys","result","Set","consumed","catalogRequired","settings","privacyDefault","DROP","claimKeys","owner","source","resolveValue","raw","visibility","redactAll","redactMetadata","scopeMetadata","callSiteMetadata","Map","size","undefined","catalog","keyCatalog","requireCatalog","create","dropped","resolution"],"sourceRoot":"../../src","sources":["privacy.ts"],"mappings":"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","ignoreList":[]}

package/lib/module/specs/FileSink.nitro.js

@@ -0,0 +1,4 @@
+"use strict";
+
+export {};
+//# sourceMappingURL=FileSink.nitro.js.map

package/lib/module/specs/FileSink.nitro.js.map

@@ -0,0 +1 @@
+{"version":3,"names":[],"sourceRoot":"../../../src","sources":["specs/FileSink.nitro.ts"],"mappings":"","ignoreList":[]}

package/lib/module/specs/NativeConsoleSink.nitro.js

@@ -0,0 +1,4 @@
+"use strict";
+
+export {};
+//# sourceMappingURL=NativeConsoleSink.nitro.js.map

package/lib/module/specs/NativeConsoleSink.nitro.js.map

@@ -0,0 +1 @@
+{"version":3,"names":[],"sourceRoot":"../../../src","sources":["specs/NativeConsoleSink.nitro.ts"],"mappings":"","ignoreList":[]}

package/lib/module/types.js

@@ -0,0 +1,4 @@
+"use strict";
+
+export {};
+//# sourceMappingURL=types.js.map

package/lib/module/types.js.map

@@ -0,0 +1 @@
+{"version":3,"names":[],"sourceRoot":"../../src","sources":["types.ts"],"mappings":"","ignoreList":[]}

package/lib/module/utf8.js

@@ -0,0 +1,42 @@
+"use strict";
+
+/**
+ * UTF-8 byte length, without allocating an encoder.
+ *
+ * `TextEncoder` is not guaranteed on every Hermes build this package targets,
+ * and counting is cheaper than encoding when the answer is all that is
+ * wanted. Every byte budget in this package — the sink's payload cap, the
+ * batcher's pending cap, a formatter's truncation limit — is a UTF-8 budget,
+ * because that is what actually reaches the file.
+ *
+ * An unpaired surrogate counts as 3, matching every standard encoder: it has
+ * no UTF-8 form of its own, so encoders substitute U+FFFD, which is three
+ * bytes.
+ */
+export function utf8Length(text) {
+  let bytes = 0;
+  for (let i = 0; i < text.length; i += 1) {
+    const code = text.charCodeAt(i);
+    if (code < 0x80) {
+      bytes += 1;
+    } else if (code < 0x800) {
+      bytes += 2;
+    } else if (code >= 0xd800 && code <= 0xdbff) {
+      const next = text.charCodeAt(i + 1);
+      if (next >= 0xdc00 && next <= 0xdfff) {
+        bytes += 4;
+        i += 1;
+      } else {
+        // Lone high surrogate: encodes as U+FFFD.
+        bytes += 3;
+      }
+    } else if (code >= 0xdc00 && code <= 0xdfff) {
+      // Lone low surrogate: likewise.
+      bytes += 3;
+    } else {
+      bytes += 3;
+    }
+  }
+  return bytes;
+}
+//# sourceMappingURL=utf8.js.map

package/lib/module/utf8.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["utf8Length","text","bytes","i","length","code","charCodeAt","next"],"sourceRoot":"../../src","sources":["utf8.ts"],"mappings":";;AAAA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,OAAO,SAASA,UAAUA,CAACC,IAAY,EAAU;EAC/C,IAAIC,KAAK,GAAG,CAAC;EACb,KAAK,IAAIC,CAAC,GAAG,CAAC,EAAEA,CAAC,GAAGF,IAAI,CAACG,MAAM,EAAED,CAAC,IAAI,CAAC,EAAE;IACvC,MAAME,IAAI,GAAGJ,IAAI,CAACK,UAAU,CAACH,CAAC,CAAC;IAC/B,IAAIE,IAAI,GAAG,IAAI,EAAE;MACfH,KAAK,IAAI,CAAC;IACZ,CAAC,MAAM,IAAIG,IAAI,GAAG,KAAK,EAAE;MACvBH,KAAK,IAAI,CAAC;IACZ,CAAC,MAAM,IAAIG,IAAI,IAAI,MAAM,IAAIA,IAAI,IAAI,MAAM,EAAE;MAC3C,MAAME,IAAI,GAAGN,IAAI,CAACK,UAAU,CAACH,CAAC,GAAG,CAAC,CAAC;MACnC,IAAII,IAAI,IAAI,MAAM,IAAIA,IAAI,IAAI,MAAM,EAAE;QACpCL,KAAK,IAAI,CAAC;QACVC,CAAC,IAAI,CAAC;MACR,CAAC,MAAM;QACL;QACAD,KAAK,IAAI,CAAC;MACZ;IACF,CAAC,MAAM,IAAIG,IAAI,IAAI,MAAM,IAAIA,IAAI,IAAI,MAAM,EAAE;MAC3C;MACAH,KAAK,IAAI,CAAC;IACZ,CAAC,MAAM;MACLA,KAAK,IAAI,CAAC;IACZ;EACF;EACA,OAAOA,KAAK;AACd","ignoreList":[]}

package/lib/typescript/package.json

@@ -0,0 +1 @@
+{"type":"module"}

package/lib/typescript/src/Logger.d.ts

@@ -0,0 +1,122 @@
+import type { LazyMessage, LogLevel, LogMetadata } from './types.js';
+import type { LogDestination } from './destinations/types.js';
+import type { PrivacyDefault } from './privacy.js';
+import { ScopedLogger } from './ScopedLogger.js';
+export interface LogOptions {
+    level?: LogLevel;
+    subsystem?: string;
+    metadata?: LogMetadata;
+    /** Scope defaults, outranked by `metadata` on any key they share. Kept a
+     * separate field rather than pre-merged: redaction settles precedence per
+     * key and validates the winner before reading it, which a merge would
+     * defeat by reading everything first. `ScopedLogger` sets this. */
+    scopeMetadata?: LogMetadata;
+    correlation?: string;
+}
+/**
+ * The logger. Access through the `Log` singleton.
+ *
+ * Everything runs on the JS thread, so unlike the Swift original there is no
+ * lock or config-snapshot machinery — plain fields mutated by the fluent
+ * methods are safe by construction.
+ *
+ * Pipeline per message: resolve effective level (exact subsystem → parent
+ * walk → global) → collect destinations passing isEnabled AND minimumLevel →
+ * return BEFORE evaluating a lazy message when none remain → evaluate once,
+ * guarded → prepare metadata (redaction seam; M2 adds privacy wrappers) →
+ * freeze → fan out with per-destination isolation.
+ *
+ * Destinations are treated as untrusted: every property read and call is
+ * guarded so one faulty implementation can neither crash the app nor starve
+ * its siblings.
+ */
+export declare class Logger {
+    private globalMinimum;
+    private readonly subsystemLevels;
+    private registrations;
+    /** Consecutive write-failure counts per destination label. */
+    private readonly failureCounts;
+    private readonly disabledLabels;
+    private privacyDefaultValue;
+    private privacyDefaultLocked;
+    private redactAll;
+    private keyCatalog;
+    /**
+     * Choose how bare (unmarked) metadata values are treated.
+     *
+     * `'public'` — the OSS default — renders them. `'private'` redacts every
+     * bare value outside dev builds unless wrapped in `pub()`, so a forgotten
+     * wrapper hides data instead of leaking it. Apps handling PHI set
+     * `'private'` in their entry point.
+     *
+     * First call wins; later calls may only tighten (`'public'` → `'private'`).
+     * A request to loosen is ignored, not obeyed. Anything that is not exactly
+     * `'public'` or `'private'` — a JS caller, JSON config, an `any` — resolves
+     * to `'private'`: ambiguity must never resolve toward disclosure.
+     *
+     * `'private'` also makes the metadata key catalog mandatory — see
+     * {@link metadataKeyCatalog}.
+     */
+    privacyDefault(value: PrivacyDefault): this;
+    /** Redact every metadata value from here on, marked or not, dev or not.
+     * One-way: there is no call that undoes it. */
+    redactAllMetadata(): this;
+    /**
+     * Restrict metadata to an approved set of keys; anything else is dropped
+     * and counted. Rejecting computed keys is not enough on its own — a
+     * literal key like `patient123` is still PHI — so the catalog checks exact
+     * membership at runtime.
+     *
+     * Tighten-only: repeat calls intersect with the existing catalog rather
+     * than replacing it. Mandatory under a `'private'` privacy default, where
+     * an unconfigured catalog approves nothing and all metadata drops.
+     *
+     * Input is not trusted: a non-iterable, a throwing iterator, a non-string
+     * or malformed entry, or an over-long iterable all yield an empty catalog
+     * rather than an exception or a hung JS thread.
+     */
+    metadataKeyCatalog(keys: Iterable<string>): this;
+    private privacySettings;
+    /** Global minimum level; messages below it are discarded. Default 'debug'. */
+    minimumLevel(level: LogLevel): this;
+    /** Minimum level for a dot-hierarchical subsystem (`network` covers
+     * `network.api` unless the child sets its own). */
+    subsystem(name: string, level: LogLevel): this;
+    resetSubsystem(name: string): this;
+    /** Toggle console printing. The console destination's test sink, when set,
+     * keeps receiving lines regardless. */
+    consoleLogging(enabled: boolean): this;
+    /**
+     * Register a destination. A *different* destination already holding the
+     * same label is flushed, disposed, and replaced; re-adding an instance
+     * that is already registered is a no-op, because disposing and re-pushing
+     * the same object would leave a live destination in a closed state.
+     */
+    addDestination(destination: LogDestination): this;
+    removeDestination(label: string): this;
+    /** Drain every destination synchronously (bounded per destination). */
+    flush(deadlineMs?: number): void;
+    /** Short-lived random correlation ID — the encouraged way to correlate.
+     * Never derive correlation IDs from patient/visit/record identifiers. */
+    newCorrelationId(): string;
+    /** A scoped logger tagging every message with a correlation ID, optional
+     * subsystem, and default metadata. Omit `correlation` to auto-generate. */
+    scoped(correlation?: string, subsystem?: string, metadata?: LogMetadata): ScopedLogger;
+    log(message: LazyMessage, options?: LogOptions): void;
+    verbose(message: LazyMessage, metadata?: LogMetadata, subsystem?: string): void;
+    debug(message: LazyMessage, metadata?: LogMetadata, subsystem?: string): void;
+    info(message: LazyMessage, metadata?: LogMetadata, subsystem?: string): void;
+    warning(message: LazyMessage, metadata?: LogMetadata, subsystem?: string): void;
+    error(message: LazyMessage, metadata?: LogMetadata, subsystem?: string): void;
+    /** Marks incomplete work; highest severity so it always surfaces. */
+    todo(message: LazyMessage, metadata?: LogMetadata, subsystem?: string): void;
+    /** Integration entry point (ScopedLogger, error handler, bridges). */
+    logMessage(message: LazyMessage, options?: LogOptions): void;
+    /** Count a consecutive failure; disable the destination at the threshold.
+     * The diagnostic is fixed text — labels are caller-controlled, so including
+     * one would break the payload-free contract and invite log injection. */
+    private noteFailure;
+}
+/** Global shorthand, mirroring SwiftLogger's `Log`. */
+export declare const Log: Logger;
+//# sourceMappingURL=Logger.d.ts.map

package/lib/typescript/src/Logger.d.ts.map

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

package/lib/typescript/src/ScopedLogger.d.ts

@@ -0,0 +1,36 @@
+import type { LazyMessage, LogLevel, LogMetadata } from './types.js';
+import type { Logger } from './Logger.js';
+/**
+ * A lightweight logger that tags every message with a correlation ID,
+ * optional default subsystem, and default metadata. Direct port of
+ * SwiftLogger's ScopedLogger: immutable, delegates all work to the parent
+ * Logger, nests.
+ *
+ * Metadata semantics: the scope's metadata merges into every message;
+ * call-site keys win on collision (a message reporting `state: 'failed'`
+ * must not be masked by the scope's `state: 'running'`). Child scopes merge
+ * into — never replace — the parent's metadata.
+ */
+export declare class ScopedLogger {
+    private readonly logger;
+    readonly correlation: string;
+    readonly subsystem?: string | undefined;
+    /** Frozen snapshot taken at construction — mutating the object the caller
+     * passed in (or this field) after the fact must not change future logs,
+     * matching SwiftLogger's value semantics. */
+    readonly metadata?: Readonly<LogMetadata>;
+    constructor(logger: Logger, correlation: string, subsystem?: string | undefined, metadata?: LogMetadata);
+    log(message: LazyMessage, level?: LogLevel, metadata?: LogMetadata): void;
+    verbose(message: LazyMessage, metadata?: LogMetadata): void;
+    debug(message: LazyMessage, metadata?: LogMetadata): void;
+    info(message: LazyMessage, metadata?: LogMetadata): void;
+    warning(message: LazyMessage, metadata?: LogMetadata): void;
+    error(message: LazyMessage, metadata?: LogMetadata): void;
+    todo(message: LazyMessage, metadata?: LogMetadata): void;
+    /** Child scope: inherits this scope's subsystem unless overridden, merges
+     * metadata (child keys win). The merge happens at construction, like any
+     * scope snapshot — both sides are materialized here so later mutation of
+     * the caller's object cannot change what the child reports. */
+    scoped(correlation: string, subsystem?: string, metadata?: LogMetadata): ScopedLogger;
+}
+//# sourceMappingURL=ScopedLogger.d.ts.map

package/lib/typescript/src/ScopedLogger.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ScopedLogger.d.ts","sourceRoot":"","sources":["../../../src/ScopedLogger.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,WAAW,EAAE,QAAQ,EAAE,WAAW,EAAE,MAAM,YAAS,CAAC;AAClE,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,aAAU,CAAC;AAGvC;;;;;;;;;;GAUG;AACH,qBAAa,YAAY;IAOrB,OAAO,CAAC,QAAQ,CAAC,MAAM;IACvB,QAAQ,CAAC,WAAW,EAAE,MAAM;IAC5B,QAAQ,CAAC,SAAS,CAAC,EAAE,MAAM;IAR7B;;iDAE6C;IAC7C,QAAQ,CAAC,QAAQ,CAAC,EAAE,QAAQ,CAAC,WAAW,CAAC,CAAC;gBAGvB,MAAM,EAAE,MAAM,EACtB,WAAW,EAAE,MAAM,EACnB,SAAS,CAAC,EAAE,MAAM,YAAA,EAC3B,QAAQ,CAAC,EAAE,WAAW;IAMxB,GAAG,CACD,OAAO,EAAE,WAAW,EACpB,KAAK,GAAE,QAAiB,EACxB,QAAQ,CAAC,EAAE,WAAW,GACrB,IAAI;IAcP,OAAO,CAAC,OAAO,EAAE,WAAW,EAAE,QAAQ,CAAC,EAAE,WAAW,GAAG,IAAI;IAI3D,KAAK,CAAC,OAAO,EAAE,WAAW,EAAE,QAAQ,CAAC,EAAE,WAAW,GAAG,IAAI;IAIzD,IAAI,CAAC,OAAO,EAAE,WAAW,EAAE,QAAQ,CAAC,EAAE,WAAW,GAAG,IAAI;IAIxD,OAAO,CAAC,OAAO,EAAE,WAAW,EAAE,QAAQ,CAAC,EAAE,WAAW,GAAG,IAAI;IAI3D,KAAK,CAAC,OAAO,EAAE,WAAW,EAAE,QAAQ,CAAC,EAAE,WAAW,GAAG,IAAI;IAIzD,IAAI,CAAC,OAAO,EAAE,WAAW,EAAE,QAAQ,CAAC,EAAE,WAAW,GAAG,IAAI;IAIxD;;;mEAG+D;IAC/D,MAAM,CACJ,WAAW,EAAE,MAAM,EACnB,SAAS,CAAC,EAAE,MAAM,EAClB,QAAQ,CAAC,EAAE,WAAW,GACrB,YAAY;CAYhB"}

package/lib/typescript/src/config.d.ts

@@ -0,0 +1,12 @@
+import type { LogLevel } from './types.js';
+/**
+ * Resolves the effective minimum level for a subsystem by walking the
+ * dot-separated hierarchy: exact match, then each parent (`a.b.c` → `a.b` →
+ * `a`), then undefined so the caller falls back to the global minimum.
+ * Direct port of SwiftLogger's LoggerConfiguration.resolveSubsystemLevel.
+ *
+ * Single-threaded JS means no snapshot/locking machinery — a plain Map
+ * mutated by the fluent config methods is safe.
+ */
+export declare function resolveSubsystemLevel(subsystemLevels: ReadonlyMap<string, LogLevel>, name: string): LogLevel | undefined;
+//# sourceMappingURL=config.d.ts.map

package/lib/typescript/src/config.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"config.d.ts","sourceRoot":"","sources":["../../../src/config.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,YAAS,CAAC;AAExC;;;;;;;;GAQG;AACH,wBAAgB,qBAAqB,CACnC,eAAe,EAAE,WAAW,CAAC,MAAM,EAAE,QAAQ,CAAC,EAC9C,IAAI,EAAE,MAAM,GACX,QAAQ,GAAG,SAAS,CAUtB"}