@dbx-tools/cache 0.9.176 → 0.9.178

package/README.md

@@ -20,6 +20,25 @@ await closeCache(cache);
 `projectCache` reuses the same named cache within the process. Call `closeCache`
 during application shutdown to flush pending disk writes.
 
+## Refresh hot values without blocking
+
+Set `refreshAfterWrite` when callers should keep receiving the current value
+while one asynchronous reload updates it. The duration can depend on the cached
+value:
+
+```ts
+const enabled = await getOrSet(cache, "smart-router", probeSmartRouter, {
+  ttl: "2h",
+  refreshAfterWrite: (value) => (value ? "5m" : "30s"),
+});
+```
+
+The first miss blocks for the loader. After `refreshAfterWrite`, the next access
+returns the cached value immediately and starts one coalesced background refresh.
+Unused entries are not refreshed, and `ttl` remains the hard expiration. A
+failed background refresh keeps the previous value. `closeCache()` waits for
+active refreshes before disconnecting persistence.
+
 ## Create a memory-only cache
 
 Use `createCache` without persistence levels when values should remain local to

package/index.ts

@@ -3,7 +3,7 @@
 // Hand edits are overwritten on the next watch; this file is read-only.
 
 export const PACKAGE_IDENTIFIER = "@dbx-tools/cache";
-export const PACKAGE_VERSION = "0.9.176";
+export const PACKAGE_VERSION = "0.9.178";
 export * as cache from "./src/cache.ts";
 export { createCache, cachePath, projectCache, flushCache, closeCache, cacheKeys, deleteCachedValue, getOrSet } from "./src/cache.ts";
-export type { CacheLevel, CacheOptions, ProjectCacheOptions, GetOrSetOptions } from "./src/cache.ts";
+export type { CacheLevel, CacheOptions, ProjectCacheOptions, RefreshAfterWrite, GetOrSetOptions } from "./src/cache.ts";

package/lib/index.d.ts

@@ -1,5 +1,5 @@
 export declare const PACKAGE_IDENTIFIER = "@dbx-tools/cache";
-export declare const PACKAGE_VERSION = "0.9.176";
+export declare const PACKAGE_VERSION = "0.9.178";
 export * as cache from "./src/cache.ts";
 export { createCache, cachePath, projectCache, flushCache, closeCache, cacheKeys, deleteCachedValue, getOrSet } from "./src/cache.ts";
-export type { CacheLevel, CacheOptions, ProjectCacheOptions, GetOrSetOptions } from "./src/cache.ts";
+export type { CacheLevel, CacheOptions, ProjectCacheOptions, RefreshAfterWrite, GetOrSetOptions } from "./src/cache.ts";

package/lib/index.js

@@ -2,7 +2,7 @@
 // Regenerated from the exporting modules in ./src.
 // Hand edits are overwritten on the next watch; this file is read-only.
 export const PACKAGE_IDENTIFIER = "@dbx-tools/cache";
-export const PACKAGE_VERSION = "0.9.176";
+export const PACKAGE_VERSION = "0.9.178";
 export * as cache from "./src/cache.js";
 export { createCache, cachePath, projectCache, flushCache, closeCache, cacheKeys, deleteCachedValue, getOrSet } from "./src/cache.js";
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi9pbmRleC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSwyQ0FBMkM7QUFDM0MsbURBQW1EO0FBQ25ELHdFQUF3RTtBQUV4RSxNQUFNLENBQUMsTUFBTSxrQkFBa0IsR0FBRyxrQkFBa0IsQ0FBQztBQUNyRCxNQUFNLENBQUMsTUFBTSxlQUFlLEdBQUcsU0FBUyxDQUFDO0FBQ3pDLE9BQU8sS0FBSyxLQUFLLE1BQU0sZ0JBQWdCLENBQUM7QUFDeEMsT0FBTyxFQUFFLFdBQVcsRUFBRSxTQUFTLEVBQUUsWUFBWSxFQUFFLFVBQVUsRUFBRSxVQUFVLEVBQUUsU0FBUyxFQUFFLGlCQUFpQixFQUFFLFFBQVEsRUFBRSxNQUFNLGdCQUFnQixDQUFDIiwic291cmNlc0NvbnRlbnQiOlsiLy8gR0VORVJBVEVEIGJ5IHByb2plbiB3YXRjaCAtIERPIE5PVCBFRElULlxuLy8gUmVnZW5lcmF0ZWQgZnJvbSB0aGUgZXhwb3J0aW5nIG1vZHVsZXMgaW4gLi9zcmMuXG4vLyBIYW5kIGVkaXRzIGFyZSBvdmVyd3JpdHRlbiBvbiB0aGUgbmV4dCB3YXRjaDsgdGhpcyBmaWxlIGlzIHJlYWQtb25seS5cblxuZXhwb3J0IGNvbnN0IFBBQ0tBR0VfSURFTlRJRklFUiA9IFwiQGRieC10b29scy9jYWNoZVwiO1xuZXhwb3J0IGNvbnN0IFBBQ0tBR0VfVkVSU0lPTiA9IFwiMC45LjE3NlwiO1xuZXhwb3J0ICogYXMgY2FjaGUgZnJvbSBcIi4vc3JjL2NhY2hlLnRzXCI7XG5leHBvcnQgeyBjcmVhdGVDYWNoZSwgY2FjaGVQYXRoLCBwcm9qZWN0Q2FjaGUsIGZsdXNoQ2FjaGUsIGNsb3NlQ2FjaGUsIGNhY2hlS2V5cywgZGVsZXRlQ2FjaGVkVmFsdWUsIGdldE9yU2V0IH0gZnJvbSBcIi4vc3JjL2NhY2hlLnRzXCI7XG5leHBvcnQgdHlwZSB7IENhY2hlTGV2ZWwsIENhY2hlT3B0aW9ucywgUHJvamVjdENhY2hlT3B0aW9ucywgR2V0T3JTZXRPcHRpb25zIH0gZnJvbSBcIi4vc3JjL2NhY2hlLnRzXCI7XG4iXX0=
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi9pbmRleC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSwyQ0FBMkM7QUFDM0MsbURBQW1EO0FBQ25ELHdFQUF3RTtBQUV4RSxNQUFNLENBQUMsTUFBTSxrQkFBa0IsR0FBRyxrQkFBa0IsQ0FBQztBQUNyRCxNQUFNLENBQUMsTUFBTSxlQUFlLEdBQUcsU0FBUyxDQUFDO0FBQ3pDLE9BQU8sS0FBSyxLQUFLLE1BQU0sZ0JBQWdCLENBQUM7QUFDeEMsT0FBTyxFQUFFLFdBQVcsRUFBRSxTQUFTLEVBQUUsWUFBWSxFQUFFLFVBQVUsRUFBRSxVQUFVLEVBQUUsU0FBUyxFQUFFLGlCQUFpQixFQUFFLFFBQVEsRUFBRSxNQUFNLGdCQUFnQixDQUFDIiwic291cmNlc0NvbnRlbnQiOlsiLy8gR0VORVJBVEVEIGJ5IHByb2plbiB3YXRjaCAtIERPIE5PVCBFRElULlxuLy8gUmVnZW5lcmF0ZWQgZnJvbSB0aGUgZXhwb3J0aW5nIG1vZHVsZXMgaW4gLi9zcmMuXG4vLyBIYW5kIGVkaXRzIGFyZSBvdmVyd3JpdHRlbiBvbiB0aGUgbmV4dCB3YXRjaDsgdGhpcyBmaWxlIGlzIHJlYWQtb25seS5cblxuZXhwb3J0IGNvbnN0IFBBQ0tBR0VfSURFTlRJRklFUiA9IFwiQGRieC10b29scy9jYWNoZVwiO1xuZXhwb3J0IGNvbnN0IFBBQ0tBR0VfVkVSU0lPTiA9IFwiMC45LjE3OFwiO1xuZXhwb3J0ICogYXMgY2FjaGUgZnJvbSBcIi4vc3JjL2NhY2hlLnRzXCI7XG5leHBvcnQgeyBjcmVhdGVDYWNoZSwgY2FjaGVQYXRoLCBwcm9qZWN0Q2FjaGUsIGZsdXNoQ2FjaGUsIGNsb3NlQ2FjaGUsIGNhY2hlS2V5cywgZGVsZXRlQ2FjaGVkVmFsdWUsIGdldE9yU2V0IH0gZnJvbSBcIi4vc3JjL2NhY2hlLnRzXCI7XG5leHBvcnQgdHlwZSB7IENhY2hlTGV2ZWwsIENhY2hlT3B0aW9ucywgUHJvamVjdENhY2hlT3B0aW9ucywgUmVmcmVzaEFmdGVyV3JpdGUsIEdldE9yU2V0T3B0aW9ucyB9IGZyb20gXCIuL3NyYy9jYWNoZS50c1wiO1xuIl19

package/lib/src/cache.d.ts

@@ -33,12 +33,19 @@ export interface ProjectCacheOptions extends CacheOptions {
     /** Override the project name resolved through projectUtils.name(). */
     readonly projectName?: string;
 }
+/** Age after which a cache hit returns its value and starts an asynchronous refresh. */
+export type RefreshAfterWrite<T> = number | string | ((value: T) => number | string);
 /** Options for the Cacheable-compatible get-or-set extension. */
-export interface GetOrSetOptions extends GetOrSetFunctionOptions {
+export interface GetOrSetOptions<T = unknown> extends GetOrSetFunctionOptions {
     /** Return a separately retained successful value when the loader fails. Defaults to false. */
     readonly returnCachedOnError?: boolean;
     /** TTL for the cached-on-error value. Defaults to 0, meaning no expiration. */
     readonly cachedOnErrorTtl?: number | string;
+    /**
+     * Return an older cached value immediately and refresh it once in the background after this
+     * duration since its last successful write. The hard `ttl` still controls final expiration.
+     */
+    readonly refreshAfterWrite?: RefreshAfterWrite<T>;
 }
 /** Create a memory-first cache with optional ordered persistent levels. */
 export declare function createCache(options?: CacheOptions): Cacheable;
@@ -61,4 +68,4 @@ export declare function deleteCachedValue(cache: Cacheable, key: string): Promis
  * Use Cacheable's native in-flight get-or-set behavior, optionally retaining a
  * successful value under a separate key for recovery when a later loader fails.
  */
-export declare function getOrSet<T>(cache: Cacheable, key: string, load: () => Promise<T>, options?: GetOrSetOptions): Promise<T | undefined>;
+export declare function getOrSet<T>(cache: Cacheable, key: string, load: () => Promise<T>, options?: GetOrSetOptions<T>): Promise<T | undefined>;

package/lib/src/cache.js

@@ -7,7 +7,7 @@ import { EventEmitter } from "node:events";
 import { join } from "node:path";
 import { projectUtils } from "@dbx-tools/core";
 import { log, toError } from "@dbx-tools/shared-core";
-import { Cacheable, CacheableHooks, KeyvCacheableMemory, } from "cacheable";
+import { Cacheable, CacheableHooks, KeyvCacheableMemory, shorthandToMilliseconds, } from "cacheable";
 import envPaths from "env-paths";
 import { Keyv } from "keyv";
 import { KeyvFile } from "keyv-file";
@@ -18,6 +18,7 @@ const ENVELOPE_VERSION = 1;
 const logger = log.logger("cache");
 const states = new WeakMap();
 const projectCaches = new Map();
+const resultWriteTimes = new WeakMap();
 /**
  * Keyv adapter that composes arbitrary ordered levels behind Cacheable's one
  * secondary-store slot and owns tracked write-behind persistence.
@@ -208,7 +209,7 @@ export function createCache(options = {}) {
     cache.on("error", (error) => {
         logger.warn("cacheable operation failed", { error: toError(error) });
     });
-    states.set(cache, { adapter, closed: false });
+    states.set(cache, { adapter, refreshes: new Map(), closed: false });
     return cache;
 }
 /** Resolve the default portable disk path for a project cache scope. */
@@ -253,6 +254,8 @@ export async function closeCache(cache) {
     const state = requireState(cache);
     if (state.closed)
         return;
+    while (state.refreshes.size > 0)
+        await Promise.all([...state.refreshes.values()]);
     await state.adapter?.disconnect();
     state.closed = true;
     if (state.registryKey && projectCaches.get(state.registryKey) === cache) {
@@ -280,15 +283,40 @@ export async function deleteCachedValue(cache, key) {
  * successful value under a separate key for recovery when a later loader fails.
  */
 export async function getOrSet(cache, key, load, options = {}) {
-    const { returnCachedOnError = false, cachedOnErrorTtl = 0, ...cacheableOptions } = options;
-    if (!returnCachedOnError)
-        return cache.getOrSet(key, load, cacheableOptions);
-    try {
-        return await cache.getOrSet(key, async () => {
-            const value = await load();
+    const { returnCachedOnError = false, cachedOnErrorTtl = 0, refreshAfterWrite, ...cacheableOptions } = options;
+    const loadFresh = async () => {
+        const value = await load();
+        if (returnCachedOnError) {
             await cache.set(cachedOnErrorKey(key), value, { ttl: cachedOnErrorTtl });
+        }
+        return value;
+    };
+    if (refreshAfterWrite !== undefined) {
+        const getOptions = cacheableOptions.nonBlocking === undefined
+            ? undefined
+            : { nonBlocking: cacheableOptions.nonBlocking };
+        let cached = await cache.getRaw(key, getOptions);
+        if (!cached) {
+            const refresh = requireState(cache).refreshes.get(key);
+            if (refresh) {
+                await refresh;
+                cached = await cache.getRaw(key, getOptions);
+            }
+        }
+        if (cached) {
+            const value = cached.value;
+            const writtenAt = resultWriteTimes.get(cached);
+            const refreshMs = resolveRefreshAfterWrite(refreshAfterWrite, value);
+            if (writtenAt === undefined || Date.now() - writtenAt >= refreshMs) {
+                startRefresh(cache, key, loadFresh, cacheableOptions);
+            }
             return value;
-        }, { ...cacheableOptions, throwErrors: true });
+        }
+    }
+    if (!returnCachedOnError)
+        return cache.getOrSet(key, loadFresh, cacheableOptions);
+    try {
+        return await cache.getOrSet(key, loadFresh, { ...cacheableOptions, throwErrors: true });
     }
     catch (error) {
         const cached = await cache.get(cachedOnErrorKey(key));
@@ -309,20 +337,26 @@ function installValueEnvelope(cache) {
     });
     cache.onHook(CacheableHooks.AFTER_GET, (item) => {
         if (item.result)
-            item.result.value = unwrap(item.result.value);
+            unwrapResult(item.result);
     });
     cache.onHook(CacheableHooks.AFTER_GET_MANY, (item) => {
         for (const result of item.result) {
             if (result)
-                result.value = unwrap(result.value);
+                unwrapResult(result);
         }
     });
 }
 function envelope(value) {
-    return { __dbxToolsCacheEnvelope: ENVELOPE_VERSION, value };
+    return { __dbxToolsCacheEnvelope: ENVELOPE_VERSION, value, writtenAt: Date.now() };
 }
-function unwrap(value) {
-    return isEnvelope(value) ? value.value : value;
+function unwrapResult(result) {
+    if (!isEnvelope(result.value))
+        return;
+    const { writtenAt } = result.value;
+    if (typeof writtenAt === "number" && Number.isFinite(writtenAt)) {
+        resultWriteTimes.set(result, writtenAt);
+    }
+    result.value = result.value.value;
 }
 function isEnvelope(value) {
     return Boolean(value &&
@@ -334,6 +368,35 @@ function isEnvelope(value) {
 function cachedOnErrorKey(key) {
     return `${ERROR_VALUE_PREFIX}${key}`;
 }
+function startRefresh(cache, key, load, options) {
+    const state = requireState(cache);
+    if (state.refreshes.has(key))
+        return;
+    let refresh;
+    refresh = (async () => {
+        const value = await load();
+        await cache.set(key, value, {
+            ...(options.ttl === undefined ? {} : { ttl: options.ttl }),
+            ...(options.nonBlocking === undefined ? {} : { nonBlocking: options.nonBlocking }),
+        });
+    })()
+        .catch((error) => {
+        logger.warn("cache background refresh failed", { key, error: toError(error) });
+    })
+        .finally(() => {
+        if (state.refreshes.get(key) === refresh)
+            state.refreshes.delete(key);
+    });
+    state.refreshes.set(key, refresh);
+}
+function resolveRefreshAfterWrite(option, value) {
+    const configured = typeof option === "function" ? option(value) : option;
+    const resolved = typeof configured === "number" ? configured : shorthandToMilliseconds(configured);
+    if (resolved === undefined || !Number.isFinite(resolved) || resolved <= 0) {
+        throw new RangeError("refreshAfterWrite must resolve to a positive duration");
+    }
+    return resolved;
+}
 async function settleLevels(levels, operation, operationName) {
     const results = await Promise.allSettled(levels.map((level) => operation(level)));
     const errors = results.flatMap((result, index) => result.status === "rejected"
@@ -369,4 +432,4 @@ function nonNegativeInteger(value, fallback, name) {
     }
     return resolved;
 }
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"cache.js","sourceRoot":"","sources":["../../src/cache.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * Memory-first Cacheable and Keyv composition.\n *\n * @module\n */\n\nimport { EventEmitter } from \"node:events\";\nimport { join } from \"node:path\";\nimport { projectUtils } from \"@dbx-tools/core\";\nimport { log, toError } from \"@dbx-tools/shared-core\";\nimport {\n  Cacheable,\n  CacheableHooks,\n  KeyvCacheableMemory,\n  type CacheableOptions,\n  type GetOrSetFunctionOptions,\n  type KeyvStoreAdapter,\n} from \"cacheable\";\nimport envPaths from \"env-paths\";\nimport { Keyv } from \"keyv\";\nimport { KeyvFile } from \"keyv-file\";\n\nconst DEFAULT_MAX_ENTRIES = 1_000;\nconst DEFAULT_WRITE_DELAY_MS = 25;\nconst ERROR_VALUE_PREFIX = \"__dbx_tools_cached_on_error__:\";\nconst ENVELOPE_VERSION = 1;\nconst logger = log.logger(\"cache\");\n\ninterface ValueEnvelope {\n  readonly __dbxToolsCacheEnvelope: typeof ENVELOPE_VERSION;\n  readonly value: unknown;\n}\n\ninterface SetMutation {\n  readonly kind: \"set\";\n  readonly ttl?: number;\n  readonly value: unknown;\n}\n\ninterface DeleteMutation {\n  readonly kind: \"delete\";\n}\n\ntype Mutation = DeleteMutation | SetMutation;\n\ninterface CacheState {\n  readonly adapter?: TieredStoreAdapter;\n  path?: string;\n  registryKey?: string;\n  closed: boolean;\n}\n\n/** One ordered persistent cache level. Earlier levels are read first. */\nexport interface CacheLevel {\n  /** Optional name included in persistence error messages. */\n  readonly name?: string;\n  /** Keyv-compatible store adapter. */\n  readonly store: KeyvStoreAdapter;\n}\n\n/** Options for an AppKit-independent memory-first cache. */\nexport interface CacheOptions extends Pick<\n  CacheableOptions,\n  \"cacheId\" | \"maxTtl\" | \"namespace\" | \"stats\" | \"tags\" | \"ttl\"\n> {\n  /** Additional ordered persistence levels. No levels creates a memory-only cache. */\n  readonly levels?: readonly CacheLevel[];\n  /** Maximum entries retained in the memory primary. Defaults to 1,000. */\n  readonly maxEntries?: number;\n  /** Whether memory reads clone values. Defaults to true. */\n  readonly useClone?: boolean;\n  /** Delay used to coalesce persistence mutations. Defaults to 25 milliseconds. */\n  readonly writeDelayMs?: number;\n}\n\n/** Options for the default project-scoped memory and disk cache. */\nexport interface ProjectCacheOptions extends CacheOptions {\n  /** Override the cache directory, primarily for tests. */\n  readonly cacheDir?: string;\n  /** Disable the default disk level. Defaults to true. */\n  readonly disk?: boolean;\n  /** Delay used by keyv-file to coalesce file rewrites. Defaults to 100 milliseconds. */\n  readonly diskWriteDelayMs?: number;\n  /** Override the project name resolved through projectUtils.name(). */\n  readonly projectName?: string;\n}\n\n/** Options for the Cacheable-compatible get-or-set extension. */\nexport interface GetOrSetOptions extends GetOrSetFunctionOptions {\n  /** Return a separately retained successful value when the loader fails. Defaults to false. */\n  readonly returnCachedOnError?: boolean;\n  /** TTL for the cached-on-error value. Defaults to 0, meaning no expiration. */\n  readonly cachedOnErrorTtl?: number | string;\n}\n\nconst states = new WeakMap<Cacheable, CacheState>();\nconst projectCaches = new Map<string, Cacheable>();\n\n/**\n * Keyv adapter that composes arbitrary ordered levels behind Cacheable's one\n * secondary-store slot and owns tracked write-behind persistence.\n */\nclass TieredStoreAdapter extends EventEmitter implements KeyvStoreAdapter {\n  readonly opts = {};\n  namespace?: string;\n\n  private readonly levels: readonly CacheLevel[];\n  private readonly pending = new Map<string, Mutation>();\n  private readonly promotions = new Set<Promise<void>>();\n  private readonly writeDelayMs: number;\n  private flushPromise?: Promise<void>;\n  private timer?: ReturnType<typeof setTimeout>;\n  private disconnected = false;\n\n  constructor(levels: readonly CacheLevel[], writeDelayMs: number) {\n    super();\n    this.levels = levels;\n    this.writeDelayMs = writeDelayMs;\n  }\n\n  async get<Value>(key: string): Promise<Value | undefined> {\n    const mutation = this.pending.get(key);\n    if (mutation?.kind === \"delete\") return undefined;\n    if (mutation?.kind === \"set\") return mutation.value as Value;\n\n    for (const [index, level] of this.levels.entries()) {\n      const value = await level.store.get<Value>(key);\n      if (value === undefined) continue;\n      if (index > 0) this.promote(key, value, this.levels.slice(0, index));\n      return value as Value;\n    }\n    return undefined;\n  }\n\n  async getMany<Value>(keys: string[]): Promise<Array<Value | undefined>> {\n    return Promise.all(keys.map((key) => this.get<Value>(key)));\n  }\n\n  set(key: string, value: unknown, ttl?: number): Promise<boolean> {\n    this.assertConnected();\n    this.pending.set(key, { kind: \"set\", value, ...(ttl === undefined ? {} : { ttl }) });\n    this.schedule();\n    return Promise.resolve(true);\n  }\n\n  async setMany(values: Array<{ key: string; value: unknown; ttl?: number }>): Promise<void> {\n    for (const entry of values) await this.set(entry.key, entry.value, entry.ttl);\n  }\n\n  delete(key: string): Promise<boolean> {\n    this.assertConnected();\n    this.pending.set(key, { kind: \"delete\" });\n    this.schedule();\n    return Promise.resolve(true);\n  }\n\n  async deleteMany(keys: string[]): Promise<boolean> {\n    await Promise.all(keys.map((key) => this.delete(key)));\n    return true;\n  }\n\n  async has(key: string): Promise<boolean> {\n    const pending = this.pending.get(key);\n    if (pending) return pending.kind === \"set\";\n    for (const level of this.levels) {\n      if (\n        level.store.has ? await level.store.has(key) : (await level.store.get(key)) !== undefined\n      ) {\n        return true;\n      }\n    }\n    return false;\n  }\n\n  async clear(): Promise<void> {\n    this.assertConnected();\n    await this.flush();\n    this.pending.clear();\n    await settleLevels(this.levels, (level) => level.store.clear(), \"clear\");\n  }\n\n  async flush(): Promise<void> {\n    if (this.timer) {\n      clearTimeout(this.timer);\n      this.timer = undefined;\n    }\n    if (!this.flushPromise) {\n      this.flushPromise = this.flushPending().finally(() => {\n        this.flushPromise = undefined;\n      });\n    }\n    await this.flushPromise;\n    await this.flushPromotions();\n    if (this.pending.size > 0) await this.flush();\n  }\n\n  async disconnect(): Promise<void> {\n    if (this.disconnected) return;\n    await this.flush();\n    this.disconnected = true;\n    await settleLevels(\n      this.levels.filter((level) => level.store.disconnect),\n      (level) => level.store.disconnect!(),\n      \"disconnect\",\n    );\n  }\n\n  private assertConnected(): void {\n    if (this.disconnected) throw new Error(\"Cache persistence is disconnected\");\n  }\n\n  private schedule(): void {\n    if (this.timer || this.flushPromise) return;\n    this.timer = setTimeout(() => {\n      this.timer = undefined;\n      void this.flush().catch((error) => {\n        logger.warn(\"cache persistence flush failed\", { error: toError(error) });\n        this.emit(\"error\", error);\n      });\n    }, this.writeDelayMs);\n    this.timer.unref?.();\n  }\n\n  private async flushPending(): Promise<void> {\n    while (this.pending.size > 0) {\n      const batch = new Map(this.pending);\n      for (const key of batch.keys()) this.pending.delete(key);\n      const failures: Array<{ key: string; mutation: Mutation; error: unknown }> = [];\n      await Promise.all(\n        [...batch].map(async ([key, mutation]) => {\n          try {\n            await settleLevels(\n              this.levels,\n              (level) =>\n                mutation.kind === \"set\"\n                  ? level.store.set(key, mutation.value, mutation.ttl)\n                  : level.store.delete(key),\n              mutation.kind,\n            );\n          } catch (error) {\n            failures.push({ key, mutation, error });\n          }\n        }),\n      );\n      if (failures.length > 0) {\n        for (const failure of failures) {\n          if (!this.pending.has(failure.key)) this.pending.set(failure.key, failure.mutation);\n        }\n        throw new AggregateError(\n          failures.map((failure) => failure.error),\n          `Cache persistence failed for ${failures.length} mutation(s)`,\n        );\n      }\n    }\n  }\n\n  private promote(key: string, value: unknown, levels: readonly CacheLevel[]): void {\n    const promotion = settleLevels(levels, (level) => level.store.set(key, value), \"promote\")\n      .catch((error) => {\n        logger.warn(\"cache persistence promotion failed\", {\n          key,\n          error: toError(error),\n        });\n      })\n      .finally(() => {\n        this.promotions.delete(promotion);\n      });\n    this.promotions.add(promotion);\n  }\n\n  private async flushPromotions(): Promise<void> {\n    while (this.promotions.size > 0) await Promise.all([...this.promotions]);\n  }\n}\n\n/** Create a memory-first cache with optional ordered persistent levels. */\nexport function createCache(options: CacheOptions = {}): Cacheable {\n  const maxEntries = positiveInteger(options.maxEntries, DEFAULT_MAX_ENTRIES, \"maxEntries\");\n  const writeDelayMs = nonNegativeInteger(\n    options.writeDelayMs,\n    DEFAULT_WRITE_DELAY_MS,\n    \"writeDelayMs\",\n  );\n  const primary = new Keyv({\n    store: new KeyvCacheableMemory({\n      lruSize: maxEntries,\n      ttl: options.ttl,\n      useClone: options.useClone ?? true,\n    }),\n    ...(typeof options.ttl === \"number\" && Number.isInteger(options.ttl)\n      ? { ttl: options.ttl }\n      : {}),\n  });\n  primary.serialize = undefined;\n  primary.deserialize = undefined;\n  const adapter = options.levels?.length\n    ? new TieredStoreAdapter(options.levels, writeDelayMs)\n    : undefined;\n  const secondary = adapter ? new Keyv({ store: adapter }) : undefined;\n  const cache = new Cacheable({\n    primary,\n    ...(secondary ? { secondary, nonBlocking: true } : {}),\n    ...(options.cacheId === undefined ? {} : { cacheId: options.cacheId }),\n    ...(options.maxTtl === undefined ? {} : { maxTtl: options.maxTtl }),\n    ...(options.namespace === undefined ? {} : { namespace: options.namespace }),\n    ...(options.stats === undefined ? {} : { stats: options.stats }),\n    ...(options.tags === undefined ? {} : { tags: options.tags }),\n    ...(options.ttl === undefined ? {} : { ttl: options.ttl }),\n  });\n  installValueEnvelope(cache);\n  cache.on(\"error\", (error) => {\n    logger.warn(\"cacheable operation failed\", { error: toError(error) });\n  });\n  states.set(cache, { adapter, closed: false });\n  return cache;\n}\n\n/** Resolve the default portable disk path for a project cache scope. */\nexport function cachePath(\n  scope: string,\n  options: Pick<ProjectCacheOptions, \"cacheDir\" | \"projectName\"> = {},\n): string {\n  const projectName = options.projectName ?? projectUtils.name();\n  const root = options.cacheDir ?? envPaths(\"dbx-tools\", { suffix: \"\" }).cache;\n  return join(root, \"cache\", safeSegment(projectName), `${safeSegment(scope)}.json`);\n}\n\n/**\n * Return a process-shared project cache. By default it is memory-first with a\n * portable keyv-file secondary scoped by project and logical cache name.\n */\nexport function projectCache(scope: string, options: ProjectCacheOptions = {}): Cacheable {\n  const path = cachePath(scope, options);\n  const registryKey = JSON.stringify([path, options.disk !== false]);\n  const existing = projectCaches.get(registryKey);\n  if (existing) return existing;\n\n  const levels = [...(options.levels ?? [])];\n  if (options.disk !== false) {\n    levels.push({\n      name: \"disk\",\n      store: new KeyvFile({\n        filename: path,\n        writeDelay: nonNegativeInteger(options.diskWriteDelayMs, 100, \"diskWriteDelayMs\"),\n      }),\n    });\n  }\n  const cache = createCache({ ...options, levels });\n  const state = requireState(cache);\n  state.path = path;\n  state.registryKey = registryKey;\n  projectCaches.set(registryKey, cache);\n  return cache;\n}\n\n/** Wait for all tracked write-behind persistence without closing the cache. */\nexport async function flushCache(cache: Cacheable): Promise<void> {\n  await requireState(cache).adapter?.flush();\n}\n\n/** Flush pending persistence and disconnect all cache levels. Idempotent. */\nexport async function closeCache(cache: Cacheable): Promise<void> {\n  const state = requireState(cache);\n  if (state.closed) return;\n  await state.adapter?.disconnect();\n  state.closed = true;\n  if (state.registryKey && projectCaches.get(state.registryKey) === cache) {\n    projectCaches.delete(state.registryKey);\n  }\n}\n\n/** Iterate keys currently retained by the bounded memory primary. */\nexport function cacheKeys(cache: Cacheable): IterableIterator<string> {\n  const store = cache.primary.store;\n  if (!(store instanceof KeyvCacheableMemory)) {\n    throw new TypeError(\"Cache primary is not Cacheable memory\");\n  }\n  return store.store.keys;\n}\n\n/** Delete a normal cache value and its optional cached-on-error companion. */\nexport async function deleteCachedValue(cache: Cacheable, key: string): Promise<boolean> {\n  const [value, fallback] = await Promise.all([\n    cache.delete(key),\n    cache.delete(cachedOnErrorKey(key)),\n  ]);\n  return Boolean(value || fallback);\n}\n\n/**\n * Use Cacheable's native in-flight get-or-set behavior, optionally retaining a\n * successful value under a separate key for recovery when a later loader fails.\n */\nexport async function getOrSet<T>(\n  cache: Cacheable,\n  key: string,\n  load: () => Promise<T>,\n  options: GetOrSetOptions = {},\n): Promise<T | undefined> {\n  const { returnCachedOnError = false, cachedOnErrorTtl = 0, ...cacheableOptions } = options;\n  if (!returnCachedOnError) return cache.getOrSet(key, load, cacheableOptions);\n\n  try {\n    return await cache.getOrSet(\n      key,\n      async () => {\n        const value = await load();\n        await cache.set(cachedOnErrorKey(key), value, { ttl: cachedOnErrorTtl });\n        return value;\n      },\n      { ...cacheableOptions, throwErrors: true },\n    );\n  } catch (error) {\n    const cached = await cache.get<T>(cachedOnErrorKey(key));\n    if (cached !== undefined) return cached;\n    if (cacheableOptions.throwErrors) throw error;\n    return undefined;\n  }\n}\n\nfunction installValueEnvelope(cache: Cacheable): void {\n  cache.onHook(CacheableHooks.BEFORE_SET, (item) => {\n    item.value = envelope(item.value);\n  });\n  cache.onHook(CacheableHooks.BEFORE_SET_MANY, (items) => {\n    for (const item of items) item.value = envelope(item.value);\n  });\n  cache.onHook(CacheableHooks.AFTER_GET, (item) => {\n    if (item.result) item.result.value = unwrap(item.result.value);\n  });\n  cache.onHook(CacheableHooks.AFTER_GET_MANY, (item) => {\n    for (const result of item.result) {\n      if (result) result.value = unwrap(result.value);\n    }\n  });\n}\n\nfunction envelope(value: unknown): ValueEnvelope {\n  return { __dbxToolsCacheEnvelope: ENVELOPE_VERSION, value };\n}\n\nfunction unwrap(value: unknown): unknown {\n  return isEnvelope(value) ? value.value : value;\n}\n\nfunction isEnvelope(value: unknown): value is ValueEnvelope {\n  return Boolean(\n    value &&\n    typeof value === \"object\" &&\n    \"__dbxToolsCacheEnvelope\" in value &&\n    (value as ValueEnvelope).__dbxToolsCacheEnvelope === ENVELOPE_VERSION &&\n    \"value\" in value,\n  );\n}\n\nfunction cachedOnErrorKey(key: string): string {\n  return `${ERROR_VALUE_PREFIX}${key}`;\n}\n\nasync function settleLevels(\n  levels: readonly CacheLevel[],\n  operation: (level: CacheLevel) => unknown | Promise<unknown>,\n  operationName: string,\n): Promise<void> {\n  const results = await Promise.allSettled(levels.map((level) => operation(level)));\n  const errors = results.flatMap((result, index) =>\n    result.status === \"rejected\"\n      ? [\n          new Error(`${levels[index]?.name ?? `level-${index + 1}`} ${operationName} failed`, {\n            cause: result.reason,\n          }),\n        ]\n      : [],\n  );\n  if (errors.length > 0) throw new AggregateError(errors, `Cache ${operationName} failed`);\n}\n\nfunction requireState(cache: Cacheable): CacheState {\n  const state = states.get(cache);\n  if (!state) throw new TypeError(\"Cache was not created by @dbx-tools/cache\");\n  return state;\n}\n\nfunction safeSegment(value: string): string {\n  return encodeURIComponent(value.trim() || \"default\");\n}\n\nfunction positiveInteger(value: number | undefined, fallback: number, name: string): number {\n  const resolved = value ?? fallback;\n  if (!Number.isInteger(resolved) || resolved <= 0) {\n    throw new RangeError(`${name} must be a positive integer`);\n  }\n  return resolved;\n}\n\nfunction nonNegativeInteger(value: number | undefined, fallback: number, name: string): number {\n  const resolved = value ?? fallback;\n  if (!Number.isInteger(resolved) || resolved < 0) {\n    throw new RangeError(`${name} must be a non-negative integer`);\n  }\n  return resolved;\n}\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"cache.js","sourceRoot":"","sources":["../../src/cache.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * Memory-first Cacheable and Keyv composition.\n *\n * @module\n */\n\nimport { EventEmitter } from \"node:events\";\nimport { join } from \"node:path\";\nimport { projectUtils } from \"@dbx-tools/core\";\nimport { log, toError } from \"@dbx-tools/shared-core\";\nimport {\n  Cacheable,\n  CacheableHooks,\n  KeyvCacheableMemory,\n  type CacheableOptions,\n  type GetOrSetFunctionOptions,\n  type KeyvStoreAdapter,\n  shorthandToMilliseconds,\n} from \"cacheable\";\nimport envPaths from \"env-paths\";\nimport { Keyv } from \"keyv\";\nimport { KeyvFile } from \"keyv-file\";\n\nconst DEFAULT_MAX_ENTRIES = 1_000;\nconst DEFAULT_WRITE_DELAY_MS = 25;\nconst ERROR_VALUE_PREFIX = \"__dbx_tools_cached_on_error__:\";\nconst ENVELOPE_VERSION = 1;\nconst logger = log.logger(\"cache\");\n\ninterface ValueEnvelope {\n  readonly __dbxToolsCacheEnvelope: typeof ENVELOPE_VERSION;\n  readonly value: unknown;\n  readonly writtenAt?: number;\n}\n\ninterface SetMutation {\n  readonly kind: \"set\";\n  readonly ttl?: number;\n  readonly value: unknown;\n}\n\ninterface DeleteMutation {\n  readonly kind: \"delete\";\n}\n\ntype Mutation = DeleteMutation | SetMutation;\n\ninterface CacheState {\n  readonly adapter?: TieredStoreAdapter;\n  readonly refreshes: Map<string, Promise<void>>;\n  path?: string;\n  registryKey?: string;\n  closed: boolean;\n}\n\n/** One ordered persistent cache level. Earlier levels are read first. */\nexport interface CacheLevel {\n  /** Optional name included in persistence error messages. */\n  readonly name?: string;\n  /** Keyv-compatible store adapter. */\n  readonly store: KeyvStoreAdapter;\n}\n\n/** Options for an AppKit-independent memory-first cache. */\nexport interface CacheOptions extends Pick<\n  CacheableOptions,\n  \"cacheId\" | \"maxTtl\" | \"namespace\" | \"stats\" | \"tags\" | \"ttl\"\n> {\n  /** Additional ordered persistence levels. No levels creates a memory-only cache. */\n  readonly levels?: readonly CacheLevel[];\n  /** Maximum entries retained in the memory primary. Defaults to 1,000. */\n  readonly maxEntries?: number;\n  /** Whether memory reads clone values. Defaults to true. */\n  readonly useClone?: boolean;\n  /** Delay used to coalesce persistence mutations. Defaults to 25 milliseconds. */\n  readonly writeDelayMs?: number;\n}\n\n/** Options for the default project-scoped memory and disk cache. */\nexport interface ProjectCacheOptions extends CacheOptions {\n  /** Override the cache directory, primarily for tests. */\n  readonly cacheDir?: string;\n  /** Disable the default disk level. Defaults to true. */\n  readonly disk?: boolean;\n  /** Delay used by keyv-file to coalesce file rewrites. Defaults to 100 milliseconds. */\n  readonly diskWriteDelayMs?: number;\n  /** Override the project name resolved through projectUtils.name(). */\n  readonly projectName?: string;\n}\n\n/** Age after which a cache hit returns its value and starts an asynchronous refresh. */\nexport type RefreshAfterWrite<T> = number | string | ((value: T) => number | string);\n\n/** Options for the Cacheable-compatible get-or-set extension. */\nexport interface GetOrSetOptions<T = unknown> extends GetOrSetFunctionOptions {\n  /** Return a separately retained successful value when the loader fails. Defaults to false. */\n  readonly returnCachedOnError?: boolean;\n  /** TTL for the cached-on-error value. Defaults to 0, meaning no expiration. */\n  readonly cachedOnErrorTtl?: number | string;\n  /**\n   * Return an older cached value immediately and refresh it once in the background after this\n   * duration since its last successful write. The hard `ttl` still controls final expiration.\n   */\n  readonly refreshAfterWrite?: RefreshAfterWrite<T>;\n}\n\nconst states = new WeakMap<Cacheable, CacheState>();\nconst projectCaches = new Map<string, Cacheable>();\nconst resultWriteTimes = new WeakMap<object, number>();\n\n/**\n * Keyv adapter that composes arbitrary ordered levels behind Cacheable's one\n * secondary-store slot and owns tracked write-behind persistence.\n */\nclass TieredStoreAdapter extends EventEmitter implements KeyvStoreAdapter {\n  readonly opts = {};\n  namespace?: string;\n\n  private readonly levels: readonly CacheLevel[];\n  private readonly pending = new Map<string, Mutation>();\n  private readonly promotions = new Set<Promise<void>>();\n  private readonly writeDelayMs: number;\n  private flushPromise?: Promise<void>;\n  private timer?: ReturnType<typeof setTimeout>;\n  private disconnected = false;\n\n  constructor(levels: readonly CacheLevel[], writeDelayMs: number) {\n    super();\n    this.levels = levels;\n    this.writeDelayMs = writeDelayMs;\n  }\n\n  async get<Value>(key: string): Promise<Value | undefined> {\n    const mutation = this.pending.get(key);\n    if (mutation?.kind === \"delete\") return undefined;\n    if (mutation?.kind === \"set\") return mutation.value as Value;\n\n    for (const [index, level] of this.levels.entries()) {\n      const value = await level.store.get<Value>(key);\n      if (value === undefined) continue;\n      if (index > 0) this.promote(key, value, this.levels.slice(0, index));\n      return value as Value;\n    }\n    return undefined;\n  }\n\n  async getMany<Value>(keys: string[]): Promise<Array<Value | undefined>> {\n    return Promise.all(keys.map((key) => this.get<Value>(key)));\n  }\n\n  set(key: string, value: unknown, ttl?: number): Promise<boolean> {\n    this.assertConnected();\n    this.pending.set(key, { kind: \"set\", value, ...(ttl === undefined ? {} : { ttl }) });\n    this.schedule();\n    return Promise.resolve(true);\n  }\n\n  async setMany(values: Array<{ key: string; value: unknown; ttl?: number }>): Promise<void> {\n    for (const entry of values) await this.set(entry.key, entry.value, entry.ttl);\n  }\n\n  delete(key: string): Promise<boolean> {\n    this.assertConnected();\n    this.pending.set(key, { kind: \"delete\" });\n    this.schedule();\n    return Promise.resolve(true);\n  }\n\n  async deleteMany(keys: string[]): Promise<boolean> {\n    await Promise.all(keys.map((key) => this.delete(key)));\n    return true;\n  }\n\n  async has(key: string): Promise<boolean> {\n    const pending = this.pending.get(key);\n    if (pending) return pending.kind === \"set\";\n    for (const level of this.levels) {\n      if (\n        level.store.has ? await level.store.has(key) : (await level.store.get(key)) !== undefined\n      ) {\n        return true;\n      }\n    }\n    return false;\n  }\n\n  async clear(): Promise<void> {\n    this.assertConnected();\n    await this.flush();\n    this.pending.clear();\n    await settleLevels(this.levels, (level) => level.store.clear(), \"clear\");\n  }\n\n  async flush(): Promise<void> {\n    if (this.timer) {\n      clearTimeout(this.timer);\n      this.timer = undefined;\n    }\n    if (!this.flushPromise) {\n      this.flushPromise = this.flushPending().finally(() => {\n        this.flushPromise = undefined;\n      });\n    }\n    await this.flushPromise;\n    await this.flushPromotions();\n    if (this.pending.size > 0) await this.flush();\n  }\n\n  async disconnect(): Promise<void> {\n    if (this.disconnected) return;\n    await this.flush();\n    this.disconnected = true;\n    await settleLevels(\n      this.levels.filter((level) => level.store.disconnect),\n      (level) => level.store.disconnect!(),\n      \"disconnect\",\n    );\n  }\n\n  private assertConnected(): void {\n    if (this.disconnected) throw new Error(\"Cache persistence is disconnected\");\n  }\n\n  private schedule(): void {\n    if (this.timer || this.flushPromise) return;\n    this.timer = setTimeout(() => {\n      this.timer = undefined;\n      void this.flush().catch((error) => {\n        logger.warn(\"cache persistence flush failed\", { error: toError(error) });\n        this.emit(\"error\", error);\n      });\n    }, this.writeDelayMs);\n    this.timer.unref?.();\n  }\n\n  private async flushPending(): Promise<void> {\n    while (this.pending.size > 0) {\n      const batch = new Map(this.pending);\n      for (const key of batch.keys()) this.pending.delete(key);\n      const failures: Array<{ key: string; mutation: Mutation; error: unknown }> = [];\n      await Promise.all(\n        [...batch].map(async ([key, mutation]) => {\n          try {\n            await settleLevels(\n              this.levels,\n              (level) =>\n                mutation.kind === \"set\"\n                  ? level.store.set(key, mutation.value, mutation.ttl)\n                  : level.store.delete(key),\n              mutation.kind,\n            );\n          } catch (error) {\n            failures.push({ key, mutation, error });\n          }\n        }),\n      );\n      if (failures.length > 0) {\n        for (const failure of failures) {\n          if (!this.pending.has(failure.key)) this.pending.set(failure.key, failure.mutation);\n        }\n        throw new AggregateError(\n          failures.map((failure) => failure.error),\n          `Cache persistence failed for ${failures.length} mutation(s)`,\n        );\n      }\n    }\n  }\n\n  private promote(key: string, value: unknown, levels: readonly CacheLevel[]): void {\n    const promotion = settleLevels(levels, (level) => level.store.set(key, value), \"promote\")\n      .catch((error) => {\n        logger.warn(\"cache persistence promotion failed\", {\n          key,\n          error: toError(error),\n        });\n      })\n      .finally(() => {\n        this.promotions.delete(promotion);\n      });\n    this.promotions.add(promotion);\n  }\n\n  private async flushPromotions(): Promise<void> {\n    while (this.promotions.size > 0) await Promise.all([...this.promotions]);\n  }\n}\n\n/** Create a memory-first cache with optional ordered persistent levels. */\nexport function createCache(options: CacheOptions = {}): Cacheable {\n  const maxEntries = positiveInteger(options.maxEntries, DEFAULT_MAX_ENTRIES, \"maxEntries\");\n  const writeDelayMs = nonNegativeInteger(\n    options.writeDelayMs,\n    DEFAULT_WRITE_DELAY_MS,\n    \"writeDelayMs\",\n  );\n  const primary = new Keyv({\n    store: new KeyvCacheableMemory({\n      lruSize: maxEntries,\n      ttl: options.ttl,\n      useClone: options.useClone ?? true,\n    }),\n    ...(typeof options.ttl === \"number\" && Number.isInteger(options.ttl)\n      ? { ttl: options.ttl }\n      : {}),\n  });\n  primary.serialize = undefined;\n  primary.deserialize = undefined;\n  const adapter = options.levels?.length\n    ? new TieredStoreAdapter(options.levels, writeDelayMs)\n    : undefined;\n  const secondary = adapter ? new Keyv({ store: adapter }) : undefined;\n  const cache = new Cacheable({\n    primary,\n    ...(secondary ? { secondary, nonBlocking: true } : {}),\n    ...(options.cacheId === undefined ? {} : { cacheId: options.cacheId }),\n    ...(options.maxTtl === undefined ? {} : { maxTtl: options.maxTtl }),\n    ...(options.namespace === undefined ? {} : { namespace: options.namespace }),\n    ...(options.stats === undefined ? {} : { stats: options.stats }),\n    ...(options.tags === undefined ? {} : { tags: options.tags }),\n    ...(options.ttl === undefined ? {} : { ttl: options.ttl }),\n  });\n  installValueEnvelope(cache);\n  cache.on(\"error\", (error) => {\n    logger.warn(\"cacheable operation failed\", { error: toError(error) });\n  });\n  states.set(cache, { adapter, refreshes: new Map(), closed: false });\n  return cache;\n}\n\n/** Resolve the default portable disk path for a project cache scope. */\nexport function cachePath(\n  scope: string,\n  options: Pick<ProjectCacheOptions, \"cacheDir\" | \"projectName\"> = {},\n): string {\n  const projectName = options.projectName ?? projectUtils.name();\n  const root = options.cacheDir ?? envPaths(\"dbx-tools\", { suffix: \"\" }).cache;\n  return join(root, \"cache\", safeSegment(projectName), `${safeSegment(scope)}.json`);\n}\n\n/**\n * Return a process-shared project cache. By default it is memory-first with a\n * portable keyv-file secondary scoped by project and logical cache name.\n */\nexport function projectCache(scope: string, options: ProjectCacheOptions = {}): Cacheable {\n  const path = cachePath(scope, options);\n  const registryKey = JSON.stringify([path, options.disk !== false]);\n  const existing = projectCaches.get(registryKey);\n  if (existing) return existing;\n\n  const levels = [...(options.levels ?? [])];\n  if (options.disk !== false) {\n    levels.push({\n      name: \"disk\",\n      store: new KeyvFile({\n        filename: path,\n        writeDelay: nonNegativeInteger(options.diskWriteDelayMs, 100, \"diskWriteDelayMs\"),\n      }),\n    });\n  }\n  const cache = createCache({ ...options, levels });\n  const state = requireState(cache);\n  state.path = path;\n  state.registryKey = registryKey;\n  projectCaches.set(registryKey, cache);\n  return cache;\n}\n\n/** Wait for all tracked write-behind persistence without closing the cache. */\nexport async function flushCache(cache: Cacheable): Promise<void> {\n  await requireState(cache).adapter?.flush();\n}\n\n/** Flush pending persistence and disconnect all cache levels. Idempotent. */\nexport async function closeCache(cache: Cacheable): Promise<void> {\n  const state = requireState(cache);\n  if (state.closed) return;\n  while (state.refreshes.size > 0) await Promise.all([...state.refreshes.values()]);\n  await state.adapter?.disconnect();\n  state.closed = true;\n  if (state.registryKey && projectCaches.get(state.registryKey) === cache) {\n    projectCaches.delete(state.registryKey);\n  }\n}\n\n/** Iterate keys currently retained by the bounded memory primary. */\nexport function cacheKeys(cache: Cacheable): IterableIterator<string> {\n  const store = cache.primary.store;\n  if (!(store instanceof KeyvCacheableMemory)) {\n    throw new TypeError(\"Cache primary is not Cacheable memory\");\n  }\n  return store.store.keys;\n}\n\n/** Delete a normal cache value and its optional cached-on-error companion. */\nexport async function deleteCachedValue(cache: Cacheable, key: string): Promise<boolean> {\n  const [value, fallback] = await Promise.all([\n    cache.delete(key),\n    cache.delete(cachedOnErrorKey(key)),\n  ]);\n  return Boolean(value || fallback);\n}\n\n/**\n * Use Cacheable's native in-flight get-or-set behavior, optionally retaining a\n * successful value under a separate key for recovery when a later loader fails.\n */\nexport async function getOrSet<T>(\n  cache: Cacheable,\n  key: string,\n  load: () => Promise<T>,\n  options: GetOrSetOptions<T> = {},\n): Promise<T | undefined> {\n  const {\n    returnCachedOnError = false,\n    cachedOnErrorTtl = 0,\n    refreshAfterWrite,\n    ...cacheableOptions\n  } = options;\n  const loadFresh = async (): Promise<T> => {\n    const value = await load();\n    if (returnCachedOnError) {\n      await cache.set(cachedOnErrorKey(key), value, { ttl: cachedOnErrorTtl });\n    }\n    return value;\n  };\n\n  if (refreshAfterWrite !== undefined) {\n    const getOptions =\n      cacheableOptions.nonBlocking === undefined\n        ? undefined\n        : { nonBlocking: cacheableOptions.nonBlocking };\n    let cached = await cache.getRaw<T>(key, getOptions);\n    if (!cached) {\n      const refresh = requireState(cache).refreshes.get(key);\n      if (refresh) {\n        await refresh;\n        cached = await cache.getRaw<T>(key, getOptions);\n      }\n    }\n    if (cached) {\n      const value = cached.value as T;\n      const writtenAt = resultWriteTimes.get(cached as object);\n      const refreshMs = resolveRefreshAfterWrite(refreshAfterWrite, value);\n      if (writtenAt === undefined || Date.now() - writtenAt >= refreshMs) {\n        startRefresh(cache, key, loadFresh, cacheableOptions);\n      }\n      return value;\n    }\n  }\n\n  if (!returnCachedOnError) return cache.getOrSet(key, loadFresh, cacheableOptions);\n\n  try {\n    return await cache.getOrSet(key, loadFresh, { ...cacheableOptions, throwErrors: true });\n  } catch (error) {\n    const cached = await cache.get<T>(cachedOnErrorKey(key));\n    if (cached !== undefined) return cached;\n    if (cacheableOptions.throwErrors) throw error;\n    return undefined;\n  }\n}\n\nfunction installValueEnvelope(cache: Cacheable): void {\n  cache.onHook(CacheableHooks.BEFORE_SET, (item) => {\n    item.value = envelope(item.value);\n  });\n  cache.onHook(CacheableHooks.BEFORE_SET_MANY, (items) => {\n    for (const item of items) item.value = envelope(item.value);\n  });\n  cache.onHook(CacheableHooks.AFTER_GET, (item) => {\n    if (item.result) unwrapResult(item.result);\n  });\n  cache.onHook(CacheableHooks.AFTER_GET_MANY, (item) => {\n    for (const result of item.result) {\n      if (result) unwrapResult(result);\n    }\n  });\n}\n\nfunction envelope(value: unknown): ValueEnvelope {\n  return { __dbxToolsCacheEnvelope: ENVELOPE_VERSION, value, writtenAt: Date.now() };\n}\n\nfunction unwrapResult(result: { value?: unknown }): void {\n  if (!isEnvelope(result.value)) return;\n  const { writtenAt } = result.value;\n  if (typeof writtenAt === \"number\" && Number.isFinite(writtenAt)) {\n    resultWriteTimes.set(result, writtenAt);\n  }\n  result.value = result.value.value;\n}\n\nfunction isEnvelope(value: unknown): value is ValueEnvelope {\n  return Boolean(\n    value &&\n    typeof value === \"object\" &&\n    \"__dbxToolsCacheEnvelope\" in value &&\n    (value as ValueEnvelope).__dbxToolsCacheEnvelope === ENVELOPE_VERSION &&\n    \"value\" in value,\n  );\n}\n\nfunction cachedOnErrorKey(key: string): string {\n  return `${ERROR_VALUE_PREFIX}${key}`;\n}\n\nfunction startRefresh<T>(\n  cache: Cacheable,\n  key: string,\n  load: () => Promise<T>,\n  options: GetOrSetFunctionOptions,\n): void {\n  const state = requireState(cache);\n  if (state.refreshes.has(key)) return;\n  let refresh!: Promise<void>;\n  refresh = (async () => {\n    const value = await load();\n    await cache.set(key, value, {\n      ...(options.ttl === undefined ? {} : { ttl: options.ttl }),\n      ...(options.nonBlocking === undefined ? {} : { nonBlocking: options.nonBlocking }),\n    });\n  })()\n    .catch((error) => {\n      logger.warn(\"cache background refresh failed\", { key, error: toError(error) });\n    })\n    .finally(() => {\n      if (state.refreshes.get(key) === refresh) state.refreshes.delete(key);\n    });\n  state.refreshes.set(key, refresh);\n}\n\nfunction resolveRefreshAfterWrite<T>(option: RefreshAfterWrite<T>, value: T): number {\n  const configured = typeof option === \"function\" ? option(value) : option;\n  const resolved =\n    typeof configured === \"number\" ? configured : shorthandToMilliseconds(configured);\n  if (resolved === undefined || !Number.isFinite(resolved) || resolved <= 0) {\n    throw new RangeError(\"refreshAfterWrite must resolve to a positive duration\");\n  }\n  return resolved;\n}\n\nasync function settleLevels(\n  levels: readonly CacheLevel[],\n  operation: (level: CacheLevel) => unknown | Promise<unknown>,\n  operationName: string,\n): Promise<void> {\n  const results = await Promise.allSettled(levels.map((level) => operation(level)));\n  const errors = results.flatMap((result, index) =>\n    result.status === \"rejected\"\n      ? [\n          new Error(`${levels[index]?.name ?? `level-${index + 1}`} ${operationName} failed`, {\n            cause: result.reason,\n          }),\n        ]\n      : [],\n  );\n  if (errors.length > 0) throw new AggregateError(errors, `Cache ${operationName} failed`);\n}\n\nfunction requireState(cache: Cacheable): CacheState {\n  const state = states.get(cache);\n  if (!state) throw new TypeError(\"Cache was not created by @dbx-tools/cache\");\n  return state;\n}\n\nfunction safeSegment(value: string): string {\n  return encodeURIComponent(value.trim() || \"default\");\n}\n\nfunction positiveInteger(value: number | undefined, fallback: number, name: string): number {\n  const resolved = value ?? fallback;\n  if (!Number.isInteger(resolved) || resolved <= 0) {\n    throw new RangeError(`${name} must be a positive integer`);\n  }\n  return resolved;\n}\n\nfunction nonNegativeInteger(value: number | undefined, fallback: number, name: string): number {\n  const resolved = value ?? fallback;\n  if (!Number.isInteger(resolved) || resolved < 0) {\n    throw new RangeError(`${name} must be a non-negative integer`);\n  }\n  return resolved;\n}\n"]}

package/package.json

@@ -24,8 +24,8 @@
     "vitest": "3.2.4"
   },
   "dependencies": {
-    "@dbx-tools/core": "^0.9.176",
-    "@dbx-tools/shared-core": "^0.9.176",
+    "@dbx-tools/core": "^0.9.178",
+    "@dbx-tools/shared-core": "^0.9.178",
     "cacheable": "2.5.0",
     "env-paths": "^4.0.0",
     "keyv": "5.6.0",
@@ -45,7 +45,7 @@
       "./package.json": "./package.json"
     }
   },
-  "version": "0.9.176",
+  "version": "0.9.178",
   "types": "./lib/index.d.ts",
   "dbxToolsConfig": {
     "tags": [

package/src/cache.ts

@@ -15,6 +15,7 @@ import {
   type CacheableOptions,
   type GetOrSetFunctionOptions,
   type KeyvStoreAdapter,
+  shorthandToMilliseconds,
 } from "cacheable";
 import envPaths from "env-paths";
 import { Keyv } from "keyv";
@@ -29,6 +30,7 @@ const logger = log.logger("cache");
 interface ValueEnvelope {
   readonly __dbxToolsCacheEnvelope: typeof ENVELOPE_VERSION;
   readonly value: unknown;
+  readonly writtenAt?: number;
 }
 
 interface SetMutation {
@@ -45,6 +47,7 @@ type Mutation = DeleteMutation | SetMutation;
 
 interface CacheState {
   readonly adapter?: TieredStoreAdapter;
+  readonly refreshes: Map<string, Promise<void>>;
   path?: string;
   registryKey?: string;
   closed: boolean;
@@ -85,16 +88,25 @@ export interface ProjectCacheOptions extends CacheOptions {
   readonly projectName?: string;
 }
 
+/** Age after which a cache hit returns its value and starts an asynchronous refresh. */
+export type RefreshAfterWrite<T> = number | string | ((value: T) => number | string);
+
 /** Options for the Cacheable-compatible get-or-set extension. */
-export interface GetOrSetOptions extends GetOrSetFunctionOptions {
+export interface GetOrSetOptions<T = unknown> extends GetOrSetFunctionOptions {
   /** Return a separately retained successful value when the loader fails. Defaults to false. */
   readonly returnCachedOnError?: boolean;
   /** TTL for the cached-on-error value. Defaults to 0, meaning no expiration. */
   readonly cachedOnErrorTtl?: number | string;
+  /**
+   * Return an older cached value immediately and refresh it once in the background after this
+   * duration since its last successful write. The hard `ttl` still controls final expiration.
+   */
+  readonly refreshAfterWrite?: RefreshAfterWrite<T>;
 }
 
 const states = new WeakMap<Cacheable, CacheState>();
 const projectCaches = new Map<string, Cacheable>();
+const resultWriteTimes = new WeakMap<object, number>();
 
 /**
  * Keyv adapter that composes arbitrary ordered levels behind Cacheable's one
@@ -311,7 +323,7 @@ export function createCache(options: CacheOptions = {}): Cacheable {
   cache.on("error", (error) => {
     logger.warn("cacheable operation failed", { error: toError(error) });
   });
-  states.set(cache, { adapter, closed: false });
+  states.set(cache, { adapter, refreshes: new Map(), closed: false });
   return cache;
 }
 
@@ -362,6 +374,7 @@ export async function flushCache(cache: Cacheable): Promise<void> {
 export async function closeCache(cache: Cacheable): Promise<void> {
   const state = requireState(cache);
   if (state.closed) return;
+  while (state.refreshes.size > 0) await Promise.all([...state.refreshes.values()]);
   await state.adapter?.disconnect();
   state.closed = true;
   if (state.registryKey && projectCaches.get(state.registryKey) === cache) {
@@ -395,21 +408,50 @@ export async function getOrSet<T>(
   cache: Cacheable,
   key: string,
   load: () => Promise<T>,
-  options: GetOrSetOptions = {},
+  options: GetOrSetOptions<T> = {},
 ): Promise<T | undefined> {
-  const { returnCachedOnError = false, cachedOnErrorTtl = 0, ...cacheableOptions } = options;
-  if (!returnCachedOnError) return cache.getOrSet(key, load, cacheableOptions);
+  const {
+    returnCachedOnError = false,
+    cachedOnErrorTtl = 0,
+    refreshAfterWrite,
+    ...cacheableOptions
+  } = options;
+  const loadFresh = async (): Promise<T> => {
+    const value = await load();
+    if (returnCachedOnError) {
+      await cache.set(cachedOnErrorKey(key), value, { ttl: cachedOnErrorTtl });
+    }
+    return value;
+  };
+
+  if (refreshAfterWrite !== undefined) {
+    const getOptions =
+      cacheableOptions.nonBlocking === undefined
+        ? undefined
+        : { nonBlocking: cacheableOptions.nonBlocking };
+    let cached = await cache.getRaw<T>(key, getOptions);
+    if (!cached) {
+      const refresh = requireState(cache).refreshes.get(key);
+      if (refresh) {
+        await refresh;
+        cached = await cache.getRaw<T>(key, getOptions);
+      }
+    }
+    if (cached) {
+      const value = cached.value as T;
+      const writtenAt = resultWriteTimes.get(cached as object);
+      const refreshMs = resolveRefreshAfterWrite(refreshAfterWrite, value);
+      if (writtenAt === undefined || Date.now() - writtenAt >= refreshMs) {
+        startRefresh(cache, key, loadFresh, cacheableOptions);
+      }
+      return value;
+    }
+  }
+
+  if (!returnCachedOnError) return cache.getOrSet(key, loadFresh, cacheableOptions);
 
   try {
-    return await cache.getOrSet(
-      key,
-      async () => {
-        const value = await load();
-        await cache.set(cachedOnErrorKey(key), value, { ttl: cachedOnErrorTtl });
-        return value;
-      },
-      { ...cacheableOptions, throwErrors: true },
-    );
+    return await cache.getOrSet(key, loadFresh, { ...cacheableOptions, throwErrors: true });
   } catch (error) {
     const cached = await cache.get<T>(cachedOnErrorKey(key));
     if (cached !== undefined) return cached;
@@ -426,21 +468,26 @@ function installValueEnvelope(cache: Cacheable): void {
     for (const item of items) item.value = envelope(item.value);
   });
   cache.onHook(CacheableHooks.AFTER_GET, (item) => {
-    if (item.result) item.result.value = unwrap(item.result.value);
+    if (item.result) unwrapResult(item.result);
   });
   cache.onHook(CacheableHooks.AFTER_GET_MANY, (item) => {
     for (const result of item.result) {
-      if (result) result.value = unwrap(result.value);
+      if (result) unwrapResult(result);
     }
   });
 }
 
 function envelope(value: unknown): ValueEnvelope {
-  return { __dbxToolsCacheEnvelope: ENVELOPE_VERSION, value };
+  return { __dbxToolsCacheEnvelope: ENVELOPE_VERSION, value, writtenAt: Date.now() };
 }
 
-function unwrap(value: unknown): unknown {
-  return isEnvelope(value) ? value.value : value;
+function unwrapResult(result: { value?: unknown }): void {
+  if (!isEnvelope(result.value)) return;
+  const { writtenAt } = result.value;
+  if (typeof writtenAt === "number" && Number.isFinite(writtenAt)) {
+    resultWriteTimes.set(result, writtenAt);
+  }
+  result.value = result.value.value;
 }
 
 function isEnvelope(value: unknown): value is ValueEnvelope {
@@ -457,6 +504,41 @@ function cachedOnErrorKey(key: string): string {
   return `${ERROR_VALUE_PREFIX}${key}`;
 }
 
+function startRefresh<T>(
+  cache: Cacheable,
+  key: string,
+  load: () => Promise<T>,
+  options: GetOrSetFunctionOptions,
+): void {
+  const state = requireState(cache);
+  if (state.refreshes.has(key)) return;
+  let refresh!: Promise<void>;
+  refresh = (async () => {
+    const value = await load();
+    await cache.set(key, value, {
+      ...(options.ttl === undefined ? {} : { ttl: options.ttl }),
+      ...(options.nonBlocking === undefined ? {} : { nonBlocking: options.nonBlocking }),
+    });
+  })()
+    .catch((error) => {
+      logger.warn("cache background refresh failed", { key, error: toError(error) });
+    })
+    .finally(() => {
+      if (state.refreshes.get(key) === refresh) state.refreshes.delete(key);
+    });
+  state.refreshes.set(key, refresh);
+}
+
+function resolveRefreshAfterWrite<T>(option: RefreshAfterWrite<T>, value: T): number {
+  const configured = typeof option === "function" ? option(value) : option;
+  const resolved =
+    typeof configured === "number" ? configured : shorthandToMilliseconds(configured);
+  if (resolved === undefined || !Number.isFinite(resolved) || resolved <= 0) {
+    throw new RangeError("refreshAfterWrite must resolve to a positive duration");
+  }
+  return resolved;
+}
+
 async function settleLevels(
   levels: readonly CacheLevel[],
   operation: (level: CacheLevel) => unknown | Promise<unknown>,