@holo-js/cache 0.2.6 → 0.3.0

package/dist/chunk-7FH4KYTX.mjs

@@ -0,0 +1,152 @@
+// src/config.ts
+import { registerConfigNormalizer } from "@holo-js/config/registry";
+var DEFAULT_CACHE_DRIVER = "file";
+var DEFAULT_CACHE_PREFIX = "";
+var DEFAULT_CACHE_FILE_PATH = "./storage/framework/cache/data";
+var DEFAULT_CACHE_REDIS_CONNECTION = "default";
+var DEFAULT_CACHE_DATABASE_CONNECTION = "default";
+var DEFAULT_CACHE_DATABASE_TABLE = "cache";
+var DEFAULT_CACHE_DATABASE_LOCK_TABLE = "cache_locks";
+var holoCacheDefaults = Object.freeze({
+  default: DEFAULT_CACHE_DRIVER,
+  prefix: DEFAULT_CACHE_PREFIX,
+  drivers: Object.freeze({
+    file: Object.freeze({
+      name: "file",
+      driver: "file",
+      path: DEFAULT_CACHE_FILE_PATH,
+      prefix: DEFAULT_CACHE_PREFIX
+    }),
+    memory: Object.freeze({
+      name: "memory",
+      driver: "memory",
+      maxEntries: void 0,
+      prefix: DEFAULT_CACHE_PREFIX
+    })
+  })
+});
+function normalizeOptionalString(value) {
+  const normalized = value?.trim();
+  return normalized || void 0;
+}
+function normalizeName(value, label) {
+  const normalized = value?.trim();
+  if (!normalized) {
+    throw new Error(`[Holo Cache] ${label} must be a non-empty string.`);
+  }
+  return normalized;
+}
+function parseOptionalInteger(value, label) {
+  if (typeof value === "undefined") return void 0;
+  const normalized = typeof value === "number" ? value : value.trim() ? Number(value.trim()) : Number.NaN;
+  if (!Number.isFinite(normalized) || !Number.isInteger(normalized)) {
+    throw new Error(`[Holo Cache] ${label} must be an integer.`);
+  }
+  if (normalized < 1) {
+    throw new Error(`[Holo Cache] ${label} must be greater than or equal to 1.`);
+  }
+  return normalized;
+}
+function resolvePrefix(globalPrefix, localPrefix) {
+  return normalizeOptionalString(localPrefix) ?? globalPrefix;
+}
+function normalizeDriverConfig(name, config, globalPrefix, defaultRedisConnection, defaultDatabaseConnection) {
+  switch (config.driver) {
+    case "memory": {
+      const memoryConfig = config;
+      return Object.freeze({
+        name,
+        driver: "memory",
+        prefix: resolvePrefix(globalPrefix, memoryConfig.prefix),
+        maxEntries: parseOptionalInteger(memoryConfig.maxEntries, `cache driver "${name}" maxEntries`)
+      });
+    }
+    case "file": {
+      const fileConfig = config;
+      return Object.freeze({
+        name,
+        driver: "file",
+        path: normalizeOptionalString(fileConfig.path) || DEFAULT_CACHE_FILE_PATH,
+        prefix: resolvePrefix(globalPrefix, fileConfig.prefix)
+      });
+    }
+    case "redis": {
+      const redisConfig = config;
+      return Object.freeze({
+        name,
+        driver: "redis",
+        connection: normalizeOptionalString(redisConfig.connection) ?? defaultRedisConnection,
+        prefix: resolvePrefix(globalPrefix, redisConfig.prefix)
+      });
+    }
+    case "database": {
+      const databaseConfig = config;
+      return Object.freeze({
+        name,
+        driver: "database",
+        connection: normalizeOptionalString(databaseConfig.connection) ?? defaultDatabaseConnection,
+        table: normalizeOptionalString(databaseConfig.table) || DEFAULT_CACHE_DATABASE_TABLE,
+        lockTable: normalizeOptionalString(databaseConfig.lockTable) || DEFAULT_CACHE_DATABASE_LOCK_TABLE,
+        prefix: resolvePrefix(globalPrefix, databaseConfig.prefix)
+      });
+    }
+    default: {
+      const { driver, prefix, ...options } = config;
+      return Object.freeze({
+        ...options,
+        name,
+        driver: normalizeName(driver, `Cache driver "${name}" driver`),
+        prefix: resolvePrefix(globalPrefix, prefix)
+      });
+    }
+  }
+}
+function normalizeCacheConfig(config = {}, options = {}) {
+  const prefix = normalizeOptionalString(config.prefix) ?? DEFAULT_CACHE_PREFIX;
+  const defaultRedisConnection = options.redis?.default ?? DEFAULT_CACHE_REDIS_CONNECTION;
+  const defaultDatabaseConnection = options.database?.defaultConnection ?? DEFAULT_CACHE_DATABASE_CONNECTION;
+  const driverEntries = !config.drivers || Object.keys(config.drivers).length === 0 ? Object.entries(holoCacheDefaults.drivers) : Object.entries(config.drivers);
+  const normalizedDriverEntries = driverEntries.map(([name, driver]) => {
+    const normalizedName = normalizeName(name, "Cache driver name");
+    return [normalizedName, normalizeDriverConfig(
+      normalizedName,
+      driver,
+      prefix,
+      defaultRedisConnection,
+      defaultDatabaseConnection
+    )];
+  });
+  const drivers = Object.freeze(Object.fromEntries(normalizedDriverEntries));
+  const configuredDefault = normalizeOptionalString(config.default);
+  if (configuredDefault && !Object.hasOwn(drivers, configuredDefault)) {
+    throw new Error(`[Holo Cache] default cache driver "${configuredDefault}" is not configured.`);
+  }
+  const defaultDriver = configuredDefault ?? normalizedDriverEntries.find(([name]) => name === DEFAULT_CACHE_DRIVER)?.[0] ?? normalizedDriverEntries[0][0];
+  return Object.freeze({ default: defaultDriver, prefix, drivers });
+}
+function defineCacheConfig(config) {
+  return Object.freeze({ ...config });
+}
+registerConfigNormalizer({
+  name: "cache",
+  dependencies: ["database", "redis"],
+  normalize(config, context) {
+    return normalizeCacheConfig(config, {
+      database: context.get("database"),
+      redis: context.has("redis") ? context.get("redis") : void 0
+    });
+  }
+});
+
+export {
+  DEFAULT_CACHE_DRIVER,
+  DEFAULT_CACHE_PREFIX,
+  DEFAULT_CACHE_FILE_PATH,
+  DEFAULT_CACHE_REDIS_CONNECTION,
+  DEFAULT_CACHE_DATABASE_CONNECTION,
+  DEFAULT_CACHE_DATABASE_TABLE,
+  DEFAULT_CACHE_DATABASE_LOCK_TABLE,
+  holoCacheDefaults,
+  normalizeCacheConfig,
+  defineCacheConfig
+};

package/dist/chunk-FRE6NONR.mjs

@@ -0,0 +1,31 @@
+import {
+  CacheOptionalPackageError
+} from "./chunk-KIYULZES.mjs";
+
+// src/driver-registry.ts
+var cacheDriverRuntime = globalThis;
+cacheDriverRuntime.__holoCacheDriverFactories__ ??= /* @__PURE__ */ new Map();
+var factories = cacheDriverRuntime.__holoCacheDriverFactories__;
+function registerCacheDriverFactory(factory) {
+  const driver = factory.driver.trim();
+  if (!driver) throw new TypeError("Cache driver factories require a non-empty driver name.");
+  const existing = factories.get(driver);
+  if (existing && existing !== factory && (!factory.registrationKey || existing.registrationKey !== factory.registrationKey)) {
+    throw new Error(`Cache driver factory "${driver}" is already registered.`);
+  }
+  factories.set(driver, factory);
+}
+function unregisterCacheDriverFactory(factory) {
+  if (factories.get(factory.driver.trim()) === factory) factories.delete(factory.driver.trim());
+}
+function requireCacheDriverFactory(driver, message) {
+  const factory = factories.get(driver);
+  if (!factory) throw new CacheOptionalPackageError(message);
+  return factory;
+}
+
+export {
+  registerCacheDriverFactory,
+  unregisterCacheDriverFactory,
+  requireCacheDriverFactory
+};

package/dist/chunk-NZGSTXGZ.mjs

@@ -0,0 +1,119 @@
+// src/plugins.ts
+import { resolve } from "path";
+import {
+  loadHoloPluginContributionModules,
+  loadHoloPluginDefinitions
+} from "@holo-js/kernel";
+var loadedContractsByProjectRoot = /* @__PURE__ */ new Map();
+var failedLoadsByProjectRoot = /* @__PURE__ */ new Map();
+function isRecord(value) {
+  return !!value && typeof value === "object" && !Array.isArray(value);
+}
+function resolvePluginCandidate(moduleValue) {
+  return isRecord(moduleValue) && typeof moduleValue.default !== "undefined" ? moduleValue.default : isRecord(moduleValue) && typeof moduleValue.driver !== "undefined" ? moduleValue.driver : moduleValue;
+}
+function isCachePluginDriverFactory(candidate, driverName) {
+  return isRecord(candidate) && candidate.driver === driverName && typeof candidate.create === "function";
+}
+function assertCacheDriverContract(candidate, packageName, driverName, expectedName) {
+  if (!isRecord(candidate) || candidate.driver !== driverName || candidate.name !== expectedName || typeof candidate.get !== "function" || typeof candidate.put !== "function" || typeof candidate.add !== "function" || typeof candidate.forget !== "function" || typeof candidate.flush !== "function" || typeof candidate.increment !== "function" || typeof candidate.decrement !== "function" || typeof candidate.lock !== "function") {
+    throw new Error(`[@holo-js/cache] Plugin ${packageName} cache driver "${driverName}" must export a matching CacheDriverContract.`);
+  }
+}
+function resolveCacheDriver(moduleValue, packageName, driverName) {
+  const candidate = resolvePluginCandidate(moduleValue);
+  assertCacheDriverContract(candidate, packageName, driverName, driverName);
+  return candidate;
+}
+function resolveConfiguredCacheDriver(moduleValue, packageName, driverName, config) {
+  const candidate = resolvePluginCandidate(moduleValue);
+  if (isCachePluginDriverFactory(candidate, driverName)) {
+    const driver = candidate.create(config);
+    assertCacheDriverContract(driver, packageName, driverName, config.name);
+    return driver;
+  }
+  assertCacheDriverContract(candidate, packageName, driverName, driverName);
+  Object.defineProperties(candidate, {
+    name: {
+      value: config.name,
+      enumerable: true,
+      configurable: true
+    },
+    driver: {
+      value: driverName,
+      enumerable: true,
+      configurable: true
+    }
+  });
+  return Object.freeze(candidate);
+}
+function assertConfiguredCacheDriverContributions(configs, contributions) {
+  const availableDrivers = new Set(contributions.map((contribution) => contribution.name));
+  const missingDrivers = Array.from(new Set(
+    configs.map((config) => config.driver).filter((driver) => !availableDrivers.has(driver))
+  ));
+  if (missingDrivers.length === 0) {
+    return;
+  }
+  const available = contributions.length > 0 ? contributions.map((contribution) => `"${contribution.name}"`).join(", ") : "none";
+  throw new Error(
+    `[@holo-js/cache] Configured cache plugin driver ${missingDrivers.map((driver) => `"${driver}"`).join(", ")} has no matching plugin contribution. Available cache plugin driver contributions: ${available}.`
+  );
+}
+async function loadCachePluginDriverContracts(projectRoot = process.cwd(), pluginNames = []) {
+  const root = resolve(projectRoot);
+  const cacheKey = `${root}\0${[...pluginNames].sort().join("\0")}`;
+  const loadedContracts = loadedContractsByProjectRoot.get(cacheKey);
+  if (loadedContracts) {
+    return loadedContracts;
+  }
+  if (failedLoadsByProjectRoot.has(cacheKey)) {
+    throw failedLoadsByProjectRoot.get(cacheKey);
+  }
+  const plugins = await loadHoloPluginDefinitions(root, pluginNames);
+  const contributions = await loadHoloPluginContributionModules(root, plugins, "cache", "drivers");
+  let drivers;
+  try {
+    drivers = Object.freeze(contributions.map((contribution) => resolveCacheDriver(
+      contribution.module,
+      contribution.plugin.packageName,
+      contribution.name
+    )));
+  } catch (error) {
+    failedLoadsByProjectRoot.set(cacheKey, error);
+    throw error;
+  }
+  loadedContractsByProjectRoot.set(cacheKey, drivers);
+  return drivers;
+}
+async function loadConfiguredCachePluginDriverContracts(projectRoot, pluginNames, configs) {
+  if (configs.length === 0) {
+    return Object.freeze([]);
+  }
+  const plugins = await loadHoloPluginDefinitions(projectRoot, pluginNames);
+  const contributions = await loadHoloPluginContributionModules(projectRoot, plugins, "cache", "drivers");
+  assertConfiguredCacheDriverContributions(configs, contributions);
+  const drivers = [];
+  for (const contribution of contributions) {
+    const matchingConfigs = configs.filter((config) => config.driver === contribution.name);
+    for (const config of matchingConfigs) {
+      drivers.push(resolveConfiguredCacheDriver(
+        contribution.module,
+        contribution.plugin.packageName,
+        contribution.name,
+        config
+      ));
+    }
+  }
+  return Object.freeze(drivers);
+}
+function resetCachePluginDriverContracts() {
+  loadedContractsByProjectRoot.clear();
+  failedLoadsByProjectRoot.clear();
+}
+
+export {
+  loadCachePluginDriverContracts,
+  loadConfiguredCachePluginDriverContracts,
+  resetCachePluginDriverContracts
+};

package/dist/config.d.ts

@@ -0,0 +1,96 @@
+import { NormalizedHoloDatabaseConfig } from '@holo-js/db';
+import { NormalizedHoloRedisConfig } from '@holo-js/kernel';
+
+type CacheDriver = 'memory' | 'file' | 'redis' | 'database' | (string & {});
+declare module '@holo-js/config' {
+    interface HoloConfigRegistry {
+        cache: NormalizedHoloCacheConfig;
+    }
+}
+interface CacheMemoryDriverConfig {
+    readonly driver: 'memory';
+    readonly maxEntries?: number | string;
+    readonly prefix?: string;
+}
+interface CacheFileDriverConfig {
+    readonly driver: 'file';
+    readonly path?: string;
+    readonly prefix?: string;
+}
+interface CacheRedisDriverConfig {
+    readonly driver: 'redis';
+    readonly connection?: string;
+    readonly prefix?: string;
+}
+interface CacheDatabaseDriverConfig {
+    readonly driver: 'database';
+    readonly connection?: string;
+    readonly table?: string;
+    readonly lockTable?: string;
+    readonly prefix?: string;
+}
+interface CachePluginDriverConfig {
+    readonly driver: string;
+    readonly prefix?: string;
+    readonly [key: string]: unknown;
+}
+type CacheDriverConfig = CacheMemoryDriverConfig | CacheFileDriverConfig | CacheRedisDriverConfig | CacheDatabaseDriverConfig | CachePluginDriverConfig;
+interface HoloCacheConfig {
+    readonly default?: string;
+    readonly prefix?: string;
+    readonly drivers?: Readonly<Record<string, CacheDriverConfig>>;
+}
+interface NormalizedCacheMemoryDriverConfig {
+    readonly name: string;
+    readonly driver: 'memory';
+    readonly prefix: string;
+    readonly maxEntries?: number;
+}
+interface NormalizedCacheFileDriverConfig {
+    readonly name: string;
+    readonly driver: 'file';
+    readonly path: string;
+    readonly prefix: string;
+}
+interface NormalizedCacheRedisDriverConfig {
+    readonly name: string;
+    readonly driver: 'redis';
+    readonly connection: string;
+    readonly prefix: string;
+}
+interface NormalizedCacheDatabaseDriverConfig {
+    readonly name: string;
+    readonly driver: 'database';
+    readonly connection: string;
+    readonly table: string;
+    readonly lockTable: string;
+    readonly prefix: string;
+}
+interface NormalizedCachePluginDriverConfig {
+    readonly name: string;
+    readonly driver: string;
+    readonly prefix: string;
+    readonly [key: string]: unknown;
+}
+type NormalizedCacheDriverConfig = NormalizedCacheMemoryDriverConfig | NormalizedCacheFileDriverConfig | NormalizedCacheRedisDriverConfig | NormalizedCacheDatabaseDriverConfig | NormalizedCachePluginDriverConfig;
+interface NormalizedHoloCacheConfig {
+    readonly default: string;
+    readonly prefix: string;
+    readonly drivers: Readonly<Record<string, NormalizedCacheDriverConfig>>;
+}
+type CacheNormalizationOptions = {
+    readonly database?: NormalizedHoloDatabaseConfig;
+    readonly redis?: NormalizedHoloRedisConfig;
+};
+declare const DEFAULT_CACHE_DRIVER = "file";
+declare const DEFAULT_CACHE_PREFIX = "";
+declare const DEFAULT_CACHE_FILE_PATH = "./storage/framework/cache/data";
+declare const DEFAULT_CACHE_REDIS_CONNECTION = "default";
+declare const DEFAULT_CACHE_DATABASE_CONNECTION = "default";
+declare const DEFAULT_CACHE_DATABASE_TABLE = "cache";
+declare const DEFAULT_CACHE_DATABASE_LOCK_TABLE = "cache_locks";
+declare const holoCacheDefaults: Readonly<NormalizedHoloCacheConfig>;
+declare function normalizeCacheConfig(config?: HoloCacheConfig, options?: CacheNormalizationOptions): NormalizedHoloCacheConfig;
+declare function defineCacheConfig<TConfig extends HoloCacheConfig>(config: TConfig): Readonly<TConfig>;
+
+export { type CacheDatabaseDriverConfig, type CacheDriver, type CacheDriverConfig, type CacheFileDriverConfig, type CacheMemoryDriverConfig, type CacheNormalizationOptions, type CachePluginDriverConfig, type CacheRedisDriverConfig, DEFAULT_CACHE_DATABASE_CONNECTION, DEFAULT_CACHE_DATABASE_LOCK_TABLE, DEFAULT_CACHE_DATABASE_TABLE, DEFAULT_CACHE_DRIVER, DEFAULT_CACHE_FILE_PATH, DEFAULT_CACHE_PREFIX, DEFAULT_CACHE_REDIS_CONNECTION, type HoloCacheConfig, type NormalizedCacheDatabaseDriverConfig, type NormalizedCacheDriverConfig, type NormalizedCacheFileDriverConfig, type NormalizedCacheMemoryDriverConfig, type NormalizedCachePluginDriverConfig, type NormalizedCacheRedisDriverConfig, type NormalizedHoloCacheConfig, defineCacheConfig, holoCacheDefaults, normalizeCacheConfig };

package/dist/config.mjs

@@ -0,0 +1,24 @@
+import {
+  DEFAULT_CACHE_DATABASE_CONNECTION,
+  DEFAULT_CACHE_DATABASE_LOCK_TABLE,
+  DEFAULT_CACHE_DATABASE_TABLE,
+  DEFAULT_CACHE_DRIVER,
+  DEFAULT_CACHE_FILE_PATH,
+  DEFAULT_CACHE_PREFIX,
+  DEFAULT_CACHE_REDIS_CONNECTION,
+  defineCacheConfig,
+  holoCacheDefaults,
+  normalizeCacheConfig
+} from "./chunk-7FH4KYTX.mjs";
+export {
+  DEFAULT_CACHE_DATABASE_CONNECTION,
+  DEFAULT_CACHE_DATABASE_LOCK_TABLE,
+  DEFAULT_CACHE_DATABASE_TABLE,
+  DEFAULT_CACHE_DRIVER,
+  DEFAULT_CACHE_FILE_PATH,
+  DEFAULT_CACHE_PREFIX,
+  DEFAULT_CACHE_REDIS_CONNECTION,
+  defineCacheConfig,
+  holoCacheDefaults,
+  normalizeCacheConfig
+};

package/dist/contracts.d.ts

@@ -1,4 +1,6 @@
-import { HoloCacheConfig, NormalizedHoloCacheConfig, HoloDatabaseConfig, NormalizedHoloDatabaseConfig, HoloRedisConfig, NormalizedHoloRedisConfig } from '@holo-js/config';
+import { HoloCacheConfig, NormalizedHoloCacheConfig } from './config.js';
+import { HoloDatabaseConfig, NormalizedHoloDatabaseConfig } from '@holo-js/db';
+import { HoloRedisConfig, NormalizedHoloRedisConfig } from '@holo-js/kernel';
 
 declare const cacheKeyBrand: unique symbol;
 type CacheKey<TValue> = Readonly<{

package/dist/driver-registry-YQMWF4CC.mjs

@@ -0,0 +1,11 @@
+import {
+  registerCacheDriverFactory,
+  requireCacheDriverFactory,
+  unregisterCacheDriverFactory
+} from "./chunk-FRE6NONR.mjs";
+import "./chunk-KIYULZES.mjs";
+export {
+  registerCacheDriverFactory,
+  requireCacheDriverFactory,
+  unregisterCacheDriverFactory
+};

package/dist/index.d.ts

@@ -1,7 +1,10 @@
 import { CacheFlexibleTtlInput, CacheFacade, CacheRepository, CacheFallback, CacheValueResolver, CacheOptionalPackageError, CacheDriverContract, CacheDependencyIndex, CacheQueryBridge, CacheKeyInput, CacheDependencyDescriptor, CacheRuntimeBindings, CacheKey, CacheTtlInput, CacheLockContract, defineCacheKey, normalizeCacheTtl, serializeCacheValue, deserializeCacheValue } from './contracts.js';
 export { CacheConfigError, CacheDriverGetResult, CacheDriverPutInput, CacheDriverResolutionError, CacheError, CacheErrorCode, CacheFallbackResolver, CacheInvalidNumericMutationError, CacheInvalidTtlError, CacheLockAcquisitionError, CacheQueryIntegrationError, CacheRuntimeNotConfiguredError, CacheSerializationError, NormalizedCacheTtl, cacheContractsInternals, isCacheKey, resolveCacheKey } from './contracts.js';
-import { HoloDatabaseConfig, NormalizedHoloDatabaseConfig, HoloDatabaseConnectionConfig, HoloRedisConfig, NormalizedHoloRedisConfig, NormalizedHoloRedisConnectionConfig, NormalizedHoloCacheConfig, HoloCacheConfig } from '@holo-js/config';
-export { CacheDatabaseDriverConfig, CacheDriver, CacheDriverConfig, CacheFileDriverConfig, CacheMemoryDriverConfig, CacheRedisDriverConfig, HoloCacheConfig, NormalizedCacheDatabaseDriverConfig, NormalizedCacheDriverConfig, NormalizedCacheFileDriverConfig, NormalizedCacheMemoryDriverConfig, NormalizedCacheRedisDriverConfig, NormalizedHoloCacheConfig, defineCacheConfig } from '@holo-js/config';
+import { NormalizedHoloCacheConfig, HoloCacheConfig, NormalizedCachePluginDriverConfig } from './config.js';
+export { CacheDatabaseDriverConfig, CacheDriver, CacheDriverConfig, CacheFileDriverConfig, CacheMemoryDriverConfig, CachePluginDriverConfig, CacheRedisDriverConfig, NormalizedCacheDatabaseDriverConfig, NormalizedCacheDriverConfig, NormalizedCacheFileDriverConfig, NormalizedCacheMemoryDriverConfig, NormalizedCacheRedisDriverConfig, defineCacheConfig, holoCacheDefaults, normalizeCacheConfig } from './config.js';
+import { HoloDatabaseConnectionConfig, HoloDatabaseConfig, NormalizedHoloDatabaseConfig } from '@holo-js/db';
+import { mkdir, readdir, rmdir, writeFile } from 'node:fs/promises';
+import { NormalizedHoloRedisConnectionConfig, HoloRedisConfig, NormalizedHoloRedisConfig } from '@holo-js/kernel';
 
 type FlexibleEnvelope<TValue> = {
     readonly __holo_cache_flexible: true;
@@ -56,7 +59,7 @@ declare function resetDatabaseDriverModuleLoader(): void;
 declare const cacheDbInternals: {
     isModuleNotFoundError: typeof isModuleNotFoundError$1;
     isNormalizedDatabaseConfig: typeof isNormalizedDatabaseConfig;
-    loadDatabaseDriverModule: OptionalDriverModuleLoader<DatabaseCacheDriverModule>;
+    loadDatabaseDriverModule: () => Promise<DatabaseCacheDriverModule>;
     normalizeDatabaseModuleLoadError: typeof normalizeDatabaseModuleLoadError;
     normalizeRuntimeDatabaseConfig: typeof normalizeRuntimeDatabaseConfig;
     resolveSharedDatabaseConnection: typeof resolveSharedDatabaseConnection;
@@ -74,6 +77,12 @@ type FileCacheLockEnvelope = {
     owner: string;
     expiresAt: number;
 };
+type FileSystemOperations = {
+    readonly mkdir: typeof mkdir;
+    readonly readdir: typeof readdir;
+    readonly rmdir: typeof rmdir;
+    readonly writeFile: typeof writeFile;
+};
 declare function hashCacheKey(key: string): string;
 declare function resolveDriverRoot(path: string): string;
 declare function resolveEntryFilePath(rootPath: string, key: string): string;
@@ -87,6 +96,8 @@ declare const fileDriverInternals: {
     resolveDriverRoot: typeof resolveDriverRoot;
     resolveEntryFilePath: typeof resolveEntryFilePath;
     resolveLockFilePath: typeof resolveLockFilePath;
+    resetFileSystemOperations(): void;
+    setFileSystemOperations(operations: Partial<FileSystemOperations>): void;
 };
 
 type DependencyIndexState = {
@@ -133,7 +144,7 @@ declare function resetRedisDriverModuleLoader(): void;
 declare const cacheRedisInternals: {
     isModuleNotFoundError: typeof isModuleNotFoundError;
     isNormalizedRedisConfig: typeof isNormalizedRedisConfig;
-    loadRedisDriverModule: OptionalDriverModuleLoader<RedisCacheDriverModule>;
+    loadRedisDriverModule: () => Promise<RedisCacheDriverModule>;
     normalizeRedisModuleLoadError: typeof normalizeRedisModuleLoadError;
     normalizeRuntimeRedisConfig: typeof normalizeRuntimeRedisConfig;
     resolveSharedRedisConnection: typeof resolveSharedRedisConnection;
@@ -141,6 +152,15 @@ declare const cacheRedisInternals: {
     setRedisDriverModuleLoader: typeof setRedisDriverModuleLoader;
 };
 
+interface CacheDriverFactory<TOptions> {
+    readonly driver: string;
+    readonly registrationKey?: string;
+    create(options: TOptions): CacheDriverContract;
+}
+declare function registerCacheDriverFactory<TOptions extends object>(factory: CacheDriverFactory<TOptions>): void;
+declare function unregisterCacheDriverFactory<TOptions extends object>(factory: CacheDriverFactory<TOptions>): void;
+declare function requireCacheDriverFactory<TOptions extends object>(driver: string, message: string): CacheDriverFactory<TOptions>;
+
 type CacheRuntimeFacade = {
     readonly config: NormalizedHoloCacheConfig;
     readonly databaseConfig?: NormalizedHoloDatabaseConfig;
@@ -160,6 +180,7 @@ declare function getCacheRuntime(): CacheRuntimeFacade;
 declare function resolveConfiguredDriver(facade: CacheRuntimeFacade, requestedName?: string): CacheDriverContract;
 
 declare function configureCacheRuntime$1(bindings?: CacheRuntimeBindings): void;
+declare function loadCachePluginDrivers(projectRoot?: string, pluginNames?: readonly string[]): Promise<void>;
 declare const cacheRuntimeInternals: {
     getCacheRuntimeState: typeof getCacheRuntimeState;
     isNormalizedCacheConfig: typeof isNormalizedCacheConfig;
@@ -167,6 +188,10 @@ declare const cacheRuntimeInternals: {
     resolveConfiguredDriver: typeof resolveConfiguredDriver;
 };
 
+declare function loadCachePluginDriverContracts(projectRoot?: string, pluginNames?: readonly string[]): Promise<readonly CacheDriverContract[]>;
+declare function loadConfiguredCachePluginDriverContracts(projectRoot: string, pluginNames: readonly string[], configs: readonly NormalizedCachePluginDriverConfig[]): Promise<readonly CacheDriverContract[]>;
+declare function resetCachePluginDriverContracts(): void;
+
 declare function configureCacheRuntime(...parameters: Parameters<typeof configureCacheRuntime$1>): void;
 declare function resetCacheRuntime(): void;
 declare const cache: Readonly<{
@@ -195,7 +220,8 @@ declare const cache: Readonly<{
     configureCacheRuntime: typeof configureCacheRuntime;
     getCacheRuntime: typeof getCacheRuntime;
     getCacheRuntimeBindings: typeof getCacheRuntimeBindings;
+    loadCachePluginDrivers: typeof loadCachePluginDrivers;
     resetCacheRuntime: typeof resetCacheRuntime;
 }>;
 
-export { CacheDependencyDescriptor, CacheDependencyIndex, CacheDriverContract, CacheFacade, CacheFallback, CacheFlexibleTtlInput, CacheKey, CacheKeyInput, CacheLockContract, CacheOptionalPackageError, CacheQueryBridge, CacheRepository, CacheRuntimeBindings, CacheTtlInput, CacheValueResolver, cacheDbInternals, cacheFacade, cacheFacadeInternals, cacheQueryBridgeInternals, cacheRedisInternals, cacheRuntimeInternals, configureCacheRuntime, cache as default, defineCacheKey, deserializeCacheValue, fileDriverInternals, getCacheRuntime, getCacheRuntimeBindings, normalizeCacheTtl, resetCacheRuntime, serializeCacheValue };
+export { CacheDependencyDescriptor, CacheDependencyIndex, CacheDriverContract, type CacheDriverFactory, CacheFacade, CacheFallback, CacheFlexibleTtlInput, CacheKey, CacheKeyInput, CacheLockContract, CacheOptionalPackageError, CacheQueryBridge, CacheRepository, CacheRuntimeBindings, CacheTtlInput, CacheValueResolver, type DatabaseCacheDriverOptions, HoloCacheConfig, NormalizedCachePluginDriverConfig, NormalizedHoloCacheConfig, type RedisCacheDriverOptions, cacheDbInternals, cacheFacade, cacheFacadeInternals, cacheQueryBridgeInternals, cacheRedisInternals, cacheRuntimeInternals, configureCacheRuntime, cache as default, defineCacheKey, deserializeCacheValue, fileDriverInternals, getCacheRuntime, getCacheRuntimeBindings, loadCachePluginDriverContracts, loadCachePluginDrivers, loadConfiguredCachePluginDriverContracts, normalizeCacheTtl, registerCacheDriverFactory, requireCacheDriverFactory, resetCachePluginDriverContracts, resetCacheRuntime, serializeCacheValue, unregisterCacheDriverFactory };

package/dist/index.mjs

@@ -1,3 +1,13 @@
+import {
+  defineCacheConfig,
+  holoCacheDefaults,
+  normalizeCacheConfig
+} from "./chunk-7FH4KYTX.mjs";
+import {
+  registerCacheDriverFactory,
+  requireCacheDriverFactory,
+  unregisterCacheDriverFactory
+} from "./chunk-FRE6NONR.mjs";
 import {
   CacheConfigError,
   CacheDriverResolutionError,
@@ -17,9 +27,11 @@ import {
   resolveCacheKey,
   serializeCacheValue
 } from "./chunk-KIYULZES.mjs";
-
-// src/index.ts
-import { defineCacheConfig } from "@holo-js/config";
+import {
+  loadCachePluginDriverContracts,
+  loadConfiguredCachePluginDriverContracts,
+  resetCachePluginDriverContracts
+} from "./chunk-NZGSTXGZ.mjs";
 
 // src/flexible.ts
 function normalizeFlexibleTtl(ttl) {
@@ -93,21 +105,12 @@ async function resolveFlexibleCachedValue(options) {
   return options.refresh(normalizedTtl);
 }
 
-// src/runtime-shared.ts
-import {
-  holoCacheDefaults,
-  normalizeCacheConfig
-} from "@holo-js/config";
-
 // src/db.ts
 import {
   normalizeDatabaseConfig
-} from "@holo-js/config";
+} from "@holo-js/db";
 
 // src/optional-driver.ts
-import { createRequire } from "module";
-import { join } from "path";
-import { pathToFileURL } from "url";
 var CACHE_DRIVER_DISPOSE_SYMBOL = /* @__PURE__ */ Symbol.for("holo.cache.driver.dispose");
 function escapeRegExp(value) {
   return value.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
@@ -138,29 +141,6 @@ function normalizeOptionalDriverModuleLoadError(error, expectedSpecifier, messag
   }
   return error;
 }
-async function importOptionalDriverModuleFromProject(specifier) {
-  const projectRequire = createRequire(join(process.cwd(), "package.json"));
-  return await import(pathToFileURL(projectRequire.resolve(specifier)).href);
-}
-function createOptionalDriverModuleLoader(specifier, missingPackageMessage) {
-  return async () => {
-    try {
-      return await import(
-        /* webpackIgnore: true */
-        specifier
-      );
-    } catch (error) {
-      if (!isOptionalDriverModuleNotFoundError(error, specifier)) {
-        throw normalizeOptionalDriverModuleLoadError(error, specifier, missingPackageMessage);
-      }
-      try {
-        return await importOptionalDriverModuleFromProject(specifier);
-      } catch (fallbackError) {
-        throw normalizeOptionalDriverModuleLoadError(fallbackError, specifier, missingPackageMessage);
-      }
-    }
-  };
-}
 var LazyOptionalCacheDriver = class {
   constructor(lazyOptions) {
     this.lazyOptions = lazyOptions;
@@ -260,7 +240,6 @@ function createLazyOptionalCacheDriver(options) {
 }
 
 // src/db.ts
-var DATABASE_CACHE_PACKAGE = "@holo-js/cache-db";
 var DATABASE_CACHE_MISSING_MESSAGE = "[@holo-js/cache] Database cache support requires @holo-js/cache-db to be installed.";
 function isNormalizedDatabaseConfig(config) {
   return typeof config === "object" && config !== null && typeof config.connections === "object" && config.connections !== null;
@@ -288,10 +267,11 @@ function isModuleNotFoundError(error, expectedSpecifier = "@holo-js/cache-db") {
 function normalizeDatabaseModuleLoadError(error, expectedSpecifier = "@holo-js/cache-db") {
   return normalizeOptionalDriverModuleLoadError(error, expectedSpecifier, DATABASE_CACHE_MISSING_MESSAGE);
 }
-var loadDatabaseDriverModule = createOptionalDriverModuleLoader(
-  DATABASE_CACHE_PACKAGE,
-  DATABASE_CACHE_MISSING_MESSAGE
-);
+var loadDatabaseDriverModule = async () => {
+  const { requireCacheDriverFactory: requireCacheDriverFactory2 } = await import("./driver-registry-YQMWF4CC.mjs");
+  const factory = requireCacheDriverFactory2("database", DATABASE_CACHE_MISSING_MESSAGE);
+  return { createDatabaseCacheDriver: (options) => factory.create(options) };
+};
 var databaseDriverModuleLoader = loadDatabaseDriverModule;
 function setDatabaseDriverModuleLoader(loader) {
   databaseDriverModuleLoader = loader;
@@ -321,8 +301,24 @@ var cacheDbInternals = {
 
 // src/file.ts
 import { createHash, randomUUID } from "crypto";
-import { mkdir, open, readFile, readdir, rename, rm, rmdir, writeFile } from "fs/promises";
-import { dirname, join as join2, resolve } from "path";
+import {
+  mkdir as defaultMkdir,
+  open,
+  readFile,
+  readdir as defaultReaddir,
+  rename,
+  rm,
+  rmdir as defaultRmdir,
+  writeFile as defaultWriteFile
+} from "fs/promises";
+import { dirname, join, resolve } from "path";
+var defaultFileSystemOperations = {
+  mkdir: defaultMkdir,
+  readdir: defaultReaddir,
+  rmdir: defaultRmdir,
+  writeFile: defaultWriteFile
+};
+var fileSystemOperations = defaultFileSystemOperations;
 var MALFORMED_FILE = /* @__PURE__ */ Symbol("MALFORMED_FILE");
 function defaultSleep(milliseconds) {
   return new Promise((resolveDelay) => {
@@ -347,14 +343,14 @@ function resolveDriverRoot(path) {
 }
 function resolveEntryFilePath(rootPath, key) {
   const hash = hashCacheKey(key);
-  return join2(rootPath, "entries", hash.slice(0, 2), `${hash}.json`);
+  return join(rootPath, "entries", hash.slice(0, 2), `${hash}.json`);
 }
 function resolveLockFilePath(rootPath, name) {
   const hash = hashCacheKey(name);
-  return join2(rootPath, "locks", hash.slice(0, 2), `${hash}.lock`);
+  return join(rootPath, "locks", hash.slice(0, 2), `${hash}.lock`);
 }
 function resolveLockMarkerFilePath(lockPath, owner) {
-  return join2(lockPath, `${hashCacheKey(owner)}.json`);
+  return join(lockPath, `${hashCacheKey(owner)}.json`);
 }
 function isPositiveTimestamp(value) {
   return typeof value === "number" && Number.isFinite(value) && value >= 0;
@@ -374,14 +370,14 @@ function isFileCacheLockEnvelope(value) {
   return typeof lock.name === "string" && typeof lock.owner === "string" && isPositiveTimestamp(lock.expiresAt);
 }
 async function ensureParentDirectory(filePath) {
-  await mkdir(dirname(filePath), { recursive: true });
+  await fileSystemOperations.mkdir(dirname(filePath), { recursive: true });
 }
 async function removeFileIfPresent(filePath) {
   await rm(filePath, { force: true });
 }
 async function removeEmptyDirectoryIfPresent(path) {
   try {
-    await rmdir(path);
+    await fileSystemOperations.rmdir(path);
   } catch (error) {
     if (error instanceof Error && "code" in error && (error.code === "ENOENT" || error.code === "ENOTEMPTY" || error.code === "ENOTDIR")) {
       return;
@@ -402,7 +398,7 @@ async function readFileIfPresent(filePath) {
 async function writeFileAtomically(filePath, contents) {
   await ensureParentDirectory(filePath);
   const temporaryPath = `${filePath}.${process.pid}.${randomUUID()}.tmp`;
-  await writeFile(temporaryPath, contents, "utf8");
+  await fileSystemOperations.writeFile(temporaryPath, contents, "utf8");
   try {
     await rename(temporaryPath, filePath);
   } catch (error) {
@@ -438,9 +434,9 @@ async function readJsonFile(filePath) {
 }
 async function listFiles(rootPath) {
   try {
-    const entries = await readdir(rootPath, { withFileTypes: true });
+    const entries = await fileSystemOperations.readdir(rootPath, { withFileTypes: true });
     const nested = await Promise.all(entries.map(async (entry) => {
-      const entryPath = join2(rootPath, entry.name);
+      const entryPath = join(rootPath, entry.name);
       if (entry.isDirectory()) return listFiles(entryPath);
       return [entryPath];
     }));
@@ -468,7 +464,7 @@ async function removeScopedCacheFiles(rootPath, prefix, isEnvelope, resolveName)
   }
   if (!prefix) {
     await rm(rootPath, { recursive: true, force: true });
-    await mkdir(rootPath, { recursive: true });
+    await fileSystemOperations.mkdir(rootPath, { recursive: true });
     return;
   }
   for (const filePath of await listFiles(rootPath)) {
@@ -501,8 +497,8 @@ async function readLock(rootPath, name, now) {
   const filePath = resolveLockFilePath(rootPath, name);
   let markerFilePaths;
   try {
-    const entries = await readdir(filePath, { withFileTypes: true });
-    markerFilePaths = entries.filter((entry) => entry.isFile()).map((entry) => join2(filePath, entry.name));
+    const entries = await fileSystemOperations.readdir(filePath, { withFileTypes: true });
+    markerFilePaths = entries.filter((entry) => entry.isFile()).map((entry) => join(filePath, entry.name));
   } catch (error) {
     if (error instanceof Error && "code" in error && error.code === "ENOENT") {
       return {
@@ -585,7 +581,7 @@ function createFileLock(rootPath, name, seconds, now, sleep, ownerFactory) {
   async function writeLockDirectory(filePath, envelope) {
     await ensureParentDirectory(filePath);
     try {
-      await mkdir(filePath);
+      await fileSystemOperations.mkdir(filePath);
     } catch (error) {
       if (error instanceof Error && "code" in error && error.code === "EEXIST") {
         return false;
@@ -593,7 +589,7 @@ function createFileLock(rootPath, name, seconds, now, sleep, ownerFactory) {
       throw error;
     }
     try {
-      await writeFile(resolveLockMarkerFilePath(filePath, owner), envelope, "utf8");
+      await fileSystemOperations.writeFile(resolveLockMarkerFilePath(filePath, owner), envelope, "utf8");
     } catch (error) {
       await removeFileIfPresent(resolveLockMarkerFilePath(filePath, owner));
       await removeEmptyDirectoryIfPresent(filePath);
@@ -747,13 +743,13 @@ function createFileCacheDriver(options) {
     },
     async flush() {
       await removeScopedCacheFiles(
-        join2(rootPath, "entries"),
+        join(rootPath, "entries"),
         prefix,
         isFileCacheEntryEnvelope,
         (entry) => entry.key
       );
       await removeScopedCacheFiles(
-        join2(rootPath, "locks"),
+        join(rootPath, "locks"),
         prefix,
         isFileCacheLockEnvelope,
         (lock) => lock.name
@@ -776,7 +772,13 @@ var fileDriverInternals = {
   isFileCacheLockEnvelope,
   resolveDriverRoot,
   resolveEntryFilePath,
-  resolveLockFilePath
+  resolveLockFilePath,
+  resetFileSystemOperations() {
+    fileSystemOperations = defaultFileSystemOperations;
+  },
+  setFileSystemOperations(operations) {
+    fileSystemOperations = { ...defaultFileSystemOperations, ...operations };
+  }
 };
 
 // src/memory.ts
@@ -969,8 +971,7 @@ function createMemoryCacheDriver(options) {
 // src/redis.ts
 import {
   normalizeRedisConfig
-} from "@holo-js/config";
-var REDIS_CACHE_PACKAGE = "@holo-js/cache-redis";
+} from "@holo-js/kernel";
 var REDIS_CACHE_MISSING_MESSAGE = "[@holo-js/cache] Redis cache support requires @holo-js/cache-redis to be installed.";
 function isNormalizedRedisConfig(config) {
   return typeof config.default === "string" && typeof config.connections === "object" && config.connections !== null && Object.values(config.connections).every((connection) => {
@@ -1000,10 +1001,11 @@ function isModuleNotFoundError2(error, expectedSpecifier = "@holo-js/cache-redis
 function normalizeRedisModuleLoadError(error, expectedSpecifier = "@holo-js/cache-redis") {
   return normalizeOptionalDriverModuleLoadError(error, expectedSpecifier, REDIS_CACHE_MISSING_MESSAGE);
 }
-var loadRedisDriverModule = createOptionalDriverModuleLoader(
-  REDIS_CACHE_PACKAGE,
-  REDIS_CACHE_MISSING_MESSAGE
-);
+var loadRedisDriverModule = async () => {
+  const { requireCacheDriverFactory: requireCacheDriverFactory2 } = await import("./driver-registry-YQMWF4CC.mjs");
+  const factory = requireCacheDriverFactory2("redis", REDIS_CACHE_MISSING_MESSAGE);
+  return { createRedisCacheDriver: (options) => factory.create(options) };
+};
 var redisDriverModuleLoader = loadRedisDriverModule;
 function setRedisDriverModuleLoader(loader) {
   redisDriverModuleLoader = loader;
@@ -1093,45 +1095,55 @@ function resolveConfiguredDriver(facade, requestedName) {
   }
   switch (driverConfig.driver) {
     case "file": {
+      const fileConfig = driverConfig;
       return cacheResolvedDriver(facade, driverName, createFileCacheDriver({
-        name: driverConfig.name,
-        path: driverConfig.path,
-        prefix: driverConfig.prefix
+        name: fileConfig.name,
+        path: fileConfig.path,
+        prefix: fileConfig.prefix
       }));
     }
     case "memory": {
+      const memoryConfig = driverConfig;
       return cacheResolvedDriver(facade, driverName, createMemoryCacheDriver({
-        name: driverConfig.name,
-        maxEntries: driverConfig.maxEntries
+        name: memoryConfig.name,
+        maxEntries: memoryConfig.maxEntries
       }));
     }
     case "redis": {
+      const redisConfig = driverConfig;
       const connection = cacheRedisInternals.resolveSharedRedisConnection(
         facade.redisConfig,
-        driverConfig.connection
+        redisConfig.connection
       );
       return cacheResolvedDriver(facade, driverName, createRedisCacheDriver({
-        name: driverConfig.name,
+        name: redisConfig.name,
         connectionName: connection.name,
-        prefix: driverConfig.prefix,
+        prefix: redisConfig.prefix,
         redis: connection
       }));
     }
     case "database": {
+      const databaseConfig = driverConfig;
       const connection = cacheDbInternals.resolveSharedDatabaseConnection(
         facade.databaseConfig,
-        driverConfig.connection
+        databaseConfig.connection
       );
       return cacheResolvedDriver(facade, driverName, createDatabaseCacheDriver({
-        name: driverConfig.name,
-        connectionName: driverConfig.connection,
-        table: driverConfig.table,
-        lockTable: driverConfig.lockTable,
-        prefix: driverConfig.prefix,
+        name: databaseConfig.name,
+        connectionName: databaseConfig.connection,
+        table: databaseConfig.table,
+        lockTable: databaseConfig.lockTable,
+        prefix: databaseConfig.prefix,
         connection
       }));
     }
     default:
+      if (typeof driverConfig.driver === "string") {
+        const pluginDriver = facade.drivers.get(driverConfig.driver);
+        if (pluginDriver) {
+          return cacheResolvedDriver(facade, driverName, pluginDriver);
+        }
+      }
       throw new CacheDriverResolutionError(
         `[@holo-js/cache] Cache driver "${driverName}" uses unsupported driver "${String(driverConfig.driver)}" in this phase.`
       );
@@ -1205,14 +1217,11 @@ function resetDefaultDependencyIndex() {
 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;
-  }
+  const driver = resolveConfiguredDriver(runtime, configuredDriverName);
+  const normalizedKeyPrefix = runtime.config.drivers[configuredDriverName].prefix;
   return Object.freeze({
     driverName: configuredDriverName,
-    driver: resolveConfiguredDriver(runtime, configuredDriverName),
+    driver,
     normalizedKeyPrefix
   });
 }
@@ -1370,6 +1379,26 @@ function resetCacheRuntime() {
   getCacheRuntimeState().bindings = void 0;
   resetDefaultDependencyIndex();
   setGlobalDatabaseQueryCacheBridge(void 0);
+  resetCachePluginDriverContracts();
+}
+async function loadCachePluginDrivers(projectRoot = process.cwd(), pluginNames = []) {
+  const bindings = getCacheRuntimeState().bindings;
+  if (!bindings) {
+    return;
+  }
+  const pluginDriverConfigs = Object.values(bindings.config.drivers).filter((driver) => {
+    return driver.driver !== "memory" && driver.driver !== "file" && driver.driver !== "redis" && driver.driver !== "database";
+  });
+  for (const driver of await loadConfiguredCachePluginDriverContracts(projectRoot, pluginNames, pluginDriverConfigs)) {
+    bindings.drivers.set(driver.name, driver);
+  }
+  if (pluginDriverConfigs.length > 0) {
+    return;
+  }
+  const { loadCachePluginDriverContracts: loadCachePluginDriverContracts2 } = await import("./plugins-JHYNVE7O.mjs");
+  for (const driver of await loadCachePluginDriverContracts2(projectRoot, pluginNames)) {
+    bindings.drivers.set(driver.name, driver);
+  }
 }
 var cacheRuntimeInternals = {
   getCacheRuntimeState,
@@ -1605,6 +1634,7 @@ var cache = Object.freeze({
   configureCacheRuntime: configureCacheRuntime2,
   getCacheRuntime,
   getCacheRuntimeBindings,
+  loadCachePluginDrivers,
   resetCacheRuntime: resetCacheRuntime2,
   ...cacheFacade
 });
@@ -1635,9 +1665,18 @@ export {
   fileDriverInternals,
   getCacheRuntime,
   getCacheRuntimeBindings,
+  holoCacheDefaults,
   isCacheKey,
+  loadCachePluginDriverContracts,
+  loadCachePluginDrivers,
+  loadConfiguredCachePluginDriverContracts,
+  normalizeCacheConfig,
   normalizeCacheTtl,
+  registerCacheDriverFactory,
+  requireCacheDriverFactory,
+  resetCachePluginDriverContracts,
   resetCacheRuntime2 as resetCacheRuntime,
   resolveCacheKey,
-  serializeCacheValue
+  serializeCacheValue,
+  unregisterCacheDriverFactory
 };

package/dist/plugins-JHYNVE7O.mjs

@@ -0,0 +1,10 @@
+import {
+  loadCachePluginDriverContracts,
+  loadConfiguredCachePluginDriverContracts,
+  resetCachePluginDriverContracts
+} from "./chunk-NZGSTXGZ.mjs";
+export {
+  loadCachePluginDriverContracts,
+  loadConfiguredCachePluginDriverContracts,
+  resetCachePluginDriverContracts
+};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@holo-js/cache",
-  "version": "0.2.6",
+  "version": "0.3.0",
   "description": "Holo-JS Framework - cache contracts, config helpers, serialization, and runtime seams",
   "type": "module",
   "license": "MIT",
@@ -10,6 +10,11 @@
       "import": "./dist/index.mjs",
       "default": "./dist/index.mjs"
     },
+    "./config": {
+      "types": "./dist/config.d.ts",
+      "import": "./dist/config.mjs",
+      "default": "./dist/config.mjs"
+    },
     "./contracts": {
       "types": "./dist/contracts.d.ts",
       "import": "./dist/contracts.mjs",
@@ -28,7 +33,9 @@
     "test": "vitest --run"
   },
   "dependencies": {
-    "@holo-js/config": "^0.2.6"
+    "@holo-js/config": "^0.3.0",
+    "@holo-js/db": "^0.3.0",
+    "@holo-js/kernel": "^0.3.0"
   },
   "devDependencies": {
     "@types/node": "^22.10.2",