@wow-two-beta/ui-vue 0.0.5 → 0.0.6

package/dist/foundation/json/LosslessJson.d.ts

@@ -0,0 +1,8 @@
+import { Result } from '../results';
+import { JsonFailure } from './models/JsonFailure';
+import { LosslessJsonValue } from './models/LosslessJsonValue';
+/** Lossless numeric JSON codec with explicit unsupported-value and resource failures. */
+export declare const LosslessJson: Readonly<{
+    parse(text: string): Result<LosslessJsonValue, JsonFailure>;
+    stringify(value: unknown): Result<string, JsonFailure>;
+}>;

package/dist/foundation/json/adapters/losslessJson/JsonAdapter.d.ts

@@ -0,0 +1,5 @@
+import { ExactNumber } from '../../../numbers';
+/** Keys have already been encoded to avoid the vendor's special object properties. */
+export declare function parseJson(text: string, number: (token: string) => ExactNumber): unknown;
+/** Special number serialization runs before ExactNumber's deliberately throwing toJSON. */
+export declare function stringifyJson(value: unknown): string;

package/dist/foundation/json/index.d.ts

@@ -0,0 +1,5 @@
+export { LosslessJson } from './LosslessJson';
+export { JsonFailureCode } from './JsonFailureCode';
+export { JsonLimits } from './JsonLimits';
+export type { JsonFailure } from './models/JsonFailure';
+export type { LosslessJsonValue } from './models/LosslessJsonValue';

package/dist/foundation/json/index.js

@@ -0,0 +1,7 @@
+import { J, a, L } from "../../chunks/index-BzMmo8Zb.js";
+export {
+  J as JsonFailureCode,
+  a as JsonLimits,
+  L as LosslessJson
+};
+//# sourceMappingURL=index.js.map

package/dist/foundation/json/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sources":[],"sourcesContent":[],"names":[],"mappings":";"}

package/dist/foundation/json/models/JsonFailure.d.ts

@@ -0,0 +1,6 @@
+import { JsonFailureCode } from '../JsonFailureCode';
+/** A safe diagnostic; does not echo potentially sensitive JSON input. */
+export interface JsonFailure {
+    readonly code: JsonFailureCode;
+    readonly message: string;
+}

package/dist/foundation/json/models/LosslessJsonValue.d.ts

@@ -0,0 +1,5 @@
+import { ExactNumber } from '../../numbers';
+/** Parsed numeric values always use the SDK type, including small integers. */
+export type LosslessJsonValue = null | boolean | string | ExactNumber | LosslessJsonValue[] | {
+    [key: string]: LosslessJsonValue;
+};

package/dist/foundation/logger/ConsoleLogSink.d.ts

@@ -4,5 +4,8 @@ export interface ConsoleLogSinkOptions {
     /** The tag prefixed to every message. Default `'[log]'`; pass `''` for no prefix. */
     readonly prefix?: string;
 }
-/** Creates a sink that writes each record to the matching `console` method — the development destination, opt-in like every other wire. */
+/**
+ * Creates a sink that writes each record to the matching `console` method — the development destination, opt-in
+ * like every other wire.
+ */
 export declare function consoleLogSink(options?: ConsoleLogSinkOptions): LogSink;

package/dist/foundation/logger/LogLevel.d.ts

@@ -1,4 +1,7 @@
-/** Defines the severity a record is emitted at — ordered `Trace` (finest) through `Error`, with `Silent` as the off switch. */
+/**
+ * Defines the severity a record is emitted at — ordered `Trace` (finest) through `Error`, with `Silent` as the
+ * off switch.
+ */
 export declare const LogLevel: {
     /** Refers to the finest-grained diagnostics — per-iteration detail, off in every deployed environment. */
     readonly Trace: "trace";
@@ -14,7 +17,10 @@ export declare const LogLevel: {
     readonly Silent: "silent";
 };
 export type LogLevel = (typeof LogLevel)[keyof typeof LogLevel];
-/** Provides the numeric severity of each level — the ordering {@link isLevelEnabled} compares on. `Silent` is infinite, so nothing clears it. */
+/**
+ * Provides the numeric severity of each level — the ordering {@link isLevelEnabled} compares on. `Silent` is
+ * infinite, so nothing clears it.
+ */
 export declare const LogLevelSeverity: Readonly<Record<LogLevel, number>>;
 /**
  * Checks whether a value is one of the known levels — guards the runtime `setLevel` dial and a level read

package/dist/foundation/logger/LogRecord.d.ts

@@ -1,6 +1,6 @@
 import { SerializedError } from '../errors';
 import { LogLevel } from './LogLevel';
-/** Defines the structured fields attached to a record — the "what was happening" that a message string alone cannot carry. */
+/** Defines the structured fields on a record — the "what was happening" that a message string alone cannot carry. */
 export type LogContext = Record<string, unknown>;
 /** Defines one emitted log entry — the payload handed to every registered sink. */
 export interface LogRecord {
@@ -10,7 +10,7 @@ export interface LogRecord {
     readonly message: string;
     /** When the record was created (epoch ms), stamped at call time — never at delivery time. */
     readonly timestamp: number;
-    /** The merged and redacted structured fields — logger context first, call-site keys winning. Empty when there were none. */
+    /** The merged and redacted fields — logger context first, call-site keys winning. Empty when there were none. */
     readonly context: LogContext;
     /** The serialized failure, when one was logged. Omitted otherwise. */
     readonly error?: SerializedError;

package/dist/foundation/logger/LogSink.d.ts

@@ -3,7 +3,7 @@ import { LogRecord } from './LogRecord';
 export interface LogSink {
     /** The name used in `onError` reporting — the only way a handler can tell which sink failed. */
     readonly name?: string;
-    /** Receives one record, already filtered by level and redacted. Treat it as read-only; it is shared across the fan-out. */
+    /** Receives one record, already filtered by level and redacted. Treat it as read-only; shared across the fan-out. */
     write(record: LogRecord): void;
 }
 /** Defines the context handed to `onError` when a sink's `write` throws. */
@@ -13,5 +13,8 @@ export interface LogSinkErrorContext {
     /** The record being written when it threw. */
     readonly record: LogRecord;
 }
-/** Defines the sink-failure handler — logging must never break the caller, so every sink throw lands here instead of propagating. */
+/**
+ * Defines the sink-failure handler — logging must never break the caller, so every sink throw lands here
+ * instead of propagating.
+ */
 export type LogErrorHandler = (error: unknown, context: LogSinkErrorContext) => void;

package/dist/foundation/logger/Logger.d.ts

@@ -8,14 +8,14 @@ export interface LoggerOptions {
     /** The starting threshold — records below it are dropped. Default {@link DefaultLogLevel}. */
     readonly level?: LogLevel;
     /** The sinks records fan out to. Copied on construction; empty means every call is a no-op. */
-    readonly sinks?: readonly LogSink[];
+    readonly sinks?: ReadonlyArray<LogSink>;
     /** The base structured fields merged into every record — service name, release, session id. */
     readonly context?: LogContext;
     /** The context keys whose values are masked, at any depth, case-insensitively. Default {@link DefaultRedactKeys}. */
-    readonly redactKeys?: readonly string[];
+    readonly redactKeys?: ReadonlyArray<string>;
     /** The placeholder written over a redacted value. Default {@link DefaultRedactionMask}. */
     readonly redactionMask?: string;
-    /** Receives every sink failure. Omitted means failures are swallowed — a broken sink is never worth an app crash. */
+    /** Receives every sink failure. Omitted → failures are swallowed; a broken sink is never worth an app crash. */
     readonly onError?: LogErrorHandler;
     /** Supplies the record timestamp (epoch ms) — injectable for deterministic tests. Default `Date.now`. */
     readonly now?: () => number;
@@ -32,11 +32,20 @@ export interface Logger {
     warn(message: string, context?: LogContext): void;
     /** Emits at `error` with structured context only. */
     error(message: string, context?: LogContext): void;
-    /** Emits at `error` with a caught value, serialized onto the record's `error`. Pass `undefined` to log context under a `message` key. */
+    /**
+     * Emits at `error` with a caught value, serialized onto the record's `error`. Pass `undefined` to log context
+     * under a `message` key.
+     */
     error(message: string, error: unknown, context?: LogContext): void;
-    /** Creates a logger whose records carry this one's context merged with `context` — the child's keys win. Sinks, level, and config are shared. */
+    /**
+     * Creates a logger whose records carry this one's context merged with `context` — the child's keys win.
+     * Sinks, level, and config are shared.
+     */
     child(context: LogContext): Logger;
-    /** Moves the threshold for the WHOLE logger tree at runtime — an unknown value is ignored rather than silently muting output. */
+    /**
+     * Moves the threshold for the WHOLE logger tree at runtime — an unknown value is ignored rather than silently
+     * muting output.
+     */
     setLevel(level: LogLevel): void;
     /** Reads the current threshold. */
     getLevel(): LogLevel;

package/dist/foundation/logger/MemoryLogSink.d.ts

@@ -3,7 +3,7 @@ import { LogSink } from './LogSink';
 /** Defines the in-memory sink returned by {@link memoryLogSink} — a sink plus the capture it records. */
 export interface MemoryLogSink extends LogSink {
     /** Every record written, in emit order. */
-    readonly records: readonly LogRecord[];
+    readonly records: ReadonlyArray<LogRecord>;
     /** Clears the capture — for a `beforeEach` reset of a shared instance. */
     reset(): void;
 }

package/dist/foundation/logger/Redaction.d.ts

@@ -1,15 +1,15 @@
 import { LogContext } from './LogRecord';
 /** Provides the context keys redacted by default — the credential names that show up in practically every payload. */
-export declare const DefaultRedactKeys: readonly string[];
+export declare const DefaultRedactKeys: ReadonlyArray<string>;
 /** Provides the placeholder written over a redacted value. */
 export declare const DefaultRedactionMask = "[redacted]";
 /** Provides the placeholder written where the walk met a value already on the current path. */
 export declare const CircularMarker = "[circular]";
 /** Provides the placeholder written where reading a property threw — a getter or a `Proxy` trap. */
 export declare const UnreadableMarker = "[unreadable]";
-/** Provides the placeholder written where the walk hit {@link DefaultMaxRedactDepth} — fail-closed, so nothing below it escapes unredacted. */
+/** Provides the placeholder written at {@link DefaultMaxRedactDepth} — fail-closed, so nothing below escapes. */
 export declare const TruncatedMarker = "[truncated]";
-/** Provides how many levels the walk descends before truncating — deep enough for any real context, shallow enough to bound the work. */
+/** Provides how many levels the walk descends before truncating — deep enough for real context, still bounded. */
 export declare const DefaultMaxRedactDepth = 8;
 /**
  * Checks whether a value is a plain object — prototype `Object.prototype` or `null`. `getPrototypeOf` is a
@@ -26,4 +26,4 @@ export declare function isPlainObject(value: unknown): value is Record<string, u
  * Never throws — a hostile context (throwing getters, `Proxy` traps, self-reference, pathological depth)
  * degrades to markers, and a total failure degrades to `{}`.
  */
-export declare function redactContext(context: LogContext, redactKeys?: readonly string[], mask?: string): LogContext;
+export declare function redactContext(context: LogContext, redactKeys?: ReadonlyArray<string>, mask?: string): LogContext;

package/dist/foundation/logger/index.js

@@ -1,5 +1,5 @@
-import { i as isErrorLike } from "../../chunks/ErrorLike-Cfj0lZW3.js";
-import { s as serializeError } from "../../chunks/SerializeError-CclP2jCW.js";
+import { a as isErrorLike } from "../../chunks/ErrorLike-CRnbeEM0.js";
+import { s as serializeError } from "../../chunks/SerializeError-BzTdy-3I.js";
 const LogLevel = {
   /** Refers to the finest-grained diagnostics — per-iteration detail, off in every deployed environment. */
   Trace: "trace",
@@ -72,7 +72,12 @@ function redactValue(value, keys, mask, depth, path) {
     }
     const copy = {};
     for (const key of readKeys(value)) {
-      copy[key] = keys.has(key.toLowerCase()) ? mask : redactValue(readProperty(value, key), keys, mask, depth + 1, path);
+      Object.defineProperty(copy, key, {
+        value: keys.has(key.toLowerCase()) ? mask : redactValue(readProperty(value, key), keys, mask, depth + 1, path),
+        enumerable: true,
+        writable: true,
+        configurable: true
+      });
     }
     return copy;
   } finally {

package/dist/foundation/logger/index.js.map

@@ -1 +1 @@
-{"version":3,"file":"index.js","sources":["../../../src/foundation/logger/LogLevel.ts","../../../src/foundation/logger/Redaction.ts","../../../src/foundation/logger/Logger.ts","../../../src/foundation/logger/ConsoleLogSink.ts","../../../src/foundation/logger/MemoryLogSink.ts"],"sourcesContent":["// The severity vocabulary, plus the one comparison the emit path makes. A const object rather than a TS\n// `enum`, matching `BackoffStrategy` / `AnalyticsCallKind`: an `enum` emits a runtime object into every\n// consumer's bundle and is not erasable under `verbatimModuleSyntax`, while this shape tree-shakes and its\n// values are plain strings a sink can print or ship as-is.\n//\n// `Silent` is a THRESHOLD-ONLY value: it exists so `createLogger({ level: LogLevel.Silent })` drops\n// everything, and no record is ever emitted at it. Hence `Number.POSITIVE_INFINITY` for its severity —\n// nothing clears it — plus the explicit guard in `isLevelEnabled`, without which the degenerate\n// `isLevelEnabled(Silent, Silent)` (`Infinity >= Infinity`) would read as enabled.\n//\n// Severities are spaced by ten so a consumer can slot a custom level between two of ours without\n// renumbering the set.\n\n/** Defines the severity a record is emitted at — ordered `Trace` (finest) through `Error`, with `Silent` as the off switch. */\nexport const LogLevel = {\n  /** Refers to the finest-grained diagnostics — per-iteration detail, off in every deployed environment. */\n  Trace: 'trace',\n  /** Refers to developer-facing detail for diagnosing — request payloads, cache hits, retry decisions. */\n  Debug: 'debug',\n  /** Refers to the normal-operation narrative — lifecycle milestones worth keeping in production. */\n  Info: 'info',\n  /** Refers to a recovered or degraded condition — the app continued, but something was off. */\n  Warn: 'warn',\n  /** Refers to a failure the app could not absorb — the level the `error` payload rides on. */\n  Error: 'error',\n  /** Refers to the threshold that drops everything. Only ever set as a level; never emitted on a record. */\n  Silent: 'silent',\n} as const;\n\nexport type LogLevel = (typeof LogLevel)[keyof typeof LogLevel];\n\n/** Provides the numeric severity of each level — the ordering {@link isLevelEnabled} compares on. `Silent` is infinite, so nothing clears it. */\nexport const LogLevelSeverity: Readonly<Record<LogLevel, number>> = {\n  [LogLevel.Trace]: 10,\n  [LogLevel.Debug]: 20,\n  [LogLevel.Info]: 30,\n  [LogLevel.Warn]: 40,\n  [LogLevel.Error]: 50,\n  [LogLevel.Silent]: Number.POSITIVE_INFINITY,\n};\n\n/**\n * Checks whether a value is one of the known levels — guards the runtime `setLevel` dial and a level read\n * from an env var, where an unrecognized string would otherwise mute the logger in silence.\n *\n * Never throws.\n */\nexport function isLogLevel(value: unknown): value is LogLevel {\n  return typeof value === 'string' && Object.hasOwn(LogLevelSeverity, value);\n}\n\n/**\n * Checks whether a record at `level` clears `threshold` — the single comparison guarding the emit path,\n * made before any context merge, redaction, or error serialization is paid for.\n *\n * `Silent` never passes as a `level`, even against a `Silent` threshold.\n *\n * Never throws.\n */\nexport function isLevelEnabled(level: LogLevel, threshold: LogLevel): boolean {\n  if (level === LogLevel.Silent) return false;\n  return LogLevelSeverity[level] >= LogLevelSeverity[threshold];\n}\n","// Redaction runs on the way IN — inside the logger, before the record reaches any sink — rather than\n// inside each sink. A sink is third-party code that may ship off the device, so a secret that reaches one\n// has already leaked; asking every adapter to redact is asking for the one that forgets.\n//\n// Decisions:\n//\n// - **Keys match case-insensitively; matched values are dropped whole.** `Authorization` / `authorization`\n//   / `AUTHORIZATION` are the same header. A partial mask (`sk-…f31a`) still leaks a prefix and invites a\n//   per-call-site judgement about whether that is enough, so the value is replaced regardless of its type —\n//   a matched key whose value is an object does not get walked.\n// - **The walk copies; it never mutates.** The caller's object is theirs and is very often live\n//   application state — redacting in place would erase a real token from a real session, which is exactly\n//   the kind of damage a logger must never do.\n// - **Recursion covers arrays and PLAIN objects only.** `Object.keys(new Date())` is empty, so walking a\n//   `Date` / `Map` / `URL` / class instance would silently replace it with `{}`. Everything non-plain\n//   passes through by reference — worth knowing, because a secret held on a class instance is NOT redacted.\n//\n// The input is assumed hostile, because a context object is assembled at a call site that may itself be\n// mid-failure: a cycle is cut with `CircularMarker`, a throwing getter or `ownKeys` trap yields\n// `UnreadableMarker`, and depth is capped at `DefaultMaxRedactDepth`. The cap is fail-CLOSED — the subtree\n// becomes `TruncatedMarker` rather than passing through unredacted — and it is what keeps a pathological\n// graph from overflowing the stack, which is the one way this could otherwise break its no-throw contract.\n//\n// Cycles are tracked along the current PATH (added before descending, removed after), not globally, so a\n// value legitimately referenced by several siblings still renders each time instead of the second and later\n// occurrences reading as circular.\n\nimport type { LogContext } from './LogRecord';\n\n/** Provides the context keys redacted by default — the credential names that show up in practically every payload. */\nexport const DefaultRedactKeys: readonly string[] = ['password', 'token', 'secret', 'authorization', 'apiKey'];\n\n/** Provides the placeholder written over a redacted value. */\nexport const DefaultRedactionMask = '[redacted]';\n\n/** Provides the placeholder written where the walk met a value already on the current path. */\nexport const CircularMarker = '[circular]';\n\n/** Provides the placeholder written where reading a property threw — a getter or a `Proxy` trap. */\nexport const UnreadableMarker = '[unreadable]';\n\n/** Provides the placeholder written where the walk hit {@link DefaultMaxRedactDepth} — fail-closed, so nothing below it escapes unredacted. */\nexport const TruncatedMarker = '[truncated]';\n\n/** Provides how many levels the walk descends before truncating — deep enough for any real context, shallow enough to bound the work. */\nexport const DefaultMaxRedactDepth = 8;\n\n/**\n * Checks whether a value is a plain object — prototype `Object.prototype` or `null`. `getPrototypeOf` is a\n * trappable operation, so the read is guarded. Internal; not barrelled.\n */\nexport function isPlainObject(value: unknown): value is Record<string, unknown> {\n  if (value === null || typeof value !== 'object') return false;\n  try {\n    const prototype: unknown = Object.getPrototypeOf(value);\n    return prototype === Object.prototype || prototype === null;\n  } catch {\n    return false;\n  }\n}\n\n/** Reads one property without trusting the source — a getter and a `Proxy` `get` trap can both throw. */\nfunction readProperty(source: Record<string, unknown>, key: string): unknown {\n  try {\n    return source[key];\n  } catch {\n    return UnreadableMarker;\n  }\n}\n\n/** Lists a source's own enumerable keys without trusting it — an `ownKeys` trap can throw. */\nfunction readKeys(source: Record<string, unknown>): readonly string[] {\n  try {\n    return Object.keys(source);\n  } catch {\n    return [];\n  }\n}\n\n/** Walks one value, copying it with matched keys masked. Recurses only into arrays and plain objects. */\nfunction redactValue(\n  value: unknown,\n  keys: ReadonlySet<string>,\n  mask: string,\n  depth: number,\n  path: Set<object>,\n): unknown {\n  if (!Array.isArray(value) && !isPlainObject(value)) return value;\n\n  const container: object = value;\n  if (path.has(container)) return CircularMarker;\n  if (depth >= DefaultMaxRedactDepth) return TruncatedMarker;\n\n  path.add(container);\n  try {\n    if (Array.isArray(value)) {\n      const items: unknown[] = [];\n      // `for…of` over the array itself — indexed access would be `T | undefined` under\n      // `noUncheckedIndexedAccess`, and a hole would then be indistinguishable from a stored `undefined`.\n      for (const item of value) items.push(redactValue(item, keys, mask, depth + 1, path));\n      return items;\n    }\n\n    const copy: Record<string, unknown> = {};\n    for (const key of readKeys(value)) {\n      copy[key] = keys.has(key.toLowerCase())\n        ? mask\n        : redactValue(readProperty(value, key), keys, mask, depth + 1, path);\n    }\n    return copy;\n  } finally {\n    path.delete(container);\n  }\n}\n\n/**\n * Copies a context object with every value under a matching key replaced by `mask`, at any nesting depth.\n * Key matching is case-insensitive.\n *\n * The result is always a fresh, cycle-free, depth-bounded plain object, so it is safe to `JSON.stringify`\n * and safe to hand to a sink that outlives the call. The source is never mutated.\n *\n * Never throws — a hostile context (throwing getters, `Proxy` traps, self-reference, pathological depth)\n * degrades to markers, and a total failure degrades to `{}`.\n */\nexport function redactContext(\n  context: LogContext,\n  redactKeys: readonly string[] = DefaultRedactKeys,\n  mask: string = DefaultRedactionMask,\n): LogContext {\n  try {\n    const keys = new Set(redactKeys.map((key) => key.toLowerCase()));\n    const redacted = redactValue(context, keys, mask, 0, new Set<object>());\n    // Non-plain input (a class instance cast to a context) is not walked, so it cannot be proven safe —\n    // dropping it keeps the \"always a plain, serializable object\" guarantee the sinks rely on.\n    return isPlainObject(redacted) ? redacted : {};\n  } catch {\n    return {};\n  }\n}\n","// The logger every app talks to. One contract dominates every decision in this file:\n//\n// DEFINING CONTRACT: NO METHOD HERE THROWS. `logger.error(...)` is called from `catch` blocks, error\n// boundaries, and unhandled-rejection handlers — precisely where a second exception masks the first and\n// takes down the path that was meant to recover. So the emit body is wrapped end to end, every sink is\n// invoked in isolation, and `onError` (itself wrapped) is the only place a failure ever surfaces. A hostile\n// context, a `Proxy` that throws from every trap, a sink that always throws, a clock that throws: all\n// degrade to a dropped or partial record, never to a raised exception.\n//\n// Decisions worth stating:\n//\n// - **The threshold is checked FIRST, before any work.** Merging context, walking it for redaction and\n//   serializing an error all cost more than a suppressed line is worth. Only the caller's own arguments are\n//   evaluated (`logger.debug('x', expensive())` still pays for `expensive()` — that is JS, not us); nothing\n//   this module controls is spent below the threshold, and no sink is touched.\n// - **`child()` forks the CONTEXT, and only the context.** Sinks, redaction config, `onError` and the clock\n//   are shared with the root — and so is the LEVEL, held in one mutable cell for the whole tree. That makes\n//   `setLevel` a single runtime dial (\"turn debug on\") instead of something to re-apply across every child\n//   an app has spawned. A child cannot diverge from its parent's level; that is the design, not a gap.\n// - **Context merges parent-first, so the more specific writer wins:** root < child < grandchild < call\n//   site. A child re-binding `requestId` overrides its parent's, which is how a reader expects the nearest\n//   scope to describe the record.\n// - **`error()`'s second argument is the ERROR unless it is a plain object that is not error-like.** This\n//   mirrors how TypeScript picks the overload — an `Error` instance is not assignable to `LogContext`\n//   (no index signature), so `error(msg, err)` resolves to the error signature and `error(msg, { userId })`\n//   to the context one. The one addition is that a PLAIN object which is error-like (`{ message: '…' }`) is\n//   also taken as the error, because `catch (e) { log.error('failed', e) }` — where a library threw a\n//   non-`Error` — is the whole reason the overload exists, and `e` is typed `unknown` there. The cost: a\n//   context whose fields include `message` reads as an error. Disambiguate with `error(msg, undefined, ctx)`.\n// - **One record object is shared across the fan-out.** Building a copy per sink would be pure waste;\n//   `LogRecord` is fully `readonly` so a sink is expected to treat it as immutable.\n\nimport { isErrorLike, serializeError } from '../errors';\nimport { isLevelEnabled, isLogLevel, LogLevel } from './LogLevel';\nimport type { LogContext, LogRecord } from './LogRecord';\nimport type { LogErrorHandler, LogSink } from './LogSink';\nimport { DefaultRedactionMask, DefaultRedactKeys, isPlainObject, redactContext } from './Redaction';\n\n/** Provides the level a logger starts at when the options name none — production-safe, so `debug` is opt-in. */\nexport const DefaultLogLevel: LogLevel = LogLevel.Info;\n\n/** Defines the options for {@link createLogger}. */\nexport interface LoggerOptions {\n  /** The starting threshold — records below it are dropped. Default {@link DefaultLogLevel}. */\n  readonly level?: LogLevel;\n\n  /** The sinks records fan out to. Copied on construction; empty means every call is a no-op. */\n  readonly sinks?: readonly LogSink[];\n\n  /** The base structured fields merged into every record — service name, release, session id. */\n  readonly context?: LogContext;\n\n  /** The context keys whose values are masked, at any depth, case-insensitively. Default {@link DefaultRedactKeys}. */\n  readonly redactKeys?: readonly string[];\n\n  /** The placeholder written over a redacted value. Default {@link DefaultRedactionMask}. */\n  readonly redactionMask?: string;\n\n  /** Receives every sink failure. Omitted means failures are swallowed — a broken sink is never worth an app crash. */\n  readonly onError?: LogErrorHandler;\n\n  /** Supplies the record timestamp (epoch ms) — injectable for deterministic tests. Default `Date.now`. */\n  readonly now?: () => number;\n}\n\n/** Defines the logger — five level methods, a context fork, and a runtime level dial. No method throws. */\nexport interface Logger {\n  /** Emits at `trace` — the finest detail, suppressed unless the threshold is lowered to it. */\n  trace(message: string, context?: LogContext): void;\n\n  /** Emits at `debug` — developer-facing detail while diagnosing. */\n  debug(message: string, context?: LogContext): void;\n\n  /** Emits at `info` — the normal-operation narrative. */\n  info(message: string, context?: LogContext): void;\n\n  /** Emits at `warn` — a recovered or degraded condition. */\n  warn(message: string, context?: LogContext): void;\n\n  /** Emits at `error` with structured context only. */\n  error(message: string, context?: LogContext): void;\n\n  /** Emits at `error` with a caught value, serialized onto the record's `error`. Pass `undefined` to log context under a `message` key. */\n  error(message: string, error: unknown, context?: LogContext): void;\n\n  /** Creates a logger whose records carry this one's context merged with `context` — the child's keys win. Sinks, level, and config are shared. */\n  child(context: LogContext): Logger;\n\n  /** Moves the threshold for the WHOLE logger tree at runtime — an unknown value is ignored rather than silently muting output. */\n  setLevel(level: LogLevel): void;\n\n  /** Reads the current threshold. */\n  getLevel(): LogLevel;\n\n  /** Checks whether a level would currently be emitted — guard an expensive context build with this. */\n  isEnabled(level: LogLevel): boolean;\n}\n\n/** Holds everything a logger tree shares — every field but `level` is fixed at construction. */\ninterface LoggerCore {\n  /** The sinks every record in the tree fans out to. */\n  readonly sinks: readonly LogSink[];\n\n  /** The keys redacted from every context in the tree. */\n  readonly redactKeys: readonly string[];\n\n  /** The mask written over a redacted value. */\n  readonly mask: string;\n\n  /** The sink-failure handler, when the app supplied one. */\n  readonly onError: LogErrorHandler | undefined;\n\n  /** The clock every record is stamped from. */\n  readonly now: () => number;\n\n  /** The threshold — the one mutable cell, shared by the root and every child. */\n  level: LogLevel;\n}\n\n/** Copies a context object without trusting it — a throwing getter must not turn construction into a failure. */\nfunction copyContext(context: LogContext | undefined): LogContext {\n  if (context === undefined) return {};\n  try {\n    return { ...context };\n  } catch {\n    return {};\n  }\n}\n\n/** Builds one logger node over a shared core and an already-safe context — the root and every child go through here. */\nfunction createLoggerFrom(core: LoggerCore, context: LogContext): Logger {\n  /** Routes a sink failure to `onError` — a handler that itself throws is swallowed, since there is nowhere left to report. */\n  const report = (error: unknown, sink: LogSink, record: LogRecord): void => {\n    if (!core.onError) return;\n    try {\n      core.onError(error, { sink, record });\n    } catch {\n      // The handler is the last line of defence; a throw here must not reach the caller either.\n    }\n  };\n\n  /**\n   * Builds one record and fans it out. `failure` is BOXED so that \"no error was logged\" stays distinct from\n   * \"the logged error was `undefined`\" — `error(msg, undefined, ctx)` means the former.\n   */\n  const emit = (\n    level: LogLevel,\n    message: string,\n    callContext?: LogContext,\n    failure?: { readonly value: unknown },\n  ): void => {\n    try {\n      if (!isLevelEnabled(level, core.level)) return;\n\n      let merged: LogContext = context;\n      if (callContext !== undefined) {\n        try {\n          merged = { ...context, ...callContext };\n        } catch {\n          // A hostile call-site context (a throwing getter, an `ownKeys` trap) costs its own fields, never\n          // the line — the message and the error still reach the sinks under the logger's own context.\n          merged = context;\n        }\n      }\n\n      const record: LogRecord = {\n        level,\n        message,\n        timestamp: core.now(),\n        context: redactContext(merged, core.redactKeys, core.mask),\n        ...(failure ? { error: serializeError(failure.value) } : {}),\n      };\n\n      for (const sink of core.sinks) {\n        try {\n          sink.write(record);\n        } catch (sinkFailure) {\n          report(sinkFailure, sink, record);\n        }\n      }\n    } catch {\n      // A failure in the emit path itself (a hostile context spread, a clock that throws) has no record to\n      // report against and no sink proven able to receive it — the contract says drop it, never raise it.\n    }\n  };\n\n  return {\n    trace: (message: string, callContext?: LogContext): void => emit(LogLevel.Trace, message, callContext),\n\n    debug: (message: string, callContext?: LogContext): void => emit(LogLevel.Debug, message, callContext),\n\n    info: (message: string, callContext?: LogContext): void => emit(LogLevel.Info, message, callContext),\n\n    warn: (message: string, callContext?: LogContext): void => emit(LogLevel.Warn, message, callContext),\n\n    error: (message: string, second?: unknown, third?: LogContext): void => {\n      // Nothing in the second slot: whatever is in the third is the context (the explicit disambiguator).\n      if (second === undefined) {\n        emit(LogLevel.Error, message, third);\n        return;\n      }\n      // A plain, non-error-like object is structured context — everything else is the caught value.\n      if (isPlainObject(second) && !isErrorLike(second)) {\n        emit(LogLevel.Error, message, second);\n        return;\n      }\n      emit(LogLevel.Error, message, third, { value: second });\n    },\n\n    child: (childContext: LogContext): Logger => createLoggerFrom(core, { ...context, ...copyContext(childContext) }),\n\n    setLevel: (level: LogLevel): void => {\n      if (isLogLevel(level)) core.level = level;\n    },\n\n    getLevel: (): LogLevel => core.level,\n\n    isEnabled: (level: LogLevel): boolean => isLevelEnabled(level, core.level),\n  };\n}\n\n/**\n * Creates a {@link Logger} — one per app (or per bounded context), shared by every caller under it.\n *\n * Nothing is wired by default: with no `sinks`, every call is a no-op, so an SDK consumer opts into output\n * explicitly rather than inheriting console noise. Fan out to `consoleLogSink()` in development and add a\n * shipping sink in production; `memoryLogSink()` is the test double.\n *\n * Never throws, and neither does any method on the returned logger.\n */\nexport function createLogger(options: LoggerOptions = {}): Logger {\n  const core: LoggerCore = {\n    sinks: [...(options.sinks ?? [])],\n    redactKeys: options.redactKeys ?? DefaultRedactKeys,\n    mask: options.redactionMask ?? DefaultRedactionMask,\n    onError: options.onError,\n    now: options.now ?? Date.now,\n    level: isLogLevel(options.level) ? options.level : DefaultLogLevel,\n  };\n\n  return createLoggerFrom(core, copyContext(options.context));\n}\n","// The dev sink — the one an app wires up first and the one it keeps in development.\n//\n// Deliberately NOT registered by default: an SDK that writes to the console unasked is noise (GWDNBM), so\n// `createLogger({ sinks: [consoleLogSink()] })` is an explicit opt-in.\n//\n// `console` is read inside `write` rather than captured at factory time, so a test that stubs\n// `console.warn` after construction still sees the stub, and importing this file asserts nothing about the\n// environment. Each level routes to its own method because devtools filters on exactly that — collapsing\n// everything onto `console.log` throws away the level filter the browser already gives you for free. Note\n// `console.trace` prints a stack alongside the message; that is what makes it the trace method, and why\n// `Trace` is off by default.\n//\n// Context and error are passed as separate arguments rather than interpolated into the message, so devtools\n// renders them as inspectable objects instead of `[object Object]`.\n\nimport { LogLevel } from './LogLevel';\nimport type { LogRecord } from './LogRecord';\nimport type { LogSink } from './LogSink';\n\n/** Defines the options for {@link consoleLogSink}. */\nexport interface ConsoleLogSinkOptions {\n  /** The tag prefixed to every message. Default `'[log]'`; pass `''` for no prefix. */\n  readonly prefix?: string;\n}\n\n/** Resolves the console method a level routes to. `Silent` never reaches a sink; it returns `undefined` to keep the switch exhaustive. */\nfunction resolveMethod(level: LogLevel): ((...args: unknown[]) => void) | undefined {\n  switch (level) {\n    case LogLevel.Trace:\n      return console.trace;\n    case LogLevel.Debug:\n      return console.debug;\n    case LogLevel.Info:\n      return console.info;\n    case LogLevel.Warn:\n      return console.warn;\n    case LogLevel.Error:\n      return console.error;\n    case LogLevel.Silent:\n      return undefined;\n  }\n}\n\n/** Creates a sink that writes each record to the matching `console` method — the development destination, opt-in like every other wire. */\nexport function consoleLogSink(options: ConsoleLogSinkOptions = {}): LogSink {\n  const prefix = options.prefix ?? '[log]';\n\n  return {\n    name: 'console',\n    write: (record: LogRecord): void => {\n      const method = resolveMethod(record.level) ?? console.log;\n      const args: unknown[] = [];\n      if (Object.keys(record.context).length > 0) args.push(record.context);\n      if (record.error !== undefined) args.push(record.error);\n\n      method.call(console, prefix === '' ? record.message : `${prefix} ${record.message}`, ...args);\n    },\n  };\n}\n","// The test double — a sink that ships nowhere and remembers everything.\n//\n// `records` surfaces through a getter typed `readonly`, so a test reads the live capture without being able\n// to push into it, and the array identity stays stable across a `reset` (mirrors `memoryAnalyticsProvider`).\n// Records are stored by reference, not copied: they are already frozen in shape and fully `readonly`, and a\n// copy would defeat the assertion that every sink in a fan-out received the SAME object.\n\nimport type { LogRecord } from './LogRecord';\nimport type { LogSink } from './LogSink';\n\n/** Defines the in-memory sink returned by {@link memoryLogSink} — a sink plus the capture it records. */\nexport interface MemoryLogSink extends LogSink {\n  /** Every record written, in emit order. */\n  readonly records: readonly LogRecord[];\n\n  /** Clears the capture — for a `beforeEach` reset of a shared instance. */\n  reset(): void;\n}\n\n/** Creates an in-memory sink capturing every record — the test double for asserting what an app logs. */\nexport function memoryLogSink(): MemoryLogSink {\n  const records: LogRecord[] = [];\n\n  return {\n    name: 'memory',\n\n    get records() {\n      return records;\n    },\n\n    write: (record) => {\n      records.push(record);\n    },\n\n    reset: () => {\n      records.length = 0;\n    },\n  };\n}\n"],"names":[],"mappings":"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"}
+{"version":3,"file":"index.js","sources":["../../../src/foundation/logger/LogLevel.ts","../../../src/foundation/logger/Redaction.ts","../../../src/foundation/logger/Logger.ts","../../../src/foundation/logger/ConsoleLogSink.ts","../../../src/foundation/logger/MemoryLogSink.ts"],"sourcesContent":["// The severity vocabulary, plus the one comparison the emit path makes. A const object rather than a TS\n// `enum`, matching `BackoffStrategy` / `AnalyticsCallKind`: an `enum` emits a runtime object into every\n// consumer's bundle and is not erasable under `verbatimModuleSyntax`, while this shape tree-shakes and its\n// values are plain strings a sink can print or ship as-is.\n//\n// `Silent` is a THRESHOLD-ONLY value: it exists so `createLogger({ level: LogLevel.Silent })` drops\n// everything, and no record is ever emitted at it. Hence `Number.POSITIVE_INFINITY` for its severity —\n// nothing clears it — plus the explicit guard in `isLevelEnabled`, without which the degenerate\n// `isLevelEnabled(Silent, Silent)` (`Infinity >= Infinity`) would read as enabled.\n//\n// Severities are spaced by ten so a consumer can slot a custom level between two of ours without\n// renumbering the set.\n\n/**\n * Defines the severity a record is emitted at — ordered `Trace` (finest) through `Error`, with `Silent` as the\n * off switch.\n */\nexport const LogLevel = {\n  /** Refers to the finest-grained diagnostics — per-iteration detail, off in every deployed environment. */\n  Trace: 'trace',\n  /** Refers to developer-facing detail for diagnosing — request payloads, cache hits, retry decisions. */\n  Debug: 'debug',\n  /** Refers to the normal-operation narrative — lifecycle milestones worth keeping in production. */\n  Info: 'info',\n  /** Refers to a recovered or degraded condition — the app continued, but something was off. */\n  Warn: 'warn',\n  /** Refers to a failure the app could not absorb — the level the `error` payload rides on. */\n  Error: 'error',\n  /** Refers to the threshold that drops everything. Only ever set as a level; never emitted on a record. */\n  Silent: 'silent',\n} as const;\n\nexport type LogLevel = (typeof LogLevel)[keyof typeof LogLevel];\n\n/**\n * Provides the numeric severity of each level — the ordering {@link isLevelEnabled} compares on. `Silent` is\n * infinite, so nothing clears it.\n */\nexport const LogLevelSeverity: Readonly<Record<LogLevel, number>> = {\n  [LogLevel.Trace]: 10,\n  [LogLevel.Debug]: 20,\n  [LogLevel.Info]: 30,\n  [LogLevel.Warn]: 40,\n  [LogLevel.Error]: 50,\n  [LogLevel.Silent]: Number.POSITIVE_INFINITY,\n};\n\n/**\n * Checks whether a value is one of the known levels — guards the runtime `setLevel` dial and a level read\n * from an env var, where an unrecognized string would otherwise mute the logger in silence.\n *\n * Never throws.\n */\nexport function isLogLevel(value: unknown): value is LogLevel {\n  return typeof value === 'string' && Object.hasOwn(LogLevelSeverity, value);\n}\n\n/**\n * Checks whether a record at `level` clears `threshold` — the single comparison guarding the emit path,\n * made before any context merge, redaction, or error serialization is paid for.\n *\n * `Silent` never passes as a `level`, even against a `Silent` threshold.\n *\n * Never throws.\n */\nexport function isLevelEnabled(level: LogLevel, threshold: LogLevel): boolean {\n  if (level === LogLevel.Silent) return false;\n  return LogLevelSeverity[level] >= LogLevelSeverity[threshold];\n}\n","// Redaction runs on the way IN — inside the logger, before the record reaches any sink — rather than\n// inside each sink. A sink is third-party code that may ship off the device, so a secret that reaches one\n// has already leaked; asking every adapter to redact is asking for the one that forgets.\n//\n// Decisions:\n//\n// - **Keys match case-insensitively; matched values are dropped whole.** `Authorization` / `authorization`\n//   / `AUTHORIZATION` are the same header. A partial mask (`sk-…f31a`) still leaks a prefix and invites a\n//   per-call-site judgement about whether that is enough, so the value is replaced regardless of its type —\n//   a matched key whose value is an object does not get walked.\n// - **The walk copies; it never mutates.** The caller's object is theirs and is very often live\n//   application state — redacting in place would erase a real token from a real session, which is exactly\n//   the kind of damage a logger must never do.\n// - **Recursion covers arrays and PLAIN objects only.** `Object.keys(new Date())` is empty, so walking a\n//   `Date` / `Map` / `URL` / class instance would silently replace it with `{}`. Everything non-plain\n//   passes through by reference — worth knowing, because a secret held on a class instance is NOT redacted.\n//\n// The input is assumed hostile, because a context object is assembled at a call site that may itself be\n// mid-failure: a cycle is cut with `CircularMarker`, a throwing getter or `ownKeys` trap yields\n// `UnreadableMarker`, and depth is capped at `DefaultMaxRedactDepth`. The cap is fail-CLOSED — the subtree\n// becomes `TruncatedMarker` rather than passing through unredacted — and it is what keeps a pathological\n// graph from overflowing the stack, which is the one way this could otherwise break its no-throw contract.\n//\n// Cycles are tracked along the current PATH (added before descending, removed after), not globally, so a\n// value legitimately referenced by several siblings still renders each time instead of the second and later\n// occurrences reading as circular.\n\nimport type { LogContext } from './LogRecord';\n\n/** Provides the context keys redacted by default — the credential names that show up in practically every payload. */\nexport const DefaultRedactKeys: ReadonlyArray<string> = ['password', 'token', 'secret', 'authorization', 'apiKey'];\n\n/** Provides the placeholder written over a redacted value. */\nexport const DefaultRedactionMask = '[redacted]';\n\n/** Provides the placeholder written where the walk met a value already on the current path. */\nexport const CircularMarker = '[circular]';\n\n/** Provides the placeholder written where reading a property threw — a getter or a `Proxy` trap. */\nexport const UnreadableMarker = '[unreadable]';\n\n/** Provides the placeholder written at {@link DefaultMaxRedactDepth} — fail-closed, so nothing below escapes. */\nexport const TruncatedMarker = '[truncated]';\n\n/** Provides how many levels the walk descends before truncating — deep enough for real context, still bounded. */\nexport const DefaultMaxRedactDepth = 8;\n\n/**\n * Checks whether a value is a plain object — prototype `Object.prototype` or `null`. `getPrototypeOf` is a\n * trappable operation, so the read is guarded. Internal; not barrelled.\n */\nexport function isPlainObject(value: unknown): value is Record<string, unknown> {\n  if (value === null || typeof value !== 'object') return false;\n  try {\n    const prototype: unknown = Object.getPrototypeOf(value);\n    return prototype === Object.prototype || prototype === null;\n  } catch {\n    return false;\n  }\n}\n\n/** Reads one property without trusting the source — a getter and a `Proxy` `get` trap can both throw. */\nfunction readProperty(source: Record<string, unknown>, key: string): unknown {\n  try {\n    return source[key];\n  } catch {\n    return UnreadableMarker;\n  }\n}\n\n/** Lists a source's own enumerable keys without trusting it — an `ownKeys` trap can throw. */\nfunction readKeys(source: Record<string, unknown>): ReadonlyArray<string> {\n  try {\n    return Object.keys(source);\n  } catch {\n    return [];\n  }\n}\n\n/** Walks one value, copying it with matched keys masked. Recurses only into arrays and plain objects. */\nfunction redactValue(\n  value: unknown,\n  keys: ReadonlySet<string>,\n  mask: string,\n  depth: number,\n  path: Set<object>,\n): unknown {\n  if (!Array.isArray(value) && !isPlainObject(value)) return value;\n\n  const container: object = value;\n  if (path.has(container)) return CircularMarker;\n  if (depth >= DefaultMaxRedactDepth) return TruncatedMarker;\n\n  path.add(container);\n  try {\n    if (Array.isArray(value)) {\n      const items: unknown[] = [];\n      // `for…of` over the array itself — indexed access would be `T | undefined` under\n      // `noUncheckedIndexedAccess`, and a hole would then be indistinguishable from a stored `undefined`.\n      for (const item of value) items.push(redactValue(item, keys, mask, depth + 1, path));\n      return items;\n    }\n\n    const copy: Record<string, unknown> = {};\n    for (const key of readKeys(value)) {\n      Object.defineProperty(copy, key, {\n        value: keys.has(key.toLowerCase()) ? mask : redactValue(readProperty(value, key), keys, mask, depth + 1, path),\n        enumerable: true,\n        writable: true,\n        configurable: true,\n      });\n    }\n    return copy;\n  } finally {\n    path.delete(container);\n  }\n}\n\n/**\n * Copies a context object with every value under a matching key replaced by `mask`, at any nesting depth.\n * Key matching is case-insensitive.\n *\n * The result is always a fresh, cycle-free, depth-bounded plain object, so it is safe to `JSON.stringify`\n * and safe to hand to a sink that outlives the call. The source is never mutated.\n *\n * Never throws — a hostile context (throwing getters, `Proxy` traps, self-reference, pathological depth)\n * degrades to markers, and a total failure degrades to `{}`.\n */\nexport function redactContext(\n  context: LogContext,\n  redactKeys: ReadonlyArray<string> = DefaultRedactKeys,\n  mask: string = DefaultRedactionMask,\n): LogContext {\n  try {\n    const keys = new Set(redactKeys.map((key) => key.toLowerCase()));\n    const redacted = redactValue(context, keys, mask, 0, new Set<object>());\n    // Non-plain input (a class instance cast to a context) is not walked, so it cannot be proven safe —\n    // dropping it keeps the \"always a plain, serializable object\" guarantee the sinks rely on.\n    return isPlainObject(redacted) ? redacted : {};\n  } catch {\n    return {};\n  }\n}\n","// The logger every app talks to. One contract dominates every decision in this file:\n//\n// DEFINING CONTRACT: NO METHOD HERE THROWS. `logger.error(...)` is called from `catch` blocks, error\n// boundaries, and unhandled-rejection handlers — precisely where a second exception masks the first and\n// takes down the path that was meant to recover. So the emit body is wrapped end to end, every sink is\n// invoked in isolation, and `onError` (itself wrapped) is the only place a failure ever surfaces. A hostile\n// context, a `Proxy` that throws from every trap, a sink that always throws, a clock that throws: all\n// degrade to a dropped or partial record, never to a raised exception.\n//\n// Decisions worth stating:\n//\n// - **The threshold is checked FIRST, before any work.** Merging context, walking it for redaction and\n//   serializing an error all cost more than a suppressed line is worth. Only the caller's own arguments are\n//   evaluated (`logger.debug('x', expensive())` still pays for `expensive()` — that is JS, not us); nothing\n//   this module controls is spent below the threshold, and no sink is touched.\n// - **`child()` forks the CONTEXT, and only the context.** Sinks, redaction config, `onError` and the clock\n//   are shared with the root — and so is the LEVEL, held in one mutable cell for the whole tree. That makes\n//   `setLevel` a single runtime dial (\"turn debug on\") instead of something to re-apply across every child\n//   an app has spawned. A child cannot diverge from its parent's level; that is the design, not a gap.\n// - **Context merges parent-first, so the more specific writer wins:** root < child < grandchild < call\n//   site. A child re-binding `requestId` overrides its parent's, which is how a reader expects the nearest\n//   scope to describe the record.\n// - **`error()`'s second argument is the ERROR unless it is a plain object that is not error-like.** This\n//   mirrors how TypeScript picks the overload — an `Error` instance is not assignable to `LogContext`\n//   (no index signature), so `error(msg, err)` resolves to the error signature and `error(msg, { userId })`\n//   to the context one. The one addition is that a PLAIN object which is error-like (`{ message: '…' }`) is\n//   also taken as the error, because `catch (e) { log.error('failed', e) }` — where a library threw a\n//   non-`Error` — is the whole reason the overload exists, and `e` is typed `unknown` there. The cost: a\n//   context whose fields include `message` reads as an error. Disambiguate with `error(msg, undefined, ctx)`.\n// - **One record object is shared across the fan-out.** Building a copy per sink would be pure waste;\n//   `LogRecord` is fully `readonly` so a sink is expected to treat it as immutable.\n\nimport { isErrorLike, serializeError } from '../errors';\nimport { isLevelEnabled, isLogLevel, LogLevel } from './LogLevel';\nimport type { LogContext, LogRecord } from './LogRecord';\nimport type { LogErrorHandler, LogSink } from './LogSink';\nimport { DefaultRedactionMask, DefaultRedactKeys, isPlainObject, redactContext } from './Redaction';\n\n/** Provides the level a logger starts at when the options name none — production-safe, so `debug` is opt-in. */\nexport const DefaultLogLevel: LogLevel = LogLevel.Info;\n\n/** Defines the options for {@link createLogger}. */\nexport interface LoggerOptions {\n  /** The starting threshold — records below it are dropped. Default {@link DefaultLogLevel}. */\n  readonly level?: LogLevel;\n\n  /** The sinks records fan out to. Copied on construction; empty means every call is a no-op. */\n  readonly sinks?: ReadonlyArray<LogSink>;\n\n  /** The base structured fields merged into every record — service name, release, session id. */\n  readonly context?: LogContext;\n\n  /** The context keys whose values are masked, at any depth, case-insensitively. Default {@link DefaultRedactKeys}. */\n  readonly redactKeys?: ReadonlyArray<string>;\n\n  /** The placeholder written over a redacted value. Default {@link DefaultRedactionMask}. */\n  readonly redactionMask?: string;\n\n  /** Receives every sink failure. Omitted → failures are swallowed; a broken sink is never worth an app crash. */\n  readonly onError?: LogErrorHandler;\n\n  /** Supplies the record timestamp (epoch ms) — injectable for deterministic tests. Default `Date.now`. */\n  readonly now?: () => number;\n}\n\n/** Defines the logger — five level methods, a context fork, and a runtime level dial. No method throws. */\nexport interface Logger {\n  /** Emits at `trace` — the finest detail, suppressed unless the threshold is lowered to it. */\n  trace(message: string, context?: LogContext): void;\n\n  /** Emits at `debug` — developer-facing detail while diagnosing. */\n  debug(message: string, context?: LogContext): void;\n\n  /** Emits at `info` — the normal-operation narrative. */\n  info(message: string, context?: LogContext): void;\n\n  /** Emits at `warn` — a recovered or degraded condition. */\n  warn(message: string, context?: LogContext): void;\n\n  /** Emits at `error` with structured context only. */\n  error(message: string, context?: LogContext): void;\n\n  /**\n   * Emits at `error` with a caught value, serialized onto the record's `error`. Pass `undefined` to log context\n   * under a `message` key.\n   */\n  error(message: string, error: unknown, context?: LogContext): void;\n\n  /**\n   * Creates a logger whose records carry this one's context merged with `context` — the child's keys win.\n   * Sinks, level, and config are shared.\n   */\n  child(context: LogContext): Logger;\n\n  /**\n   * Moves the threshold for the WHOLE logger tree at runtime — an unknown value is ignored rather than silently\n   * muting output.\n   */\n  setLevel(level: LogLevel): void;\n\n  /** Reads the current threshold. */\n  getLevel(): LogLevel;\n\n  /** Checks whether a level would currently be emitted — guard an expensive context build with this. */\n  isEnabled(level: LogLevel): boolean;\n}\n\n/** Holds everything a logger tree shares — every field but `level` is fixed at construction. */\ninterface LoggerCore {\n  /** The sinks every record in the tree fans out to. */\n  readonly sinks: ReadonlyArray<LogSink>;\n\n  /** The keys redacted from every context in the tree. */\n  readonly redactKeys: ReadonlyArray<string>;\n\n  /** The mask written over a redacted value. */\n  readonly mask: string;\n\n  /** The sink-failure handler, when the app supplied one. */\n  readonly onError: LogErrorHandler | undefined;\n\n  /** The clock every record is stamped from. */\n  readonly now: () => number;\n\n  /** The threshold — the one mutable cell, shared by the root and every child. */\n  level: LogLevel;\n}\n\n/** Copies a context object without trusting it — a throwing getter must not turn construction into a failure. */\nfunction copyContext(context: LogContext | undefined): LogContext {\n  if (context === undefined) return {};\n  try {\n    return { ...context };\n  } catch {\n    return {};\n  }\n}\n\n/** Builds a logger node over a shared core and an already-safe context — the root and every child go through it. */\nfunction createLoggerFrom(core: LoggerCore, context: LogContext): Logger {\n  /** Routes a sink failure to `onError` — a throwing handler is swallowed, since nowhere is left to report. */\n  const report = (error: unknown, sink: LogSink, record: LogRecord): void => {\n    if (!core.onError) return;\n    try {\n      core.onError(error, { sink, record });\n    } catch {\n      // The handler is the last line of defence; a throw here must not reach the caller either.\n    }\n  };\n\n  /**\n   * Builds one record and fans it out. `failure` is BOXED so that \"no error was logged\" stays distinct from\n   * \"the logged error was `undefined`\" — `error(msg, undefined, ctx)` means the former.\n   */\n  const emit = (\n    level: LogLevel,\n    message: string,\n    callContext?: LogContext,\n    failure?: { readonly value: unknown },\n  ): void => {\n    try {\n      if (!isLevelEnabled(level, core.level)) return;\n\n      let merged: LogContext = context;\n      if (callContext !== undefined) {\n        try {\n          merged = { ...context, ...callContext };\n        } catch {\n          // A hostile call-site context (a throwing getter, an `ownKeys` trap) costs its own fields, never\n          // the line — the message and the error still reach the sinks under the logger's own context.\n          merged = context;\n        }\n      }\n\n      const record: LogRecord = {\n        level,\n        message,\n        timestamp: core.now(),\n        context: redactContext(merged, core.redactKeys, core.mask),\n        ...(failure ? { error: serializeError(failure.value) } : {}),\n      };\n\n      for (const sink of core.sinks) {\n        try {\n          sink.write(record);\n        } catch (sinkFailure) {\n          report(sinkFailure, sink, record);\n        }\n      }\n    } catch {\n      // A failure in the emit path itself (a hostile context spread, a clock that throws) has no record to\n      // report against and no sink proven able to receive it — the contract says drop it, never raise it.\n    }\n  };\n\n  return {\n    trace: (message: string, callContext?: LogContext): void => emit(LogLevel.Trace, message, callContext),\n\n    debug: (message: string, callContext?: LogContext): void => emit(LogLevel.Debug, message, callContext),\n\n    info: (message: string, callContext?: LogContext): void => emit(LogLevel.Info, message, callContext),\n\n    warn: (message: string, callContext?: LogContext): void => emit(LogLevel.Warn, message, callContext),\n\n    error: (message: string, second?: unknown, third?: LogContext): void => {\n      // Nothing in the second slot: whatever is in the third is the context (the explicit disambiguator).\n      if (second === undefined) {\n        emit(LogLevel.Error, message, third);\n        return;\n      }\n      // A plain, non-error-like object is structured context — everything else is the caught value.\n      if (isPlainObject(second) && !isErrorLike(second)) {\n        emit(LogLevel.Error, message, second);\n        return;\n      }\n      emit(LogLevel.Error, message, third, { value: second });\n    },\n\n    child: (childContext: LogContext): Logger => createLoggerFrom(core, { ...context, ...copyContext(childContext) }),\n\n    setLevel: (level: LogLevel): void => {\n      if (isLogLevel(level)) core.level = level;\n    },\n\n    getLevel: (): LogLevel => core.level,\n\n    isEnabled: (level: LogLevel): boolean => isLevelEnabled(level, core.level),\n  };\n}\n\n/**\n * Creates a {@link Logger} — one per app (or per bounded context), shared by every caller under it.\n *\n * Nothing is wired by default: with no `sinks`, every call is a no-op, so an SDK consumer opts into output\n * explicitly rather than inheriting console noise. Fan out to `consoleLogSink()` in development and add a\n * shipping sink in production; `memoryLogSink()` is the test double.\n *\n * Never throws, and neither does any method on the returned logger.\n */\nexport function createLogger(options: LoggerOptions = {}): Logger {\n  const core: LoggerCore = {\n    sinks: [...(options.sinks ?? [])],\n    redactKeys: options.redactKeys ?? DefaultRedactKeys,\n    mask: options.redactionMask ?? DefaultRedactionMask,\n    onError: options.onError,\n    now: options.now ?? Date.now,\n    level: isLogLevel(options.level) ? options.level : DefaultLogLevel,\n  };\n\n  return createLoggerFrom(core, copyContext(options.context));\n}\n","// The dev sink — the one an app wires up first and the one it keeps in development.\n//\n// Deliberately NOT registered by default: an SDK that writes to the console unasked is noise (GWDNBM), so\n// `createLogger({ sinks: [consoleLogSink()] })` is an explicit opt-in.\n//\n// `console` is read inside `write` rather than captured at factory time, so a test that stubs\n// `console.warn` after construction still sees the stub, and importing this file asserts nothing about the\n// environment. Each level routes to its own method because devtools filters on exactly that — collapsing\n// everything onto `console.log` throws away the level filter the browser already gives you for free. Note\n// `console.trace` prints a stack alongside the message; that is what makes it the trace method, and why\n// `Trace` is off by default.\n//\n// Context and error are passed as separate arguments rather than interpolated into the message, so devtools\n// renders them as inspectable objects instead of `[object Object]`.\n\nimport { LogLevel } from './LogLevel';\nimport type { LogRecord } from './LogRecord';\nimport type { LogSink } from './LogSink';\n\n/** Defines the options for {@link consoleLogSink}. */\nexport interface ConsoleLogSinkOptions {\n  /** The tag prefixed to every message. Default `'[log]'`; pass `''` for no prefix. */\n  readonly prefix?: string;\n}\n\n/**\n * Resolves the console method a level routes to. `Silent` never reaches a sink; it returns `undefined` to keep\n * the switch exhaustive.\n */\nfunction resolveMethod(level: LogLevel): ((...args: unknown[]) => void) | undefined {\n  switch (level) {\n    case LogLevel.Trace:\n      return console.trace;\n    case LogLevel.Debug:\n      return console.debug;\n    case LogLevel.Info:\n      return console.info;\n    case LogLevel.Warn:\n      return console.warn;\n    case LogLevel.Error:\n      return console.error;\n    case LogLevel.Silent:\n      return undefined;\n  }\n}\n\n/**\n * Creates a sink that writes each record to the matching `console` method — the development destination, opt-in\n * like every other wire.\n */\nexport function consoleLogSink(options: ConsoleLogSinkOptions = {}): LogSink {\n  const prefix = options.prefix ?? '[log]';\n\n  return {\n    name: 'console',\n    write: (record: LogRecord): void => {\n      const method = resolveMethod(record.level) ?? console.log;\n      const args: unknown[] = [];\n      if (Object.keys(record.context).length > 0) args.push(record.context);\n      if (record.error !== undefined) args.push(record.error);\n\n      method.call(console, prefix === '' ? record.message : `${prefix} ${record.message}`, ...args);\n    },\n  };\n}\n","// The test double — a sink that ships nowhere and remembers everything.\n//\n// `records` surfaces through a getter typed `readonly`, so a test reads the live capture without being able\n// to push into it, and the array identity stays stable across a `reset` (mirrors `memoryAnalyticsProvider`).\n// Records are stored by reference, not copied: they are already frozen in shape and fully `readonly`, and a\n// copy would defeat the assertion that every sink in a fan-out received the SAME object.\n\nimport type { LogRecord } from './LogRecord';\nimport type { LogSink } from './LogSink';\n\n/** Defines the in-memory sink returned by {@link memoryLogSink} — a sink plus the capture it records. */\nexport interface MemoryLogSink extends LogSink {\n  /** Every record written, in emit order. */\n  readonly records: ReadonlyArray<LogRecord>;\n\n  /** Clears the capture — for a `beforeEach` reset of a shared instance. */\n  reset(): void;\n}\n\n/** Creates an in-memory sink capturing every record — the test double for asserting what an app logs. */\nexport function memoryLogSink(): MemoryLogSink {\n  const records: LogRecord[] = [];\n\n  return {\n    name: 'memory',\n\n    get records() {\n      return records;\n    },\n\n    write: (record) => {\n      records.push(record);\n    },\n\n    reset: () => {\n      records.length = 0;\n    },\n  };\n}\n"],"names":[],"mappings":"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"}

package/dist/foundation/media/CanCaptureMedia.d.ts

@@ -6,7 +6,16 @@
  *   serve over HTTPS (or `localhost`). Distinguished from `unsupported` because the fix is completely different.
  * - `unsupported` — no API and no evidence the context is the reason: SSR, a worker, an older browser.
  */
-export type MediaSupport = 'supported' | 'insecure-context' | 'unsupported';
+export declare const MediaSupport: {
+    /** `navigator.mediaDevices.getUserMedia` is present and callable. */
+    readonly Supported: "supported";
+    /** The API is absent and the page is a known non-secure context — serve over HTTPS or `localhost`. */
+    readonly InsecureContext: "insecure-context";
+    /** No API and no evidence the context is the reason: SSR, a worker, an older browser. */
+    readonly Unsupported: "unsupported";
+};
+/** Why media capture is (un)available here. */
+export type MediaSupport = (typeof MediaSupport)[keyof typeof MediaSupport];
 /**
  * Reads `navigator.mediaDevices` when it exists and carries `member` as a callable.
  *

package/dist/foundation/media/FacingMode.d.ts

@@ -1,11 +1,18 @@
-import { MediaStreamResult } from './MediaStreamResult';
+import { MediaStreamRequestResult } from './MediaStreamMapping';
 /**
  * Which camera to prefer.
  *
  * - `user` — front / selfie camera, facing the user.
  * - `environment` — rear camera, facing away. What a scanner or a document capture wants.
  */
-export type FacingMode = 'user' | 'environment';
+export declare const FacingMode: {
+    /** Prefers the front / selfie camera, facing the user. */
+    readonly User: "user";
+    /** Prefers the rear camera, facing away — what a scanner or a document capture wants. */
+    readonly Environment: "environment";
+};
+/** Which camera to prefer. */
+export type FacingMode = (typeof FacingMode)[keyof typeof FacingMode];
 /** Tunes how a facing-mode preference is expressed as constraints. */
 export interface FacingModeOptions {
     /**
@@ -14,7 +21,7 @@ export interface FacingModeOptions {
      * (`{ ideal }`), which degrades to whatever camera exists.
      */
     readonly exact?: boolean;
-    /** Extra video track constraints to merge — resolution, frame rate, `deviceId`. A `facingMode` here is overwritten. */
+    /** Extra video constraints to merge — resolution, frame rate, `deviceId`. A `facingMode` here is overwritten. */
     readonly video?: MediaTrackConstraints;
 }
 /**
@@ -42,4 +49,4 @@ export declare function facingModeConstraints(facingMode: FacingMode, options?:
  * @param options Whether to demand rather than prefer it, plus any extra track constraints.
  * @returns The typed outcome of the new acquisition. Anything other than `granted` means nothing is live now.
  */
-export declare function switchCamera(current: MediaStream | null | undefined, facingMode: FacingMode, options?: FacingModeOptions): Promise<MediaStreamResult>;
+export declare function switchCamera(current: MediaStream | null | undefined, facingMode: FacingMode, options?: FacingModeOptions): Promise<MediaStreamRequestResult>;

package/dist/foundation/media/ListMediaDevices.d.ts

@@ -5,14 +5,17 @@
  * module header. Group membership and counts are accurate regardless.
  */
 export interface MediaDeviceGroups {
-    /** Whether `enumerateDevices` was reachable at all. `false` means every group is empty because the API is absent (SSR, older browser), not because the machine has no devices. */
+    /**
+     * Whether `enumerateDevices` was reachable at all. `false` means every group is empty because the API is
+     * absent (SSR, older browser), not because the machine has no devices.
+     */
     readonly supported: boolean;
     /** Video inputs — `kind === 'videoinput'`. Webcams, virtual cameras, capture cards. */
-    readonly cameras: readonly MediaDeviceInfo[];
+    readonly cameras: ReadonlyArray<MediaDeviceInfo>;
     /** Audio inputs — `kind === 'audioinput'`. Microphones, line-ins, virtual audio devices. */
-    readonly microphones: readonly MediaDeviceInfo[];
-    /** Audio outputs — `kind === 'audiooutput'`. Speakers and headsets. Absent entirely on Firefox, which does not enumerate outputs. */
-    readonly speakers: readonly MediaDeviceInfo[];
+    readonly microphones: ReadonlyArray<MediaDeviceInfo>;
+    /** Audio outputs — `kind === 'audiooutput'`. Speakers and headsets. Always empty on Firefox, which omits them. */
+    readonly speakers: ReadonlyArray<MediaDeviceInfo>;
 }
 /**
  * Lists the available media devices, grouped by kind.

package/dist/foundation/media/MediaStreamFailureCode.d.ts

@@ -0,0 +1,10 @@
+/** Closed failure vocabulary for MediaStreamFailure. */
+export declare const MediaStreamFailureCode: {
+    readonly Cancelled: "cancelled";
+    readonly Denied: "denied";
+    readonly Unavailable: "unavailable";
+    readonly InUse: "in-use";
+    readonly Unsupported: "unsupported";
+    readonly Failed: "failed";
+};
+export type MediaStreamFailureCode = (typeof MediaStreamFailureCode)[keyof typeof MediaStreamFailureCode];

package/dist/foundation/media/MediaStreamMapping.d.ts

@@ -0,0 +1,15 @@
+import { MediaStreamFailure } from './models/MediaStreamFailure';
+export type { MediaStreamFailure } from './models/MediaStreamFailure';
+export type { MediaStreamRequestResult } from './models/MediaStreamRequestResult';
+export type MediaStreamStatus = 'granted' | MediaStreamFailure['status'];
+/**
+ * Classifies a rejected `getUserMedia` into its {@link MediaStreamFailure}.
+ *
+ * Exported for the sibling request modules and their tests; absent from the barrel, where the request functions
+ * are the surface a consumer wants. Never throws — an unrecognized name falls through to `failed` with the value
+ * normalized by `foundation/errors`' `toError`, so even a thrown `null` arrives as a real `Error`.
+ *
+ * @param cause The value `getUserMedia` rejected (or threw) with.
+ * @returns The matching failure arm.
+ */
+export declare function toMediaStreamFailure(cause: unknown): MediaStreamFailure;

package/dist/foundation/media/RequestMediaStream.d.ts

@@ -1,4 +1,4 @@
-import { MediaStreamResult } from './MediaStreamResult';
+import { MediaStreamRequestResult } from './MediaStreamMapping';
 /**
  * Requests a stream for arbitrary constraints — the general form the camera / microphone helpers delegate to.
  *
@@ -10,7 +10,7 @@ import { MediaStreamResult } from './MediaStreamResult';
  * @param constraints The `MediaStreamConstraints` to pass through, e.g. `{ video: true, audio: true }`.
  * @returns The typed outcome — `granted` carrying the live stream, or one of the five failure arms.
  */
-export declare function requestMediaStream(constraints: MediaStreamConstraints): Promise<MediaStreamResult>;
+export declare function requestMediaStream(constraints: MediaStreamConstraints): Promise<MediaStreamRequestResult>;
 /**
  * Requests a camera-only stream.
  *
@@ -24,7 +24,7 @@ export declare function requestMediaStream(constraints: MediaStreamConstraints):
  *   means `video: true`: whichever camera the browser prefers.
  * @returns The typed outcome.
  */
-export declare function requestCameraStream(constraints?: MediaTrackConstraints): Promise<MediaStreamResult>;
+export declare function requestCameraStream(constraints?: MediaTrackConstraints): Promise<MediaStreamRequestResult>;
 /**
  * Requests a microphone-only stream.
  *
@@ -34,4 +34,4 @@ export declare function requestCameraStream(constraints?: MediaTrackConstraints)
  *   Omitted means `audio: true`.
  * @returns The typed outcome.
  */
-export declare function requestMicrophoneStream(constraints?: MediaTrackConstraints): Promise<MediaStreamResult>;
+export declare function requestMicrophoneStream(constraints?: MediaTrackConstraints): Promise<MediaStreamRequestResult>;

package/dist/foundation/media/UseMediaStream.d.ts

@@ -1,13 +1,23 @@
 import { MaybeRefOrGetter, ShallowRef } from 'vue';
-import { MediaStreamResult, MediaStreamStatus } from './MediaStreamResult';
+import { MediaStreamRequestResult, MediaStreamStatus } from './MediaStreamMapping';
 /**
  * Where a `useMediaStream` instance sits in its cycle: `idle` before the first attempt and after `stop`,
  * `pending` while the browser prompt is open, then the {@link MediaStreamStatus} of the last attempt.
  */
-export type MediaStreamState = 'idle' | 'pending' | MediaStreamStatus;
+export declare const MediaStreamState: {
+    /** Before the first attempt, and after `stop` — nothing acquired, nothing in flight. */
+    readonly Idle: "idle";
+    /** An acquisition is in flight; the browser's permission prompt may be open. */
+    readonly Pending: "pending";
+};
+/**
+ * Where a `useMediaStream` instance sits in its cycle: `idle` before the first attempt and after `stop`,
+ * `pending` while the browser prompt is open, then the {@link MediaStreamStatus} of the last attempt.
+ */
+export type MediaStreamState = (typeof MediaStreamState)[keyof typeof MediaStreamState] | MediaStreamStatus;
 /** Tunes a `useMediaStream` instance. */
 export interface UseMediaStreamOptions {
-    /** Constraints for every `start()` that does not pass its own. Defaults to `{ video: true }` — camera, no microphone. */
+    /** Constraints for every `start()` not passing its own. Default `{ video: true }` — camera, no microphone. */
     readonly constraints?: MediaStreamConstraints;
 }
 /** What {@link useMediaStream} returns. */
@@ -16,10 +26,13 @@ export interface MediaStreamControls {
     readonly status: Readonly<ShallowRef<MediaStreamState>>;
     /** The live stream, or `null` whenever `status` is anything but `granted`. Assign to a `<video>`'s `srcObject`. */
     readonly stream: Readonly<ShallowRef<MediaStream | null>>;
-    /** The normalized error from a `failed` attempt; `null` for every other status, including `denied`, which is a decision rather than a failure. */
+    /**
+     * The normalized error from a `failed` attempt; `null` for every other status, including `denied`, which is a
+     * decision rather than a failure.
+     */
     readonly error: Readonly<ShallowRef<Error | null>>;
     /** Acquires a stream, releasing any currently held one first. Resolves to the outcome; never throws. */
-    readonly start: (constraints?: MediaStreamConstraints) => Promise<MediaStreamResult>;
+    readonly start: (constraints?: MediaStreamConstraints) => Promise<MediaStreamRequestResult>;
     /** Releases the held stream and returns to `idle`. Idempotent, safe before the first `start`. */
     readonly stop: () => void;
 }

package/dist/foundation/media/index.d.ts

@@ -1,8 +1,9 @@
 export { canCaptureMedia, getMediaSupport, type MediaSupport } from './CanCaptureMedia';
-export { type MediaStreamResult, type MediaStreamStatus, type MediaStreamFailure } from './MediaStreamResult';
+export { type MediaStreamRequestResult, type MediaStreamStatus, type MediaStreamFailure } from './MediaStreamMapping';
 export { requestMediaStream, requestCameraStream, requestMicrophoneStream } from './RequestMediaStream';
 export { listMediaDevices, hasCamera, hasMicrophone, type MediaDeviceGroups } from './ListMediaDevices';
 export { stopMediaStream } from './StopMediaStream';
 export { facingModeConstraints, switchCamera, type FacingMode, type FacingModeOptions } from './FacingMode';
 export { getCameraPermission, getMicrophonePermission, type PermissionQueryState } from './MediaPermission';
 export { useMediaStream, type MediaStreamControls, type MediaStreamState, type UseMediaStreamOptions, } from './UseMediaStream';
+export { MediaStreamFailureCode } from './MediaStreamFailureCode';