@kikiutils/shared 20.0.1 → 20.1.1

package/dist/logger/types.d.ts

@@ -1,6 +1,11 @@
-/** Minimum severity to emit; `success` uses the same threshold as `info`. */
+import { SafePromise } from "../types/index.js";
+/**
+ * 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. */
+/**
+ * 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.
@@ -11,40 +16,60 @@ export type LoggerMethod = 'success' | Exclude<LoggerLevel, 'silent'>;
  */
 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. */
+  debug: (...args: unknown[]) => SafePromise<void>;
+  error: (...args: unknown[]) => SafePromise<void>;
+  fatal: (...args: unknown[]) => SafePromise<void>;
+  info: (...args: unknown[]) => SafePromise<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. */
+  /**
+   * 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>;
+  success: (...args: unknown[]) => SafePromise<void>;
+  trace: (...args: unknown[]) => SafePromise<void>;
+  warn: (...args: unknown[]) => SafePromise<void>;
 }
-/** A shallow-frozen failure notification; nested error values retain their original ownership. */
+/**
+ * A shallow-frozen failure notification; nested error values retain their original ownership.
+ */
 export interface LoggerDiagnostic {
   droppedCount?: number;
   error?: unknown;
   message: string;
-  /** Same-type notifications suppressed since the previous emitted diagnostic. */
+  /**
+   * 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. */
+/**
+ * Configuration shared by browser and server loggers.
+ */
 export interface LoggerOptions {
-  /** Enables console output. Defaults to `true`. */
+  /**
+   * Enables console output. Defaults to `true`.
+   */
   console?: boolean;
-  /** Enables Unicode level icons. Defaults to `true`. */
+  /**
+   * Enables Unicode level icons. Defaults to `true`.
+   */
   icons?: boolean;
-  /** Overrides LOG_LEVEL; `env` restores the environment-driven threshold. */
+  /**
+   * Overrides LOG_LEVEL; `env` restores the environment-driven threshold.
+   */
   level?: 'env' | LoggerLevel;
-  /** Best-effort, rate-limited notification; failures in this callback are contained. */
+  /**
+   * Best-effort, rate-limited notification; failures in this callback are contained.
+   */
   onError?: (event: Readonly<LoggerDiagnostic>) => void;
   prefix?: string;
   suffix?: string;
-  /** Enables the fixed local-time millisecond prefix. Defaults to `true`. */
+  /**
+   * Enables the fixed local-time millisecond prefix. Defaults to `true`.
+   */
   timestamp?: boolean;
 }
 //# sourceMappingURL=types.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"types.d.ts","names":[],"sources":["../../src/logger/types.ts"],"mappings":";YACY;;YAGA,2BAA2B,QAAQ;;;;;;;;iBAS9B;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,SAAS;EAC3B;EACA;;EAGA"}
+{"version":3,"file":"types.d.ts","names":[],"sources":["../../src/logger/types.ts"],"mappings":";;;;YAKY;;;;YAKA,2BAA2B,QAAQ;;;;;;;;iBAS9B;EACb,YAAY,SAAS,KAAK;EAC1B,WAAW,oBAAoB;EAC/B,WAAW,oBAAoB;EAC/B,WAAW,oBAAoB;EAC/B,UAAU,oBAAoB;;;;EAK9B,iBAAiB,OAAO,cAAc;;;;EAKtC,WAAW,eAAe;EAC1B,aAAa,oBAAoB;EACjC,WAAW,oBAAoB;EAC/B,UAAU,oBAAoB;;;;;iBAMjB;EACb;EACA;EACA;;;;EAKA;EACA;;;;;iBAMa;;;;EAIb;;;;EAKA;;;;EAKA,gBAAgB;;;;EAKhB,WAAW,OAAO,SAAS;EAC3B;EACA;;;;EAKA"}

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

@@ -12,7 +12,7 @@
  *
  * @returns A promise resolving to the Redis script result after execution completes.
  */
-export type RedisScriptRunner<T = unknown> = (keys: readonly string[], args: readonly (number | string)[]) => Promise<T>;
+export type RedisScriptRunner<T = unknown> = (keys: readonly string[], args: ReadonlyArray<number | string>) => Promise<T>;
 /**
  * A caller-owned Redis client exposing raw command execution.
  *

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,MAAM,mCAAmC,QAC5G;;;;;;;;;iBAWa;;;;;;;EAOb,OAAO,iBAAiB,mBAAmB;;;;;;;;;;;;;;;;;;;;;;;wBAwB/B,wBAAwB,aACpC,QAAQ,uBACR,gBACA,uBACD,kBAAkB"}

package/dist/redis/script-runner.js.map

@@ -1 +1 @@
-{"version":3,"file":"script-runner.js","names":[],"sources":["../../src/redis/script-runner.ts"],"sourcesContent":["import { createHash } from 'node:crypto';\n\n/**\n * An asynchronous Lua script runner with caller-declared results.\n *\n * @remarks\n * Input arrays are unchanged, and numeric arguments are converted to strings before execution.\n * Results are not cached or validated against the declared type.\n *\n * @typeParam T - The expected Lua result type, without runtime validation.\n *\n * @param keys - The script's Redis keys, in `KEYS` order.\n * @param args - The script's arguments, in `ARGV` order.\n *\n * @returns A promise resolving to the Redis script result after execution completes.\n */\nexport type RedisScriptRunner<T = unknown> = (keys: readonly string[], args: readonly (number | string)[]) => Promise<\n    T\n>;\n\n/**\n * A caller-owned Redis client exposing raw command execution.\n *\n * @remarks\n * The client manages connections and command routing. `SCRIPT LOAD` and `EVALSHA` must target the same server\n * for script-cache recovery to succeed. Missing-script rejections must be `Error` instances whose messages\n * begin with the Redis error code `NOSCRIPT`, followed by whitespace or the end of the message.\n */\nexport interface RedisLikeScriptClient {\n    /**\n     * Sends a raw Redis command and resolves to its reply, or rejects on failure.\n     *\n     * @param command - The Redis command name.\n     * @param args - The command arguments in protocol order.\n     */\n    send: (command: string, args: string[]) => Promise<unknown>;\n}\n\n/**\n * Creates a Lua script runner that reloads missing cached scripts before retrying execution.\n *\n * @remarks\n * Calls use `EVALSHA` with the SHA-1 digest of the source. A `NOSCRIPT` rejection loads the script with\n * `SCRIPT LOAD` before another execution attempt, provided the attempt limit has not been reached.\n * Concurrent cache misses on the same runner share an in-flight load; reuse the runner to share that load.\n * Load failures and errors other than `NOSCRIPT` propagate without retries. The final execution error is\n * preserved when the attempt limit is reached. The runner does not cache results or close the client.\n *\n * @typeParam T - The expected Lua result type, without runtime validation.\n *\n * @param client - The caller-owned client used for raw Redis commands.\n * @param source - The Lua source loaded when the script is absent from the server's cache.\n * @param maxAttempts - The maximum `EVALSHA` attempts per invocation, including the initial attempt.\n * Must be a positive safe integer. Defaults to `3`; `1` disables script loading and retries.\n *\n * @returns A reusable runner sharing the client and any in-flight script load.\n *\n * @throws RangeError if `maxAttempts` is not a positive safe integer.\n */\nexport function createRedisScriptRunner<T = unknown>(\n    client: RedisLikeScriptClient,\n    source: string,\n    maxAttempts: number = 3,\n): RedisScriptRunner<T> {\n    if (!Number.isSafeInteger(maxAttempts) || maxAttempts < 1) {\n        throw new RangeError('maxAttempts must be a positive safe integer');\n    }\n\n    const digest = createHash('sha1').update(source).digest('hex');\n    let loadingPromise: Promise<unknown> | undefined;\n\n    return async (keys, args) => {\n        for (let attempt = 1; ; attempt += 1) {\n            try {\n                return await client.send(\n                    'EVALSHA',\n                    [\n                        digest,\n                        String(keys.length),\n                        ...keys,\n                        ...args.map(String),\n                    ],\n                ) as T;\n            } catch (error) {\n                if (\n                    !(error instanceof Error)\n                    || !/^NOSCRIPT(?:\\s|$)/.test(error.message)\n                    || attempt >= maxAttempts\n                ) throw error;\n\n                if (loadingPromise === undefined) {\n                    loadingPromise = client\n                        .send(\n                            'SCRIPT',\n                            [\n                                'LOAD',\n                                source,\n                            ],\n                        )\n                        .finally(() => loadingPromise = undefined);\n                }\n\n                await loadingPromise;\n            }\n        }\n    };\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;AA2DA,SAAgB,wBACZ,QACA,QACA,cAAsB,GACF;CACpB,IAAI,CAAC,OAAO,cAAc,WAAW,KAAK,cAAc,GACpD,MAAM,IAAI,WAAW,6CAA6C;CAGtE,MAAM,SAAS,WAAW,MAAM,CAAC,CAAC,OAAO,MAAM,CAAC,CAAC,OAAO,KAAK;CAC7D,IAAI;CAEJ,OAAO,OAAO,MAAM,SAAS;EACzB,KAAK,IAAI,UAAU,IAAK,WAAW,GAC/B,IAAI;GACA,OAAO,MAAM,OAAO,KAChB,WACA;IACI;IACA,OAAO,KAAK,MAAM;IAClB,GAAG;IACH,GAAG,KAAK,IAAI,MAAM;GACtB,CACJ;EACJ,SAAS,OAAO;GACZ,IACI,EAAE,iBAAiB,UAChB,CAAC,oBAAoB,KAAK,MAAM,OAAO,KACvC,WAAW,aAChB,MAAM;GAER,IAAI,mBAAmB,KAAA,GACnB,iBAAiB,OACZ,KACG,UACA,CACI,QACA,MACJ,CACJ,CAAC,CACA,cAAc,iBAAiB,KAAA,CAAS;GAGjD,MAAM;EACV;CAER;AACJ"}
+{"version":3,"file":"script-runner.js","names":[],"sources":["../../src/redis/script-runner.ts"],"sourcesContent":["import { createHash } from 'node:crypto';\n\n/**\n * An asynchronous Lua script runner with caller-declared results.\n *\n * @remarks\n * Input arrays are unchanged, and numeric arguments are converted to strings before execution.\n * Results are not cached or validated against the declared type.\n *\n * @typeParam T - The expected Lua result type, without runtime validation.\n *\n * @param keys - The script's Redis keys, in `KEYS` order.\n * @param args - The script's arguments, in `ARGV` order.\n *\n * @returns A promise resolving to the Redis script result after execution completes.\n */\nexport type RedisScriptRunner<T = unknown> = (keys: readonly string[], args: ReadonlyArray<number | string>) => Promise<\n    T\n>;\n\n/**\n * A caller-owned Redis client exposing raw command execution.\n *\n * @remarks\n * The client manages connections and command routing. `SCRIPT LOAD` and `EVALSHA` must target the same server\n * for script-cache recovery to succeed. Missing-script rejections must be `Error` instances whose messages\n * begin with the Redis error code `NOSCRIPT`, followed by whitespace or the end of the message.\n */\nexport interface RedisLikeScriptClient {\n    /**\n     * Sends a raw Redis command and resolves to its reply, or rejects on failure.\n     *\n     * @param command - The Redis command name.\n     * @param args - The command arguments in protocol order.\n     */\n    send: (command: string, args: string[]) => Promise<unknown>;\n}\n\n/**\n * Creates a Lua script runner that reloads missing cached scripts before retrying execution.\n *\n * @remarks\n * Calls use `EVALSHA` with the SHA-1 digest of the source. A `NOSCRIPT` rejection loads the script with\n * `SCRIPT LOAD` before another execution attempt, provided the attempt limit has not been reached.\n * Concurrent cache misses on the same runner share an in-flight load; reuse the runner to share that load.\n * Load failures and errors other than `NOSCRIPT` propagate without retries. The final execution error is\n * preserved when the attempt limit is reached. The runner does not cache results or close the client.\n *\n * @typeParam T - The expected Lua result type, without runtime validation.\n *\n * @param client - The caller-owned client used for raw Redis commands.\n * @param source - The Lua source loaded when the script is absent from the server's cache.\n * @param maxAttempts - The maximum `EVALSHA` attempts per invocation, including the initial attempt.\n * Must be a positive safe integer. Defaults to `3`; `1` disables script loading and retries.\n *\n * @returns A reusable runner sharing the client and any in-flight script load.\n *\n * @throws RangeError if `maxAttempts` is not a positive safe integer.\n */\nexport function createRedisScriptRunner<T = unknown>(\n    client: RedisLikeScriptClient,\n    source: string,\n    maxAttempts: number = 3,\n): RedisScriptRunner<T> {\n    if (!Number.isSafeInteger(maxAttempts) || maxAttempts < 1) {\n        throw new RangeError('maxAttempts must be a positive safe integer');\n    }\n\n    const digest = createHash('sha1').update(source).digest('hex');\n    let loadingPromise: Promise<unknown> | undefined;\n\n    return async (keys, args) => {\n        for (let attempt = 1; ; attempt += 1) {\n            try {\n                return await client.send(\n                    'EVALSHA',\n                    [\n                        digest,\n                        String(keys.length),\n                        ...keys,\n                        ...args.map(String),\n                    ],\n                ) as T;\n            } catch (error) {\n                if (\n                    !(error instanceof Error)\n                    || !/^NOSCRIPT(?:\\s|$)/.test(error.message)\n                    || attempt >= maxAttempts\n                ) throw error;\n\n                if (loadingPromise === undefined) {\n                    loadingPromise = client\n                        .send(\n                            'SCRIPT',\n                            [\n                                'LOAD',\n                                source,\n                            ],\n                        )\n                        .finally(() => loadingPromise = undefined);\n                }\n\n                await loadingPromise;\n            }\n        }\n    };\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;AA2DA,SAAgB,wBACZ,QACA,QACA,cAAsB,GACF;CACpB,IAAI,CAAC,OAAO,cAAc,WAAW,KAAK,cAAc,GACpD,MAAM,IAAI,WAAW,6CAA6C;CAGtE,MAAM,SAAS,WAAW,MAAM,CAAC,CAAC,OAAO,MAAM,CAAC,CAAC,OAAO,KAAK;CAC7D,IAAI;CAEJ,OAAO,OAAO,MAAM,SAAS;EACzB,KAAK,IAAI,UAAU,IAAK,WAAW,GAC/B,IAAI;GACA,OAAO,MAAM,OAAO,KAChB,WACA;IACI;IACA,OAAO,KAAK,MAAM;IAClB,GAAG;IACH,GAAG,KAAK,IAAI,MAAM;GACtB,CACJ;EACJ,SAAS,OAAO;GACZ,IACI,EAAE,iBAAiB,UAChB,CAAC,oBAAoB,KAAK,MAAM,OAAO,KACvC,WAAW,aAChB,MAAM;GAER,IAAI,mBAAmB,KAAA,GACnB,iBAAiB,OACZ,KACG,UACA,CACI,QACA,MACJ,CACJ,CAAC,CACA,cAAc,iBAAiB,KAAA,CAAS;GAGjD,MAAM;EACV;CAER;AACJ"}

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;EACtB,sBAAA,MAAA,MAAC,QAAA;EACV,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;EAGpB,uBAAA,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;EAChB,sBAAA,MAAA,MAAC,QAAA;EACV,aAAA,MAAA,MAAC,QAAA;EACE,gBAAA,MAAA,MAAC;EACJ,aAAA,MAAA,MAAC;EACE,gBAAA,MAAA,MAAC;EACP,gBAAA,MAAA;EACC,UAAA,OAAA,MAAC,MAAW,MAAC;EACH,eAAA,oBAAM,OAAS,MAAC,MAAW,IAAC;EAGpB,uBAAA,oBAAM,OAAS,MAAC,MAAW,IAAC"}

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

@@ -17,18 +17,18 @@
 */
 function createRedisKeyedStore(storage) {
 	return (keyFn) => Object.freeze({
-		getAndRemoveItem: (...args) => storage.getAndRemoveItem(keyFn(...args)),
-		getItem: (...args) => storage.getItem(keyFn(...args)),
-		getItemTtl: (...args) => storage.getItemTtl(keyFn(...args)),
-		hasItem: (...args) => storage.hasItem(keyFn(...args)),
-		removeItem: (...args) => storage.removeItem(keyFn(...args)),
+		getAndRemoveItem: async (...args) => await storage.getAndRemoveItem(keyFn(...args)),
+		getItem: async (...args) => await storage.getItem(keyFn(...args)),
+		getItemTtl: async (...args) => await storage.getItemTtl(keyFn(...args)),
+		hasItem: async (...args) => await storage.hasItem(keyFn(...args)),
+		removeItem: async (...args) => await storage.removeItem(keyFn(...args)),
 		resolveKey: (...args) => keyFn(...args),
-		setItem: (value, ...args) => storage.setItem(keyFn(...args), value),
-		setItemWithTtl(ttlSeconds, value, ...args) {
-			return storage.setItemWithTtl(keyFn(...args), ttlSeconds, value);
+		setItem: async (value, ...args) => await storage.setItem(keyFn(...args), value),
+		async setItemWithTtl(ttlSeconds, value, ...args) {
+			return await storage.setItemWithTtl(keyFn(...args), ttlSeconds, value);
 		},
-		setItemWithTtlIfAbsent(ttlSeconds, value, ...args) {
-			return storage.setItemWithTtlIfAbsent(keyFn(...args), ttlSeconds, value);
+		async setItemWithTtlIfAbsent(ttlSeconds, value, ...args) {
+			return await storage.setItemWithTtlIfAbsent(keyFn(...args), ttlSeconds, value);
 		}
 	});
 }

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

@@ -1 +1 @@
-{"version":3,"file":"keyed-store.js","names":[],"sources":["../../../src/storages/redis/keyed-store.ts"],"sourcesContent":["import type { MaybeReadonly } from '../../types';\n\nimport type { RedisLikeStorage } from './types';\n\n/**\n * Creates a keyed store factory sharing a caller-owned Redis-like storage facade.\n *\n * @remarks\n * The key resolver is called synchronously once per operation with the operation's key arguments.\n * Resolver exceptions propagate synchronously; asynchronous storage failures retain the underlying rejection.\n * `setItemWithTtl` and `setItemWithTtlIfAbsent` accept their TTL in seconds before the value and key arguments.\n * The factory does not open or close the underlying connection; cleanup remains the caller's responsibility.\n *\n * @typeParam D - The stored value type used by reads and writes.\n *\n * @param storage - The shared Redis-like storage instance.\n *\n * @returns A factory accepting a key resolver and returning a new frozen keyed facade sharing the storage.\n * Reads, atomic read-and-removals, writes, removals, and TTL results retain the underlying storage contract.\n */\nexport function createRedisKeyedStore<D = unknown>(storage: MaybeReadonly<RedisLikeStorage>) {\n    return <P extends any[]>(keyFn: (...args: P) => string) => Object.freeze({\n        getAndRemoveItem: (...args: P) => storage.getAndRemoveItem<D>(keyFn(...args)),\n        getItem: (...args: P) => storage.getItem<D>(keyFn(...args)),\n        getItemTtl: (...args: P) => storage.getItemTtl(keyFn(...args)),\n        hasItem: (...args: P) => storage.hasItem(keyFn(...args)),\n        removeItem: (...args: P) => storage.removeItem(keyFn(...args)),\n        resolveKey: (...args: P) => keyFn(...args),\n        setItem: (value: D, ...args: P) => storage.setItem(keyFn(...args), value),\n        setItemWithTtl(ttlSeconds: number, value: D, ...args: P) {\n            return storage.setItemWithTtl(keyFn(...args), ttlSeconds, value);\n        },\n        setItemWithTtlIfAbsent(ttlSeconds: number, value: D, ...args: P) {\n            return storage.setItemWithTtlIfAbsent(keyFn(...args), ttlSeconds, value);\n        },\n    });\n}\n"],"mappings":";;;;;;;;;;;;;;;;;AAoBA,SAAgB,sBAAmC,SAA0C;CACzF,QAAyB,UAAkC,OAAO,OAAO;EACrE,mBAAmB,GAAG,SAAY,QAAQ,iBAAoB,MAAM,GAAG,IAAI,CAAC;EAC5E,UAAU,GAAG,SAAY,QAAQ,QAAW,MAAM,GAAG,IAAI,CAAC;EAC1D,aAAa,GAAG,SAAY,QAAQ,WAAW,MAAM,GAAG,IAAI,CAAC;EAC7D,UAAU,GAAG,SAAY,QAAQ,QAAQ,MAAM,GAAG,IAAI,CAAC;EACvD,aAAa,GAAG,SAAY,QAAQ,WAAW,MAAM,GAAG,IAAI,CAAC;EAC7D,aAAa,GAAG,SAAY,MAAM,GAAG,IAAI;EACzC,UAAU,OAAU,GAAG,SAAY,QAAQ,QAAQ,MAAM,GAAG,IAAI,GAAG,KAAK;EACxE,eAAe,YAAoB,OAAU,GAAG,MAAS;GACrD,OAAO,QAAQ,eAAe,MAAM,GAAG,IAAI,GAAG,YAAY,KAAK;EACnE;EACA,uBAAuB,YAAoB,OAAU,GAAG,MAAS;GAC7D,OAAO,QAAQ,uBAAuB,MAAM,GAAG,IAAI,GAAG,YAAY,KAAK;EAC3E;CACJ,CAAC;AACL"}
+{"version":3,"file":"keyed-store.js","names":[],"sources":["../../../src/storages/redis/keyed-store.ts"],"sourcesContent":["import type { MaybeReadonly } from '../../types';\n\nimport type { RedisLikeStorage } from './types';\n\n/**\n * Creates a keyed store factory sharing a caller-owned Redis-like storage facade.\n *\n * @remarks\n * The key resolver is called synchronously once per operation with the operation's key arguments.\n * Resolver exceptions propagate synchronously; asynchronous storage failures retain the underlying rejection.\n * `setItemWithTtl` and `setItemWithTtlIfAbsent` accept their TTL in seconds before the value and key arguments.\n * The factory does not open or close the underlying connection; cleanup remains the caller's responsibility.\n *\n * @typeParam D - The stored value type used by reads and writes.\n *\n * @param storage - The shared Redis-like storage instance.\n *\n * @returns A factory accepting a key resolver and returning a new frozen keyed facade sharing the storage.\n * Reads, atomic read-and-removals, writes, removals, and TTL results retain the underlying storage contract.\n */\nexport function createRedisKeyedStore<D = unknown>(storage: MaybeReadonly<RedisLikeStorage>) {\n    return <P extends any[]>(keyFn: (...args: P) => string) => Object.freeze({\n        getAndRemoveItem: async (...args: P) => await storage.getAndRemoveItem<D>(keyFn(...args)),\n        getItem: async (...args: P) => await storage.getItem<D>(keyFn(...args)),\n        getItemTtl: async (...args: P) => await storage.getItemTtl(keyFn(...args)),\n        hasItem: async (...args: P) => await storage.hasItem(keyFn(...args)),\n        removeItem: async (...args: P) => await storage.removeItem(keyFn(...args)),\n        resolveKey: (...args: P) => keyFn(...args),\n        setItem: async (value: D, ...args: P) => await storage.setItem(keyFn(...args), value),\n        async setItemWithTtl(ttlSeconds: number, value: D, ...args: P) {\n            return await storage.setItemWithTtl(keyFn(...args), ttlSeconds, value);\n        },\n        async setItemWithTtlIfAbsent(ttlSeconds: number, value: D, ...args: P) {\n            return await storage.setItemWithTtlIfAbsent(keyFn(...args), ttlSeconds, value);\n        },\n    });\n}\n"],"mappings":";;;;;;;;;;;;;;;;;AAoBA,SAAgB,sBAAmC,SAA0C;CACzF,QAAyB,UAAkC,OAAO,OAAO;EACrE,kBAAkB,OAAO,GAAG,SAAY,MAAM,QAAQ,iBAAoB,MAAM,GAAG,IAAI,CAAC;EACxF,SAAS,OAAO,GAAG,SAAY,MAAM,QAAQ,QAAW,MAAM,GAAG,IAAI,CAAC;EACtE,YAAY,OAAO,GAAG,SAAY,MAAM,QAAQ,WAAW,MAAM,GAAG,IAAI,CAAC;EACzE,SAAS,OAAO,GAAG,SAAY,MAAM,QAAQ,QAAQ,MAAM,GAAG,IAAI,CAAC;EACnE,YAAY,OAAO,GAAG,SAAY,MAAM,QAAQ,WAAW,MAAM,GAAG,IAAI,CAAC;EACzE,aAAa,GAAG,SAAY,MAAM,GAAG,IAAI;EACzC,SAAS,OAAO,OAAU,GAAG,SAAY,MAAM,QAAQ,QAAQ,MAAM,GAAG,IAAI,GAAG,KAAK;EACpF,MAAM,eAAe,YAAoB,OAAU,GAAG,MAAS;GAC3D,OAAO,MAAM,QAAQ,eAAe,MAAM,GAAG,IAAI,GAAG,YAAY,KAAK;EACzE;EACA,MAAM,uBAAuB,YAAoB,OAAU,GAAG,MAAS;GACnE,OAAO,MAAM,QAAQ,uBAAuB,MAAM,GAAG,IAAI,GAAG,YAAY,KAAK;EACjF;CACJ,CAAC;AACL"}

package/dist/storages/redis/msgpack.js

@@ -61,8 +61,8 @@ function createRedisMsgpackStorage(adapter) {
 			const rawValue = await adapter.getBuffer(key);
 			return rawValue ? decode(rawValue) : null;
 		},
-		getItemTtl: (key) => adapter.ttl(key),
-		hasItem: (key) => adapter.has(key),
+		getItemTtl: async (key) => await adapter.ttl(key),
+		hasItem: async (key) => await adapter.has(key),
 		removeItem: async (key) => await adapter.delete(key) === 1,
 		setItem: async (key, value) => await adapter.setBuffer(key, encode(value)) === "OK",
 		async setItemWithTtl(key, ttlSeconds, value) {

package/dist/storages/redis/msgpack.js.map

@@ -1 +1 @@
-{"version":3,"file":"msgpack.js","names":[],"sources":["../../../src/storages/redis/msgpack.ts"],"sourcesContent":["import {\n    decode,\n    encode,\n    isNativeAccelerationEnabled,\n} from 'msgpackr';\n\nimport type {\n    RedisLikeAdapter,\n    RedisLikeStorage,\n} from './types';\n\nif (!isNativeAccelerationEnabled) {\n    console.warn('Native acceleration not enabled for msgpackr, verify that install finished properly');\n}\n\n/**\n * Creates a frozen Redis-like storage facade using MessagePack serialization.\n *\n * @remarks\n * Adapter rejections and MessagePack serialization errors propagate to the caller.\n * Reads resolve to `null` when no raw value exists; `getAndRemoveItem` reads and deletes in one atomic adapter call.\n * Writes resolve to `true` only when the adapter returns `OK`;\n * removal resolves to `true` only when exactly one key is deleted.\n * The adapter remains caller-owned; creating the facade does not open or close a connection.\n *\n * @param adapter - The caller-owned adapter for raw binary operations.\n *\n * @returns A new frozen facade sharing the supplied adapter.\n *\n * @example\n *\n * ```ts\n * import { createRedisMsgpackStorage } from '@kikiutils/shared/storages/redis/msgpack';\n * import type { RedisLikeAdapter } from '@kikiutils/shared/storages/redis/types';\n *\n * // This in-memory adapter demonstrates non-expiring operations without an external service.\n * const values = new Map<string, Uint8Array>();\n * const adapter: RedisLikeAdapter = {\n *     delete: async (key) => values.delete(key) ? 1 : 0,\n *     getBuffer: async (key) => values.get(key) ?? null,\n *     getBufferAndDelete: async (key) => {\n *         const value = values.get(key) ?? null;\n *         values.delete(key);\n *         return value;\n *     },\n *     has: async (key) => values.has(key),\n *     setBuffer: async (key, value) => {\n *         values.set(key, value);\n *         return 'OK';\n *     },\n *     setBufferEx: async () => {\n *         throw new Error('TTL writes are not supported by this example adapter');\n *     },\n *     setBufferExNx: async () => {\n *         throw new Error('TTL writes are not supported by this example adapter');\n *     },\n *     ttl: async (key) => values.has(key) ? -1 : -2,\n * };\n *\n * const storage = createRedisMsgpackStorage(adapter);\n * await storage.setItem('profile', { name: 'Alice' });\n * const profile = await storage.getItem<{ name: string }>('profile');\n * console.log(profile); // => { name: 'Alice' }\n * ```\n */\nexport function createRedisMsgpackStorage(adapter: RedisLikeAdapter): Readonly<RedisLikeStorage> {\n    return Object.freeze({\n        async getAndRemoveItem<T = unknown>(key: string) {\n            const rawValue = await adapter.getBufferAndDelete(key);\n            return rawValue ? decode(rawValue) as T : null;\n        },\n        async getItem<T = unknown>(key: string) {\n            const rawValue = await adapter.getBuffer(key);\n            return rawValue ? decode(rawValue) as T : null;\n        },\n        getItemTtl: (key: string) => adapter.ttl(key),\n        hasItem: (key: string) => adapter.has(key),\n        removeItem: async (key: string) => await adapter.delete(key) === 1,\n        setItem: async (key: string, value: any) => await adapter.setBuffer(key, encode(value)) === 'OK',\n        async setItemWithTtl(key: string, ttlSeconds: number, value: any) {\n            return await adapter.setBufferEx(key, ttlSeconds, encode(value)) === 'OK';\n        },\n        async setItemWithTtlIfAbsent(key: string, ttlSeconds: number, value: any) {\n            return await adapter.setBufferExNx(key, ttlSeconds, encode(value)) === 'OK';\n        },\n    });\n}\n"],"mappings":";;AAWA,IAAI,CAAC,6BACD,QAAQ,KAAK,qFAAqF;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAqDtG,SAAgB,0BAA0B,SAAuD;CAC7F,OAAO,OAAO,OAAO;EACjB,MAAM,iBAA8B,KAAa;GAC7C,MAAM,WAAW,MAAM,QAAQ,mBAAmB,GAAG;GACrD,OAAO,WAAW,OAAO,QAAQ,IAAS;EAC9C;EACA,MAAM,QAAqB,KAAa;GACpC,MAAM,WAAW,MAAM,QAAQ,UAAU,GAAG;GAC5C,OAAO,WAAW,OAAO,QAAQ,IAAS;EAC9C;EACA,aAAa,QAAgB,QAAQ,IAAI,GAAG;EAC5C,UAAU,QAAgB,QAAQ,IAAI,GAAG;EACzC,YAAY,OAAO,QAAgB,MAAM,QAAQ,OAAO,GAAG,MAAM;EACjE,SAAS,OAAO,KAAa,UAAe,MAAM,QAAQ,UAAU,KAAK,OAAO,KAAK,CAAC,MAAM;EAC5F,MAAM,eAAe,KAAa,YAAoB,OAAY;GAC9D,OAAO,MAAM,QAAQ,YAAY,KAAK,YAAY,OAAO,KAAK,CAAC,MAAM;EACzE;EACA,MAAM,uBAAuB,KAAa,YAAoB,OAAY;GACtE,OAAO,MAAM,QAAQ,cAAc,KAAK,YAAY,OAAO,KAAK,CAAC,MAAM;EAC3E;CACJ,CAAC;AACL"}
+{"version":3,"file":"msgpack.js","names":[],"sources":["../../../src/storages/redis/msgpack.ts"],"sourcesContent":["import {\n    decode,\n    encode,\n    isNativeAccelerationEnabled,\n} from 'msgpackr';\n\nimport type {\n    RedisLikeAdapter,\n    RedisLikeStorage,\n} from './types';\n\nif (!isNativeAccelerationEnabled) {\n    console.warn('Native acceleration not enabled for msgpackr, verify that install finished properly');\n}\n\n/**\n * Creates a frozen Redis-like storage facade using MessagePack serialization.\n *\n * @remarks\n * Adapter rejections and MessagePack serialization errors propagate to the caller.\n * Reads resolve to `null` when no raw value exists; `getAndRemoveItem` reads and deletes in one atomic adapter call.\n * Writes resolve to `true` only when the adapter returns `OK`;\n * removal resolves to `true` only when exactly one key is deleted.\n * The adapter remains caller-owned; creating the facade does not open or close a connection.\n *\n * @param adapter - The caller-owned adapter for raw binary operations.\n *\n * @returns A new frozen facade sharing the supplied adapter.\n *\n * @example\n *\n * ```ts\n * import { createRedisMsgpackStorage } from '@kikiutils/shared/storages/redis/msgpack';\n * import type { RedisLikeAdapter } from '@kikiutils/shared/storages/redis/types';\n *\n * // This in-memory adapter demonstrates non-expiring operations without an external service.\n * const values = new Map<string, Uint8Array>();\n * const adapter: RedisLikeAdapter = {\n *     delete: async (key) => values.delete(key) ? 1 : 0,\n *     getBuffer: async (key) => values.get(key) ?? null,\n *     getBufferAndDelete: async (key) => {\n *         const value = values.get(key) ?? null;\n *         values.delete(key);\n *         return value;\n *     },\n *     has: async (key) => values.has(key),\n *     setBuffer: async (key, value) => {\n *         values.set(key, value);\n *         return 'OK';\n *     },\n *     setBufferEx: async () => {\n *         throw new Error('TTL writes are not supported by this example adapter');\n *     },\n *     setBufferExNx: async () => {\n *         throw new Error('TTL writes are not supported by this example adapter');\n *     },\n *     ttl: async (key) => values.has(key) ? -1 : -2,\n * };\n *\n * const storage = createRedisMsgpackStorage(adapter);\n * await storage.setItem('profile', { name: 'Alice' });\n * const profile = await storage.getItem<{ name: string }>('profile');\n * console.log(profile); // => { name: 'Alice' }\n * ```\n */\nexport function createRedisMsgpackStorage(adapter: RedisLikeAdapter): Readonly<RedisLikeStorage> {\n    return Object.freeze({\n        async getAndRemoveItem<T = unknown>(key: string) {\n            const rawValue = await adapter.getBufferAndDelete(key);\n            return rawValue ? decode(rawValue) as T : null;\n        },\n        async getItem<T = unknown>(key: string) {\n            const rawValue = await adapter.getBuffer(key);\n            return rawValue ? decode(rawValue) as T : null;\n        },\n        getItemTtl: async (key: string) => await adapter.ttl(key),\n        hasItem: async (key: string) => await adapter.has(key),\n        removeItem: async (key: string) => await adapter.delete(key) === 1,\n        setItem: async (key: string, value: any) => await adapter.setBuffer(key, encode(value)) === 'OK',\n        async setItemWithTtl(key: string, ttlSeconds: number, value: any) {\n            return await adapter.setBufferEx(key, ttlSeconds, encode(value)) === 'OK';\n        },\n        async setItemWithTtlIfAbsent(key: string, ttlSeconds: number, value: any) {\n            return await adapter.setBufferExNx(key, ttlSeconds, encode(value)) === 'OK';\n        },\n    });\n}\n"],"mappings":";;AAWA,IAAI,CAAC,6BACD,QAAQ,KAAK,qFAAqF;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAqDtG,SAAgB,0BAA0B,SAAuD;CAC7F,OAAO,OAAO,OAAO;EACjB,MAAM,iBAA8B,KAAa;GAC7C,MAAM,WAAW,MAAM,QAAQ,mBAAmB,GAAG;GACrD,OAAO,WAAW,OAAO,QAAQ,IAAS;EAC9C;EACA,MAAM,QAAqB,KAAa;GACpC,MAAM,WAAW,MAAM,QAAQ,UAAU,GAAG;GAC5C,OAAO,WAAW,OAAO,QAAQ,IAAS;EAC9C;EACA,YAAY,OAAO,QAAgB,MAAM,QAAQ,IAAI,GAAG;EACxD,SAAS,OAAO,QAAgB,MAAM,QAAQ,IAAI,GAAG;EACrD,YAAY,OAAO,QAAgB,MAAM,QAAQ,OAAO,GAAG,MAAM;EACjE,SAAS,OAAO,KAAa,UAAe,MAAM,QAAQ,UAAU,KAAK,OAAO,KAAK,CAAC,MAAM;EAC5F,MAAM,eAAe,KAAa,YAAoB,OAAY;GAC9D,OAAO,MAAM,QAAQ,YAAY,KAAK,YAAY,OAAO,KAAK,CAAC,MAAM;EACzE;EACA,MAAM,uBAAuB,KAAa,YAAoB,OAAY;GACtE,OAAO,MAAM,QAAQ,cAAc,KAAK,YAAY,OAAO,KAAK,CAAC,MAAM;EAC3E;CACJ,CAAC;AACL"}

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":";;;;;;;;;;;;;;;;;;;;wBAoBsB,MAAM,YAAY,SAAS,cAAc;;;;;;;;;;;;;;;;;;;;;;;;;wBA2CzC,aAAa,YAAY,SAAS,cAAc"}

package/dist/time.js

@@ -19,8 +19,8 @@
 * await delay(5000, controller.signal);
 * ```
 */
-function delay(ms, signal) {
-	return new Promise((resolve) => {
+async function delay(ms, signal) {
+	return await new Promise((resolve) => {
 		if (signal?.aborted) {
 			resolve();
 			return;
@@ -58,8 +58,8 @@ function delay(ms, signal) {
 * }
 * ```
 */
-function delayOrThrow(ms, signal) {
-	return new Promise((resolve, reject) => {
+async function delayOrThrow(ms, signal) {
+	return await new Promise((resolve, reject) => {
 		if (signal?.aborted) {
 			reject(signal.reason);
 			return;

package/dist/time.js.map

@@ -1 +1 @@
-{"version":3,"file":"time.js","names":[],"sources":["../src/time.ts"],"sourcesContent":["/**\n * Waits until a duration elapses or cancellation occurs without rejecting on cancellation.\n *\n * @remarks\n * The promise resolves without a value when the timer completes or the signal aborts.\n * An already aborted signal resolves immediately; completion removes the abort listener and clears the timer.\n *\n * @param ms - The delay duration in milliseconds, using native `setTimeout` timing rules.\n * @param signal - The signal that ends the wait early.\n *\n * @example\n *\n * ```ts\n * import { delay } from '@kikiutils/shared/time';\n *\n * const controller = new AbortController();\n * controller.abort();\n * await delay(5000, controller.signal);\n * ```\n */\nexport function delay(ms: number, signal?: AbortSignal): Promise<void> {\n    return new Promise((resolve) => {\n        if (signal?.aborted) {\n            resolve();\n            return;\n        }\n\n        const done = () => {\n            // eslint-disable-next-line ts/no-use-before-define\n            clearTimeout(timeout);\n            signal?.removeEventListener('abort', done);\n            resolve();\n        };\n\n        const timeout = setTimeout(done, ms);\n        signal?.addEventListener('abort', done, { once: true });\n    });\n}\n\n/**\n * Waits until a duration elapses and rejects on cancellation.\n *\n * @remarks\n * The promise resolves without a value when the timer completes and rejects with `signal.reason` if aborted.\n * An already aborted signal rejects immediately. Aborting clears the timer; timer completion removes the listener.\n *\n * @param ms - The delay duration in milliseconds, using native `setTimeout` timing rules.\n * @param signal - The signal that cancels the wait.\n *\n * @example\n *\n * ```ts\n * import { delayOrThrow } from '@kikiutils/shared/time';\n *\n * const controller = new AbortController();\n * controller.abort(new Error('Canceled'));\n * try {\n *     await delayOrThrow(5000, controller.signal);\n * } catch (error) {\n *     console.error(error);\n * }\n * ```\n */\nexport function delayOrThrow(ms: number, signal?: AbortSignal): Promise<void> {\n    return new Promise((resolve, reject) => {\n        if (signal?.aborted) {\n            reject(signal.reason);\n            return;\n        }\n\n        const onAbort = () => {\n            // eslint-disable-next-line ts/no-use-before-define\n            clearTimeout(timeout);\n            reject(signal!.reason);\n        };\n\n        const timeout = setTimeout(\n            () => {\n                signal?.removeEventListener('abort', onAbort);\n                resolve();\n            },\n            ms,\n        );\n\n        signal?.addEventListener('abort', onAbort, { once: true });\n    });\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;AAoBA,SAAgB,MAAM,IAAY,QAAqC;CACnE,OAAO,IAAI,SAAS,YAAY;EAC5B,IAAI,QAAQ,SAAS;GACjB,QAAQ;GACR;EACJ;EAEA,MAAM,aAAa;GAEf,aAAa,OAAO;GACpB,QAAQ,oBAAoB,SAAS,IAAI;GACzC,QAAQ;EACZ;EAEA,MAAM,UAAU,WAAW,MAAM,EAAE;EACnC,QAAQ,iBAAiB,SAAS,MAAM,EAAE,MAAM,KAAK,CAAC;CAC1D,CAAC;AACL;;;;;;;;;;;;;;;;;;;;;;;;;AA0BA,SAAgB,aAAa,IAAY,QAAqC;CAC1E,OAAO,IAAI,SAAS,SAAS,WAAW;EACpC,IAAI,QAAQ,SAAS;GACjB,OAAO,OAAO,MAAM;GACpB;EACJ;EAEA,MAAM,gBAAgB;GAElB,aAAa,OAAO;GACpB,OAAO,OAAQ,MAAM;EACzB;EAEA,MAAM,UAAU,iBACN;GACF,QAAQ,oBAAoB,SAAS,OAAO;GAC5C,QAAQ;EACZ,GACA,EACJ;EAEA,QAAQ,iBAAiB,SAAS,SAAS,EAAE,MAAM,KAAK,CAAC;CAC7D,CAAC;AACL"}
+{"version":3,"file":"time.js","names":[],"sources":["../src/time.ts"],"sourcesContent":["/**\n * Waits until a duration elapses or cancellation occurs without rejecting on cancellation.\n *\n * @remarks\n * The promise resolves without a value when the timer completes or the signal aborts.\n * An already aborted signal resolves immediately; completion removes the abort listener and clears the timer.\n *\n * @param ms - The delay duration in milliseconds, using native `setTimeout` timing rules.\n * @param signal - The signal that ends the wait early.\n *\n * @example\n *\n * ```ts\n * import { delay } from '@kikiutils/shared/time';\n *\n * const controller = new AbortController();\n * controller.abort();\n * await delay(5000, controller.signal);\n * ```\n */\nexport async function delay(ms: number, signal?: AbortSignal): Promise<void> {\n    return await new Promise((resolve) => {\n        if (signal?.aborted) {\n            resolve();\n            return;\n        }\n\n        const done = () => {\n            // eslint-disable-next-line ts/no-use-before-define\n            clearTimeout(timeout);\n            signal?.removeEventListener('abort', done);\n            resolve();\n        };\n\n        const timeout = setTimeout(done, ms);\n        signal?.addEventListener('abort', done, { once: true });\n    });\n}\n\n/**\n * Waits until a duration elapses and rejects on cancellation.\n *\n * @remarks\n * The promise resolves without a value when the timer completes and rejects with `signal.reason` if aborted.\n * An already aborted signal rejects immediately. Aborting clears the timer; timer completion removes the listener.\n *\n * @param ms - The delay duration in milliseconds, using native `setTimeout` timing rules.\n * @param signal - The signal that cancels the wait.\n *\n * @example\n *\n * ```ts\n * import { delayOrThrow } from '@kikiutils/shared/time';\n *\n * const controller = new AbortController();\n * controller.abort(new Error('Canceled'));\n * try {\n *     await delayOrThrow(5000, controller.signal);\n * } catch (error) {\n *     console.error(error);\n * }\n * ```\n */\nexport async function delayOrThrow(ms: number, signal?: AbortSignal): Promise<void> {\n    return await new Promise((resolve, reject) => {\n        if (signal?.aborted) {\n            reject(signal.reason);\n            return;\n        }\n\n        const onAbort = () => {\n            // eslint-disable-next-line ts/no-use-before-define\n            clearTimeout(timeout);\n            reject(signal!.reason);\n        };\n\n        const timeout = setTimeout(\n            () => {\n                signal?.removeEventListener('abort', onAbort);\n                resolve();\n            },\n            ms,\n        );\n\n        signal?.addEventListener('abort', onAbort, { once: true });\n    });\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;AAoBA,eAAsB,MAAM,IAAY,QAAqC;CACzE,OAAO,MAAM,IAAI,SAAS,YAAY;EAClC,IAAI,QAAQ,SAAS;GACjB,QAAQ;GACR;EACJ;EAEA,MAAM,aAAa;GAEf,aAAa,OAAO;GACpB,QAAQ,oBAAoB,SAAS,IAAI;GACzC,QAAQ;EACZ;EAEA,MAAM,UAAU,WAAW,MAAM,EAAE;EACnC,QAAQ,iBAAiB,SAAS,MAAM,EAAE,MAAM,KAAK,CAAC;CAC1D,CAAC;AACL;;;;;;;;;;;;;;;;;;;;;;;;;AA0BA,eAAsB,aAAa,IAAY,QAAqC;CAChF,OAAO,MAAM,IAAI,SAAS,SAAS,WAAW;EAC1C,IAAI,QAAQ,SAAS;GACjB,OAAO,OAAO,MAAM;GACpB;EACJ;EAEA,MAAM,gBAAgB;GAElB,aAAa,OAAO;GACpB,OAAO,OAAQ,MAAM;EACzB;EAEA,MAAM,UAAU,iBACN;GACF,QAAQ,oBAAoB,SAAS,OAAO;GAC5C,QAAQ;EACZ,GACA,EACJ;EAEA,QAAQ,iBAAiB,SAAS,SAAS,EAAE,MAAM,KAAK,CAAC;CAC7D,CAAC;AACL"}

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

@@ -8,9 +8,9 @@ type DefaultPath<K extends number | string, V, U = never, RK = `${K}`> = V exten
  * @typeParam U - The value type to select; `never` disables filtering.
  */
 export type FilteredKeyPath<T, U = never> = T extends ReadonlyArray<infer V> ? (IsTuple<T> extends true ? { [K in TupleKey<T>]-?: PathImpl<Exclude<K, symbol>, T[K], U>; }[TupleKey<T>] : PathImpl<number, V, U>) : { [K in keyof T]-?: PathImpl<Exclude<K, symbol>, T[K], U>; }[keyof T];
-type IsTuple<T extends ReadonlyArray<any>> = number extends T['length'] ? false : true;
+type IsTuple<T extends readonly any[]> = number extends T['length'] ? false : true;
 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[]>;
+type TupleKey<T extends readonly any[]> = Exclude<keyof T, keyof any[]>;
 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,2CAA2C;KACnD,SAAS,2BAA2B,GAAG,MAAM,qBAAqB,YAAY,GAAG,KAAK,gBAAgB,GAAG,GAAG;KAC5G,wBAED,iBAEA,OACA,uBAGA,WACA;KAKC,SAAS,4BAA4B,cAAc"}

package/dist/types/index.d.ts

@@ -28,5 +28,12 @@ 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>>;
+/**
+ * A promise whose rejection is handled internally and can safely be left unawaited.
+ * This type only marks that contract; it does not add runtime rejection handling.
+ */
+export type SafePromise<T> = Promise<T> & {
+  readonly __safePromise?: true;
+};
 export type { FilteredKeyPath };
 //# sourceMappingURL=index.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","names":["NodeBlob","NodeFile"],"sources":["../../src/types/index.ts"],"mappings":";;;;;YAWY,cAAc,cAAc,OAAO,SAAS,OAAOA,SAAWC,SAAW;;;;YAKzE;;;;YAKA,aAAa,KAAK,QAAQ,KAAK;;;;YAK/B,cAAc,KAAK,SAAS,KAAK;;;;YAKjC,cAAc,qBAAqB,KAAK,QAAQ,OAAO,GAAG;;;;YAK1D,sBAAsB,qBAAqB,KAAK,SAAS,cAAc,GAAG;;;;YAK1E,eAAe,qBAAqB,KAAK,SAAS,OAAO,GAAG"}
+{"version":3,"file":"index.d.ts","names":["NodeBlob","NodeFile"],"sources":["../../src/types/index.ts"],"mappings":";;;;;YAWY,cAAc,cAAc,OAAO,SAAS,OAAOA,SAAWC,SAAW;;;;YAKzE;;;;YAKA,aAAa,KAAK,QAAQ,KAAK;;;;YAK/B,cAAc,KAAK,SAAS,KAAK;;;;YAKjC,cAAc,qBAAqB,KAAK,QAAQ,OAAO,GAAG;;;;YAK1D,sBAAsB,qBAAqB,KAAK,SAAS,cAAc,GAAG;;;;YAK1E,eAAe,qBAAqB,KAAK,SAAS,OAAO,GAAG;;;;;YAM5D,YAAY,KAAK,QAAQ;WAAgB"}

package/dist/url.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"url.d.ts","names":[],"sources":["../src/url.ts"],"mappings":";;;;;;;;;;;;;wBAagB,yBAAyB,aAAa;;;;;;;;;;;;;wBAwBtC,mBAAmB,iBAAiB;;;;;;;;;;;;;wBAoBpC,sBAAsB,gBAAgB"}
+{"version":3,"file":"url.d.ts","names":[],"sources":["../src/url.ts"],"mappings":";;;;;;;;;;;;;wBAagB,yBAAyB,aAAa;;;;;;;;;;;;;wBAuBtC,mBAAmB,iBAAiB;;;;;;;;;;;;;wBAoBpC,sBAAsB,gBAAgB"}

package/dist/url.js.map

@@ -1 +1 @@
-{"version":3,"file":"url.js","names":[],"sources":["../src/url.ts"],"sourcesContent":["/**\n * Appends or updates the `redirect` query parameter on a given URL.\n *\n * @remarks\n * Typically used to preserve the user's current path for post-login navigation.\n *\n * @param url - The target URL to modify.\n * @param redirectPath - The safe same-origin application path starting with `/` to use as the redirect destination.\n *\n * @returns A new URL string with the `redirect` query parameter.\n *\n * @throws Error if `redirectPath` is not a safe same-origin application path.\n */\nexport function appendRedirectParamToUrl(url: string, redirectPath: string) {\n    // eslint-disable-next-line style/max-len\n    if (!isSafeRedirectPath(redirectPath)) throw new Error(`Invalid redirect path: \"${redirectPath}\". Redirect paths must be safe same-origin paths starting with '/'.`);\n\n    const [baseAndHash, rawQuery = ''] = url.split('?');\n    const [base, hash] = (baseAndHash || '').split('#');\n    const searchParams = new URLSearchParams(rawQuery);\n    searchParams.set('redirect', redirectPath);\n    const queryString = searchParams.toString();\n    return hash ? `${base}?${queryString}#${hash}` : `${base}?${queryString}`;\n}\n\n/**\n * Returns whether a value is a safe same-origin redirect path.\n *\n * @remarks\n * Safe redirect paths are absolute application paths such as `/dashboard`.\n * Protocol-relative URLs (`//example.com`), absolute URLs, backslash paths,\n * and non-string values are rejected.\n *\n * @param value - The value to check.\n *\n * @returns Whether the value is safe to use as an application redirect path.\n */\nexport function isSafeRedirectPath(value: unknown): value is string {\n    if (typeof value !== 'string') return false;\n    if (!value.startsWith('/')) return false;\n    if (value.startsWith('//')) return false;\n    if (value.includes('\\\\')) return false;\n    return true;\n}\n\n/**\n * Normalizes a redirect value into a safe same-origin application path.\n *\n * @remarks\n * If an array is provided, the first value is checked. Unsafe values fall back\n * to the provided fallback path.\n *\n * @param value - The redirect value to normalize.\n * @param fallback - The caller-supplied safe fallback path; it is returned unchanged and is not validated.\n *\n * @returns The validated input path, or the unvalidated fallback path.\n */\nexport function normalizeRedirectPath(value: unknown, fallback = '/') {\n    const redirectPath = Array.isArray(value) ? value[0] : value;\n    return isSafeRedirectPath(redirectPath) ? redirectPath : fallback;\n}\n"],"mappings":";;;;;;;;;;;;;;AAaA,SAAgB,yBAAyB,KAAa,cAAsB;CAExE,IAAI,CAAC,mBAAmB,YAAY,GAAG,MAAM,IAAI,MAAM,2BAA2B,aAAa,oEAAoE;CAEnK,MAAM,CAAC,aAAa,WAAW,MAAM,IAAI,MAAM,GAAG;CAClD,MAAM,CAAC,MAAM,SAAS,eAAe,GAAA,CAAI,MAAM,GAAG;CAClD,MAAM,eAAe,IAAI,gBAAgB,QAAQ;CACjD,aAAa,IAAI,YAAY,YAAY;CACzC,MAAM,cAAc,aAAa,SAAS;CAC1C,OAAO,OAAO,GAAG,KAAK,GAAG,YAAY,GAAG,SAAS,GAAG,KAAK,GAAG;AAChE;;;;;;;;;;;;;AAcA,SAAgB,mBAAmB,OAAiC;CAChE,IAAI,OAAO,UAAU,UAAU,OAAO;CACtC,IAAI,CAAC,MAAM,WAAW,GAAG,GAAG,OAAO;CACnC,IAAI,MAAM,WAAW,IAAI,GAAG,OAAO;CACnC,IAAI,MAAM,SAAS,IAAI,GAAG,OAAO;CACjC,OAAO;AACX;;;;;;;;;;;;;AAcA,SAAgB,sBAAsB,OAAgB,WAAW,KAAK;CAClE,MAAM,eAAe,MAAM,QAAQ,KAAK,IAAI,MAAM,KAAK;CACvD,OAAO,mBAAmB,YAAY,IAAI,eAAe;AAC7D"}
+{"version":3,"file":"url.js","names":[],"sources":["../src/url.ts"],"sourcesContent":["/**\n * Appends or updates the `redirect` query parameter on a given URL.\n *\n * @remarks\n * Typically used to preserve the user's current path for post-login navigation.\n *\n * @param url - The target URL to modify.\n * @param redirectPath - The safe same-origin application path starting with `/` to use as the redirect destination.\n *\n * @returns A new URL string with the `redirect` query parameter.\n *\n * @throws Error if `redirectPath` is not a safe same-origin application path.\n */\nexport function appendRedirectParamToUrl(url: string, redirectPath: string) {\n    if (!isSafeRedirectPath(redirectPath)) throw new Error(`Invalid redirect path: \"${redirectPath}\". Redirect paths must be safe same-origin paths starting with '/'.`);\n\n    const [baseAndHash, rawQuery = ''] = url.split('?');\n    const [base, hash] = (baseAndHash || '').split('#');\n    const searchParams = new URLSearchParams(rawQuery);\n    searchParams.set('redirect', redirectPath);\n    const queryString = searchParams.toString();\n    return hash ? `${base}?${queryString}#${hash}` : `${base}?${queryString}`;\n}\n\n/**\n * Returns whether a value is a safe same-origin redirect path.\n *\n * @remarks\n * Safe redirect paths are absolute application paths such as `/dashboard`.\n * Protocol-relative URLs (`//example.com`), absolute URLs, backslash paths,\n * and non-string values are rejected.\n *\n * @param value - The value to check.\n *\n * @returns Whether the value is safe to use as an application redirect path.\n */\nexport function isSafeRedirectPath(value: unknown): value is string {\n    if (typeof value !== 'string') return false;\n    if (!value.startsWith('/')) return false;\n    if (value.startsWith('//')) return false;\n    if (value.includes('\\\\')) return false;\n    return true;\n}\n\n/**\n * Normalizes a redirect value into a safe same-origin application path.\n *\n * @remarks\n * If an array is provided, the first value is checked. Unsafe values fall back\n * to the provided fallback path.\n *\n * @param value - The redirect value to normalize.\n * @param fallback - The caller-supplied safe fallback path; it is returned unchanged and is not validated.\n *\n * @returns The validated input path, or the unvalidated fallback path.\n */\nexport function normalizeRedirectPath(value: unknown, fallback = '/') {\n    const redirectPath = Array.isArray(value) ? value[0] : value;\n    return isSafeRedirectPath(redirectPath) ? redirectPath : fallback;\n}\n"],"mappings":";;;;;;;;;;;;;;AAaA,SAAgB,yBAAyB,KAAa,cAAsB;CACxE,IAAI,CAAC,mBAAmB,YAAY,GAAG,MAAM,IAAI,MAAM,2BAA2B,aAAa,oEAAoE;CAEnK,MAAM,CAAC,aAAa,WAAW,MAAM,IAAI,MAAM,GAAG;CAClD,MAAM,CAAC,MAAM,SAAS,eAAe,GAAA,CAAI,MAAM,GAAG;CAClD,MAAM,eAAe,IAAI,gBAAgB,QAAQ;CACjD,aAAa,IAAI,YAAY,YAAY;CACzC,MAAM,cAAc,aAAa,SAAS;CAC1C,OAAO,OAAO,GAAG,KAAK,GAAG,YAAY,GAAG,SAAS,GAAG,KAAK,GAAG;AAChE;;;;;;;;;;;;;AAcA,SAAgB,mBAAmB,OAAiC;CAChE,IAAI,OAAO,UAAU,UAAU,OAAO;CACtC,IAAI,CAAC,MAAM,WAAW,GAAG,GAAG,OAAO;CACnC,IAAI,MAAM,WAAW,IAAI,GAAG,OAAO;CACnC,IAAI,MAAM,SAAS,IAAI,GAAG,OAAO;CACjC,OAAO;AACX;;;;;;;;;;;;;AAcA,SAAgB,sBAAsB,OAAgB,WAAW,KAAK;CAClE,MAAM,eAAe,MAAM,QAAQ,KAAK,IAAI,MAAM,KAAK;CACvD,OAAO,mBAAmB,YAAY,IAAI,eAAe;AAC7D"}

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@kikiutils/shared",
   "type": "module",
-  "version": "20.0.1",
+  "version": "20.1.1",
   "description": "A lightweight and modular utility library for modern JavaScript and TypeScript — includes secure hashing, flexible logging, datetime tools, Vue/web helpers, storage abstraction, and more.",
   "author": "kiki-kanri",
   "license": "MIT",
@@ -143,35 +143,39 @@
       "optional": true
     }
   },
+  "dependencies": {
+    "ts-extras": "^2.0.0",
+    "type-fest": "^5.10.0"
+  },
   "devDependencies": {
     "@antfu/eslint-config": "^10.0.0",
     "@arethetypeswrong/core": "^0.18.5",
-    "@kikiutils/eslint-config": "^9.3.2",
+    "@kikiutils/eslint-config": "^11.0.0",
     "@kikiutils/tsconfigs": "^7.0.0",
     "@noble/hashes": "^2.4.0",
     "@types/node": "^26.6.6",
-    "@vitest/coverage-v8": "^5.0.5",
+    "@vitest/coverage-v8": "^5.1.0",
     "async-validator": "^4.2.5",
-    "bson": "^7.3.3",
+    "bson": "^7.3.4",
     "changelogen": "^0.6.2",
     "cross-env": "^10.1.0",
     "date-fns": "^4.4.0",
     "decimal.js": "^10.6.0",
-    "element-plus": "^2.14.7",
+    "element-plus": "^2.14.8",
     "eslint": "^10.14.0",
     "file-type": "^22.3.0",
-    "jsdom": "^30.1.3",
-    "knip": "^6.44.0",
+    "jsdom": "^31.0.0",
+    "knip": "^6.44.2",
     "lru-cache": "^11.5.3",
     "millify": "^6.1.0",
-    "msgpackr": "^2.1.3",
+    "msgpackr": "^2.1.4",
     "publint": "^0.3.25",
     "rotating-file-stream": "^3.2.10",
-    "tsdown": "^0.23.4",
+    "tsdown": "^0.23.7",
     "typescript": "^6.0.3",
     "unplugin-unused": "^0.6.0",
-    "vitest": "^5.0.5",
-    "vue": "^3.5.44",
+    "vitest": "^5.1.0",
+    "vue": "^3.5.45",
     "vue-router": "^5.4.0"
   }
 }

package/src/buffer.ts

@@ -36,6 +36,5 @@ export async function toBuffer(input: BinaryInput) {
     if (input instanceof ArrayBuffer) return Buffer.from(input);
     if (input instanceof Uint8Array) return Buffer.from(input.buffer, input.byteOffset, input.byteLength);
     if (typeof input.arrayBuffer === 'function') return Buffer.from(await input.arrayBuffer());
-    // eslint-disable-next-line style/max-len
     throw new TypeError('The provided input is not a supported binary type (Blob, Buffer, File, ArrayBuffer, or Uint8Array).');
 }

package/src/classes/enhanced-date.ts

@@ -100,7 +100,7 @@ export class EnhancedDate extends Date {
      *
      * @returns A new `EnhancedDate`, or `Invalid Date` if the array is empty or contains an invalid date.
      */
-    static max(dates: (Date | number)[]) {
+    static max(dates: Array<Date | number>) {
         return new EnhancedDate(dateFns.max(dates));
     }
 
@@ -111,7 +111,7 @@ export class EnhancedDate extends Date {
      *
      * @returns A new `EnhancedDate`, or `Invalid Date` if the array is empty or contains an invalid date.
      */
-    static min(dates: (Date | number)[]) {
+    static min(dates: Array<Date | number>) {
         return new EnhancedDate(dateFns.min(dates));
     }
 

package/src/classes/path.ts

@@ -241,8 +241,8 @@ export class Path {
      *
      * @see {@link https://nodejs.org/api/fs.html | Node.js fsPromises.access}
      */
-    access(...args: DropFirstParameters<typeof fsp.access>) {
-        return fsp.access(this.#value, ...args);
+    async access(...args: DropFirstParameters<typeof fsp.access>) {
+        return await fsp.access(this.#value, ...args);
     }
 
     /**
@@ -253,8 +253,8 @@ export class Path {
      *
      * @see {@link https://nodejs.org/api/fs.html | Node.js fsPromises.appendFile}
      */
-    appendFile(...args: DropFirstParameters<typeof fsp.appendFile>) {
-        return fsp.appendFile(this.#value, ...args);
+    async appendFile(...args: DropFirstParameters<typeof fsp.appendFile>) {
+        return await fsp.appendFile(this.#value, ...args);
     }
 
     /**
@@ -265,8 +265,8 @@ export class Path {
      *
      * @see {@link https://nodejs.org/api/fs.html | Node.js fsPromises.chmod}
      */
-    chmod(...args: DropFirstParameters<typeof fsp.chmod>) {
-        return fsp.chmod(this.#value, ...args);
+    async chmod(...args: DropFirstParameters<typeof fsp.chmod>) {
+        return await fsp.chmod(this.#value, ...args);
     }
 
     /**
@@ -277,8 +277,8 @@ export class Path {
      *
      * @see {@link https://nodejs.org/api/fs.html | Node.js fsPromises.chown}
      */
-    chown(...args: DropFirstParameters<typeof fsp.chown>) {
-        return fsp.chown(this.#value, ...args);
+    async chown(...args: DropFirstParameters<typeof fsp.chown>) {
+        return await fsp.chown(this.#value, ...args);
     }
 
     /**
@@ -289,8 +289,8 @@ export class Path {
      *
      * @see {@link https://nodejs.org/api/fs.html | Node.js fsPromises.copyFile}
      */
-    copyFile(...args: DropFirstParameters<typeof fsp.copyFile>) {
-        return fsp.copyFile(this.#value, ...args);
+    async copyFile(...args: DropFirstParameters<typeof fsp.copyFile>) {
+        return await fsp.copyFile(this.#value, ...args);
     }
 
     /**
@@ -310,8 +310,8 @@ export class Path {
           | null,
     ): Promise<void>;
     mkdir(options?: fs.MakeDirectoryOptions | fs.Mode | null): Promise<string | undefined>;
-    mkdir(...args: any): any {
-        return fsp.mkdir(this.#value, ...args);
+    async mkdir(...args: any): Promise<any> {
+        return await fsp.mkdir(this.#value, ...args);
     }
 
     /**
@@ -322,8 +322,8 @@ export class Path {
      *
      * @see {@link https://nodejs.org/api/fs.html | Node.js fsPromises.open}
      */
-    open(...args: DropFirstParameters<typeof fsp.open>) {
-        return fsp.open(this.#value, ...args);
+    async open(...args: DropFirstParameters<typeof fsp.open>) {
+        return await fsp.open(this.#value, ...args);
     }
 
     /**
@@ -373,9 +373,9 @@ export class Path {
             recursive?: boolean;
             withFileTypes: true;
         },
-    ): Promise<fs.Dirent<Buffer>[]>;
-    readdir(...args: any): any {
-        return fsp.readdir(this.#value, ...args);
+    ): Promise<Array<fs.Dirent<Buffer>>>;
+    async readdir(...args: any): Promise<any> {
+        return await fsp.readdir(this.#value, ...args);
     }
 
     /**
@@ -412,8 +412,8 @@ export class Path {
             | BufferEncoding
             | null,
     ): Promise<Buffer | string>;
-    readFile(...args: any): any {
-        return fsp.readFile(this.#value, ...args);
+    async readFile(...args: any): Promise<any> {
+        return await fsp.readFile(this.#value, ...args);
     }
 
     /**
@@ -426,8 +426,8 @@ export class Path {
      *
      * @see {@link https://nodejs.org/api/fs.html | Node.js fsPromises.rename}
      */
-    rename(newPath: PathLike) {
-        return fsp.rename(this.#value, newPath.toString());
+    async rename(newPath: PathLike) {
+        return await fsp.rename(this.#value, newPath.toString());
     }
 
     /**
@@ -438,8 +438,8 @@ export class Path {
      *
      * @see {@link https://nodejs.org/api/fs.html | Node.js fsPromises.rm}
      */
-    rm(...args: DropFirstParameters<typeof fsp.rm>) {
-        return fsp.rm(this.#value, ...args);
+    async rm(...args: DropFirstParameters<typeof fsp.rm>) {
+        return await fsp.rm(this.#value, ...args);
     }
 
     /**
@@ -450,8 +450,8 @@ export class Path {
      *
      * @see {@link https://nodejs.org/api/fs.html | Node.js fsPromises.rmdir}
      */
-    rmdir(...args: DropFirstParameters<typeof fsp.rmdir>) {
-        return fsp.rmdir(this.#value, ...args);
+    async rmdir(...args: DropFirstParameters<typeof fsp.rmdir>) {
+        return await fsp.rmdir(this.#value, ...args);
     }
 
     /**
@@ -512,8 +512,8 @@ export class Path {
      *
      * @see {@link https://nodejs.org/api/fs.html | Node.js fsPromises.truncate}
      */
-    truncate(...args: DropFirstParameters<typeof fsp.truncate>) {
-        return fsp.truncate(this.#value, ...args);
+    async truncate(...args: DropFirstParameters<typeof fsp.truncate>) {
+        return await fsp.truncate(this.#value, ...args);
     }
 
     /**
@@ -524,8 +524,8 @@ export class Path {
      *
      * @see {@link https://nodejs.org/api/fs.html | Node.js fsPromises.unlink}
      */
-    unlink() {
-        return fsp.unlink(this.#value);
+    async unlink() {
+        return await fsp.unlink(this.#value);
     }
 
     /**
@@ -536,7 +536,7 @@ export class Path {
      *
      * @see {@link https://nodejs.org/api/fs.html | Node.js fsPromises.writeFile}
      */
-    writeFile(...args: DropFirstParameters<typeof fsp.writeFile>) {
-        return fsp.writeFile(this.#value, ...args);
+    async writeFile(...args: DropFirstParameters<typeof fsp.writeFile>) {
+        return await fsp.writeFile(this.#value, ...args);
     }
 }