@orkestrel/console 0.0.1

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Orkestrel
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,92 @@
+# @orkestrel/console
+
+A unified output-control system for the `@orkestrel` line — one
+environment-agnostic engine composing five concerns over a shared substrate:
+a **style engine** (`Styler` + `ANSIRenderer`, style as data), **structured
+logging** (`Logger`, `LoggerManager`), **narrative reporting** (`Reporter`),
+**console & stream capture** (`Capture`, `ProcessCapture`), and **live
+animations** (`Spinner`, `Progress`). Built to sit beside `@orkestrel/emitter`
+(observable lifecycle), reusing it as it takes shape.
+
+## Install
+
+```sh
+npm install @orkestrel/console
+```
+
+## Requirements
+
+- Node.js >= 24
+- Core is ESM; the `./server` subpath ships dual ESM+CJS builds; `./browser`
+  is ESM-only
+
+## Usage
+
+The same code retargets to any environment by swapping the `sink`:
+
+```ts
+import { createLogger, createReporter, createSpinner } from '@src/core'
+
+const logger = createLogger({ name: 'http', level: 'info' }) // ANSI to the console by default
+logger.info('request', { method: 'GET', path: '/' }) // a styled, leveled line + an `entry` event
+logger.emitter.on('entry', (record) => archive(record)) // the transport seam — file / JSON / remote
+
+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
+
+const spinner = createSpinner({ message: 'deploying' })
+spinner.start() // a self-driving glyph cycle, `\r`-redrawn by an overwrite-capable sink
+spinner.success('deployed') // ✔ deployed — the timer cleared, the line committed
+```
+
+Style is data — a `Style` is a frozen record rendered through a swappable
+`RendererInterface` (`ANSIRenderer` by default):
+
+```ts
+import { createStyler } from '@src/core'
+
+const styler = createStyler()
+console.log(styler.red.bold('hi')) // renders through the injected renderer
+```
+
+Take control of `console.*` on the read side with `Capture`:
+
+```ts
+import { createCapture } from '@src/core'
+
+const capture = createCapture({ mirror: true })
+capture.start()
+console.log('hello')
+capture.messages() // [{ level: 'log', text: 'hello', time: ... }]
+capture.stop()
+```
+
+On the server, `ProcessCapture` takes over the whole `process` output surface
+(direct `process.stdout`/`stderr` writes, not just `console.*`):
+
+```ts
+import { createProcessCapture } from '@src/server'
+
+const capture = createProcessCapture({ levels: ['stderr'], mirror: true })
+capture.start()
+```
+
+## Guide
+
+See [guides/src/console.md](./guides/src/console.md) for the full documented
+surface — styling, logging, reporting, capture, and animations.
+
+## Package
+
+Published as three environment-scoped entry points per the `exports` field
+in `package.json`: `.` (the shared, environment-agnostic core engine, the
+default ANSI renderer, and the console sink), `./server` (adds the server
+sink and `ProcessCapture`), and `./browser` (adds the browser sink
+translating ANSI to `console.log('%c…', css)`). Core and `./server` ship
+dual ESM+CJS builds; `./browser` is ESM-only.
+
+## License
+
+MIT © [Orkestrel](https://github.com/orkestrel) — see [LICENSE](./LICENSE).

package/dist/src/browser/index.d.ts

@@ -0,0 +1,214 @@
+import { Color } from '../core/index.js';
+import { SinkInterface } from '../core/index.js';
+
+/**
+ * Translate an ANSI-styled string into a browser `console.log`-ready {@link ConsoleOutput} — a
+ * `%c`-segmented format string and the parallel array of CSS declarations, so a DevTools console
+ * renders the SAME styling a terminal would (the C-f sink calls `console[method](format, ...styles)`).
+ *
+ * @remarks
+ * - **SGR runs → `%c` segments.** The text is scanned for SGR sequences ({@link SGR_PATTERN} —
+ *   `ESC[…m`); each delimits a run. A run carrying VISIBLE text emits one `%c` directive plus that
+ *   text into `format` and the run's accumulated CSS into `styles`, so the browser switches style at
+ *   each `%c`. Foreground / background / attribute codes accumulate; the reset code (`0`, or a bare
+ *   `ESC[m`) clears the accumulated style back to none. A later color of the same channel REPLACES
+ *   the earlier one; an attribute is added once. Non-SGR escapes (cursor / erase / OSC) are not style
+ *   and are left in the text verbatim.
+ * - **`%`-safe.** Every LITERAL `%` in the text is doubled to `%%` so the console never treats it as
+ *   a directive — only the `%c`s this function inserts are real directives. So `format`'s real `%c`
+ *   count always equals `styles.length`, and `console.log(format, ...styles)` lines up exactly.
+ * - **Plain text short-circuits.** A string with NO SGR sequence yields `{ format: <escaped text>,
+ *   styles: [] }` — no `%c`, no styles (the text is still `%`-escaped).
+ * - **Pure + total.** Same input → same output; it never throws on any string (adversarial escapes,
+ *   lone `ESC`, unterminated sequences all fall through as literal text).
+ *
+ * @param text - Any string, ANSI-styled or plain
+ * @returns The `%c` format string + parallel CSS array ({@link ConsoleOutput})
+ *
+ * @example
+ * ```ts
+ * ansiToConsole('\x1b[31mred\x1b[0m') // { format: '%cred', styles: ['color:#cd0000'] }
+ * ansiToConsole('plain') // { format: 'plain', styles: [] }
+ * ansiToConsole('50%') // { format: '50%%', styles: [] }
+ * ```
+ */
+export declare function ansiToConsole(text: string): ConsoleOutput;
+
+/**
+ * Each text-{@link Attribute}'s SGR "on" number → its equivalent CSS declaration — the browser
+ * counterpart to the terminal's SGR text effects (`bold` 1 → `font-weight:bold`, `dim` 2 →
+ * `opacity:0.6`, `italic` 3 → `font-style:italic`, `underline` 4 → `text-decoration:underline`,
+ * `inverse` 7 → best-effort, `strikethrough` 9 → `text-decoration:line-through`). Keyed by the SGR
+ * NUMBER (derived from core's {@link ATTRIBUTE_CODES}) so the sink looks a parameter up directly
+ * while scanning a run.
+ *
+ * @remarks
+ * `inverse` (SGR 7) has no faithful single-declaration CSS equivalent (it swaps the fore/back inks,
+ * which depends on the live colors); it maps to a best-effort `filter:invert(100%)` — documented as
+ * approximate, never silently dropped. Deeply frozen.
+ */
+export declare const ATTRIBUTE_CSS: Readonly<Record<number, string>>;
+
+/**
+ * Each SGR BACKGROUND parameter (40–47 / 100–107) → its `background:<hex>` CSS, derived by walking
+ * core's {@link COLORS} against {@link BACKGROUND_CODES} and {@link COLOR_HEX}. The sink reads this
+ * while scanning a run to translate a background code to CSS.
+ */
+export declare const BACKGROUND_CSS: Readonly<Record<number, string>>;
+
+/**
+ * Each named {@link Color}'s hex value — the 16 standard terminal colors a browser DevTools
+ * console renders the SAME {@link Color} names as. The source of truth for the BROWSER color
+ * axis: the ANSI renderer maps a `Color` name to an SGR number, and this maps the same name to
+ * the CSS color the `%c` sink paints with, so a browser shows the same 16 colors a terminal does.
+ *
+ * @remarks
+ * The conventional VGA/xterm 16-color palette (the base 8 plus their bright variants); `default`
+ * is intentionally absent (it leaves the console's own ink and emits no CSS). Deeply frozen.
+ */
+export declare const COLOR_HEX: Readonly<Record<Exclude<Color, 'default'>, string>>;
+
+/**
+ * The `console.log`-ready output {@link import('./helpers.js').ansiToConsole} produces from
+ * an ANSI-styled string — a format string of `%c`-prefixed segments and the parallel array
+ * of CSS declarations, ready to spread into a browser `console` call as
+ * `console.log(format, ...styles)`.
+ *
+ * @remarks
+ * - `format` — the text with each styled run prefixed by one `%c` directive (the directive
+ *   the browser console consumes to switch the active style) and every LITERAL `%` doubled to
+ *   `%%` so it is not mistaken for a directive. A plain (no-ANSI) input yields the text
+ *   verbatim with NO `%c` and an empty `styles` (still `%`-escaped).
+ * - `styles` — one CSS declaration string per `%c` in `format`, in order: the browser applies
+ *   `styles[n]` from the n-th `%c` onward. Each entry is the accumulated style for that run
+ *   (an SGR reset clears it back to `''`). `format`'s `%c` count always equals `styles.length`,
+ *   so the spread `console.log(format, ...styles)` lines up exactly.
+ */
+export declare interface ConsoleOutput {
+    readonly format: string;
+    readonly styles: readonly string[];
+}
+
+/**
+ * Create the browser `%c` {@link SinkInterface} — the C-f browser output backend. `write(text, level?)`
+ * translates the ANSI-styled `text` into a browser `console` call (`console[method](format, ...styles)`)
+ * via {@link ansiToConsole}, so a DevTools console renders the SAME styling a terminal does. Drop it in
+ * as a logger / reporter / spinner sink (`createLogger({ sink: createBrowserSink() })`) to retarget the
+ * core output to the browser console with no change to the core.
+ *
+ * @returns A browser `%c` {@link SinkInterface}
+ *
+ * @remarks
+ * - **ANSI → `%c` at the sink.** The core produces ANSI strings; this sink parses the SGR runs and
+ *   re-emits them as a `console.log`-ready `%c` format string + parallel CSS array ({@link ansiToConsole}
+ *   — pure, total, and `%`-safe), so the styling survives the trip to a console that can't render ANSI.
+ * - **Routes by level.** `error` → `console.error`, `warn` → `console.warn`, every other level (and an
+ *   omitted level) → `console.log` — the SAME routing as core's `createConsoleSink`, so a logger's level
+ *   reaches the matching DevTools stream.
+ * - **Animation degrade (locked).** A browser console cannot overwrite a line, so a `text` beginning with
+ *   a carriage return `\r` (a spinner / progress redraw) has the leading `\r` STRIPPED and is written as a
+ *   fresh, non-overwriting line — the locked browser degrade. Only a LEADING `\r` is stripped; an interior
+ *   one is left to the console.
+ * - **Snapshotted — no capture loop.** It captures `console.log` / `console.warn` / `console.error` AT
+ *   CREATION and writes through those references, so a later `Capture` that PATCHES `console.*` can never
+ *   feed this sink's output back into itself (the no-capture-loop principle, AGENTS / the core sink's
+ *   precedent). Create the sink (or the logger) BEFORE installing a capture.
+ *
+ * @example
+ * ```ts
+ * import { createLogger } from '../core/index.js'
+ * import { createBrowserSink } from '@src/browser'
+ *
+ * const logger = createLogger({ name: 'app', sink: createBrowserSink() })
+ * logger.error('boom') // → console.error('%c…', 'color:#cd0000;…') in DevTools
+ * ```
+ */
+export declare function createBrowserSink(): SinkInterface;
+
+/**
+ * The browser console directive that switches the active style — one `%c` prefixes every styled run
+ * in the {@link import('./types.js').ConsoleOutput} format string, consuming the next entry of the
+ * parallel CSS array. The single source of truth for the directive token.
+ */
+export declare const DIRECTIVE = "%c";
+
+/**
+ * Double every literal `%` in `text` to `%%` — the `%`-escape that keeps a browser console from
+ * reading a stray `%` (e.g. in `50%` or `%s`) as a format directive. The single escape the
+ * {@link ansiToConsole} translation applies to every text segment before assembling the format
+ * string (so only the `%c`s it inserts are real directives).
+ *
+ * @param text - A literal text segment (no inserted directives)
+ * @returns `text` with each `%` doubled
+ *
+ * @example
+ * ```ts
+ * escapePercent('100% done') // '100%% done'
+ * ```
+ */
+export declare function escapePercent(text: string): string;
+
+/**
+ * Each SGR FOREGROUND parameter (30–37 / 90–97) → its `color:<hex>` CSS, derived by walking core's
+ * {@link COLORS} against {@link FOREGROUND_CODES} and {@link COLOR_HEX} (so the number↔name mapping
+ * stays in core, never duplicated here). The sink reads this while scanning a run to translate a
+ * foreground code to CSS. A pure build-once expression producing a frozen record (the
+ * `DEFAULT_CAPTURE_LEVELS = CAPTURE_LEVELS` precedent — derived data, not new data).
+ */
+export declare const FOREGROUND_CSS: Readonly<Record<number, string>>;
+
+/**
+ * Parse an SGR parameter list (the `;`-separated numeric string captured by {@link SGR_PATTERN})
+ * into its numeric codes — `'1;31'` → `[1, 31]`. An EMPTY list (a bare `ESC[m`) yields `[0]`, since
+ * the SGR spec treats a parameterless sequence as a reset; an empty field within a list (`'1;;4'`)
+ * likewise counts as a `0` reset, matching the spec.
+ *
+ * @param parameters - The raw `;`-separated parameter string (the regex capture)
+ * @returns The parsed SGR codes (a parameterless / empty field becoming `0`)
+ *
+ * @example
+ * ```ts
+ * parseParameters('1;31') // [1, 31]
+ * parseParameters('') // [0]
+ * ```
+ */
+export declare function parseParameters(parameters: string): readonly number[];
+
+/**
+ * Matches one SGR sequence (`ESC[ <params> m`) and CAPTURES its `;`-separated numeric parameters —
+ * the subset of ANSI {@link import('../core/index.js').strip} cares about that carries STYLE (color /
+ * attribute / reset), as opposed to cursor / erase / OSC sequences. Global, so the scanner walks
+ * every SGR run in a string; built from core's {@link ESC} so no control-character literal appears
+ * in source (the codebase idiom). The capture group is the parameter list (`''` for a bare `ESC[m`,
+ * which the spec treats as a reset).
+ *
+ * @remarks
+ * A global `RegExp` carries a mutable `lastIndex`; a scan builds a FRESH `RegExp` from this one's
+ * `source` + `flags` rather than reuse this instance, so concurrent scans never collide. This is the
+ * canonical definition, not a shared scanner.
+ */
+export declare const SGR_PATTERN: RegExp;
+
+/**
+ * The mutable accumulator {@link import('./helpers.js').ansiToConsole} carries across a run while
+ * translating SGR codes to CSS — a single `foreground` and `background` declaration (each channel
+ * REPLACEABLE by a later color of the same channel) plus an ordered, de-duplicated list of attribute
+ * declarations. An SGR reset empties all three; {@link import('./helpers.js').ansiToConsole} folds
+ * it into the `;`-joined CSS string a run emits.
+ *
+ * @remarks
+ * Mutable BY DESIGN — it is internal scan state the scanner updates in place per SGR sequence (the
+ * one place this surface departs from the `readonly` default, AGENTS §11), never a returned value. A
+ * channel holds the FULL CSS declaration (`'color:#cd0000'`, not a bare hex), or `''` when unset.
+ * - `foreground` — the current `color:<hex>` declaration, or `''` (unset / post-reset).
+ * - `background` — the current `background:<hex>` declaration, or `''`.
+ * - `attributes` — the active text-effect declarations in insertion order (`'font-weight:bold'`, …),
+ *   each present at most once.
+ */
+export declare interface StyleAccumulator {
+    foreground: string;
+    background: string;
+    attributes: string[];
+}
+
+export { }

package/dist/src/browser/index.js

@@ -0,0 +1,275 @@
+import { ATTRIBUTE_CODES, BACKGROUND_CODES, COLORS, ESC, FOREGROUND_CODES, RESET_CODE } from "../core/index.js";
+//#region src/browser/constants.ts
+/**
+* Each named {@link Color}'s hex value — the 16 standard terminal colors a browser DevTools
+* console renders the SAME {@link Color} names as. The source of truth for the BROWSER color
+* axis: the ANSI renderer maps a `Color` name to an SGR number, and this maps the same name to
+* the CSS color the `%c` sink paints with, so a browser shows the same 16 colors a terminal does.
+*
+* @remarks
+* The conventional VGA/xterm 16-color palette (the base 8 plus their bright variants); `default`
+* is intentionally absent (it leaves the console's own ink and emits no CSS). Deeply frozen.
+*/
+var COLOR_HEX = Object.freeze({
+	black: "#000000",
+	red: "#cd0000",
+	green: "#00cd00",
+	yellow: "#cdcd00",
+	blue: "#0000ee",
+	magenta: "#cd00cd",
+	cyan: "#00cdcd",
+	white: "#e5e5e5",
+	brightBlack: "#7f7f7f",
+	brightRed: "#ff0000",
+	brightGreen: "#00ff00",
+	brightYellow: "#ffff00",
+	brightBlue: "#5c5cff",
+	brightMagenta: "#ff00ff",
+	brightCyan: "#00ffff",
+	brightWhite: "#ffffff"
+});
+/**
+* Each text-{@link Attribute}'s SGR "on" number → its equivalent CSS declaration — the browser
+* counterpart to the terminal's SGR text effects (`bold` 1 → `font-weight:bold`, `dim` 2 →
+* `opacity:0.6`, `italic` 3 → `font-style:italic`, `underline` 4 → `text-decoration:underline`,
+* `inverse` 7 → best-effort, `strikethrough` 9 → `text-decoration:line-through`). Keyed by the SGR
+* NUMBER (derived from core's {@link ATTRIBUTE_CODES}) so the sink looks a parameter up directly
+* while scanning a run.
+*
+* @remarks
+* `inverse` (SGR 7) has no faithful single-declaration CSS equivalent (it swaps the fore/back inks,
+* which depends on the live colors); it maps to a best-effort `filter:invert(100%)` — documented as
+* approximate, never silently dropped. Deeply frozen.
+*/
+var ATTRIBUTE_CSS = Object.freeze({
+	[ATTRIBUTE_CODES.bold]: "font-weight:bold",
+	[ATTRIBUTE_CODES.dim]: "opacity:0.6",
+	[ATTRIBUTE_CODES.italic]: "font-style:italic",
+	[ATTRIBUTE_CODES.underline]: "text-decoration:underline",
+	[ATTRIBUTE_CODES.inverse]: "filter:invert(100%)",
+	[ATTRIBUTE_CODES.strikethrough]: "text-decoration:line-through"
+});
+/**
+* Each SGR FOREGROUND parameter (30–37 / 90–97) → its `color:<hex>` CSS, derived by walking core's
+* {@link COLORS} against {@link FOREGROUND_CODES} and {@link COLOR_HEX} (so the number↔name mapping
+* stays in core, never duplicated here). The sink reads this while scanning a run to translate a
+* foreground code to CSS. A pure build-once expression producing a frozen record (the
+* `DEFAULT_CAPTURE_LEVELS = CAPTURE_LEVELS` precedent — derived data, not new data).
+*/
+var FOREGROUND_CSS = Object.freeze(Object.fromEntries(COLORS.map((color) => [FOREGROUND_CODES[color], `color:${COLOR_HEX[color]}`])));
+/**
+* Each SGR BACKGROUND parameter (40–47 / 100–107) → its `background:<hex>` CSS, derived by walking
+* core's {@link COLORS} against {@link BACKGROUND_CODES} and {@link COLOR_HEX}. The sink reads this
+* while scanning a run to translate a background code to CSS.
+*/
+var BACKGROUND_CSS = Object.freeze(Object.fromEntries(COLORS.map((color) => [BACKGROUND_CODES[color], `background:${COLOR_HEX[color]}`])));
+/**
+* The browser console directive that switches the active style — one `%c` prefixes every styled run
+* in the {@link import('./types.js').ConsoleOutput} format string, consuming the next entry of the
+* parallel CSS array. The single source of truth for the directive token.
+*/
+var DIRECTIVE = "%c";
+/**
+* Matches one SGR sequence (`ESC[ <params> m`) and CAPTURES its `;`-separated numeric parameters —
+* the subset of ANSI {@link import('@src/core').strip} cares about that carries STYLE (color /
+* attribute / reset), as opposed to cursor / erase / OSC sequences. Global, so the scanner walks
+* every SGR run in a string; built from core's {@link ESC} so no control-character literal appears
+* in source (the codebase idiom). The capture group is the parameter list (`''` for a bare `ESC[m`,
+* which the spec treats as a reset).
+*
+* @remarks
+* A global `RegExp` carries a mutable `lastIndex`; a scan builds a FRESH `RegExp` from this one's
+* `source` + `flags` rather than reuse this instance, so concurrent scans never collide. This is the
+* canonical definition, not a shared scanner.
+*/
+var SGR_PATTERN = new RegExp(`${ESC}\\[([0-9;]*)m`, "g");
+//#endregion
+//#region src/browser/helpers.ts
+/**
+* Translate an ANSI-styled string into a browser `console.log`-ready {@link ConsoleOutput} — a
+* `%c`-segmented format string and the parallel array of CSS declarations, so a DevTools console
+* renders the SAME styling a terminal would (the C-f sink calls `console[method](format, ...styles)`).
+*
+* @remarks
+* - **SGR runs → `%c` segments.** The text is scanned for SGR sequences ({@link SGR_PATTERN} —
+*   `ESC[…m`); each delimits a run. A run carrying VISIBLE text emits one `%c` directive plus that
+*   text into `format` and the run's accumulated CSS into `styles`, so the browser switches style at
+*   each `%c`. Foreground / background / attribute codes accumulate; the reset code (`0`, or a bare
+*   `ESC[m`) clears the accumulated style back to none. A later color of the same channel REPLACES
+*   the earlier one; an attribute is added once. Non-SGR escapes (cursor / erase / OSC) are not style
+*   and are left in the text verbatim.
+* - **`%`-safe.** Every LITERAL `%` in the text is doubled to `%%` so the console never treats it as
+*   a directive — only the `%c`s this function inserts are real directives. So `format`'s real `%c`
+*   count always equals `styles.length`, and `console.log(format, ...styles)` lines up exactly.
+* - **Plain text short-circuits.** A string with NO SGR sequence yields `{ format: <escaped text>,
+*   styles: [] }` — no `%c`, no styles (the text is still `%`-escaped).
+* - **Pure + total.** Same input → same output; it never throws on any string (adversarial escapes,
+*   lone `ESC`, unterminated sequences all fall through as literal text).
+*
+* @param text - Any string, ANSI-styled or plain
+* @returns The `%c` format string + parallel CSS array ({@link ConsoleOutput})
+*
+* @example
+* ```ts
+* ansiToConsole('\x1b[31mred\x1b[0m') // { format: '%cred', styles: ['color:#cd0000'] }
+* ansiToConsole('plain') // { format: 'plain', styles: [] }
+* ansiToConsole('50%') // { format: '50%%', styles: [] }
+* ```
+*/
+function ansiToConsole(text) {
+	const scanner = new RegExp(SGR_PATTERN.source, SGR_PATTERN.flags);
+	const active = {
+		foreground: "",
+		background: "",
+		attributes: []
+	};
+	const segments = [];
+	const styles = [];
+	let styled = false;
+	let cursor = 0;
+	let pending = "";
+	const apply = (codes) => {
+		for (const code of codes) {
+			if (code === RESET_CODE) {
+				active.foreground = "";
+				active.background = "";
+				active.attributes.length = 0;
+				continue;
+			}
+			const foreground = FOREGROUND_CSS[code];
+			if (foreground !== void 0) {
+				active.foreground = foreground;
+				continue;
+			}
+			const background = BACKGROUND_CSS[code];
+			if (background !== void 0) {
+				active.background = background;
+				continue;
+			}
+			const attribute = ATTRIBUTE_CSS[code];
+			if (attribute !== void 0 && !active.attributes.includes(attribute)) active.attributes.push(attribute);
+		}
+	};
+	const serialize = () => {
+		const declarations = [...active.attributes];
+		if (active.foreground !== "") declarations.push(active.foreground);
+		if (active.background !== "") declarations.push(active.background);
+		return declarations.join(";");
+	};
+	const flush = () => {
+		if (pending === "") return;
+		segments.push(`%c${pending}`);
+		styles.push(serialize());
+		pending = "";
+	};
+	for (let match = scanner.exec(text); match !== null; match = scanner.exec(text)) {
+		styled = true;
+		pending += escapePercent(text.slice(cursor, match.index));
+		flush();
+		apply(parseParameters(match[1] ?? ""));
+		cursor = match.index + match[0].length;
+	}
+	if (!styled) return {
+		format: escapePercent(text),
+		styles: []
+	};
+	pending += escapePercent(text.slice(cursor));
+	flush();
+	return {
+		format: segments.join(""),
+		styles
+	};
+}
+/**
+* Double every literal `%` in `text` to `%%` — the `%`-escape that keeps a browser console from
+* reading a stray `%` (e.g. in `50%` or `%s`) as a format directive. The single escape the
+* {@link ansiToConsole} translation applies to every text segment before assembling the format
+* string (so only the `%c`s it inserts are real directives).
+*
+* @param text - A literal text segment (no inserted directives)
+* @returns `text` with each `%` doubled
+*
+* @example
+* ```ts
+* escapePercent('100% done') // '100%% done'
+* ```
+*/
+function escapePercent(text) {
+	return text.replace(/%/g, "%%");
+}
+/**
+* Parse an SGR parameter list (the `;`-separated numeric string captured by {@link SGR_PATTERN})
+* into its numeric codes — `'1;31'` → `[1, 31]`. An EMPTY list (a bare `ESC[m`) yields `[0]`, since
+* the SGR spec treats a parameterless sequence as a reset; an empty field within a list (`'1;;4'`)
+* likewise counts as a `0` reset, matching the spec.
+*
+* @param parameters - The raw `;`-separated parameter string (the regex capture)
+* @returns The parsed SGR codes (a parameterless / empty field becoming `0`)
+*
+* @example
+* ```ts
+* parseParameters('1;31') // [1, 31]
+* parseParameters('') // [0]
+* ```
+*/
+function parseParameters(parameters) {
+	if (parameters === "") return [RESET_CODE];
+	return parameters.split(";").map((field) => field === "" ? RESET_CODE : Number(field));
+}
+//#endregion
+//#region src/browser/factories.ts
+/**
+* Create the browser `%c` {@link SinkInterface} — the C-f browser output backend. `write(text, level?)`
+* translates the ANSI-styled `text` into a browser `console` call (`console[method](format, ...styles)`)
+* via {@link ansiToConsole}, so a DevTools console renders the SAME styling a terminal does. Drop it in
+* as a logger / reporter / spinner sink (`createLogger({ sink: createBrowserSink() })`) to retarget the
+* core output to the browser console with no change to the core.
+*
+* @returns A browser `%c` {@link SinkInterface}
+*
+* @remarks
+* - **ANSI → `%c` at the sink.** The core produces ANSI strings; this sink parses the SGR runs and
+*   re-emits them as a `console.log`-ready `%c` format string + parallel CSS array ({@link ansiToConsole}
+*   — pure, total, and `%`-safe), so the styling survives the trip to a console that can't render ANSI.
+* - **Routes by level.** `error` → `console.error`, `warn` → `console.warn`, every other level (and an
+*   omitted level) → `console.log` — the SAME routing as core's `createConsoleSink`, so a logger's level
+*   reaches the matching DevTools stream.
+* - **Animation degrade (locked).** A browser console cannot overwrite a line, so a `text` beginning with
+*   a carriage return `\r` (a spinner / progress redraw) has the leading `\r` STRIPPED and is written as a
+*   fresh, non-overwriting line — the locked browser degrade. Only a LEADING `\r` is stripped; an interior
+*   one is left to the console.
+* - **Snapshotted — no capture loop.** It captures `console.log` / `console.warn` / `console.error` AT
+*   CREATION and writes through those references, so a later `Capture` that PATCHES `console.*` can never
+*   feed this sink's output back into itself (the no-capture-loop principle, AGENTS / the core sink's
+*   precedent). Create the sink (or the logger) BEFORE installing a capture.
+*
+* @example
+* ```ts
+* import { createLogger } from '@src/core'
+* import { createBrowserSink } from '@src/browser'
+*
+* const logger = createLogger({ name: 'app', sink: createBrowserSink() })
+* logger.error('boom') // → console.error('%c…', 'color:#cd0000;…') in DevTools
+* ```
+*/
+function createBrowserSink() {
+	const log = console.log.bind(console);
+	const warn = console.warn.bind(console);
+	const error = console.error.bind(console);
+	return { write(text, level) {
+		const { format, styles } = ansiToConsole(text.startsWith("\r") ? text.slice(1) : text);
+		if (level === "error") {
+			error(format, ...styles);
+			return;
+		}
+		if (level === "warn") {
+			warn(format, ...styles);
+			return;
+		}
+		log(format, ...styles);
+	} };
+}
+//#endregion
+export { ATTRIBUTE_CSS, BACKGROUND_CSS, COLOR_HEX, DIRECTIVE, FOREGROUND_CSS, SGR_PATTERN, ansiToConsole, createBrowserSink, escapePercent, parseParameters };
+
+//# sourceMappingURL=index.js.map

package/dist/src/browser/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","names":[],"sources":["../../../src/browser/constants.ts","../../../src/browser/helpers.ts","../../../src/browser/factories.ts"],"sourcesContent":["import type { Color } from '@src/core'\nimport { ATTRIBUTE_CODES, BACKGROUND_CODES, COLORS, ESC, FOREGROUND_CODES } from '@src/core'\n\n// The SGR → CSS translation DATA the browser sink maps ANSI runs through (the C-f branch).\n// The core `src/core/console` is the source of truth for the SGR NUMBERS (which code is which\n// color / attribute); this module owns only the BROWSER-side mapping — a named-color → hex\n// palette and each SGR number → its CSS declaration — and DERIVES the number→CSS lookups by\n// walking core's `COLORS` against its code maps + the palette, so the number↔name mapping is\n// never re-hardcoded here. The SGR-scan pattern is built from core's `ESC` so no control-\n// character literal appears in source. UPPER_SNAKE, deeply `Object.freeze`d, every member\n// exported (AGENTS §5).\n\n/**\n * Each named {@link Color}'s hex value — the 16 standard terminal colors a browser DevTools\n * console renders the SAME {@link Color} names as. The source of truth for the BROWSER color\n * axis: the ANSI renderer maps a `Color` name to an SGR number, and this maps the same name to\n * the CSS color the `%c` sink paints with, so a browser shows the same 16 colors a terminal does.\n *\n * @remarks\n * The conventional VGA/xterm 16-color palette (the base 8 plus their bright variants); `default`\n * is intentionally absent (it leaves the console's own ink and emits no CSS). Deeply frozen.\n */\nexport const COLOR_HEX: Readonly<Record<Exclude<Color, 'default'>, string>> = Object.freeze({\n\tblack: '#000000',\n\tred: '#cd0000',\n\tgreen: '#00cd00',\n\tyellow: '#cdcd00',\n\tblue: '#0000ee',\n\tmagenta: '#cd00cd',\n\tcyan: '#00cdcd',\n\twhite: '#e5e5e5',\n\tbrightBlack: '#7f7f7f',\n\tbrightRed: '#ff0000',\n\tbrightGreen: '#00ff00',\n\tbrightYellow: '#ffff00',\n\tbrightBlue: '#5c5cff',\n\tbrightMagenta: '#ff00ff',\n\tbrightCyan: '#00ffff',\n\tbrightWhite: '#ffffff',\n})\n\n/**\n * Each text-{@link Attribute}'s SGR \"on\" number → its equivalent CSS declaration — the browser\n * counterpart to the terminal's SGR text effects (`bold` 1 → `font-weight:bold`, `dim` 2 →\n * `opacity:0.6`, `italic` 3 → `font-style:italic`, `underline` 4 → `text-decoration:underline`,\n * `inverse` 7 → best-effort, `strikethrough` 9 → `text-decoration:line-through`). Keyed by the SGR\n * NUMBER (derived from core's {@link ATTRIBUTE_CODES}) so the sink looks a parameter up directly\n * while scanning a run.\n *\n * @remarks\n * `inverse` (SGR 7) has no faithful single-declaration CSS equivalent (it swaps the fore/back inks,\n * which depends on the live colors); it maps to a best-effort `filter:invert(100%)` — documented as\n * approximate, never silently dropped. Deeply frozen.\n */\nexport const ATTRIBUTE_CSS: Readonly<Record<number, string>> = Object.freeze({\n\t[ATTRIBUTE_CODES.bold]: 'font-weight:bold',\n\t[ATTRIBUTE_CODES.dim]: 'opacity:0.6',\n\t[ATTRIBUTE_CODES.italic]: 'font-style:italic',\n\t[ATTRIBUTE_CODES.underline]: 'text-decoration:underline',\n\t[ATTRIBUTE_CODES.inverse]: 'filter:invert(100%)',\n\t[ATTRIBUTE_CODES.strikethrough]: 'text-decoration:line-through',\n})\n\n/**\n * Each SGR FOREGROUND parameter (30–37 / 90–97) → its `color:<hex>` CSS, derived by walking core's\n * {@link COLORS} against {@link FOREGROUND_CODES} and {@link COLOR_HEX} (so the number↔name mapping\n * stays in core, never duplicated here). The sink reads this while scanning a run to translate a\n * foreground code to CSS. A pure build-once expression producing a frozen record (the\n * `DEFAULT_CAPTURE_LEVELS = CAPTURE_LEVELS` precedent — derived data, not new data).\n */\nexport const FOREGROUND_CSS: Readonly<Record<number, string>> = Object.freeze(\n\tObject.fromEntries(COLORS.map((color) => [FOREGROUND_CODES[color], `color:${COLOR_HEX[color]}`])),\n)\n\n/**\n * Each SGR BACKGROUND parameter (40–47 / 100–107) → its `background:<hex>` CSS, derived by walking\n * core's {@link COLORS} against {@link BACKGROUND_CODES} and {@link COLOR_HEX}. The sink reads this\n * while scanning a run to translate a background code to CSS.\n */\nexport const BACKGROUND_CSS: Readonly<Record<number, string>> = Object.freeze(\n\tObject.fromEntries(\n\t\tCOLORS.map((color) => [BACKGROUND_CODES[color], `background:${COLOR_HEX[color]}`]),\n\t),\n)\n\n/**\n * The browser console directive that switches the active style — one `%c` prefixes every styled run\n * in the {@link import('./types.js').ConsoleOutput} format string, consuming the next entry of the\n * parallel CSS array. The single source of truth for the directive token.\n */\nexport const DIRECTIVE = '%c'\n\n/**\n * Matches one SGR sequence (`ESC[ <params> m`) and CAPTURES its `;`-separated numeric parameters —\n * the subset of ANSI {@link import('@src/core').strip} cares about that carries STYLE (color /\n * attribute / reset), as opposed to cursor / erase / OSC sequences. Global, so the scanner walks\n * every SGR run in a string; built from core's {@link ESC} so no control-character literal appears\n * in source (the codebase idiom). The capture group is the parameter list (`''` for a bare `ESC[m`,\n * which the spec treats as a reset).\n *\n * @remarks\n * A global `RegExp` carries a mutable `lastIndex`; a scan builds a FRESH `RegExp` from this one's\n * `source` + `flags` rather than reuse this instance, so concurrent scans never collide. This is the\n * canonical definition, not a shared scanner.\n */\nexport const SGR_PATTERN = new RegExp(`${ESC}\\\\[([0-9;]*)m`, 'g')\n","import type { ConsoleOutput, StyleAccumulator } from './types.js'\nimport { RESET_CODE } from '@src/core'\nimport {\n\tATTRIBUTE_CSS,\n\tBACKGROUND_CSS,\n\tDIRECTIVE,\n\tFOREGROUND_CSS,\n\tSGR_PATTERN,\n} from './constants.js'\n\n// The pure, browser-only translation behind the `%c` console sink (the C-f branch). The core\n// styler / Logger / Reporter emit ANSI-styled STRINGS; a DevTools console can't render ANSI but\n// can style via `console.log('%ctext', 'css')`, so `ansiToConsole` parses the SGR runs in the\n// incoming text and re-emits them as a `%c`-ready format string + parallel CSS array — the\n// translation happens at the OUTPUT boundary, leaving the core unchanged. Pure + total + `%`-safe.\n// `ansiToConsole`'s scan glue (apply / serialize / flush over its own `active` / `segments` /\n// `styles` state) lives as local closures inside it (AGENTS §5); only the standalone, reusable\n// `escapePercent` / `parseParameters` utilities are exported alongside it.\n\n/**\n * Translate an ANSI-styled string into a browser `console.log`-ready {@link ConsoleOutput} — a\n * `%c`-segmented format string and the parallel array of CSS declarations, so a DevTools console\n * renders the SAME styling a terminal would (the C-f sink calls `console[method](format, ...styles)`).\n *\n * @remarks\n * - **SGR runs → `%c` segments.** The text is scanned for SGR sequences ({@link SGR_PATTERN} —\n *   `ESC[…m`); each delimits a run. A run carrying VISIBLE text emits one `%c` directive plus that\n *   text into `format` and the run's accumulated CSS into `styles`, so the browser switches style at\n *   each `%c`. Foreground / background / attribute codes accumulate; the reset code (`0`, or a bare\n *   `ESC[m`) clears the accumulated style back to none. A later color of the same channel REPLACES\n *   the earlier one; an attribute is added once. Non-SGR escapes (cursor / erase / OSC) are not style\n *   and are left in the text verbatim.\n * - **`%`-safe.** Every LITERAL `%` in the text is doubled to `%%` so the console never treats it as\n *   a directive — only the `%c`s this function inserts are real directives. So `format`'s real `%c`\n *   count always equals `styles.length`, and `console.log(format, ...styles)` lines up exactly.\n * - **Plain text short-circuits.** A string with NO SGR sequence yields `{ format: <escaped text>,\n *   styles: [] }` — no `%c`, no styles (the text is still `%`-escaped).\n * - **Pure + total.** Same input → same output; it never throws on any string (adversarial escapes,\n *   lone `ESC`, unterminated sequences all fall through as literal text).\n *\n * @param text - Any string, ANSI-styled or plain\n * @returns The `%c` format string + parallel CSS array ({@link ConsoleOutput})\n *\n * @example\n * ```ts\n * ansiToConsole('\\x1b[31mred\\x1b[0m') // { format: '%cred', styles: ['color:#cd0000'] }\n * ansiToConsole('plain') // { format: 'plain', styles: [] }\n * ansiToConsole('50%') // { format: '50%%', styles: [] }\n * ```\n */\nexport function ansiToConsole(text: string): ConsoleOutput {\n\tconst scanner = new RegExp(SGR_PATTERN.source, SGR_PATTERN.flags)\n\t// The accumulated active style across a run — a separate foreground / background declaration\n\t// (each channel REPLACEABLE) plus an ordered, de-duplicated list of attribute declarations. An\n\t// SGR reset empties all three. Serialized to a `;`-joined CSS string per emitted run.\n\tconst active: StyleAccumulator = { foreground: '', background: '', attributes: [] }\n\tconst segments: string[] = []\n\tconst styles: string[] = []\n\tlet styled = false\n\tlet cursor = 0\n\tlet pending = ''\n\n\t// Apply one SGR sequence's `codes` to `active` (in place): a reset clears every channel; a\n\t// foreground / background code REPLACES that channel; an attribute is added once (idempotent).\n\t// An unrecognized code (a 256-color / truecolor extension this layer doesn't map) is ignored,\n\t// never raised — keeping the translation total.\n\tconst apply = (codes: readonly number[]): void => {\n\t\tfor (const code of codes) {\n\t\t\tif (code === RESET_CODE) {\n\t\t\t\tactive.foreground = ''\n\t\t\t\tactive.background = ''\n\t\t\t\tactive.attributes.length = 0\n\t\t\t\tcontinue\n\t\t\t}\n\t\t\tconst foreground = FOREGROUND_CSS[code]\n\t\t\tif (foreground !== undefined) {\n\t\t\t\tactive.foreground = foreground\n\t\t\t\tcontinue\n\t\t\t}\n\t\t\tconst background = BACKGROUND_CSS[code]\n\t\t\tif (background !== undefined) {\n\t\t\t\tactive.background = background\n\t\t\t\tcontinue\n\t\t\t}\n\t\t\tconst attribute = ATTRIBUTE_CSS[code]\n\t\t\tif (attribute !== undefined && !active.attributes.includes(attribute)) {\n\t\t\t\tactive.attributes.push(attribute)\n\t\t\t}\n\t\t}\n\t}\n\n\t// Serialize `active` into one `;`-joined CSS declaration string — attributes (insertion order),\n\t// then foreground, then background, mirroring the renderer's stable code order; an empty style\n\t// (post-reset / nothing accumulated) serializes to `''`.\n\tconst serialize = (): string => {\n\t\tconst declarations = [...active.attributes]\n\t\tif (active.foreground !== '') declarations.push(active.foreground)\n\t\tif (active.background !== '') declarations.push(active.background)\n\t\treturn declarations.join(';')\n\t}\n\n\t// Push `pending` (the run's already-escaped text) as one `%c` segment paired with the run's\n\t// current CSS, then clear `pending`. An EMPTY run is dropped (a style change with no visible text\n\t// emits no `%c`), keeping `format`'s `%c` count exactly equal to `styles.length`.\n\tconst flush = (): void => {\n\t\tif (pending === '') return\n\t\tsegments.push(`${DIRECTIVE}${pending}`)\n\t\tstyles.push(serialize())\n\t\tpending = ''\n\t}\n\n\tfor (let match = scanner.exec(text); match !== null; match = scanner.exec(text)) {\n\t\tstyled = true\n\t\tpending += escapePercent(text.slice(cursor, match.index))\n\t\tflush()\n\t\tapply(parseParameters(match[1] ?? ''))\n\t\tcursor = match.index + match[0].length\n\t}\n\tif (!styled) return { format: escapePercent(text), styles: [] }\n\tpending += escapePercent(text.slice(cursor))\n\tflush()\n\treturn { format: segments.join(''), styles }\n}\n\n/**\n * Double every literal `%` in `text` to `%%` — the `%`-escape that keeps a browser console from\n * reading a stray `%` (e.g. in `50%` or `%s`) as a format directive. The single escape the\n * {@link ansiToConsole} translation applies to every text segment before assembling the format\n * string (so only the `%c`s it inserts are real directives).\n *\n * @param text - A literal text segment (no inserted directives)\n * @returns `text` with each `%` doubled\n *\n * @example\n * ```ts\n * escapePercent('100% done') // '100%% done'\n * ```\n */\nexport function escapePercent(text: string): string {\n\treturn text.replace(/%/g, '%%')\n}\n\n/**\n * Parse an SGR parameter list (the `;`-separated numeric string captured by {@link SGR_PATTERN})\n * into its numeric codes — `'1;31'` → `[1, 31]`. An EMPTY list (a bare `ESC[m`) yields `[0]`, since\n * the SGR spec treats a parameterless sequence as a reset; an empty field within a list (`'1;;4'`)\n * likewise counts as a `0` reset, matching the spec.\n *\n * @param parameters - The raw `;`-separated parameter string (the regex capture)\n * @returns The parsed SGR codes (a parameterless / empty field becoming `0`)\n *\n * @example\n * ```ts\n * parseParameters('1;31') // [1, 31]\n * parseParameters('') // [0]\n * ```\n */\nexport function parseParameters(parameters: string): readonly number[] {\n\tif (parameters === '') return [RESET_CODE]\n\treturn parameters.split(';').map((field) => (field === '' ? RESET_CODE : Number(field)))\n}\n","import type { LogLevel, SinkInterface } from '@src/core'\nimport { ansiToConsole } from './helpers.js'\n\n// The browser `%c` console sink (the C-f branch) — the platform-bound backend that satisfies core's\n// `SinkInterface` in a browser DevTools console. The core styler / Logger / Reporter emit ANSI-styled\n// STRINGS; a DevTools console can't render ANSI but CAN style via `console.log('%ctext', 'css')`, so\n// this sink translates the incoming ANSI runs into a `%c` call at the OUTPUT boundary (the env-split\n// rule: core owns the contract + universal logic, the browser provides the platform backend). A thin\n// stateless adapter, so a frozen-object factory — like core's `createConsoleSink` — not a class\n// (AGENTS §5). `SinkInterface` / `LogLevel` are IMPORTED from `@src/core`, never redeclared.\n\n/**\n * Create the browser `%c` {@link SinkInterface} — the C-f browser output backend. `write(text, level?)`\n * translates the ANSI-styled `text` into a browser `console` call (`console[method](format, ...styles)`)\n * via {@link ansiToConsole}, so a DevTools console renders the SAME styling a terminal does. Drop it in\n * as a logger / reporter / spinner sink (`createLogger({ sink: createBrowserSink() })`) to retarget the\n * core output to the browser console with no change to the core.\n *\n * @returns A browser `%c` {@link SinkInterface}\n *\n * @remarks\n * - **ANSI → `%c` at the sink.** The core produces ANSI strings; this sink parses the SGR runs and\n *   re-emits them as a `console.log`-ready `%c` format string + parallel CSS array ({@link ansiToConsole}\n *   — pure, total, and `%`-safe), so the styling survives the trip to a console that can't render ANSI.\n * - **Routes by level.** `error` → `console.error`, `warn` → `console.warn`, every other level (and an\n *   omitted level) → `console.log` — the SAME routing as core's `createConsoleSink`, so a logger's level\n *   reaches the matching DevTools stream.\n * - **Animation degrade (locked).** A browser console cannot overwrite a line, so a `text` beginning with\n *   a carriage return `\\r` (a spinner / progress redraw) has the leading `\\r` STRIPPED and is written as a\n *   fresh, non-overwriting line — the locked browser degrade. Only a LEADING `\\r` is stripped; an interior\n *   one is left to the console.\n * - **Snapshotted — no capture loop.** It captures `console.log` / `console.warn` / `console.error` AT\n *   CREATION and writes through those references, so a later `Capture` that PATCHES `console.*` can never\n *   feed this sink's output back into itself (the no-capture-loop principle, AGENTS / the core sink's\n *   precedent). Create the sink (or the logger) BEFORE installing a capture.\n *\n * @example\n * ```ts\n * import { createLogger } from '@src/core'\n * import { createBrowserSink } from '@src/browser'\n *\n * const logger = createLogger({ name: 'app', sink: createBrowserSink() })\n * logger.error('boom') // → console.error('%c…', 'color:#cd0000;…') in DevTools\n * ```\n */\nexport function createBrowserSink(): SinkInterface {\n\t// Snapshot the three console writers NOW — bound to their `console` receiver — so a later patch of\n\t// `console.*` (by Capture) can never reach this sink's output (no capture loop), exactly as core's\n\t// `createConsoleSink` does.\n\tconst log = console.log.bind(console)\n\tconst warn = console.warn.bind(console)\n\tconst error = console.error.bind(console)\n\treturn {\n\t\twrite(text: string, level?: LogLevel): void {\n\t\t\t// Degrade the animation redraw first: a leading `\\r` can't overwrite a line in a browser\n\t\t\t// console, so drop it and write a fresh, non-overwriting line (the locked decision).\n\t\t\tconst line = text.startsWith('\\r') ? text.slice(1) : text\n\t\t\tconst { format, styles } = ansiToConsole(line)\n\t\t\tif (level === 'error') {\n\t\t\t\terror(format, ...styles)\n\t\t\t\treturn\n\t\t\t}\n\t\t\tif (level === 'warn') {\n\t\t\t\twarn(format, ...styles)\n\t\t\t\treturn\n\t\t\t}\n\t\t\tlog(format, ...styles)\n\t\t},\n\t}\n}\n"],"mappings":"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"}