@dbx-tools/cache 0.0.0-stage → 0.9.119

package/lib/src/cache.js

@@ -0,0 +1,363 @@
+/**
+ * Memory-first Cacheable and Keyv composition.
+ *
+ * @module
+ */
+import { EventEmitter } from "node:events";
+import { join } from "node:path";
+import { projectUtils } from "@dbx-tools/core";
+import { errorUtils, log } from "@dbx-tools/shared-core";
+import { Cacheable, CacheableHooks, createKeyv, KeyvCacheableMemory, } from "cacheable";
+import envPaths from "env-paths";
+import { KeyvFile } from "keyv-file";
+const DEFAULT_MAX_ENTRIES = 1_000;
+const DEFAULT_WRITE_DELAY_MS = 25;
+const ERROR_VALUE_PREFIX = "__dbx_tools_cached_on_error__:";
+const ENVELOPE_VERSION = 1;
+const logger = log.logger("cache");
+const states = new WeakMap();
+const projectCaches = new Map();
+/**
+ * Keyv adapter that composes arbitrary ordered levels behind Cacheable's one
+ * secondary-store slot and owns tracked write-behind persistence.
+ */
+class TieredStoreAdapter extends EventEmitter {
+    opts = {};
+    namespace;
+    levels;
+    pending = new Map();
+    promotions = new Set();
+    writeDelayMs;
+    flushPromise;
+    timer;
+    disconnected = false;
+    constructor(levels, writeDelayMs) {
+        super();
+        this.levels = levels;
+        this.writeDelayMs = writeDelayMs;
+    }
+    async get(key) {
+        const mutation = this.pending.get(key);
+        if (mutation?.kind === "delete")
+            return undefined;
+        if (mutation?.kind === "set")
+            return mutation.value;
+        for (const [index, level] of this.levels.entries()) {
+            const value = await level.store.get(key);
+            if (value === undefined)
+                continue;
+            if (index > 0)
+                this.promote(key, value, this.levels.slice(0, index));
+            return value;
+        }
+        return undefined;
+    }
+    async getMany(keys) {
+        return Promise.all(keys.map((key) => this.get(key)));
+    }
+    set(key, value, ttl) {
+        this.assertConnected();
+        this.pending.set(key, { kind: "set", value, ...(ttl === undefined ? {} : { ttl }) });
+        this.schedule();
+        return Promise.resolve(true);
+    }
+    async setMany(values) {
+        for (const entry of values)
+            await this.set(entry.key, entry.value, entry.ttl);
+    }
+    delete(key) {
+        this.assertConnected();
+        this.pending.set(key, { kind: "delete" });
+        this.schedule();
+        return Promise.resolve(true);
+    }
+    async deleteMany(keys) {
+        await Promise.all(keys.map((key) => this.delete(key)));
+        return true;
+    }
+    async has(key) {
+        const pending = this.pending.get(key);
+        if (pending)
+            return pending.kind === "set";
+        for (const level of this.levels) {
+            if (level.store.has ? await level.store.has(key) : (await level.store.get(key)) !== undefined) {
+                return true;
+            }
+        }
+        return false;
+    }
+    async clear() {
+        this.assertConnected();
+        await this.flush();
+        this.pending.clear();
+        await settleLevels(this.levels, (level) => level.store.clear(), "clear");
+    }
+    async flush() {
+        if (this.timer) {
+            clearTimeout(this.timer);
+            this.timer = undefined;
+        }
+        if (!this.flushPromise) {
+            this.flushPromise = this.flushPending().finally(() => {
+                this.flushPromise = undefined;
+            });
+        }
+        await this.flushPromise;
+        await this.flushPromotions();
+        if (this.pending.size > 0)
+            await this.flush();
+    }
+    async disconnect() {
+        if (this.disconnected)
+            return;
+        await this.flush();
+        this.disconnected = true;
+        await settleLevels(this.levels.filter((level) => level.store.disconnect), (level) => level.store.disconnect(), "disconnect");
+    }
+    assertConnected() {
+        if (this.disconnected)
+            throw new Error("Cache persistence is disconnected");
+    }
+    schedule() {
+        if (this.timer || this.flushPromise)
+            return;
+        this.timer = setTimeout(() => {
+            this.timer = undefined;
+            void this.flush().catch((error) => {
+                logger.warn("cache persistence flush failed", { error: errorUtils.errorMessage(error) });
+                this.emit("error", error);
+            });
+        }, this.writeDelayMs);
+        this.timer.unref?.();
+    }
+    async flushPending() {
+        while (this.pending.size > 0) {
+            const batch = new Map(this.pending);
+            for (const key of batch.keys())
+                this.pending.delete(key);
+            const failures = [];
+            await Promise.all([...batch].map(async ([key, mutation]) => {
+                try {
+                    await settleLevels(this.levels, (level) => mutation.kind === "set"
+                        ? level.store.set(key, mutation.value, mutation.ttl)
+                        : level.store.delete(key), mutation.kind);
+                }
+                catch (error) {
+                    failures.push({ key, mutation, error });
+                }
+            }));
+            if (failures.length > 0) {
+                for (const failure of failures) {
+                    if (!this.pending.has(failure.key))
+                        this.pending.set(failure.key, failure.mutation);
+                }
+                throw new AggregateError(failures.map((failure) => failure.error), `Cache persistence failed for ${failures.length} mutation(s)`);
+            }
+        }
+    }
+    promote(key, value, levels) {
+        const promotion = settleLevels(levels, (level) => level.store.set(key, value), "promote")
+            .catch((error) => {
+            logger.warn("cache persistence promotion failed", {
+                key,
+                error: errorUtils.errorMessage(error),
+            });
+        })
+            .finally(() => {
+            this.promotions.delete(promotion);
+        });
+        this.promotions.add(promotion);
+    }
+    async flushPromotions() {
+        while (this.promotions.size > 0)
+            await Promise.all([...this.promotions]);
+    }
+}
+/** Create a memory-first cache with optional ordered persistent levels. */
+export function createCache(options = {}) {
+    const maxEntries = positiveInteger(options.maxEntries, DEFAULT_MAX_ENTRIES, "maxEntries");
+    const writeDelayMs = nonNegativeInteger(options.writeDelayMs, DEFAULT_WRITE_DELAY_MS, "writeDelayMs");
+    const primary = createKeyv({
+        lruSize: maxEntries,
+        ttl: options.ttl,
+        useClone: options.useClone ?? true,
+    });
+    const adapter = options.levels?.length
+        ? new TieredStoreAdapter(options.levels, writeDelayMs)
+        : undefined;
+    const cache = new Cacheable({
+        primary,
+        ...(adapter ? { secondary: adapter, nonBlocking: true } : {}),
+        ...(options.cacheId === undefined ? {} : { cacheId: options.cacheId }),
+        ...(options.maxTtl === undefined ? {} : { maxTtl: options.maxTtl }),
+        ...(options.namespace === undefined ? {} : { namespace: options.namespace }),
+        ...(options.stats === undefined ? {} : { stats: options.stats }),
+        ...(options.tags === undefined ? {} : { tags: options.tags }),
+        ...(options.ttl === undefined ? {} : { ttl: options.ttl }),
+    });
+    installValueEnvelope(cache);
+    cache.on("error", (error) => {
+        logger.warn("cacheable operation failed", { error: errorUtils.errorMessage(error) });
+    });
+    states.set(cache, { adapter, closed: false });
+    return cache;
+}
+/** Resolve the default portable disk path for a project cache scope. */
+export function cachePath(scope, options = {}) {
+    const projectName = options.projectName ?? projectUtils.name();
+    const root = options.cacheDir ?? envPaths("dbx-tools", { suffix: "" }).cache;
+    return join(root, "cache", safeSegment(projectName), `${safeSegment(scope)}.json`);
+}
+/**
+ * Return a process-shared project cache. By default it is memory-first with a
+ * portable keyv-file secondary scoped by project and logical cache name.
+ */
+export function projectCache(scope, options = {}) {
+    const path = cachePath(scope, options);
+    const registryKey = JSON.stringify([path, options.disk !== false]);
+    const existing = projectCaches.get(registryKey);
+    if (existing)
+        return existing;
+    const levels = [...(options.levels ?? [])];
+    if (options.disk !== false) {
+        levels.push({
+            name: "disk",
+            store: new KeyvFile({
+                filename: path,
+                writeDelay: nonNegativeInteger(options.diskWriteDelayMs, 100, "diskWriteDelayMs"),
+            }),
+        });
+    }
+    const cache = createCache({ ...options, levels });
+    const state = requireState(cache);
+    state.path = path;
+    state.registryKey = registryKey;
+    projectCaches.set(registryKey, cache);
+    return cache;
+}
+/** Wait for all tracked write-behind persistence without closing the cache. */
+export async function flushCache(cache) {
+    await requireState(cache).adapter?.flush();
+}
+/** Flush pending persistence and disconnect all cache levels. Idempotent. */
+export async function closeCache(cache) {
+    const state = requireState(cache);
+    if (state.closed)
+        return;
+    await state.adapter?.disconnect();
+    state.closed = true;
+    if (state.registryKey && projectCaches.get(state.registryKey) === cache) {
+        projectCaches.delete(state.registryKey);
+    }
+}
+/** Iterate keys currently retained by the bounded memory primary. */
+export function cacheKeys(cache) {
+    const store = cache.primary.store;
+    if (!(store instanceof KeyvCacheableMemory)) {
+        throw new TypeError("Cache primary is not Cacheable memory");
+    }
+    return store.store.keys;
+}
+/** Delete a normal cache value and its optional cached-on-error companion. */
+export async function deleteCachedValue(cache, key) {
+    const [value, fallback] = await Promise.all([
+        cache.delete(key),
+        cache.delete(cachedOnErrorKey(key)),
+    ]);
+    return Boolean(value || fallback);
+}
+/**
+ * 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 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();
+            await cache.set(cachedOnErrorKey(key), value, { ttl: cachedOnErrorTtl });
+            return value;
+        }, { ...cacheableOptions, throwErrors: true });
+    }
+    catch (error) {
+        const cached = await cache.get(cachedOnErrorKey(key));
+        if (cached !== undefined)
+            return cached;
+        if (cacheableOptions.throwErrors)
+            throw error;
+        return undefined;
+    }
+}
+function installValueEnvelope(cache) {
+    cache.onHook(CacheableHooks.BEFORE_SET, (item) => {
+        item.value = envelope(item.value);
+    });
+    cache.onHook(CacheableHooks.BEFORE_SET_MANY, (items) => {
+        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);
+    });
+    cache.onHook(CacheableHooks.AFTER_GET_MANY, (item) => {
+        for (const result of item.result) {
+            if (result)
+                result.value = unwrap(result.value);
+        }
+    });
+}
+function envelope(value) {
+    return { __dbxToolsCacheEnvelope: ENVELOPE_VERSION, value };
+}
+function unwrap(value) {
+    return isEnvelope(value) ? value.value : value;
+}
+function isEnvelope(value) {
+    return Boolean(value &&
+        typeof value === "object" &&
+        "__dbxToolsCacheEnvelope" in value &&
+        value.__dbxToolsCacheEnvelope === ENVELOPE_VERSION &&
+        "value" in value);
+}
+function cachedOnErrorKey(key) {
+    return `${ERROR_VALUE_PREFIX}${key}`;
+}
+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"
+        ? [
+            new Error(`${levels[index]?.name ?? `level-${index + 1}`} ${operationName} failed`, {
+                cause: result.reason,
+            }),
+        ]
+        : []);
+    if (errors.length > 0)
+        throw new AggregateError(errors, `Cache ${operationName} failed`);
+}
+function requireState(cache) {
+    const state = states.get(cache);
+    if (!state)
+        throw new TypeError("Cache was not created by @dbx-tools/cache");
+    return state;
+}
+function safeSegment(value) {
+    return encodeURIComponent(value.trim() || "default");
+}
+function positiveInteger(value, fallback, name) {
+    const resolved = value ?? fallback;
+    if (!Number.isInteger(resolved) || resolved <= 0) {
+        throw new RangeError(`${name} must be a positive integer`);
+    }
+    return resolved;
+}
+function nonNegativeInteger(value, fallback, name) {
+    const resolved = value ?? fallback;
+    if (!Number.isInteger(resolved) || resolved < 0) {
+        throw new RangeError(`${name} must be a non-negative integer`);
+    }
+    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 { errorUtils, log } from \"@dbx-tools/shared-core\";\nimport {\n  Cacheable,\n  CacheableHooks,\n  createKeyv,\n  KeyvCacheableMemory,\n  type CacheableOptions,\n  type GetOrSetFunctionOptions,\n  type KeyvStoreAdapter,\n} from \"cacheable\";\nimport envPaths from \"env-paths\";\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: errorUtils.errorMessage(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: errorUtils.errorMessage(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 = createKeyv({\n    lruSize: maxEntries,\n    ttl: options.ttl,\n    useClone: options.useClone ?? true,\n  });\n  const adapter = options.levels?.length\n    ? new TieredStoreAdapter(options.levels, writeDelayMs)\n    : undefined;\n  const cache = new Cacheable({\n    primary,\n    ...(adapter ? { secondary: adapter, 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: errorUtils.errorMessage(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"]}

package/lib/tsconfig.tsbuildinfo

@@ -0,0 +1 @@
+{"root":["../src/cache.ts","../index.ts"],"version":"5.9.3"}

package/package.json

@@ -1,6 +1,84 @@
 {
   "name": "@dbx-tools/cache",
-  "version": "0.0.0-stage",
-  "stub": true,
-  "description": "Temporary package placeholder for staged publishing"
-}
+  "description": "Memory-first Cacheable and Keyv storage with project-scoped persistence and tracked write-behind",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/reggie-db/dbx-tools.git",
+    "directory": "packages/js/node/cache"
+  },
+  "scripts": {
+    "build": "projen build",
+    "compile": "projen compile",
+    "default": "projen default",
+    "package": "projen package",
+    "post-compile": "projen post-compile",
+    "pre-compile": "projen pre-compile",
+    "prepack": "projen prepack",
+    "test": "projen test",
+    "watch": "projen watch",
+    "projen": "projen"
+  },
+  "devDependencies": {
+    "@types/node": "^24.6.0",
+    "typescript": "^5.9.3",
+    "vitest": "3.2.4"
+  },
+  "dependencies": {
+    "@dbx-tools/core": "^0.9.119",
+    "@dbx-tools/shared-core": "^0.9.119",
+    "cacheable": "2.5.0",
+    "env-paths": "^4.0.0",
+    "keyv-file": "5.3.5"
+  },
+  "main": "./lib/index.js",
+  "license": "Apache-2.0",
+  "publishConfig": {
+    "access": "public",
+    "main": "./lib/index.js",
+    "types": "./lib/index.d.ts",
+    "exports": {
+      ".": {
+        "types": "./lib/index.d.ts",
+        "default": "./lib/index.js"
+      },
+      "./cache": {
+        "types": "./lib/src/cache.d.ts",
+        "default": "./lib/src/cache.js"
+      },
+      "./*": {
+        "types": "./lib/src/*/index.d.ts",
+        "default": "./lib/src/*/index.js"
+      },
+      "./package.json": "./package.json"
+    }
+  },
+  "version": "0.9.119",
+  "types": "./lib/index.d.ts",
+  "dbxToolsConfig": {
+    "tags": [
+      "node"
+    ]
+  },
+  "type": "module",
+  "exports": {
+    ".": {
+      "types": "./lib/index.d.ts",
+      "default": "./lib/index.js"
+    },
+    "./cache": {
+      "types": "./lib/src/cache.d.ts",
+      "default": "./lib/src/cache.js"
+    },
+    "./*": {
+      "types": "./lib/src/*/index.d.ts",
+      "default": "./lib/src/*/index.js"
+    },
+    "./package.json": "./package.json"
+  },
+  "files": [
+    "index.ts",
+    "src",
+    "lib"
+  ],
+  "//": "~~ Generated by projen. To modify, edit .projenrc.js and run \"bunx projen\"."
+}