@socketsecurity/lib 6.0.6 → 6.0.8

package/dist/logger/options.d.ts

@@ -0,0 +1,39 @@
+/**
+ * @file Constructor-options parsing for the `Logger` class. Pulls the
+ *   options-shape inspection (null-prototype clone, original-stdout capture,
+ *   theme-name-or-object resolution) out of `./node` so the class constructor
+ *   stays a thin shell over `parseLoggerOptions`. Returns a normalized
+ *   `ParsedLoggerOptions`; the constructor copies the fields onto its private
+ *   slots.
+ */
+import type { Theme } from '../themes/types';
+/**
+ * The normalized result of inspecting the first `Logger` constructor argument.
+ */
+export interface ParsedLoggerOptions {
+    /**
+     * Null-prototype clone of the options object (empty when no options were
+     * passed). Stored for future extensibility.
+     */
+    options: Record<string, unknown>;
+    /**
+     * The caller-supplied stdout stream, used by `write()` to bypass Console
+     * formatting. `undefined` when not provided.
+     */
+    originalStdout: NodeJS.WritableStream | undefined;
+    /**
+     * The resolved instance theme: a `THEMES` entry when a theme name was given,
+     * the object itself when a `Theme` was given, or `undefined` otherwise.
+     */
+    theme: Theme | undefined;
+}
+/**
+ * Parse the first `Logger` constructor argument into normalized option slots.
+ *
+ * A `theme` string is resolved against `THEMES` (unknown names yield no theme);
+ * a `theme` object is used directly. When the first argument is not an object,
+ * every slot defaults (empty null-prototype options, no stdout, no theme).
+ *
+ * @param args - The raw `Logger` constructor arguments.
+ */
+export declare function parseLoggerOptions(args: unknown[]): ParsedLoggerOptions;

package/dist/logger/options.js

@@ -0,0 +1,47 @@
+"use strict";
+/* Socket Lib - Built with rolldown */
+Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
+const require_themes_themes = require('../themes/themes.js');
+
+//#region src/logger/options.ts
+/**
+* @file Constructor-options parsing for the `Logger` class. Pulls the
+*   options-shape inspection (null-prototype clone, original-stdout capture,
+*   theme-name-or-object resolution) out of `./node` so the class constructor
+*   stays a thin shell over `parseLoggerOptions`. Returns a normalized
+*   `ParsedLoggerOptions`; the constructor copies the fields onto its private
+*   slots.
+*/
+/**
+* Parse the first `Logger` constructor argument into normalized option slots.
+*
+* A `theme` string is resolved against `THEMES` (unknown names yield no theme);
+* a `theme` object is used directly. When the first argument is not an object,
+* every slot defaults (empty null-prototype options, no stdout, no theme).
+*
+* @param args - The raw `Logger` constructor arguments.
+*/
+function parseLoggerOptions(args) {
+	const options = args[0];
+	if (typeof options !== "object" || options === null) return {
+		options: { __proto__: null },
+		originalStdout: void 0,
+		theme: void 0
+	};
+	const originalStdout = options.stdout;
+	const themeOption = options.theme;
+	let theme;
+	if (typeof themeOption === "string") theme = require_themes_themes.THEMES[themeOption] ?? void 0;
+	else if (themeOption) theme = themeOption;
+	return {
+		options: {
+			__proto__: null,
+			...options
+		},
+		originalStdout,
+		theme
+	};
+}
+
+//#endregion
+exports.parseLoggerOptions = parseLoggerOptions;

package/dist/logger/semantic-methods.d.ts

@@ -0,0 +1,63 @@
+/**
+ * @file Free-function bodies for the symbol-prefixed semantic `Logger` methods
+ *   (`done`, `fail`, `info`, `skip`, `step`, `success`, `warn`). Each strips
+ *   any leading status symbol from the message, re-prefixes it with the theme's
+ *   colored symbol, writes to the appropriate stream (status messages to
+ *   stderr, `step` to stdout), and updates the shared blank-line / call-count
+ *   tracking via the exported logger symbols. Pulling these out of `./node`
+ *   keeps the `Logger` class body under the file-size cap. The class retains
+ *   one-line delegators that resolve `con` / `indent` / `symbols` from its
+ *   private state and forward them here.
+ */
+import type { ConsoleLike, LoggerTrackable } from './console-methods';
+import type { LogSymbols } from './types';
+/**
+ * Apply a `node:console` method with the given indentation prefix on its first
+ * (string) argument.
+ *
+ * Mirrors the former private `#apply`: when the first argument is a string it
+ * is line-prefixed with `indent`; otherwise the args pass through unchanged.
+ * Tracks the blank-line state for `targetStream` and bumps the call count.
+ * Returns the logger for chaining.
+ *
+ * @param logger - The calling logger instance.
+ * @param con - The logger's resolved console instance.
+ * @param methodName - The `node:console` method to invoke (`log`, `error`,
+ *   ...).
+ * @param args - The arguments forwarded to the console method.
+ * @param targetStream - The stream the method writes to.
+ * @param indent - The resolved indentation prefix for `targetStream`.
+ */
+export declare function applyMethod<T extends LoggerTrackable>(logger: T, con: ConsoleLike, methodName: string, args: unknown[], targetStream: 'stderr' | 'stdout', indent: string): T;
+/**
+ * Logs a main step message with a colored arrow symbol to stdout.
+ *
+ * Strips any leading status symbol from `msg`, re-prefixes it with the theme's
+ * `step` symbol, and writes to stdout (unlike the other semantic methods, which
+ * go to stderr). The blank line before the step is handled by the caller.
+ * Returns the logger for chaining.
+ *
+ * @param logger - The calling logger instance.
+ * @param con - The logger's resolved console instance.
+ * @param indent - The resolved stdout indentation prefix.
+ * @param symbols - The logger's resolved `LogSymbols` map.
+ * @param msg - The step message to log.
+ * @param extras - Additional arguments to log.
+ */
+export declare function stepMethod<T extends LoggerTrackable>(logger: T, con: ConsoleLike, indent: string, symbols: LogSymbols, msg: string, extras: unknown[]): T;
+/**
+ * Strip a leading status symbol, re-prefix with the colored symbol for
+ * `symbolType`, and write to stderr.
+ *
+ * Mirrors the former private `#symbolApply`: status messages (info / fail /
+ * success / warn / skip / done) always go to stderr. Returns the logger for
+ * chaining.
+ *
+ * @param logger - The calling logger instance.
+ * @param con - The logger's resolved console instance.
+ * @param indent - The resolved stderr indentation prefix.
+ * @param symbols - The logger's resolved `LogSymbols` map.
+ * @param symbolType - The `LogSymbols` key whose symbol prefixes the message.
+ * @param args - The message and additional arguments to log.
+ */
+export declare function symbolApplyMethod<T extends LoggerTrackable>(logger: T, con: ConsoleLike, indent: string, symbols: LogSymbols, symbolType: string, args: unknown[]): T;

package/dist/logger/semantic-methods.js

@@ -0,0 +1,108 @@
+"use strict";
+/* Socket Lib - Built with rolldown */
+Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
+const require_primordials_array = require('../primordials/array.js');
+const require_primordials_reflect = require('../primordials/reflect.js');
+const require_logger_symbols_builder = require('./symbols-builder.js');
+const require_logger_symbols = require('./symbols.js');
+const require_strings_format = require('../strings/format.js');
+const require_strings_predicates = require('../strings/predicates.js');
+
+//#region src/logger/semantic-methods.ts
+/**
+* @file Free-function bodies for the symbol-prefixed semantic `Logger` methods
+*   (`done`, `fail`, `info`, `skip`, `step`, `success`, `warn`). Each strips
+*   any leading status symbol from the message, re-prefixes it with the theme's
+*   colored symbol, writes to the appropriate stream (status messages to
+*   stderr, `step` to stdout), and updates the shared blank-line / call-count
+*   tracking via the exported logger symbols. Pulling these out of `./node`
+*   keeps the `Logger` class body under the file-size cap. The class retains
+*   one-line delegators that resolve `con` / `indent` / `symbols` from its
+*   private state and forward them here.
+*/
+/**
+* Apply a `node:console` method with the given indentation prefix on its first
+* (string) argument.
+*
+* Mirrors the former private `#apply`: when the first argument is a string it
+* is line-prefixed with `indent`; otherwise the args pass through unchanged.
+* Tracks the blank-line state for `targetStream` and bumps the call count.
+* Returns the logger for chaining.
+*
+* @param logger - The calling logger instance.
+* @param con - The logger's resolved console instance.
+* @param methodName - The `node:console` method to invoke (`log`, `error`,
+*   ...).
+* @param args - The arguments forwarded to the console method.
+* @param targetStream - The stream the method writes to.
+* @param indent - The resolved indentation prefix for `targetStream`.
+*/
+function applyMethod(logger, con, methodName, args, targetStream, indent) {
+	const text = require_primordials_array.ArrayPrototypeAt(args, 0);
+	const hasText = typeof text === "string";
+	const logArgs = hasText ? [require_strings_format.applyLinePrefix(text, { prefix: indent }), ...require_primordials_array.ArrayPrototypeSlice(args, 1)] : args;
+	require_primordials_reflect.ReflectApply(con[methodName], con, logArgs);
+	logger[require_logger_symbols.lastWasBlankSymbol](hasText && require_strings_predicates.isBlankString(logArgs[0]), targetStream);
+	logger[require_logger_symbols.incLogCallCountSymbol]();
+	return logger;
+}
+/**
+* Logs a main step message with a colored arrow symbol to stdout.
+*
+* Strips any leading status symbol from `msg`, re-prefixes it with the theme's
+* `step` symbol, and writes to stdout (unlike the other semantic methods, which
+* go to stderr). The blank line before the step is handled by the caller.
+* Returns the logger for chaining.
+*
+* @param logger - The calling logger instance.
+* @param con - The logger's resolved console instance.
+* @param indent - The resolved stdout indentation prefix.
+* @param symbols - The logger's resolved `LogSymbols` map.
+* @param msg - The step message to log.
+* @param extras - Additional arguments to log.
+*/
+function stepMethod(logger, con, indent, symbols, msg, extras) {
+	const text = require_logger_symbols_builder.stripLoggerSymbols(msg);
+	con.log(require_strings_format.applyLinePrefix(`${symbols.step} ${text}`, { prefix: indent }), ...extras);
+	logger[require_logger_symbols.lastWasBlankSymbol](false, "stdout");
+	logger[require_logger_symbols.incLogCallCountSymbol]();
+	return logger;
+}
+/**
+* Strip a leading status symbol, re-prefix with the colored symbol for
+* `symbolType`, and write to stderr.
+*
+* Mirrors the former private `#symbolApply`: status messages (info / fail /
+* success / warn / skip / done) always go to stderr. Returns the logger for
+* chaining.
+*
+* @param logger - The calling logger instance.
+* @param con - The logger's resolved console instance.
+* @param indent - The resolved stderr indentation prefix.
+* @param symbols - The logger's resolved `LogSymbols` map.
+* @param symbolType - The `LogSymbols` key whose symbol prefixes the message.
+* @param args - The message and additional arguments to log.
+*/
+function symbolApplyMethod(logger, con, indent, symbols, symbolType, args) {
+	let text = args[0];
+	let extras;
+	/* c8 ignore start - text-non-string arm fires only when caller passes
+	an object as the first argument; tests always pass a string. */
+	if (typeof text === "string") {
+		text = require_logger_symbols_builder.stripLoggerSymbols(text);
+		extras = args.slice(1);
+	} else {
+		extras = args;
+		text = "";
+	}
+	/* c8 ignore stop */
+	con.error(require_strings_format.applyLinePrefix(`${symbols[symbolType]} ${text}`, { prefix: indent }), ...extras);
+	logger[require_logger_symbols.lastWasBlankSymbol](false, "stderr");
+	logger[require_logger_symbols.incLogCallCountSymbol]();
+	return logger;
+}
+
+//#endregion
+exports.applyMethod = applyMethod;
+exports.stepMethod = stepMethod;
+exports.symbolApplyMethod = symbolApplyMethod;

package/dist/logger/stream-methods.d.ts

@@ -0,0 +1,63 @@
+/**
+ * @file Free-function bodies for the `Logger` methods that write to or clear a
+ *   raw stream rather than going through the indented `#apply` path
+ *   (`clearLine`, `clearVisible`, `progress`, `write`). Each takes the calling
+ *   logger plus the already-resolved `node:console` instance and whatever
+ *   stream / symbol state it needs, then updates the shared blank-line /
+ *   call-count tracking via the exported logger symbols. Pulling these out of
+ *   `./node` keeps the `Logger` class body under the file-size cap; the class
+ *   retains one-line delegators that resolve the arguments from its private
+ *   state.
+ */
+import type { ConsoleLike, LoggerTrackable } from './console-methods';
+import type { LogSymbols } from './types';
+/**
+ * Clears the current terminal line on the logger's target stream (TTY and
+ * non-TTY). Useful after `progress()`. Returns the logger for chaining.
+ *
+ * @param logger - The calling logger instance.
+ * @param con - The logger's resolved console instance.
+ * @param stream - The target stream to clear.
+ */
+export declare function clearLineMethod<T extends LoggerTrackable>(logger: T, con: ConsoleLike, stream: 'stderr' | 'stdout'): T;
+/**
+ * Clears the visible terminal screen. Only valid on the main (non-stream-bound)
+ * logger. When the underlying stdout is a TTY, resets blank-line tracking and
+ * invokes `resetCount` to zero the log-call counter. Returns the logger for
+ * chaining.
+ *
+ * @param logger - The calling logger instance.
+ * @param con - The logger's resolved console instance.
+ * @param boundStream - The logger's bound stream, or `undefined` on the root.
+ * @param resetCount - Callback that zeroes the logger's log-call counter.
+ *
+ * @throws {Error} If called on a stream-bound logger instance.
+ */
+export declare function clearVisibleMethod<T extends LoggerTrackable>(logger: T, con: ConsoleLike, boundStream: 'stderr' | 'stdout' | undefined, resetCount: () => void): T;
+/**
+ * Shows a progress indicator (a `∴`-prefixed status message) that can be
+ * cleared with `clearLine()`. Always clears the current line first so repeated
+ * `progress(...)` calls redraw cleanly. Returns the logger for chaining.
+ *
+ * @param logger - The calling logger instance.
+ * @param con - The logger's resolved console instance.
+ * @param stream - The target stream to write to.
+ * @param symbols - The logger's resolved `LogSymbols` map.
+ * @param text - The progress message to display.
+ */
+export declare function progressMethod<T extends LoggerTrackable>(logger: T, con: ConsoleLike, stream: 'stderr' | 'stdout', symbols: LogSymbols, text: string): T;
+/**
+ * Writes text directly to the original stdout stream, bypassing Console
+ * formatting and applying no indentation. Returns the logger for chaining.
+ *
+ * The original stdout is resolved with a three-way fallback: the seeded
+ * `originalStdout`, then the constructor args' `stdout`, then the Console's
+ * internal `_stdout` slot.
+ *
+ * @param logger - The calling logger instance.
+ * @param con - The logger's resolved console instance.
+ * @param originalStdout - The stdout seeded at construction, if any.
+ * @param ctorArgs - The logger's stored constructor args.
+ * @param text - The text to write.
+ */
+export declare function writeMethod<T extends LoggerTrackable>(logger: T, con: ConsoleLike, originalStdout: NodeJS.WritableStream | undefined, ctorArgs: unknown[], text: string): T;

package/dist/logger/stream-methods.js

@@ -0,0 +1,101 @@
+"use strict";
+/* Socket Lib - Built with rolldown */
+Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
+const require_primordials_error = require('../primordials/error.js');
+const require_logger_symbols = require('./symbols.js');
+const require_logger_stream = require('./stream.js');
+
+//#region src/logger/stream-methods.ts
+/**
+* @file Free-function bodies for the `Logger` methods that write to or clear a
+*   raw stream rather than going through the indented `#apply` path
+*   (`clearLine`, `clearVisible`, `progress`, `write`). Each takes the calling
+*   logger plus the already-resolved `node:console` instance and whatever
+*   stream / symbol state it needs, then updates the shared blank-line /
+*   call-count tracking via the exported logger symbols. Pulling these out of
+*   `./node` keeps the `Logger` class body under the file-size cap; the class
+*   retains one-line delegators that resolve the arguments from its private
+*   state.
+*/
+/**
+* Clears the current terminal line on the logger's target stream (TTY and
+* non-TTY). Useful after `progress()`. Returns the logger for chaining.
+*
+* @param logger - The calling logger instance.
+* @param con - The logger's resolved console instance.
+* @param stream - The target stream to clear.
+*/
+function clearLineMethod(logger, con, stream) {
+	require_logger_stream.clearTerminalLine(require_logger_stream.resolveWriteStream(con, stream));
+	return logger;
+}
+/**
+* Clears the visible terminal screen. Only valid on the main (non-stream-bound)
+* logger. When the underlying stdout is a TTY, resets blank-line tracking and
+* invokes `resetCount` to zero the log-call counter. Returns the logger for
+* chaining.
+*
+* @param logger - The calling logger instance.
+* @param con - The logger's resolved console instance.
+* @param boundStream - The logger's bound stream, or `undefined` on the root.
+* @param resetCount - Callback that zeroes the logger's log-call counter.
+*
+* @throws {Error} If called on a stream-bound logger instance.
+*/
+function clearVisibleMethod(logger, con, boundStream, resetCount) {
+	/* c8 ignore start - clearVisible TTY-mode behavior; tests use non-TTY
+	capture streams so the bound-stream throw and TTY clear branches
+	aren't reached. */
+	if (boundStream) throw new require_primordials_error.ErrorCtor("clearVisible() is only available on the main logger instance, not on stream-bound instances");
+	con.clear();
+	if (con["_stdout"].isTTY) {
+		logger[require_logger_symbols.lastWasBlankSymbol](true);
+		resetCount();
+	}
+	return logger;
+	/* c8 ignore stop */
+}
+/**
+* Shows a progress indicator (a `∴`-prefixed status message) that can be
+* cleared with `clearLine()`. Always clears the current line first so repeated
+* `progress(...)` calls redraw cleanly. Returns the logger for chaining.
+*
+* @param logger - The calling logger instance.
+* @param con - The logger's resolved console instance.
+* @param stream - The target stream to write to.
+* @param symbols - The logger's resolved `LogSymbols` map.
+* @param text - The progress message to display.
+*/
+function progressMethod(logger, con, stream, symbols, text) {
+	const streamObj = require_logger_stream.resolveWriteStream(con, stream);
+	require_logger_stream.clearTerminalLine(streamObj);
+	streamObj.write(`${symbols.progress} ${text}`);
+	logger[require_logger_symbols.lastWasBlankSymbol](false);
+	return logger;
+}
+/**
+* Writes text directly to the original stdout stream, bypassing Console
+* formatting and applying no indentation. Returns the logger for chaining.
+*
+* The original stdout is resolved with a three-way fallback: the seeded
+* `originalStdout`, then the constructor args' `stdout`, then the Console's
+* internal `_stdout` slot.
+*
+* @param logger - The calling logger instance.
+* @param con - The logger's resolved console instance.
+* @param originalStdout - The stdout seeded at construction, if any.
+* @param ctorArgs - The logger's stored constructor args.
+* @param text - The text to write.
+*/
+function writeMethod(logger, con, originalStdout, ctorArgs, text) {
+	/* c8 ignore stop */
+	(originalStdout || ctorArgs[0]?.stdout || con._stdout).write(text);
+	logger[require_logger_symbols.lastWasBlankSymbol](false);
+	return logger;
+}
+
+//#endregion
+exports.clearLineMethod = clearLineMethod;
+exports.clearVisibleMethod = clearVisibleMethod;
+exports.progressMethod = progressMethod;
+exports.writeMethod = writeMethod;

package/dist/logger/stream.d.ts

@@ -0,0 +1,37 @@
+/**
+ * @file Terminal stream resolution + line-clearing helpers shared by the
+ *   Node-side `Logger` methods that write directly to a stream (`clearLine`,
+ *   `clearVisible`, `progress`). The Logger's `node:console` instance keeps its
+ *   underlying writable streams on the internal `_stderr` / `_stdout` symbols;
+ *   these helpers resolve the right one for a given target stream and
+ *   centralize the TTY-vs-non-TTY clear sequence (`cursorTo(0) + clearLine(0)`
+ *   on a TTY, `\r\x1b[K` fallback elsewhere — which still works in CI logs).
+ */
+/**
+ * Clear the current line on a writable stream. Uses `cursorTo(0) +
+ * clearLine(0)` on a TTY and falls back to `\r\x1b[K` otherwise so the same
+ * call redraws cleanly in both interactive terminals and CI logs.
+ *
+ * @param streamObj - The resolved writable stream to clear.
+ */
+export declare function clearTerminalLine(streamObj: WriteStreamLike): void;
+/**
+ * Subset of `NodeJS.WriteStream` the logger needs for direct, cursor-aware
+ * writes. Modeled as a structural shape so the cast off the console's internal
+ * `_stderr` / `_stdout` slots stays explicit.
+ */
+export interface WriteStreamLike {
+    isTTY: boolean;
+    cursorTo: (x: number) => void;
+    clearLine: (dir: number) => void;
+    write: (text: string) => boolean;
+}
+/**
+ * Resolve the underlying writable stream for a target stream from a console
+ * instance, casting from the console's internal `_stderr` / `_stdout` slots to
+ * the cursor-aware shape the logger writes to directly.
+ *
+ * @param con - The console instance exposing `_stderr` / `_stdout`.
+ * @param stream - Which target stream to resolve.
+ */
+export declare function resolveWriteStream(con: Record<string, unknown>, stream: 'stderr' | 'stdout'): WriteStreamLike;

package/dist/logger/stream.js

@@ -0,0 +1,42 @@
+"use strict";
+/* Socket Lib - Built with rolldown */
+Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
+
+//#region src/logger/stream.ts
+/**
+* @file Terminal stream resolution + line-clearing helpers shared by the
+*   Node-side `Logger` methods that write directly to a stream (`clearLine`,
+*   `clearVisible`, `progress`). The Logger's `node:console` instance keeps its
+*   underlying writable streams on the internal `_stderr` / `_stdout` symbols;
+*   these helpers resolve the right one for a given target stream and
+*   centralize the TTY-vs-non-TTY clear sequence (`cursorTo(0) + clearLine(0)`
+*   on a TTY, `\r\x1b[K` fallback elsewhere — which still works in CI logs).
+*/
+/**
+* Clear the current line on a writable stream. Uses `cursorTo(0) +
+* clearLine(0)` on a TTY and falls back to `\r\x1b[K` otherwise so the same
+* call redraws cleanly in both interactive terminals and CI logs.
+*
+* @param streamObj - The resolved writable stream to clear.
+*/
+function clearTerminalLine(streamObj) {
+	if (streamObj.isTTY) {
+		streamObj.cursorTo(0);
+		streamObj.clearLine(0);
+	} else streamObj.write("\r\x1B[K");
+}
+/**
+* Resolve the underlying writable stream for a target stream from a console
+* instance, casting from the console's internal `_stderr` / `_stdout` slots to
+* the cursor-aware shape the logger writes to directly.
+*
+* @param con - The console instance exposing `_stderr` / `_stdout`.
+* @param stream - Which target stream to resolve.
+*/
+function resolveWriteStream(con, stream) {
+	return stream === "stderr" ? con["_stderr"] : con["_stdout"];
+}
+
+//#endregion
+exports.clearTerminalLine = clearTerminalLine;
+exports.resolveWriteStream = resolveWriteStream;

package/dist/logger/symbols-builder.js

@@ -26,18 +26,18 @@ src_external__socketregistry_is_unicode_supported = require_runtime.__toESM(src_
 */
 function buildLoggerSymbols(theme) {
 	const supported = (0, src_external__socketregistry_is_unicode_supported.default)();
-	const colors = /* @__PURE__ */ require_logger_colors.getYoctocolors();
+	const colors = require_logger_colors.getYoctocolors();
 	/* c8 ignore start - ASCII-fallback symbol arms only fire on
 	terminals without unicode support; tests run on unicode TTYs. */
 	return {
 		__proto__: null,
-		fail: /* @__PURE__ */ require_logger_colors.applyColor(supported ? "✖" : "×", theme.colors.error, colors),
-		info: /* @__PURE__ */ require_logger_colors.applyColor(supported ? "ℹ" : "i", theme.colors.info, colors),
-		progress: /* @__PURE__ */ require_logger_colors.applyColor(supported ? "∴" : ":.", theme.colors.step, colors),
-		skip: /* @__PURE__ */ require_logger_colors.applyColor(supported ? "↻" : "@", theme.colors.step, colors),
-		step: /* @__PURE__ */ require_logger_colors.applyColor(supported ? "→" : ">", theme.colors.step, colors),
-		success: /* @__PURE__ */ require_logger_colors.applyColor(supported ? "✔" : "√", theme.colors.success, colors),
-		warn: /* @__PURE__ */ require_logger_colors.applyColor(supported ? "⚠" : "‼", theme.colors.warning, colors)
+		fail: require_logger_colors.applyColor(supported ? "✖" : "×", theme.colors.error, colors),
+		info: require_logger_colors.applyColor(supported ? "ℹ" : "i", theme.colors.info, colors),
+		progress: require_logger_colors.applyColor(supported ? "∴" : ":.", theme.colors.step, colors),
+		skip: require_logger_colors.applyColor(supported ? "↻" : "@", theme.colors.step, colors),
+		step: require_logger_colors.applyColor(supported ? "→" : ">", theme.colors.step, colors),
+		success: require_logger_colors.applyColor(supported ? "✔" : "√", theme.colors.success, colors),
+		warn: require_logger_colors.applyColor(supported ? "⚠" : "‼", theme.colors.warning, colors)
 	};
 	/* c8 ignore stop */
 }
@@ -51,7 +51,7 @@ function buildLoggerSymbols(theme) {
 * input becomes `'Done'`.
 */
 function stripLoggerSymbols(text) {
-	return require_primordials_string.StringPrototypeReplace(text, /^(?:[✖✗×⚠‼✔✓√ℹ→∴↻]|:.)[️\s]*/u, "");
+	return require_primordials_string.StringPrototypeReplace(text, /^(?::.|[✖✗×⚠‼✔✓√ℹ→∴↻])[️\s]*/u, "");
 }
 
 //#endregion

package/dist/logger/symbols.d.ts

@@ -8,6 +8,8 @@
  *   are configured) and re-renders whenever `setTheme()` fires
  *   `onThemeChange`.
  */
+export declare function createLogSymbols(): Record<string, string>;
+export declare function createLogSymbolsProxyPlaceholder(): void;
 /**
  * Lazily get console symbols on first access.
  *
@@ -33,29 +35,4 @@ export declare const incLogCallCountSymbol: unique symbol;
  * determine whether to add spacing before certain messages.
  */
 export declare const lastWasBlankSymbol: unique symbol;
-/**
- * Log symbols for terminal output with colored indicators.
- *
- * Provides colored Unicode symbols (✖, ℹ, ∴, →, ✔, ⚠) with ASCII fallbacks (×,
- * i, :., >, √, ‼) for terminals that don't support Unicode. Symbols are colored
- * according to the active theme's color palette (error, info, reason, step,
- * success, warning).
- *
- * The symbols are lazily initialized on first access and automatically update
- * when the fallback theme changes (via setTheme()). Note that LOG_SYMBOLS
- * reflect the global fallback theme, not async-local theme contexts from
- * withTheme().
- *
- * @example
- *   ```typescript
- *   import { LOG_SYMBOLS } from '@socketsecurity/lib/logger/symbols'
- *
- *   console.log(`${LOG_SYMBOLS.fail} Build failed`) // Theme error color ✖
- *   console.log(`${LOG_SYMBOLS.info} Starting process`) // Theme info color ℹ
- *   console.log(`${LOG_SYMBOLS.progress} Working on task`) // Theme step color ∴
- *   console.log(`${LOG_SYMBOLS.step} Processing files`) // Theme step color →
- *   console.log(`${LOG_SYMBOLS.success} Build completed`) // Theme success color ✔
- *   console.log(`${LOG_SYMBOLS.warn} Deprecated API used`) // Theme warning color ⚠
- *   ```
- */
 export declare const LOG_SYMBOLS: Record<string, string>;