@kikiutils/shared 18.3.0 → 19.0.0

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

@@ -0,0 +1 @@
+{"version":3,"file":"formatter.js","names":[],"sources":["../../../../src/logger/node/_internals/formatter.ts"],"sourcesContent":["import { inspect } from 'node:util';\n\nimport { formatLoggerParts } from '../../_internals/formatter';\nimport type { LoggerRecord } from '../../_internals/types';\n\n// Functions\n\n/** Preserve user ANSI for console output without invoking custom inspect callbacks/getters. */\nexport function formatNodeLoggerRecord(record: LoggerRecord, colors = false) {\n    const message = record.args.map(\n        (arg) => typeof arg === 'string'\n            ? arg\n            : inspect(\n                arg,\n                {\n                    colors: false,\n                    customInspect: false,\n                    depth: 6,\n                    getters: false,\n                    maxArrayLength: 100,\n                    maxStringLength: 10_000,\n                },\n            ),\n    ).join(' ');\n\n    return formatLoggerParts(\n        {\n            ...record,\n            args: record.args.length ? [message] : [],\n        },\n        colors,\n    ).join(' ');\n}\n"],"mappings":";;;;AAQA,SAAgB,uBAAuB,QAAsB,SAAS,OAAO;CACzE,MAAM,UAAU,OAAO,KAAK,KACvB,QAAQ,OAAO,QAAQ,WAClB,MACA,QACE,KACA;EACI,QAAQ;EACR,eAAe;EACf,OAAO;EACP,SAAS;EACT,gBAAgB;EAChB,iBAAiB;CACrB,CACJ,CACR,CAAC,CAAC,KAAK,GAAG;CAEV,OAAO,kBACH;EACI,GAAG;EACH,MAAM,OAAO,KAAK,SAAS,CAAC,OAAO,IAAI,CAAC;CAC5C,GACA,MACJ,CAAC,CAAC,KAAK,GAAG;AACd"}

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

@@ -0,0 +1,10 @@
+import { NodeLogger, NodeLoggerOptions } from "./types.js";
+/**
+ * Creates a Node.js/Bun logger with optional bounded, append-only file output and rotation.
+ *
+ * Log calls never throw or reject. Awaiting them waits for processing, not proof of successful
+ * persistence: overload drops the newest file record and failures are reported safely. Factory
+ * validation/open failures reject. Call close explicitly; no process signal handlers are installed.
+ */
+export declare function createNodeLogger(options?: NodeLoggerOptions): Promise<NodeLogger>;
+//# sourceMappingURL=index.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","names":[],"sources":["../../../src/logger/node/index.ts"],"mappings":";;;;;;;;wBAqCsB,iBAAiB,UAAS,oBAAyB,QAAQ"}

package/dist/logger/node/index.js

@@ -0,0 +1,122 @@
+import { getLoggerStreamName } from "../_internals/levels.js";
+import { supportsLoggerColor } from "../_internals/formatter.js";
+import { createDiagnosticReporter, createLoggerCore } from "../_internals/logger.js";
+import { createFileWriter } from "./_internals/file-writer.js";
+import { formatNodeLoggerRecord } from "./_internals/formatter.js";
+import { writeSync } from "node:fs";
+import { stripVTControlCharacters } from "node:util";
+// src/logger/node/index.ts
+const consoleStreams = /* @__PURE__ */ new WeakMap();
+/**
+* Creates a Node.js/Bun logger with optional bounded, append-only file output and rotation.
+*
+* Log calls never throw or reject. Awaiting them waits for processing, not proof of successful
+* persistence: overload drops the newest file record and failures are reported safely. Factory
+* validation/open failures reject. Call close explicitly; no process signal handlers are installed.
+*/
+async function createNodeLogger(options = {}) {
+	const report = createDiagnosticReporter(options.onError, (message) => writeSync(2, message));
+	let writer;
+	let closed = false;
+	let closePromise;
+	const consoleOwner = {};
+	const consoleTargets = /* @__PURE__ */ new Set();
+	const consoleWrites = /* @__PURE__ */ new Set();
+	const logger = createLoggerCore(options, {
+		report,
+		write(record) {
+			if (closed) {
+				report({
+					message: "Logger is closed.",
+					type: "closed"
+				});
+				return;
+			}
+			if (!record.console && !writer) return;
+			const target = process[getLoggerStreamName(record.type)];
+			const text = formatNodeLoggerRecord(record, record.console && supportsLoggerColor(target));
+			if (record.console) {
+				const line = `${text}\n`;
+				consoleTargets.add(target);
+				const completion = writeConsole(target, line, report, consoleOwner);
+				consoleWrites.add(completion);
+				completion.then(() => consoleWrites.delete(completion));
+				const fileCompletion = writer?.write(`${stripVTControlCharacters(text)}\n`);
+				return fileCompletion ? Promise.all([completion, fileCompletion]).then(() => {}) : completion;
+			}
+			return writer?.write(`${stripVTControlCharacters(text)}\n`);
+		}
+	});
+	if (options.file !== void 0 && options.file !== false) writer = await createFileWriter(options.file, report);
+	return Object.assign(logger, {
+		close() {
+			if (closePromise) return closePromise;
+			closed = true;
+			closePromise = (async () => {
+				await Promise.all([writer?.close(), ...consoleWrites]);
+				for (const target of consoleTargets) {
+					const state = consoleStreams.get(target);
+					if (!state) continue;
+					state.owners.delete(consoleOwner);
+					if (!state.owners.size) {
+						target.off("error", state.onError);
+						target.off("close", state.onClose);
+						consoleStreams.delete(target);
+					}
+				}
+				consoleTargets.clear();
+			})();
+			return closePromise;
+		},
+		getStats: () => writer?.getStats() ?? {
+			droppedCount: 0,
+			pendingBytes: 0,
+			writeErrorCount: 0
+		}
+	});
+}
+/** One error listener per shared output stream; retained until its last owning logger calls close(). */
+function writeConsole(target, text, report, owner) {
+	let state = consoleStreams.get(target);
+	if (!state) {
+		const pending = /* @__PURE__ */ new Set();
+		const onError = (error) => {
+			for (const settle of pending) settle(error);
+		};
+		const onClose = () => onError(/* @__PURE__ */ new Error("Console stream closed."));
+		state = {
+			onClose,
+			onError,
+			owners: /* @__PURE__ */ new Set(),
+			pending
+		};
+		consoleStreams.set(target, state);
+		target.on("error", onError);
+		target.on("close", onClose);
+	}
+	state.owners.add(owner);
+	const current = state;
+	return new Promise((resolveWritten) => {
+		let settled = false;
+		const settle = (error) => {
+			if (settled) return;
+			settled = true;
+			current.pending.delete(settle);
+			if (error) report({
+				error,
+				message: "Console output failed.",
+				type: "console"
+			});
+			resolveWritten();
+		};
+		current.pending.add(settle);
+		try {
+			target.write(text, settle);
+		} catch (error) {
+			settle(error instanceof Error ? error : /* @__PURE__ */ new Error("Console output failed."));
+		}
+	});
+}
+export { createNodeLogger };
+
+//# sourceMappingURL=index.js.map

package/dist/logger/node/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","names":[],"sources":["../../../src/logger/node/index.ts"],"sourcesContent":["import { writeSync } from 'node:fs';\nimport { stripVTControlCharacters } from 'node:util';\n\nimport { supportsLoggerColor } from '../_internals/formatter';\nimport { getLoggerStreamName } from '../_internals/levels';\nimport {\n    createDiagnosticReporter,\n    createLoggerCore,\n} from '../_internals/logger';\nimport type { LoggerDiagnostic } from '../types';\n\nimport { createFileWriter } from './_internals/file-writer';\nimport { formatNodeLoggerRecord } from './_internals/formatter';\nimport type {\n    NodeLogger,\n    NodeLoggerOptions,\n} from './types';\n\ninterface ConsoleStreamState {\n    onClose: () => void;\n    onError: (error: Error) => void;\n    owners: Set<object>;\n    pending: Set<(error?: Error | null) => void>;\n}\n\n// Constants/Variables\nconst consoleStreams = new WeakMap<NodeJS.WriteStream, ConsoleStreamState>();\n\n// Functions\n\n/**\n * Creates a Node.js/Bun logger with optional bounded, append-only file output and rotation.\n *\n * Log calls never throw or reject. Awaiting them waits for processing, not proof of successful\n * persistence: overload drops the newest file record and failures are reported safely. Factory\n * validation/open failures reject. Call close explicitly; no process signal handlers are installed.\n */\nexport async function createNodeLogger(options: NodeLoggerOptions = {}): Promise<NodeLogger> {\n    const report = createDiagnosticReporter(options.onError, (message) => writeSync(2, message));\n    let writer: Awaited<ReturnType<typeof createFileWriter>> | undefined;\n    let closed = false;\n    let closePromise: Promise<void> | undefined;\n    const consoleOwner = {};\n    const consoleTargets = new Set<NodeJS.WriteStream>();\n    const consoleWrites = new Set<Promise<void>>();\n    const logger = createLoggerCore(\n        options,\n        {\n            report,\n            write(record) {\n                if (closed) {\n                    report({\n                        message: 'Logger is closed.',\n                        type: 'closed',\n                    });\n\n                    return;\n                }\n\n                if (!record.console && !writer) return;\n                const target = process[getLoggerStreamName(record.type)];\n\n                const text = formatNodeLoggerRecord(record, record.console && supportsLoggerColor(target));\n                if (record.console) {\n                    const line = `${text}\\n`;\n                    consoleTargets.add(target);\n                    const completion = writeConsole(target, line, report, consoleOwner);\n                    consoleWrites.add(completion);\n                    void completion.then(() => consoleWrites.delete(completion));\n                    const fileCompletion = writer?.write(`${stripVTControlCharacters(text)}\\n`);\n                    return fileCompletion\n                        ? Promise.all([\n                            completion,\n                            fileCompletion,\n                        ]).then(() => {})\n                        : completion;\n                }\n\n                return writer?.write(`${stripVTControlCharacters(text)}\\n`);\n            },\n        },\n    );\n\n    if (options.file !== undefined && options.file !== false) writer = await createFileWriter(options.file, report);\n\n    return Object.assign(\n        logger,\n        {\n            close() {\n                if (closePromise) return closePromise;\n                closed = true;\n                closePromise = (async () => {\n                    await Promise.all([\n                        writer?.close(),\n                        ...consoleWrites,\n                    ]);\n\n                    for (const target of consoleTargets) {\n                        const state = consoleStreams.get(target);\n                        if (!state) continue;\n                        state.owners.delete(consoleOwner);\n                        if (!state.owners.size) {\n                            target.off('error', state.onError);\n                            target.off('close', state.onClose);\n                            consoleStreams.delete(target);\n                        }\n                    }\n\n                    consoleTargets.clear();\n                })();\n                return closePromise;\n            },\n            getStats: () => writer?.getStats() ?? {\n                droppedCount: 0,\n                pendingBytes: 0,\n                writeErrorCount: 0,\n            },\n        },\n    );\n}\n\n/** One error listener per shared output stream; retained until its last owning logger calls close(). */\nfunction writeConsole(\n    target: NodeJS.WriteStream,\n    text: string,\n    report: (event: LoggerDiagnostic) => void,\n    owner: object,\n) {\n    let state = consoleStreams.get(target);\n    if (!state) {\n        const pending = new Set<(error?: Error | null) => void>();\n        const onError = (error: Error) => {\n            for (const settle of pending) settle(error);\n        };\n\n        const onClose = () => onError(new Error('Console stream closed.'));\n        state = {\n            onClose,\n            onError,\n            owners: new Set(),\n            pending,\n        };\n\n        consoleStreams.set(target, state);\n        target.on('error', onError);\n        target.on('close', onClose);\n    }\n\n    state.owners.add(owner);\n    const current = state;\n    return new Promise<void>((resolveWritten) => {\n        let settled = false;\n        const settle = (error?: Error | null) => {\n            if (settled) return;\n            settled = true;\n            current.pending.delete(settle);\n            if (error) {\n                report({\n                    error,\n                    message: 'Console output failed.',\n                    type: 'console',\n                });\n            }\n\n            resolveWritten();\n        };\n\n        current.pending.add(settle);\n        try {\n            target.write(text, settle);\n        } catch (error) {\n            settle(error instanceof Error ? error : new Error('Console output failed.'));\n        }\n    });\n}\n"],"mappings":"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"}

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

@@ -0,0 +1,43 @@
+import { PathLike } from "../../classes/path.js";
+import { Logger, LoggerOptions } from "../types.js";
+/** Specify interval and/or maxSize. Size limits use positive integers with B, K, M, or G (binary units). */
+export type LoggerRotationOptions = {
+  /** Gzip historical files. Defaults to true. */
+  compress?: boolean;
+  /** Number of historical files, excluding the active file. Defaults to 30. */
+  keepFiles?: number;
+  /** Maximum combined size of historical files. */
+  maxTotalSize?: string;
+} & ({
+  /** Opt-in time rotation aligned to the system's local calendar boundary. */
+  interval: 'daily' | 'hourly';
+  maxSize?: string;
+} | {
+  /** Opt-in time rotation aligned to the system's local calendar boundary. */
+  interval?: 'daily' | 'hourly';
+  maxSize: string;
+});
+export interface LoggerFileOptions {
+  /** Maximum unfinished payload bytes, including data already submitted to the stream. */
+  maxPendingBytes?: number;
+  /** Resolved once at creation. The file is opened in append mode. */
+  path: PathLike;
+  /** Omitted or false disables rotation. An object must specify interval or maxSize. */
+  rotate?: false | LoggerRotationOptions;
+}
+export interface NodeLogger extends Logger {
+  /** Stop accepting records, finish accepted file writes, then release the stream. Not fsync. */
+  close: () => Promise<void>;
+  /** A fresh snapshot. Dropped/failed records still resolve their logging promises. */
+  getStats: () => NodeLoggerStats;
+}
+export interface NodeLoggerOptions extends LoggerOptions {
+  /** Disabled by default. Each logger owns at most one fixed file destination. */
+  file?: false | LoggerFileOptions;
+}
+export interface NodeLoggerStats {
+  droppedCount: number;
+  pendingBytes: number;
+  writeErrorCount: number;
+}
+//# sourceMappingURL=types.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","names":[],"sources":["../../../src/logger/node/types.ts"],"mappings":";;;YAOY;;EAER;;EAGA;;EAGA;;;EAIE;EACA;;;EAIA;EACA;;iBAIW;;EAEb;;EAGA,MAAM;;EAGN,iBAAiB;;iBAGJ,mBAAmB;;EAEhC,aAAa;;EAGb,gBAAgB;;iBAGH,0BAA0B;;EAEvC,eAAe;;iBAGF;EACb;EACA;EACA"}

package/dist/logger/node/types.js

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

package/dist/logger/types.d.ts

@@ -0,0 +1,49 @@
+/** Minimum severity to emit; `success` uses the same threshold as `info`. */
+export type LoggerLevel = 'debug' | 'error' | 'fatal' | 'info' | 'silent' | 'trace' | 'warn';
+/** A logging method, including the informational success presentation. */
+export type LoggerMethod = 'success' | Exclude<LoggerLevel, 'silent'>;
+/**
+ * A logger whose logging methods never throw or reject for recoverable failures.
+ *
+ * Awaiting a method waits for processing, not guaranteed successful delivery or fsync.
+ * Configuration errors may throw from the factory, configure(), or setLevel().
+ */
+export interface Logger {
+  configure: (options: Pick<LoggerOptions, 'console' | 'icons' | 'prefix' | 'suffix' | 'timestamp'>) => void;
+  debug: (...args: unknown[]) => Promise<void>;
+  error: (...args: unknown[]) => Promise<void>;
+  fatal: (...args: unknown[]) => Promise<void>;
+  info: (...args: unknown[]) => Promise<void>;
+  /** Accepts success as an informational method; it is not a configurable threshold. */
+  isLevelEnabled: (level: LoggerLevel | LoggerMethod) => boolean;
+  /** Sets a severity threshold (not success); env restores environment-driven filtering. */
+  setLevel: (level: 'env' | LoggerLevel) => void;
+  success: (...args: unknown[]) => Promise<void>;
+  trace: (...args: unknown[]) => Promise<void>;
+  warn: (...args: unknown[]) => Promise<void>;
+}
+/** A recoverable logging failure, reported without throwing from log methods. */
+export interface LoggerDiagnostic {
+  droppedCount?: number;
+  error?: unknown;
+  message: string;
+  /** Same-type notifications suppressed since the previous emitted diagnostic. */
+  suppressedCount?: number;
+  type: 'closed' | 'console' | 'file' | 'format' | 'invalid-level' | 'overflow';
+}
+/** Configuration shared by browser and server loggers. */
+export interface LoggerOptions {
+  /** Enables console output. Defaults to `true`. */
+  console?: boolean;
+  /** Enables Unicode level icons. Defaults to `true`. */
+  icons?: boolean;
+  /** Overrides LOG_LEVEL; `env` restores the environment-driven threshold. */
+  level?: 'env' | LoggerLevel;
+  /** Best-effort, rate-limited notification; failures in this callback are contained. */
+  onError?: (event: LoggerDiagnostic) => void;
+  prefix?: string;
+  suffix?: string;
+  /** Enables the fixed local-time millisecond prefix. Defaults to `true`. */
+  timestamp?: boolean;
+}
+//# sourceMappingURL=types.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","names":[],"sources":["../../src/logger/types.ts"],"mappings":";YACY;;YAGA,2BAA2B,QAAQ;;;;;;;iBAQ9B;EACb,YAAY,SAAS,KAAK;EAC1B,WAAW,oBAAoB;EAC/B,WAAW,oBAAoB;EAC/B,WAAW,oBAAoB;EAC/B,UAAU,oBAAoB;;EAG9B,iBAAiB,OAAO,cAAc;;EAGtC,WAAW,eAAe;EAC1B,aAAa,oBAAoB;EACjC,WAAW,oBAAoB;EAC/B,UAAU,oBAAoB;;;iBAIjB;EACb;EACA;EACA;;EAGA;EACA;;;iBAIa;;EAEb;;EAGA;;EAGA,gBAAgB;;EAGhB,WAAW,OAAO;EAClB;EACA;;EAGA"}

package/dist/logger/types.js

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

package/dist/math.d.ts

@@ -1,5 +1,4 @@
 import { Decimal } from "decimal.js";
-//#region src/math.d.ts
 type CalculableValue = Decimal.Value | {
   toString: () => string;
 };
@@ -45,6 +44,5 @@ export interface ToPercentageStringOptions {
  * ```
  */
 export declare function toPercentageString(molecular: CalculableValue, denominator: CalculableValue, options?: ToPercentageStringOptions): string;
-//#endregion
 export {};
 //# sourceMappingURL=math.d.ts.map

package/dist/math.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"math.d.ts","names":[],"sources":["../src/math.ts"],"mappings":";;KAEK,kBAAkB,QAAQ;EAAU;;;;;iBAKxB;;;;;;EAMb;;;;;;EAOA;;;;;;;;;;;;;;;;;;;;;;;;;;wBA2BY,mBACZ,WAAW,iBACX,aAAa,iBACb,UAAU"}
+{"version":3,"file":"math.d.ts","names":[],"sources":["../src/math.ts"],"mappings":";KAEK,kBAAkB,QAAQ;EAAU;;;;;iBAKxB;;;;;;EAMb;;;;;;EAOA;;;;;;;;;;;;;;;;;;;;;;;;;;wBA2BY,mBACZ,WAAW,iBACX,aAAa,iBACb,UAAU"}

package/dist/math.js

@@ -1,5 +1,5 @@
 import { Decimal } from "decimal.js";
-//#region src/math.ts
+// src/math.ts
 /**
 * Converts a numerator and denominator into a formatted percentage.
 *
@@ -31,7 +31,6 @@ function toPercentageString(molecular, denominator, options) {
 	const result = calculationResult.isNaN() || !calculationResult.isFinite() ? "0.00" : calculationResult.times(100).toFixed(options?.decimalPlaces ?? 2);
 	return options?.withSymbol ?? true ? `${result}%` : result;
 }
-//#endregion
 export { toPercentageString };
 
 //# sourceMappingURL=math.js.map

package/dist/number.d.ts

@@ -1,5 +1,4 @@
 import { millify } from "millify";
-//#region src/number.d.ts
 /**
  * Converts a large number into a compact, human-readable string using `millify`.
  *
@@ -21,5 +20,4 @@ import { millify } from "millify";
  * ```
  */
 export declare function toCompactNumberString(value: number, options?: Parameters<typeof millify>[1]): string;
-//#endregion
 //# sourceMappingURL=number.d.ts.map

package/dist/number.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"number.d.ts","names":[],"sources":["../src/number.ts"],"mappings":";;;;;;;;;;;;;;;;;;;;;;wBAsBgB,sBAAsB,eAAe,UAAU,kBAAkB"}
+{"version":3,"file":"number.d.ts","names":[],"sources":["../src/number.ts"],"mappings":";;;;;;;;;;;;;;;;;;;;;wBAsBgB,sBAAsB,eAAe,UAAU,kBAAkB"}

package/dist/number.js

@@ -1,5 +1,5 @@
 import { millify } from "millify";
-//#region src/number.ts
+// src/number.ts
 /**
 * Converts a large number into a compact, human-readable string using `millify`.
 *
@@ -27,7 +27,6 @@ function toCompactNumberString(value, options) {
 		...options
 	});
 }
-//#endregion
 export { toCompactNumberString };
 
 //# sourceMappingURL=number.js.map

package/dist/random.d.ts

@@ -1,4 +1,3 @@
-//#region src/random.d.ts
 /**
  * Calls a generator once with a length sampled from two nested random ranges.
  *
@@ -23,5 +22,4 @@
  * @throws Error if `minMin` exceeds `minMax` or `maxMin` exceeds `maxMax`.
  */
 export declare function generateWithNestedRandomLength<T = string>(generator: (length: number) => T, minMin: number, minMax: number, maxMin: number, maxMax: number): T;
-//#endregion
 //# sourceMappingURL=random.d.ts.map

package/dist/random.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"random.d.ts","names":[],"sources":["../src/random.ts"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;wBAuBgB,+BAA+B,YAC3C,YAAY,mBAAmB,GAC/B,gBACA,gBACA,gBACA,iBAAc"}
+{"version":3,"file":"random.d.ts","names":[],"sources":["../src/random.ts"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;wBAuBgB,+BAA+B,YAC3C,YAAY,mBAAmB,GAC/B,gBACA,gBACA,gBACA,iBAAc"}

package/dist/random.js

@@ -1,4 +1,4 @@
-//#region src/random.ts
+// src/random.ts
 /**
 * Calls a generator once with a length sampled from two nested random ranges.
 *
@@ -29,7 +29,6 @@ function generateWithNestedRandomLength(generator, minMin, minMax, maxMin, maxMa
 	const innerMin = random(minMin, minMax);
 	return generator(random(Math.max(innerMin, maxMin), maxMax));
 }
-//#endregion
 export { generateWithNestedRandomLength };
 
 //# sourceMappingURL=random.js.map

package/dist/redis/script-runner.d.ts

@@ -1,4 +1,3 @@
-//#region src/redis/script-runner.d.ts
 /**
  * An asynchronous Lua script runner with caller-declared results.
  *
@@ -53,5 +52,4 @@ export interface RedisLikeScriptClient {
  * @throws RangeError if `maxAttempts` is not a positive safe integer.
  */
 export declare function createRedisScriptRunner<T = unknown>(client: RedisLikeScriptClient, source: string, maxAttempts?: number): RedisScriptRunner<T>;
-//#endregion
 //# sourceMappingURL=script-runner.d.ts.map

package/dist/redis/script-runner.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"script-runner.d.ts","names":[],"sources":["../../src/redis/script-runner.ts"],"mappings":";;;;;;;;;;;;;;;YAgBY,kBAAkB,gBAAgB,yBAAyB,uCAAuC,QAC1G;;;;;;;;;iBAWa;;;;;;;EAOb,OAAO,iBAAiB,mBAAmB;;;;;;;;;;;;;;;;;;;;;;;wBAwB/B,wBAAwB,aACpC,QAAQ,uBACR,gBACA,uBACD,kBAAkB"}
+{"version":3,"file":"script-runner.d.ts","names":[],"sources":["../../src/redis/script-runner.ts"],"mappings":";;;;;;;;;;;;;;YAgBY,kBAAkB,gBAAgB,yBAAyB,uCAAuC,QAC1G;;;;;;;;;iBAWa;;;;;;;EAOb,OAAO,iBAAiB,mBAAmB;;;;;;;;;;;;;;;;;;;;;;;wBAwB/B,wBAAwB,aACpC,QAAQ,uBACR,gBACA,uBACD,kBAAkB"}

package/dist/redis/script-runner.js

@@ -1,5 +1,5 @@
 import { createHash } from "node:crypto";
-//#region src/redis/script-runner.ts
+// src/redis/script-runner.ts
 /**
 * Creates a Lua script runner that reloads missing cached scripts before retrying execution.
 *
@@ -40,7 +40,6 @@ function createRedisScriptRunner(client, source, maxAttempts = 3) {
 		}
 	};
 }
-//#endregion
 export { createRedisScriptRunner };
 
 //# sourceMappingURL=script-runner.js.map

package/dist/storages/lru/keyed-store.d.ts

@@ -1,5 +1,4 @@
 import { LRUCache } from "lru-cache";
-//#region src/storages/lru/keyed-store.d.ts
 /**
  * Creates a keyed cache factory sharing a caller-owned LRU cache.
  *
@@ -45,5 +44,4 @@ export declare function createLruKeyedStore<D = unknown>(lruInstance: LRUCache<a
   setItem: (value: D, ...args: P) => LRUCache<any, any, any>;
   setItemWithTtl(ttlMilliseconds: number, value: D, ...args: P): LRUCache<any, any, any>;
 }>;
-//#endregion
 //# sourceMappingURL=keyed-store.d.ts.map

package/dist/storages/lru/keyed-store.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"keyed-store.d.ts","names":[],"sources":["../../../src/storages/lru/keyed-store.ts"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;wBA8BgB,oBAAoB,aAAa,aAAa,2BAClD,iBAAiB,WAAW,MAAM,iBAAY;;;;;;EAMjC,WAAA,MAAA,IAAC,YAAA;EAII,gBAAA,MAAA;EACH,aAAA,MAAA;EACG,gBAAA,MAAA;;;;EAIA,gBAAA,MAAA;EACL,UAAA,OAAA,MAAC,MAAW,MAAC;EACE,eAAA,yBAAM,OAAS,MAAC,MAAW,IAAC"}
+{"version":3,"file":"keyed-store.d.ts","names":[],"sources":["../../../src/storages/lru/keyed-store.ts"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;wBA8BgB,oBAAoB,aAAa,aAAa,2BAClD,iBAAiB,WAAW,MAAM,iBAAY;;;;;;EAMjC,WAAA,MAAA,IAAC,YAAA;EAII,gBAAA,MAAA;EACH,aAAA,MAAA;EACG,gBAAA,MAAA;;;;EAIA,gBAAA,MAAA;EACL,UAAA,OAAA,MAAC,MAAW,MAAC;EACE,eAAA,yBAAM,OAAS,MAAC,MAAW,IAAC"}

package/dist/storages/lru/keyed-store.js

@@ -1,4 +1,4 @@
-//#region src/storages/lru/keyed-store.ts
+// src/storages/lru/keyed-store.ts
 /**
 * Creates a keyed cache factory sharing a caller-owned LRU cache.
 *
@@ -50,7 +50,6 @@ function createLruKeyedStore(lruInstance) {
 		}
 	});
 }
-//#endregion
 export { createLruKeyedStore };
 
 //# sourceMappingURL=keyed-store.js.map

package/dist/storages/redis/keyed-store.d.ts

@@ -1,6 +1,5 @@
 import { MaybeReadonly } from "../../types/index.js";
 import { RedisLikeStorage } from "./types.js";
-//#region src/storages/redis/keyed-store.d.ts
 /**
  * Creates a keyed store factory sharing a caller-owned Redis-like storage facade.
  *
@@ -26,5 +25,4 @@ export declare function createRedisKeyedStore<D = unknown>(storage: MaybeReadonl
   setItem: (value: D, ...args: P) => Promise<boolean>;
   setItemWithTtl(ttlSeconds: number, value: D, ...args: P): Promise<boolean>;
 }>;
-//#endregion
 //# sourceMappingURL=keyed-store.d.ts.map

package/dist/storages/redis/keyed-store.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"keyed-store.d.ts","names":[],"sources":["../../../src/storages/redis/keyed-store.ts"],"mappings":";;;;;;;;;;;;;;;;;;;wBAoBgB,sBAAsB,aAAa,SAAS,cAAc,qBAC9D,iBAAiB,WAAW,MAAM,iBAAY;EAC/B,aAAA,MAAA,MAAC,QAAA;EACE,gBAAA,MAAA,MAAC;EACJ,aAAA,MAAA,MAAC;EACE,gBAAA,MAAA,MAAC;EACD,gBAAA,MAAA;EACL,UAAA,OAAA,MAAC,MAAW,MAAC;EACH,eAAA,oBAAM,OAAS,MAAC,MAAW,IAAC"}
+{"version":3,"file":"keyed-store.d.ts","names":[],"sources":["../../../src/storages/redis/keyed-store.ts"],"mappings":";;;;;;;;;;;;;;;;;;wBAoBgB,sBAAsB,aAAa,SAAS,cAAc,qBAC9D,iBAAiB,WAAW,MAAM,iBAAY;EAC/B,aAAA,MAAA,MAAC,QAAA;EACE,gBAAA,MAAA,MAAC;EACJ,aAAA,MAAA,MAAC;EACE,gBAAA,MAAA,MAAC;EACD,gBAAA,MAAA;EACL,UAAA,OAAA,MAAC,MAAW,MAAC;EACH,eAAA,oBAAM,OAAS,MAAC,MAAW,IAAC"}

package/dist/storages/redis/keyed-store.js

@@ -1,4 +1,4 @@
-//#region src/storages/redis/keyed-store.ts
+// src/storages/redis/keyed-store.ts
 /**
 * Creates a keyed store factory sharing a caller-owned Redis-like storage facade.
 *
@@ -28,7 +28,6 @@ function createRedisKeyedStore(storage) {
 		}
 	});
 }
-//#endregion
 export { createRedisKeyedStore };
 
 //# sourceMappingURL=keyed-store.js.map

package/dist/storages/redis/msgpack.d.ts

@@ -1,5 +1,4 @@
 import { RedisLikeAdapter, RedisLikeStorage } from "./types.js";
-//#region src/storages/redis/msgpack.d.ts
 /**
  * Creates a frozen Redis-like storage facade using MessagePack serialization.
  *
@@ -42,5 +41,4 @@ import { RedisLikeAdapter, RedisLikeStorage } from "./types.js";
  * ```
  */
 export declare function createRedisMsgpackStorage(adapter: RedisLikeAdapter): Readonly<RedisLikeStorage>;
-//#endregion
 //# sourceMappingURL=msgpack.d.ts.map

package/dist/storages/redis/msgpack.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"msgpack.d.ts","names":[],"sources":["../../../src/storages/redis/msgpack.ts"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;wBAwDgB,0BAA0B,SAAS,mBAAmB,SAAS"}
+{"version":3,"file":"msgpack.d.ts","names":[],"sources":["../../../src/storages/redis/msgpack.ts"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;wBAwDgB,0BAA0B,SAAS,mBAAmB,SAAS"}

package/dist/storages/redis/msgpack.js

@@ -1,5 +1,5 @@
 import { decode, encode, isNativeAccelerationEnabled } from "msgpackr";
-//#region src/storages/redis/msgpack.ts
+// src/storages/redis/msgpack.ts
 if (!isNativeAccelerationEnabled) console.warn("Native acceleration not enabled for msgpackr, verify that install finished properly");
 /**
 * Creates a frozen Redis-like storage facade using MessagePack serialization.
@@ -57,7 +57,6 @@ function createRedisMsgpackStorage(adapter) {
 		}
 	});
 }
-//#endregion
 export { createRedisMsgpackStorage };
 
 //# sourceMappingURL=msgpack.js.map

package/dist/storages/redis/types.d.ts

@@ -1,4 +1,3 @@
-//#region src/storages/redis/types.d.ts
 /**
  * A caller-owned asynchronous adapter for Redis-like binary operations.
  *
@@ -75,5 +74,4 @@ export interface RedisLikeStorage {
    */
   setItemWithTtl: (key: string, ttlSeconds: number, value: any) => Promise<boolean>;
 }
-//#endregion
 //# sourceMappingURL=types.d.ts.map

package/dist/storages/redis/types.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"types.d.ts","names":[],"sources":["../../../src/storages/redis/types.ts"],"mappings":";;;;;;;;iBAOiB;;;;EAIb,SAAS,gBAAgB;;;;EAKzB,YAAY,gBAAgB,eAAe;;;;EAK3C,MAAM,gBAAgB;;;;EAKtB,YAAY,aAAa,OAAO,eAAe;;;;;;;;EAS/C,cAAc,aAAa,oBAAoB,OAAO,eAAe;;;;EAKrE,MAAM,gBAAgB;;;;;;;;;iBAUT;;;;;;EAMb,UAAU,aAAa,gBAAgB,eAAe;;;;EAKtD,aAAa,gBAAgB;;;;EAK7B,UAAU,gBAAgB;;;;EAK1B,aAAa,gBAAgB;;;;EAK7B,UAAU,aAAa,eAAe;;;;;;;;EAStC,iBAAiB,aAAa,oBAAoB,eAAe"}
+{"version":3,"file":"types.d.ts","names":[],"sources":["../../../src/storages/redis/types.ts"],"mappings":";;;;;;;iBAOiB;;;;EAIb,SAAS,gBAAgB;;;;EAKzB,YAAY,gBAAgB,eAAe;;;;EAK3C,MAAM,gBAAgB;;;;EAKtB,YAAY,aAAa,OAAO,eAAe;;;;;;;;EAS/C,cAAc,aAAa,oBAAoB,OAAO,eAAe;;;;EAKrE,MAAM,gBAAgB;;;;;;;;;iBAUT;;;;;;EAMb,UAAU,aAAa,gBAAgB,eAAe;;;;EAKtD,aAAa,gBAAgB;;;;EAK7B,UAAU,gBAAgB;;;;EAK1B,aAAa,gBAAgB;;;;EAK7B,UAAU,aAAa,eAAe;;;;;;;;EAStC,iBAAiB,aAAa,oBAAoB,eAAe"}

package/dist/string.d.ts

@@ -1,4 +1,3 @@
-//#region src/string.d.ts
 /**
  * Character-set presets supported by `randomString`.
  */
@@ -28,5 +27,4 @@ export type RandomStringMode = 'alphabetic' | 'alphanumeric' | 'lowercase' | 'lo
  * ```
  */
 export declare function randomString(length: number, mode?: RandomStringMode): string;
-//#endregion
 //# sourceMappingURL=string.d.ts.map

package/dist/string.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"string.d.ts","names":[],"sources":["../src/string.ts"],"mappings":";;;;YAGY;;;;;;;;;;;;;;;;;;;;;;;;;wBA8CI,aAAa,gBAAgB,OAAM"}
+{"version":3,"file":"string.d.ts","names":[],"sources":["../src/string.ts"],"mappings":";;;YAGY;;;;;;;;;;;;;;;;;;;;;;;;;wBA8CI,aAAa,gBAAgB,OAAM"}

package/dist/string.js

@@ -1,4 +1,4 @@
-//#region src/string.ts
+// src/string.ts
 const DIGITS = "0123456789";
 const LOWERCASE = "abcdefghijklmnopqrstuvwxyz";
 const UPPERCASE = "ABCDEFGHIJKLMNOPQRSTUVWXYZ";
@@ -41,7 +41,6 @@ function randomString(length, mode = "alphabetic") {
 	if (!charset) throw new Error(`Unsupported mode: ${mode}`);
 	return Array.from({ length }, () => charset[Math.floor(Math.random() * charset.length)]).join("");
 }
-//#endregion
 export { randomString };
 
 //# sourceMappingURL=string.js.map

package/dist/time.d.ts

@@ -1,4 +1,3 @@
-//#region src/time.d.ts
 /**
  * Waits until a duration elapses or cancellation occurs without rejecting on cancellation.
  *
@@ -45,5 +44,4 @@ export declare function delay(ms: number, signal?: AbortSignal): Promise<void>;
  * ```
  */
 export declare function delayOrThrow(ms: number, signal?: AbortSignal): Promise<void>;
-//#endregion
 //# sourceMappingURL=time.d.ts.map

package/dist/time.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"time.d.ts","names":[],"sources":["../src/time.ts"],"mappings":";;;;;;;;;;;;;;;;;;;;;wBAoBgB,MAAM,YAAY,SAAS,cAAc;;;;;;;;;;;;;;;;;;;;;;;;;wBA2CzC,aAAa,YAAY,SAAS,cAAc"}
+{"version":3,"file":"time.d.ts","names":[],"sources":["../src/time.ts"],"mappings":";;;;;;;;;;;;;;;;;;;;wBAoBgB,MAAM,YAAY,SAAS,cAAc;;;;;;;;;;;;;;;;;;;;;;;;;wBA2CzC,aAAa,YAAY,SAAS,cAAc"}

package/dist/time.js

@@ -1,4 +1,4 @@
-//#region src/time.ts
+// src/time.ts
 /**
 * Waits until a duration elapses or cancellation occurs without rejecting on cancellation.
 *
@@ -75,7 +75,6 @@ function delayOrThrow(ms, signal) {
 		signal?.addEventListener("abort", onAbort, { once: true });
 	});
 }
-//#endregion
 export { delay, delayOrThrow };
 
 //# sourceMappingURL=time.js.map

package/dist/types/filtered-key-path.d.ts

@@ -1,5 +1,4 @@
 import { ObjectId } from "bson";
-//#region src/types/filtered-key-path.d.ts
 type ConditionalPath<K extends number | string, V, U> = V extends U ? `${K}` : DefaultPath<K, V, U, never>;
 type DefaultPath<K extends number | string, V, U = never, RK = `${K}`> = V extends TerminalType ? RK : `${K}.${FilteredKeyPath<V, U>}`;
 /**
@@ -13,6 +12,5 @@ type IsTuple<T extends ReadonlyArray<any>> = number extends T['length'] ? false
 type PathImpl<K extends number | string, V, U> = [U] extends [never] ? DefaultPath<K, V> : ConditionalPath<K, V, U>;
 type TerminalType = bigint | Blob | boolean | Date | File | null | number | ObjectId | RegExp | string | symbol | undefined;
 type TupleKey<T extends ReadonlyArray<any>> = Exclude<keyof T, keyof any[]>;
-//#endregion
 export {};
 //# sourceMappingURL=filtered-key-path.d.ts.map

package/dist/types/filtered-key-path.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"filtered-key-path.d.ts","names":[],"sources":["../../src/types/filtered-key-path.ts"],"mappings":";;KAKK,gBAAgB,2BAA2B,GAAG,KAAK,UAAU,OAAO,MAAM,YAAY,GAAG,GAAG;KAC5F,YACD,2BACA,GACA,WACA,QAAQ,OACR,UAAU,eAAe,QAAQ,KAAK,gBAAgB,GAAG;;;;;;;YAUjD,gBAAgB,GAAG,aAAa,UAAU,oBAAoB,MAAM,QAAQ,qBAAqB,KAAK,SAAS,OAAO,SAAS,QAAQ,YAAY,EAAE,IAAI,MAAK,SAAS,MAAM,iBAAiB,GAAG,SAAS,WAAW,MAAM,SAAS,QAAQ,YAAY,EAAE,IAAI,YAAW;KAGhR,QAAQ,UAAU,qCAAqC;KACvD,SAAS,2BAA2B,GAAG,MAAM,qBAAqB,YAAY,GAAG,KAAK,gBAAgB,GAAG,GAAG;KAC5G,wBAED,iBAEA,OACA,uBAGA,WACA;KAKC,SAAS,UAAU,sBAAsB,cAAc"}
+{"version":3,"file":"filtered-key-path.d.ts","names":[],"sources":["../../src/types/filtered-key-path.ts"],"mappings":";KAKK,gBAAgB,2BAA2B,GAAG,KAAK,UAAU,OAAO,MAAM,YAAY,GAAG,GAAG;KAC5F,YACD,2BACA,GACA,WACA,QAAQ,OACR,UAAU,eAAe,QAAQ,KAAK,gBAAgB,GAAG;;;;;;;YAUjD,gBAAgB,GAAG,aAAa,UAAU,oBAAoB,MAAM,QAAQ,qBAAqB,KAAK,SAAS,OAAO,SAAS,QAAQ,YAAY,EAAE,IAAI,MAAK,SAAS,MAAM,iBAAiB,GAAG,SAAS,WAAW,MAAM,SAAS,QAAQ,YAAY,EAAE,IAAI,YAAW;KAGhR,QAAQ,UAAU,qCAAqC;KACvD,SAAS,2BAA2B,GAAG,MAAM,qBAAqB,YAAY,GAAG,KAAK,gBAAgB,GAAG,GAAG;KAC5G,wBAED,iBAEA,OACA,uBAGA,WACA;KAKC,SAAS,UAAU,sBAAsB,cAAc"}

package/dist/types/index.d.ts

@@ -1,10 +1,5 @@
 import { FilteredKeyPath } from "./filtered-key-path.js";
 import { Blob as Blob$1, Buffer, File as File$1 } from "node:buffer";
-//#region src/types/index.d.ts
-/**
- * A generic string-keyed object for utility APIs that intentionally accept any value shape.
- */
-export type AnyRecord = Record<string, any>;
 /**
  * Binary-like inputs accepted by `toBuffer` across browser and Node.js runtimes.
  */
@@ -21,10 +16,6 @@ export type MaybePartial<T> = Partial<T> | T;
  * Accepts either a mutable value or a readonly view of that value.
  */
 export type MaybeReadonly<T> = Readonly<T> | T;
-/**
- * Number-like value represented as a number or a numeric string.
- */
-export type Numberish = number | string;
 /**
  * A `Record` where every key is optional.
  */
@@ -37,6 +28,5 @@ export type ReadonlyPartialRecord<K extends keyof any, T> = Readonly<PartialReco
  * A readonly `Record`.
  */
 export type ReadonlyRecord<K extends keyof any, T> = Readonly<Record<K, T>>;
-//#endregion
 export type { FilteredKeyPath };
 //# sourceMappingURL=index.d.ts.map