@orkestrel/console 0.0.11 → 0.0.13

package/dist/src/server/index.cjs

@@ -4,57 +4,56 @@ let _orkestrel_emitter = require("@orkestrel/emitter");
 let _src_core = require("../core/index.cjs");
 //#region src/server/constants.ts
 /**
-* The two process streams a {@link import('./types.js').ProcessCaptureInterface} can intercept, in
-* `stdout`-then-`stderr` order — the {@link StreamLevel} universe and the default configured set.
+* Lists the process streams a {@link import('./types.js').ProcessCaptureInterface} can intercept,
+* in `stdout`-then-`stderr` order — the {@link StreamLevel} universe and the default configured
+* set.
 */
 var STREAM_LEVELS = Object.freeze(["stdout", "stderr"]);
 /**
-* The default set of {@link StreamLevel}s a process capture patches when `options.levels` is omitted
-* — BOTH streams ({@link STREAM_LEVELS}). A consumer narrows it (e.g. just `['stderr']`) via
-* `options.levels`.
-*/
-var DEFAULT_CAPTURE_LEVELS = STREAM_LEVELS;
-/**
-* The default bounded-buffer cap for a {@link import('./types.js').ProcessCaptureInterface} — at
-* most this many recent {@link import('./types.js').CapturedChunk}s are retained per buffer (the
-* total buffer AND each per-stream bucket; oldest dropped first). Mirrors the core `Capture`'s
-* `DEFAULT_CAPTURE_LIMIT`; a consumer overrides it via `options.limit`.
+* Sets the default bounded-buffer cap for a {@link import('./types.js').ProcessCaptureInterface} —
+* `1000`, so at most that many recent {@link import('./types.js').CapturedChunk}s are retained per
+* buffer (the total buffer and each per-stream bucket; oldest dropped first) and retention is
+* always bounded.
+*
+* @remarks
+* It mirrors the core `Capture`'s `DEFAULT_CAPTURE_LIMIT`; a consumer overrides the cap through
+* `options.limit`.
 */
-var DEFAULT_CAPTURE_LIMIT = 1e3;
+var DEFAULT_STREAM_LIMIT = 1e3;
 /**
-* The terminal width {@link import('./factories.js').createServerSink} reports through
-* {@link import('./types.js').ServerSinkInterface.columns} when the out stream is NOT a TTY (so
-* `.columns` is `undefined`) and no explicit `options.columns` was supplied — the conventional
+* Sets the terminal width {@link import('./factories.js').createServerSink} reports through
+* {@link import('./types.js').ServerSinkInterface.columns} when the `stdout` stream is not a TTY
+* (so `.columns` is `undefined`) and no explicit `options.columns` was supplied — the conventional
 * 80-column default a non-interactive context (a pipe, a CI log) assumes.
 */
 var DEFAULT_COLUMNS = 80;
 /**
-* Each {@link StreamLevel}'s {@link LogLevel} for the optional sink forward — the projection a
-* process capture routes through when writing an intercepted chunk to a
-* {@link import('@src/core').SinkInterface}
-* (`sink.write(text, STREAM_LEVEL_MAP[level])`). `stderr` is conventionally the error/diagnostic
-* stream → `error`; `stdout` is the normal output stream → `info`. The source of truth for the
-* stream-to-log projection (the server analogue of the core `CAPTURE_LEVEL_MAP`).
+* Maps each {@link StreamLevel} to its {@link LogLevel} for the optional sink forward — the
+* projection a process capture routes through when writing an intercepted chunk to a
+* {@link import('@src/core').SinkInterface}. `sink.write(text, STREAM_LEVEL_MAP[level])` is the
+* call this map backs. `stderr` is conventionally the error/diagnostic stream → `error`; `stdout`
+* is the normal output stream → `info`. The source of truth for the stream-to-log projection (the
+* server analogue of the core `CAPTURE_LEVEL_MAP`).
 */
 var STREAM_LEVEL_MAP = Object.freeze({
 	stdout: "info",
 	stderr: "error"
 });
 //#endregion
-//#region src/server/helpers.ts
+//#region src/server/validators.ts
 /**
-* Whether `value` is a usable {@link StreamTargetInterface} — a record with a callable `write`. A
-* total type guard (AGENTS §14): it NEVER throws and returns `false` for anything off-shape, so it
+* Checks whether `value` is a usable {@link StreamTargetInterface} — a record with a callable `write`. A
+* total type guard: it never throws and returns `false` for anything off-shape, so it
 * narrows the one unavoidable boundary (the real `process.stdout` / `process.stderr`, or a fake
 * stream a test injects) to the exact slice the sink + capture touch — no `as`.
 *
 * @remarks
 * Only `write` is required (the irreducible output method); `isTTY` and `columns` are optional on
 * {@link StreamTargetInterface}, so their absence does not disqualify a target — a piped stream
-* (no `isTTY`) is still a valid write target, just a non-terminal one.
+* (no `isTTY`) is still a valid write target, only a non-terminal one.
 *
 * @param value - Any value crossing the boundary (a process stream, an injected fake, `unknown`)
-* @returns `true` when `value` has a callable `write`
+* @returns True if `value` has a callable `write`; false otherwise
 *
 * @example
 * ```ts
@@ -67,36 +66,50 @@ function isStreamTarget(value) {
 	return typeof value === "object" && value !== null && "write" in value && typeof value.write === "function";
 }
 /**
-* The width in character cells of a stream target — its live `columns` when it is a TTY, else the
-* non-interactive {@link DEFAULT_COLUMNS} fallback. The basis a {@link import('./types.js').ServerSinkInterface}
-* reports through `columns` so a `Reporter` / `Progress` can size its layout to the terminal.
+* Checks whether `encoding` is a {@link BufferEncoding} accepted by `Buffer.prototype.toString` — a
+* total guard used by {@link import('./helpers.js').decodeChunk} to honor a process-write
+* `encoding` argument only when it is a real Node encoding (otherwise utf-8 is assumed).
+*
+* @param encoding - The candidate encoding (the second `write` argument, possibly a callback)
+* @returns True if `encoding` names a supported buffer encoding; false otherwise
+*/
+function isBufferEncoding(encoding) {
+	return typeof encoding === "string" && Buffer.isEncoding(encoding);
+}
+//#endregion
+//#region src/server/helpers.ts
+/**
+* Infers the width in character cells of a stream target — its live `columns` when it is a TTY,
+* else the non-interactive {@link DEFAULT_COLUMNS} fallback. The basis a
+* {@link import('./types.js').ServerSinkInterface} reports through `columns` so a `Reporter` /
+* `Progress` can size its layout to the terminal.
 *
 * @remarks
-* Reads `target.columns` ON EACH CALL (so a getter-backed real stream reflects a live resize) and
+* Reads `target.columns` on each call (so a getter-backed real stream reflects a live resize) and
 * accepts it only when it is a positive finite number; a missing / `0` / non-finite `columns` (a
 * piped, non-TTY stream) falls back to {@link DEFAULT_COLUMNS}. Total — never throws.
 *
 * @param target - The stream whose width to probe
 * @returns The terminal column count, or {@link DEFAULT_COLUMNS} when not a TTY
 */
-function columnsOf(target) {
+function inferColumns(target) {
 	const columns = target.columns;
 	if (typeof columns === "number" && Number.isFinite(columns) && columns > 0) return columns;
 	return 80;
 }
 /**
-* Infer whether one stream target should receive styled output. The result is a construction-time
-* target fact for {@link import('./factories.js').createServerSink}; this helper is pure and never
-* reads process globals itself.
+* Infers whether one stream target receives styled output — a present `FORCE_COLOR` first, then a
+* non-empty `NO_COLOR`, then `target.isTTY === true`.
 *
 * @remarks
-* A present `FORCE_COLOR` key has first precedence: only the exact value `'0'` disables styling.
-* Next, a non-empty `NO_COLOR` disables styling. Otherwise styling follows
-* `target.isTTY === true`.
+* The result is a construction-time target fact for
+* {@link import('./factories.js').createServerSink}; this helper is pure and
+* never reads process globals itself. Under `FORCE_COLOR` only the exact value `'0'` disables
+* styling.
 *
 * @param target - The stream target whose terminal capability is the fallback
 * @param environment - The environment record supplying `FORCE_COLOR` and `NO_COLOR`
-* @returns Whether output for the target should retain styling and control sequences
+* @returns True if output for the target retains styling and control sequences; false otherwise
 *
 * @example
 * ```ts
@@ -111,8 +124,8 @@ function inferStyled(target, environment) {
 	return target.isTTY === true;
 }
 /**
-* Decode one `process.stdout.write` / `process.stderr.write` chunk to a string — TOTAL, never
-* throws (AGENTS §14). The process write signature accepts `string | Uint8Array` plus an optional
+* Decodes one `process.stdout.write` / `process.stderr.write` chunk to a string — total, never
+* throws. The process write signature accepts `string | Uint8Array` plus an optional
 * encoding; the capture wrapper reuses this so intercepting a raw stream write can never crash the
 * host (a throw inside `process.stdout.write` would take the program down).
 *
@@ -121,12 +134,12 @@ function inferStyled(target, environment) {
 *   and `process.stdout.write('text')` all pass a string).
 * - A `Buffer` chunk is decoded with the supplied `encoding` when it is a recognized
 *   {@link BufferEncoding} (`process` write supports `'utf8'` / `'hex'` / `'base64'` / …), defaulting
-*   to `'utf8'`; a bare `Uint8Array` is decoded via `TextDecoder` (always utf-8 — the `encoding`
-*   argument applies ONLY to a `Buffer`, never a plain `Uint8Array`).
+*   to `'utf8'`; a bare `Uint8Array` is decoded through `TextDecoder` (always utf-8 — the `encoding`
+*   argument applies only to a `Buffer`, never a plain `Uint8Array`).
 * - Anything else is coerced with `String(chunk)` (a number / object / bigint / symbol a misbehaving
 *   writer hands the stream). The coercion is itself guarded: a value whose `toString` /
 *   `Symbol.toPrimitive` throws yields the stable `'[unprintable]'` placeholder. So the helper is
-*   TOTAL on every input — it always yields SOME string, never an exception (a throw here would
+*   total on every input — it always yields some string, never an exception (a throw here would
 *   escape into `process.*.write` and crash the host).
 *
 * @param chunk - The chunk passed to the stream's `write`
@@ -150,42 +163,31 @@ function decodeChunk(chunk, encoding) {
 		return "[unprintable]";
 	}
 }
-/**
-* Whether `encoding` is a {@link BufferEncoding} accepted by `Buffer.prototype.toString` — a total
-* guard used by {@link decodeChunk} to honor a process-write `encoding` argument only when it is a
-* real Node encoding (otherwise utf-8 is assumed).
-*
-* @param encoding - The candidate encoding (the second `write` argument, possibly a callback)
-* @returns `true` when `encoding` names a supported buffer encoding
-*/
-function isBufferEncoding(encoding) {
-	return typeof encoding === "string" && Buffer.isEncoding(encoding);
-}
 //#endregion
 //#region src/server/ProcessCapture.ts
 /**
-* An observable interceptor of the RAW process output streams (AGENTS §13) — it takes control of
-* `process.stdout.write` / `process.stderr.write` on the WRITE side. While `active`, every write to
+* Implements an observable interceptor of the raw process output streams — it takes control of
+* `process.stdout.write` / `process.stderr.write` on the write side. While `active`, every write to
 * a configured {@link StreamLevel} is captured as a frozen {@link CapturedChunk}, buffered (total +
-* per-stream, bounded), emitted on `capture`, and — per options — mirrored to the real stream and/or
-* forwarded to a {@link SinkInterface}.
+* per-stream, bounded), emitted on `capture`, and — per options — mirrored to the real stream,
+* forwarded to a {@link SinkInterface}, or both.
 *
 * @remarks
 * Where the core `Capture` patches `console.*` (the high-level read side), this patches the
-* low-level stream `write`, so it owns ALL server output: a direct `process.stdout.write`, a
+* low-level stream `write`, so it owns all server output: a direct `process.stdout.write`, a
 * third-party library's writes, a child-process pipe — not only `console.*`.
 *
-* - **Snapshot-at-start (the no-capture-loop principle).** `start()` snapshots the CURRENT
+* - **Snapshot-at-start (the no-capture-loop principle).** `start()` snapshots the current
 *   `process[stream].write` for each configured level, then installs the wrappers. The mirror
 *   replays through that snapshot (bound to its stream) — so a server sink created from the same
-*   streams BEFORE the capture is never re-captured: this catches OTHER writers, not the mirror's
+*   streams before the capture is never re-captured: this catches other writers, not the mirror's
 *   own replay. Create your sinks before installing a capture.
-* - **Idempotent + PROCESS-GLOBAL + NON-REENTRANT.** `start()` while `active` is a no-op (never
+* - **Idempotent + process-global + non-reentrant.** `start()` while `active` is a no-op (never
 *   double-patches — that would snapshot the wrapper as the "original" and break restore); `stop()`
-*   while inactive is a no-op. It patches the ONE global `process`, so at most ONE process capture
+*   while inactive is a no-op. It patches the one global `process`, so at most one process capture
 *   may be active at a time — two concurrently would interleave buffers and clobber each other's
 *   restore.
-* - **The wrapper NEVER throws and passes backpressure through.** A throw inside
+* - **The wrapper never throws and passes backpressure through.** A throw inside
 *   `process.stdout.write` would crash the host, so the wrapper decodes each chunk totally (a byte
 *   chunk through the per-level streaming decoder below, everything else through the total
 *   {@link decodeChunk}), and returns the snapshot-original's `boolean` when mirroring (so a caller's
@@ -196,18 +198,18 @@ function isBufferEncoding(encoding) {
 *   child-process pipe, a library, or OS buffering all produce this — carries its partial bytes to
 *   the next write instead of decoding each half to `U+FFFD`. `stop()` flushes each decoder once, so
 *   a codepoint left half-written at stop is still surfaced. A `string` chunk is already text and
-*   passes through; an explicit NON-utf-8 buffer encoding (`latin1` / `hex` / `base64` / …) names a
+*   passes through; an explicit non-utf-8 buffer encoding (`latin1` / `hex` / `base64` / …) names a
 *   self-contained per-write decode and is honored one-shot through {@link decodeChunk}.
 * - **Bounded buffers.** The total buffer and each per-stream bucket are each capped at `limit`
 *   (oldest dropped first), never unbounded — the same retention precedent as the core `Capture`.
-* - **Lifecycle (§10).** `start` / `stop` toggle interception (emitting `start` / `stop`);
-*   `destroy()` stops (restoring the PRISTINE `write`) then destroys the emitter.
+* - **Lifecycle.** `start` / `stop` toggle interception (emitting `start` / `stop`);
+*   `destroy()` stops (restoring the pristine `write`) then destroys the emitter.
 *
 * @example
 * ```ts
 * const capture = new ProcessCapture({ levels: ['stderr'], mirror: true })
 * capture.start()
-* process.stderr.write('a library diagnostic\n') // captured AND still written to the terminal
+* process.stderr.write('a library diagnostic\n') // captured and still written to the terminal
 * capture.messages('stderr') // [{ level: 'stderr', text: 'a library diagnostic\n', time: … }]
 * capture.stop() // process.stderr.write restored
 * ```
@@ -217,9 +219,7 @@ var ProcessCapture = class {
 	#levels;
 	#mirror;
 	#sink;
-	#limit;
-	#messages = [];
-	#buckets = /* @__PURE__ */ new Map();
+	#retention;
 	#originals = /* @__PURE__ */ new Map();
 	#decoders = /* @__PURE__ */ new Map();
 	#active = false;
@@ -228,11 +228,10 @@ var ProcessCapture = class {
 			...options?.on !== void 0 ? { on: options.on } : {},
 			...options?.error !== void 0 ? { error: options.error } : {}
 		});
-		this.#levels = options?.levels ?? DEFAULT_CAPTURE_LEVELS;
+		this.#levels = options?.levels ?? STREAM_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, []);
+		this.#retention = new _src_core.Retention(this.#levels, options?.limit ?? 1e3);
 	}
 	get emitter() {
 		return this.#emitter;
@@ -262,12 +261,11 @@ var ProcessCapture = class {
 		this.#emitter.emit("stop");
 	}
 	messages(level) {
-		if (level === void 0) return [...this.#messages];
-		return [...this.#buckets.get(level) ?? []];
+		if (level === void 0) return this.#retention.records();
+		return this.#retention.records(level);
 	}
 	clear() {
-		this.#messages.length = 0;
-		for (const bucket of this.#buckets.values()) bucket.length = 0;
+		this.#retention.clear();
 	}
 	destroy() {
 		this.stop();
@@ -306,7 +304,7 @@ var ProcessCapture = class {
 			text,
 			time: Date.now()
 		});
-		this.#retain(message);
+		this.#retention.add(message);
 		this.#emitter.emit("capture", message);
 		if (this.#sink !== void 0) try {
 			this.#sink.write(message.text, STREAM_LEVEL_MAP[level]);
@@ -319,24 +317,14 @@ var ProcessCapture = class {
 		}
 		this.#decoders.clear();
 	}
-	#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/server/factories.ts
 /**
-* Create the server TTY {@link ServerSinkInterface} — the C-g server output backend, the
-* env-symmetric sibling of `createBrowserSink` / core's `createConsoleSink`. `write(text, level?)`
-* routes by level to the process streams and uses construction-time styled facts: it sends ANSI
-* straight to a styled target (with a leading `\r` overwriting a terminal line natively) but
-* {@link import('@src/core').strip}s ANSI to clean text for a plain target.
+* Creates the server TTY {@link ServerSinkInterface} — the server output backend, whose
+* `write(text, level?)` routes by level to the process streams and uses construction-time styled
+* facts: it sends ANSI straight to a styled target (with a leading `\r` overwriting a terminal
+* line natively) but {@link import('@src/core').strip}s ANSI to clean text for a plain target.
 *
 * @param options - See {@link ServerSinkOptions}
 * @returns A {@link ServerSinkInterface} — a {@link import('@src/core').SinkInterface} that also
@@ -344,37 +332,52 @@ var ProcessCapture = class {
 *
 * @remarks
 * - **Routes by level.** `error` / `warn` → the error stream (`process.stderr` by default), every
-*   other level (and an omitted level) → the out stream (`process.stdout`) — the SAME routing as
-*   core's `createConsoleSink`, so a logger's `error` reaches `stderr`.
+*   other level (and an omitted level) → the `stdout` stream (`process.stdout`) — the same routing
+*   as core's `createConsoleSink`, so a logger's `error` reaches `stderr`. Both call the one
+*   {@link import('@src/core').selectWriter} leaf, which is what keeps them identical.
 * - **Per-target styled facts.** At construction, each target uses `options.styled` when supplied;
 *   otherwise {@link inferStyled} applies the injected `environment` (default `process.env`) and
 *   then that target's `isTTY`.
-*   Writes use those stored facts, so `styled` and the out target's strip decision never disagree;
-*   the err target keeps its own fact internally.
-* - **Width.** `columns` reflects the live `out.columns` (so it tracks a terminal resize), falling
-*   back to {@link import('./constants.js').DEFAULT_COLUMNS} when the out stream is not a TTY — or a
-*   fixed value when `options.columns` is supplied. Feed it to a `Reporter` / `Progress` `width`.
-* - **Injectable + guard-narrowed.** `options.out` / `options.err` default to `process.stdout` /
-*   `process.stderr` but accept ANY {@link import('./types.js').StreamTargetInterface}, resolved
-*   through {@link isStreamTarget} (AGENTS §14 — narrow the boundary, never `as`), so a test drives
+*   Writes use those stored facts, so `styled` and the `stdout` target's strip decision never
+*   disagree; the `stderr` target keeps its own fact internally.
+* - **Width.** `columns` reflects the live `stdout.columns` (so it tracks a terminal resize),
+*   falling back to {@link import('./constants.js').DEFAULT_COLUMNS} when the `stdout` stream is not
+*   a TTY — or a fixed value when `options.columns` is supplied. Feed it to a `Reporter` /
+*   `Progress` `width`.
+* - **Injectable + guard-narrowed.** `options.stdout` / `options.stderr` default to `process.stdout`
+*   / `process.stderr` but accept any {@link import('./types.js').StreamTargetInterface}, resolved
+*   through {@link isStreamTarget} (narrow the boundary, never `as`), so a test drives
 *   the sink (and the isTTY-strip path) with a fake stream that never touches the real process
 *   streams.
 *
-* @example
+* @example The server — a TTY sink and a process capture
 * ```ts
-* import { createLogger, createReporter, createStyler } from '@src/core'
-* import { createServerSink } from '@src/server'
+* import { createStyler, Logger, Reporter } from '@orkestrel/console'
+* import { createServerSink, ProcessCapture } from '@orkestrel/console/server'
+*
+* const sink = createServerSink() // FORCE_COLOR, then NO_COLOR, then isTTY — per target, at construction
+* const styler = createStyler({ enabled: sink.styled }) // keep generated ANSI paired with the sink's stdout stripping
+* const logger = new Logger({ name: 'server', sink, styler })
+* logger.error('boom') // → process.stderr (the error stream)
+* const reporter = new Reporter({ sink, width: sink.columns }) // size the layout to the live terminal
 *
-* const sink = createServerSink()
-* const styler = createStyler({ enabled: sink.styled })
-* const logger = createLogger({ name: 'app', sink, styler })
-* logger.error('boom') // → process.stderr, ANSI rendered on a TTY / stripped to a pipe
-* const reporter = createReporter({ sink, width: sink.columns })
+* // `styled` overrides the inference outright — for a CI log that renders ANSI off a TTY, say.
+* const forced = createServerSink({ styled: true })
+* forced.styled // true, whatever the environment and the streams say
+*
+* // Own every output path — a direct process.stdout.write, library output, child-process pipes:
+* const capture = new ProcessCapture({ levels: ['stderr'], mirror: true })
+* capture.start()
+* process.stderr.write('a library diagnostic\n') // captured and still shown (mirror: true)
+* capture.messages('stderr') // [{ level: 'stderr', text: 'a library diagnostic\n', time: … }]
+* capture.clear() // drop buffered chunks; interception is unaffected
+* capture.stop()
+* capture.destroy() // stop() then tear down the emitter
 * ```
 */
 function createServerSink(options) {
-	const out = isStreamTarget(options?.out) ? options.out : process.stdout;
-	const err = isStreamTarget(options?.err) ? options.err : process.stderr;
+	const out = isStreamTarget(options?.stdout) ? options.stdout : process.stdout;
+	const err = isStreamTarget(options?.stderr) ? options.stderr : process.stderr;
 	const styled = options?.styled;
 	const environment = options?.environment ?? process.env;
 	const outStyled = styled ?? inferStyled(out, environment);
@@ -383,59 +386,33 @@ function createServerSink(options) {
 	return Object.freeze({
 		styled: outStyled,
 		write(text, level) {
-			const error = level === "error" || level === "warn";
-			const target = error ? err : out;
-			const keep = error ? errStyled : outStyled;
+			const target = (0, _src_core.selectWriter)(level, {
+				log: out,
+				warn: err,
+				error: err
+			});
+			const keep = (0, _src_core.selectWriter)(level, {
+				log: outStyled,
+				warn: errStyled,
+				error: errStyled
+			});
 			const line = text.startsWith("\r") ? text : `${text}\n`;
 			target.write(keep ? line : (0, _src_core.stripControls)((0, _src_core.strip)(line)));
 		},
 		get columns() {
-			return typeof fixed === "number" ? fixed : columnsOf(out);
+			return typeof fixed === "number" ? fixed : inferColumns(out);
 		}
 	});
 }
-/**
-* Create an observable {@link ProcessCaptureInterface} — the server "own ALL output" capture. It
-* intercepts the RAW `process.stdout.write` / `process.stderr.write` (not just `console.*`, which is
-* the core `Capture`), so it catches direct `process` writes, library output, and child-process
-* pipes. Each intercepted write becomes a frozen {@link import('./types.js').CapturedChunk},
-* buffered (bounded, per-stream) and emitted on `capture`; per options it is mirrored back to the
-* real stream and/or forwarded to a {@link import('@src/core').SinkInterface}.
-*
-* @param options - See {@link ProcessCaptureOptions}
-* @returns A {@link ProcessCaptureInterface}
-*
-* @remarks
-* - **The wrapper never throws and passes backpressure through** — a throw in `process.stdout.write`
-*   would crash the host, so chunks are decoded totally and the original's `boolean` is returned.
-* - **Snapshot-at-start + non-reentrant + process-global** — `start()` snapshots and swaps the
-*   pristine `write`; `stop()` restores the EXACT original. At most ONE may be active at a time.
-*   Create any server sink BEFORE installing a capture so the mirror's replay is not re-captured.
-*
-* @example
-* ```ts
-* import { createProcessCapture } from '@src/server'
-*
-* const capture = createProcessCapture({ levels: ['stderr'], mirror: true })
-* capture.start()
-* process.stderr.write('a library diagnostic\n') // captured AND still shown
-* capture.stop()
-* ```
-*/
-function createProcessCapture(options) {
-	return new ProcessCapture(options);
-}
 //#endregion
-exports.DEFAULT_CAPTURE_LEVELS = DEFAULT_CAPTURE_LEVELS;
-exports.DEFAULT_CAPTURE_LIMIT = DEFAULT_CAPTURE_LIMIT;
 exports.DEFAULT_COLUMNS = DEFAULT_COLUMNS;
+exports.DEFAULT_STREAM_LIMIT = DEFAULT_STREAM_LIMIT;
 exports.ProcessCapture = ProcessCapture;
 exports.STREAM_LEVELS = STREAM_LEVELS;
 exports.STREAM_LEVEL_MAP = STREAM_LEVEL_MAP;
-exports.columnsOf = columnsOf;
-exports.createProcessCapture = createProcessCapture;
 exports.createServerSink = createServerSink;
 exports.decodeChunk = decodeChunk;
+exports.inferColumns = inferColumns;
 exports.inferStyled = inferStyled;
 exports.isBufferEncoding = isBufferEncoding;
 exports.isStreamTarget = isStreamTarget;