@dexto/core 1.3.0 → 1.5.0

package/dist/storage/blob/providers/local.cjs

@@ -0,0 +1,39 @@
+"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 local_exports = {};
+__export(local_exports, {
+  localBlobStoreProvider: () => localBlobStoreProvider
+});
+module.exports = __toCommonJS(local_exports);
+var import_schemas = require("../schemas.js");
+var import_local_blob_store = require("../local-blob-store.js");
+const localBlobStoreProvider = {
+  type: "local",
+  configSchema: import_schemas.LocalBlobStoreSchema,
+  create: (config, logger) => new import_local_blob_store.LocalBlobStore(config, logger),
+  metadata: {
+    displayName: "Local Filesystem",
+    description: "Store blobs on the local filesystem with automatic deduplication",
+    requiresNetwork: false
+  }
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  localBlobStoreProvider
+});

package/dist/storage/blob/providers/local.d.ts

@@ -0,0 +1,17 @@
+import type { BlobStoreProvider } from '../provider.js';
+import type { LocalBlobStoreConfig } from '../schemas.js';
+/**
+ * Provider for local filesystem blob storage.
+ *
+ * This provider stores blobs on the local filesystem with content-based
+ * deduplication and metadata tracking. It's ideal for development and
+ * single-machine deployments.
+ *
+ * Features:
+ * - Zero external dependencies (uses Node.js fs module)
+ * - Content-based deduplication (same hash = same blob)
+ * - Automatic cleanup of old blobs
+ * - No network required
+ */
+export declare const localBlobStoreProvider: BlobStoreProvider<'local', LocalBlobStoreConfig>;
+//# sourceMappingURL=local.d.ts.map

package/dist/storage/blob/providers/local.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"local.d.ts","sourceRoot":"","sources":["../../../../src/storage/blob/providers/local.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,gBAAgB,CAAC;AACxD,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,eAAe,CAAC;AAI1D;;;;;;;;;;;;GAYG;AACH,eAAO,MAAM,sBAAsB,EAAE,iBAAiB,CAAC,OAAO,EAAE,oBAAoB,CASnF,CAAC"}

package/dist/storage/blob/providers/local.js

@@ -0,0 +1,16 @@
+import "../../../chunk-PTJYTZNU.js";
+import { LocalBlobStoreSchema } from "../schemas.js";
+import { LocalBlobStore } from "../local-blob-store.js";
+const localBlobStoreProvider = {
+  type: "local",
+  configSchema: LocalBlobStoreSchema,
+  create: (config, logger) => new LocalBlobStore(config, logger),
+  metadata: {
+    displayName: "Local Filesystem",
+    description: "Store blobs on the local filesystem with automatic deduplication",
+    requiresNetwork: false
+  }
+};
+export {
+  localBlobStoreProvider
+};

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

@@ -0,0 +1,39 @@
+"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, {
+  inMemoryBlobStoreProvider: () => inMemoryBlobStoreProvider
+});
+module.exports = __toCommonJS(memory_exports);
+var import_schemas = require("../schemas.js");
+var import_memory_blob_store = require("../memory-blob-store.js");
+const inMemoryBlobStoreProvider = {
+  type: "in-memory",
+  configSchema: import_schemas.InMemoryBlobStoreSchema,
+  create: (config, logger) => new import_memory_blob_store.InMemoryBlobStore(config, logger),
+  metadata: {
+    displayName: "In-Memory",
+    description: "Store blobs in RAM (ephemeral, for testing and development)",
+    requiresNetwork: false
+  }
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  inMemoryBlobStoreProvider
+});

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

@@ -0,0 +1,17 @@
+import type { BlobStoreProvider } from '../provider.js';
+import type { InMemoryBlobStoreConfig } from '../schemas.js';
+/**
+ * Provider for in-memory blob storage.
+ *
+ * This provider stores blobs in RAM, making it ideal for testing and
+ * development. All data is lost when the process exits.
+ *
+ * Features:
+ * - Zero dependencies
+ * - Extremely fast (no I/O)
+ * - Configurable size limits
+ * - No network required
+ * - Perfect for unit tests
+ */
+export declare const inMemoryBlobStoreProvider: BlobStoreProvider<'in-memory', InMemoryBlobStoreConfig>;
+//# sourceMappingURL=memory.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"memory.d.ts","sourceRoot":"","sources":["../../../../src/storage/blob/providers/memory.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,gBAAgB,CAAC;AACxD,OAAO,KAAK,EAAE,uBAAuB,EAAE,MAAM,eAAe,CAAC;AAI7D;;;;;;;;;;;;GAYG;AACH,eAAO,MAAM,yBAAyB,EAAE,iBAAiB,CAAC,WAAW,EAAE,uBAAuB,CAS7F,CAAC"}

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

@@ -0,0 +1,16 @@
+import "../../../chunk-PTJYTZNU.js";
+import { InMemoryBlobStoreSchema } from "../schemas.js";
+import { InMemoryBlobStore } from "../memory-blob-store.js";
+const inMemoryBlobStoreProvider = {
+  type: "in-memory",
+  configSchema: InMemoryBlobStoreSchema,
+  create: (config, logger) => new InMemoryBlobStore(config, logger),
+  metadata: {
+    displayName: "In-Memory",
+    description: "Store blobs in RAM (ephemeral, for testing and development)",
+    requiresNetwork: false
+  }
+};
+export {
+  inMemoryBlobStoreProvider
+};

package/dist/storage/blob/registry.cjs

@@ -0,0 +1,50 @@
+"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 registry_exports = {};
+__export(registry_exports, {
+  BlobStoreRegistry: () => BlobStoreRegistry,
+  blobStoreRegistry: () => blobStoreRegistry
+});
+module.exports = __toCommonJS(registry_exports);
+var import_errors = require("../errors.js");
+var import_base_registry = require("../../providers/base-registry.js");
+const blobStoreErrorFactory = {
+  alreadyRegistered: (type) => import_errors.StorageError.blobProviderAlreadyRegistered(type),
+  notFound: (type, availableTypes) => import_errors.StorageError.unknownBlobProvider(type, availableTypes)
+};
+class BlobStoreRegistry extends import_base_registry.BaseRegistry {
+  constructor() {
+    super(blobStoreErrorFactory);
+  }
+  /**
+   * Get all registered providers.
+   * Alias for getAll() for backward compatibility.
+   *
+   * @returns Array of providers
+   */
+  getProviders() {
+    return this.getAll();
+  }
+}
+const blobStoreRegistry = new BlobStoreRegistry();
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  BlobStoreRegistry,
+  blobStoreRegistry
+});

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

@@ -0,0 +1,42 @@
+import type { BlobStoreProvider } from './provider.js';
+import { BaseRegistry } from '../../providers/base-registry.js';
+/**
+ * Registry for blob store providers.
+ *
+ * This registry manages available blob store 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 BlobStoreRegistry extends BaseRegistry<BlobStoreProvider<any, any>> {
+    constructor();
+    /**
+     * Get all registered providers.
+     * Alias for getAll() for backward compatibility.
+     *
+     * @returns Array of providers
+     */
+    getProviders(): BlobStoreProvider<any, any>[];
+}
+/**
+ * Global singleton registry for blob store providers.
+ *
+ * This registry is used by the createBlobStore factory and can be extended
+ * with custom providers before configuration loading.
+ *
+ * Example usage in CLI/server layer:
+ * ```typescript
+ * import { blobStoreRegistry } from '@dexto/core';
+ * import { s3Provider } from './storage/s3-provider.js';
+ *
+ * // Register custom provider before loading config
+ * blobStoreRegistry.register(s3Provider);
+ * ```
+ */
+export declare const blobStoreRegistry: BlobStoreRegistry;
+//# sourceMappingURL=registry.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"registry.d.ts","sourceRoot":"","sources":["../../../src/storage/blob/registry.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,eAAe,CAAC;AAEvD,OAAO,EAAE,YAAY,EAA6B,MAAM,kCAAkC,CAAC;AAY3F;;;;;;;;;;;;GAYG;AACH,qBAAa,iBAAkB,SAAQ,YAAY,CAAC,iBAAiB,CAAC,GAAG,EAAE,GAAG,CAAC,CAAC;;IAK5E;;;;;OAKG;IACH,YAAY,IAAI,iBAAiB,CAAC,GAAG,EAAE,GAAG,CAAC,EAAE;CAGhD;AAED;;;;;;;;;;;;;;GAcG;AACH,eAAO,MAAM,iBAAiB,mBAA0B,CAAC"}

package/dist/storage/blob/registry.js

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

package/dist/storage/blob/schemas.cjs

@@ -19,7 +19,9 @@ var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: tru
 var schemas_exports = {};
 __export(schemas_exports, {
   BLOB_STORE_TYPES: () => BLOB_STORE_TYPES,
-  BlobStoreConfigSchema: () => BlobStoreConfigSchema
+  BlobStoreConfigSchema: () => BlobStoreConfigSchema,
+  InMemoryBlobStoreSchema: () => InMemoryBlobStoreSchema,
+  LocalBlobStoreSchema: () => LocalBlobStoreSchema
 });
 module.exports = __toCommonJS(schemas_exports);
 var import_zod = require("zod");
@@ -38,18 +40,13 @@ const LocalBlobStoreSchema = import_zod.z.object({
   maxTotalSize: import_zod.z.number().int().positive().optional().default(1024 * 1024 * 1024).describe("Maximum total storage size in bytes"),
   cleanupAfterDays: import_zod.z.number().int().positive().optional().default(30).describe("Auto-cleanup blobs older than N days")
 }).strict();
-const BlobStoreConfigSchema = import_zod.z.discriminatedUnion("type", [InMemoryBlobStoreSchema, LocalBlobStoreSchema], {
-  errorMap: (issue, ctx) => {
-    if (issue.code === import_zod.z.ZodIssueCode.invalid_union_discriminator) {
-      return {
-        message: `Invalid blob store type. Expected 'in-memory' or 'local'.`
-      };
-    }
-    return { message: ctx.defaultError };
-  }
-}).describe("Blob store configuration");
+const BlobStoreConfigSchema = import_zod.z.object({
+  type: import_zod.z.string().describe("Blob store provider type")
+}).passthrough().describe("Blob store configuration (validated at runtime by provider registry)");
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   BLOB_STORE_TYPES,
-  BlobStoreConfigSchema
+  BlobStoreConfigSchema,
+  InMemoryBlobStoreSchema,
+  LocalBlobStoreSchema
 });

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

@@ -1,4 +1,8 @@
 import { z } from 'zod';
+/**
+ * Built-in blob store types (core providers only).
+ * Custom providers registered at runtime are not included in this list.
+ */
 export declare const BLOB_STORE_TYPES: readonly ["in-memory", "local"];
 export type BlobStoreType = (typeof BLOB_STORE_TYPES)[number];
 /**
@@ -42,39 +46,40 @@ declare const LocalBlobStoreSchema: z.ZodObject<{
 }>;
 export type LocalBlobStoreConfig = z.output<typeof LocalBlobStoreSchema>;
 /**
- * Blob store configuration using discriminated union
+ * Blob store configuration schema.
+ *
+ * This schema uses `.passthrough()` to accept any provider-specific configuration.
+ * It only validates that a `type` field exists as a string.
+ *
+ * Detailed validation happens at runtime via blobStoreRegistry.validateConfig(),
+ * which looks up the registered provider and validates against its specific schema.
+ *
+ * This approach allows:
+ * - Custom providers to be registered at the CLI/server layer
+ * - Each provider to define its own configuration structure
+ * - Type safety through the provider registry pattern
+ *
+ * Example flow:
+ * 1. Config passes this schema (basic structure check)
+ * 2. blobStoreRegistry.validateConfig(config) validates against provider schema
+ * 3. Provider's create() method receives validated, typed config
  */
-export declare const BlobStoreConfigSchema: z.ZodDiscriminatedUnion<"type", [z.ZodObject<{
-    type: z.ZodLiteral<"in-memory">;
-    maxBlobSize: z.ZodDefault<z.ZodOptional<z.ZodNumber>>;
-    maxTotalSize: z.ZodDefault<z.ZodOptional<z.ZodNumber>>;
-}, "strict", z.ZodTypeAny, {
-    type: "in-memory";
-    maxBlobSize: number;
-    maxTotalSize: number;
-}, {
-    type: "in-memory";
-    maxBlobSize?: number | undefined;
-    maxTotalSize?: number | undefined;
-}>, z.ZodObject<{
-    type: z.ZodLiteral<"local">;
-    storePath: z.ZodString;
-    maxBlobSize: z.ZodDefault<z.ZodOptional<z.ZodNumber>>;
-    maxTotalSize: z.ZodDefault<z.ZodOptional<z.ZodNumber>>;
-    cleanupAfterDays: z.ZodDefault<z.ZodOptional<z.ZodNumber>>;
-}, "strict", z.ZodTypeAny, {
-    type: "local";
-    maxBlobSize: number;
-    maxTotalSize: number;
-    storePath: string;
-    cleanupAfterDays: number;
-}, {
-    type: "local";
-    storePath: string;
-    maxBlobSize?: number | undefined;
-    maxTotalSize?: number | undefined;
-    cleanupAfterDays?: number | undefined;
-}>]>;
-export type BlobStoreConfig = z.output<typeof BlobStoreConfigSchema>;
-export {};
+export declare const BlobStoreConfigSchema: z.ZodObject<{
+    type: z.ZodString;
+}, "passthrough", z.ZodTypeAny, z.objectOutputType<{
+    type: z.ZodString;
+}, z.ZodTypeAny, "passthrough">, z.objectInputType<{
+    type: z.ZodString;
+}, z.ZodTypeAny, "passthrough">>;
+/**
+ * Blob store configuration type.
+ *
+ * Union type including built-in providers (local, in-memory) and a catch-all
+ * for custom providers registered at runtime.
+ */
+export type BlobStoreConfig = InMemoryBlobStoreConfig | LocalBlobStoreConfig | {
+    type: string;
+    [key: string]: any;
+};
+export { InMemoryBlobStoreSchema, LocalBlobStoreSchema };
 //# sourceMappingURL=schemas.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"schemas.d.ts","sourceRoot":"","sources":["../../../src/storage/blob/schemas.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAExB,eAAO,MAAM,gBAAgB,iCAAkC,CAAC;AAChE,MAAM,MAAM,aAAa,GAAG,CAAC,OAAO,gBAAgB,CAAC,CAAC,MAAM,CAAC,CAAC;AAE9D;;GAEG;AACH,QAAA,MAAM,uBAAuB;;;;;;;;;;;;EAkBhB,CAAC;AAEd,MAAM,MAAM,uBAAuB,GAAG,CAAC,CAAC,MAAM,CAAC,OAAO,uBAAuB,CAAC,CAAC;AAE/E;;GAEG;AACH,QAAA,MAAM,oBAAoB;;;;;;;;;;;;;;;;;;EA8Bb,CAAC;AAEd,MAAM,MAAM,oBAAoB,GAAG,CAAC,CAAC,MAAM,CAAC,OAAO,oBAAoB,CAAC,CAAC;AAEzE;;GAEG;AACH,eAAO,MAAM,qBAAqB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;IAWO,CAAC;AAE1C,MAAM,MAAM,eAAe,GAAG,CAAC,CAAC,MAAM,CAAC,OAAO,qBAAqB,CAAC,CAAC"}
+{"version":3,"file":"schemas.d.ts","sourceRoot":"","sources":["../../../src/storage/blob/schemas.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAExB;;;GAGG;AACH,eAAO,MAAM,gBAAgB,iCAAkC,CAAC;AAChE,MAAM,MAAM,aAAa,GAAG,CAAC,OAAO,gBAAgB,CAAC,CAAC,MAAM,CAAC,CAAC;AAE9D;;GAEG;AACH,QAAA,MAAM,uBAAuB;;;;;;;;;;;;EAkBhB,CAAC;AAEd,MAAM,MAAM,uBAAuB,GAAG,CAAC,CAAC,MAAM,CAAC,OAAO,uBAAuB,CAAC,CAAC;AAE/E;;GAEG;AACH,QAAA,MAAM,oBAAoB;;;;;;;;;;;;;;;;;;EA8Bb,CAAC;AAEd,MAAM,MAAM,oBAAoB,GAAG,CAAC,CAAC,MAAM,CAAC,OAAO,oBAAoB,CAAC,CAAC;AAEzE;;;;;;;;;;;;;;;;;;GAkBG;AACH,eAAO,MAAM,qBAAqB;;;;;;gCAKmD,CAAC;AAEtF;;;;;GAKG;AACH,MAAM,MAAM,eAAe,GACrB,uBAAuB,GACvB,oBAAoB,GACpB;IAAE,IAAI,EAAE,MAAM,CAAC;IAAC,CAAC,GAAG,EAAE,MAAM,GAAG,GAAG,CAAA;CAAE,CAAC;AAG3C,OAAO,EAAE,uBAAuB,EAAE,oBAAoB,EAAE,CAAC"}

package/dist/storage/blob/schemas.js

@@ -1,4 +1,4 @@
-import "../../chunk-C6A6W6XS.js";
+import "../../chunk-PTJYTZNU.js";
 import { z } from "zod";
 const BLOB_STORE_TYPES = ["in-memory", "local"];
 const InMemoryBlobStoreSchema = z.object({
@@ -15,17 +15,12 @@ const LocalBlobStoreSchema = z.object({
   maxTotalSize: z.number().int().positive().optional().default(1024 * 1024 * 1024).describe("Maximum total storage size in bytes"),
   cleanupAfterDays: z.number().int().positive().optional().default(30).describe("Auto-cleanup blobs older than N days")
 }).strict();
-const BlobStoreConfigSchema = z.discriminatedUnion("type", [InMemoryBlobStoreSchema, LocalBlobStoreSchema], {
-  errorMap: (issue, ctx) => {
-    if (issue.code === z.ZodIssueCode.invalid_union_discriminator) {
-      return {
-        message: `Invalid blob store type. Expected 'in-memory' or 'local'.`
-      };
-    }
-    return { message: ctx.defaultError };
-  }
-}).describe("Blob store configuration");
+const BlobStoreConfigSchema = z.object({
+  type: z.string().describe("Blob store provider type")
+}).passthrough().describe("Blob store configuration (validated at runtime by provider registry)");
 export {
   BLOB_STORE_TYPES,
-  BlobStoreConfigSchema
+  BlobStoreConfigSchema,
+  InMemoryBlobStoreSchema,
+  LocalBlobStoreSchema
 };

package/dist/storage/cache/factory.cjs

@@ -1,9 +1,7 @@
 "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)
@@ -17,48 +15,22 @@ var __copyProps = (to, from, except, desc) => {
   }
   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 factory_exports = {};
 __export(factory_exports, {
   createCache: () => createCache
 });
 module.exports = __toCommonJS(factory_exports);
-var import_memory_cache_store = require("./memory-cache-store.js");
-var import_errors = require("../errors.js");
-let RedisStore = null;
+var import_registry = require("./registry.js");
 async function createCache(config, logger) {
-  switch (config.type) {
-    case "redis":
-      return createRedisStore(config, logger);
-    case "in-memory":
-    default:
-      logger.info("Using in-memory cache store");
-      return new import_memory_cache_store.MemoryCacheStore();
-  }
-}
-async function createRedisStore(config, logger) {
-  try {
-    if (!RedisStore) {
-      const module2 = await import("./redis-store.js");
-      RedisStore = module2.RedisStore;
-    }
-    logger.info(`Connecting to Redis at ${config.host}:${config.port}`);
-    return new 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;
+  const validatedConfig = import_registry.cacheRegistry.validateConfig(config);
+  const provider = import_registry.cacheRegistry.get(validatedConfig.type);
+  if (!provider) {
+    throw new Error(`Provider '${validatedConfig.type}' not found in registry`);
   }
+  const providerName = provider.metadata?.displayName || validatedConfig.type;
+  logger.info(`Using ${providerName} cache`);
+  return provider.create(validatedConfig, logger);
 }
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {

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

@@ -1,12 +1,37 @@
 import type { Cache } from './types.js';
-import type { CacheConfig } from '../schemas.js';
 import type { IDextoLogger } from '../../logger/v2/types.js';
 /**
- * Create a cache store based on configuration.
- * Handles lazy loading of optional dependencies.
- * Throws StorageError.dependencyNotInstalled if required package is missing.
- * @param config Cache configuration
- * @param logger Logger instance for logging
+ * Create a cache based on configuration using the provider registry.
+ *
+ * This factory function:
+ * 1. Validates the configuration against the registered provider's schema
+ * 2. Looks up the provider in the registry
+ * 3. Calls the provider's create method to instantiate the cache
+ *
+ * The configuration type is determined at runtime by the 'type' field,
+ * which must match a registered provider. Custom providers can be registered
+ * via cacheRegistry.register() before calling this function.
+ *
+ * @param config - Cache configuration with a 'type' discriminator
+ * @param logger - Logger instance for the cache
+ * @returns A Cache implementation
+ * @throws Error if the provider type is not registered or validation fails
+ *
+ * @example
+ * ```typescript
+ * // Using built-in provider
+ * const cache = await createCache({ type: 'redis', host: 'localhost' }, logger);
+ *
+ * // Using custom provider (registered beforehand)
+ * import { cacheRegistry } from '@dexto/core';
+ * import { memcachedProvider } from './storage/memcached-provider.js';
+ *
+ * cacheRegistry.register(memcachedProvider);
+ * const cache = await createCache({ type: 'memcached', servers: ['...'] }, logger);
+ * ```
  */
-export declare function createCache(config: CacheConfig, logger: IDextoLogger): Promise<Cache>;
+export declare function createCache(config: {
+    type: string;
+    [key: string]: any;
+}, logger: IDextoLogger): Promise<Cache>;
 //# sourceMappingURL=factory.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"factory.d.ts","sourceRoot":"","sources":["../../../src/storage/cache/factory.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,YAAY,CAAC;AACxC,OAAO,KAAK,EAAoB,WAAW,EAAE,MAAM,eAAe,CAAC;AAEnE,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,0BAA0B,CAAC;AAW7D;;;;;;GAMG;AACH,wBAAsB,WAAW,CAAC,MAAM,EAAE,WAAW,EAAE,MAAM,EAAE,YAAY,GAAG,OAAO,CAAC,KAAK,CAAC,CAU3F"}
+{"version":3,"file":"factory.d.ts","sourceRoot":"","sources":["../../../src/storage/cache/factory.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,YAAY,CAAC;AACxC,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,0BAA0B,CAAC;AAG7D;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA6BG;AACH,wBAAsB,WAAW,CAC7B,MAAM,EAAE;IAAE,IAAI,EAAE,MAAM,CAAC;IAAC,CAAC,GAAG,EAAE,MAAM,GAAG,GAAG,CAAA;CAAE,EAC5C,MAAM,EAAE,YAAY,GACrB,OAAO,CAAC,KAAK,CAAC,CAgBhB"}

package/dist/storage/cache/factory.js

@@ -1,32 +1,14 @@
-import "../../chunk-C6A6W6XS.js";
-import { MemoryCacheStore } from "./memory-cache-store.js";
-import { StorageError } from "../errors.js";
-let RedisStore = null;
+import "../../chunk-PTJYTZNU.js";
+import { cacheRegistry } from "./registry.js";
 async function createCache(config, logger) {
-  switch (config.type) {
-    case "redis":
-      return createRedisStore(config, logger);
-    case "in-memory":
-    default:
-      logger.info("Using in-memory cache store");
-      return new MemoryCacheStore();
-  }
-}
-async function createRedisStore(config, logger) {
-  try {
-    if (!RedisStore) {
-      const module = await import("./redis-store.js");
-      RedisStore = module.RedisStore;
-    }
-    logger.info(`Connecting to Redis at ${config.host}:${config.port}`);
-    return new 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;
+  const validatedConfig = cacheRegistry.validateConfig(config);
+  const provider = cacheRegistry.get(validatedConfig.type);
+  if (!provider) {
+    throw new Error(`Provider '${validatedConfig.type}' not found in registry`);
   }
+  const providerName = provider.metadata?.displayName || validatedConfig.type;
+  logger.info(`Using ${providerName} cache`);
+  return provider.create(validatedConfig, logger);
 }
 export {
   createCache

package/dist/storage/cache/index.cjs

@@ -0,0 +1,53 @@
+"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 cache_exports = {};
+__export(cache_exports, {
+  CACHE_TYPES: () => import_schemas.CACHE_TYPES,
+  CacheConfigSchema: () => import_schemas.CacheConfigSchema,
+  CacheRegistry: () => import_registry2.CacheRegistry,
+  InMemoryCacheSchema: () => import_schemas.InMemoryCacheSchema,
+  MemoryCacheStore: () => import_memory_cache_store.MemoryCacheStore,
+  RedisCacheSchema: () => import_schemas.RedisCacheSchema,
+  cacheRegistry: () => import_registry2.cacheRegistry,
+  createCache: () => import_factory.createCache
+});
+module.exports = __toCommonJS(cache_exports);
+var import_registry = require("./registry.js");
+var import_providers = require("./providers/index.js");
+var import_factory = require("./factory.js");
+var import_registry2 = require("./registry.js");
+var import_schemas = require("./schemas.js");
+var import_memory_cache_store = require("./memory-cache-store.js");
+if (!import_registry.cacheRegistry.has("in-memory")) {
+  import_registry.cacheRegistry.register(import_providers.inMemoryCacheProvider);
+}
+if (!import_registry.cacheRegistry.has("redis")) {
+  import_registry.cacheRegistry.register(import_providers.redisCacheProvider);
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  CACHE_TYPES,
+  CacheConfigSchema,
+  CacheRegistry,
+  InMemoryCacheSchema,
+  MemoryCacheStore,
+  RedisCacheSchema,
+  cacheRegistry,
+  createCache
+});