@orkestrel/console 0.0.11 → 0.0.13

package/dist/src/core/index.cjs

@@ -3,7 +3,7 @@ let _orkestrel_emitter = require("@orkestrel/emitter");
 let _orkestrel_contract = require("@orkestrel/contract");
 //#region src/core/constants.ts
 /**
-* Each {@link Color}'s SGR FOREGROUND parameter — the 8 base colors at 30–37 and their
+* Maps each {@link Color} to its SGR foreground parameter — the 8 base colors at 30–37 and their
 * bright variants at 90–97. `default` is intentionally absent (it emits no code).
 */
 var FOREGROUND_CODES = Object.freeze({
@@ -25,7 +25,7 @@ var FOREGROUND_CODES = Object.freeze({
 	brightWhite: 97
 });
 /**
-* Each {@link Color}'s SGR BACKGROUND parameter — the 8 base colors at 40–47 and their
+* Maps each {@link Color} to its SGR background parameter — the 8 base colors at 40–47 and their
 * bright variants at 100–107. `default` is intentionally absent (it emits no code).
 */
 var BACKGROUND_CODES = Object.freeze({
@@ -47,7 +47,7 @@ var BACKGROUND_CODES = Object.freeze({
 	brightWhite: 107
 });
 /**
-* Each {@link Attribute}'s SGR "on" parameter — `bold` 1, `dim` 2, `italic` 3,
+* Maps each {@link Attribute} to its SGR "on" parameter — `bold` 1, `dim` 2, `italic` 3,
 * `underline` 4, `inverse` 7, `strikethrough` 9. The renderer composes several by
 * joining their codes with `;` in one SGR sequence.
 */
@@ -60,13 +60,13 @@ var ATTRIBUTE_CODES = Object.freeze({
 	strikethrough: 9
 });
 /**
-* The EMPTY {@link Style} — no foreground, no background, no attributes — frozen. The
+* Holds the empty {@link Style} — no foreground, no background, no attributes — frozen. The
 * neutral starting point a base styler builds from, and what a renderer passes through
 * unchanged (it carries no codes). Deeply frozen, so it is safe to share as the base.
 */
 var EMPTY_STYLE = Object.freeze({ attributes: Object.freeze([]) });
 /**
-* Every named {@link Color} except `default`, frozen — the colors the styler exposes as
+* Lists every named {@link Color} except `default`, frozen — the colors the styler exposes as
 * chainable accessors. The source of truth for the color axis; the styler drives its
 * accessors from this array so the literals live in one place.
 */
@@ -89,7 +89,7 @@ var COLORS = Object.freeze([
 	"brightWhite"
 ]);
 /**
-* Every {@link Attribute}, frozen — the attributes the styler exposes as chainable
+* Lists every {@link Attribute}, frozen — the attributes the styler exposes as chainable
 * accessors. The source of truth for the attribute axis.
 */
 var ATTRIBUTES = Object.freeze([
@@ -100,30 +100,30 @@ var ATTRIBUTES = Object.freeze([
 	"inverse",
 	"strikethrough"
 ]);
-/** The SGR RESET parameter (0) — terminates a styled run, clearing all colors and attributes. */
+/** Holds the SGR RESET parameter (0) — terminates a styled run, clearing all colors and attributes. */
 var RESET_CODE = 0;
 /**
-* The ESC control character (`U+001B`) that begins every ANSI escape sequence. Built
+* Holds the escape control character (`U+001B`) that begins every ANSI escape sequence. Built
 * with `String.fromCharCode` so no raw control character appears in source.
 */
 var ESC = String.fromCharCode(27);
-/** The BEL control character (`U+0007`) that can terminate an OSC sequence. */
+/** Holds the bell control character (`U+0007`) that can terminate an OSC sequence. */
 var BEL = String.fromCharCode(7);
-/** The Control Sequence Introducer (`ESC[`) that opens every SGR sequence. */
+/** Holds the Control Sequence Introducer (`ESC[`) that opens every SGR sequence. */
 var CSI = `[`;
-/** The full SGR reset sequence (`ESC[0m`) appended after a styled run. */
+/** Holds the full SGR reset sequence (`ESC[0m`) appended after a styled run. */
 var RESET = `${CSI}0m`;
 /**
 * Matches any ANSI/VT escape sequence — CSI (SGR color/style plus cursor/erase/scroll,
 * including colon-parameterized SGR), OSC / DCS / PM / APC / SOS string sequences
 * (titles, hyperlinks, device strings), the `nF` charset-select family, and the
-* two-byte `Fp` / `Fe` / `Fs` sequences (e.g. `ESC 7`, `ESC D`, `ESC c` RIS). Global, so
+* two-byte `Fp` / `Fe` / `Fs` sequences (for example `ESC 7`, `ESC D`, `ESC c` RIS). Global, so
 * `strip` removes every occurrence.
 *
 * @remarks
-* A global `RegExp` carries a mutable `lastIndex`; a scan must build a FRESH `RegExp`
+* A global `RegExp` carries a mutable `lastIndex`; a scan must build a fresh `RegExp`
 * from this one's `source` + `flags` rather than reuse this instance's `lastIndex`. This
-* is the canonical definition, not a shared scanner. The alternation is ORDERED so the
+* is the canonical definition, not a shared scanner. The alternation is ordered so the
 * CSI / string-family arms (which can start with a byte a later single-byte arm would
 * also match) win first; every arm uses disjoint, non-nested character classes, so the
 * match is linear in input length — no catastrophic backtracking (ReDoS-safe) even on an
@@ -132,20 +132,20 @@ var RESET = `${CSI}0m`;
 */
 var ANSI_PATTERN = new RegExp(`(?:\\[[0-?]*[ -/]*[@-~]|\\][^]*(?:|\\\\)|[P^_X][^]*(?:|\\\\)|[ -/]+[0-~]|[0-?]|[@-OQ-WYZ\\\\]|[\`-~])`, "g");
 /**
-* Matches every C0 control character EXCEPT `\t` / `\n` / `\r` (which are meaningful
+* Matches every C0 control character except `\t` / `\n` / `\r` (which are meaningful
 * whitespace), plus DEL (`0x7F`) — the non-printing bytes {@link
 * import('./helpers.js').stripControls} removes. Global, ASCII-only source (no raw
 * control-character literal), so a scan builds a fresh `RegExp` the same way as
 * {@link ANSI_PATTERN} to avoid a mutated `lastIndex`.
 *
 * @remarks
-* Deliberately SEPARATE from {@link ANSI_PATTERN}: `strip()` must stay pure ANSI-escape
+* Deliberately separate from {@link ANSI_PATTERN}: `strip()` must stay pure ANSI-escape
 * removal (width / alignment computations depend on it leaving raw C0 bytes alone), while
-* C0-stripping is an ADDITIONAL, orthogonal pass a non-TTY output sink applies on top.
+* C0-stripping is an additional, orthogonal pass a non-TTY output sink applies on top.
 */
 var CONTROL_PATTERN = new RegExp(`[${String.fromCharCode(0)}-${String.fromCharCode(8)}${String.fromCharCode(11)}${String.fromCharCode(12)}${String.fromCharCode(14)}-${String.fromCharCode(31)}${String.fromCharCode(127)}]`, "g");
 /**
-* Each {@link LogLevel}'s numeric SEVERITY — the ascending order the level gate compares
+* Maps each {@link LogLevel} to its numeric severity — the ascending order the level gate compares
 * through (`debug` 0 < `info` 1 < `warn` 2 < `error` 3). A record is kept when its level's
 * severity is at or above the logger's threshold. The source of truth for level ordering.
 */
@@ -156,8 +156,8 @@ var LEVEL_SEVERITY = Object.freeze({
 	error: 3
 });
 /**
-* Each {@link LogLevel}'s default label {@link Color} — the level's VISUAL treatment, which
-* is a styling choice ORTHOGONAL to the level itself (never a separate pseudo-level). The
+* Maps each {@link LogLevel} to its default label {@link Color} — the level's visual treatment, which
+* is a styling choice orthogonal to the level itself (never a separate pseudo-level). The
 * logger colors the level label through its styler with these; swapping a color never
 * changes leveling. `debug` is cyan, `info` blue, `warn` yellow, `error` red.
 *
@@ -172,29 +172,35 @@ var LEVEL_COLORS = Object.freeze({
 	error: "red"
 });
 /**
-* The default bounded-retention cap for a {@link import('./types.js').LoggerInterface} — at
-* most this many recent records are kept (oldest dropped first). Retention is ALWAYS bounded
-* (never the unbounded buffer scsr leaked); a consumer overrides it via `options.limit`.
+* Sets the default bounded-retention cap for a {@link import('./types.js').LoggerInterface} —
+* `1000`, so at most that many recent records are kept and retention is always bounded.
+*
+* @remarks
+* The oldest record is dropped after the cap is reached; a consumer overrides the cap through
+* `options.limit`.
 */
 var DEFAULT_LOG_LIMIT = 1e3;
-/** The default {@link LogLevel} threshold a logger gates at when none is supplied — `info`. */
+/** Sets the default {@link LogLevel} threshold a logger gates at when none is supplied — `info`. */
 var DEFAULT_LOG_LEVEL = "info";
 /**
-* Every {@link LogLevel}, in ascending severity order — the levels a logger exposes as
+* Lists every {@link LogLevel}, in ascending severity order — the levels a logger exposes as
 * methods and the manager fans out to. The source of truth for the level axis (drives
 * exhaustive tests); aligned with {@link LEVEL_SEVERITY}.
 */
-var LEVELS = Object.freeze([
+var LOG_LEVELS = Object.freeze([
 	"debug",
 	"info",
 	"warn",
 	"error"
 ]);
 /**
-* The complete {@link BorderChars} junction set for each {@link BorderStyle} — the standard
-* Unicode box-drawing glyphs at the four line weights. The renderers ({@link
-* import('./helpers.js').renderBox} / {@link import('./helpers.js').renderTable}) look the
-* style up here, so no glyph literal lives in a renderer. Deeply frozen.
+* Holds the complete {@link BorderChars} junction set for each {@link BorderStyle} — the standard
+* Unicode box-drawing glyphs at each line weight, deeply frozen.
+*
+* @remarks
+* The renderers ({@link import('./helpers.js').renderBox} /
+* {@link import('./helpers.js').renderTable}) look the style up here, so no glyph literal lives in
+* a renderer.
 *
 * @remarks
 * `round` shares `single`'s edges and tees — only its corners differ (the rounded `╭╮╰╯`).
@@ -254,7 +260,7 @@ var BORDER_CHARS = Object.freeze({
 	})
 });
 /**
-* Each {@link StatusLevel}'s icon glyph — the leading mark a {@link
+* Maps each {@link StatusLevel} to its icon glyph — the leading mark a {@link
 * import('./types.js').ReporterInterface.status} outcome line shows: `success` ✔, `error` ✖,
 * `warn` ⚠, `info` ℹ. The narrative-outcome counterpart to a log level's label; frozen.
 */
@@ -265,8 +271,8 @@ var STATUS_ICONS = Object.freeze({
 	info: "ℹ"
 });
 /**
-* Each {@link StatusLevel}'s {@link Color} — the icon + message color a `status` line renders
-* in (`success` green, `error` red, `warn` yellow, `info` blue). The VISUAL treatment of a
+* Maps each {@link StatusLevel} to its {@link Color} — the icon + message color a `status` line renders
+* in (`success` green, `error` red, `warn` yellow, `info` blue). The visual treatment of a
 * narrative outcome, colored through the reporter's styler; orthogonal to leveling, like
 * {@link LEVEL_COLORS}. Excludes `default` so each value indexes a real styler accessor.
 */
@@ -277,7 +283,7 @@ var STATUS_COLORS = Object.freeze({
 	info: "blue"
 });
 /**
-* Every {@link StatusLevel}, frozen — the outcomes a `status` line supports (drives exhaustive
+* Lists every {@link StatusLevel}, frozen — the outcomes a `status` line supports (drives exhaustive
 * tests). The source of truth for the status axis; aligned with {@link STATUS_ICONS} /
 * {@link STATUS_COLORS}.
 */
@@ -288,33 +294,33 @@ var STATUS_LEVELS = Object.freeze([
 	"info"
 ]);
 /**
-* The default visible column width for the width-aware renderers — the separator rule and a
+* Sets the default visible column width for the width-aware renderers — the separator rule and a
 * {@link import('./helpers.js').renderBox} with no explicit `width`, and the reporter's
-* `section` rule. A sane terminal default (80 columns); a caller overrides it per-call or via
-* {@link import('./types.js').ReporterOptions}`.width`.
+* `section` rule. A sane terminal default (80 columns); a caller overrides it per-call or through
+* {@link import('./types.js').ReporterOptions.width}.
 */
 var DEFAULT_WIDTH = 80;
-/** The default horizontal padding inside a box's edges ({@link import('./helpers.js').renderBox}) — one cell. */
+/** Sets the default horizontal padding inside a box's edges ({@link import('./helpers.js').renderBox}) — one cell. */
 var DEFAULT_PADDING = 1;
-/** The default {@link BorderStyle} the box / table renderers frame with when none is given — `single`. */
+/** Sets the default {@link BorderStyle} the box / table renderers frame with when none is given — `single`. */
 var DEFAULT_BORDER = "single";
-/** The default cell {@link Alignment} a {@link import('./types.js').ColumnSpec} uses when none is given — `left`. */
+/** Sets the default cell {@link Alignment} a {@link import('./types.js').ColumnSpec} uses when none is given — `left`. */
 var DEFAULT_ALIGN = "left";
-/** The default fill character {@link import('./helpers.js').renderSeparator} draws its rule with — `─`. */
+/** Holds the default fill character {@link import('./helpers.js').renderSeparator} draws its rule with — `─`. */
 var SEPARATOR_FILL = "─";
 /**
-* The single padding cell on each side of a separator's embedded title (` title `) — keeps the
+* Holds the single padding cell on each side of a separator's embedded title (` title `) — keeps the
 * title from butting against the rule. One space.
 */
 var SEPARATOR_TITLE_GAP = " ";
 /**
-* The number of milliseconds at or above which {@link import('./helpers.js').formatDuration}
-* (and so `Reporter.timing`) switches from a `…ms` rendering to a `…s` (seconds, 2 d.p.)
-* rendering — exactly one second.
+* Sets the millisecond threshold at or above which {@link import('./helpers.js').formatDuration}
+* (and so `Reporter.timing`) switches from a `…ms` rendering to a `…s` (seconds, 2 d.p.) rendering
+* — `1000`, exactly one second.
 */
 var SECOND_MS = 1e3;
 /**
-* Every {@link CaptureLevel}, frozen — the `console.*` methods a {@link
+* Lists every {@link CaptureLevel}, frozen — the `console.*` methods a {@link
 * import('./types.js').CaptureInterface} intercepts by default (and the source of truth for the
 * capture-level axis; drives exhaustive tests). The universal console methods: `log`, `info`,
 * `warn`, `error`, `debug`.
@@ -327,23 +333,20 @@ var CAPTURE_LEVELS = Object.freeze([
 	"debug"
 ]);
 /**
-* The default set of {@link CaptureLevel}s a Capture patches when `options.levels` is omitted —
-* all five universal `console.*` methods ({@link CAPTURE_LEVELS}). A consumer narrows it (e.g. just
-* `['warn', 'error']`) via `options.levels`.
-*/
-var DEFAULT_CAPTURE_LEVELS = CAPTURE_LEVELS;
-/**
-* The default bounded-buffer cap for a {@link import('./types.js').CaptureInterface} — at most this
-* many recent {@link CapturedMessage}s are retained per buffer (the total buffer AND each by-level
-* bucket; oldest dropped first). Capture retention is ALWAYS bounded so a long-running capture can
-* never grow without bound (the same retention precedent as {@link DEFAULT_LOG_LIMIT}); a consumer
-* overrides it via `options.limit`.
+* Sets the default bounded-buffer cap for a {@link import('./types.js').CaptureInterface} — `1000`,
+* so at most that many recent {@link CapturedMessage}s are retained per buffer (the total buffer
+* and each by-level bucket; oldest dropped first) and retention is always bounded.
+*
+* @remarks
+* A long-running capture can never grow without bound (the same retention precedent as
+* {@link DEFAULT_LOG_LIMIT}); a consumer overrides the cap through `options.limit`.
 */
 var DEFAULT_CAPTURE_LIMIT = 1e3;
 /**
-* Each {@link CaptureLevel}'s {@link LogLevel} for the optional sink forward — the projection the
+* Maps each {@link CaptureLevel} to its {@link LogLevel} for the optional sink forward — the projection the
 * Capture routes through when writing an intercepted call to a {@link
-* import('./types.js').SinkInterface} (`sink.write(text, CAPTURE_LEVEL_MAP[level])`). `warn` /
+* import('./types.js').SinkInterface}. `sink.write(text, CAPTURE_LEVEL_MAP[level])` is the call
+* this map backs. `warn` /
 * `error` / `debug` / `info` map to their matching {@link LogLevel}; `log` maps to `info` (a plain
 * console log is informational — the default stream), so a stream-aware sink routes `warn` / `error`
 * captures to the right stream. The source of truth for the capture-to-log projection.
@@ -356,11 +359,14 @@ var CAPTURE_LEVEL_MAP = Object.freeze({
 	debug: "debug"
 });
 /**
-* The default spinner frame cycle a {@link import('./types.js').SpinnerInterface} advances through —
-* the ten braille-pattern glyphs (U+2800 block) that read as a smoothly rotating dot, the universal
-* terminal-spinner convention. Frozen; a consumer swaps the whole cycle via `options.frames`.
+* Holds the default spinner frame cycle a {@link import('./types.js').SpinnerInterface} advances
+* through — the braille-pattern glyphs (`⠋⠙⠹…`, the U+2800 block) that read as a smoothly rotating
+* dot.
 *
 * @remarks
+* The cycle is the universal terminal-spinner convention. Frozen; a consumer swaps the whole
+* cycle through `options.frames`.
+*
 * Braille glyphs are single visible cells, so every frame occupies one column — the spinner glyph
 * never shifts the message beside it as it advances. The source of truth for the default frame axis.
 */
@@ -377,35 +383,43 @@ var SPINNER_FRAMES = Object.freeze([
 	"⠏"
 ]);
 /**
-* The default timer period in milliseconds between a {@link import('./types.js').SpinnerInterface}'s
-* frames — the `setInterval` interval `start()` arms. Eighty milliseconds (≈12.5 frames/second) is
-* the conventional spinner cadence: fast enough to read as motion, slow enough not to thrash a
-* terminal. A consumer overrides it via `options.interval`.
+* Sets the default timer period between a {@link import('./types.js').SpinnerInterface}'s frames —
+* the `setInterval` interval `start()` arms, `80` ms (≈12.5 frames/second).
+*
+* @remarks
+* That is the conventional spinner cadence: fast enough to read as motion, slow enough not to
+* thrash a terminal. A consumer overrides it through `options.interval`.
 */
 var DEFAULT_SPINNER_INTERVAL = 80;
 /**
-* The default FILLED-cell glyph {@link import('./helpers.js').renderBar} draws the completed run of a
-* progress bar with — the full block `█` (U+2588). A single visible cell; a consumer overrides it via
-* {@link import('./types.js').ProgressBarOptions}`.fill`.
+* Holds the default filled-cell glyph {@link import('./helpers.js').renderBar} draws the completed
+* run of a progress bar with — the full block `█` (U+2588). A single visible cell; a consumer
+* overrides it through {@link import('./types.js').BarOptions.fill}.
 */
 var BAR_FILL = "█";
 /**
-* The default EMPTY-cell glyph {@link import('./helpers.js').renderBar} draws the remaining run of a
-* progress bar with — the light-shade block `░` (U+2591). A single visible cell; a consumer overrides
-* it via {@link import('./types.js').ProgressBarOptions}`.empty`.
+* Holds the default empty-cell glyph {@link import('./helpers.js').renderBar} draws the remaining
+* run of a progress bar with — the light-shade block `░` (U+2591). A single visible cell; a
+* consumer overrides it through {@link import('./types.js').BarOptions.empty}.
 */
 var BAR_EMPTY = "░";
 /**
-* The default visible cell count of a progress-bar TRACK — the glyph run {@link
-* import('./helpers.js').renderBar} fills (and a {@link import('./types.js').ProgressInterface} sizes
-* its bar to). Thirty cells is a compact, terminal-friendly default; a consumer overrides it via
-* `options.width`. Distinct from {@link DEFAULT_WIDTH} (the renderers' 80-column line width) — a bar
-* track is one inline element, not a full-width rule.
+* Sets the default visible cell count of a progress-bar track — the glyph run
+* {@link import('./helpers.js').renderBar} fills, and the width a
+* {@link import('./types.js').ProgressInterface} sizes its bar to. `30` cells.
+*
+* @remarks
+* Thirty cells is a compact, terminal-friendly default; a consumer overrides it through
+* `options.width`. It is distinct from {@link DEFAULT_WIDTH} (the renderers' 80-column line
+* width) — a bar track is one inline element, not a full-width rule.
 */
 var DEFAULT_BAR_WIDTH = 30;
 /**
-* The default {@link Theme} — every role bound to its default {@link Style}, deeply frozen.
-* The base {@link import('./factories.js').createTheme} merges over, and the theme every
+* Holds the default {@link Theme} — every role bound to its default {@link Style}, assembled from
+* {@link LEVEL_COLORS}, {@link STATUS_ICONS}, and {@link STATUS_COLORS} and deeply frozen.
+*
+* @remarks
+* It is the base {@link import('./factories.js').createTheme} merges over, and the theme every
 * entity uses when none is supplied.
 *
 * @remarks
@@ -474,12 +488,12 @@ var DEFAULT_THEME = Object.freeze({
 //#endregion
 //#region src/core/errors.ts
 /**
-* An error thrown by the console layer.
+* Carries a {@link ConsoleErrorCode} and an optional `context` bag — the error the console layer
+* throws for an internal invariant violated at a defensive guard.
 *
 * @remarks
-* Carries a {@link ConsoleErrorCode} and an optional `context` bag. Thrown for: an
-* internal invariant violated at a defensive, structurally-unreachable guard
-* (`INVARIANT`) — the one throw site in this codebase today.
+* `INVARIANT` is the code for a guard that is structurally unreachable, so a `catch` branches on
+* `error.code` rather than parsing the message.
 */
 var ConsoleError = class extends Error {
 	code;
@@ -492,10 +506,10 @@ var ConsoleError = class extends Error {
 	}
 };
 /**
-* Narrow an unknown caught value to a {@link ConsoleError}.
+* Narrows an unknown caught value to a {@link ConsoleError} — the guard a `catch` branches on.
 *
 * @param value - The value to test (typically a `catch` binding)
-* @returns `true` when `value` is a {@link ConsoleError}
+* @returns True if `value` is a {@link ConsoleError}; false otherwise
 *
 * @example
 * ```ts
@@ -510,134 +524,13 @@ function isConsoleError(value) {
 	return value instanceof ConsoleError;
 }
 //#endregion
-//#region src/core/Capture.ts
-/**
-* An observable console interceptor (AGENTS §13) — it takes control of the global `console.*` on
-* the READ side. While `active`, every configured `console.x` call is captured as a frozen
-* {@link CapturedMessage}, buffered (total + by level, bounded), emitted on `capture`, and — per
-* options — mirrored to the real console and/or forwarded to a {@link SinkInterface}.
-*
-* @remarks
-* - **Snapshot-at-start (the no-capture-loop principle).** `start()` snapshots the CURRENT
-*   `console[level]` for each configured {@link CaptureLevel}, then installs the wrappers. The
-*   mirror writes through that snapshot — so our OWN console sink output (the Logger / Reporter,
-*   which snapshot the real `console` at creation) is never recaptured: `Capture` catches
-*   THIRD-PARTY `console.*`, not our writes. Create your loggers BEFORE installing a capture.
-* - **Idempotent + PROCESS-GLOBAL + NON-REENTRANT.** `start()` while already `active` is a no-op
-*   (never double-patches); `stop()` while inactive is a no-op. It patches the ONE global
-*   `console`, so at most ONE capture may be active at a time — running two concurrently
-*   interleaves their buffers and clobbers each other's restore.
-* - **Bounded buffers.** `messages()` / `messages(level)` — the total buffer and each by-level
-*   bucket are each capped at `limit`
-*   (oldest dropped first), never unbounded — the same retention precedent as {@link Logger}.
-* - **Lifecycle (§10).** `start` / `stop` toggle interception (emitting `start` / `stop`);
-*   `destroy()` stops (restoring `console`) then destroys the emitter.
-*
-* @example
-* ```ts
-* const capture = new Capture({ levels: ['warn', 'error'], mirror: true })
-* capture.start()
-* console.warn('third-party noise') // captured AND mirrored to the real console
-* capture.messages('warn') // [{ level: 'warn', text: 'third-party noise', time: … }]
-* capture.stop() // console.warn restored
-* ```
-*/
-var Capture = class {
-	#emitter;
-	#levels;
-	#mirror;
-	#sink;
-	#limit;
-	#messages = [];
-	#buckets = /* @__PURE__ */ new Map();
-	#originals = /* @__PURE__ */ new Map();
-	#active = false;
-	constructor(options) {
-		this.#emitter = new _orkestrel_emitter.Emitter({
-			...options?.on !== void 0 ? { on: options.on } : {},
-			...options?.error !== void 0 ? { error: options.error } : {}
-		});
-		this.#levels = options?.levels ?? DEFAULT_CAPTURE_LEVELS;
-		this.#mirror = options?.mirror ?? false;
-		this.#sink = options?.sink;
-		this.#limit = options?.limit ?? 1e3;
-		for (const level of this.#levels) this.#buckets.set(level, []);
-	}
-	get emitter() {
-		return this.#emitter;
-	}
-	get active() {
-		return this.#active;
-	}
-	start() {
-		if (this.#active) return;
-		this.#active = true;
-		const target = console;
-		for (const level of this.#levels) {
-			const original = target[level];
-			this.#originals.set(level, original);
-			const mirror = original.bind(console);
-			target[level] = this.#captureCall.bind(this, level, mirror);
-		}
-		this.#emitter.emit("start");
-	}
-	stop() {
-		if (!this.#active) return;
-		this.#active = false;
-		const target = console;
-		for (const [level, original] of this.#originals) target[level] = original;
-		this.#originals.clear();
-		this.#emitter.emit("stop");
-	}
-	messages(level) {
-		if (level === void 0) return [...this.#messages];
-		return [...this.#buckets.get(level) ?? []];
-	}
-	clear() {
-		this.#messages.length = 0;
-		for (const bucket of this.#buckets.values()) bucket.length = 0;
-	}
-	destroy() {
-		this.stop();
-		this.#emitter.destroy();
-	}
-	#captureCall(level, mirror, ...args) {
-		this.#intercept(level, args, mirror);
-	}
-	#intercept(level, args, mirror) {
-		const message = this.#capture(level, args);
-		this.#retain(message);
-		this.#emitter.emit("capture", message);
-		if (this.#mirror) mirror(...args);
-		if (this.#sink !== void 0) try {
-			this.#sink.write(message.text, CAPTURE_LEVEL_MAP[level]);
-		} catch {}
-	}
-	#capture(level, args) {
-		return Object.freeze({
-			level,
-			text: formatArgs(args),
-			time: Date.now()
-		});
-	}
-	#retain(message) {
-		this.#push(this.#messages, message);
-		const bucket = this.#buckets.get(message.level);
-		if (bucket !== void 0) this.#push(bucket, message);
-	}
-	#push(buffer, message) {
-		buffer.push(message);
-		if (buffer.length > this.#limit) buffer.shift();
-	}
-};
-//#endregion
 //#region src/core/helpers.ts
 /**
-* Remove every ANSI escape sequence from `text`, returning the plain visible string.
+* Removes every ANSI escape sequence from `text`, returning the plain visible string.
 *
 * @remarks
-* Strips SGR color/style codes AND other CSI controls (cursor, erase) plus OSC
-* sequences (titles, hyperlinks) — see {@link ANSI_PATTERN}. A FRESH `RegExp` is built
+* Strips SGR color/style codes and other CSI controls (cursor, erase) plus OSC
+* sequences (titles, hyperlinks) — see {@link ANSI_PATTERN}. A fresh `RegExp` is built
 * per call from the canonical pattern's `source` + `flags`, so the shared global
 * pattern's `lastIndex` is never mutated across calls (re-entrant and deterministic).
 *
@@ -653,14 +546,15 @@ function strip(text) {
 	return text.replace(new RegExp(ANSI_PATTERN.source, ANSI_PATTERN.flags), "");
 }
 /**
-* Remove every non-printing C0 control character from `text` EXCEPT `\t` / `\n` / `\r`
-* (meaningful whitespace), plus DEL — returning the sanitized string.
+* Removes every non-printing C0 control character from `text` except `\t` / `\n` / `\r`
+* (meaningful whitespace), plus DEL — a separate pass from {@link strip}, so `width` stays
+* untouched.
 *
 * @remarks
-* Deliberately SEPARATE from {@link strip} (ANSI-escape removal only, so `width` /
+* Deliberately separate from {@link strip} (ANSI-escape removal only, so `width` /
 * `align` stay untouched) — this is the additional pass a non-TTY output sink applies
 * on top of `strip`, so a captured `\x07` bell or stray `\x00` never reaches a log file
-* / non-terminal target. A FRESH `RegExp` is built per call from {@link CONTROL_PATTERN}'s
+* / non-terminal target. A fresh `RegExp` is built per call from {@link CONTROL_PATTERN}'s
 * `source` + `flags`, the same re-entrant idiom as `strip`.
 *
 * @param text - Any string, possibly carrying raw control bytes
@@ -675,13 +569,13 @@ function stripControls(text) {
 	return text.replace(new RegExp(CONTROL_PATTERN.source, CONTROL_PATTERN.flags), "");
 }
 /**
-* The visible width of `text` — its length after ANSI escapes are stripped, counted in
+* Measures how many visible columns `text` occupies — its length after ANSI escapes are stripped, counted in
 * Unicode code points (so an astral character such as an emoji counts as one, not the
 * two UTF-16 units `String.length` would report).
 *
 * @remarks
 * The basis for terminal layout (box / table / progress alignment): the column count a
-* styled string occupies, independent of its escape codes. It does NOT account for
+* styled string occupies, independent of its escape codes. It does not account for
 * wide (CJK / fullwidth) glyphs occupying two cells — a deliberate, documented
 * simplification at this layer; callers needing east-asian width handle it above.
 *
@@ -697,7 +591,8 @@ function width(text) {
 	return [...strip(text)].length;
 }
 /**
-* Snapshot and deeply freeze one {@link Style} value.
+* Snapshots and deeply freezes one {@link Style} value, including an independent frozen copy of
+* its `attributes`.
 *
 * @param style - The caller-owned style to snapshot
 * @returns A frozen style record with an independently frozen attributes list
@@ -718,17 +613,17 @@ function freezeStyle(style) {
 	});
 }
 /**
-* Whether a record at `level` passes a logger gated at `threshold` — i.e. its severity is
-* at or above the threshold's.
+* Checks whether a record at `level` passes a logger gated at `threshold` — that is, its severity
+* is at or above the threshold's.
 *
 * @remarks
-* The level gate (AGENTS §5 — the comparison lives here, not inlined in the logger). Reads
+* The level gate (the comparison lives here, not inlined in the logger). Reads
 * the ascending {@link LEVEL_SEVERITY} order: `meetsLevel('warn', 'error')` is `true`
 * (error ≥ warn), `meetsLevel('warn', 'info')` is `false` (info < warn).
 *
 * @param threshold - The logger's configured minimum {@link LogLevel}
 * @param level - The record's {@link LogLevel}
-* @returns `true` when `level` is at least as severe as `threshold`
+* @returns True if `level` is at least as severe as `threshold`; false otherwise
 *
 * @example
 * ```ts
@@ -740,10 +635,39 @@ function meetsLevel(threshold, level) {
 	return LEVEL_SEVERITY[level] >= LEVEL_SEVERITY[threshold];
 }
 /**
-* Format a {@link LogRecord}'s `time` (epoch milliseconds) as an ISO-8601 timestamp string.
+* Selects the member of a {@link WriterSet} a {@link LogLevel} routes to — `error` to `error`,
+* `warn` to `warn`, every other level and an omitted level to `log`.
+*
+* @remarks
+* The single owner of the level-to-target decision every sink backend shares, so core's console
+* sink, the browser `%c` sink, and the server stream sink cannot drift apart. A backend that sends
+* two levels to one destination passes the same member twice: the server sink routes `warn`
+* alongside `error` by supplying its error stream for both, which matches `console.warn` writing
+* to `stderr`. The member type is the caller's, so the same leaf selects a bound console method, a
+* stream target, or a per-target styling fact.
+*
+* @param level - The originating record's {@link LogLevel}, or `undefined` when the caller has none
+* @param writers - See {@link WriterSet}
+* @returns The member `level` routes to
+*
+* @example
+* ```ts
+* selectWriter('error', { log: 'stdout', warn: 'stderr', error: 'stderr' }) // 'stderr'
+* selectWriter('warn', { log: 'stdout', warn: 'stderr', error: 'stderr' }) // 'stderr'
+* selectWriter('debug', { log: 'stdout', warn: 'stderr', error: 'stderr' }) // 'stdout'
+* selectWriter(undefined, { log: 'stdout', warn: 'stderr', error: 'stderr' }) // 'stdout'
+* ```
+*/
+function selectWriter(level, writers) {
+	if (level === "error") return writers.error;
+	if (level === "warn") return writers.warn;
+	return writers.log;
+}
+/**
+* Formats a {@link LogRecord}'s `time` (epoch milliseconds) as an ISO-8601 timestamp string.
 *
 * @remarks
-* Deterministic and serializable — `new Date(time).toISOString()`, e.g.
+* Deterministic and serializable — `new Date(time).toISOString()`, for example
 * `1716900000000 → '2024-05-28T12:40:00.000Z'`. The timestamp portion of the formatted log
 * line; kept a pure helper so the line layout and the logger stay decoupled.
 *
@@ -754,7 +678,7 @@ function formatTime(time) {
 	return new Date(time).toISOString();
 }
 /**
-* Format a {@link LogRecord} into a single styled line — the default human line layout a
+* Formats a {@link LogRecord} into a single styled line — the default human line layout a
 * {@link import('./types.js').LoggerInterface} writes to its sink.
 *
 * @remarks
@@ -763,7 +687,7 @@ function formatTime(time) {
 * the originating logger's `name` in brackets (omitted when absent), the message, and the
 * structured `data` appended as compact JSON (omitted when absent / empty). Coloring flows
 * through the injected `styler`, so a disabled styler yields a plain line and a browser
-* `%c` styler (C-f) retargets it — the layout never changes. Pure: same record + styler →
+* `%c` styler retargets it — the layout never changes. Pure: same record + styler →
 * same line.
 *
 * @param record - The {@link LogRecord} to render
@@ -789,21 +713,21 @@ function formatRecord(record, styler, theme) {
 	return `${time} ${label}${name} ${record.message}${data}`;
 }
 /**
-* Pad (or, when over budget, truncate) `text` to exactly `target` VISIBLE columns, positioning
+* Pads (or, when over budget, truncates) `text` to exactly `columns` visible columns, positioning
 * it by `alignment`. The width primitive the box / table renderers align every cell with.
 *
 * @remarks
 * Measures with {@link width} (visible code points, ANSI-aware), so a styled string aligns by
-* its visible content, not its escape codes. When `width(text) < target`, the deficit is added
+* its visible content, not its escape codes. When `width(text) < columns`, the deficit is added
 * as spaces — all trailing (`left`), all leading (`right`), or split with the extra space on
-* the right (`center`). When `width(text) > target`, the VISIBLE characters are sliced to
-* `target` (a defensive guard — the renderers size columns to fit, so this is rarely hit; it
+* the right (`center`). When `width(text) > columns`, the visible characters are sliced to
+* `columns` (a defensive guard — the renderers size columns to fit, so this is rarely hit; it
 * slices the stripped text, so it never bisects an escape sequence into a broken half).
 *
 * @param text - The cell content (may be styled)
-* @param target - The visible column count to fit `text` into
-* @param alignment - Where to position `text` within the width; defaults to `left`
-* @returns `text` fitted to exactly `target` visible columns
+* @param columns - The visible column count to fit `text` into
+* @param alignment - Where to position `text` within that budget; defaults to `left`
+* @returns `text` fitted to exactly `columns` visible columns
 *
 * @example
 * ```ts
@@ -812,10 +736,10 @@ function formatRecord(record, styler, theme) {
 * align('hi', 5, 'center') // ' hi  '
 * ```
 */
-function align(text, target, alignment = DEFAULT_ALIGN) {
+function align(text, columns, alignment = DEFAULT_ALIGN) {
 	const visible = width(text);
-	if (visible > target) return [...strip(text)].slice(0, target).join("");
-	const deficit = target - visible;
+	if (visible > columns) return [...strip(text)].slice(0, columns).join("");
+	const deficit = columns - visible;
 	if (alignment === "right") return `${" ".repeat(deficit)}${text}`;
 	if (alignment === "center") {
 		const left = Math.floor(deficit / 2);
@@ -824,7 +748,7 @@ function align(text, target, alignment = DEFAULT_ALIGN) {
 	return `${text}${" ".repeat(deficit)}`;
 }
 /**
-* Format a millisecond duration as a compact human string — `…ms` below one second, `…s`
+* Formats a millisecond duration as a compact human string — `…ms` below one second, `…s`
 * (seconds to 2 decimal places) at or above one second. The timing rendering behind
 * {@link import('./types.js').ReporterInterface.timing}.
 *
@@ -839,12 +763,12 @@ function formatDuration(ms) {
 	return ms < 1e3 ? `${ms}ms` : `${(ms / SECOND_MS).toFixed(2)}s`;
 }
 /**
-* Color `text` through `styler`, or return it verbatim when `styler` is `undefined` — the
-* single optional-styling primitive every renderer applies to its border / title / connector
-* glyphs (AGENTS §5 — the ONE styler seam, shared, never re-hand-rolled per renderer).
+* Colors `text` through `styler` and an optional by-value {@link Style}, or returns it verbatim
+* when `styler` is `undefined` — the single optional-styling primitive every renderer applies to
+* its border / title / connector glyphs.
 *
 * @remarks
-* The renderers all take an OPTIONAL `styler`: present ⇒ glyphs are colored, absent ⇒ plain.
+* The renderers all take an optional `styler`: present ⇒ glyphs are colored, absent ⇒ plain.
 * Folding that `styler === undefined ? text : styler(text)` ternary into one exported helper
 * keeps the renderers terse and the styling decision in one tested place. A disabled styler
 * (`enabled: false`) is still a styler — it returns its text verbatim — so passing one paints
@@ -860,17 +784,17 @@ function paint(styler, text, style) {
 	return style === void 0 ? styler(text) : styler.render(style, text);
 }
 /**
-* Repeat `unit` until it fills exactly `count` VISIBLE columns, trimming a trailing partial
+* Repeats `unit` until it fills exactly `columns` visible columns, trimming a trailing partial
 * unit so the run is never over-wide — the fill primitive the separator + box edges draw with.
 *
 * @remarks
 * Counts in code points ({@link width}-consistent), so a multi-cell or astral `unit` is laid
-* down whole and the result is sliced to exactly `count` visible columns. `count <= 0` (or an
+* down whole and the result is sliced to exactly `columns` visible columns. `columns <= 0` (or an
 * empty / zero-width `unit`) yields `''`.
 *
 * @param unit - The (possibly multi-character) fill unit
-* @param count - The visible column count to fill
-* @returns `unit` tiled to exactly `count` visible columns
+* @param columns - The visible column count to fill
+* @returns `unit` tiled to exactly `columns` visible columns
 *
 * @example
 * ```ts
@@ -878,14 +802,14 @@ function paint(styler, text, style) {
 * repeatTo('=-', 5) // '=-=-='
 * ```
 */
-function repeatTo(unit, count) {
-	if (count <= 0) return "";
+function repeatTo(unit, columns) {
+	if (columns <= 0) return "";
 	const per = width(unit);
 	if (per === 0) return "";
-	return [...unit.repeat(Math.ceil(count / per))].slice(0, count).join("");
+	return [...unit.repeat(Math.ceil(columns / per))].slice(0, columns).join("");
 }
 /**
-* The cell at `index` of a (possibly ragged) row — `''` when the row is shorter than the
+* Returns the cell at `index` of a (possibly ragged) row — `''` when the row is shorter than the
 * column count, so a short row pads out instead of throwing (the ragged-row guard
 * {@link renderTable} reads every cell through).
 *
@@ -897,7 +821,7 @@ function cellAt(row, index) {
 	return row[index] ?? "";
 }
 /**
-* Render a horizontal rule — an optional centered title embedded in a line of fill characters,
+* Renders a horizontal rule — an optional centered title embedded in a line of fill characters,
 * to a fixed visible width. Pure: same {@link SeparatorOptions} → same string.
 *
 * @remarks
@@ -906,10 +830,10 @@ function cellAt(row, index) {
 *   side) in the line, splitting the remaining fill between the two sides (the extra column,
 *   when the remainder is odd, goes to the right). The visible width stays exactly `width`,
 *   even when the title is styled (the title's escape codes don't count toward the budget) —
-*   a title at least as wide as `width` yields just the gapped title (no fill).
+*   a title at least as wide as `width` yields only the gapped title (no fill).
 * - **Styling.** When `options.styler` is given, the fill runs (and the embedded title) are
 *   colored through it; the layout is identical with or without color, since width is measured
-*   on the visible content (AGENTS — width-aware via {@link width}).
+*   on the visible content (width-aware through {@link width}).
 *
 * @param options - See {@link SeparatorOptions}
 * @returns The rule line (no trailing newline)
@@ -931,19 +855,19 @@ function renderSeparator(options) {
 	return `${paint(options.styler, repeatTo(fill, left), options.style)}${gapped}${paint(options.styler, repeatTo(fill, room - left), options.style)}`;
 }
 /**
-* Render `content` framed in box-drawing characters, optionally captioned, width-aware so
+* Renders `content` framed in box-drawing characters, optionally captioned, width-aware so
 * styled content stays aligned inside the frame. Pure: same {@link BoxOptions} → same string.
 *
 * @remarks
-* - **Lines.** `content` is split on `\n` OR `\r\n`, so caller text written on Windows frames
-*   exactly as the same text written on POSIX; a LONE `\r` is kept inside its line (it is a
+* - **Lines.** `content` is split on `\n` or `\r\n`, so caller text written on Windows frames
+*   exactly as the same text written on POSIX; a lone `\r` is kept inside its line (it is a
 *   cursor control — the animation frame prefix — not a line separator). Each line is padded
 *   (left-aligned) to the inner
-*   width by {@link align} — measured on VISIBLE width, so a styled line never breaks the
+*   width by {@link align} — measured on visible width, so a styled line never breaks the
 *   right edge. The inner width is the widest line's visible width (or `width − borders −
 *   2·padding` when an explicit `width` is given and is wider), plus `padding` blank cells
 *   inside each {@link BorderChars.vertical} edge.
-* - **Title.** An optional `title` is embedded in the TOP border (` title `), the remaining
+* - **Title.** An optional `title` is embedded in the top border (` title `), the remaining
 *   top edge drawn as fill; a title wider than the inner width widens the box to fit it.
 * - **Border + styling.** The {@link BorderStyle} (`options.border`, default
 *   {@link DEFAULT_BORDER}) selects the glyph set from {@link BORDER_CHARS}; `options.styler`
@@ -983,17 +907,17 @@ function renderBox(options) {
 	].join("\n");
 }
 /**
-* Render a bordered grid of `columns` + `rows` with per-column alignment and width-aware
+* Renders a bordered grid of `columns` + `rows` with per-column alignment and width-aware
 * column sizing. Pure: same {@link TableOptions} → same string.
 *
 * @remarks
-* - **Column sizing — visible width.** Each column is sized to the widest VISIBLE width
+* - **Column sizing — visible width.** Each column is sized to the widest visible width
 *   ({@link width}) among its header label and its cells, so an already-styled cell never
 *   breaks the column (its escape codes don't count toward the width).
 * - **Ragged rows.** A row shorter than the column count is padded with empty cells; a longer
 *   row is truncated to the column count — a ragged input never throws.
 * - **Alignment.** Each cell is positioned by its column's {@link ColumnSpec.align} (default
-*   {@link DEFAULT_ALIGN}) via {@link align}.
+*   {@link DEFAULT_ALIGN}) through {@link align}.
 * - **Frame.** The {@link BorderStyle} (`options.border`, default {@link DEFAULT_BORDER})
 *   draws the outer frame, the header rule (a `teeRight … cross … teeLeft` line), and the
 *   `vertical` column separators; `options.styler` colors the frame + header labels when
@@ -1026,8 +950,8 @@ function renderTable(options) {
 	].join("\n");
 }
 /**
-* Render a nested {@link TreeNode} tree with box-drawing connectors. Pure: same
-* {@link TreeOptions} → same string.
+* Renders a nested {@link TreeNode} tree whose connectors derive from the chosen `border` set.
+* Pure: same {@link TreeOptions} → same string.
 *
 * @remarks
 * The `root` label is the unindented first line; its descendants are drawn beneath it with
@@ -1056,13 +980,17 @@ function renderTree(options) {
 	})].join("\n");
 }
 /**
-* Render the connector-prefixed lines for a {@link TreeNode} list — the recursive core
-* behind {@link renderTree}. Each child is drawn as `prefix` + its connector (`├─ ` for
-* any but the last, `└─ ` for the last) + its label, with its own descendants recursed
-* beneath under the carried guide (`│  ` under a non-last node, `   ` under the last).
+* Renders the connector-prefixed lines for a {@link TreeNode} list — the recursive core behind
+* {@link renderTree}, whose third options argument requires `border` and groups the optional
+* `styler` and `style`.
+*
+* @remarks
+* Each child is drawn as `prefix` + its connector (`├─ ` for any but the last, `└─ ` for the
+* last) + its label, with its own descendants recursed beneath under the carried guide (`│  `
+* under a non-last node, `   ` under the last).
 *
 * @remarks
-* A centralized, exported recursion branch (AGENTS §5) so it is directly testable and
+* A centralized, exported recursion branch so it is directly testable and
 * reusable outside {@link renderTree}'s top-level `root.label` framing.
 *
 * @param nodes - The sibling {@link TreeNode}s to render at this depth
@@ -1092,17 +1020,18 @@ function renderTreeChildren(nodes, prefix, options) {
 	return lines;
 }
 /**
-* Stringify ONE captured console argument into a line fragment — the per-argument rule behind
+* Stringifies one captured console argument into a line fragment — the per-argument rule behind
 * {@link formatArgs}: an `Error` → `name: message`, a plain object / array → circular-safe JSON,
 * anything else (string, number, boolean, `null`, `undefined`, symbol, function) → `String(value)`.
 *
 * @remarks
-* - **Total + never throws.** Like a guard (§14), this never throws on adversarial input — a value
+* - **Total + never throws.** Like a guard, this never throws on adversarial input — a value
 *   carrying a circular reference, a `BigInt`, or a throwing `toJSON` is rendered, not raised. The
 *   `JSON.stringify` runs with a circular-guard replacer (a seen-set drops a back-reference as
-*   `'[Circular]'`); should `JSON.stringify` still throw (e.g. a `BigInt`), the value falls back to
-*   `String(value)`. So a `Capture` can never crash the program whose `console.*` it intercepts.
-* - **`Error` first.** An `Error` renders as `name: message` (e.g. `TypeError: bad`) — the useful
+*   `'[Circular]'`); if `JSON.stringify` still throws (for example on a `BigInt`), the value falls
+*   back to `String(value)`. So a `Capture` can never crash the program whose `console.*` it
+*   intercepts.
+* - **`Error` first.** An `Error` renders as `name: message` (for example `TypeError: bad`) — the useful
 *   one-line form, since `JSON.stringify(error)` is `{}` (its fields are non-enumerable).
 * - **Objects → JSON.** A non-null `object` (including an array) is `JSON.stringify`d; a primitive
 *   (or `null` / `undefined` / `function` / `symbol`) goes through `String`.
@@ -1137,7 +1066,7 @@ function stringifyValue(value) {
 	}
 }
 /**
-* Stringify a captured `console.*` argument list into ONE line — the text of a {@link
+* Stringifies a captured `console.*` argument list into one line — the text of a {@link
 * import('./types.js').CapturedMessage}. Each argument is rendered by {@link stringifyValue} and
 * the parts are space-joined, mirroring how a console concatenates its arguments.
 *
@@ -1159,26 +1088,29 @@ function formatArgs(args) {
 	return args.map(stringifyValue).join(" ");
 }
 /**
-* Render a determinate progress bar string — a filled / empty glyph track followed by the percentage
-* and the `(current/total)` count (`█████░░░░░ 50% (5/10)`). Pure: same {@link ProgressBarOptions} →
-* same string. The animation-layer sibling of the C-c `render*` renderers (box / table / tree /
-* separator), shared so a {@link import('./types.js').ProgressInterface} and any direct caller draw
-* the ONE bar — never a second, hand-rolled one (AGENTS §5; scsr shipped three).
+* Renders a determinate progress bar string — a filled / empty glyph track followed by the percentage
+* and the `(current/total)` count (`█████░░░░░ 50% (5/10)`). Pure and width-aware: same
+* {@link BarOptions} → same string.
 *
 * @remarks
+* It is the animation-layer sibling of the `render*` renderers (box / table / tree / separator),
+* shared so a {@link import('./types.js').ProgressInterface} and any direct caller draw the one
+* bar — never a second,
+* hand-rolled one.
+*
 * - **Fill fraction, clamped.** The filled cell count is `round((current / total) · width)` with
 *   `current` clamped to `[0, total]`, so an overrun never over-fills and a negative never under-fills.
-*   A `total <= 0` renders a FULL track (there is nothing to fill toward — the work is trivially done).
+*   A `total <= 0` renders a full track (there is nothing to fill toward — the work is trivially done).
 * - **Width-aware track.** The filled run is `fill` tiled to the filled cell count and the empty run
-*   `empty` tiled to the remainder, each via {@link repeatTo} — so the TRACK is exactly `width` VISIBLE
+*   `empty` tiled to the remainder, each through {@link repeatTo} — so the track is exactly `width` visible
 *   columns even for a multi-cell glyph (its escape codes / extra cells never break the width).
-* - **Styling.** `options.styler` colors the FILLED run only (the empty run + the trailing
+* - **Styling.** `options.styler` colors the filled run only (the empty run + the trailing
 *   `percent (count)` label stay plain), through {@link paint}; the layout is identical with or
 *   without color, since the track is measured on visible width.
-* - **Label.** The percentage is the rounded `current / total` (e.g. `50%`); the count is the CLAMPED
+* - **Label.** The percentage is the rounded `current / total` (for example `50%`); the count is the clamped
 *   `current` over `total` (`(5/10)`), a single space separating the track, the percent, and the count.
 *
-* @param options - See {@link ProgressBarOptions}
+* @param options - See {@link BarOptions}
 * @returns The rendered bar line (no trailing newline)
 *
 * @example
@@ -1196,87 +1128,18 @@ function renderBar(options) {
 	const filledCells = Math.round(fraction * track);
 	return `${`${paint(options.styler, repeatTo(fill, filledCells), options.style)}${repeatTo(empty, track - filledCells)}`} ${Math.round(fraction * 100)}% (${current}/${options.total})`;
 }
-/**
-* Run `fn` with the global `console.*` captured for its duration, returning the function's `value`
-* plus the {@link import('./types.js').CapturedMessage}s it logged — the scoped, self-restoring
-* ergonomic form of {@link createCapture}.
-*
-* @param fn - The function to run under capture; may be sync (returns `T`) or async (returns
-*   `Promise<T>`)
-* @param options - See {@link CaptureOptions} (`levels` / `mirror` / `sink` / `limit` / `on` /
-*   `error`); the capture is started for the duration of `fn` regardless
-* @returns For a sync `fn`, a {@link CaptureResult}`<T>` (`{ value, messages }`); for an async
-*   `fn`, a `Promise<CaptureResult<T>>` (awaited, then console restored)
-*
-* @remarks
-* - **Always restores.** `start()` runs before `fn`; `stop()` runs in a `finally`, so `console` is
-*   restored even if `fn` throws / rejects (the throw / rejection still propagates). The capture
-*   is local — created, used, and destroyed within the call.
-* - **Sync vs async.** A `fn` returning a `Promise` is detected and AWAITED before `stop()`, so
-*   captures during the async work are included; a plain `fn` stops synchronously. The return type
-*   follows `fn`'s (overloaded).
-* - **PROCESS-GLOBAL caveat.** Like {@link createCapture}, this patches the one global `console`.
-*   Concurrent `withCapture` calls (or a `withCapture` around other capturing code) INTERLEAVE —
-*   each captures every `console.*` call in flight, and the inner `stop()` restores whatever the
-*   outer had installed. Use it for sequential, scoped capture, not overlapping captures.
-*
-* @example
-* ```ts
-* import { withCapture } from '@src/core'
-*
-* const { value, messages } = withCapture(() => {
-* 	console.log('working')
-* 	return 42
-* })
-* value // 42
-* messages.map((m) => m.text) // ['working']
-*
-* // Async — awaited before console is restored.
-* const out = await withCapture(async () => {
-* 	console.warn('async noise')
-* 	return 'done'
-* })
-* out.value // 'done'
-* ```
-*/
-function withCapture(fn, options) {
-	const capture = new Capture(options);
-	capture.start();
-	try {
-		const result = fn();
-		if (result instanceof Promise) return result.then((value) => {
-			const messages = capture.messages();
-			capture.destroy();
-			return {
-				value,
-				messages
-			};
-		}, (error) => {
-			capture.destroy();
-			throw error;
-		});
-		const messages = capture.messages();
-		capture.destroy();
-		return {
-			value: result,
-			messages
-		};
-	} catch (error) {
-		capture.destroy();
-		throw error;
-	}
-}
 //#endregion
-//#region src/core/ANSIRenderer.ts
+//#region src/core/renderers/ANSIRenderer.ts
 /**
-* The cross-environment default {@link RendererInterface} — renders style DATA as ANSI
-* SGR escape codes, exactly as `Scheduler` is the `setTimeout` default for its seam. It
-* is the single styling output the whole console / terminal system uses in a terminal;
-* the browser `%c` / CSS renderer (the C-f branch) implements the SAME contract over
-* the SAME {@link Style}, so retargeting changes the renderer, never the style model.
+* Implements the cross-environment default {@link RendererInterface} — renders style data as ANSI
+* SGR escape codes, stateless and event-free.
 *
 * @remarks
-* - **Style is DATA in, SGR string out.** It reads the style's `foreground` /
+* It is the single styling output the whole console / terminal system uses in a terminal; the
+* browser `%c` / CSS renderer implements the same contract over the same {@link Style}, so
+* retargeting changes the renderer, never the style model.
+*
+* - **Style is data in, SGR string out.** It reads the style's `foreground` /
 *   `background` / `attributes` and emits one `ESC[…m` sequence whose parameters are the
 *   mapped SGR numbers (foreground 30–37 / 90–97, background 40–47 / 100–107, attributes
 *   1 / 2 / 3 / 4 / 7 / 9), followed by `text`, terminated by the reset `ESC[0m`.
@@ -1285,13 +1148,13 @@ function withCapture(fn, options) {
 * - **`default` and unset colors emit no code** — a `default` (or absent) `foreground` /
 *   `background` leaves the terminal's own ink.
 * - **The empty style and the empty string pass through** — when there is nothing to
-*   apply (no colors, no attributes) or `text` is `''`, `text` is returned VERBATIM with
+*   apply (no colors, no attributes) or `text` is `''`, `text` is returned verbatim with
 *   no escape codes, so an unstyled render never injects a stray reset.
 * - **Stateless and event-free** — no fields, no events; safe to share one instance.
 */
 var ANSIRenderer = class {
 	/**
-	* Wrap `text` in the SGR codes for `style`. Returns `text` unchanged when the style
+	* Wraps `text` in the SGR codes for `style`. Returns `text` unchanged when the style
 	* is empty or `text` is `''`.
 	*/
 	render(style, text) {
@@ -1309,163 +1172,112 @@ var ANSIRenderer = class {
 	}
 };
 //#endregion
-//#region src/core/LoggerManager.ts
+//#region src/core/Retention.ts
 /**
-* An event-free registry of named {@link Logger}s plus a convenience fan-out — the §9
-* manager over the logging layer (a registry, never observable itself; each {@link Logger}
-* owns its own `emitter`).
+* Implements the bounded, level-keyed retention engine the console and process captures buffer
+* through — one capped total buffer
+* plus one capped bucket per level, generic over the record type each capture carries.
 *
 * @remarks
-* - **Registry (§9).** Loggers live in an insertion-ordered `Map` keyed by `name`.
-*   `register(name, options?)` mints a {@link Logger} named `name` — the manager's default
-*   `level` / `sink` / `styler` / `theme` / `format` / `limit` / `silent` flow in unless
-*   `options` OVERRIDES them
-*   (`name` is always the registry key, so any `options.name` is ignored) — stores it (a
-*   re-`register` of the same name OVERWRITES, last write wins), and returns it. `count` is
-*   the map size, `logger(name)` looks one up, `loggers()` lists them in insertion order.
-* - **Removal (§9.2).** `remove()` clears ALL, `remove(name)` drops ONE (`true` if present),
-*   `remove(names)` drops a batch (`true` if any was removed).
-*   (Removal does NOT `destroy` the returned loggers — a caller still holding one keeps using
-*   it; the manager simply stops tracking it.)
-* - **Fan-out.** `debug` / `info` / `warn` / `error(message, data?)` forward the one call to
-*   every registered logger in insertion order; each gates / emits / writes per its own `level`
-*   and `sink`. A formatter throw is a programmer error and propagates, stopping the remaining
-*   loggers for that call. A fan-out over an empty registry is a no-op.
-* - **Event-free.** No emitter, no events — the manager is a pure registry; observability is
-*   per-{@link Logger}.
+* - **One engine, two captures.** The core `Capture` retains
+*   {@link import('./types.js').CapturedMessage}s keyed by
+*   {@link import('./types.js').CaptureLevel}, and the server `ProcessCapture` retains chunks keyed
+*   by its stream level; both compose this, so their retention semantics cannot drift apart.
+* - **Bounded on both axes.** `add` appends to the total buffer and to the record's bucket, then
+*   drops the oldest of whichever exceeded `limit`, so neither grows without bound.
+* - **Buckets are fixed at construction.** Only the levels passed to the constructor get a bucket.
+*   A record at any other level still joins the total buffer, and `records(level)` for a level with
+*   no bucket returns an empty list.
+* - **Copies out.** `records` returns a fresh list each call, so retained state is never reachable
+*   for mutation through a returned value.
 *
 * @example
 * ```ts
-* const manager = new LoggerManager({ level: 'warn' })
-* manager.register('http') // inherits the `warn` default
-* manager.register('db', { level: 'debug' }) // overrides to `debug`
-* manager.warn('slow', { ms: 900 }) // fans out to both loggers
-* manager.count // 2
+* const retention = new Retention<{ level: 'warn' | 'error'; text: string }>(['warn'], 2)
+* retention.add({ level: 'warn', text: 'first' })
+* retention.add({ level: 'error', text: 'second' }) // no bucket, still in the total buffer
+* retention.records().length // 2
+* retention.records('warn').map((record) => record.text) // ['first']
+* retention.clear()
+* retention.records() // []
 * ```
 */
-var LoggerManager = class {
-	#loggers = /* @__PURE__ */ new Map();
-	#level;
-	#sink;
-	#styler;
-	#theme;
-	#format;
+var Retention = class {
 	#limit;
-	#silent;
-	constructor(options) {
-		this.#level = options?.level;
-		this.#sink = options?.sink;
-		this.#styler = options?.styler;
-		this.#theme = options?.theme;
-		this.#format = options?.format;
-		this.#limit = options?.limit;
-		this.#silent = options?.silent;
-	}
-	get count() {
-		return this.#loggers.size;
-	}
-	register(name, options) {
-		const logger = new Logger({
-			...this.#level !== void 0 ? { level: this.#level } : {},
-			...this.#sink !== void 0 ? { sink: this.#sink } : {},
-			...this.#styler !== void 0 ? { styler: this.#styler } : {},
-			...this.#theme !== void 0 ? { theme: this.#theme } : {},
-			...this.#format !== void 0 ? { format: this.#format } : {},
-			...this.#limit !== void 0 ? { limit: this.#limit } : {},
-			...this.#silent !== void 0 ? { silent: this.#silent } : {},
-			...options,
-			name
-		});
-		this.#loggers.set(name, logger);
-		return logger;
-	}
-	logger(name) {
-		return this.#loggers.get(name);
-	}
-	loggers() {
-		return [...this.#loggers.values()];
-	}
-	debug(message, data) {
-		for (const logger of this.#loggers.values()) logger.debug(message, data);
+	#records = [];
+	#buckets = /* @__PURE__ */ new Map();
+	constructor(levels, limit) {
+		this.#limit = limit;
+		for (const level of levels) this.#buckets.set(level, []);
 	}
-	info(message, data) {
-		for (const logger of this.#loggers.values()) logger.info(message, data);
+	add(record) {
+		this.#push(this.#records, record);
+		const bucket = this.#buckets.get(record.level);
+		if (bucket !== void 0) this.#push(bucket, record);
 	}
-	warn(message, data) {
-		for (const logger of this.#loggers.values()) logger.warn(message, data);
+	records(level) {
+		if (level === void 0) return [...this.#records];
+		return [...this.#buckets.get(level) ?? []];
 	}
-	error(message, data) {
-		for (const logger of this.#loggers.values()) logger.error(message, data);
+	clear() {
+		this.#records.length = 0;
+		for (const bucket of this.#buckets.values()) bucket.length = 0;
 	}
-	remove(names) {
-		if (names === void 0) {
-			this.#loggers.clear();
-			return;
-		}
-		if ((0, _orkestrel_contract.isArray)(names)) {
-			let removed = false;
-			for (const name of names) if (this.#loggers.delete(name)) removed = true;
-			return removed;
-		}
-		return this.#loggers.delete(names);
+	#push(buffer, record) {
+		buffer.push(record);
+		if (buffer.length > this.#limit) buffer.shift();
 	}
 };
 //#endregion
-//#region src/core/Progress.ts
+//#region src/core/Capture.ts
 /**
-* An update-driven, observable progress bar (AGENTS §13) — {@link update} recomputes the bar via
-* {@link renderBar}, writes `\r` + bar to its {@link SinkInterface}, and emits the `{ current, total }`
-* on `update`. The leading `\r` is what an overwrite-capable sink (the C-g TTY sink) redraws on; a
-* plain sink (C-f) degrades to a fresh, non-overwriting line — the line-OVERWRITE is the SINK's job.
-* UNIVERSAL — the one {@link StylerInterface} + the one {@link SinkInterface}, no `node:*`, no
-* `process.stdout`. NO self-timer (unlike {@link import('./Spinner.js').Spinner}) — the caller drives it.
+* Implements an observable console interceptor — it takes control of the global `console.*` on
+* the read side. While `active`, every configured `console.x` call is captured as a frozen
+* {@link CapturedMessage}, buffered (total + by level, bounded), emitted on `capture`, and — per
+* options — mirrored to the real console, forwarded to a {@link SinkInterface}, or both.
 *
 * @remarks
-* - **Update-driven.** Each {@link update} clamps `current` to `[0, total]`, renders the bar (filled
-*   to `current / total`, with the trailing `percent (current/total)` + message) via {@link renderBar},
-*   emits `update`, and writes `'\r' + bar`. Progress advances only when the caller reports it.
-* - **Outcome lines.** {@link complete} renders a FULL bar (`current = total`) + message, terminated by
-*   a newline, emits a final `update` then `complete`, and marks `completed`. {@link failure} renders the
-*   bar at its CURRENT fill + message + newline and routes to the sink's error stream (no `complete` —
-*   the work did not finish). Both are terminal: a later {@link update} is ignored once `active` is false.
-* - **Bounded.** `current` is always clamped to `[0, total]`; {@link completed} reports whether
-*   {@link complete} has run; {@link active} is `true` until a {@link complete} / {@link failure}.
-* - **Lifecycle (§10).** {@link destroy} destroys the emitter (there is no timer to clear).
-*
-* @example
-* ```ts
-* const progress = new Progress({ total: 100, message: 'downloading' })
-* progress.update(40) // ████████████░░░░░░░░░░░░░░░░░░ 40% (40/100) downloading
-* progress.update(80, 'almost there')
-* progress.complete('done') // a full bar, committed with a newline
+* - **Snapshot-at-start (the no-capture-loop principle).** `start()` snapshots the current
+*   `console[level]` for each configured {@link CaptureLevel}, then installs the wrappers. The
+*   mirror writes through that snapshot — so our own console sink output (the Logger / Reporter,
+*   which snapshot the real `console` at creation) is never recaptured: `Capture` catches
+*   third-party `console.*`, not our writes. Create your loggers before installing a capture.
+* - **Idempotent + process-global + non-reentrant.** `start()` while already `active` is a no-op
+*   (never double-patches); `stop()` while inactive is a no-op. It patches the one global
+*   `console`, so at most one capture may be active at a time — running two concurrently
+*   interleaves their buffers and clobbers each other's restore.
+* - **Bounded buffers.** `messages()` / `messages(level)` — the total buffer and each by-level
+*   bucket are each capped at `limit`
+*   (oldest dropped first), never unbounded — the same retention precedent as {@link Logger}.
+* - **Lifecycle.** `start` / `stop` toggle interception (emitting `start` / `stop`);
+*   `destroy()` stops (restoring `console`) then destroys the emitter.
+*
+* @example
+* ```ts
+* const capture = new Capture({ levels: ['warn', 'error'], mirror: true })
+* capture.start()
+* console.warn('third-party noise') // captured and mirrored to the real console
+* capture.messages('warn') // [{ level: 'warn', text: 'third-party noise', time: … }]
+* capture.stop() // console.warn restored
 * ```
 */
-var Progress = class {
+var Capture = class {
 	#emitter;
-	#total;
-	#width;
-	#fill;
-	#empty;
+	#levels;
+	#mirror;
 	#sink;
-	#styler;
-	#theme;
-	#message;
-	#current = 0;
-	#active = true;
-	#completed = false;
+	#retention;
+	#originals = /* @__PURE__ */ new Map();
+	#active = false;
 	constructor(options) {
 		this.#emitter = new _orkestrel_emitter.Emitter({
-			...options.on !== void 0 ? { on: options.on } : {},
-			...options.error !== void 0 ? { error: options.error } : {}
+			...options?.on !== void 0 ? { on: options.on } : {},
+			...options?.error !== void 0 ? { error: options.error } : {}
 		});
-		this.#total = options.total;
-		this.#width = options.width ?? 30;
-		this.#fill = options.fill;
-		this.#empty = options.empty;
-		this.#sink = options.sink ?? createConsoleSink();
-		this.#styler = options.styler ?? createStyler();
-		this.#theme = options.theme ?? DEFAULT_THEME;
-		this.#message = options.message ?? "";
+		this.#levels = options?.levels ?? CAPTURE_LEVELS;
+		this.#mirror = options?.mirror ?? false;
+		this.#sink = options?.sink;
+		this.#retention = new Retention(this.#levels, options?.limit ?? 1e3);
 	}
 	get emitter() {
 		return this.#emitter;
@@ -1473,383 +1285,176 @@ var Progress = class {
 	get active() {
 		return this.#active;
 	}
-	get completed() {
-		return this.#completed;
-	}
-	get current() {
-		return this.#current;
-	}
-	get total() {
-		return this.#total;
-	}
-	update(current, message) {
-		if (!this.#active) return;
-		this.#advance(current, message);
-		this.#paint(false);
+	start() {
+		if (this.#active) return;
+		this.#active = true;
+		const target = console;
+		for (const level of this.#levels) {
+			const original = target[level];
+			this.#originals.set(level, original);
+			const mirror = original.bind(console);
+			target[level] = this.#captureCall.bind(this, level, mirror);
+		}
+		this.#emitter.emit("start");
 	}
-	complete(message) {
+	stop() {
 		if (!this.#active) return;
-		this.#advance(this.#total, message);
 		this.#active = false;
-		this.#completed = true;
-		this.#paint(true);
-		this.#emitter.emit("complete");
+		const target = console;
+		for (const [level, original] of this.#originals) target[level] = original;
+		this.#originals.clear();
+		this.#emitter.emit("stop");
 	}
-	failure(message) {
-		if (!this.#active) return;
-		this.#advance(this.#current, message);
-		this.#active = false;
-		this.#paint(true, "error");
+	messages(level) {
+		if (level === void 0) return this.#retention.records();
+		return this.#retention.records(level);
+	}
+	clear() {
+		this.#retention.clear();
 	}
 	destroy() {
+		this.stop();
 		this.#emitter.destroy();
 	}
-	#advance(current, message) {
-		this.#current = Math.max(0, Math.min(this.#total, current));
-		if (message !== void 0) this.#message = message;
-		this.#emitter.emit("update", {
-			current: this.#current,
-			total: this.#total
-		});
+	#captureCall(level, mirror, ...args) {
+		this.#intercept(level, args, mirror);
 	}
-	#paint(final, level) {
-		const bar = renderBar({
-			current: this.#current,
-			total: this.#total,
-			width: this.#width,
-			...this.#fill === void 0 ? {} : { fill: this.#fill },
-			...this.#empty === void 0 ? {} : { empty: this.#empty },
-			styler: this.#styler,
-			style: this.#theme.accent
+	#intercept(level, args, mirror) {
+		const message = this.#capture(level, args);
+		this.#retention.add(message);
+		this.#emitter.emit("capture", message);
+		if (this.#mirror) mirror(...args);
+		if (this.#sink !== void 0) try {
+			this.#sink.write(message.text, CAPTURE_LEVEL_MAP[level]);
+		} catch {}
+	}
+	#capture(level, args) {
+		return Object.freeze({
+			level,
+			text: formatArgs(args),
+			time: Date.now()
 		});
-		const line = this.#message === "" ? bar : `${bar} ${this.#message}`;
-		this.#sink.write(`\r${line}${final ? "\n" : ""}`, level);
 	}
 };
 //#endregion
-//#region src/core/Reporter.ts
+//#region src/core/Styler.ts
 /**
-* A lean, event-free narrative reporter (AGENTS §13) — the composable verb set for human /
-* build-run output. Each verb FORMATS its line through the shared {@link StylerInterface} and
-* the pure layout renderers ({@link renderSeparator} / {@link renderBox} / {@link renderTable}
-* / {@link renderTree}) and WRITES it to a {@link SinkInterface} — the SAME styler + sink
-* substrate the logger uses, never a second colorizer.
+* Builds the fluent, composable styling surface — the consumer-facing API over the style
+* engine. It
+* builds a {@link Style} (style as data) and renders it through an injected
+* {@link RendererInterface} (the ANSI default, or a browser `%c` renderer). Each
+* color / attribute accessor is immutable copy-on-write: it returns a new styler's
+* surface with the token added, so `styler.red.bold('hi')` composes without mutating,
+* and a base styler is freely reusable.
 *
 * @remarks
-* - **A SMALL set, not a grab-bag.** `section` / `step` / `timing` / `status` / `table` /
-*   `tree` / `box` / `line` / `blank`. No spinner / bar (the animation chunk), no buffering /
-*   capture (the capture chunk), no level retention (the logger). Just format + write.
-* - **`status` is a narrative OUTCOME, not a log level.** Its {@link StatusLevel} (`success` /
-*   `error` / `warn` / `info`) is distinct from {@link import('./types.js').LogLevel}: an icon
-*   supplied theme status icon + style, with `error` routed to the sink's
-*   error stream (the `level` hint forwarded to {@link SinkInterface.write}) — there is no
-*   gating and no severity ordering.
-* - **Width-aware.** `section` (and a `box` with no explicit `width`) lay out to the reporter's
-*   `#width`; the renderers measure on VISIBLE width (ANSI-aware), so styled content aligns.
-* - **Event-free (§13).** No `#emitter` — a pure formatting front-end with no observable
-*   lifecycle (like the renderers and `Scheduler`). It is reusable and holds no per-call state.
-*
-* @example
-* ```ts
-* const reporter = new Reporter()
-* reporter.section('Build')
-* reporter.step('compiling', { index: 1, total: 3 }) //   [1/3] compiling
-* reporter.timing('bundle', 1234) //   bundle … 1.23s
-* reporter.status('success', 'done') //   ✔ done
-* ```
+* - **Callable surface.** A `Styler` is not itself callable; its {@link surface} getter
+*   returns the {@link StylerInterface} — a render function carrying the chainable
+*   accessors. The accessors are installed as lazy getters (`Object.defineProperties`),
+*   so a chain materializes only the stylers it actually walks — never the full tree —
+*   and the recursion terminates. The factory returns that surface; this class is the
+*   engine behind it.
+* - **Immutable.** `#foreground` and `#attribute` return a fresh `Styler` (the style is
+*   rebuilt, never mutated). A later color of the same channel wins (last write); a
+*   repeated attribute is idempotent (de-duplicated, order preserved).
+* - **Styling by value.** `render(style, text)` merges a {@link Style} over the accumulated
+*   one and renders that — the same precedence a chain applies, reached with data instead of
+*   accessor names. It is how a {@link import('./types.js').Theme} role is drawn.
+* - **`enabled` switch.** When `false`, the render function returns text verbatim — no
+*   renderer call, no escape codes (for a non-TTY / `NO_COLOR` / piped output).
+* - **Event-free** — a pure styling primitive, like `Scheduler`.
 */
-var Reporter = class {
-	#sink;
-	#styler;
-	#theme;
-	#width;
-	constructor(options) {
-		this.#sink = options?.sink ?? createConsoleSink();
-		this.#styler = options?.styler ?? createStyler();
-		this.#theme = options?.theme ?? DEFAULT_THEME;
-		this.#width = options?.width ?? 80;
+var Styler = class Styler {
+	#renderer;
+	#enabled;
+	#style;
+	constructor(renderer, enabled, style) {
+		this.#renderer = renderer;
+		this.#enabled = enabled;
+		this.#style = style;
 	}
-	section(title) {
-		this.#sink.write(renderSeparator({
-			title,
-			width: this.#width,
-			styler: this.#styler,
-			style: this.#theme.chrome
-		}));
+	/** Holds the accumulated style data — the empty style on a base styler. */
+	get style() {
+		return this.#style;
 	}
-	step(message, position) {
-		const prefix = position === void 0 ? "" : `${this.#styler.render(this.#theme.accent, `[${position.index}/${position.total}]`)} `;
-		this.#sink.write(`${prefix}${message}`);
+	/** Reports whether styling is applied; when `false`, the surface returns text unchanged. */
+	get enabled() {
+		return this.#enabled;
 	}
-	timing(label, ms) {
-		this.#sink.write(`${label} ${this.#styler.render(this.#theme.chrome, `… ${formatDuration(ms)}`)}`);
+	/**
+	* Builds the fluent {@link StylerInterface} value — a render function (`text => string`) with
+	* `style`, `enabled`, and every {@link Color} / {@link Attribute} as a lazy accessor
+	* (each computes the next styler's surface only when read). This is what consumers
+	* hold and call.
+	*
+	* @remarks
+	* The accessors are defined as getters (not eagerly-merged values), so accessing one
+	* builds exactly one child styler — the tree is never fully materialized and the
+	* construction terminates. The assembled function is then narrowed to
+	* {@link StylerInterface} through {@link #isSurface} (a real structural check), so no
+	* type assertion is used — narrow, never assert.
+	*/
+	get surface() {
+		const callable = this.#render.bind(this);
+		const descriptors = {
+			style: {
+				value: this.#style,
+				enumerable: true
+			},
+			enabled: {
+				value: this.#enabled,
+				enumerable: true
+			},
+			render: {
+				value: this.render.bind(this),
+				enumerable: true
+			}
+		};
+		for (const color of COLORS) descriptors[color] = {
+			get: this.#foregroundSurface.bind(this, color),
+			enumerable: true
+		};
+		for (const attribute of ATTRIBUTES) descriptors[attribute] = {
+			get: this.#attributeSurface.bind(this, attribute),
+			enumerable: true
+		};
+		const surface = Object.defineProperties(callable, descriptors);
+		if (this.#isSurface(surface)) return surface;
+		throw new ConsoleError("INVARIANT", "console: styler surface construction is incomplete");
 	}
-	status(level, message) {
-		const status = this.#theme.statuses[level];
-		const line = `${this.#styler.render(status.style, status.icon)} ${this.#styler.render(status.style, message)}`;
-		this.#sink.write(line, level === "error" ? "error" : void 0);
+	/**
+	* Renders `text` in `style` merged over the accumulated style — the by-value door beside
+	* the accessor chain, and how a {@link import('./types.js').Theme} role is applied.
+	*
+	* @param style - The style to overlay; its colors win over the accumulated ones and its
+	* attributes join them (de-duplicated, the accumulated ones first)
+	* @param text - The text to wrap
+	* @returns The rendered text — verbatim when `enabled` is `false`, and (by the
+	* {@link RendererInterface} contract) when the merged style or `text` is empty
+	*
+	* @example
+	* ```ts
+	* import { createStyler, DEFAULT_THEME } from '@orkestrel/console'
+	*
+	* const styler = createStyler()
+	* styler.render(DEFAULT_THEME.levels.warn, 'WARN') // yellow
+	* styler.bold.render(DEFAULT_THEME.chrome, '│') // dim, over the accumulated bold
+	* ```
+	*/
+	render(style, text) {
+		return this.#enabled ? this.#renderer.render(this.#merge(style), text) : text;
 	}
-	table(options) {
-		this.#sink.write(renderTable(this.#resolveStyle(options)));
+	#render(text) {
+		return this.#enabled ? this.#renderer.render(this.#style, text) : text;
 	}
-	tree(options) {
-		this.#sink.write(renderTree(this.#resolveStyle(options)));
-	}
-	box(options) {
-		this.#sink.write(renderBox(this.#resolveStyle({
-			width: this.#width,
-			...options
-		})));
-	}
-	line(text) {
-		this.#sink.write(text);
-	}
-	blank(count = 1) {
-		for (let index = 0; index < count; index += 1) this.#sink.write("");
-	}
-	#resolveStyle(options) {
-		return {
-			styler: this.#styler,
-			...options.styler === void 0 && options.style === void 0 ? { style: this.#theme.chrome } : {},
-			...options
-		};
-	}
-};
-//#endregion
-//#region src/core/Spinner.ts
-/**
-* A self-driving, observable activity spinner (AGENTS §13) — a glyph cycle that advances on a
-* periodic timer, writing each `\r` + frame line to its {@link SinkInterface} and emitting it on
-* `frame`. The leading `\r` is what an overwrite-capable sink (the C-g TTY sink) redraws on; a plain
-* sink (C-f) degrades to a fresh, non-overwriting line — the line-OVERWRITE is the SINK's job, never
-* the spinner's. UNIVERSAL — `setInterval` + the one {@link StylerInterface} + the one
-* {@link SinkInterface}, no `node:*`, no `process.stdout`.
-*
-* @remarks
-* - **Self-driving but deterministically testable.** `start()` arms a `setInterval` that calls
-*   {@link tick} each `interval`; each {@link tick} builds the styled `glyph + message` line for the
-*   current frame, emits it on `frame`, writes `'\r' + line` to the sink, then advances the frame
-*   index (wrapping). A test drives frames by calling {@link tick} directly, or arms a real short
-*   `interval` and proves the timer arms / clears through the sink it writes to.
-* - **Leak-free timer.** The interval is ALWAYS cleared on {@link success} / {@link failure} /
-*   {@link stop} / {@link destroy} — `#handle` is the single source of `active`, set on arm and unset
-*   on clear, so a spinner never leaks a running interval.
-* - **Idempotent `start`.** A {@link start} while already `active` is a no-op (it never arms a second
-*   timer).
-* - **Outcome lines.** {@link success} / {@link failure} clear the timer then write + emit a FINAL line —
-*   the supplied theme status icon + style (`✔` / `✖` by default) + the message — terminated
-*   by a newline (the activity is over; the line is committed, not overwritten). {@link failure} routes to
-*   the sink's error stream.
-* - **Lifecycle (§10).** {@link stop} clears the timer and LEAVES the current line; {@link destroy}
-*   stops then destroys the emitter. {@link update} swaps the message and re-renders immediately when
-*   `active`.
-*
-* @example
-* ```ts
-* const spinner = new Spinner({ message: 'building' })
-* spinner.start() // arms the timer, paints the first frame to the sink
-* spinner.update('bundling') // message changes, re-rendered at once
-* spinner.success('built in 1.2s') // ✔ built in 1.2s — timer cleared, line committed
-* ```
-*/
-var Spinner = class {
-	#emitter;
-	#frames;
-	#interval;
-	#sink;
-	#styler;
-	#theme;
-	#message;
-	#handle;
-	#index = 0;
-	constructor(options) {
-		this.#emitter = new _orkestrel_emitter.Emitter({
-			...options?.on !== void 0 ? { on: options.on } : {},
-			...options?.error !== void 0 ? { error: options.error } : {}
-		});
-		const frames = options?.frames ?? SPINNER_FRAMES;
-		this.#frames = frames.length === 0 ? SPINNER_FRAMES : frames;
-		this.#interval = options?.interval ?? 80;
-		this.#sink = options?.sink ?? createConsoleSink();
-		this.#styler = options?.styler ?? createStyler();
-		this.#theme = options?.theme ?? DEFAULT_THEME;
-		this.#message = options?.message ?? "";
-	}
-	get emitter() {
-		return this.#emitter;
-	}
-	get active() {
-		return this.#handle !== void 0;
-	}
-	get message() {
-		return this.#message;
-	}
-	start() {
-		if (this.#handle !== void 0) return;
-		this.#handle = setInterval(() => this.tick(), this.#interval);
-		this.#emitter.emit("start");
-		this.tick();
-	}
-	tick() {
-		this.#paint(this.#line());
-		this.#index = (this.#index + 1) % this.#frames.length;
-	}
-	update(message) {
-		this.#message = message;
-		if (this.#handle !== void 0) this.#paint(this.#line());
-	}
-	success(message) {
-		this.#finish("success", message);
-	}
-	failure(message) {
-		this.#finish("error", message);
-	}
-	stop() {
-		if (this.#handle === void 0) return;
-		clearInterval(this.#handle);
-		this.#handle = void 0;
-		this.#emitter.emit("stop");
-	}
-	destroy() {
-		this.stop();
-		this.#emitter.destroy();
-	}
-	#finish(level, message) {
-		this.stop();
-		const text = message ?? this.#message;
-		if (message !== void 0) this.#message = message;
-		const status = this.#theme.statuses[level];
-		const line = `${this.#styler.render(status.style, status.icon)} ${this.#styler.render(status.style, text)}`;
-		this.#emitter.emit("frame", line);
-		this.#sink.write(`\r${line}\n`, level === "error" ? "error" : void 0);
-	}
-	#line() {
-		const glyph = this.#styler.render(this.#theme.accent, this.#frames[this.#index] ?? "");
-		return this.#message === "" ? glyph : `${glyph} ${this.#message}`;
-	}
-	#paint(line) {
-		this.#emitter.emit("frame", line);
-		this.#sink.write(`\r${line}`);
-	}
-};
-//#endregion
-//#region src/core/Styler.ts
-/**
-* The fluent, composable styler — the consumer-facing API over the style engine. It
-* builds a {@link Style} (style as DATA) and renders it through an injected
-* {@link RendererInterface} (the ANSI default, or a browser `%c` renderer at C-f). Each
-* color / attribute accessor is immutable copy-on-write: it returns a NEW styler's
-* surface with the token added, so `styler.red.bold('hi')` composes without mutating,
-* and a base styler is freely reusable.
-*
-* @remarks
-* - **Callable surface.** A `Styler` is not itself callable; its {@link surface} getter
-*   returns the {@link StylerInterface} — a render FUNCTION carrying the chainable
-*   accessors. The accessors are installed as LAZY getters (`Object.defineProperties`),
-*   so a chain materializes only the stylers it actually walks — never the full tree —
-*   and the recursion terminates. The factory returns that surface; this class is the
-*   engine behind it.
-* - **Immutable.** `#foreground` and `#attribute` return a fresh `Styler` (the style is
-*   rebuilt, never mutated). A later color of the same channel WINS (last write); a
-*   repeated attribute is idempotent (de-duplicated, order preserved).
-* - **Styling by value.** `render(style, text)` merges a {@link Style} over the accumulated
-*   one and renders that — the same precedence a chain applies, reached with DATA instead of
-*   accessor names. It is how a {@link import('./types.js').Theme} role is drawn.
-* - **`enabled` switch.** When `false`, the render function returns text VERBATIM — no
-*   renderer call, no escape codes (for a non-TTY / `NO_COLOR` / piped output).
-* - **Event-free** — a pure styling primitive (AGENTS §13), like `Scheduler`.
-*/
-var Styler = class Styler {
-	#renderer;
-	#enabled;
-	#style;
-	constructor(renderer, enabled, style) {
-		this.#renderer = renderer;
-		this.#enabled = enabled;
-		this.#style = style;
-	}
-	/** The accumulated style DATA — the empty style on a base styler. */
-	get style() {
-		return this.#style;
-	}
-	/** Whether styling is applied; when `false`, the surface returns text unchanged. */
-	get enabled() {
-		return this.#enabled;
-	}
-	/**
-	* The fluent {@link StylerInterface} value — a render function (`text => string`) with
-	* `style`, `enabled`, and every {@link Color} / {@link Attribute} as a LAZY accessor
-	* (each computes the next styler's surface only when read). This is what consumers
-	* hold and call.
-	*
-	* @remarks
-	* The accessors are defined as getters (not eagerly-merged values), so accessing one
-	* builds exactly one child styler — the tree is never fully materialized and the
-	* construction terminates. The assembled function is then narrowed to
-	* {@link StylerInterface} through {@link #isSurface} (a real structural check), so no
-	* type assertion is used (AGENTS §1 / §14 — narrow, never assert).
-	*/
-	get surface() {
-		const callable = this.#render.bind(this);
-		const descriptors = {
-			style: {
-				value: this.#style,
-				enumerable: true
-			},
-			enabled: {
-				value: this.#enabled,
-				enumerable: true
-			},
-			render: {
-				value: this.render.bind(this),
-				enumerable: true
-			}
-		};
-		for (const color of COLORS) descriptors[color] = {
-			get: this.#foregroundSurface.bind(this, color),
-			enumerable: true
-		};
-		for (const attribute of ATTRIBUTES) descriptors[attribute] = {
-			get: this.#attributeSurface.bind(this, attribute),
-			enumerable: true
-		};
-		const surface = Object.defineProperties(callable, descriptors);
-		if (this.#isSurface(surface)) return surface;
-		throw new ConsoleError("INVARIANT", "console: styler surface construction is incomplete");
-	}
-	/**
-	* Render `text` in `style` merged OVER the accumulated style — the by-value door beside
-	* the accessor chain, and how a {@link import('./types.js').Theme} role is applied.
-	*
-	* @param style - The style to overlay; its colors win over the accumulated ones and its
-	* attributes join them (de-duplicated, the accumulated ones first)
-	* @param text - The text to wrap
-	* @returns The rendered text — verbatim when `enabled` is `false`, and (by the
-	* {@link RendererInterface} contract) when the merged style or `text` is empty
-	*
-	* @example
-	* ```ts
-	* import { createStyler, DEFAULT_THEME } from '@src/core'
-	*
-	* const styler = createStyler()
-	* styler.render(DEFAULT_THEME.levels.warn, 'WARN') // yellow
-	* styler.bold.render(DEFAULT_THEME.chrome, '│') // dim, over the accumulated bold
-	* ```
-	*/
-	render(style, text) {
-		return this.#enabled ? this.#renderer.render(this.#merge(style), text) : text;
-	}
-	#render(text) {
-		return this.#enabled ? this.#renderer.render(this.#style, text) : text;
-	}
-	#merge(style) {
-		const attributes = [...this.#style.attributes];
-		for (const attribute of style.attributes) if (!attributes.includes(attribute)) attributes.push(attribute);
-		return Object.freeze({
-			...this.#style,
-			...style,
-			attributes: Object.freeze(attributes)
-		});
+	#merge(style) {
+		const attributes = [...this.#style.attributes];
+		for (const attribute of style.attributes) if (!attributes.includes(attribute)) attributes.push(attribute);
+		return Object.freeze({
+			...this.#style,
+			...style,
+			attributes: Object.freeze(attributes)
+		});
 	}
 	#foregroundSurface(color) {
 		return this.#foreground(color).surface;
@@ -1877,43 +1482,27 @@ var Styler = class Styler {
 //#endregion
 //#region src/core/factories.ts
 /**
-* Create the cross-environment default {@link RendererInterface} — the ANSI / SGR
-* renderer that turns style DATA into terminal escape codes. The default behind
-* {@link createStyler}; construct one directly to render a {@link import('./types.js').Style}
-* without the fluent surface, or to share one instance across stylers.
-*
-* @returns A stateless ANSI {@link RendererInterface}
-*
-* @example
-* ```ts
-* import { createANSIRenderer } from '@src/core'
+* Creates the fluent, composable {@link StylerInterface} — ANSI by default, retargeted by a
+* `renderer` and stripped of color by `enabled: false`.
 *
-* const renderer = createANSIRenderer()
-* renderer.render({ foreground: 'red', attributes: ['bold'] }, 'alert') // '\x1b[1;31malert\x1b[0m'
-* ```
-*/
-function createANSIRenderer() {
-	return new ANSIRenderer();
-}
-/**
-* Create the fluent, composable {@link StylerInterface} — the consumer-facing styling
-* API. It builds a {@link import('./types.js').Style} under the hood and renders it
-* through a {@link RendererInterface} (the ANSI default), so `styler.red.bold('hi')`
-* yields styled text. Chains are immutable, so a base styler is freely reusable.
+* @remarks
+* It builds a {@link import('./types.js').Style} under the hood and renders it through a
+* {@link import('./types.js').RendererInterface}, so `styler.red.bold('hi')` yields styled text.
+* Chains are immutable, so a base styler is freely reusable.
 *
 * @param options - See {@link StylerOptions}
 * @returns A base {@link StylerInterface}
 *
 * @remarks
 * - `options.renderer` swaps the output target without touching the style model — pass a
-*   browser `%c` / CSS renderer (the C-f branch) to retarget; defaults to the ANSI
+*   browser `%c` / CSS renderer (the browser branch) to retarget; defaults to the ANSI
 *   renderer (the cross-environment default).
 * - `options.enabled` is the no-color switch: when `false`, the styler returns text
-*   VERBATIM (for a non-TTY, `NO_COLOR`, or piped output); defaults to `true`.
+*   verbatim (for a non-TTY, `NO_COLOR`, or piped output); defaults to `true`.
 *
 * @example
 * ```ts
-* import { createStyler } from '@src/core'
+* import { createStyler } from '@orkestrel/console'
 *
 * const style = createStyler()
 * style.red.bold('error') // bold red
@@ -1928,7 +1517,7 @@ function createStyler(options) {
 	return new Styler(options?.renderer ?? new ANSIRenderer(), options?.enabled ?? true, EMPTY_STYLE).surface;
 }
 /**
-* Create a {@link Theme} — the app-wide semantic style vocabulary, merged role by role over
+* Creates a {@link Theme} — the app-wide semantic style vocabulary, merged role by role over
 * {@link DEFAULT_THEME}. Hand one theme to a logger / reporter / spinner / progress and every
 * surface speaks it; omit `options` for the defaults.
 *
@@ -1936,8 +1525,8 @@ function createStyler(options) {
 * @returns A frozen {@link Theme}
 *
 * @remarks
-* - **Merges per ROLE, not per theme.** An omitted role keeps its default, and `levels` /
-*   `statuses` merge per ENTRY — `{ levels: { warn: … } }` restyles the `warn` label and
+* - **Merges per role, not per theme.** An omitted role keeps its default, and `levels` /
+*   `statuses` merge per entry — `{ levels: { warn: … } }` restyles the `warn` label and
 *   leaves `debug` / `info` / `error` untouched.
 * - **Frozen and shareable.** The factory snapshots and deep-freezes every style leaf. The
 *   returned theme and its `levels` / `statuses` records are frozen. Each status record is also
@@ -1945,7 +1534,7 @@ function createStyler(options) {
 *
 * @example
 * ```ts
-* import { createStyler, createTheme } from '@src/core'
+* import { createStyler, createTheme } from '@orkestrel/console'
 *
 * const styler = createStyler()
 * const theme = createTheme({
@@ -1957,7 +1546,7 @@ function createStyler(options) {
 */
 function createTheme(options) {
 	const levels = { ...DEFAULT_THEME.levels };
-	for (const level of LEVELS) levels[level] = freezeStyle(options?.levels?.[level] ?? DEFAULT_THEME.levels[level]);
+	for (const level of LOG_LEVELS) levels[level] = freezeStyle(options?.levels?.[level] ?? DEFAULT_THEME.levels[level]);
 	const statuses = { ...DEFAULT_THEME.statuses };
 	for (const status of STATUS_LEVELS) {
 		const source = options?.statuses?.[status] ?? DEFAULT_THEME.statuses[status];
@@ -1974,27 +1563,28 @@ function createTheme(options) {
 	});
 }
 /**
-* Create the default {@link SinkInterface} — a console sink that routes by level and writes
-* through the `console` methods SNAPSHOTTED at creation. The default output target behind
-* {@link createLogger}.
+* Creates the default {@link SinkInterface} — a console sink that routes by level and writes
+* through the `console` methods snapshotted at creation. The default output target behind the
+* {@link import('./loggers/Logger.js').Logger}.
 *
 * @returns A console {@link SinkInterface}
 *
 * @remarks
 * - **Snapshotted — no capture loop.** It captures `console.log` / `console.warn` /
-*   `console.error` AT CALL TIME and writes through those references. So when a later
-*   `Capture` (C-d) PATCHES `console.*`, this sink still reaches the REAL streams — the
+*   `console.error` at call time and writes through those references. So when a later
+*   `Capture` patches `console.*`, this sink still reaches the real streams — the
 *   writer and the capturer never feed each other (the no-capture-loop principle). Create
-*   the sink (or the logger) BEFORE installing a capture for this to hold.
+*   the sink (or the logger) before installing a capture for this to hold.
 * - **Routes by level.** `error` → the snapshotted `console.error`, `warn` →
 *   `console.warn`, every other level → `console.log`. The `level` is supplied by the
-*   logger; an omitted `level` goes to `console.log`.
+*   logger; an omitted `level` goes to `console.log`. The decision is
+*   {@link import('./helpers.js').selectWriter}'s, shared with the browser and server sinks.
 *
 * @example
 * ```ts
-* import { createConsoleSink } from '@src/core'
+* import { createConsoleSink } from '@orkestrel/console'
 *
-* const sink = createConsoleSink() // snapshots console.* now
+* const sink = createConsoleSink() // snapshots console.* at construction
 * sink.write('boom', 'error') // → the real console.error, even after a later console patch
 * ```
 */
@@ -2003,317 +1593,580 @@ function createConsoleSink() {
 	const warn = console.warn.bind(console);
 	const error = console.error.bind(console);
 	return { write(text, level) {
-		if (level === "error") {
-			error(text);
-			return;
-		}
-		if (level === "warn") {
-			warn(text);
-			return;
-		}
-		log(text);
+		selectWriter(level, {
+			log,
+			warn,
+			error
+		})(text);
 	} };
 }
-/**
-* Create an observable, leveled {@link LoggerInterface} — the entry point into structured
-* logging. Each `debug` / `info` / `warn` / `error` call builds a frozen
-* {@link import('./types.js').LogRecord}, gates it by severity, retains a bounded tail,
-* ALWAYS emits it on `entry` (the transport seam), and — unless `silent` — writes a styled
-* line to its sink.
-*
-* @param options - See {@link LoggerOptions}
-* @returns A {@link LoggerInterface}
-*
-* @remarks
-* - **Record + event = transport (§13).** Subscribe `logger.emitter.on('entry', …)` to tee
-*   records to a file / JSON / remote transport; the event fires for every accepted record,
-*   even when `silent` (silence suppresses only the SINK WRITE).
-* - **Bounded retention.** `entries()` returns the recent records, capped at `options.limit`
-*   (default {@link DEFAULT_LOG_LIMIT}); never unbounded.
-* - **Sink + styler defaults.** `options.sink` defaults to {@link createConsoleSink} (the
-*   snapshotted, level-routing console sink); `options.styler` to {@link createStyler} (ANSI).
-*   Styling is orthogonal to level — a level only chooses a label color.
-*
-* @example
-* ```ts
-* import { createLogger } from '@src/core'
-*
-* const logger = createLogger({ name: 'http', level: 'info' })
-* logger.info('request', { method: 'GET', path: '/' })
-* logger.debug('verbose') // dropped — below the info threshold
-* ```
-*/
-function createLogger(options) {
-	return new Logger(options);
-}
-/**
-* Create an event-free {@link LoggerManagerInterface} — a §9 registry of named loggers plus
-* a convenience fan-out. It mints + stores {@link LoggerInterface}s keyed by name (its
-* defaults flowing into each), looks them up, removes them, and broadcasts a one-off log to
-* every registered logger.
-*
-* @param options - See {@link LoggerManagerOptions}
-* @returns A {@link LoggerManagerInterface}
-*
-* @remarks
-* - **Defaults flow in.** `options.level` / `sink` / `styler` / `limit` / `silent` are the
-*   defaults flowed into every `register`ed logger unless that call's options override them.
-* - **Event-free.** The manager carries NO emitter (each registered logger owns its own
-*   observable `emitter`) — it is a pure registry.
-*
-* @example
-* ```ts
-* import { createLoggerManager } from '@src/core'
-*
-* const loggers = createLoggerManager({ level: 'warn' })
-* loggers.register('http')
-* loggers.register('db', { level: 'debug' }) // overrides the default
-* loggers.warn('slow', { ms: 900 }) // fans out to both
-* ```
-*/
-function createLoggerManager(options) {
-	return new LoggerManager(options);
+function createCaptureResult(fn, options) {
+	const capture = new Capture(options);
+	capture.start();
+	try {
+		const result = fn();
+		if (result instanceof Promise) return result.then((value) => {
+			const messages = capture.messages();
+			capture.destroy();
+			return {
+				value,
+				messages
+			};
+		}, (error) => {
+			capture.destroy();
+			throw error;
+		});
+		const messages = capture.messages();
+		capture.destroy();
+		return {
+			value: result,
+			messages
+		};
+	} catch (error) {
+		capture.destroy();
+		throw error;
+	}
 }
+//#endregion
+//#region src/core/loggers/Logger.ts
 /**
-* Create a lean, event-free {@link ReporterInterface} — the entry point into narrative
-* reporting. Each verb (`section` / `step` / `timing` / `status` / `table` / `tree` / `box` /
-* `line` / `blank`) formats through the shared styler + the pure layout renderers and writes to
-* the sink — human / build-run narration over the SAME substrate the logger uses.
-*
-* @param options - See {@link ReporterOptions}
-* @returns A {@link ReporterInterface}
+* Implements an observable, leveled logger — the entry point into the structured-logging
+* pipeline. Each `debug` / `info` / `warn` / `error` call builds a frozen {@link LogRecord},
+* gates it by severity, retains a bounded tail of accepted records, always emits it on
+* `entry` (the transport seam), and — unless `silent` — formats it into a styled line and
+* writes it to its {@link SinkInterface}.
 *
 * @remarks
-* - **One styler, one sink.** `options.styler` defaults to {@link createStyler} (ANSI) and
-*   `options.sink` to {@link createConsoleSink} (the snapshotted, level-routing console sink) —
-*   no second colorizer. A `status('error', …)` routes to the sink's error stream.
-* - **Width-aware.** `options.width` (default {@link DEFAULT_WIDTH}) sizes `section` and a
-*   `box` with no explicit width; the renderers align on VISIBLE width so styled content keeps
-*   its columns.
-* - **Event-free (§13).** The reporter carries no emitter — a pure formatting front-end, like
-*   the renderers and `Scheduler`. Reach for a {@link createLogger} when you need observable,
-*   leveled, transportable records instead.
+* - **Record + event = transport.** An accepted record is frozen and emitted on
+*   `entry` before anything else observable — every file / JSON / remote transport rides
+*   `emitter.on('entry')`. The event fires even when `silent`: silence suppresses only the
+*   sink write, never the record or the event, so transports keep flowing.
+* - **Leveled gate.** A record whose {@link LogLevel} is below the logger's `level` threshold
+*   is dropped entirely — no record built past the level check, no event, no retention, no
+*   write (see {@link meetsLevel}).
+* - **Bounded retention.** Accepted records accrue in a ring capped at `limit` (default
+*   {@link DEFAULT_LOG_LIMIT}); the oldest is dropped when full. `entries()` returns a copy,
+*   oldest first; `clear()` empties it. Never unbounded — retention is capped at `limit`.
+* - **Styled write, orthogonal to level.** The line ({@link formatRecord}) is colored through
+*   the injected `styler` (the ANSI default, or a browser `%c` styler) — a level only
+*   chooses a label color; styling is not a level. A disabled styler yields a plain line.
+* - **Snapshotted sink.** The default {@link createConsoleSink} writes to the `console`
+*   methods captured at creation, so a later `Capture` patching `console` can't loop the
+*   sink's output back into itself.
 *
 * @example
 * ```ts
-* import { createReporter } from '@src/core'
+* const logger = new Logger({ name: 'http', level: 'info' })
+* logger.emitter.on('entry', (record) => archive(record)) // transport hook
+* logger.info('request', { method: 'GET', path: '/' }) // styled line to the console sink
+* logger.debug('verbose') // dropped — below the `info` threshold
+* logger.entries() // [the info record]
+* ```
+*/
+var Logger = class {
+	#emitter;
+	#level;
+	#sink;
+	#styler;
+	#theme;
+	#format;
+	#limit;
+	#silent;
+	#entries = [];
+	name;
+	constructor(options) {
+		this.#emitter = new _orkestrel_emitter.Emitter({
+			...options?.on !== void 0 ? { on: options.on } : {},
+			...options?.error !== void 0 ? { error: options.error } : {}
+		});
+		this.#level = options?.level ?? "info";
+		if (options?.name !== void 0) this.name = options.name;
+		this.#sink = options?.sink ?? createConsoleSink();
+		this.#styler = options?.styler ?? createStyler();
+		this.#theme = options?.theme ?? DEFAULT_THEME;
+		this.#format = options?.format ?? formatRecord;
+		this.#limit = options?.limit ?? 1e3;
+		this.#silent = options?.silent ?? false;
+	}
+	get emitter() {
+		return this.#emitter;
+	}
+	get level() {
+		return this.#level;
+	}
+	debug(message, data) {
+		this.#log("debug", message, data);
+	}
+	info(message, data) {
+		this.#log("info", message, data);
+	}
+	warn(message, data) {
+		this.#log("warn", message, data);
+	}
+	error(message, data) {
+		this.#log("error", message, data);
+	}
+	entries() {
+		return [...this.#entries];
+	}
+	clear() {
+		this.#entries.length = 0;
+	}
+	destroy() {
+		this.#entries.length = 0;
+		this.#emitter.destroy();
+	}
+	#log(level, message, data) {
+		if (!meetsLevel(this.#level, level)) return;
+		const record = this.#record(level, message, data);
+		this.#retain(record);
+		this.#emitter.emit("entry", record);
+		if (this.#silent) return;
+		this.#sink.write(this.#format(record, this.#styler, this.#theme), level);
+	}
+	#record(level, message, data) {
+		return Object.freeze({
+			level,
+			message,
+			time: Date.now(),
+			...this.name === void 0 ? {} : { name: this.name },
+			...data === void 0 ? {} : { data: Object.freeze({ ...data }) }
+		});
+	}
+	#retain(record) {
+		this.#entries.push(record);
+		if (this.#entries.length > this.#limit) this.#entries.shift();
+	}
+};
+//#endregion
+//#region src/core/loggers/LoggerManager.ts
+/**
+* Implements an event-free registry of named {@link Logger}s plus a convenience fan-out — the
+* manager over the logging layer (a registry, never observable itself; each {@link Logger}
+* owns its own `emitter`).
 *
-* const reporter = createReporter()
-* reporter.section('Build')
-* reporter.step('bundling', { index: 2, total: 5 }) // [2/5] bundling
-* reporter.status('success', 'built in 1.2s') // ✔ built in 1.2s
+* @remarks
+* - **Registry.** Loggers live in an insertion-ordered `Map` keyed by `name`.
+*   `register(name, options?)` mints a {@link Logger} named `name` — the manager's default
+*   `level` / `sink` / `styler` / `theme` / `format` / `limit` / `silent` flow in unless
+*   `options` overrides them
+*   (`name` is always the registry key, so any `options.name` is ignored) — stores it (a
+*   re-`register` of the same name overwrites, last write wins), and returns it. `count` is
+*   the map size, `logger(name)` looks one up, `loggers()` lists them in insertion order.
+* - **Removal.** `remove()` clears all, `remove(name)` drops one (`true` if present),
+*   `remove(names)` drops a batch (`true` only when every name was present; an empty list
+*   succeeds vacuously). Every listed name is attempted whatever the result.
+*   (Removal does not `destroy` the returned loggers — a caller still holding one keeps using
+*   it; the manager stops tracking it.)
+* - **Fan-out.** `debug` / `info` / `warn` / `error(message, data?)` forward the one call to
+*   every registered logger in insertion order; each gates / emits / writes per its own `level`
+*   and `sink`. A formatter throw is a programmer error and propagates, stopping the remaining
+*   loggers for that call. A fan-out over an empty registry is a no-op.
+* - **Event-free.** No emitter, no events — the manager is a pure registry; observability is
+*   per-{@link Logger}.
 *
-* // Disable color (a non-TTY) — every line is plain.
-* const plain = createReporter({ styler: createStyler({ enabled: false }) })
+* @example
+* ```ts
+* const manager = new LoggerManager({ level: 'warn' })
+* manager.register('http') // inherits the `warn` default
+* manager.register('db', { level: 'debug' }) // overrides to `debug`
+* manager.warn('slow', { ms: 900 }) // fans out to both loggers
+* manager.count // 2
 * ```
 */
-function createReporter(options) {
-	return new Reporter(options);
-}
+var LoggerManager = class {
+	#loggers = /* @__PURE__ */ new Map();
+	#level;
+	#sink;
+	#styler;
+	#theme;
+	#format;
+	#limit;
+	#silent;
+	constructor(options) {
+		this.#level = options?.level;
+		this.#sink = options?.sink;
+		this.#styler = options?.styler;
+		this.#theme = options?.theme;
+		this.#format = options?.format;
+		this.#limit = options?.limit;
+		this.#silent = options?.silent;
+	}
+	get count() {
+		return this.#loggers.size;
+	}
+	register(name, options) {
+		const logger = new Logger({
+			...this.#level !== void 0 ? { level: this.#level } : {},
+			...this.#sink !== void 0 ? { sink: this.#sink } : {},
+			...this.#styler !== void 0 ? { styler: this.#styler } : {},
+			...this.#theme !== void 0 ? { theme: this.#theme } : {},
+			...this.#format !== void 0 ? { format: this.#format } : {},
+			...this.#limit !== void 0 ? { limit: this.#limit } : {},
+			...this.#silent !== void 0 ? { silent: this.#silent } : {},
+			...options,
+			name
+		});
+		this.#loggers.set(name, logger);
+		return logger;
+	}
+	logger(name) {
+		return this.#loggers.get(name);
+	}
+	loggers() {
+		return [...this.#loggers.values()];
+	}
+	debug(message, data) {
+		for (const logger of this.#loggers.values()) logger.debug(message, data);
+	}
+	info(message, data) {
+		for (const logger of this.#loggers.values()) logger.info(message, data);
+	}
+	warn(message, data) {
+		for (const logger of this.#loggers.values()) logger.warn(message, data);
+	}
+	error(message, data) {
+		for (const logger of this.#loggers.values()) logger.error(message, data);
+	}
+	remove(names) {
+		if (names === void 0) {
+			this.#loggers.clear();
+			return;
+		}
+		if ((0, _orkestrel_contract.isArray)(names)) {
+			let removed = true;
+			for (const name of names) if (!this.#loggers.delete(name)) removed = false;
+			return removed;
+		}
+		return this.#loggers.delete(names);
+	}
+};
+//#endregion
+//#region src/core/Reporter.ts
 /**
-* Create an observable {@link CaptureInterface} — console interception on the READ side. While
-* `active`, every configured `console.*` call is captured as a frozen
-* {@link import('./types.js').CapturedMessage}, buffered (total + by level, bounded), emitted on
-* `capture`, and — per options — mirrored to the real console and/or forwarded to a
-* {@link SinkInterface}.
-*
-* @param options - See {@link CaptureOptions}
-* @returns A {@link CaptureInterface} (inactive until `start()`)
+* Implements a lean, event-free narrative reporter — the composable verb set for human /
+* build-run output. Each verb formats its line through the shared {@link StylerInterface} and
+* the pure layout renderers ({@link renderSeparator} / {@link renderBox} / {@link renderTable}
+* / {@link renderTree}) and writes it to a {@link SinkInterface} — the same styler + sink
+* substrate the logger uses, never a second colorizer.
 *
 * @remarks
-* - **Snapshot-at-start — no capture loop.** `start()` snapshots the CURRENT `console[level]` per
-*   configured level, then patches; the mirror writes through that snapshot. Our OWN console sink
-*   output (the Logger / Reporter, which snapshot `console` at creation) is never recaptured —
-*   `Capture` catches THIRD-PARTY `console.*`, not our writes. Create your loggers FIRST.
-* - **PROCESS-GLOBAL + NON-REENTRANT.** It patches the one global `console`, so at most ONE
-*   capture may be active at a time; two concurrent captures interleave and clobber each other's
-*   restore. Prefer {@link withCapture} for a scoped, self-restoring capture.
-* - **Bounded.** `options.limit` (default {@link import('./constants.js').DEFAULT_CAPTURE_LIMIT})
-*   caps both the total buffer and each by-level bucket; never unbounded.
+* - **A small set, not a grab-bag.** `section` / `step` / `timing` / `status` / `table` /
+*   `tree` / `box` / `line` / `blank`. No spinner / bar (the animation chunk), no buffering /
+*   capture (the capture chunk), no level retention (the logger). Format and write, nothing more.
+* - **`status` is a narrative outcome, not a log level.** Its {@link StatusLevel} (`success` /
+*   `error` / `warn` / `info`) is distinct from {@link import('./types.js').LogLevel}: an icon
+*   supplied theme status icon + style, with `error` routed to the sink's
+*   error stream (the `level` hint forwarded to {@link SinkInterface.write}) — there is no
+*   gating and no severity ordering.
+* - **Width-aware.** `section` (and a `box` with no explicit `width`) lay out to the reporter's
+*   `#width`; the renderers measure on visible width (ANSI-aware), so styled content aligns.
+* - **Event-free.** No `#emitter` — a pure formatting front-end with no observable
+*   lifecycle (like the renderers and `Scheduler`). It is reusable and holds no per-call state.
 *
 * @example
 * ```ts
-* import { createCapture } from '@src/core'
-*
-* const capture = createCapture({ levels: ['warn', 'error'] })
-* capture.start()
-* console.error('boom') // captured, NOT mirrored (mirror defaults to false)
-* capture.messages('error') // [{ level: 'error', text: 'boom', time: … }]
-* capture.stop()
+* const reporter = new Reporter()
+* reporter.section('Build')
+* reporter.step('compiling', { index: 1, total: 3 }) //   [1/3] compiling
+* reporter.timing('bundle', 1234) //   bundle … 1.23s
+* reporter.status('success', 'done') //   ✔ done
 * ```
 */
-function createCapture(options) {
-	return new Capture(options);
-}
+var Reporter = class {
+	#sink;
+	#styler;
+	#theme;
+	#width;
+	constructor(options) {
+		this.#sink = options?.sink ?? createConsoleSink();
+		this.#styler = options?.styler ?? createStyler();
+		this.#theme = options?.theme ?? DEFAULT_THEME;
+		this.#width = options?.width ?? 80;
+	}
+	section(title) {
+		this.#sink.write(renderSeparator({
+			title,
+			width: this.#width,
+			styler: this.#styler,
+			style: this.#theme.chrome
+		}));
+	}
+	step(message, position) {
+		const prefix = position === void 0 ? "" : `${this.#styler.render(this.#theme.accent, `[${position.index}/${position.total}]`)} `;
+		this.#sink.write(`${prefix}${message}`);
+	}
+	timing(label, ms) {
+		this.#sink.write(`${label} ${this.#styler.render(this.#theme.chrome, `… ${formatDuration(ms)}`)}`);
+	}
+	status(level, message) {
+		const status = this.#theme.statuses[level];
+		const line = `${this.#styler.render(status.style, status.icon)} ${this.#styler.render(status.style, message)}`;
+		this.#sink.write(line, level === "error" ? "error" : void 0);
+	}
+	table(options) {
+		this.#sink.write(renderTable(this.#resolveStyle(options)));
+	}
+	tree(options) {
+		this.#sink.write(renderTree(this.#resolveStyle(options)));
+	}
+	box(options) {
+		this.#sink.write(renderBox(this.#resolveStyle({
+			width: this.#width,
+			...options
+		})));
+	}
+	line(text) {
+		this.#sink.write(text);
+	}
+	blank(count = 1) {
+		for (let index = 0; index < count; index += 1) this.#sink.write("");
+	}
+	#resolveStyle(options) {
+		return {
+			styler: this.#styler,
+			...options.styler === void 0 && options.style === void 0 ? { style: this.#theme.chrome } : {},
+			...options
+		};
+	}
+};
+//#endregion
+//#region src/core/Spinner.ts
 /**
-* Create a self-driving, observable {@link SpinnerInterface} — a live activity spinner. `start()`
-* arms a periodic timer that advances a glyph cycle, writing each `\r` + frame line to its sink and
-* emitting it on `frame`; `success` / `failure` commit a final `✔` / `✖` line. The leading `\r` is the
-* sink's to redraw on — a TTY sink (C-g) overwrites for a smooth animation, a plain sink (C-f)
-* degrades to a fresh line.
-*
-* @param options - See {@link SpinnerOptions}
-* @returns A {@link SpinnerInterface} (inactive until `start()`)
+* Implements a self-driving, observable activity spinner — a glyph cycle that advances on a
+* periodic timer, writing each `\r` + frame line to its {@link SinkInterface} and emitting it on
+* `frame`. The timer is always cleared on an outcome, so the spinner is leak-free.
 *
 * @remarks
-* - **Universal + leak-free.** Built on `setInterval` + the one styler + the one sink (no `node:*`,
-*   no `process.stdout`); the timer is ALWAYS cleared on `success` / `failure` / `stop` / `destroy`, so
-*   it never leaks. `start()` is idempotent (no second timer while `active`).
-* - **Observable (§13).** Subscribe `spinner.emitter.on('frame', …)` to mirror the animation without
-*   a terminal; `start` / `stop` bracket the timer lifecycle. `options.sink` defaults to
-*   {@link createConsoleSink}, `options.styler` to {@link createStyler} (ANSI).
-*
-* @example
-* ```ts
-* import { createSpinner } from '@src/core'
-*
-* const spinner = createSpinner({ message: 'building' })
-* spinner.start()
-* spinner.success('built in 1.2s') // ✔ built in 1.2s — timer cleared, line committed
-* ```
-*/
-function createSpinner(options) {
-	return new Spinner(options);
-}
-/**
-* Create an update-driven, observable {@link ProgressInterface} — a live progress bar. Each
-* `update(current)` recomputes the bar, writes `\r` + bar to its sink, and emits `{ current, total }`
-* on `update`; `complete` / `failure` commit a final line. The leading `\r` is the sink's to redraw on —
-* a TTY sink (C-g) overwrites, a plain sink (C-f) degrades to a fresh line. NO self-timer — the caller
-* drives the bar.
-*
-* @param options - See {@link ProgressOptions} (`total` is required)
-* @returns A {@link ProgressInterface}
+* The leading `\r` is what an overwrite-capable sink (the TTY sink) redraws on; a plain sink
+* degrades to a fresh, non-overwriting line — the line-overwrite is the sink's job, never the
+* spinner's. Universal — `setInterval` + the one {@link StylerInterface} + the one
+* {@link SinkInterface}, no `node:*`, no `process.stdout`.
 *
-* @remarks
-* - **Universal + update-driven.** Built on the one styler + the one sink (no `node:*`, no
-*   `process.stdout`); progress advances only when the caller reports it. `current` is always clamped
-*   to `[0, total]`. `options.sink` defaults to {@link createConsoleSink}, `options.styler` to
-*   {@link createStyler} (ANSI).
-* - **Observable (§13).** Subscribe `progress.emitter.on('update', …)` to mirror progress without a
-*   terminal; `complete` signals a successful finish.
+* - **Self-driving but deterministically testable.** `start()` arms a `setInterval` that calls
+*   {@link tick} each `interval`; each {@link tick} builds the styled `glyph + message` line for the
+*   current frame, emits it on `frame`, writes `'\r' + line` to the sink, then advances the frame
+*   index (wrapping). A test drives frames by calling {@link tick} directly, or arms a real short
+*   `interval` and proves the timer arms / clears through the sink it writes to.
+* - **Leak-free timer.** The interval is always cleared on {@link succeed} / {@link fail} /
+*   {@link stop} / {@link destroy} — `#handle` is the single source of `active`, set on arm and unset
+*   on clear, so a spinner never leaks a running interval.
+* - **Idempotent `start`.** A {@link start} while already `active` is a no-op (it never arms a second
+*   timer).
+* - **Outcome lines.** {@link succeed} / {@link fail} clear the timer then write + emit a final line —
+*   the supplied theme status icon + style (`✔` / `✖` by default) + the message — terminated
+*   by a newline (the activity is over; the line is committed, not overwritten). {@link fail} routes to
+*   the sink's error stream.
+* - **Lifecycle.** {@link stop} clears the timer and leaves the current line; {@link destroy}
+*   stops then destroys the emitter. {@link update} swaps the message and re-renders immediately when
+*   `active`.
 *
 * @example
 * ```ts
-* import { createProgress } from '@src/core'
-*
-* const progress = createProgress({ total: 100, message: 'downloading' })
-* progress.update(40)
-* progress.complete('done')
+* const spinner = new Spinner({ message: 'building' })
+* spinner.start() // arms the timer, paints the first frame to the sink
+* spinner.update('bundling') // message changes, re-rendered at once
+* spinner.succeed('built in 1.2s') // ✔ built in 1.2s — timer cleared, line committed
 * ```
 */
-function createProgress(options) {
-	return new Progress(options);
-}
+var Spinner = class {
+	#emitter;
+	#frames;
+	#interval;
+	#sink;
+	#styler;
+	#theme;
+	#message;
+	#handle;
+	#index = 0;
+	constructor(options) {
+		this.#emitter = new _orkestrel_emitter.Emitter({
+			...options?.on !== void 0 ? { on: options.on } : {},
+			...options?.error !== void 0 ? { error: options.error } : {}
+		});
+		const frames = options?.frames ?? SPINNER_FRAMES;
+		this.#frames = frames.length === 0 ? SPINNER_FRAMES : frames;
+		this.#interval = options?.interval ?? 80;
+		this.#sink = options?.sink ?? createConsoleSink();
+		this.#styler = options?.styler ?? createStyler();
+		this.#theme = options?.theme ?? DEFAULT_THEME;
+		this.#message = options?.message ?? "";
+	}
+	get emitter() {
+		return this.#emitter;
+	}
+	get active() {
+		return this.#handle !== void 0;
+	}
+	get message() {
+		return this.#message;
+	}
+	start() {
+		if (this.#handle !== void 0) return;
+		this.#handle = setInterval(() => this.tick(), this.#interval);
+		this.#emitter.emit("start");
+		this.tick();
+	}
+	tick() {
+		this.#paint(this.#line());
+		this.#index = (this.#index + 1) % this.#frames.length;
+	}
+	update(message) {
+		this.#message = message;
+		if (this.#handle !== void 0) this.#paint(this.#line());
+	}
+	succeed(message) {
+		this.#finish("success", message);
+	}
+	fail(message) {
+		this.#finish("error", message);
+	}
+	stop() {
+		if (this.#handle === void 0) return;
+		clearInterval(this.#handle);
+		this.#handle = void 0;
+		this.#emitter.emit("stop");
+	}
+	destroy() {
+		this.stop();
+		this.#emitter.destroy();
+	}
+	#finish(level, message) {
+		this.stop();
+		const text = message ?? this.#message;
+		if (message !== void 0) this.#message = message;
+		const status = this.#theme.statuses[level];
+		const line = `${this.#styler.render(status.style, status.icon)} ${this.#styler.render(status.style, text)}`;
+		this.#emitter.emit("frame", line);
+		this.#sink.write(`\r${line}\n`, level === "error" ? "error" : void 0);
+	}
+	#line() {
+		const glyph = this.#styler.render(this.#theme.accent, this.#frames[this.#index] ?? "");
+		return this.#message === "" ? glyph : `${glyph} ${this.#message}`;
+	}
+	#paint(line) {
+		this.#emitter.emit("frame", line);
+		this.#sink.write(`\r${line}`);
+	}
+};
 //#endregion
-//#region src/core/Logger.ts
+//#region src/core/Progress.ts
 /**
-* An observable, leveled logger (AGENTS §13) — the entry point into the structured-logging
-* pipeline. Each `debug` / `info` / `warn` / `error` call builds a frozen {@link LogRecord},
-* gates it by severity, retains a bounded tail of accepted records, ALWAYS emits it on
-* `entry` (the transport seam), and — unless `silent` — formats it into a styled line and
-* writes it to its {@link SinkInterface}.
+* Implements an update-driven, observable progress bar — {@link update} recomputes the bar through
+* {@link renderBar}, writes `\r` + bar to its {@link SinkInterface}, and emits the `{ current,
+* total }` on `update`. No self-timer, unlike {@link import('./Spinner.js').Spinner} — the caller
+* drives it.
 *
 * @remarks
-* - **Record + event = transport (§13).** An accepted record is frozen and emitted on
-*   `entry` BEFORE anything else observable — every file / JSON / remote transport rides
-*   `emitter.on('entry')`. The event fires even when `silent`: silence suppresses only the
-*   SINK WRITE, never the record or the event, so transports keep flowing.
-* - **Leveled gate.** A record whose {@link LogLevel} is below the logger's `level` threshold
-*   is dropped ENTIRELY — no record built past the level check, no event, no retention, no
-*   write (see {@link meetsLevel}).
-* - **Bounded retention.** Accepted records accrue in a ring capped at `limit` (default
-*   {@link DEFAULT_LOG_LIMIT}); the oldest is dropped when full. `entries()` returns a copy,
-*   oldest first; `clear()` empties it. NEVER unbounded (scsr's leak).
-* - **Styled write, orthogonal to level.** The line ({@link formatRecord}) is colored through
-*   the injected `styler` (the ANSI default, or a browser `%c` styler at C-f) — a level only
-*   chooses a label color; styling is not a level. A disabled styler yields a plain line.
-* - **Snapshotted sink.** The default {@link createConsoleSink} writes to the `console`
-*   methods captured at creation, so a later `Capture` patching `console` can't loop the
-*   sink's output back into itself.
+* The leading `\r` is what an overwrite-capable sink (the TTY sink) redraws on; a plain sink
+* degrades to a fresh, non-overwriting line — the line-overwrite is the sink's job. Universal —
+* the one {@link StylerInterface} + the one {@link SinkInterface}, no `node:*`, no
+* `process.stdout`.
+*
+* - **Update-driven.** Each {@link update} clamps `current` to `[0, total]`, renders the bar (filled
+*   to `current / total`, with the trailing `percent (current/total)` + message) through {@link renderBar},
+*   emits `update`, and writes `'\r' + bar`. Progress advances only when the caller reports it.
+* - **Outcome lines.** {@link succeed} renders a full bar (`current = total`) + message, terminated by
+*   a newline, emits a final `update` then `succeed`, and marks `succeeded`. {@link fail} renders the
+*   bar at its current fill + message + newline and routes to the sink's error stream (no `succeed` —
+*   the work did not finish). Both are terminal: a later {@link update} is ignored once `active` is false.
+* - **Bounded.** `current` is always clamped to `[0, total]`; {@link succeeded} reports whether
+*   {@link succeed} has run; {@link active} is `true` until a {@link succeed} / {@link fail}.
+* - **Lifecycle.** {@link destroy} destroys the emitter (there is no timer to clear).
 *
 * @example
 * ```ts
-* const logger = new Logger({ name: 'http', level: 'info' })
-* logger.emitter.on('entry', (record) => archive(record)) // transport hook
-* logger.info('request', { method: 'GET', path: '/' }) // styled line to the console sink
-* logger.debug('verbose') // dropped — below the `info` threshold
-* logger.entries() // [the info record]
+* const progress = new Progress({ total: 100, message: 'downloading' })
+* progress.update(40) // ████████████░░░░░░░░░░░░░░░░░░ 40% (40/100) downloading
+* progress.update(80, 'almost there')
+* progress.succeed('done') // a full bar, committed with a newline
 * ```
 */
-var Logger = class {
+var Progress = class {
 	#emitter;
-	#level;
+	#total;
+	#width;
+	#fill;
+	#empty;
 	#sink;
 	#styler;
 	#theme;
-	#format;
-	#limit;
-	#silent;
-	#entries = [];
-	name;
+	#message;
+	#current = 0;
+	#active = true;
+	#succeeded = false;
 	constructor(options) {
 		this.#emitter = new _orkestrel_emitter.Emitter({
-			...options?.on !== void 0 ? { on: options.on } : {},
-			...options?.error !== void 0 ? { error: options.error } : {}
+			...options.on !== void 0 ? { on: options.on } : {},
+			...options.error !== void 0 ? { error: options.error } : {}
 		});
-		this.#level = options?.level ?? "info";
-		if (options?.name !== void 0) this.name = options.name;
-		this.#sink = options?.sink ?? createConsoleSink();
-		this.#styler = options?.styler ?? createStyler();
-		this.#theme = options?.theme ?? DEFAULT_THEME;
-		this.#format = options?.format ?? formatRecord;
-		this.#limit = options?.limit ?? 1e3;
-		this.#silent = options?.silent ?? false;
+		this.#total = options.total;
+		this.#width = options.width ?? 30;
+		this.#fill = options.fill;
+		this.#empty = options.empty;
+		this.#sink = options.sink ?? createConsoleSink();
+		this.#styler = options.styler ?? createStyler();
+		this.#theme = options.theme ?? DEFAULT_THEME;
+		this.#message = options.message ?? "";
 	}
 	get emitter() {
 		return this.#emitter;
 	}
-	get level() {
-		return this.#level;
+	get active() {
+		return this.#active;
 	}
-	debug(message, data) {
-		this.#log("debug", message, data);
+	get succeeded() {
+		return this.#succeeded;
 	}
-	info(message, data) {
-		this.#log("info", message, data);
+	get current() {
+		return this.#current;
 	}
-	warn(message, data) {
-		this.#log("warn", message, data);
+	get total() {
+		return this.#total;
 	}
-	error(message, data) {
-		this.#log("error", message, data);
+	update(current, message) {
+		if (!this.#active) return;
+		this.#advance(current, message);
+		this.#paint(false);
 	}
-	entries() {
-		return [...this.#entries];
+	succeed(message) {
+		if (!this.#active) return;
+		this.#advance(this.#total, message);
+		this.#active = false;
+		this.#succeeded = true;
+		this.#paint(true);
+		this.#emitter.emit("succeed");
 	}
-	clear() {
-		this.#entries.length = 0;
+	fail(message) {
+		if (!this.#active) return;
+		this.#advance(this.#current, message);
+		this.#active = false;
+		this.#paint(true, "error");
 	}
 	destroy() {
-		this.#entries.length = 0;
 		this.#emitter.destroy();
 	}
-	#log(level, message, data) {
-		if (!meetsLevel(this.#level, level)) return;
-		const record = this.#record(level, message, data);
-		this.#retain(record);
-		this.#emitter.emit("entry", record);
-		if (this.#silent) return;
-		this.#sink.write(this.#format(record, this.#styler, this.#theme), level);
+	#advance(current, message) {
+		this.#current = Math.max(0, Math.min(this.#total, current));
+		if (message !== void 0) this.#message = message;
+		const report = {
+			current: this.#current,
+			total: this.#total
+		};
+		this.#emitter.emit("update", report);
 	}
-	#record(level, message, data) {
-		return Object.freeze({
-			level,
-			message,
-			time: Date.now(),
-			...this.name === void 0 ? {} : { name: this.name },
-			...data === void 0 ? {} : { data: Object.freeze({ ...data }) }
+	#paint(final, level) {
+		const bar = renderBar({
+			current: this.#current,
+			total: this.#total,
+			width: this.#width,
+			...this.#fill === void 0 ? {} : { fill: this.#fill },
+			...this.#empty === void 0 ? {} : { empty: this.#empty },
+			styler: this.#styler,
+			style: this.#theme.accent
 		});
-	}
-	#retain(record) {
-		this.#entries.push(record);
-		if (this.#entries.length > this.#limit) this.#entries.shift();
+		const line = this.#message === "" ? bar : `${bar} ${this.#message}`;
+		this.#sink.write(`\r${line}${final ? "\n" : ""}`, level);
 	}
 };
 //#endregion
@@ -2336,7 +2189,6 @@ exports.ConsoleError = ConsoleError;
 exports.DEFAULT_ALIGN = DEFAULT_ALIGN;
 exports.DEFAULT_BAR_WIDTH = DEFAULT_BAR_WIDTH;
 exports.DEFAULT_BORDER = DEFAULT_BORDER;
-exports.DEFAULT_CAPTURE_LEVELS = DEFAULT_CAPTURE_LEVELS;
 exports.DEFAULT_CAPTURE_LIMIT = DEFAULT_CAPTURE_LIMIT;
 exports.DEFAULT_LOG_LEVEL = DEFAULT_LOG_LEVEL;
 exports.DEFAULT_LOG_LIMIT = DEFAULT_LOG_LIMIT;
@@ -2347,15 +2199,16 @@ exports.DEFAULT_WIDTH = DEFAULT_WIDTH;
 exports.EMPTY_STYLE = EMPTY_STYLE;
 exports.ESC = ESC;
 exports.FOREGROUND_CODES = FOREGROUND_CODES;
-exports.LEVELS = LEVELS;
 exports.LEVEL_COLORS = LEVEL_COLORS;
 exports.LEVEL_SEVERITY = LEVEL_SEVERITY;
+exports.LOG_LEVELS = LOG_LEVELS;
 exports.Logger = Logger;
 exports.LoggerManager = LoggerManager;
 exports.Progress = Progress;
 exports.RESET = RESET;
 exports.RESET_CODE = RESET_CODE;
 exports.Reporter = Reporter;
+exports.Retention = Retention;
 exports.SECOND_MS = SECOND_MS;
 exports.SEPARATOR_FILL = SEPARATOR_FILL;
 exports.SEPARATOR_TITLE_GAP = SEPARATOR_TITLE_GAP;
@@ -2366,14 +2219,8 @@ exports.STATUS_LEVELS = STATUS_LEVELS;
 exports.Spinner = Spinner;
 exports.align = align;
 exports.cellAt = cellAt;
-exports.createANSIRenderer = createANSIRenderer;
-exports.createCapture = createCapture;
+exports.createCaptureResult = createCaptureResult;
 exports.createConsoleSink = createConsoleSink;
-exports.createLogger = createLogger;
-exports.createLoggerManager = createLoggerManager;
-exports.createProgress = createProgress;
-exports.createReporter = createReporter;
-exports.createSpinner = createSpinner;
 exports.createStyler = createStyler;
 exports.createTheme = createTheme;
 exports.formatArgs = formatArgs;
@@ -2391,10 +2238,10 @@ exports.renderTable = renderTable;
 exports.renderTree = renderTree;
 exports.renderTreeChildren = renderTreeChildren;
 exports.repeatTo = repeatTo;
+exports.selectWriter = selectWriter;
 exports.stringifyValue = stringifyValue;
 exports.strip = strip;
 exports.stripControls = stripControls;
 exports.width = width;
-exports.withCapture = withCapture;
 
 //# sourceMappingURL=index.cjs.map