@dexto/core 1.4.0 → 1.5.0

package/dist/storage/blob/factory.cjs

@@ -21,19 +21,16 @@ __export(factory_exports, {
   createBlobStore: () => createBlobStore
 });
 module.exports = __toCommonJS(factory_exports);
-var import_local_blob_store = require("./local-blob-store.js");
-var import_memory_blob_store = require("./memory-blob-store.js");
+var import_registry = require("./registry.js");
 function createBlobStore(config, logger) {
-  switch (config.type) {
-    case "in-memory":
-      logger.info("Using in-memory blob store");
-      return new import_memory_blob_store.InMemoryBlobStore(config, logger);
-    case "local":
-      logger.info("Using local file-based blob store");
-      return new import_local_blob_store.LocalBlobStore(config, logger);
-    default:
-      throw new Error(`Unknown blob store type: ${config.type}`);
+  const validatedConfig = import_registry.blobStoreRegistry.validateConfig(config);
+  const provider = import_registry.blobStoreRegistry.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} blob store`);
+  return provider.create(validatedConfig, logger);
 }
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {

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

@@ -1,11 +1,37 @@
 import type { BlobStore } from './types.js';
-import type { BlobStoreConfig } from './schemas.js';
 import type { IDextoLogger } from '../../logger/v2/types.js';
 /**
- * Create a blob store based on configuration.
- * Blob paths are provided via CLI enrichment layer for local storage.
- * @param config Blob store configuration
- * @param logger Logger instance for logging
+ * Create a blob store 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 blob store
+ *
+ * The configuration type is determined at runtime by the 'type' field,
+ * which must match a registered provider. Custom providers can be registered
+ * via blobStoreRegistry.register() before calling this function.
+ *
+ * @param config - Blob store configuration with a 'type' discriminator
+ * @param logger - Logger instance for the blob store
+ * @returns A BlobStore implementation
+ * @throws Error if the provider type is not registered or validation fails
+ *
+ * @example
+ * ```typescript
+ * // Using built-in provider
+ * const blob = createBlobStore({ type: 'local', storePath: '/tmp/blobs' }, logger);
+ *
+ * // Using custom provider (registered beforehand)
+ * import { blobStoreRegistry } from '@dexto/core';
+ * import { s3Provider } from './storage/s3-provider.js';
+ *
+ * blobStoreRegistry.register(s3Provider);
+ * const blob = createBlobStore({ type: 's3', bucket: 'my-bucket' }, logger);
+ * ```
  */
-export declare function createBlobStore(config: BlobStoreConfig, logger: IDextoLogger): BlobStore;
+export declare function createBlobStore(config: {
+    type: string;
+    [key: string]: any;
+}, logger: IDextoLogger): BlobStore;
 //# sourceMappingURL=factory.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"factory.d.ts","sourceRoot":"","sources":["../../../src/storage/blob/factory.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,YAAY,CAAC;AAC5C,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,cAAc,CAAC;AAGpD,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,0BAA0B,CAAC;AAE7D;;;;;GAKG;AACH,wBAAgB,eAAe,CAAC,MAAM,EAAE,eAAe,EAAE,MAAM,EAAE,YAAY,GAAG,SAAS,CAaxF"}
+{"version":3,"file":"factory.d.ts","sourceRoot":"","sources":["../../../src/storage/blob/factory.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,YAAY,CAAC;AAC5C,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,0BAA0B,CAAC;AAG7D;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA6BG;AACH,wBAAgB,eAAe,CAC3B,MAAM,EAAE;IAAE,IAAI,EAAE,MAAM,CAAC;IAAC,CAAC,GAAG,EAAE,MAAM,GAAG,GAAG,CAAA;CAAE,EAC5C,MAAM,EAAE,YAAY,GACrB,SAAS,CAgBX"}

package/dist/storage/blob/factory.js

@@ -1,17 +1,14 @@
 import "../../chunk-PTJYTZNU.js";
-import { LocalBlobStore } from "./local-blob-store.js";
-import { InMemoryBlobStore } from "./memory-blob-store.js";
+import { blobStoreRegistry } from "./registry.js";
 function createBlobStore(config, logger) {
-  switch (config.type) {
-    case "in-memory":
-      logger.info("Using in-memory blob store");
-      return new InMemoryBlobStore(config, logger);
-    case "local":
-      logger.info("Using local file-based blob store");
-      return new LocalBlobStore(config, logger);
-    default:
-      throw new Error(`Unknown blob store type: ${config.type}`);
+  const validatedConfig = blobStoreRegistry.validateConfig(config);
+  const provider = blobStoreRegistry.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} blob store`);
+  return provider.create(validatedConfig, logger);
 }
 export {
   createBlobStore

package/dist/storage/blob/index.cjs

@@ -0,0 +1,56 @@
+"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 blob_exports = {};
+__export(blob_exports, {
+  BLOB_STORE_TYPES: () => import_schemas.BLOB_STORE_TYPES,
+  BlobStoreConfigSchema: () => import_schemas.BlobStoreConfigSchema,
+  BlobStoreRegistry: () => import_registry2.BlobStoreRegistry,
+  InMemoryBlobStore: () => import_memory_blob_store.InMemoryBlobStore,
+  InMemoryBlobStoreSchema: () => import_schemas.InMemoryBlobStoreSchema,
+  LocalBlobStore: () => import_local_blob_store.LocalBlobStore,
+  LocalBlobStoreSchema: () => import_schemas.LocalBlobStoreSchema,
+  blobStoreRegistry: () => import_registry2.blobStoreRegistry,
+  createBlobStore: () => import_factory.createBlobStore
+});
+module.exports = __toCommonJS(blob_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_local_blob_store = require("./local-blob-store.js");
+var import_memory_blob_store = require("./memory-blob-store.js");
+if (!import_registry.blobStoreRegistry.has("local")) {
+  import_registry.blobStoreRegistry.register(import_providers.localBlobStoreProvider);
+}
+if (!import_registry.blobStoreRegistry.has("in-memory")) {
+  import_registry.blobStoreRegistry.register(import_providers.inMemoryBlobStoreProvider);
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  BLOB_STORE_TYPES,
+  BlobStoreConfigSchema,
+  BlobStoreRegistry,
+  InMemoryBlobStore,
+  InMemoryBlobStoreSchema,
+  LocalBlobStore,
+  LocalBlobStoreSchema,
+  blobStoreRegistry,
+  createBlobStore
+});

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

@@ -0,0 +1,45 @@
+/**
+ * Blob Storage Module
+ *
+ * This module provides a flexible blob storage system with support for
+ * multiple backends through a provider pattern.
+ *
+ * ## Built-in Providers
+ * - `local`: Store blobs on the local filesystem
+ * - `in-memory`: Store blobs in RAM (for testing/development)
+ *
+ * ## Custom Providers
+ * Custom providers (e.g., S3, Azure, Supabase) can be registered at the
+ * CLI/server layer before configuration loading.
+ *
+ * ## Usage
+ *
+ * ### Using built-in providers
+ * ```typescript
+ * import { createBlobStore } from '@dexto/core';
+ *
+ * const blob = createBlobStore({ type: 'local', storePath: '/tmp' }, logger);
+ * ```
+ *
+ * ### Registering custom providers
+ * ```typescript
+ * import { blobStoreRegistry, type BlobStoreProvider } from '@dexto/core';
+ *
+ * const s3Provider: BlobStoreProvider<'s3', S3Config> = {
+ *   type: 's3',
+ *   configSchema: S3ConfigSchema,
+ *   create: (config, logger) => new S3BlobStore(config, logger),
+ * };
+ *
+ * blobStoreRegistry.register(s3Provider);
+ * const blob = createBlobStore({ type: 's3', bucket: 'my-bucket' }, logger);
+ * ```
+ */
+export { createBlobStore } from './factory.js';
+export { blobStoreRegistry, BlobStoreRegistry } from './registry.js';
+export type { BlobStoreProvider } from './provider.js';
+export type { BlobStore, BlobInput, BlobMetadata, BlobReference, BlobData, BlobStats, StoredBlobMetadata, } from './types.js';
+export { BLOB_STORE_TYPES, BlobStoreConfigSchema, InMemoryBlobStoreSchema, LocalBlobStoreSchema, type BlobStoreType, type BlobStoreConfig, type InMemoryBlobStoreConfig, type LocalBlobStoreConfig, } from './schemas.js';
+export { LocalBlobStore } from './local-blob-store.js';
+export { InMemoryBlobStore } from './memory-blob-store.js';
+//# sourceMappingURL=index.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/storage/blob/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAoCG;AAiBH,OAAO,EAAE,eAAe,EAAE,MAAM,cAAc,CAAC;AAC/C,OAAO,EAAE,iBAAiB,EAAE,iBAAiB,EAAE,MAAM,eAAe,CAAC;AACrE,YAAY,EAAE,iBAAiB,EAAE,MAAM,eAAe,CAAC;AAGvD,YAAY,EACR,SAAS,EACT,SAAS,EACT,YAAY,EACZ,aAAa,EACb,QAAQ,EACR,SAAS,EACT,kBAAkB,GACrB,MAAM,YAAY,CAAC;AAGpB,OAAO,EACH,gBAAgB,EAChB,qBAAqB,EACrB,uBAAuB,EACvB,oBAAoB,EACpB,KAAK,aAAa,EAClB,KAAK,eAAe,EACpB,KAAK,uBAAuB,EAC5B,KAAK,oBAAoB,GAC5B,MAAM,cAAc,CAAC;AAGtB,OAAO,EAAE,cAAc,EAAE,MAAM,uBAAuB,CAAC;AACvD,OAAO,EAAE,iBAAiB,EAAE,MAAM,wBAAwB,CAAC"}

package/dist/storage/blob/index.js

@@ -0,0 +1,30 @@
+import "../../chunk-PTJYTZNU.js";
+import { blobStoreRegistry } from "./registry.js";
+import { localBlobStoreProvider, inMemoryBlobStoreProvider } from "./providers/index.js";
+if (!blobStoreRegistry.has("local")) {
+  blobStoreRegistry.register(localBlobStoreProvider);
+}
+if (!blobStoreRegistry.has("in-memory")) {
+  blobStoreRegistry.register(inMemoryBlobStoreProvider);
+}
+import { createBlobStore } from "./factory.js";
+import { blobStoreRegistry as blobStoreRegistry2, BlobStoreRegistry } from "./registry.js";
+import {
+  BLOB_STORE_TYPES,
+  BlobStoreConfigSchema,
+  InMemoryBlobStoreSchema,
+  LocalBlobStoreSchema
+} from "./schemas.js";
+import { LocalBlobStore } from "./local-blob-store.js";
+import { InMemoryBlobStore } from "./memory-blob-store.js";
+export {
+  BLOB_STORE_TYPES,
+  BlobStoreConfigSchema,
+  BlobStoreRegistry,
+  InMemoryBlobStore,
+  InMemoryBlobStoreSchema,
+  LocalBlobStore,
+  LocalBlobStoreSchema,
+  blobStoreRegistry2 as blobStoreRegistry,
+  createBlobStore
+};

package/dist/storage/blob/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/blob/provider.d.ts

@@ -0,0 +1,50 @@
+import type { z } from 'zod';
+import type { BlobStore } from './types.js';
+import type { IDextoLogger } from '../../logger/v2/types.js';
+/**
+ * Provider interface for creating blob store instances.
+ *
+ * This interface uses TypeScript generics to enforce type safety:
+ * - TType: The literal type string (e.g., 'local', 's3')
+ * - 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 BlobStoreProvider<TType extends string = string, TConfig extends {
+    type: TType;
+} = any> {
+    /**
+     * Unique identifier for this provider (e.g., 'local', 'supabase', 's3').
+     * 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 BlobStore instance.
+     * @param config - Validated configuration specific to this provider
+     * @param logger - Logger instance for the blob store
+     * @returns A BlobStore implementation
+     */
+    create(config: TConfig, logger: IDextoLogger): BlobStore;
+    /**
+     * Optional metadata for documentation, UIs, and discovery.
+     */
+    metadata?: {
+        /** Human-readable name (e.g., "Local Filesystem", "Amazon S3") */
+        displayName: string;
+        /** Brief description of this storage backend */
+        description: string;
+        /** Whether this provider requires network connectivity */
+        requiresNetwork?: boolean;
+    };
+}
+//# sourceMappingURL=provider.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"provider.d.ts","sourceRoot":"","sources":["../../../src/storage/blob/provider.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAC7B,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,YAAY,CAAC;AAC5C,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,0BAA0B,CAAC;AAE7D;;;;;;;;;GASG;AACH,MAAM,WAAW,iBAAiB,CAC9B,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;;;;;OAKG;IACH,MAAM,CAAC,MAAM,EAAE,OAAO,EAAE,MAAM,EAAE,YAAY,GAAG,SAAS,CAAC;IAEzD;;OAEG;IACH,QAAQ,CAAC,EAAE;QACP,kEAAkE;QAClE,WAAW,EAAE,MAAM,CAAC;QACpB,gDAAgD;QAChD,WAAW,EAAE,MAAM,CAAC;QACpB,0DAA0D;QAC1D,eAAe,CAAC,EAAE,OAAO,CAAC;KAC7B,CAAC;CACL"}

package/dist/storage/blob/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, {
+  inMemoryBlobStoreProvider: () => import_memory.inMemoryBlobStoreProvider,
+  localBlobStoreProvider: () => import_local.localBlobStoreProvider
+});
+module.exports = __toCommonJS(providers_exports);
+var import_local = require("./local.js");
+var import_memory = require("./memory.js");
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  inMemoryBlobStoreProvider,
+  localBlobStoreProvider
+});

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

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

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

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

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

@@ -0,0 +1,7 @@
+import "../../../chunk-PTJYTZNU.js";
+import { localBlobStoreProvider } from "./local.js";
+import { inMemoryBlobStoreProvider } from "./memory.js";
+export {
+  inMemoryBlobStoreProvider,
+  localBlobStoreProvider
+};

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"}