@dexto/core 1.3.0 → 1.5.0

package/dist/storage/cache/index.d.ts

@@ -0,0 +1,44 @@
+/**
+ * Cache Module
+ *
+ * This module provides a flexible caching system with support for
+ * multiple backends through a provider pattern.
+ *
+ * ## Built-in Providers
+ * - `in-memory`: Store data in RAM (for testing/development)
+ * - `redis`: Store data in Redis server
+ *
+ * ## Custom Providers
+ * Custom providers (e.g., Memcached, Hazelcast) can be registered at the
+ * CLI/server layer before configuration loading.
+ *
+ * ## Usage
+ *
+ * ### Using built-in providers
+ * ```typescript
+ * import { createCache } from '@dexto/core';
+ *
+ * const cache = await createCache({ type: 'redis', host: 'localhost' }, logger);
+ * ```
+ *
+ * ### Registering custom providers
+ * ```typescript
+ * import { cacheRegistry, type CacheProvider } from '@dexto/core';
+ *
+ * const memcachedProvider: CacheProvider<'memcached', MemcachedConfig> = {
+ *   type: 'memcached',
+ *   configSchema: MemcachedConfigSchema,
+ *   create: (config, logger) => new MemcachedCache(config, logger),
+ * };
+ *
+ * cacheRegistry.register(memcachedProvider);
+ * const cache = await createCache({ type: 'memcached', servers: ['...'] }, logger);
+ * ```
+ */
+export { createCache } from './factory.js';
+export { cacheRegistry, CacheRegistry } from './registry.js';
+export type { CacheProvider } from './provider.js';
+export type { Cache } from './types.js';
+export { CACHE_TYPES, CacheConfigSchema, InMemoryCacheSchema, RedisCacheSchema, type CacheType, type CacheConfig, type InMemoryCacheConfig, type RedisCacheConfig, } from './schemas.js';
+export { MemoryCacheStore } from './memory-cache-store.js';
+//# sourceMappingURL=index.d.ts.map

package/dist/storage/cache/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/storage/cache/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAoCG;AAiBH,OAAO,EAAE,WAAW,EAAE,MAAM,cAAc,CAAC;AAC3C,OAAO,EAAE,aAAa,EAAE,aAAa,EAAE,MAAM,eAAe,CAAC;AAC7D,YAAY,EAAE,aAAa,EAAE,MAAM,eAAe,CAAC;AAGnD,YAAY,EAAE,KAAK,EAAE,MAAM,YAAY,CAAC;AAGxC,OAAO,EACH,WAAW,EACX,iBAAiB,EACjB,mBAAmB,EACnB,gBAAgB,EAChB,KAAK,SAAS,EACd,KAAK,WAAW,EAChB,KAAK,mBAAmB,EACxB,KAAK,gBAAgB,GACxB,MAAM,cAAc,CAAC;AAGtB,OAAO,EAAE,gBAAgB,EAAE,MAAM,yBAAyB,CAAC"}

package/dist/storage/cache/index.js

@@ -0,0 +1,28 @@
+import "../../chunk-PTJYTZNU.js";
+import { cacheRegistry } from "./registry.js";
+import { inMemoryCacheProvider, redisCacheProvider } from "./providers/index.js";
+if (!cacheRegistry.has("in-memory")) {
+  cacheRegistry.register(inMemoryCacheProvider);
+}
+if (!cacheRegistry.has("redis")) {
+  cacheRegistry.register(redisCacheProvider);
+}
+import { createCache } from "./factory.js";
+import { cacheRegistry as cacheRegistry2, CacheRegistry } from "./registry.js";
+import {
+  CACHE_TYPES,
+  CacheConfigSchema,
+  InMemoryCacheSchema,
+  RedisCacheSchema
+} from "./schemas.js";
+import { MemoryCacheStore } from "./memory-cache-store.js";
+export {
+  CACHE_TYPES,
+  CacheConfigSchema,
+  CacheRegistry,
+  InMemoryCacheSchema,
+  MemoryCacheStore,
+  RedisCacheSchema,
+  cacheRegistry2 as cacheRegistry,
+  createCache
+};

package/dist/storage/cache/memory-cache-store.js

@@ -1,4 +1,4 @@
-import "../../chunk-C6A6W6XS.js";
+import "../../chunk-PTJYTZNU.js";
 import { StorageError } from "../errors.js";
 class MemoryCacheStore {
   data = /* @__PURE__ */ new Map();

package/dist/storage/cache/provider.cjs

@@ -0,0 +1,16 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var provider_exports = {};
+module.exports = __toCommonJS(provider_exports);

package/dist/storage/cache/provider.d.ts

@@ -0,0 +1,56 @@
+import type { z } from 'zod';
+import type { Cache } from './types.js';
+import type { IDextoLogger } from '../../logger/v2/types.js';
+/**
+ * Provider interface for creating cache instances.
+ *
+ * This interface uses TypeScript generics to enforce type safety:
+ * - TType: The literal type string (e.g., 'redis', 'in-memory')
+ * - TConfig: The configuration type with discriminator { type: TType }
+ *
+ * This ensures that the provider type matches the config type discriminator,
+ * providing compile-time safety for provider implementations.
+ */
+export interface CacheProvider<TType extends string = string, TConfig extends {
+    type: TType;
+} = any> {
+    /**
+     * Unique identifier for this provider (e.g., 'redis', 'in-memory', 'memcached').
+     * Must match the 'type' field in the configuration.
+     */
+    type: TType;
+    /**
+     * Zod schema for validating provider-specific configuration.
+     * The schema must output TConfig type.
+     *
+     * Note: Uses z.ZodType with relaxed generics to allow input/output type variance.
+     * This is necessary because Zod schemas with `.optional().default()` have
+     * input types that include undefined, but output types that don't.
+     */
+    configSchema: z.ZodType<TConfig, any, any>;
+    /**
+     * Factory function to create a Cache instance.
+     *
+     * Unlike blob store providers (which are sync), cache providers may return
+     * a Promise to support lazy loading of optional dependencies (e.g., ioredis).
+     *
+     * @param config - Validated configuration specific to this provider
+     * @param logger - Logger instance for the cache
+     * @returns A Cache implementation (or Promise for async providers)
+     */
+    create(config: TConfig, logger: IDextoLogger): Cache | Promise<Cache>;
+    /**
+     * Optional metadata for documentation, UIs, and discovery.
+     */
+    metadata?: {
+        /** Human-readable name (e.g., "Redis", "Memcached") */
+        displayName: string;
+        /** Brief description of this cache backend */
+        description: string;
+        /** Whether this provider requires network connectivity */
+        requiresNetwork?: boolean;
+        /** Whether this provider supports TTL (time-to-live) */
+        supportsTTL?: boolean;
+    };
+}
+//# sourceMappingURL=provider.d.ts.map

package/dist/storage/cache/provider.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"provider.d.ts","sourceRoot":"","sources":["../../../src/storage/cache/provider.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAC7B,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,YAAY,CAAC;AACxC,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,0BAA0B,CAAC;AAE7D;;;;;;;;;GASG;AACH,MAAM,WAAW,aAAa,CAC1B,KAAK,SAAS,MAAM,GAAG,MAAM,EAC7B,OAAO,SAAS;IAAE,IAAI,EAAE,KAAK,CAAA;CAAE,GAAG,GAAG;IAErC;;;OAGG;IACH,IAAI,EAAE,KAAK,CAAC;IAEZ;;;;;;;OAOG;IACH,YAAY,EAAE,CAAC,CAAC,OAAO,CAAC,OAAO,EAAE,GAAG,EAAE,GAAG,CAAC,CAAC;IAE3C;;;;;;;;;OASG;IACH,MAAM,CAAC,MAAM,EAAE,OAAO,EAAE,MAAM,EAAE,YAAY,GAAG,KAAK,GAAG,OAAO,CAAC,KAAK,CAAC,CAAC;IAEtE;;OAEG;IACH,QAAQ,CAAC,EAAE;QACP,uDAAuD;QACvD,WAAW,EAAE,MAAM,CAAC;QACpB,8CAA8C;QAC9C,WAAW,EAAE,MAAM,CAAC;QACpB,0DAA0D;QAC1D,eAAe,CAAC,EAAE,OAAO,CAAC;QAC1B,wDAAwD;QACxD,WAAW,CAAC,EAAE,OAAO,CAAC;KACzB,CAAC;CACL"}

package/dist/storage/cache/providers/index.cjs

@@ -0,0 +1,31 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var providers_exports = {};
+__export(providers_exports, {
+  inMemoryCacheProvider: () => import_memory.inMemoryCacheProvider,
+  redisCacheProvider: () => import_redis.redisCacheProvider
+});
+module.exports = __toCommonJS(providers_exports);
+var import_memory = require("./memory.js");
+var import_redis = require("./redis.js");
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  inMemoryCacheProvider,
+  redisCacheProvider
+});

package/dist/storage/cache/providers/index.d.ts

@@ -0,0 +1,8 @@
+/**
+ * Built-in cache providers.
+ *
+ * These providers are automatically registered when importing from @dexto/core.
+ */
+export { inMemoryCacheProvider } from './memory.js';
+export { redisCacheProvider } from './redis.js';
+//# sourceMappingURL=index.d.ts.map

package/dist/storage/cache/providers/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/storage/cache/providers/index.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAEH,OAAO,EAAE,qBAAqB,EAAE,MAAM,aAAa,CAAC;AACpD,OAAO,EAAE,kBAAkB,EAAE,MAAM,YAAY,CAAC"}

package/dist/storage/cache/providers/index.js

@@ -0,0 +1,7 @@
+import "../../../chunk-PTJYTZNU.js";
+import { inMemoryCacheProvider } from "./memory.js";
+import { redisCacheProvider } from "./redis.js";
+export {
+  inMemoryCacheProvider,
+  redisCacheProvider
+};

package/dist/storage/cache/providers/memory.cjs

@@ -0,0 +1,40 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var memory_exports = {};
+__export(memory_exports, {
+  inMemoryCacheProvider: () => inMemoryCacheProvider
+});
+module.exports = __toCommonJS(memory_exports);
+var import_schemas = require("../schemas.js");
+var import_memory_cache_store = require("../memory-cache-store.js");
+const inMemoryCacheProvider = {
+  type: "in-memory",
+  configSchema: import_schemas.InMemoryCacheSchema,
+  create: (_config, _logger) => new import_memory_cache_store.MemoryCacheStore(),
+  metadata: {
+    displayName: "In-Memory",
+    description: "Store cache data in RAM (ephemeral, for testing and development)",
+    requiresNetwork: false,
+    supportsTTL: true
+  }
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  inMemoryCacheProvider
+});

package/dist/storage/cache/providers/memory.d.ts

@@ -0,0 +1,17 @@
+import type { CacheProvider } from '../provider.js';
+import type { InMemoryCacheConfig } from '../schemas.js';
+/**
+ * Provider for in-memory cache storage.
+ *
+ * This provider stores data in RAM and is ideal for development,
+ * testing, and ephemeral use cases where persistence is not required.
+ *
+ * Features:
+ * - Zero external dependencies
+ * - Fast in-memory operations
+ * - TTL support for automatic expiration
+ * - No network required
+ * - Data is lost on restart
+ */
+export declare const inMemoryCacheProvider: CacheProvider<'in-memory', InMemoryCacheConfig>;
+//# sourceMappingURL=memory.d.ts.map

package/dist/storage/cache/providers/memory.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"memory.d.ts","sourceRoot":"","sources":["../../../../src/storage/cache/providers/memory.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,gBAAgB,CAAC;AACpD,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,eAAe,CAAC;AAIzD;;;;;;;;;;;;GAYG;AACH,eAAO,MAAM,qBAAqB,EAAE,aAAa,CAAC,WAAW,EAAE,mBAAmB,CAUjF,CAAC"}

package/dist/storage/cache/providers/memory.js

@@ -0,0 +1,17 @@
+import "../../../chunk-PTJYTZNU.js";
+import { InMemoryCacheSchema } from "../schemas.js";
+import { MemoryCacheStore } from "../memory-cache-store.js";
+const inMemoryCacheProvider = {
+  type: "in-memory",
+  configSchema: InMemoryCacheSchema,
+  create: (_config, _logger) => new MemoryCacheStore(),
+  metadata: {
+    displayName: "In-Memory",
+    description: "Store cache data in RAM (ephemeral, for testing and development)",
+    requiresNetwork: false,
+    supportsTTL: true
+  }
+};
+export {
+  inMemoryCacheProvider
+};

package/dist/storage/cache/providers/redis.cjs

@@ -0,0 +1,66 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var redis_exports = {};
+__export(redis_exports, {
+  redisCacheProvider: () => redisCacheProvider
+});
+module.exports = __toCommonJS(redis_exports);
+var import_schemas = require("../schemas.js");
+var import_errors = require("../../errors.js");
+const redisCacheProvider = {
+  type: "redis",
+  configSchema: import_schemas.RedisCacheSchema,
+  create: async (config, logger) => {
+    try {
+      const module2 = await import("../redis-store.js");
+      logger.info(`Connecting to Redis at ${config.host || config.url}`);
+      return new module2.RedisStore(config, logger);
+    } catch (error) {
+      const err = error;
+      if (err.code === "ERR_MODULE_NOT_FOUND") {
+        throw import_errors.StorageError.dependencyNotInstalled(
+          "Redis",
+          "ioredis",
+          "npm install ioredis"
+        );
+      }
+      throw error;
+    }
+  },
+  metadata: {
+    displayName: "Redis",
+    description: "Production Redis cache with TTL and pub/sub support",
+    requiresNetwork: true,
+    supportsTTL: true
+  }
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  redisCacheProvider
+});

package/dist/storage/cache/providers/redis.d.ts

@@ -0,0 +1,20 @@
+import type { CacheProvider } from '../provider.js';
+import type { RedisCacheConfig } from '../schemas.js';
+/**
+ * Provider for Redis cache storage.
+ *
+ * This provider stores data in a Redis server using the ioredis package.
+ * It's ideal for production deployments requiring scalability, persistence,
+ * and multi-machine access.
+ *
+ * Features:
+ * - Native TTL support
+ * - Connection pooling
+ * - Pub/sub capabilities (via additional methods)
+ * - Suitable for distributed deployments
+ *
+ * Note: ioredis is an optional dependency. Install it with:
+ * npm install ioredis
+ */
+export declare const redisCacheProvider: CacheProvider<'redis', RedisCacheConfig>;
+//# sourceMappingURL=redis.d.ts.map

package/dist/storage/cache/providers/redis.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"redis.d.ts","sourceRoot":"","sources":["../../../../src/storage/cache/providers/redis.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,gBAAgB,CAAC;AACpD,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,eAAe,CAAC;AAItD;;;;;;;;;;;;;;;GAeG;AACH,eAAO,MAAM,kBAAkB,EAAE,aAAa,CAAC,OAAO,EAAE,gBAAgB,CA0BvE,CAAC"}

package/dist/storage/cache/providers/redis.js

@@ -0,0 +1,33 @@
+import "../../../chunk-PTJYTZNU.js";
+import { RedisCacheSchema } from "../schemas.js";
+import { StorageError } from "../../errors.js";
+const redisCacheProvider = {
+  type: "redis",
+  configSchema: RedisCacheSchema,
+  create: async (config, logger) => {
+    try {
+      const module = await import("../redis-store.js");
+      logger.info(`Connecting to Redis at ${config.host || config.url}`);
+      return new module.RedisStore(config, logger);
+    } catch (error) {
+      const err = error;
+      if (err.code === "ERR_MODULE_NOT_FOUND") {
+        throw StorageError.dependencyNotInstalled(
+          "Redis",
+          "ioredis",
+          "npm install ioredis"
+        );
+      }
+      throw error;
+    }
+  },
+  metadata: {
+    displayName: "Redis",
+    description: "Production Redis cache with TTL and pub/sub support",
+    requiresNetwork: true,
+    supportsTTL: true
+  }
+};
+export {
+  redisCacheProvider
+};

package/dist/storage/cache/redis-store.js

@@ -1,4 +1,4 @@
-import "../../chunk-C6A6W6XS.js";
+import "../../chunk-PTJYTZNU.js";
 import { Redis } from "ioredis";
 import { DextoLogComponent } from "../../logger/v2/types.js";
 import { StorageError } from "../errors.js";

package/dist/{llm/tokenizer/google.cjs → storage/cache/registry.cjs}

@@ -16,37 +16,35 @@ var __copyProps = (to, from, except, desc) => {
   return to;
 };
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
-var google_exports = {};
-__export(google_exports, {
-  GoogleTokenizer: () => GoogleTokenizer
+var registry_exports = {};
+__export(registry_exports, {
+  CacheRegistry: () => CacheRegistry,
+  cacheRegistry: () => cacheRegistry
 });
-module.exports = __toCommonJS(google_exports);
-class GoogleTokenizer {
-  modelName;
-  /**
-   * Initializes the tokenizer for a specific Google Gemini model.
-   * Currently, the model name is not used due to the approximation.
-   * @param model The Google model name (e.g., 'gemini-pro')
-   */
-  constructor(model) {
-    this.modelName = model;
+module.exports = __toCommonJS(registry_exports);
+var import_errors = require("../errors.js");
+var import_base_registry = require("../../providers/base-registry.js");
+const cacheErrorFactory = {
+  alreadyRegistered: (type) => import_errors.StorageError.cacheProviderAlreadyRegistered(type),
+  notFound: (type, availableTypes) => import_errors.StorageError.unknownCacheProvider(type, availableTypes)
+};
+class CacheRegistry extends import_base_registry.BaseRegistry {
+  constructor() {
+    super(cacheErrorFactory);
   }
   /**
-   * Approximates the token count for Google Gemini models.
-   * Uses a rough guess based on character count (similar to Anthropic's approximation).
-   * IMPORTANT: This is NOT accurate for Gemini models.
-   * @param text Text content to count tokens for
-   * @returns Approximate number of tokens
+   * Get all registered providers.
+   * Alias for getAll() for backward compatibility.
+   *
+   * @returns Array of providers
    */
-  countTokens(text) {
-    if (!text) return 0;
-    return Math.ceil(text.length / 4);
-  }
-  getProviderName() {
-    return "google";
+  getProviders() {
+    return this.getAll();
   }
 }
+const cacheRegistry = new CacheRegistry();
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
-  GoogleTokenizer
+  CacheRegistry,
+  cacheRegistry
 });

package/dist/storage/cache/registry.d.ts

@@ -0,0 +1,42 @@
+import type { CacheProvider } from './provider.js';
+import { BaseRegistry } from '../../providers/base-registry.js';
+/**
+ * Registry for cache providers.
+ *
+ * This registry manages available cache implementations and provides
+ * runtime validation for configurations. Providers can be registered from
+ * both core (built-in) and application layers (custom).
+ *
+ * The registry follows a global singleton pattern to allow registration
+ * before configuration loading, while maintaining type safety through
+ * provider interfaces.
+ *
+ * Extends BaseRegistry for common registry functionality.
+ */
+export declare class CacheRegistry extends BaseRegistry<CacheProvider<any, any>> {
+    constructor();
+    /**
+     * Get all registered providers.
+     * Alias for getAll() for backward compatibility.
+     *
+     * @returns Array of providers
+     */
+    getProviders(): CacheProvider<any, any>[];
+}
+/**
+ * Global singleton registry for cache providers.
+ *
+ * This registry is used by the createCache factory and can be extended
+ * with custom providers before configuration loading.
+ *
+ * Example usage in CLI/server layer:
+ * ```typescript
+ * import { cacheRegistry } from '@dexto/core';
+ * import { memcachedProvider } from './storage/memcached-provider.js';
+ *
+ * // Register custom provider before loading config
+ * cacheRegistry.register(memcachedProvider);
+ * ```
+ */
+export declare const cacheRegistry: CacheRegistry;
+//# sourceMappingURL=registry.d.ts.map

package/dist/storage/cache/registry.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"registry.d.ts","sourceRoot":"","sources":["../../../src/storage/cache/registry.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,eAAe,CAAC;AAEnD,OAAO,EAAE,YAAY,EAA6B,MAAM,kCAAkC,CAAC;AAY3F;;;;;;;;;;;;GAYG;AACH,qBAAa,aAAc,SAAQ,YAAY,CAAC,aAAa,CAAC,GAAG,EAAE,GAAG,CAAC,CAAC;;IAKpE;;;;;OAKG;IACH,YAAY,IAAI,aAAa,CAAC,GAAG,EAAE,GAAG,CAAC,EAAE;CAG5C;AAED;;;;;;;;;;;;;;GAcG;AACH,eAAO,MAAM,aAAa,eAAsB,CAAC"}

package/dist/storage/cache/registry.js

@@ -0,0 +1,26 @@
+import "../../chunk-PTJYTZNU.js";
+import { StorageError } from "../errors.js";
+import { BaseRegistry } from "../../providers/base-registry.js";
+const cacheErrorFactory = {
+  alreadyRegistered: (type) => StorageError.cacheProviderAlreadyRegistered(type),
+  notFound: (type, availableTypes) => StorageError.unknownCacheProvider(type, availableTypes)
+};
+class CacheRegistry extends BaseRegistry {
+  constructor() {
+    super(cacheErrorFactory);
+  }
+  /**
+   * Get all registered providers.
+   * Alias for getAll() for backward compatibility.
+   *
+   * @returns Array of providers
+   */
+  getProviders() {
+    return this.getAll();
+  }
+}
+const cacheRegistry = new CacheRegistry();
+export {
+  CacheRegistry,
+  cacheRegistry
+};

package/dist/storage/cache/schemas.cjs

@@ -19,7 +19,9 @@ var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: tru
 var schemas_exports = {};
 __export(schemas_exports, {
   CACHE_TYPES: () => CACHE_TYPES,
-  CacheConfigSchema: () => CacheConfigSchema
+  CacheConfigSchema: () => CacheConfigSchema,
+  InMemoryCacheSchema: () => InMemoryCacheSchema,
+  RedisCacheSchema: () => RedisCacheSchema
 });
 module.exports = __toCommonJS(schemas_exports);
 var import_zod = require("zod");
@@ -73,5 +75,7 @@ const CacheConfigSchema = import_zod.z.discriminatedUnion("type", [InMemoryCache
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   CACHE_TYPES,
-  CacheConfigSchema
+  CacheConfigSchema,
+  InMemoryCacheSchema,
+  RedisCacheSchema
 });

package/dist/storage/cache/schemas.d.ts

@@ -1,7 +1,7 @@
 import { z } from 'zod';
 export declare const CACHE_TYPES: readonly ["in-memory", "redis"];
 export type CacheType = (typeof CACHE_TYPES)[number];
-declare const InMemoryCacheSchema: z.ZodObject<{
+export declare const InMemoryCacheSchema: z.ZodObject<{
     maxConnections: z.ZodOptional<z.ZodNumber>;
     idleTimeoutMillis: z.ZodOptional<z.ZodNumber>;
     connectionTimeoutMillis: z.ZodOptional<z.ZodNumber>;
@@ -22,7 +22,7 @@ declare const InMemoryCacheSchema: z.ZodObject<{
     connectionTimeoutMillis?: number | undefined;
 }>;
 export type InMemoryCacheConfig = z.output<typeof InMemoryCacheSchema>;
-declare const RedisCacheSchema: z.ZodObject<{
+export declare const RedisCacheSchema: z.ZodObject<{
     maxConnections: z.ZodOptional<z.ZodNumber>;
     idleTimeoutMillis: z.ZodOptional<z.ZodNumber>;
     connectionTimeoutMillis: z.ZodOptional<z.ZodNumber>;
@@ -147,5 +147,4 @@ export declare const CacheConfigSchema: z.ZodEffects<z.ZodDiscriminatedUnion<"ty
     database?: number | undefined;
 }>;
 export type CacheConfig = z.output<typeof CacheConfigSchema>;
-export {};
 //# sourceMappingURL=schemas.d.ts.map

package/dist/storage/cache/schemas.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"schemas.d.ts","sourceRoot":"","sources":["../../../src/storage/cache/schemas.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAKxB,eAAO,MAAM,WAAW,iCAAkC,CAAC;AAC3D,MAAM,MAAM,SAAS,GAAG,CAAC,OAAO,WAAW,CAAC,CAAC,MAAM,CAAC,CAAC;AAoBrD,QAAA,MAAM,mBAAmB;;;;;;;;;;;;;;;;;;;EAGd,CAAC;AAEZ,MAAM,MAAM,mBAAmB,GAAG,CAAC,CAAC,MAAM,CAAC,OAAO,mBAAmB,CAAC,CAAC;AAGvE,QAAA,MAAM,gBAAgB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAOX,CAAC;AAEZ,MAAM,MAAM,gBAAgB,GAAG,CAAC,CAAC,MAAM,CAAC,OAAO,gBAAgB,CAAC,CAAC;AAGjE,eAAO,MAAM,iBAAiB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EA4BxB,CAAC;AAEP,MAAM,MAAM,WAAW,GAAG,CAAC,CAAC,MAAM,CAAC,OAAO,iBAAiB,CAAC,CAAC"}
+{"version":3,"file":"schemas.d.ts","sourceRoot":"","sources":["../../../src/storage/cache/schemas.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAKxB,eAAO,MAAM,WAAW,iCAAkC,CAAC;AAC3D,MAAM,MAAM,SAAS,GAAG,CAAC,OAAO,WAAW,CAAC,CAAC,MAAM,CAAC,CAAC;AAoBrD,eAAO,MAAM,mBAAmB;;;;;;;;;;;;;;;;;;;EAGrB,CAAC;AAEZ,MAAM,MAAM,mBAAmB,GAAG,CAAC,CAAC,MAAM,CAAC,OAAO,mBAAmB,CAAC,CAAC;AAGvE,eAAO,MAAM,gBAAgB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAOlB,CAAC;AAEZ,MAAM,MAAM,gBAAgB,GAAG,CAAC,CAAC,MAAM,CAAC,OAAO,gBAAgB,CAAC,CAAC;AAGjE,eAAO,MAAM,iBAAiB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EA4BxB,CAAC;AAEP,MAAM,MAAM,WAAW,GAAG,CAAC,CAAC,MAAM,CAAC,OAAO,iBAAiB,CAAC,CAAC"}

package/dist/storage/cache/schemas.js

@@ -1,4 +1,4 @@
-import "../../chunk-C6A6W6XS.js";
+import "../../chunk-PTJYTZNU.js";
 import { z } from "zod";
 import { EnvExpandedString } from "../../utils/result.js";
 import { StorageErrorCode } from "../error-codes.js";
@@ -49,5 +49,7 @@ const CacheConfigSchema = z.discriminatedUnion("type", [InMemoryCacheSchema, Red
 });
 export {
   CACHE_TYPES,
-  CacheConfigSchema
+  CacheConfigSchema,
+  InMemoryCacheSchema,
+  RedisCacheSchema
 };