@kikiutils/shared 18.3.0 → 20.0.0

package/dist/logger/_internals/levels.d.ts

@@ -0,0 +1,54 @@
+import { LoggerMethod } from "../types.js";
+export declare const loggerMethods: {
+  readonly debug: {
+    readonly ansiColor: "36";
+    readonly consoleMethod: "debug";
+    readonly cssColor: "#0891b2";
+    readonly icon: "⚙";
+    readonly severity: 20;
+  };
+  readonly error: {
+    readonly ansiColor: "31";
+    readonly consoleMethod: "error";
+    readonly cssColor: "#dc2626";
+    readonly icon: "✖";
+    readonly severity: 50;
+  };
+  readonly fatal: {
+    readonly ansiColor: "31";
+    readonly consoleMethod: "error";
+    readonly cssColor: "#dc2626";
+    readonly icon: "✖";
+    readonly severity: 60;
+  };
+  readonly info: {
+    readonly ansiColor: "36";
+    readonly consoleMethod: "info";
+    readonly cssColor: "#0891b2";
+    readonly icon: "ℹ";
+    readonly severity: 30;
+  };
+  readonly success: {
+    readonly ansiColor: "32";
+    readonly consoleMethod: "info";
+    readonly cssColor: "#16a34a";
+    readonly icon: "✔";
+    readonly severity: 30;
+  };
+  readonly trace: {
+    readonly ansiColor: "90";
+    readonly consoleMethod: "debug";
+    readonly cssColor: "#808080";
+    readonly icon: "·";
+    readonly severity: 10;
+  };
+  readonly warn: {
+    readonly ansiColor: "33";
+    readonly consoleMethod: "warn";
+    readonly cssColor: "#ca8a04";
+    readonly icon: "⚠";
+    readonly severity: 40;
+  };
+};
+export declare function getLoggerStreamName(type: LoggerMethod): 'stderr' | 'stdout';
+//# sourceMappingURL=levels.d.ts.map

package/dist/logger/_internals/levels.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"levels.d.ts","names":[],"sources":["../../../src/logger/_internals/levels.ts"],"mappings":";qBAGa;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;wBAqDG,oBAAoB,MAAM"}

package/dist/logger/_internals/levels.js

@@ -0,0 +1,59 @@
+// src/logger/_internals/levels.ts
+const loggerMethods = {
+	debug: {
+		ansiColor: "36",
+		consoleMethod: "debug",
+		cssColor: "#0891b2",
+		icon: "⚙",
+		severity: 20
+	},
+	error: {
+		ansiColor: "31",
+		consoleMethod: "error",
+		cssColor: "#dc2626",
+		icon: "✖",
+		severity: 50
+	},
+	fatal: {
+		ansiColor: "31",
+		consoleMethod: "error",
+		cssColor: "#dc2626",
+		icon: "✖",
+		severity: 60
+	},
+	info: {
+		ansiColor: "36",
+		consoleMethod: "info",
+		cssColor: "#0891b2",
+		icon: "ℹ",
+		severity: 30
+	},
+	success: {
+		ansiColor: "32",
+		consoleMethod: "info",
+		cssColor: "#16a34a",
+		icon: "✔",
+		severity: 30
+	},
+	trace: {
+		ansiColor: "90",
+		consoleMethod: "debug",
+		cssColor: "#808080",
+		icon: "·",
+		severity: 10
+	},
+	warn: {
+		ansiColor: "33",
+		consoleMethod: "warn",
+		cssColor: "#ca8a04",
+		icon: "⚠",
+		severity: 40
+	}
+};
+function getLoggerStreamName(type) {
+	const method = loggerMethods[type].consoleMethod;
+	return method === "warn" || method === "error" ? "stderr" : "stdout";
+}
+export { getLoggerStreamName, loggerMethods };
+
+//# sourceMappingURL=levels.js.map

package/dist/logger/_internals/levels.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"levels.js","names":[],"sources":["../../../src/logger/_internals/levels.ts"],"sourcesContent":["import type { LoggerMethod } from '../types';\n\n// Constants/Variables\nexport const loggerMethods = {\n    debug: {\n        ansiColor: '36',\n        consoleMethod: 'debug',\n        cssColor: '#0891b2',\n        icon: '⚙',\n        severity: 20,\n    },\n    error: {\n        ansiColor: '31',\n        consoleMethod: 'error',\n        cssColor: '#dc2626',\n        icon: '✖',\n        severity: 50,\n    },\n    fatal: {\n        ansiColor: '31',\n        consoleMethod: 'error',\n        cssColor: '#dc2626',\n        icon: '✖',\n        severity: 60,\n    },\n    info: {\n        ansiColor: '36',\n        consoleMethod: 'info',\n        cssColor: '#0891b2',\n        icon: 'ℹ',\n        severity: 30,\n    },\n    success: {\n        ansiColor: '32',\n        consoleMethod: 'info',\n        cssColor: '#16a34a',\n        icon: '✔',\n        severity: 30,\n    },\n    trace: {\n        ansiColor: '90',\n        consoleMethod: 'debug',\n        cssColor: '#808080',\n        icon: '·',\n        severity: 10,\n    },\n    warn: {\n        ansiColor: '33',\n        consoleMethod: 'warn',\n        cssColor: '#ca8a04',\n        icon: '⚠',\n        severity: 40,\n    },\n} as const;\n\n// Functions\nexport function getLoggerStreamName(type: LoggerMethod): 'stderr' | 'stdout' {\n    const method = loggerMethods[type].consoleMethod;\n    return method === 'warn' || method === 'error' ? 'stderr' : 'stdout';\n}\n"],"mappings":";AAGA,MAAa,gBAAgB;CACzB,OAAO;EACH,WAAW;EACX,eAAe;EACf,UAAU;EACV,MAAM;EACN,UAAU;CACd;CACA,OAAO;EACH,WAAW;EACX,eAAe;EACf,UAAU;EACV,MAAM;EACN,UAAU;CACd;CACA,OAAO;EACH,WAAW;EACX,eAAe;EACf,UAAU;EACV,MAAM;EACN,UAAU;CACd;CACA,MAAM;EACF,WAAW;EACX,eAAe;EACf,UAAU;EACV,MAAM;EACN,UAAU;CACd;CACA,SAAS;EACL,WAAW;EACX,eAAe;EACf,UAAU;EACV,MAAM;EACN,UAAU;CACd;CACA,OAAO;EACH,WAAW;EACX,eAAe;EACf,UAAU;EACV,MAAM;EACN,UAAU;CACd;CACA,MAAM;EACF,WAAW;EACX,eAAe;EACf,UAAU;EACV,MAAM;EACN,UAAU;CACd;AACJ;AAGA,SAAgB,oBAAoB,MAAyC;CACzE,MAAM,SAAS,cAAc,KAAK,CAAC;CACnC,OAAO,WAAW,UAAU,WAAW,UAAU,WAAW;AAChE"}

package/dist/logger/_internals/logger.d.ts

@@ -0,0 +1,12 @@
+import { Logger, LoggerDiagnostic, LoggerOptions } from "../types.js";
+import { LoggerRecord } from "./types.js";
+interface LoggerHooks {
+  /** A non-throwing reporter created by createDiagnosticReporter. */
+  report: (event: LoggerDiagnostic) => void;
+  write: (record: LoggerRecord) => Promise<void> | void;
+}
+/** A non-recursive, rate-limited diagnostic boundary shared by server and browser adapters. */
+export declare function createDiagnosticReporter(onError?: (event: Readonly<LoggerDiagnostic>) => void, fallback?: (message: string) => void): (event: LoggerDiagnostic) => void;
+export declare function createLoggerCore(options: LoggerOptions, hooks: LoggerHooks): Readonly<Logger>;
+export {};
+//# sourceMappingURL=logger.d.ts.map

package/dist/logger/_internals/logger.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"logger.d.ts","names":[],"sources":["../../../src/logger/_internals/logger.ts"],"mappings":";;UAWU;;EAEN,SAAS,OAAO;EAChB,QAAQ,QAAQ,iBAAiB;;;wBAkBrB,yBACZ,WAAW,OAAO,SAAS,4BAC3B,YAAY,4BACZ,OAAO;wBAkEK,iBAAiB,SAAS,eAAe,OAAO,cAAc,SAAS"}

package/dist/logger/_internals/logger.js

@@ -0,0 +1,147 @@
+import { loggerMethods } from "./levels.js";
+// src/logger/_internals/logger.ts
+const booleanPresentationKeys = [
+	"console",
+	"icons",
+	"timestamp"
+];
+const stringPresentationKeys = ["prefix", "suffix"];
+/** A non-recursive, rate-limited diagnostic boundary shared by server and browser adapters. */
+function createDiagnosticReporter(onError, fallback) {
+	let reporting = false;
+	let callbackPending = false;
+	const stateByType = /* @__PURE__ */ new Map();
+	return (event) => {
+		if (reporting) return;
+		try {
+			const now = Date.now();
+			const state = stateByType.get(event.type);
+			if (state && now - state.lastReportedAt < 1e3) {
+				state.suppressedCount++;
+				return;
+			}
+			reporting = true;
+			const suppressedCount = state?.suppressedCount ?? 0;
+			if (suppressedCount) event = {
+				...event,
+				suppressedCount
+			};
+			stateByType.set(event.type, {
+				lastReportedAt: now,
+				suppressedCount: 0
+			});
+			try {
+				const summary = suppressedCount ? ` (${suppressedCount} similar diagnostics suppressed)` : "";
+				fallback?.(`[logger] ${event.message}${summary}\n`);
+			} catch {}
+			if (!callbackPending) try {
+				callbackPending = true;
+				const result = onError?.(Object.freeze({ ...event }));
+				if (result !== null && (typeof result === "object" || typeof result === "function")) Promise.resolve(result).then(() => {
+					callbackPending = false;
+				}, () => {
+					callbackPending = false;
+				});
+				else callbackPending = false;
+			} catch {
+				callbackPending = false;
+			}
+		} catch {} finally {
+			reporting = false;
+		}
+	};
+}
+function createLoggerCore(options, hooks) {
+	validateLevel(options.level);
+	validatePresentation(options);
+	if (options.onError !== void 0 && typeof options.onError !== "function") throw new TypeError("Logger onError must be a function");
+	const presentation = {
+		console: options.console ?? true,
+		icons: options.icons ?? true,
+		prefix: options.prefix ?? "",
+		suffix: options.suffix ?? "",
+		timestamp: options.timestamp ?? true
+	};
+	const { report } = hooks;
+	let override = options.level === "env" ? void 0 : options.level;
+	let previousEnvironment;
+	let currentLevel = override ?? "info";
+	let environmentRead = false;
+	function refreshLevel() {
+		if (override !== void 0) return;
+		const input = readEnvironmentLevel();
+		if (environmentRead && input === previousEnvironment) return;
+		environmentRead = true;
+		previousEnvironment = input;
+		const normalized = input?.trim().toLowerCase() || void 0;
+		currentLevel = isLevel(normalized) ? normalized : "info";
+		if (normalized !== void 0 && !isLevel(normalized)) report({
+			message: "Invalid LOG_LEVEL; using info",
+			type: "invalid-level"
+		});
+	}
+	const logger = {
+		configure(configuration) {
+			validatePresentation(configuration);
+			for (const name of booleanPresentationKeys) {
+				const value = configuration[name];
+				if (value !== void 0) presentation[name] = value;
+			}
+			for (const name of stringPresentationKeys) {
+				const value = configuration[name];
+				if (value !== void 0) presentation[name] = value;
+			}
+		},
+		isLevelEnabled(level) {
+			if (level !== "success" && !isLevel(level)) throw new TypeError("Invalid logger level");
+			refreshLevel();
+			return level !== "silent" && getLevelSeverity(level) >= getLevelSeverity(currentLevel);
+		},
+		setLevel(level) {
+			validateLevel(level);
+			if (level === void 0) throw new TypeError("Invalid logger level");
+			override = level === "env" ? void 0 : level;
+			environmentRead = false;
+			if (override !== void 0) currentLevel = override;
+			else refreshLevel();
+		}
+	};
+	for (const type of Object.keys(loggerMethods)) logger[type] = async (...args) => {
+		try {
+			refreshLevel();
+			if (loggerMethods[type].severity < getLevelSeverity(currentLevel)) return;
+			await hooks.write({
+				...presentation,
+				args,
+				date: /* @__PURE__ */ new Date(),
+				type
+			});
+		} catch (error) {
+			report({
+				error,
+				message: "Logger output failed",
+				type: "format"
+			});
+		}
+	};
+	return Object.freeze(logger);
+}
+function getLevelSeverity(level) {
+	return level === "silent" ? Number.POSITIVE_INFINITY : loggerMethods[level].severity;
+}
+function isLevel(value) {
+	return typeof value === "string" && (value === "silent" || value !== "success" && Object.hasOwn(loggerMethods, value));
+}
+function readEnvironmentLevel() {
+	return globalThis.process?.env?.LOG_LEVEL;
+}
+function validateLevel(value) {
+	if (value !== void 0 && value !== "env" && !isLevel(value)) throw new TypeError("Invalid logger level");
+}
+function validatePresentation(options) {
+	for (const name of booleanPresentationKeys) if (options[name] !== void 0 && typeof options[name] !== "boolean") throw new TypeError(`Logger ${name} must be a boolean`);
+	for (const name of stringPresentationKeys) if (options[name] !== void 0 && typeof options[name] !== "string") throw new TypeError(`Logger ${name} must be a string`);
+}
+export { createDiagnosticReporter, createLoggerCore };
+
+//# sourceMappingURL=logger.js.map

package/dist/logger/_internals/logger.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"logger.js","names":[],"sources":["../../../src/logger/_internals/logger.ts"],"sourcesContent":["import type {\n    Logger,\n    LoggerDiagnostic,\n    LoggerLevel,\n    LoggerMethod,\n    LoggerOptions,\n} from '../types';\n\nimport { loggerMethods } from './levels';\nimport type { LoggerRecord } from './types';\n\ninterface LoggerHooks {\n    /** A non-throwing reporter created by createDiagnosticReporter. */\n    report: (event: LoggerDiagnostic) => void;\n    write: (record: LoggerRecord) => Promise<void> | void;\n}\n\n// Constants/Variables\nconst booleanPresentationKeys = [\n    'console',\n    'icons',\n    'timestamp',\n] as const;\n\nconst stringPresentationKeys = [\n    'prefix',\n    'suffix',\n] as const;\n\n// Functions\n\n/** A non-recursive, rate-limited diagnostic boundary shared by server and browser adapters. */\nexport function createDiagnosticReporter(\n    onError?: (event: Readonly<LoggerDiagnostic>) => void,\n    fallback?: (message: string) => void,\n): (event: LoggerDiagnostic) => void {\n    let reporting = false;\n    let callbackPending = false;\n    const stateByType = new Map<LoggerDiagnostic['type'], { lastReportedAt: number; suppressedCount: number }>();\n\n    return (event) => {\n        if (reporting) return;\n        try {\n            const now = Date.now();\n            const state = stateByType.get(event.type);\n            if (state && now - state.lastReportedAt < 1000) {\n                state.suppressedCount++;\n                return;\n            }\n\n            reporting = true;\n            const suppressedCount = state?.suppressedCount ?? 0;\n            if (suppressedCount) {\n                event = {\n                    ...event,\n                    suppressedCount,\n                };\n            }\n\n            stateByType.set(\n                event.type,\n                {\n                    lastReportedAt: now,\n                    suppressedCount: 0,\n                },\n            );\n\n            try {\n                const summary = suppressedCount ? ` (${suppressedCount} similar diagnostics suppressed)` : '';\n                fallback?.(`[logger] ${event.message}${summary}\\n`);\n            } catch {\n                // Diagnostics must never re-enter the normal logging pipeline.\n            }\n\n            if (!callbackPending) {\n                try {\n                    callbackPending = true;\n                    const result: unknown = onError?.(Object.freeze({ ...event }));\n                    if (result !== null && (typeof result === 'object' || typeof result === 'function')) {\n                        void Promise.resolve(result).then(\n                            () => {\n                                callbackPending = false;\n                            },\n                            () => {\n                                callbackPending = false;\n                            },\n                        );\n                    } else {\n                        callbackPending = false;\n                    }\n                } catch {\n                    callbackPending = false;\n                    // User diagnostic callbacks have the same non-throwing boundary.\n                }\n            }\n        } catch { /* Diagnostics must never escape into the logging pipeline. */ } finally {\n            reporting = false;\n        }\n    };\n}\n\nexport function createLoggerCore(options: LoggerOptions, hooks: LoggerHooks): Readonly<Logger> {\n    validateLevel(options.level);\n    validatePresentation(options);\n    if (options.onError !== undefined && typeof options.onError !== 'function') {\n        throw new TypeError('Logger onError must be a function');\n    }\n\n    const presentation = {\n        console: options.console ?? true,\n        icons: options.icons ?? true,\n        prefix: options.prefix ?? '',\n        suffix: options.suffix ?? '',\n        timestamp: options.timestamp ?? true,\n    };\n\n    const { report } = hooks;\n\n    let override = options.level === 'env' ? undefined : options.level;\n    let previousEnvironment: string | undefined;\n    let currentLevel: LoggerLevel = override ?? 'info';\n    let environmentRead = false;\n\n    function refreshLevel() {\n        if (override !== undefined) return;\n        const input = readEnvironmentLevel();\n        if (environmentRead && input === previousEnvironment) return;\n        environmentRead = true;\n        previousEnvironment = input;\n        const normalized = input?.trim().toLowerCase() || undefined;\n        currentLevel = isLevel(normalized) ? normalized : 'info';\n        if (normalized !== undefined && !isLevel(normalized)) {\n            report({\n                message: 'Invalid LOG_LEVEL; using info',\n                type: 'invalid-level',\n            });\n        }\n    }\n\n    const logger = {\n        configure(configuration) {\n            validatePresentation(configuration);\n            for (const name of booleanPresentationKeys) {\n                const value = configuration[name];\n                if (value !== undefined) presentation[name] = value;\n            }\n\n            for (const name of stringPresentationKeys) {\n                const value = configuration[name];\n                if (value !== undefined) presentation[name] = value;\n            }\n        },\n        isLevelEnabled(level) {\n            if (level !== 'success' && !isLevel(level)) throw new TypeError('Invalid logger level');\n            refreshLevel();\n            return level !== 'silent' && getLevelSeverity(level) >= getLevelSeverity(currentLevel);\n        },\n        setLevel(level) {\n            validateLevel(level);\n            if (level === undefined) throw new TypeError('Invalid logger level');\n            override = level === 'env' ? undefined : level;\n            environmentRead = false;\n            if (override !== undefined) {\n                currentLevel = override;\n            } else {\n                refreshLevel();\n            }\n        },\n    } as Logger;\n\n    for (const type of Object.keys(loggerMethods) as LoggerMethod[]) {\n        logger[type] = async (...args: unknown[]) => {\n            try {\n                refreshLevel();\n                if (loggerMethods[type].severity < getLevelSeverity(currentLevel)) return;\n                await hooks.write({\n                    ...presentation,\n                    args,\n                    date: new Date(),\n                    type,\n                });\n            } catch (error) {\n                report({\n                    error,\n                    message: 'Logger output failed',\n                    type: 'format',\n                });\n            }\n        };\n    }\n\n    return Object.freeze(logger);\n}\n\nfunction getLevelSeverity(level: LoggerLevel | LoggerMethod): number {\n    return level === 'silent' ? Number.POSITIVE_INFINITY : loggerMethods[level].severity;\n}\n\nfunction isLevel(value: unknown): value is LoggerLevel {\n    return typeof value === 'string'\n      && (value === 'silent' || (value !== 'success' && Object.hasOwn(loggerMethods, value)));\n}\n\nfunction readEnvironmentLevel(): string | undefined {\n    return (globalThis as { process?: { env?: { LOG_LEVEL?: string } } }).process?.env?.LOG_LEVEL;\n}\n\nfunction validateLevel(value: unknown): asserts value is 'env' | LoggerLevel | undefined {\n    if (value !== undefined && value !== 'env' && !isLevel(value)) throw new TypeError('Invalid logger level');\n}\n\nfunction validatePresentation(options: Pick<LoggerOptions, 'console' | 'icons' | 'prefix' | 'suffix' | 'timestamp'>) {\n    for (const name of booleanPresentationKeys) {\n        if (options[name] !== undefined && typeof options[name] !== 'boolean') {\n            throw new TypeError(`Logger ${name} must be a boolean`);\n        }\n    }\n\n    for (const name of stringPresentationKeys) {\n        if (options[name] !== undefined && typeof options[name] !== 'string') {\n            throw new TypeError(`Logger ${name} must be a string`);\n        }\n    }\n}\n"],"mappings":"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"}

package/dist/logger/_internals/types.d.ts

@@ -0,0 +1,12 @@
+import { LoggerMethod } from "../types.js";
+export interface LoggerRecord {
+  args: readonly unknown[];
+  console: boolean;
+  date: Date;
+  icons: boolean;
+  prefix: string;
+  suffix: string;
+  timestamp: boolean;
+  type: LoggerMethod;
+}
+//# sourceMappingURL=types.d.ts.map

package/dist/logger/_internals/types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","names":[],"sources":["../../../src/logger/_internals/types.ts"],"mappings":";iBAEiB;EACb;EACA;EACA,MAAM;EACN;EACA;EACA;EACA;EACA,MAAM"}

package/dist/logger/_internals/types.js

@@ -0,0 +1 @@
+export {};

package/dist/logger/index.d.ts

@@ -0,0 +1,10 @@
+import { Logger, LoggerOptions } from "./types.js";
+/**
+ * Creates an independent, browser-safe console logger.
+ *
+ * Log calls never throw or reject for recoverable output failures. Awaiting a call
+ * waits for the console invocation, not display or durable delivery. Unspecified
+ * levels follow LOG_LEVEL when a process environment is available, otherwise info.
+ */
+export declare function createLogger(options?: LoggerOptions): Readonly<Logger>;
+//# sourceMappingURL=index.d.ts.map

package/dist/logger/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","names":[],"sources":["../../src/logger/index.ts"],"mappings":";;;;;;;;wBAoBgB,aAAa,UAAS,gBAAqB,SAAS"}

package/dist/logger/index.js

@@ -0,0 +1,25 @@
+import { loggerMethods } from "./_internals/levels.js";
+import { formatLoggerConsoleArgs } from "./_internals/formatter.js";
+import { createDiagnosticReporter, createLoggerCore } from "./_internals/logger.js";
+// src/logger/index.ts
+/**
+* Creates an independent, browser-safe console logger.
+*
+* Log calls never throw or reject for recoverable output failures. Awaiting a call
+* waits for the console invocation, not display or durable delivery. Unspecified
+* levels follow LOG_LEVEL when a process environment is available, otherwise info.
+*/
+function createLogger(options = {}) {
+	const target = globalThis.console;
+	const fallback = target?.error?.bind(target);
+	return createLoggerCore(options, {
+		report: createDiagnosticReporter(options.onError, (message) => fallback?.(message.trimEnd())),
+		write(record) {
+			if (!record.console) return;
+			target?.[loggerMethods[record.type].consoleMethod](...formatLoggerConsoleArgs(record));
+		}
+	});
+}
+export { createLogger };
+
+//# sourceMappingURL=index.js.map

package/dist/logger/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","names":[],"sources":["../../src/logger/index.ts"],"sourcesContent":["import { formatLoggerConsoleArgs } from './_internals/formatter';\nimport { loggerMethods } from './_internals/levels';\nimport {\n    createDiagnosticReporter,\n    createLoggerCore,\n} from './_internals/logger';\nimport type {\n    Logger,\n    LoggerOptions,\n} from './types';\n\n// Functions\n\n/**\n * Creates an independent, browser-safe console logger.\n *\n * Log calls never throw or reject for recoverable output failures. Awaiting a call\n * waits for the console invocation, not display or durable delivery. Unspecified\n * levels follow LOG_LEVEL when a process environment is available, otherwise info.\n */\nexport function createLogger(options: LoggerOptions = {}): Readonly<Logger> {\n    const target = globalThis.console;\n    const fallback = target?.error?.bind(target);\n    return createLoggerCore(\n        options,\n        {\n            report: createDiagnosticReporter(options.onError, (message) => fallback?.(message.trimEnd())),\n            write(record) {\n                if (!record.console) return;\n                target?.[loggerMethods[record.type].consoleMethod](...formatLoggerConsoleArgs(record));\n            },\n        },\n    );\n}\n"],"mappings":";;;;;;;;;;;AAoBA,SAAgB,aAAa,UAAyB,CAAC,GAAqB;CACxE,MAAM,SAAS,WAAW;CAC1B,MAAM,WAAW,QAAQ,OAAO,KAAK,MAAM;CAC3C,OAAO,iBACH,SACA;EACI,QAAQ,yBAAyB,QAAQ,UAAU,YAAY,WAAW,QAAQ,QAAQ,CAAC,CAAC;EAC5F,MAAM,QAAQ;GACV,IAAI,CAAC,OAAO,SAAS;GACrB,SAAS,cAAc,OAAO,KAAK,CAAC,cAAc,CAAC,GAAG,wBAAwB,MAAM,CAAC;EACzF;CACJ,CACJ;AACJ"}

package/dist/logger/node/_internals/file-writer.d.ts

@@ -0,0 +1,11 @@
+import { LoggerDiagnostic } from "../../types.js";
+import { LoggerFileOptions, NodeLoggerStats } from "../types.js";
+interface LoggerFileWriter {
+  close: () => Promise<void>;
+  getStats: () => Readonly<NodeLoggerStats>;
+  write: (text: string) => Promise<void>;
+}
+/** A bounded admission layer over the stream's own ordered write buffer; not a second FIFO. */
+export declare function createFileWriter(options: LoggerFileOptions, report: (event: LoggerDiagnostic) => void): Promise<Readonly<LoggerFileWriter>>;
+export {};
+//# sourceMappingURL=file-writer.d.ts.map

package/dist/logger/node/_internals/file-writer.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"file-writer.d.ts","names":[],"sources":["../../../../src/logger/node/_internals/file-writer.ts"],"mappings":";;UAiBU;EACN,aAAa;EACb,gBAAgB,SAAS;EACzB,QAAQ,iBAAiB;;;wBASP,iBAClB,SAAS,mBACT,SAAS,OAAO,4BACjB,QAAQ,SAAS"}

package/dist/logger/node/_internals/file-writer.js

@@ -0,0 +1,188 @@
+import { Path } from "../../../classes/path.js";
+import { Buffer } from "node:buffer";
+import { mkdir } from "node:fs/promises";
+import { basename, dirname } from "node:path";
+import { createWriteStream } from "node:fs";
+import { fileURLToPath } from "node:url";
+// src/logger/node/_internals/file-writer.ts
+const defaultMaxPendingBytes = 8388608;
+/** A bounded admission layer over the stream's own ordered write buffer; not a second FIFO. */
+async function createFileWriter(options, report) {
+	const { maxPendingBytes, path, rotate } = validateFileOptions(options);
+	const createRotatingStream = rotate ? (await import("rotating-file-stream")).createStream : void 0;
+	await mkdir(dirname(path), { recursive: true });
+	const stream = rotate && createRotatingStream ? createRotatingStream(basename(path), {
+		compress: rotate.compress === false ? false : "gzip",
+		...rotate.interval === void 0 ? {} : { interval: rotate.interval === "hourly" ? "1h" : "1d" },
+		intervalBoundary: true,
+		intervalUTC: false,
+		maxFiles: rotate.keepFiles ?? 30,
+		...rotate.maxTotalSize === void 0 ? {} : { maxSize: rotate.maxTotalSize },
+		path: dirname(path),
+		...rotate.maxSize === void 0 ? {} : { size: rotate.maxSize }
+	}) : createWriteStream(path, { flags: "a" });
+	let pendingBytes = 0;
+	let droppedCount = 0;
+	let writeErrorCount = 0;
+	let failed = false;
+	let closing = false;
+	let closed = false;
+	let closePromise;
+	let initializing = true;
+	const unfinished = /* @__PURE__ */ new Set();
+	let rejectInitialization;
+	const settleAll = () => {
+		for (const settle of unfinished) settle();
+	};
+	const fail = (error) => {
+		rejectInitialization?.(error);
+		if (!failed) {
+			failed = true;
+			if (!initializing) {
+				writeErrorCount++;
+				report({
+					error,
+					message: "File output failed and has been disabled.",
+					type: "file"
+				});
+			}
+		}
+		settleAll();
+		if (!stream.destroyed) stream.destroy();
+	};
+	stream.on("error", fail);
+	stream.on("warning", (error) => {
+		writeErrorCount++;
+		report({
+			error,
+			message: "File rotation cleanup failed.",
+			type: "file"
+		});
+	});
+	stream.on("close", () => {
+		closed = true;
+		if (!closing && !failed) fail(/* @__PURE__ */ new Error("File stream closed unexpectedly."));
+		settleAll();
+	});
+	try {
+		await new Promise((resolveReady, rejectReady) => {
+			rejectInitialization = rejectReady;
+			stream.write(Buffer.alloc(0), (error) => {
+				if (error) rejectReady(error);
+				else resolveReady();
+			});
+		});
+		if (failed || closed) throw new Error("File output failed during initialization.");
+	} catch (error) {
+		if (!stream.destroyed) stream.destroy();
+		if (!closed) await new Promise((resolveClosed) => {
+			stream.once("close", resolveClosed);
+		});
+		throw error;
+	} finally {
+		rejectInitialization = void 0;
+		initializing = false;
+	}
+	return Object.freeze({
+		close() {
+			if (closePromise) return closePromise;
+			closing = true;
+			closePromise = new Promise((resolveClosed) => {
+				if (closed) {
+					resolveClosed();
+					return;
+				}
+				stream.once("close", resolveClosed);
+				try {
+					if (!stream.destroyed) stream.end();
+				} catch (error) {
+					fail(error);
+				}
+			});
+			return closePromise;
+		},
+		getStats: () => Object.freeze({
+			droppedCount,
+			pendingBytes,
+			writeErrorCount
+		}),
+		write(text) {
+			if (closing || closed || failed) {
+				report({
+					message: "File output is closed or unavailable.",
+					type: "closed"
+				});
+				return Promise.resolve();
+			}
+			const bytes = Buffer.byteLength(text);
+			if (bytes > maxPendingBytes - pendingBytes) {
+				droppedCount++;
+				report({
+					droppedCount,
+					message: "File output queue is full; the newest record was discarded.",
+					type: "overflow"
+				});
+				return Promise.resolve();
+			}
+			pendingBytes += bytes;
+			return new Promise((resolveWritten) => {
+				let settled = false;
+				const settle = () => {
+					if (settled) return;
+					settled = true;
+					pendingBytes -= bytes;
+					unfinished.delete(settle);
+					resolveWritten();
+				};
+				unfinished.add(settle);
+				try {
+					stream.write(text, (error) => {
+						if (error) fail(error);
+						settle();
+					});
+				} catch (error) {
+					fail(error);
+				}
+			});
+		}
+	});
+}
+/** Validate before mkdir, stream creation, or other filesystem side effects. */
+function validateFileOptions(options) {
+	if (!options || typeof options !== "object" || !(typeof options.path === "string" || options.path instanceof Path || options.path instanceof URL || Buffer.isBuffer(options.path))) throw new TypeError("file.path must be a string, Buffer, file URL, or Path");
+	const path = options.path instanceof URL ? fileURLToPath(options.path) : options.path.toString();
+	if (Buffer.isBuffer(options.path) && !Buffer.from(path).equals(options.path)) throw new TypeError("file.path Buffer must contain valid UTF-8");
+	if (!path.trim() || path.includes("\0")) throw new TypeError("file.path must be a nonempty path without null bytes");
+	const maxPendingBytes = options.maxPendingBytes ?? defaultMaxPendingBytes;
+	if (!Number.isSafeInteger(maxPendingBytes) || maxPendingBytes <= 0) throw new RangeError("file.maxPendingBytes must be a positive safe integer");
+	const rotate = options.rotate;
+	if (rotate !== void 0 && rotate !== false) {
+		if (!rotate || typeof rotate !== "object") throw new TypeError("file.rotate must be false or an options object");
+		if (rotate.interval !== void 0 && rotate.interval !== "hourly" && rotate.interval !== "daily") throw new TypeError("file.rotate.interval must be hourly or daily");
+		if (rotate.interval === void 0 && rotate.maxSize === void 0) throw new TypeError("file.rotate requires interval or maxSize");
+		const keepFiles = rotate.keepFiles ?? 30;
+		if (!Number.isSafeInteger(keepFiles) || keepFiles <= 0) throw new RangeError("file.rotate.keepFiles must be a positive safe integer");
+		if (rotate.compress !== void 0 && typeof rotate.compress !== "boolean") throw new TypeError("file.rotate.compress must be a boolean");
+		validateSize(rotate.maxSize, "file.rotate.maxSize");
+		validateSize(rotate.maxTotalSize, "file.rotate.maxTotalSize");
+	}
+	return {
+		maxPendingBytes,
+		path: Path.resolve(path).value,
+		rotate
+	};
+}
+function validateSize(value, name) {
+	if (value === void 0) return;
+	if (typeof value !== "string" || !/^[1-9]\d*[BKMG]$/.test(value)) throw new TypeError(`${name} must be a positive integer followed by B, K, M, or G`);
+	const multiplier = {
+		B: 1,
+		G: 1024 ** 3,
+		K: 1024,
+		M: 1024 ** 2
+	}[value.at(-1)];
+	if (!Number.isSafeInteger(Number(value.slice(0, -1)) * multiplier)) throw new RangeError(`${name} exceeds the supported size range`);
+}
+export { createFileWriter };
+
+//# sourceMappingURL=file-writer.js.map

package/dist/logger/node/_internals/file-writer.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"file-writer.js","names":[],"sources":["../../../../src/logger/node/_internals/file-writer.ts"],"sourcesContent":["import { Buffer } from 'node:buffer';\nimport { createWriteStream } from 'node:fs';\nimport { mkdir } from 'node:fs/promises';\nimport {\n    basename,\n    dirname,\n} from 'node:path';\nimport type { Writable } from 'node:stream';\nimport { fileURLToPath } from 'node:url';\n\nimport { Path } from '../../../classes/path';\nimport type { LoggerDiagnostic } from '../../types';\nimport type {\n    LoggerFileOptions,\n    NodeLoggerStats,\n} from '../types';\n\ninterface LoggerFileWriter {\n    close: () => Promise<void>;\n    getStats: () => Readonly<NodeLoggerStats>;\n    write: (text: string) => Promise<void>;\n}\n\n// Constants/Variables\nconst defaultMaxPendingBytes = 8 * 1024 * 1024;\n\n// Functions\n\n/** A bounded admission layer over the stream's own ordered write buffer; not a second FIFO. */\nexport async function createFileWriter(\n    options: LoggerFileOptions,\n    report: (event: LoggerDiagnostic) => void,\n): Promise<Readonly<LoggerFileWriter>> {\n    const {\n        maxPendingBytes,\n        path,\n        rotate,\n    } = validateFileOptions(options);\n\n    const createRotatingStream = rotate ? (await import('rotating-file-stream')).createStream : undefined;\n    await mkdir(dirname(path), { recursive: true });\n    const stream: Writable = rotate && createRotatingStream\n        ? createRotatingStream(\n            basename(path),\n            {\n                compress: rotate.compress === false ? false : 'gzip',\n                ...rotate.interval === undefined ? {} : { interval: rotate.interval === 'hourly' ? '1h' : '1d' },\n                intervalBoundary: true,\n                intervalUTC: false,\n                maxFiles: rotate.keepFiles ?? 30,\n                ...rotate.maxTotalSize === undefined ? {} : { maxSize: rotate.maxTotalSize },\n                path: dirname(path),\n                ...rotate.maxSize === undefined ? {} : { size: rotate.maxSize },\n            },\n        )\n        : createWriteStream(path, { flags: 'a' });\n\n    let pendingBytes = 0;\n    let droppedCount = 0;\n    let writeErrorCount = 0;\n    let failed = false;\n    let closing = false;\n    let closed = false;\n    let closePromise: Promise<void> | undefined;\n    let initializing = true;\n    const unfinished = new Set<() => void>();\n    let rejectInitialization: ((error: unknown) => void) | undefined;\n\n    const settleAll = () => {\n        for (const settle of unfinished) settle();\n    };\n\n    const fail = (error: unknown) => {\n        rejectInitialization?.(error);\n        if (!failed) {\n            failed = true;\n            if (!initializing) {\n                writeErrorCount++;\n                report({\n                    error,\n                    message: 'File output failed and has been disabled.',\n                    type: 'file',\n                });\n            }\n        }\n\n        settleAll();\n        if (!stream.destroyed) stream.destroy();\n    };\n\n    stream.on('error', fail);\n    stream.on(\n        'warning',\n        (error: unknown) => {\n            writeErrorCount++;\n            report({\n                error,\n                message: 'File rotation cleanup failed.',\n                type: 'file',\n            });\n        },\n    );\n\n    stream.on(\n        'close',\n        () => {\n            closed = true;\n            if (!closing && !failed) fail(new Error('File stream closed unexpectedly.'));\n            settleAll();\n        },\n    );\n\n    // A write callback also waits for RFS's asynchronous initialization and initial rotation.\n    try {\n        await new Promise<void>((resolveReady, rejectReady) => {\n            rejectInitialization = rejectReady;\n            stream.write(\n                Buffer.alloc(0),\n                (error) => {\n                    if (error) rejectReady(error);\n                    else resolveReady();\n                },\n            );\n        });\n\n        if (failed || closed) throw new Error('File output failed during initialization.');\n    } catch (error) {\n        if (!stream.destroyed) stream.destroy();\n        if (!closed) {\n            await new Promise<void>((resolveClosed) => {\n                stream.once('close', resolveClosed);\n            });\n        }\n\n        throw error;\n    } finally {\n        rejectInitialization = undefined;\n        initializing = false;\n    }\n\n    return Object.freeze({\n        close() {\n            if (closePromise) return closePromise;\n            closing = true;\n            closePromise = new Promise<void>((resolveClosed) => {\n                if (closed) {\n                    resolveClosed();\n                    return;\n                }\n\n                stream.once('close', resolveClosed);\n                try {\n                    if (!stream.destroyed) stream.end();\n                } catch (error) {\n                    fail(error);\n                }\n            });\n\n            return closePromise;\n        },\n        getStats: () => Object.freeze({\n            droppedCount,\n            pendingBytes,\n            writeErrorCount,\n        }),\n        write(text: string) {\n            if (closing || closed || failed) {\n                report({\n                    message: 'File output is closed or unavailable.',\n                    type: 'closed',\n                });\n\n                return Promise.resolve();\n            }\n\n            const bytes = Buffer.byteLength(text);\n            if (bytes > maxPendingBytes - pendingBytes) {\n                droppedCount++;\n                report({\n                    droppedCount,\n                    message: 'File output queue is full; the newest record was discarded.',\n                    type: 'overflow',\n                });\n\n                return Promise.resolve();\n            }\n\n            pendingBytes += bytes;\n            return new Promise<void>((resolveWritten) => {\n                let settled = false;\n                const settle = () => {\n                    if (settled) return;\n                    settled = true;\n                    pendingBytes -= bytes;\n                    unfinished.delete(settle);\n                    resolveWritten();\n                };\n\n                unfinished.add(settle);\n                try {\n                    stream.write(\n                        text,\n                        (error) => {\n                            if (error) fail(error);\n                            settle();\n                        },\n                    );\n                } catch (error) {\n                    fail(error);\n                }\n            });\n        },\n    });\n}\n\n/** Validate before mkdir, stream creation, or other filesystem side effects. */\nfunction validateFileOptions(options: LoggerFileOptions) {\n    if (\n        !options\n        || typeof options !== 'object'\n        || !(\n            typeof options.path === 'string'\n            || options.path instanceof Path\n            || options.path instanceof URL\n            || Buffer.isBuffer(options.path)\n        )\n    ) {\n        throw new TypeError('file.path must be a string, Buffer, file URL, or Path');\n    }\n\n    const path = options.path instanceof URL\n        ? fileURLToPath(options.path)\n        : options.path.toString();\n\n    if (Buffer.isBuffer(options.path) && !Buffer.from(path).equals(options.path)) {\n        throw new TypeError('file.path Buffer must contain valid UTF-8');\n    }\n\n    if (!path.trim() || path.includes('\\0')) {\n        throw new TypeError('file.path must be a nonempty path without null bytes');\n    }\n\n    const maxPendingBytes = options.maxPendingBytes ?? defaultMaxPendingBytes;\n    if (!Number.isSafeInteger(maxPendingBytes) || maxPendingBytes <= 0) {\n        throw new RangeError('file.maxPendingBytes must be a positive safe integer');\n    }\n\n    const rotate = options.rotate;\n    if (rotate !== undefined && rotate !== false) {\n        if (!rotate || typeof rotate !== 'object') {\n            throw new TypeError('file.rotate must be false or an options object');\n        }\n\n        if (rotate.interval !== undefined && rotate.interval !== 'hourly' && rotate.interval !== 'daily') {\n            throw new TypeError('file.rotate.interval must be hourly or daily');\n        }\n\n        if (rotate.interval === undefined && rotate.maxSize === undefined) {\n            throw new TypeError('file.rotate requires interval or maxSize');\n        }\n\n        const keepFiles = rotate.keepFiles ?? 30;\n        if (!Number.isSafeInteger(keepFiles) || keepFiles <= 0) {\n            throw new RangeError('file.rotate.keepFiles must be a positive safe integer');\n        }\n\n        if (rotate.compress !== undefined && typeof rotate.compress !== 'boolean') {\n            throw new TypeError('file.rotate.compress must be a boolean');\n        }\n\n        validateSize(rotate.maxSize, 'file.rotate.maxSize');\n        validateSize(rotate.maxTotalSize, 'file.rotate.maxTotalSize');\n    }\n\n    return {\n        maxPendingBytes,\n        path: Path.resolve(path).value,\n        rotate,\n    };\n}\n\nfunction validateSize(value: string | undefined, name: string) {\n    if (value === undefined) return;\n    if (typeof value !== 'string' || !/^[1-9]\\d*[BKMG]$/.test(value)) {\n        throw new TypeError(`${name} must be a positive integer followed by B, K, M, or G`);\n    }\n\n    const multiplier = {\n        B: 1,\n        G: 1024 ** 3,\n        K: 1024,\n        M: 1024 ** 2,\n    }[value.at(-1) as 'B' | 'G' | 'K' | 'M'];\n\n    if (!Number.isSafeInteger(Number(value.slice(0, -1)) * multiplier)) {\n        throw new RangeError(`${name} exceeds the supported size range`);\n    }\n}\n"],"mappings":"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"}

package/dist/logger/node/_internals/formatter.d.ts

@@ -0,0 +1,4 @@
+import { LoggerRecord } from "../../_internals/types.js";
+/** Preserve user ANSI for console output without invoking custom inspect callbacks/getters. */
+export declare function formatNodeLoggerRecord(record: LoggerRecord, colors?: boolean): string;
+//# sourceMappingURL=formatter.d.ts.map

package/dist/logger/node/_internals/formatter.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"formatter.d.ts","names":[],"sources":["../../../../src/logger/node/_internals/formatter.ts"],"mappings":";;wBAQgB,uBAAuB,QAAQ,cAAc"}

package/dist/logger/node/_internals/formatter.js

@@ -0,0 +1,21 @@
+import { formatLoggerParts } from "../../_internals/formatter.js";
+import { inspect } from "node:util";
+// src/logger/node/_internals/formatter.ts
+/** Preserve user ANSI for console output without invoking custom inspect callbacks/getters. */
+function formatNodeLoggerRecord(record, colors = false) {
+	const message = record.args.map((arg) => typeof arg === "string" ? arg : inspect(arg, {
+		colors: false,
+		customInspect: false,
+		depth: 6,
+		getters: false,
+		maxArrayLength: 100,
+		maxStringLength: 1e4
+	})).join(" ");
+	return formatLoggerParts({
+		...record,
+		args: record.args.length ? [message] : []
+	}, colors).join(" ");
+}
+export { formatNodeLoggerRecord };
+
+//# sourceMappingURL=formatter.js.map