@holo-js/cache 0.1.3

package/dist/index.mjs

@@ -0,0 +1,1523 @@
+import {
+  CacheConfigError,
+  CacheDriverResolutionError,
+  CacheError,
+  CacheInvalidNumericMutationError,
+  CacheInvalidTtlError,
+  CacheLockAcquisitionError,
+  CacheOptionalPackageError,
+  CacheQueryIntegrationError,
+  CacheRuntimeNotConfiguredError,
+  CacheSerializationError,
+  cacheContractsInternals,
+  defineCacheKey,
+  deserializeCacheValue,
+  isCacheKey,
+  normalizeCacheTtl,
+  resolveCacheKey,
+  serializeCacheValue
+} from "./chunk-KIYULZES.mjs";
+
+// src/index.ts
+import { defineCacheConfig } from "@holo-js/config";
+
+// src/runtime-shared.ts
+import {
+  holoCacheDefaults,
+  normalizeCacheConfig
+} from "@holo-js/config";
+
+// src/db.ts
+import {
+  normalizeDatabaseConfig
+} from "@holo-js/config";
+function escapeRegExp(value) {
+  return value.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+function isNormalizedDatabaseConfig(config) {
+  return typeof config === "object" && config !== null && typeof config.connections === "object" && config.connections !== null;
+}
+function normalizeRuntimeDatabaseConfig(config) {
+  if (!config) return void 0;
+  return normalizeDatabaseConfig(config);
+}
+function resolveSharedDatabaseConnection(databaseConfig, connectionName) {
+  if (!databaseConfig) {
+    throw new CacheDriverResolutionError(
+      `[@holo-js/cache] Database cache driver "${connectionName}" requires a top-level database config from config/database.ts.`
+    );
+  }
+  const connection = databaseConfig.connections[connectionName];
+  if (connection) return connection;
+  const availableConnections = Object.keys(databaseConfig.connections);
+  throw new CacheDriverResolutionError(
+    `[@holo-js/cache] Database cache connection "${connectionName}" was not found in config/database.ts. Available connections: ${availableConnections.join(", ") || "(none)"}.`
+  );
+}
+function isModuleNotFoundError(error, expectedSpecifier = "@holo-js/cache-db") {
+  if (!error || typeof error !== "object") {
+    return false;
+  }
+  const message = "message" in error && typeof error.message === "string" ? error.message : "";
+  const escapedSpecifier = escapeRegExp(expectedSpecifier);
+  if ("code" in error && error.code === "ERR_MODULE_NOT_FOUND" && [
+    new RegExp(`Cannot find package ['"]${escapedSpecifier}['"]`),
+    new RegExp(`Cannot find module ['"]${escapedSpecifier}['"]`),
+    new RegExp(`Could not resolve ['"]${escapedSpecifier}['"]`),
+    new RegExp(`Failed to load url\\s+(?:['"\`]${escapedSpecifier}['"\`]|${escapedSpecifier}(?=[\\s(]|$))`)
+  ].some((pattern) => pattern.test(message))) {
+    return true;
+  }
+  if ("cause" in error) {
+    return isModuleNotFoundError(error.cause, expectedSpecifier);
+  }
+  return false;
+}
+function normalizeDatabaseModuleLoadError(error, expectedSpecifier = "@holo-js/cache-db") {
+  if (isModuleNotFoundError(error, expectedSpecifier)) {
+    return new CacheOptionalPackageError(
+      "[@holo-js/cache] Database cache support requires @holo-js/cache-db to be installed.",
+      { cause: error }
+    );
+  }
+  return error;
+}
+async function loadDatabaseDriverModule() {
+  try {
+    const specifier = "@holo-js/cache-db";
+    return await import(specifier);
+  } catch (error) {
+    throw normalizeDatabaseModuleLoadError(error, "@holo-js/cache-db");
+  }
+}
+var databaseDriverModuleLoader = loadDatabaseDriverModule;
+function setDatabaseDriverModuleLoader(loader) {
+  databaseDriverModuleLoader = loader;
+}
+function resetDatabaseDriverModuleLoader() {
+  databaseDriverModuleLoader = loadDatabaseDriverModule;
+}
+var LazyDatabaseCacheDriver = class {
+  constructor(options) {
+    this.options = options;
+  }
+  driver = "database";
+  driverInstance;
+  pending;
+  get name() {
+    return this.options.name;
+  }
+  async resolveDriver() {
+    if (this.driverInstance) return this.driverInstance;
+    this.pending ??= databaseDriverModuleLoader().then((module) => {
+      const driver = module.createDatabaseCacheDriver(this.options);
+      this.driverInstance = driver;
+      return driver;
+    }).finally(() => {
+      this.pending = void 0;
+    });
+    return this.pending;
+  }
+  async withDriver(callback) {
+    return callback(await this.resolveDriver());
+  }
+  createLockProxy(name, seconds) {
+    let lockPromise;
+    const resolveLock = async () => {
+      lockPromise ??= this.withDriver((driver) => driver.lock(name, seconds));
+      return lockPromise;
+    };
+    return {
+      name,
+      async get(callback) {
+        return (await resolveLock()).get(callback);
+      },
+      async release() {
+        return (await resolveLock()).release();
+      },
+      async block(waitSeconds, callback) {
+        return (await resolveLock()).block(waitSeconds, callback);
+      }
+    };
+  }
+  async get(key) {
+    return this.withDriver((driver) => driver.get(key));
+  }
+  async put(input) {
+    return this.withDriver((driver) => driver.put(input));
+  }
+  async add(input) {
+    return this.withDriver((driver) => driver.add(input));
+  }
+  async forget(key) {
+    return this.withDriver((driver) => driver.forget(key));
+  }
+  async flush() {
+    await this.withDriver((driver) => driver.flush());
+  }
+  async increment(key, amount) {
+    return this.withDriver((driver) => driver.increment(key, amount));
+  }
+  async decrement(key, amount) {
+    return this.withDriver((driver) => driver.decrement(key, amount));
+  }
+  lock(name, seconds) {
+    return this.createLockProxy(name, seconds);
+  }
+};
+function createDatabaseCacheDriver(options) {
+  return new LazyDatabaseCacheDriver(options);
+}
+var cacheDbInternals = {
+  isModuleNotFoundError,
+  isNormalizedDatabaseConfig,
+  loadDatabaseDriverModule,
+  normalizeDatabaseModuleLoadError,
+  normalizeRuntimeDatabaseConfig,
+  resolveSharedDatabaseConnection,
+  resetDatabaseDriverModuleLoader,
+  setDatabaseDriverModuleLoader
+};
+
+// src/file.ts
+import { createHash, randomUUID } from "crypto";
+import { mkdir, open, readFile, readdir, rename, rm, writeFile } from "fs/promises";
+import { dirname, join, resolve } from "path";
+var MALFORMED_FILE = /* @__PURE__ */ Symbol("MALFORMED_FILE");
+function defaultSleep(milliseconds) {
+  return new Promise((resolveDelay) => {
+    setTimeout(resolveDelay, milliseconds);
+  });
+}
+function hashCacheKey(key) {
+  return createHash("sha256").update(key).digest("hex");
+}
+function resolveDriverRoot(path) {
+  return resolve(path);
+}
+function resolveEntryFilePath(rootPath, key) {
+  const hash = hashCacheKey(key);
+  return join(rootPath, "entries", hash.slice(0, 2), `${hash}.json`);
+}
+function resolveLockFilePath(rootPath, name) {
+  const hash = hashCacheKey(name);
+  return join(rootPath, "locks", hash.slice(0, 2), `${hash}.lock`);
+}
+function isPositiveTimestamp(value) {
+  return typeof value === "number" && Number.isFinite(value) && value >= 0;
+}
+function isFileCacheEntryEnvelope(value) {
+  if (!value || typeof value !== "object" || Array.isArray(value)) {
+    return false;
+  }
+  const entry = value;
+  return typeof entry.key === "string" && typeof entry.payload === "string" && (typeof entry.expiresAt === "undefined" || isPositiveTimestamp(entry.expiresAt));
+}
+function isFileCacheLockEnvelope(value) {
+  if (!value || typeof value !== "object" || Array.isArray(value)) {
+    return false;
+  }
+  const lock = value;
+  return typeof lock.name === "string" && typeof lock.owner === "string" && isPositiveTimestamp(lock.expiresAt);
+}
+async function ensureParentDirectory(filePath) {
+  await mkdir(dirname(filePath), { recursive: true });
+}
+async function removeFileIfPresent(filePath) {
+  await rm(filePath, { force: true });
+}
+async function readFileIfPresent(filePath) {
+  try {
+    return await readFile(filePath, "utf8");
+  } catch (error) {
+    if (error instanceof Error && "code" in error && (error.code === "ENOENT" || error.code === "ENOTDIR")) {
+      return void 0;
+    }
+    throw error;
+  }
+}
+async function writeFileAtomically(filePath, contents) {
+  await ensureParentDirectory(filePath);
+  const temporaryPath = `${filePath}.${process.pid}.${randomUUID()}.tmp`;
+  await writeFile(temporaryPath, contents, "utf8");
+  try {
+    await rename(temporaryPath, filePath);
+  } catch (error) {
+    await removeFileIfPresent(temporaryPath);
+    throw error;
+  }
+}
+async function writeFileExclusively(filePath, contents) {
+  await ensureParentDirectory(filePath);
+  try {
+    const handle = await open(filePath, "wx");
+    try {
+      await handle.writeFile(contents, "utf8");
+    } finally {
+      await handle.close();
+    }
+    return true;
+  } catch (error) {
+    if (error instanceof Error && "code" in error && error.code === "EEXIST") {
+      return false;
+    }
+    throw error;
+  }
+}
+async function readJsonFile(filePath) {
+  const contents = await readFileIfPresent(filePath);
+  if (typeof contents === "undefined") return void 0;
+  try {
+    return JSON.parse(contents);
+  } catch {
+    return MALFORMED_FILE;
+  }
+}
+async function listFiles(rootPath) {
+  try {
+    const entries = await readdir(rootPath, { withFileTypes: true });
+    const nested = await Promise.all(entries.map(async (entry) => {
+      const entryPath = join(rootPath, entry.name);
+      if (entry.isDirectory()) return listFiles(entryPath);
+      return [entryPath];
+    }));
+    return nested.flat();
+  } catch (error) {
+    if (error instanceof Error && "code" in error && error.code === "ENOENT") {
+      return [];
+    }
+    throw error;
+  }
+}
+async function removeInvalidFileAndReadMissing(filePath, decoded) {
+  if (typeof decoded !== "undefined") {
+    await removeFileIfPresent(filePath);
+  }
+  return {
+    state: "missing",
+    filePath
+  };
+}
+async function removeScopedCacheFiles(rootPath, prefix, isEnvelope, resolveName) {
+  if (!prefix) {
+    await rm(rootPath, { recursive: true, force: true });
+    await mkdir(rootPath, { recursive: true });
+    return;
+  }
+  for (const filePath of await listFiles(rootPath)) {
+    const decoded = await readJsonFile(filePath);
+    if (!decoded || decoded === MALFORMED_FILE || !isEnvelope(decoded)) {
+      await removeFileIfPresent(filePath);
+      continue;
+    }
+    if (resolveName(decoded).startsWith(prefix)) {
+      await removeFileIfPresent(filePath);
+    }
+  }
+}
+async function readEntry(rootPath, key, now) {
+  const filePath = resolveEntryFilePath(rootPath, key);
+  const decoded = await readJsonFile(filePath);
+  if (decoded === MALFORMED_FILE || !isFileCacheEntryEnvelope(decoded) || decoded.key !== key) {
+    return removeInvalidFileAndReadMissing(filePath, decoded);
+  }
+  if (typeof decoded.expiresAt === "number" && decoded.expiresAt <= now) {
+    return removeInvalidFileAndReadMissing(filePath, decoded);
+  }
+  return {
+    state: "hit",
+    filePath,
+    value: decoded
+  };
+}
+async function readLock(rootPath, name, now) {
+  const filePath = resolveLockFilePath(rootPath, name);
+  const decoded = await readJsonFile(filePath);
+  if (decoded === MALFORMED_FILE || !isFileCacheLockEnvelope(decoded) || decoded.name !== name) {
+    return removeInvalidFileAndReadMissing(filePath, decoded);
+  }
+  if (decoded.expiresAt <= now) {
+    return removeInvalidFileAndReadMissing(filePath, decoded);
+  }
+  return {
+    state: "hit",
+    filePath,
+    value: decoded
+  };
+}
+function createEntryEnvelope(input) {
+  return {
+    key: input.key,
+    payload: input.payload,
+    expiresAt: input.expiresAt
+  };
+}
+function createFileLock(rootPath, name, seconds, now, sleep, ownerFactory) {
+  const owner = ownerFactory();
+  async function tryAcquire() {
+    const filePath = resolveLockFilePath(rootPath, name);
+    const envelope = JSON.stringify({
+      name,
+      owner,
+      expiresAt: now() + seconds * 1e3
+    });
+    if (await writeFileExclusively(filePath, envelope)) {
+      return true;
+    }
+    const currentLock = await readLock(rootPath, name, now());
+    if (currentLock.state === "missing") {
+      return writeFileExclusively(filePath, envelope);
+    }
+    return false;
+  }
+  async function withCallback(callback) {
+    if (!callback) {
+      return true;
+    }
+    try {
+      return await callback();
+    } finally {
+      await lock.release();
+    }
+  }
+  const lock = {
+    name,
+    async get(callback) {
+      if (!await tryAcquire()) {
+        return false;
+      }
+      return withCallback(callback);
+    },
+    async release() {
+      const currentLock = await readLock(rootPath, name, now());
+      if (currentLock.state === "missing" || currentLock.value.owner !== owner) {
+        return false;
+      }
+      const latestLock = await readLock(rootPath, name, now());
+      if (latestLock.state === "missing" || latestLock.value.owner !== owner) {
+        return false;
+      }
+      await removeFileIfPresent(currentLock.filePath);
+      return true;
+    },
+    async block(waitSeconds, callback) {
+      const deadline = now() + waitSeconds * 1e3;
+      while (true) {
+        if (await tryAcquire()) {
+          return withCallback(callback);
+        }
+        if (now() >= deadline) {
+          return false;
+        }
+        await sleep(10);
+      }
+    }
+  };
+  return lock;
+}
+function createFileCacheDriver(options) {
+  const rootPath = resolveDriverRoot(options.path);
+  const prefix = options.prefix ?? "";
+  const now = options.now ?? Date.now;
+  const sleep = options.sleep ?? defaultSleep;
+  const ownerFactory = options.ownerFactory ?? randomUUID;
+  const numericMutationLockSeconds = options.numericMutationLockSeconds ?? 5;
+  const numericMutationWaitSeconds = options.numericMutationWaitSeconds ?? 2;
+  async function writeEntry(input) {
+    const filePath = resolveEntryFilePath(rootPath, input.key);
+    await writeFileAtomically(filePath, JSON.stringify(createEntryEnvelope(input)));
+    return true;
+  }
+  async function mutateNumericValue(key, amount) {
+    const result = await createFileLock(
+      rootPath,
+      `__numeric__:${key}`,
+      numericMutationLockSeconds,
+      now,
+      sleep,
+      ownerFactory
+    ).block(numericMutationWaitSeconds, async () => {
+      const entry = await readEntry(rootPath, key, now());
+      const currentValue = entry.state === "hit" ? deserializeCacheValue(entry.value.payload) : 0;
+      if (typeof currentValue !== "number" || !Number.isFinite(currentValue)) {
+        throw new CacheInvalidNumericMutationError(`[@holo-js/cache] Cache key "${key}" does not contain a numeric value.`);
+      }
+      const nextValue = currentValue + amount;
+      await writeEntry({
+        key,
+        payload: serializeCacheValue(nextValue),
+        expiresAt: entry.state === "hit" ? entry.value.expiresAt : void 0
+      });
+      return nextValue;
+    });
+    if (result === false) {
+      throw new CacheLockAcquisitionError(`[@holo-js/cache] Could not acquire file cache mutation lock for "${key}".`);
+    }
+    if (result === true) {
+      throw new CacheLockAcquisitionError(`[@holo-js/cache] File cache mutation lock for "${key}" returned no numeric result.`);
+    }
+    return result;
+  }
+  return {
+    name: options.name,
+    driver: "file",
+    async get(key) {
+      const entry = await readEntry(rootPath, key, now());
+      if (entry.state === "missing") {
+        return Object.freeze({ hit: false });
+      }
+      return Object.freeze({
+        hit: true,
+        payload: entry.value.payload,
+        expiresAt: entry.value.expiresAt
+      });
+    },
+    async put(input) {
+      return writeEntry(input);
+    },
+    async add(input) {
+      const nowValue = now();
+      const filePath = resolveEntryFilePath(rootPath, input.key);
+      const existing = await readEntry(rootPath, input.key, nowValue);
+      if (existing.state === "hit") {
+        return false;
+      }
+      if (await writeFileExclusively(filePath, JSON.stringify(createEntryEnvelope(input)))) {
+        return true;
+      }
+      const afterCollision = await readEntry(rootPath, input.key, nowValue);
+      if (afterCollision.state === "hit") {
+        return false;
+      }
+      return writeFileExclusively(filePath, JSON.stringify(createEntryEnvelope(input)));
+    },
+    async forget(key) {
+      const filePath = resolveEntryFilePath(rootPath, key);
+      const contents = await readFileIfPresent(filePath);
+      if (typeof contents === "undefined") {
+        return false;
+      }
+      await removeFileIfPresent(filePath);
+      return true;
+    },
+    async flush() {
+      await removeScopedCacheFiles(
+        join(rootPath, "entries"),
+        prefix,
+        isFileCacheEntryEnvelope,
+        (entry) => entry.key
+      );
+      await removeScopedCacheFiles(
+        join(rootPath, "locks"),
+        prefix,
+        isFileCacheLockEnvelope,
+        (lock) => lock.name
+      );
+    },
+    async increment(key, amount) {
+      return mutateNumericValue(key, amount);
+    },
+    async decrement(key, amount) {
+      return mutateNumericValue(key, -amount);
+    },
+    lock(name, seconds) {
+      return createFileLock(rootPath, name, seconds, now, sleep, ownerFactory);
+    }
+  };
+}
+var fileDriverInternals = {
+  hashCacheKey,
+  isFileCacheEntryEnvelope,
+  isFileCacheLockEnvelope,
+  resolveDriverRoot,
+  resolveEntryFilePath,
+  resolveLockFilePath
+};
+
+// src/memory.ts
+function createMemoryCacheDriverState() {
+  return {
+    entries: /* @__PURE__ */ new Map(),
+    locks: /* @__PURE__ */ new Map()
+  };
+}
+function defaultSleep2(milliseconds) {
+  return new Promise((resolve2) => {
+    setTimeout(resolve2, milliseconds);
+  });
+}
+function createMemoryLock(state, name, seconds, now, sleep) {
+  const owner = Symbol(name);
+  function clearExpiredLock() {
+    const current = state.locks.get(name);
+    if (current && current.expiresAt <= now()) {
+      state.locks.delete(name);
+    }
+  }
+  function tryAcquire() {
+    clearExpiredLock();
+    const current = state.locks.get(name);
+    if (current) {
+      return false;
+    }
+    state.locks.set(name, {
+      owner,
+      expiresAt: now() + seconds * 1e3
+    });
+    return true;
+  }
+  async function withCallback(callback) {
+    if (!callback) {
+      return true;
+    }
+    try {
+      return await callback();
+    } finally {
+      await lock.release();
+    }
+  }
+  const lock = {
+    name,
+    async get(callback) {
+      if (!tryAcquire()) {
+        return false;
+      }
+      return withCallback(callback);
+    },
+    async release() {
+      clearExpiredLock();
+      const current = state.locks.get(name);
+      if (!current || current.owner !== owner) {
+        return false;
+      }
+      state.locks.delete(name);
+      return true;
+    },
+    async block(waitSeconds, callback) {
+      const deadline = now() + waitSeconds * 1e3;
+      while (true) {
+        if (tryAcquire()) {
+          return withCallback(callback);
+        }
+        if (now() >= deadline) {
+          return false;
+        }
+        await sleep(10);
+      }
+    }
+  };
+  return lock;
+}
+function isExpired(entry, timestamp) {
+  return typeof entry.expiresAt === "number" && entry.expiresAt <= timestamp;
+}
+function pruneExpiredEntry(state, key, timestamp) {
+  const entry = state.entries.get(key);
+  if (!entry) {
+    return void 0;
+  }
+  if (isExpired(entry, timestamp)) {
+    state.entries.delete(key);
+    return void 0;
+  }
+  return entry;
+}
+function pruneExpiredEntries(state, timestamp) {
+  for (const [key, entry] of state.entries.entries()) {
+    if (isExpired(entry, timestamp)) {
+      state.entries.delete(key);
+    }
+  }
+}
+function setEntry(state, input) {
+  state.entries.set(input.key, {
+    payload: input.payload,
+    expiresAt: input.expiresAt
+  });
+}
+function enforceMaxEntries(state, maxEntries, timestamp) {
+  if (typeof maxEntries === "undefined") {
+    return;
+  }
+  pruneExpiredEntries(state, timestamp);
+  while (state.entries.size > maxEntries) {
+    const oldestKey = state.entries.keys().next().value;
+    if (typeof oldestKey === "undefined") {
+      break;
+    }
+    state.entries.delete(oldestKey);
+  }
+}
+function createMemoryCacheDriver(options) {
+  const state = createMemoryCacheDriverState();
+  const now = options.now ?? Date.now;
+  const sleep = options.sleep ?? defaultSleep2;
+  return {
+    name: options.name,
+    driver: "memory",
+    async get(key) {
+      const entry = pruneExpiredEntry(state, key, now());
+      if (!entry) return Object.freeze({ hit: false });
+      return Object.freeze({
+        hit: true,
+        payload: entry.payload,
+        expiresAt: entry.expiresAt
+      });
+    },
+    async put(input) {
+      setEntry(state, input);
+      enforceMaxEntries(state, options.maxEntries, now());
+      return true;
+    },
+    async add(input) {
+      const timestamp = now();
+      if (pruneExpiredEntry(state, input.key, timestamp)) return false;
+      setEntry(state, input);
+      enforceMaxEntries(state, options.maxEntries, timestamp);
+      return true;
+    },
+    async forget(key) {
+      const existed = typeof pruneExpiredEntry(state, key, now()) !== "undefined";
+      state.entries.delete(key);
+      return existed;
+    },
+    async flush() {
+      state.entries.clear();
+      state.locks.clear();
+    },
+    async increment(key, amount) {
+      const entry = pruneExpiredEntry(state, key, now());
+      const currentValue = entry ? deserializeCacheValue(entry.payload) : 0;
+      if (typeof currentValue !== "number" || !Number.isFinite(currentValue)) {
+        throw new CacheInvalidNumericMutationError(`[@holo-js/cache] Cache key "${key}" does not contain a numeric value.`);
+      }
+      const nextValue = currentValue + amount;
+      setEntry(state, {
+        key,
+        payload: serializeCacheValue(nextValue),
+        expiresAt: entry?.expiresAt
+      });
+      enforceMaxEntries(state, options.maxEntries, now());
+      return nextValue;
+    },
+    async decrement(key, amount) {
+      return this.increment(key, -amount);
+    },
+    lock(name, seconds) {
+      return createMemoryLock(state, name, seconds, now, sleep);
+    }
+  };
+}
+
+// src/redis.ts
+import {
+  normalizeRedisConfig
+} from "@holo-js/config";
+function isNormalizedRedisConfig(config) {
+  return typeof config.default === "string" && typeof config.connections === "object" && config.connections !== null && Object.values(config.connections).every((connection) => {
+    return typeof connection === "object" && connection !== null && "name" in connection && "host" in connection && "port" in connection && typeof connection.name === "string" && typeof connection.host === "string" && typeof connection.port === "number";
+  });
+}
+function normalizeRuntimeRedisConfig(config) {
+  if (!config) return void 0;
+  return isNormalizedRedisConfig(config) ? config : normalizeRedisConfig(config);
+}
+function resolveSharedRedisConnection(redisConfig, connectionName) {
+  if (!redisConfig) {
+    throw new CacheDriverResolutionError(
+      `[@holo-js/cache] Redis cache driver "${connectionName}" requires a top-level redis config from config/redis.ts.`
+    );
+  }
+  const connection = redisConfig.connections[connectionName];
+  if (connection) return connection;
+  const availableConnections = Object.keys(redisConfig.connections);
+  throw new CacheDriverResolutionError(
+    `[@holo-js/cache] Redis cache connection "${connectionName}" was not found in config/redis.ts. Available connections: ${availableConnections.join(", ") || "(none)"}.`
+  );
+}
+function isModuleNotFoundError2(error) {
+  return !!error && typeof error === "object" && "code" in error && error.code === "ERR_MODULE_NOT_FOUND";
+}
+function normalizeRedisModuleLoadError(error) {
+  if (isModuleNotFoundError2(error)) {
+    return new CacheOptionalPackageError(
+      "[@holo-js/cache] Redis cache support requires @holo-js/cache-redis to be installed.",
+      { cause: error }
+    );
+  }
+  return error;
+}
+async function loadRedisDriverModule() {
+  try {
+    const specifier = "@holo-js/cache-redis";
+    return await import(specifier);
+  } catch (error) {
+    throw normalizeRedisModuleLoadError(error);
+  }
+}
+var redisDriverModuleLoader = loadRedisDriverModule;
+function setRedisDriverModuleLoader(loader) {
+  redisDriverModuleLoader = loader;
+}
+function resetRedisDriverModuleLoader() {
+  redisDriverModuleLoader = loadRedisDriverModule;
+}
+var LazyRedisCacheDriver = class {
+  constructor(options) {
+    this.options = options;
+  }
+  driver = "redis";
+  driverInstance;
+  pending;
+  get name() {
+    return this.options.name;
+  }
+  async resolveDriver() {
+    if (this.driverInstance) return this.driverInstance;
+    this.pending ??= redisDriverModuleLoader().then((module) => {
+      const driver = module.createRedisCacheDriver(this.options);
+      this.driverInstance = driver;
+      return driver;
+    }).finally(() => {
+      this.pending = void 0;
+    });
+    return this.pending;
+  }
+  async withDriver(callback) {
+    return callback(await this.resolveDriver());
+  }
+  createLockProxy(name, seconds) {
+    let lockPromise;
+    const resolveLock = async () => {
+      lockPromise ??= this.withDriver((driver) => driver.lock(name, seconds));
+      return lockPromise;
+    };
+    return {
+      name,
+      async get(callback) {
+        return (await resolveLock()).get(callback);
+      },
+      async release() {
+        return (await resolveLock()).release();
+      },
+      async block(waitSeconds, callback) {
+        return (await resolveLock()).block(waitSeconds, callback);
+      }
+    };
+  }
+  async get(key) {
+    return this.withDriver((driver) => driver.get(key));
+  }
+  async put(input) {
+    return this.withDriver((driver) => driver.put(input));
+  }
+  async add(input) {
+    return this.withDriver((driver) => driver.add(input));
+  }
+  async forget(key) {
+    return this.withDriver((driver) => driver.forget(key));
+  }
+  async flush() {
+    await this.withDriver((driver) => driver.flush());
+  }
+  async increment(key, amount) {
+    return this.withDriver((driver) => driver.increment(key, amount));
+  }
+  async decrement(key, amount) {
+    return this.withDriver((driver) => driver.decrement(key, amount));
+  }
+  lock(name, seconds) {
+    return this.createLockProxy(name, seconds);
+  }
+};
+function createRedisCacheDriver(options) {
+  return new LazyRedisCacheDriver(options);
+}
+var cacheRedisInternals = {
+  isModuleNotFoundError: isModuleNotFoundError2,
+  isNormalizedRedisConfig,
+  loadRedisDriverModule,
+  normalizeRedisModuleLoadError,
+  normalizeRuntimeRedisConfig,
+  resolveSharedRedisConnection,
+  resetRedisDriverModuleLoader,
+  setRedisDriverModuleLoader
+};
+
+// src/runtime-shared.ts
+function isNormalizedCacheConfig(config) {
+  return typeof config.default === "string" && typeof config.prefix === "string" && typeof config.drivers === "object" && config.drivers !== null && Object.values(config.drivers).every((driver) => {
+    return typeof driver === "object" && driver !== null && "name" in driver && "prefix" in driver && typeof driver.name === "string" && typeof driver.prefix === "string";
+  });
+}
+function normalizeRuntimeConfig(config) {
+  if (!config) return holoCacheDefaults;
+  return isNormalizedCacheConfig(config) ? config : normalizeCacheConfig(config);
+}
+function getCacheRuntimeState() {
+  const runtime = globalThis;
+  runtime.__holoCacheRuntime__ ??= {};
+  return runtime.__holoCacheRuntime__;
+}
+function getCacheRuntimeBindings() {
+  return getCacheRuntimeState().bindings;
+}
+function getCacheRuntime() {
+  const bindings = getCacheRuntimeBindings();
+  if (!bindings) {
+    throw new CacheRuntimeNotConfiguredError();
+  }
+  return bindings;
+}
+function createDriverMap(drivers) {
+  return drivers ? new Map(drivers.entries()) : /* @__PURE__ */ new Map();
+}
+function cacheResolvedDriver(facade, driverName, driver) {
+  facade.drivers.set(driverName, driver);
+  return driver;
+}
+function resolveConfiguredDriver(facade, requestedName) {
+  const driverName = requestedName?.trim() || facade.config.default;
+  const cachedDriver = facade.drivers.get(driverName);
+  if (cachedDriver) {
+    return cachedDriver;
+  }
+  const driverConfig = facade.config.drivers[driverName];
+  if (!driverConfig) {
+    throw new CacheDriverResolutionError(`[@holo-js/cache] Cache driver "${driverName}" is not configured.`);
+  }
+  switch (driverConfig.driver) {
+    case "file": {
+      return cacheResolvedDriver(facade, driverName, createFileCacheDriver({
+        name: driverConfig.name,
+        path: driverConfig.path,
+        prefix: driverConfig.prefix
+      }));
+    }
+    case "memory": {
+      return cacheResolvedDriver(facade, driverName, createMemoryCacheDriver({
+        name: driverConfig.name,
+        maxEntries: driverConfig.maxEntries
+      }));
+    }
+    case "redis": {
+      const connection = cacheRedisInternals.resolveSharedRedisConnection(
+        facade.redisConfig,
+        driverConfig.connection
+      );
+      return cacheResolvedDriver(facade, driverName, createRedisCacheDriver({
+        name: driverConfig.name,
+        connectionName: connection.name,
+        prefix: driverConfig.prefix,
+        redis: connection
+      }));
+    }
+    case "database": {
+      const connection = cacheDbInternals.resolveSharedDatabaseConnection(
+        facade.databaseConfig,
+        driverConfig.connection
+      );
+      return cacheResolvedDriver(facade, driverName, createDatabaseCacheDriver({
+        name: driverConfig.name,
+        connectionName: driverConfig.connection,
+        table: driverConfig.table,
+        lockTable: driverConfig.lockTable,
+        prefix: driverConfig.prefix,
+        connection
+      }));
+    }
+    default:
+      throw new CacheDriverResolutionError(
+        `[@holo-js/cache] Cache driver "${driverName}" uses unsupported driver "${String(driverConfig.driver)}" in this phase.`
+      );
+  }
+}
+
+// src/query-bridge.ts
+function createDependencyIndexState() {
+  return {
+    keyToDependencies: /* @__PURE__ */ new Map(),
+    dependencyToKeys: /* @__PURE__ */ new Map()
+  };
+}
+function createMemoryDependencyIndex(state = createDependencyIndexState()) {
+  return Object.freeze({
+    async register(key, dependencies) {
+      await this.removeKey(key);
+      if (dependencies.length === 0) {
+        return;
+      }
+      const uniqueDependencies = new Set(dependencies);
+      state.keyToDependencies.set(key, uniqueDependencies);
+      for (const dependency of uniqueDependencies) {
+        const keys = state.dependencyToKeys.get(dependency) ?? /* @__PURE__ */ new Set();
+        keys.add(key);
+        state.dependencyToKeys.set(dependency, keys);
+      }
+    },
+    async listKeys(dependency) {
+      return Object.freeze([...state.dependencyToKeys.get(dependency) ?? /* @__PURE__ */ new Set()]);
+    },
+    async listRegisteredKeys() {
+      return Object.freeze([...state.keyToDependencies.keys()]);
+    },
+    async removeKey(key) {
+      const dependencies = state.keyToDependencies.get(key);
+      if (!dependencies) {
+        return;
+      }
+      state.keyToDependencies.delete(key);
+      for (const dependency of dependencies) {
+        const keys = state.dependencyToKeys.get(dependency);
+        if (!keys) {
+          continue;
+        }
+        keys.delete(key);
+        if (keys.size === 0) {
+          state.dependencyToKeys.delete(dependency);
+        }
+      }
+    },
+    async clear() {
+      state.keyToDependencies.clear();
+      state.dependencyToKeys.clear();
+    }
+  });
+}
+function getQueryBridgeState() {
+  const runtime = globalThis;
+  runtime.__holoCacheQueryBridge__ ??= {};
+  return runtime.__holoCacheQueryBridge__;
+}
+function getOrCreateDependencyIndex() {
+  const state = getQueryBridgeState();
+  state.dependencyIndex ??= createMemoryDependencyIndex();
+  return state.dependencyIndex;
+}
+function resetDefaultDependencyIndex() {
+  getQueryBridgeState().dependencyIndex = void 0;
+}
+function resolveDriverContext(driverName) {
+  const runtime = getCacheRuntime();
+  const configuredDriverName = driverName?.trim() || runtime.config.default;
+  const driverConfig = runtime.config.drivers[configuredDriverName];
+  let normalizedKeyPrefix = runtime.config.prefix;
+  if (typeof driverConfig?.prefix === "string") {
+    normalizedKeyPrefix = driverConfig.prefix;
+  }
+  return Object.freeze({
+    driverName: configuredDriverName,
+    driver: resolveConfiguredDriver(runtime, configuredDriverName),
+    normalizedKeyPrefix
+  });
+}
+function resolveNormalizedKey(key, driverName) {
+  const context = resolveDriverContext(driverName);
+  return `${context.normalizedKeyPrefix}${resolveCacheKey(key)}`;
+}
+function normalizeFlexibleTtl(ttl) {
+  const freshSeconds = "fresh" in ttl ? ttl.fresh : ttl[0];
+  const staleSeconds = "stale" in ttl ? ttl.stale : ttl[1];
+  if (!Number.isInteger(freshSeconds) || freshSeconds < 0) {
+    throw new CacheInvalidTtlError("[@holo-js/cache] Flexible fresh TTL must be an integer greater than or equal to 0.");
+  }
+  if (!Number.isInteger(staleSeconds) || staleSeconds < freshSeconds) {
+    throw new CacheInvalidTtlError("[@holo-js/cache] Flexible stale TTL must be an integer greater than or equal to the fresh TTL.");
+  }
+  return Object.freeze({
+    freshSeconds,
+    staleSeconds
+  });
+}
+function isFlexibleEnvelope(value) {
+  if (!value || typeof value !== "object" || Array.isArray(value)) {
+    return false;
+  }
+  const envelope = value;
+  return envelope.__holo_cache_flexible === true && typeof envelope.freshUntil === "number" && Number.isFinite(envelope.freshUntil) && typeof envelope.staleUntil === "number" && Number.isFinite(envelope.staleUntil) && "value" in envelope;
+}
+async function getCachedValue(key, driverName) {
+  const context = resolveDriverContext(driverName);
+  const entry = await context.driver.get(resolveNormalizedKey(key, driverName));
+  if (!entry.hit || typeof entry.payload !== "string") {
+    return null;
+  }
+  return deserializeCacheValue(entry.payload);
+}
+async function putCachedValue(key, value, ttl, driverName) {
+  const context = resolveDriverContext(driverName);
+  const expiresAt = typeof ttl === "undefined" ? void 0 : normalizeCacheTtl(ttl).expiresAt;
+  await context.driver.put({
+    key: resolveNormalizedKey(key, driverName),
+    payload: serializeCacheValue(value),
+    expiresAt
+  });
+}
+function createFlexibleLock(key, ttl, driverName) {
+  const context = resolveDriverContext(driverName);
+  return context.driver.lock(
+    `${context.normalizedKeyPrefix}__flexible__:${resolveCacheKey(key)}`,
+    Math.max(1, ttl.staleSeconds)
+  );
+}
+function createIndexedKey(key, driverName) {
+  const context = resolveDriverContext(driverName);
+  return `${context.driverName}\0${resolveNormalizedKey(key, driverName)}`;
+}
+function parseIndexedKey(indexedKey) {
+  const delimiterIndex = indexedKey.indexOf("\0");
+  if (delimiterIndex === -1) {
+    return Object.freeze({
+      driverName: getCacheRuntime().config.default,
+      normalizedKey: indexedKey
+    });
+  }
+  return Object.freeze({
+    driverName: indexedKey.slice(0, delimiterIndex),
+    normalizedKey: indexedKey.slice(delimiterIndex + 1)
+  });
+}
+function setGlobalDatabaseQueryCacheBridge(bridge) {
+  const runtime = globalThis;
+  runtime.__holoDbQueryCacheBridge__ ??= {};
+  runtime.__holoDbQueryCacheBridge__.bridge = bridge;
+}
+function createCacheQueryBridge(dependencyIndex = getOrCreateDependencyIndex()) {
+  async function syncDependencies(indexedKey, dependencies) {
+    if (dependencies && dependencies.length > 0) {
+      await dependencyIndex.register(indexedKey, dependencies);
+      return;
+    }
+    await dependencyIndex.removeKey(indexedKey);
+  }
+  return Object.freeze({
+    async get(key, options) {
+      return getCachedValue(key, options?.driver);
+    },
+    async put(key, value, options) {
+      const indexedKey = createIndexedKey(key, options.driver);
+      const resolvedTtl = typeof options.flexible === "undefined" ? options.ttl : normalizeFlexibleTtl(options.flexible).staleSeconds;
+      await putCachedValue(key, value, resolvedTtl, options.driver);
+      await syncDependencies(indexedKey, options.dependencies);
+    },
+    async flexible(key, ttl, callback, options = {}) {
+      const indexedKey = createIndexedKey(key, options.driver);
+      const normalizedTtl = normalizeFlexibleTtl(ttl);
+      const now = Date.now();
+      const cached = await getCachedValue(key, options.driver);
+      const refreshValue = async () => {
+        const value = await callback();
+        const refreshedAt = Date.now();
+        const envelope = {
+          __holo_cache_flexible: true,
+          value,
+          freshUntil: refreshedAt + normalizedTtl.freshSeconds * 1e3,
+          staleUntil: refreshedAt + normalizedTtl.staleSeconds * 1e3
+        };
+        await putCachedValue(
+          key,
+          envelope,
+          normalizedTtl.staleSeconds,
+          options.driver
+        );
+        await syncDependencies(indexedKey, options.dependencies);
+        return value;
+      };
+      if (isFlexibleEnvelope(cached)) {
+        if (now <= cached.freshUntil) {
+          return cached.value;
+        }
+        if (now <= cached.staleUntil) {
+          const refreshLock2 = createFlexibleLock(key, normalizedTtl, options.driver);
+          void refreshLock2.get(async () => {
+            await refreshValue();
+            return true;
+          }).catch(() => void 0);
+          return cached.value;
+        }
+      }
+      const refreshLock = createFlexibleLock(key, normalizedTtl, options.driver);
+      const refreshed = await refreshLock.block(1, async () => refreshValue());
+      if (refreshed !== false) {
+        return refreshed;
+      }
+      const retried = await getCachedValue(key, options.driver);
+      if (isFlexibleEnvelope(retried)) {
+        if (Date.now() <= retried.staleUntil) {
+          return retried.value;
+        }
+      }
+      return refreshValue();
+    },
+    async forget(key, options) {
+      const indexedKey = createIndexedKey(key, options?.driver);
+      const context = resolveDriverContext(options?.driver);
+      await dependencyIndex.removeKey(indexedKey);
+      return context.driver.forget(resolveNormalizedKey(key, options?.driver));
+    },
+    async invalidateDependencies(dependencies) {
+      const invalidatedKeys = /* @__PURE__ */ new Set();
+      const runtime = getCacheRuntime();
+      for (const dependency of dependencies) {
+        const indexedKeys = await dependencyIndex.listKeys(dependency);
+        for (const indexedKey of indexedKeys) {
+          if (invalidatedKeys.has(indexedKey)) {
+            continue;
+          }
+          invalidatedKeys.add(indexedKey);
+          const parsed = parseIndexedKey(indexedKey);
+          const driver = resolveConfiguredDriver(runtime, parsed.driverName);
+          await driver.forget(parsed.normalizedKey);
+          await dependencyIndex.removeKey(indexedKey);
+        }
+      }
+    }
+  });
+}
+var cacheQueryBridgeInternals = {
+  createCacheQueryBridge,
+  createIndexedKey,
+  createMemoryDependencyIndex,
+  getOrCreateDependencyIndex,
+  parseIndexedKey,
+  resetDefaultDependencyIndex,
+  setGlobalDatabaseQueryCacheBridge
+};
+
+// src/runtime.ts
+function configureCacheRuntime(bindings) {
+  if (!bindings) {
+    getCacheRuntimeState().bindings = void 0;
+    resetDefaultDependencyIndex();
+    setGlobalDatabaseQueryCacheBridge(void 0);
+    return;
+  }
+  const dependencyIndex = bindings.dependencyIndex ?? getOrCreateDependencyIndex();
+  const queryBridge = bindings.queryBridge ?? createCacheQueryBridge(dependencyIndex);
+  getCacheRuntimeState().bindings = Object.freeze({
+    config: normalizeRuntimeConfig(bindings.config),
+    databaseConfig: cacheDbInternals.normalizeRuntimeDatabaseConfig(bindings.databaseConfig),
+    redisConfig: cacheRedisInternals.normalizeRuntimeRedisConfig(bindings.redisConfig),
+    drivers: createDriverMap(bindings.drivers),
+    dependencyIndex,
+    queryBridge
+  });
+  setGlobalDatabaseQueryCacheBridge(queryBridge);
+}
+function resetCacheRuntime() {
+  getCacheRuntimeState().bindings = void 0;
+  resetDefaultDependencyIndex();
+  setGlobalDatabaseQueryCacheBridge(void 0);
+}
+var cacheRuntimeInternals = {
+  getCacheRuntimeState,
+  isNormalizedCacheConfig,
+  normalizeRuntimeConfig,
+  resolveConfiguredDriver
+};
+
+// src/facade.ts
+var MAX_REFRESH_BLOCK_SECONDS = 30;
+function resolveFallback(fallback) {
+  return typeof fallback === "function" ? fallback() : fallback;
+}
+function resolveValue(callback) {
+  return Promise.resolve(callback());
+}
+function resolveDriverKey(driverName) {
+  const normalized = driverName?.trim();
+  return normalized || "__default__";
+}
+function normalizeFlexibleTtl2(ttl) {
+  const freshSeconds = "fresh" in ttl ? ttl.fresh : ttl[0];
+  const staleSeconds = "stale" in ttl ? ttl.stale : ttl[1];
+  if (!Number.isInteger(freshSeconds) || freshSeconds < 0) {
+    throw new CacheInvalidTtlError("[@holo-js/cache] Flexible fresh TTL must be an integer greater than or equal to 0.");
+  }
+  if (!Number.isInteger(staleSeconds) || staleSeconds < freshSeconds) {
+    throw new CacheInvalidTtlError("[@holo-js/cache] Flexible stale TTL must be an integer greater than or equal to the fresh TTL.");
+  }
+  return Object.freeze({
+    freshSeconds,
+    staleSeconds
+  });
+}
+function isFlexibleEnvelope2(value) {
+  if (!value || typeof value !== "object" || Array.isArray(value)) {
+    return false;
+  }
+  const envelope = value;
+  return envelope.__holo_cache_flexible === true && typeof envelope.freshUntil === "number" && Number.isFinite(envelope.freshUntil) && typeof envelope.staleUntil === "number" && Number.isFinite(envelope.staleUntil) && "value" in envelope;
+}
+function createCacheRepository(driverName) {
+  function resolveDriverContext2() {
+    const runtime = getCacheRuntime();
+    const configuredDriverName = driverName?.trim() || runtime.config.default;
+    const driver = cacheRuntimeInternals.resolveConfiguredDriver(runtime, configuredDriverName);
+    const config = runtime.config.drivers[configuredDriverName];
+    return {
+      configuredDriverName,
+      driver,
+      prefix: config?.prefix ?? runtime.config.prefix
+    };
+  }
+  function resolveNormalizedKey2(key) {
+    const { prefix } = resolveDriverContext2();
+    return `${prefix}${resolveCacheKey(key)}`;
+  }
+  function resolveNormalizedLockName(name) {
+    const { prefix } = resolveDriverContext2();
+    return `${prefix}${resolveCacheKey(name)}`;
+  }
+  async function getEntryPayload(key) {
+    const { driver } = resolveDriverContext2();
+    const entry = await driver.get(resolveNormalizedKey2(key));
+    return entry.hit ? entry.payload : void 0;
+  }
+  async function putSerializedValue(key, payload, ttl) {
+    const { driver } = resolveDriverContext2();
+    const normalizedTtl = normalizeCacheTtl(ttl);
+    return driver.put({
+      key: resolveNormalizedKey2(key),
+      payload,
+      expiresAt: normalizedTtl.expiresAt
+    });
+  }
+  async function getCachedValue2(key) {
+    const payload = await getEntryPayload(key);
+    return typeof payload === "string" ? deserializeCacheValue(payload) : null;
+  }
+  async function putFlexibleEnvelope(key, ttl, value) {
+    const now = Date.now();
+    const envelope = {
+      __holo_cache_flexible: true,
+      value,
+      freshUntil: now + ttl.freshSeconds * 1e3,
+      staleUntil: now + ttl.staleSeconds * 1e3
+    };
+    await putSerializedValue(key, serializeCacheValue(envelope), ttl.staleSeconds);
+    return value;
+  }
+  async function refreshFlexibleValue(key, ttl, callback) {
+    const value = await resolveValue(callback);
+    return putFlexibleEnvelope(key, ttl, value);
+  }
+  function createRefreshLock(key, staleSeconds) {
+    return repository.lock(`__flexible__:${resolveCacheKey(key)}`, Math.max(1, staleSeconds));
+  }
+  const repository = Object.freeze({
+    async get(key, fallback) {
+      const payload = await getEntryPayload(key);
+      if (typeof payload === "string") {
+        return deserializeCacheValue(payload);
+      }
+      if (typeof fallback === "undefined") {
+        return null;
+      }
+      return await resolveFallback(fallback);
+    },
+    async put(key, value, ttl) {
+      return putSerializedValue(key, serializeCacheValue(value), ttl);
+    },
+    async add(key, value, ttl) {
+      const { driver } = resolveDriverContext2();
+      const normalizedTtl = normalizeCacheTtl(ttl);
+      return driver.add({
+        key: resolveNormalizedKey2(key),
+        payload: serializeCacheValue(value),
+        expiresAt: normalizedTtl.expiresAt
+      });
+    },
+    async forever(key, value) {
+      const { driver } = resolveDriverContext2();
+      return driver.put({
+        key: resolveNormalizedKey2(key),
+        payload: serializeCacheValue(value)
+      });
+    },
+    async has(key) {
+      return typeof await getEntryPayload(key) === "string";
+    },
+    async missing(key) {
+      return !await this.has(key);
+    },
+    async forget(key) {
+      const runtime = getCacheRuntime();
+      const { configuredDriverName, driver } = resolveDriverContext2();
+      const forgotten = await driver.forget(resolveNormalizedKey2(key));
+      const dependencyIndex = runtime.dependencyIndex;
+      if (!dependencyIndex) {
+        return forgotten;
+      }
+      await dependencyIndex.removeKey(cacheQueryBridgeInternals.createIndexedKey(key, configuredDriverName));
+      return forgotten;
+    },
+    async flush() {
+      const runtime = getCacheRuntime();
+      const { configuredDriverName, driver } = resolveDriverContext2();
+      await driver.flush();
+      const dependencyIndex = runtime.dependencyIndex;
+      if (!dependencyIndex) {
+        return;
+      }
+      const registeredKeys = await dependencyIndex.listRegisteredKeys();
+      for (const indexedKey of registeredKeys) {
+        if (cacheQueryBridgeInternals.parseIndexedKey(indexedKey).driverName === configuredDriverName) {
+          await dependencyIndex.removeKey(indexedKey);
+        }
+      }
+    },
+    async increment(key, amount = 1) {
+      const { driver } = resolveDriverContext2();
+      return driver.increment(resolveNormalizedKey2(key), amount);
+    },
+    async decrement(key, amount = 1) {
+      const { driver } = resolveDriverContext2();
+      return driver.decrement(resolveNormalizedKey2(key), amount);
+    },
+    async remember(key, ttl, callback) {
+      const cached = await getCachedValue2(key);
+      if (cached !== null) {
+        return cached;
+      }
+      const value = await resolveValue(callback);
+      await repository.put(key, value, ttl);
+      return value;
+    },
+    async rememberForever(key, callback) {
+      const cached = await getCachedValue2(key);
+      if (cached !== null) {
+        return cached;
+      }
+      const value = await resolveValue(callback);
+      await repository.forever(key, value);
+      return value;
+    },
+    async flexible(key, ttl, callback) {
+      const normalizedTtl = normalizeFlexibleTtl2(ttl);
+      const now = Date.now();
+      const cached = await getCachedValue2(key);
+      if (isFlexibleEnvelope2(cached)) {
+        if (now <= cached.freshUntil) {
+          return cached.value;
+        }
+        if (now <= cached.staleUntil) {
+          const refreshLock2 = createRefreshLock(key, normalizedTtl.staleSeconds);
+          void refreshLock2.get(async () => {
+            await refreshFlexibleValue(key, normalizedTtl, callback);
+            return true;
+          }).catch(() => void 0);
+          return cached.value;
+        }
+      }
+      const refreshLock = createRefreshLock(key, normalizedTtl.staleSeconds);
+      const refreshed = await refreshLock.block(
+        Math.min(
+          MAX_REFRESH_BLOCK_SECONDS,
+          Math.max(1, Math.ceil(normalizedTtl.staleSeconds / 300))
+        ),
+        async () => refreshFlexibleValue(key, normalizedTtl, callback)
+      );
+      if (refreshed !== false) {
+        return refreshed;
+      }
+      const retried = await getCachedValue2(key);
+      if (isFlexibleEnvelope2(retried)) {
+        if (Date.now() <= retried.staleUntil) {
+          return retried.value;
+        }
+      }
+      return refreshFlexibleValue(key, normalizedTtl, callback);
+    },
+    lock(name, seconds) {
+      const { driver } = resolveDriverContext2();
+      return driver.lock(resolveNormalizedLockName(name), seconds);
+    }
+  });
+  return repository;
+}
+var repositories = /* @__PURE__ */ new Map();
+function getOrCreateRepository(driverName) {
+  const key = resolveDriverKey(driverName);
+  const existing = repositories.get(key);
+  if (existing) {
+    return existing;
+  }
+  const repository = createCacheRepository(driverName);
+  repositories.set(key, repository);
+  return repository;
+}
+function resetCacheFacadeRepositories() {
+  repositories.clear();
+}
+var defaultRepository = getOrCreateRepository();
+var cacheFacade = Object.freeze({
+  ...defaultRepository,
+  driver(name) {
+    return getOrCreateRepository(name);
+  }
+});
+var cacheFacadeInternals = {
+  createRefreshLockName(key) {
+    return `__flexible__:${resolveCacheKey(key)}`;
+  },
+  getOrCreateRepository,
+  isFlexibleEnvelope: isFlexibleEnvelope2,
+  normalizeFlexibleTtl: normalizeFlexibleTtl2,
+  resolveDriverKey,
+  resolveFallback,
+  resolveValue
+};
+
+// src/index.ts
+function configureCacheRuntime2(...parameters) {
+  configureCacheRuntime(...parameters);
+}
+function resetCacheRuntime2() {
+  resetCacheRuntime();
+  resetCacheFacadeRepositories();
+}
+var cache = Object.freeze({
+  defineCacheKey,
+  normalizeCacheTtl,
+  serializeCacheValue,
+  deserializeCacheValue,
+  configureCacheRuntime: configureCacheRuntime2,
+  getCacheRuntime,
+  getCacheRuntimeBindings,
+  resetCacheRuntime: resetCacheRuntime2,
+  ...cacheFacade
+});
+var src_default = cache;
+export {
+  CacheConfigError,
+  CacheDriverResolutionError,
+  CacheError,
+  CacheInvalidNumericMutationError,
+  CacheInvalidTtlError,
+  CacheLockAcquisitionError,
+  CacheOptionalPackageError,
+  CacheQueryIntegrationError,
+  CacheRuntimeNotConfiguredError,
+  CacheSerializationError,
+  cacheContractsInternals,
+  cacheDbInternals,
+  cacheFacade,
+  cacheFacadeInternals,
+  cacheQueryBridgeInternals,
+  cacheRedisInternals,
+  cacheRuntimeInternals,
+  configureCacheRuntime2 as configureCacheRuntime,
+  src_default as default,
+  defineCacheConfig,
+  defineCacheKey,
+  deserializeCacheValue,
+  fileDriverInternals,
+  getCacheRuntime,
+  getCacheRuntimeBindings,
+  isCacheKey,
+  normalizeCacheTtl,
+  resetCacheRuntime2 as resetCacheRuntime,
+  resolveCacheKey,
+  serializeCacheValue
+};