@socketsecurity/lib 6.0.6 → 6.0.8

package/dist/json/parse.d.ts

@@ -5,7 +5,7 @@
  *   limits + optional schema validation).
  */
 import type { Schema } from '../schema/types';
-import type { ParseJsonOptions, JsonPrimitive, JsonValue, ParseJsonSafeOptions } from './types';
+import type { JsonPrimitive, JsonValue, ParseJsonOptions, ParseJsonSafeOptions } from './types';
 /**
  * Check if a value is a Buffer instance. Uses duck-typing to detect Buffer
  * without requiring Node.js Buffer in type system.

package/dist/json/parse.js

@@ -4,9 +4,9 @@ Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
 const require_primordials_buffer = require('../primordials/buffer.js');
 const require_primordials_error = require('../primordials/error.js');
 const require_primordials_map_set = require('../primordials/map-set.js');
+const require_primordials_json = require('../primordials/json.js');
 const require_schema_validate = require('../schema/validate.js');
 const require_strings_transform = require('../strings/transform.js');
-const require_primordials_json = require('../primordials/json.js');
 
 //#region src/json/parse.ts
 /**
@@ -30,7 +30,6 @@ const require_primordials_json = require('../primordials/json.js');
 *
 * @returns `true` if value is a Buffer, `false` otherwise
 */
-/*@__NO_SIDE_EFFECTS__*/
 function isBuffer(x) {
 	if (!x || typeof x !== "object") return false;
 	const obj = x;
@@ -59,7 +58,6 @@ function isBuffer(x) {
 *
 * @returns `true` if value is a JSON primitive, `false` otherwise
 */
-/*@__NO_SIDE_EFFECTS__*/
 function isJsonPrimitive(value) {
 	return value === null || typeof value === "boolean" || typeof value === "number" || typeof value === "string";
 }
@@ -117,16 +115,15 @@ function isJsonPrimitive(value) {
 *
 * @throws {SyntaxError} When JSON is invalid and `throws` is `true` (default)
 */
-/*@__NO_SIDE_EFFECTS__*/
 function parseJson(content, options) {
 	const { filepath, reviver, throws } = {
 		__proto__: null,
 		...options
 	};
 	const shouldThrow = throws === void 0 || !!throws;
-	const jsonStr = /* @__PURE__ */ isBuffer(content) ? content.toString("utf8") : content;
+	const jsonStr = isBuffer(content) ? content.toString("utf8") : content;
 	try {
-		return require_primordials_json.JSONParse(/* @__PURE__ */ require_strings_transform.stripBom(jsonStr), reviver);
+		return require_primordials_json.JSONParse(require_strings_transform.stripBom(jsonStr), reviver);
 	} catch (e) {
 		if (shouldThrow) {
 			const error = e;
@@ -183,7 +180,6 @@ const DEFAULT_MAX_SIZE = 10 * 1024 * 1024;
 *   `allowPrototype` is not `true`).
 * @throws {Error} When schema validation fails.
 */
-/*@__NO_SIDE_EFFECTS__*/
 function parseJsonSafe(jsonString, schema, options = {}) {
 	const { allowPrototype = false, maxSize = DEFAULT_MAX_SIZE } = options;
 	if (require_primordials_buffer.BufferByteLength(jsonString, "utf8") > maxSize) throw new require_primordials_error.ErrorCtor(`JSON string exceeds maximum size limit${maxSize !== DEFAULT_MAX_SIZE ? ` of ${maxSize} bytes` : ""}`);

package/dist/logger/_internal.d.ts

@@ -3,7 +3,7 @@
  *   public `Logger` surface) and `logger/console-init` (which mutates
  *   `Logger.prototype` to mirror `globalConsole`). The `_` prefix keeps this
  *   module out of the generated package.json `exports` map (the `dist/**\/_*`
- *   ignore pattern in `scripts/fix/generate-package-exports.mts` filters it
+ *   ignore pattern in `scripts/post-build/make-package-exports.mts` filters it
  *   out), so it is not part of the public surface — it exists only to give the
  *   two leaves above a common owner for the WeakMap-backed lazy-init state. Why
  *   two WeakMaps instead of `#privateField` slots:
@@ -32,9 +32,9 @@ export declare const globalConsole: Console;
  */
 export declare const consolePropAttributes: {
     __proto__: null;
-    writable: boolean;
-    enumerable: boolean;
     configurable: boolean;
+    enumerable: boolean;
+    writable: boolean;
 };
 /**
  * Cap on the indentation prefix length so a runaway `indent(n)` call with a
@@ -58,7 +58,7 @@ export declare const maxIndentation = 1000;
  *   the Logger's own group methods avoid by tracking indentation at the prefix
  *   layer.
  */
-export declare const boundConsoleEntries: any[][];
+export declare const boundConsoleEntries: [string, (...args: unknown[]) => unknown][];
 /**
  * WeakMap storing the Console instance for each Logger.
  *

package/dist/logger/_internal.js

@@ -9,7 +9,7 @@ const require_primordials_map_set = require('../primordials/map-set.js');
 *   public `Logger` surface) and `logger/console-init` (which mutates
 *   `Logger.prototype` to mirror `globalConsole`). The `_` prefix keeps this
 *   module out of the generated package.json `exports` map (the `dist/**\/_*`
-*   ignore pattern in `scripts/fix/generate-package-exports.mts` filters it
+*   ignore pattern in `scripts/post-build/make-package-exports.mts` filters it
 *   out), so it is not part of the public surface — it exists only to give the
 *   two leaves above a common owner for the WeakMap-backed lazy-init state. Why
 *   two WeakMaps instead of `#privateField` slots:
@@ -38,9 +38,9 @@ const globalConsole = console;
 */
 const consolePropAttributes = {
 	__proto__: null,
-	writable: true,
+	configurable: true,
 	enumerable: false,
-	configurable: true
+	writable: true
 };
 /**
 * Cap on the indentation prefix length so a runaway `indent(n)` call with a

package/dist/logger/colors.js

@@ -17,16 +17,17 @@ src_external_yoctocolors_cjs = require_runtime.__toESM(src_external_yoctocolors_
 * Apply a color to text using yoctocolors. Handles both named colors and RGB
 * tuples.
 */
-/*@__NO_SIDE_EFFECTS__*/
 function applyColor(text, color, colors) {
-	if (typeof color === "string") return colors[color](text);
+	if (typeof color === "string") {
+		const formatter = colors[color];
+		return formatter ? formatter(text) : text;
+	}
 	const { 0: r, 1: g, 2: b } = color;
 	return `\u001B[38;2;${r};${g};${b}m${text}\u001B[39m`;
 }
 /**
 * Get the yoctocolors module for terminal colors.
 */
-/*@__NO_SIDE_EFFECTS__*/
 function getYoctocolors() {
 	return src_external_yoctocolors_cjs.default;
 }

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

@@ -0,0 +1,132 @@
+/**
+ * @file Free-function bodies for the `Logger` methods that are thin, chainable
+ *   mirrors of the underlying `node:console` API (`assert`, `count`, `dir`,
+ *   `dirxml`, `table`, `time`, `timeEnd`, `timeLog`, `trace`). Each takes the
+ *   calling logger plus its already-resolved `node:console` instance, delegates
+ *   to the matching console method, updates the shared blank-line / call-count
+ *   tracking via the exported logger symbols, and returns the logger for
+ *   chaining. Pulling these out of `./node` keeps the `Logger` class body under
+ *   the file-size cap while preserving the per-method documentation here. The
+ *   class retains one-line delegators that supply `this` and
+ *   `this.#getConsole()`.
+ */
+import { incLogCallCountSymbol, lastWasBlankSymbol } from './symbols';
+/**
+ * The slice of `node:console` the mirror methods call into, plus the internal
+ * `_stderr` / `_stdout` slots reached elsewhere. Modeled structurally so the
+ * cast from the lazily-built per-instance Console stays explicit.
+ */
+export type ConsoleLike = typeof console & Record<string, unknown>;
+/**
+ * The slice of `Logger` the mirror methods need: the two symbol-keyed tracking
+ * methods. Typed structurally to avoid a circular import with `./node`.
+ */
+export interface LoggerTrackable {
+    [incLogCallCountSymbol](): LoggerTrackable;
+    [lastWasBlankSymbol](value: unknown, stream?: 'stderr' | 'stdout'): unknown;
+}
+/**
+ * Logs an assertion failure message if the value is falsy.
+ *
+ * Works like `console.assert()` but returns the logger for chaining. If the
+ * value is truthy, nothing is logged. If falsy, logs an error message with an
+ * assertion failure.
+ *
+ * @param logger - The calling logger instance.
+ * @param con - The logger's resolved console instance.
+ * @param value - The value to test.
+ * @param message - Optional message and additional arguments to log.
+ */
+export declare function assertMethod<T extends LoggerTrackable>(logger: T, con: ConsoleLike, value: unknown, message: unknown[]): T;
+/**
+ * Increments and logs a counter for the given label.
+ *
+ * Each unique label maintains its own counter. Works like `console.count()`.
+ *
+ * @param logger - The calling logger instance.
+ * @param con - The logger's resolved console instance.
+ * @param label - Optional label for the counter (defaults to 'default').
+ */
+export declare function countMethod<T extends LoggerTrackable>(logger: T, con: ConsoleLike, label?: string | undefined): T;
+/**
+ * Displays an object's properties in a formatted way.
+ *
+ * Works like `console.dir()` with customizable options for depth, colors, etc.
+ * Useful for inspecting complex objects.
+ *
+ * @param logger - The calling logger instance.
+ * @param con - The logger's resolved console instance.
+ * @param obj - The object to display.
+ * @param options - Optional formatting options (Node.js inspect options).
+ */
+export declare function dirMethod<T extends LoggerTrackable>(logger: T, con: ConsoleLike, obj: unknown, options?: unknown | undefined): T;
+/**
+ * Displays data as XML/HTML in a formatted way.
+ *
+ * Works like `console.dirxml()`. In Node.js, behaves the same as `dir()`.
+ *
+ * @param logger - The calling logger instance.
+ * @param con - The logger's resolved console instance.
+ * @param data - The data to display.
+ */
+export declare function dirxmlMethod<T extends LoggerTrackable>(logger: T, con: ConsoleLike, data: unknown[]): T;
+/**
+ * Displays data in a table format.
+ *
+ * Works like `console.table()`. Accepts arrays of objects or objects with
+ * nested objects. Optionally specify which properties to include in the table.
+ *
+ * @param logger - The calling logger instance.
+ * @param con - The logger's resolved console instance.
+ * @param tabularData - The data to display as a table.
+ * @param properties - Optional array of property names to include.
+ */
+export declare function tableMethod<T extends LoggerTrackable>(logger: T, con: ConsoleLike, tabularData: unknown, properties?: readonly string[] | undefined): T;
+/**
+ * Ends a timer and logs the elapsed time.
+ *
+ * Logs the duration since `console.time()` or `logger.time()` was called with
+ * the same label. The timer is stopped and removed.
+ *
+ * @param logger - The calling logger instance.
+ * @param con - The logger's resolved console instance.
+ * @param label - Optional label for the timer (defaults to 'default').
+ */
+export declare function timeEndMethod<T extends LoggerTrackable>(logger: T, con: ConsoleLike, label?: string | undefined): T;
+/**
+ * Logs the current value of a timer without stopping it.
+ *
+ * Logs the duration since `console.time()` was called with the same label, but
+ * keeps the timer running. Can include additional data to log alongside the
+ * time.
+ *
+ * @param logger - The calling logger instance.
+ * @param con - The logger's resolved console instance.
+ * @param label - Optional label for the timer (defaults to 'default').
+ * @param data - Additional data to log with the time.
+ */
+export declare function timeLogMethod<T extends LoggerTrackable>(logger: T, con: ConsoleLike, label: string | undefined, data: unknown[]): T;
+/**
+ * Starts a timer for measuring elapsed time.
+ *
+ * Creates a timer with the given label. Use `timeEnd()` with the same label to
+ * stop the timer and log the elapsed time, or use `timeLog()` to check the time
+ * without stopping the timer.
+ *
+ * @param logger - The calling logger instance.
+ * @param con - The logger's resolved console instance.
+ * @param label - Optional label for the timer (defaults to 'default').
+ */
+export declare function timeMethod<T extends LoggerTrackable>(logger: T, con: ConsoleLike, label?: string | undefined): T;
+/**
+ * Logs a stack trace to the console.
+ *
+ * Works like `console.trace()`. Shows the call stack leading to where this
+ * method was called. Useful for debugging.
+ *
+ * @param logger - The calling logger instance.
+ * @param con - The logger's resolved console instance.
+ * @param message - Optional message to display with the trace.
+ * @param args - Additional arguments to log.
+ */
+export declare function traceMethod<T extends LoggerTrackable>(logger: T, con: ConsoleLike, message: unknown | undefined, args: unknown[]): T;

package/dist/logger/console-methods.js

@@ -0,0 +1,169 @@
+"use strict";
+/* Socket Lib - Built with rolldown */
+Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
+const require_logger_symbols = require('./symbols.js');
+
+//#region src/logger/console-methods.ts
+/**
+* @file Free-function bodies for the `Logger` methods that are thin, chainable
+*   mirrors of the underlying `node:console` API (`assert`, `count`, `dir`,
+*   `dirxml`, `table`, `time`, `timeEnd`, `timeLog`, `trace`). Each takes the
+*   calling logger plus its already-resolved `node:console` instance, delegates
+*   to the matching console method, updates the shared blank-line / call-count
+*   tracking via the exported logger symbols, and returns the logger for
+*   chaining. Pulling these out of `./node` keeps the `Logger` class body under
+*   the file-size cap while preserving the per-method documentation here. The
+*   class retains one-line delegators that supply `this` and
+*   `this.#getConsole()`.
+*/
+/**
+* Logs an assertion failure message if the value is falsy.
+*
+* Works like `console.assert()` but returns the logger for chaining. If the
+* value is truthy, nothing is logged. If falsy, logs an error message with an
+* assertion failure.
+*
+* @param logger - The calling logger instance.
+* @param con - The logger's resolved console instance.
+* @param value - The value to test.
+* @param message - Optional message and additional arguments to log.
+*/
+function assertMethod(logger, con, value, message) {
+	con.assert(value, message[0], ...message.slice(1));
+	logger[require_logger_symbols.lastWasBlankSymbol](false);
+	return value ? logger : logger[require_logger_symbols.incLogCallCountSymbol]();
+}
+/**
+* Increments and logs a counter for the given label.
+*
+* Each unique label maintains its own counter. Works like `console.count()`.
+*
+* @param logger - The calling logger instance.
+* @param con - The logger's resolved console instance.
+* @param label - Optional label for the counter (defaults to 'default').
+*/
+function countMethod(logger, con, label) {
+	con.count(label);
+	logger[require_logger_symbols.lastWasBlankSymbol](false);
+	return logger[require_logger_symbols.incLogCallCountSymbol]();
+}
+/**
+* Displays an object's properties in a formatted way.
+*
+* Works like `console.dir()` with customizable options for depth, colors, etc.
+* Useful for inspecting complex objects.
+*
+* @param logger - The calling logger instance.
+* @param con - The logger's resolved console instance.
+* @param obj - The object to display.
+* @param options - Optional formatting options (Node.js inspect options).
+*/
+function dirMethod(logger, con, obj, options) {
+	con.dir(obj, options);
+	logger[require_logger_symbols.lastWasBlankSymbol](false);
+	return logger[require_logger_symbols.incLogCallCountSymbol]();
+}
+/**
+* Displays data as XML/HTML in a formatted way.
+*
+* Works like `console.dirxml()`. In Node.js, behaves the same as `dir()`.
+*
+* @param logger - The calling logger instance.
+* @param con - The logger's resolved console instance.
+* @param data - The data to display.
+*/
+function dirxmlMethod(logger, con, data) {
+	con.dirxml(data);
+	logger[require_logger_symbols.lastWasBlankSymbol](false);
+	return logger[require_logger_symbols.incLogCallCountSymbol]();
+}
+/**
+* Displays data in a table format.
+*
+* Works like `console.table()`. Accepts arrays of objects or objects with
+* nested objects. Optionally specify which properties to include in the table.
+*
+* @param logger - The calling logger instance.
+* @param con - The logger's resolved console instance.
+* @param tabularData - The data to display as a table.
+* @param properties - Optional array of property names to include.
+*/
+function tableMethod(logger, con, tabularData, properties) {
+	con.table(tabularData, properties);
+	logger[require_logger_symbols.lastWasBlankSymbol](false);
+	return logger[require_logger_symbols.incLogCallCountSymbol]();
+}
+/**
+* Ends a timer and logs the elapsed time.
+*
+* Logs the duration since `console.time()` or `logger.time()` was called with
+* the same label. The timer is stopped and removed.
+*
+* @param logger - The calling logger instance.
+* @param con - The logger's resolved console instance.
+* @param label - Optional label for the timer (defaults to 'default').
+*/
+function timeEndMethod(logger, con, label) {
+	con.timeEnd(label);
+	logger[require_logger_symbols.lastWasBlankSymbol](false);
+	return logger[require_logger_symbols.incLogCallCountSymbol]();
+}
+/**
+* Logs the current value of a timer without stopping it.
+*
+* Logs the duration since `console.time()` was called with the same label, but
+* keeps the timer running. Can include additional data to log alongside the
+* time.
+*
+* @param logger - The calling logger instance.
+* @param con - The logger's resolved console instance.
+* @param label - Optional label for the timer (defaults to 'default').
+* @param data - Additional data to log with the time.
+*/
+function timeLogMethod(logger, con, label, data) {
+	con.timeLog(label, ...data);
+	logger[require_logger_symbols.lastWasBlankSymbol](false);
+	return logger[require_logger_symbols.incLogCallCountSymbol]();
+}
+/**
+* Starts a timer for measuring elapsed time.
+*
+* Creates a timer with the given label. Use `timeEnd()` with the same label to
+* stop the timer and log the elapsed time, or use `timeLog()` to check the time
+* without stopping the timer.
+*
+* @param logger - The calling logger instance.
+* @param con - The logger's resolved console instance.
+* @param label - Optional label for the timer (defaults to 'default').
+*/
+function timeMethod(logger, con, label) {
+	con.time(label);
+	return logger;
+}
+/**
+* Logs a stack trace to the console.
+*
+* Works like `console.trace()`. Shows the call stack leading to where this
+* method was called. Useful for debugging.
+*
+* @param logger - The calling logger instance.
+* @param con - The logger's resolved console instance.
+* @param message - Optional message to display with the trace.
+* @param args - Additional arguments to log.
+*/
+function traceMethod(logger, con, message, args) {
+	con.trace(message, ...args);
+	logger[require_logger_symbols.lastWasBlankSymbol](false);
+	return logger[require_logger_symbols.incLogCallCountSymbol]();
+}
+
+//#endregion
+exports.assertMethod = assertMethod;
+exports.countMethod = countMethod;
+exports.dirMethod = dirMethod;
+exports.dirxmlMethod = dirxmlMethod;
+exports.tableMethod = tableMethod;
+exports.timeEndMethod = timeEndMethod;
+exports.timeLogMethod = timeLogMethod;
+exports.timeMethod = timeMethod;
+exports.traceMethod = traceMethod;

package/dist/logger/console.d.ts

@@ -19,6 +19,7 @@
  *     `ensurePrototypeInitialized` actually runs, both modules are fully
  *     evaluated. Same pattern as `fs/path-cache` ↔ `fs/_internal`.
  */
+import { Logger } from './node';
 /**
  * Construct a new Console instance.
  */
@@ -31,3 +32,14 @@ export declare function constructConsole(...args: unknown[]): Console;
  * ready.
  */
 export declare function ensurePrototypeInitialized(): void;
+/**
+ * Resolve (and lazily construct + cache) the per-instance `Console` for a
+ * logger. Ensures the prototype is initialized, then returns the cached Console
+ * from the `privateConsole` WeakMap, building one from the stored constructor
+ * args (or the default stdout/stderr pair) on first access. This lazy path is
+ * what lets the logger be imported during early Node.js bootstrap before stdout
+ * is ready, avoiding `ERR_CONSOLE_WRITABLE_STREAM`.
+ *
+ * @param logger - The logger whose Console to resolve.
+ */
+export declare function resolveConsole(logger: Logger): typeof console & Record<string, unknown>;

package/dist/logger/console.js

@@ -32,16 +32,15 @@ node_process = require_runtime.__toESM(node_process);
 *     `ensurePrototypeInitialized` actually runs, both modules are fully
 *     evaluated. Same pattern as `fs/path-cache` ↔ `fs/_internal`.
 */
-let _Console;
-let _prototypeInitialized = false;
+let cachedConsole;
+let prototypeInitialized = false;
 /**
 * Construct a new Console instance.
 */
-/*@__NO_SIDE_EFFECTS__*/
 function constructConsole(...args) {
 	/* c8 ignore next - Lazy-init second-call branch; module-singleton. */
-	if (_Console === void 0) _Console = (/* @__PURE__ */ require("node:console")).Console;
-	return require_primordials_reflect.ReflectConstruct(_Console, args);
+	if (cachedConsole === void 0) cachedConsole = (/* @__PURE__ */ require("node:console")).Console;
+	return require_primordials_reflect.ReflectConstruct(cachedConsole, args);
 }
 /**
 * Lazily add dynamic console methods to Logger prototype.
@@ -51,8 +50,8 @@ function constructConsole(...args) {
 * ready.
 */
 function ensurePrototypeInitialized() {
-	if (_prototypeInitialized) return;
-	_prototypeInitialized = true;
+	if (prototypeInitialized) return;
+	prototypeInitialized = true;
 	const entries = [[require_logger_symbols.getKGroupIndentationWidthSymbol(), {
 		...require_logger__internal.consolePropAttributes,
 		value: 2
@@ -68,9 +67,9 @@ function ensurePrototypeInitialized() {
 			if (con === void 0) {
 				const ctorArgs = require_logger__internal.privateConstructorArgs.get(this) ?? [];
 				require_logger__internal.privateConstructorArgs.delete(this);
-				if (ctorArgs.length) con = /* @__PURE__ */ constructConsole(...ctorArgs);
+				if (ctorArgs.length) con = constructConsole(...ctorArgs);
 				else {
-					con = /* @__PURE__ */ constructConsole({
+					con = constructConsole({
 						stdout: node_process.default.stdout,
 						stderr: node_process.default.stderr
 					});
@@ -78,7 +77,6 @@ function ensurePrototypeInitialized() {
 				}
 				require_logger__internal.privateConsole.set(this, con);
 			}
-			/* c8 ignore stop */
 			const result = con[key](...args);
 			/* c8 ignore next */
 			return result === void 0 || result === con ? this : result;
@@ -90,7 +88,40 @@ function ensurePrototypeInitialized() {
 	}
 	require_primordials_object.ObjectDefineProperties(require_logger_node.Logger.prototype, require_primordials_object.ObjectFromEntries(entries));
 }
+/**
+* Resolve (and lazily construct + cache) the per-instance `Console` for a
+* logger. Ensures the prototype is initialized, then returns the cached Console
+* from the `privateConsole` WeakMap, building one from the stored constructor
+* args (or the default stdout/stderr pair) on first access. This lazy path is
+* what lets the logger be imported during early Node.js bootstrap before stdout
+* is ready, avoiding `ERR_CONSOLE_WRITABLE_STREAM`.
+*
+* @param logger - The logger whose Console to resolve.
+*/
+function resolveConsole(logger) {
+	ensurePrototypeInitialized();
+	let con = require_logger__internal.privateConsole.get(logger);
+	/* c8 ignore start - ctorArgs.length-truthy fires when caller seeded
+	constructor args; both arms are exercised across tests but not always
+	in the same run. */
+	if (!con) {
+		const ctorArgs = require_logger__internal.privateConstructorArgs.get(logger) ?? [];
+		if (ctorArgs.length) con = constructConsole(...ctorArgs);
+		else {
+			con = constructConsole({
+				stdout: node_process.default.stdout,
+				stderr: node_process.default.stderr
+			});
+			for (const { 0: key, 1: method } of require_logger__internal.boundConsoleEntries) con[key] = method;
+		}
+		require_logger__internal.privateConsole.set(logger, con);
+		require_logger__internal.privateConstructorArgs.delete(logger);
+	}
+	/* c8 ignore stop */
+	return con;
+}
 
 //#endregion
 exports.constructConsole = constructConsole;
-exports.ensurePrototypeInitialized = ensurePrototypeInitialized;
+exports.ensurePrototypeInitialized = ensurePrototypeInitialized;
+exports.resolveConsole = resolveConsole;

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

@@ -0,0 +1,81 @@
+/**
+ * @file Free-function bodies for the `Logger` indentation-domain methods
+ *   (`indent`, `dedent`, `resetIndent`, `group`, `groupCollapsed`, `groupEnd`).
+ *   Indentation is tracked at the prefix layer (a per-stream string of spaces)
+ *   rather than via `node:console`'s frozen `Symbol(kGroupIndent)`, so these
+ *   helpers read and write that prefix through a small accessor context handed
+ *   in by the calling `Logger`. Pulling these out of `./node` keeps the
+ *   `Logger` class body under the file-size cap; the class retains one-line
+ *   delegators that build the context from its private state.
+ */
+import type { LoggerTrackable } from './console-methods';
+/**
+ * The slice of `Logger` the indentation helpers need: the bound-stream marker
+ * (`undefined` on the root logger, `'stderr'` / `'stdout'` on a stream-bound
+ * instance) plus per-stream indent prefix read / write accessors. Modeled
+ * structurally to avoid a circular import with `./node`; the class supplies
+ * closures over its private `#getIndent` / `#setIndent`.
+ */
+export interface IndentContext {
+    boundStream: 'stderr' | 'stdout' | undefined;
+    getIndent(stream: 'stderr' | 'stdout'): string;
+    setIndent(stream: 'stderr' | 'stdout', value: string): void;
+}
+/**
+ * Decrease the indentation prefix by `spaces`.
+ *
+ * On the root logger (`boundStream` undefined) both streams shrink; on a
+ * stream-bound logger only the bound stream shrinks. Returns the logger for
+ * chaining.
+ *
+ * @param logger - The calling logger instance.
+ * @param ctx - The logger's indentation accessor context.
+ * @param spaces - Number of spaces to remove (default 2).
+ */
+export declare function dedentMethod<T extends LoggerTrackable>(logger: T, ctx: IndentContext, spaces: number): T;
+/**
+ * End the current log group and decrease indentation by the group-indent width.
+ *
+ * Call once per `groupMethod` / `groupCollapsed`. Returns the logger for
+ * chaining.
+ *
+ * @param logger - The calling logger instance.
+ */
+export declare function groupEndMethod<T extends {
+    dedent(spaces?: number): T;
+}>(logger: T): T;
+/**
+ * Start a new indented log group.
+ *
+ * A provided label is logged via the logger's own `log` before indentation
+ * increases by the group-indent width (default 2). Groups nest; close with
+ * `groupEndMethod`. Returns the logger for chaining.
+ *
+ * @param logger - The calling logger instance.
+ * @param label - Optional label to display before the group.
+ */
+export declare function groupMethod<T extends LoggerTrackable & {
+    indent(spaces?: number): T;
+    log(...args: unknown[]): T;
+}>(logger: T, label: unknown[]): T;
+/**
+ * Increase the indentation prefix by `spaces`, capped at `maxIndentation`.
+ *
+ * On the root logger both streams grow; on a stream-bound logger only the bound
+ * stream grows. Returns the logger for chaining.
+ *
+ * @param logger - The calling logger instance.
+ * @param ctx - The logger's indentation accessor context.
+ * @param spaces - Number of spaces to add (default 2).
+ */
+export declare function indentMethod<T extends LoggerTrackable>(logger: T, ctx: IndentContext, spaces: number): T;
+/**
+ * Reset all indentation to zero.
+ *
+ * On the root logger both streams reset; on a stream-bound logger only the
+ * bound stream resets. Returns the logger for chaining.
+ *
+ * @param logger - The calling logger instance.
+ * @param ctx - The logger's indentation accessor context.
+ */
+export declare function resetIndentMethod<T extends LoggerTrackable>(logger: T, ctx: IndentContext): T;