@dexto/storage 1.6.0 → 1.6.2

package/dist/schemas.d.cts

@@ -1,7 +1,302 @@
 import { z } from 'zod';
-export { CACHE_TYPES, CacheConfig, CacheConfigSchema, CacheType, InMemoryCacheConfig, InMemoryCacheSchema, RedisCacheConfig, RedisCacheSchema } from './cache/schemas.cjs';
-export { DATABASE_TYPES, DatabaseConfig, DatabaseConfigSchema, DatabaseType, InMemoryDatabaseConfig, InMemoryDatabaseSchema, PostgresDatabaseConfig, PostgresDatabaseSchema, SqliteDatabaseConfig, SqliteDatabaseSchema } from './database/schemas.cjs';
-export { BLOB_STORE_TYPES, BlobStoreConfig, BlobStoreConfigSchema, BlobStoreType, InMemoryBlobStoreConfig, InMemoryBlobStoreConfigInput, InMemoryBlobStoreSchema, LocalBlobStoreConfig, LocalBlobStoreConfigInput, LocalBlobStoreSchema } from './blob/schemas.cjs';
+
+declare const CACHE_TYPES: readonly ["in-memory", "redis"];
+type CacheType = (typeof CACHE_TYPES)[number];
+declare const InMemoryCacheSchema: z.ZodObject<{
+    maxConnections: z.ZodOptional<z.ZodNumber>;
+    idleTimeoutMillis: z.ZodOptional<z.ZodNumber>;
+    connectionTimeoutMillis: z.ZodOptional<z.ZodNumber>;
+    options: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+} & {
+    type: z.ZodLiteral<"in-memory">;
+}, "strict", z.ZodTypeAny, {
+    type: "in-memory";
+    maxConnections?: number | undefined;
+    idleTimeoutMillis?: number | undefined;
+    connectionTimeoutMillis?: number | undefined;
+    options?: Record<string, unknown> | undefined;
+}, {
+    type: "in-memory";
+    maxConnections?: number | undefined;
+    idleTimeoutMillis?: number | undefined;
+    connectionTimeoutMillis?: number | undefined;
+    options?: Record<string, unknown> | undefined;
+}>;
+type InMemoryCacheConfig = z.output<typeof InMemoryCacheSchema>;
+declare const RedisCacheSchema: z.ZodEffects<z.ZodObject<{
+    maxConnections: z.ZodOptional<z.ZodNumber>;
+    idleTimeoutMillis: z.ZodOptional<z.ZodNumber>;
+    connectionTimeoutMillis: z.ZodOptional<z.ZodNumber>;
+    options: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+} & {
+    type: z.ZodLiteral<"redis">;
+    url: z.ZodOptional<z.ZodEffects<z.ZodString, string, string>>;
+    host: z.ZodOptional<z.ZodString>;
+    port: z.ZodOptional<z.ZodNumber>;
+    password: z.ZodOptional<z.ZodString>;
+    database: z.ZodOptional<z.ZodNumber>;
+}, "strict", z.ZodTypeAny, {
+    type: "redis";
+    maxConnections?: number | undefined;
+    idleTimeoutMillis?: number | undefined;
+    connectionTimeoutMillis?: number | undefined;
+    options?: Record<string, unknown> | undefined;
+    url?: string | undefined;
+    host?: string | undefined;
+    port?: number | undefined;
+    password?: string | undefined;
+    database?: number | undefined;
+}, {
+    type: "redis";
+    maxConnections?: number | undefined;
+    idleTimeoutMillis?: number | undefined;
+    connectionTimeoutMillis?: number | undefined;
+    options?: Record<string, unknown> | undefined;
+    url?: string | undefined;
+    host?: string | undefined;
+    port?: number | undefined;
+    password?: string | undefined;
+    database?: number | undefined;
+}>, {
+    type: "redis";
+    maxConnections?: number | undefined;
+    idleTimeoutMillis?: number | undefined;
+    connectionTimeoutMillis?: number | undefined;
+    options?: Record<string, unknown> | undefined;
+    url?: string | undefined;
+    host?: string | undefined;
+    port?: number | undefined;
+    password?: string | undefined;
+    database?: number | undefined;
+}, {
+    type: "redis";
+    maxConnections?: number | undefined;
+    idleTimeoutMillis?: number | undefined;
+    connectionTimeoutMillis?: number | undefined;
+    options?: Record<string, unknown> | undefined;
+    url?: string | undefined;
+    host?: string | undefined;
+    port?: number | undefined;
+    password?: string | undefined;
+    database?: number | undefined;
+}>;
+type RedisCacheConfig = z.output<typeof RedisCacheSchema>;
+declare const CacheConfigSchema: z.ZodObject<{
+    type: z.ZodString;
+}, "passthrough", z.ZodTypeAny, z.objectOutputType<{
+    type: z.ZodString;
+}, z.ZodTypeAny, "passthrough">, z.objectInputType<{
+    type: z.ZodString;
+}, z.ZodTypeAny, "passthrough">>;
+type CacheConfig = z.output<typeof CacheConfigSchema>;
+
+declare const DATABASE_TYPES: readonly ["in-memory", "sqlite", "postgres"];
+type DatabaseType = (typeof DATABASE_TYPES)[number];
+declare const InMemoryDatabaseSchema: z.ZodObject<{
+    maxConnections: z.ZodOptional<z.ZodNumber>;
+    idleTimeoutMillis: z.ZodOptional<z.ZodNumber>;
+    connectionTimeoutMillis: z.ZodOptional<z.ZodNumber>;
+    options: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+} & {
+    type: z.ZodLiteral<"in-memory">;
+}, "strict", z.ZodTypeAny, {
+    type: "in-memory";
+    maxConnections?: number | undefined;
+    idleTimeoutMillis?: number | undefined;
+    connectionTimeoutMillis?: number | undefined;
+    options?: Record<string, unknown> | undefined;
+}, {
+    type: "in-memory";
+    maxConnections?: number | undefined;
+    idleTimeoutMillis?: number | undefined;
+    connectionTimeoutMillis?: number | undefined;
+    options?: Record<string, unknown> | undefined;
+}>;
+type InMemoryDatabaseConfig = z.output<typeof InMemoryDatabaseSchema>;
+declare const SqliteDatabaseSchema: z.ZodObject<{
+    maxConnections: z.ZodOptional<z.ZodNumber>;
+    idleTimeoutMillis: z.ZodOptional<z.ZodNumber>;
+    connectionTimeoutMillis: z.ZodOptional<z.ZodNumber>;
+    options: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+} & {
+    type: z.ZodLiteral<"sqlite">;
+    path: z.ZodString;
+}, "strict", z.ZodTypeAny, {
+    path: string;
+    type: "sqlite";
+    maxConnections?: number | undefined;
+    idleTimeoutMillis?: number | undefined;
+    connectionTimeoutMillis?: number | undefined;
+    options?: Record<string, unknown> | undefined;
+}, {
+    path: string;
+    type: "sqlite";
+    maxConnections?: number | undefined;
+    idleTimeoutMillis?: number | undefined;
+    connectionTimeoutMillis?: number | undefined;
+    options?: Record<string, unknown> | undefined;
+}>;
+type SqliteDatabaseConfig = z.output<typeof SqliteDatabaseSchema>;
+declare const PostgresDatabaseSchema: z.ZodEffects<z.ZodObject<{
+    maxConnections: z.ZodOptional<z.ZodNumber>;
+    idleTimeoutMillis: z.ZodOptional<z.ZodNumber>;
+    connectionTimeoutMillis: z.ZodOptional<z.ZodNumber>;
+    options: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+} & {
+    type: z.ZodLiteral<"postgres">;
+    url: z.ZodOptional<z.ZodEffects<z.ZodString, string, string>>;
+    connectionString: z.ZodOptional<z.ZodEffects<z.ZodString, string, string>>;
+    host: z.ZodOptional<z.ZodString>;
+    port: z.ZodOptional<z.ZodNumber>;
+    database: z.ZodOptional<z.ZodString>;
+    password: z.ZodOptional<z.ZodString>;
+    keyPrefix: z.ZodOptional<z.ZodString>;
+}, "strict", z.ZodTypeAny, {
+    type: "postgres";
+    maxConnections?: number | undefined;
+    idleTimeoutMillis?: number | undefined;
+    connectionTimeoutMillis?: number | undefined;
+    options?: Record<string, unknown> | undefined;
+    url?: string | undefined;
+    host?: string | undefined;
+    port?: number | undefined;
+    password?: string | undefined;
+    database?: string | undefined;
+    connectionString?: string | undefined;
+    keyPrefix?: string | undefined;
+}, {
+    type: "postgres";
+    maxConnections?: number | undefined;
+    idleTimeoutMillis?: number | undefined;
+    connectionTimeoutMillis?: number | undefined;
+    options?: Record<string, unknown> | undefined;
+    url?: string | undefined;
+    host?: string | undefined;
+    port?: number | undefined;
+    password?: string | undefined;
+    database?: string | undefined;
+    connectionString?: string | undefined;
+    keyPrefix?: string | undefined;
+}>, {
+    type: "postgres";
+    maxConnections?: number | undefined;
+    idleTimeoutMillis?: number | undefined;
+    connectionTimeoutMillis?: number | undefined;
+    options?: Record<string, unknown> | undefined;
+    url?: string | undefined;
+    host?: string | undefined;
+    port?: number | undefined;
+    password?: string | undefined;
+    database?: string | undefined;
+    connectionString?: string | undefined;
+    keyPrefix?: string | undefined;
+}, {
+    type: "postgres";
+    maxConnections?: number | undefined;
+    idleTimeoutMillis?: number | undefined;
+    connectionTimeoutMillis?: number | undefined;
+    options?: Record<string, unknown> | undefined;
+    url?: string | undefined;
+    host?: string | undefined;
+    port?: number | undefined;
+    password?: string | undefined;
+    database?: string | undefined;
+    connectionString?: string | undefined;
+    keyPrefix?: string | undefined;
+}>;
+type PostgresDatabaseConfig = z.output<typeof PostgresDatabaseSchema>;
+declare const DatabaseConfigSchema: z.ZodObject<{
+    type: z.ZodString;
+}, "passthrough", z.ZodTypeAny, z.objectOutputType<{
+    type: z.ZodString;
+}, z.ZodTypeAny, "passthrough">, z.objectInputType<{
+    type: z.ZodString;
+}, z.ZodTypeAny, "passthrough">>;
+type DatabaseConfig = z.output<typeof DatabaseConfigSchema>;
+
+/**
+ * Built-in blob store types shipped by `@dexto/storage`.
+ * Custom backends shipped via images are not included in this list.
+ */
+declare const BLOB_STORE_TYPES: readonly ["in-memory", "local"];
+type BlobStoreType = (typeof BLOB_STORE_TYPES)[number];
+/**
+ * In-memory blob store configuration
+ */
+declare const InMemoryBlobStoreSchema: 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;
+}>;
+type InMemoryBlobStoreConfigInput = z.input<typeof InMemoryBlobStoreSchema>;
+type InMemoryBlobStoreConfig = z.output<typeof InMemoryBlobStoreSchema>;
+/**
+ * Local filesystem blob store configuration
+ */
+declare const LocalBlobStoreSchema: 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;
+}>;
+type LocalBlobStoreConfigInput = z.input<typeof LocalBlobStoreSchema>;
+type LocalBlobStoreConfig = z.output<typeof LocalBlobStoreSchema>;
+/**
+ * Blob store configuration schema.
+ *
+ * This schema uses `.passthrough()` to accept any backend-specific configuration.
+ * It only validates that a `type` field exists as a string.
+ *
+ * Detailed validation happens in the product-layer resolver (`@dexto/agent-config`) via
+ * each image factory's `configSchema`. Built-in backends are validated by their factory schemas.
+ *
+ * This approach allows:
+ * - Custom backends to be provided by a custom image
+ * - Each backend to define its own configuration structure and strict schema
+ *
+ * Example flow:
+ * 1. Config passes this schema (basic structure check)
+ * 2. Product layer resolves backend via image + validates against factory schema
+ * 3. Core receives a concrete `BlobStore` instance (DI)
+ */
+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 backends (local, in-memory) and a catch-all
+ * for custom backends provided via images at runtime.
+ */
+type BlobStoreConfig = InMemoryBlobStoreConfig | LocalBlobStoreConfig | {
+    type: string;
+    [key: string]: unknown;
+};
 
 /**
  * Top-level storage configuration schema
@@ -69,4 +364,4 @@ declare const StorageSchema: z.ZodBranded<z.ZodObject<{
 type StorageConfig = z.input<typeof StorageSchema>;
 type ValidatedStorageConfig = z.output<typeof StorageSchema>;
 
-export { type StorageConfig, StorageSchema, type ValidatedStorageConfig };
+export { BLOB_STORE_TYPES, type BlobStoreConfig, BlobStoreConfigSchema, type BlobStoreType, CACHE_TYPES, type CacheConfig, CacheConfigSchema, type CacheType, DATABASE_TYPES, type DatabaseConfig, DatabaseConfigSchema, type DatabaseType, type InMemoryBlobStoreConfig, type InMemoryBlobStoreConfigInput, InMemoryBlobStoreSchema, type InMemoryCacheConfig, InMemoryCacheSchema, type InMemoryDatabaseConfig, InMemoryDatabaseSchema, type LocalBlobStoreConfig, type LocalBlobStoreConfigInput, LocalBlobStoreSchema, type PostgresDatabaseConfig, PostgresDatabaseSchema, type RedisCacheConfig, RedisCacheSchema, type SqliteDatabaseConfig, SqliteDatabaseSchema, type StorageConfig, StorageSchema, type ValidatedStorageConfig };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@dexto/storage",
-  "version": "1.6.0",
+  "version": "1.6.2",
   "description": "Storage backends and factories for Dexto agents",
   "type": "module",
   "main": "./dist/index.js",
@@ -21,7 +21,7 @@
   ],
   "dependencies": {
     "zod": "^3.25.0",
-    "@dexto/core": "1.6.0"
+    "@dexto/core": "1.6.2"
   },
   "peerDependencies": {
     "better-sqlite3": "^11.10.0",
@@ -48,7 +48,7 @@
     "README.md"
   ],
   "scripts": {
-    "build": "tsup",
+    "build": "tsup && node ../../scripts/clean-tsbuildinfo.mjs && tsc -b tsconfig.json --emitDeclarationOnly",
     "typecheck": "tsc --noEmit",
     "clean": "rm -rf dist"
   }

package/dist/blob/factories/index.d.cts

@@ -1,6 +0,0 @@
-export { localBlobStoreFactory } from './local.cjs';
-export { inMemoryBlobStoreFactory } from './memory.cjs';
-import '../schemas.cjs';
-import 'zod';
-import '../factory.cjs';
-import '@dexto/core';

package/dist/blob/factories/local.d.cts

@@ -1,21 +0,0 @@
-import { LocalBlobStoreConfig } from '../schemas.cjs';
-import { BlobStoreFactory } from '../factory.cjs';
-import 'zod';
-import '@dexto/core';
-
-/**
- * Factory for local filesystem blob storage.
- *
- * This factory 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
- */
-declare const localBlobStoreFactory: BlobStoreFactory<LocalBlobStoreConfig>;
-
-export { localBlobStoreFactory };

package/dist/blob/factories/memory.d.cts

@@ -1,21 +0,0 @@
-import { InMemoryBlobStoreConfig } from '../schemas.cjs';
-import { BlobStoreFactory } from '../factory.cjs';
-import 'zod';
-import '@dexto/core';
-
-/**
- * Factory for in-memory blob storage.
- *
- * This factory 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
- */
-declare const inMemoryBlobStoreFactory: BlobStoreFactory<InMemoryBlobStoreConfig>;
-
-export { inMemoryBlobStoreFactory };

package/dist/blob/factory.d.cts

@@ -1,36 +0,0 @@
-import { Logger, BlobStore } from '@dexto/core';
-import { z } from 'zod';
-
-/**
- * Factory interface for creating blob store instances.
- *
- * Factories are plain exports (no global registries). Images decide which factories are
- * available by including them in `image.storage.blob`.
- */
-interface BlobStoreFactory<TConfig = unknown> {
-    /**
-     * Zod schema for validating factory-specific configuration.
-     * The schema must output the `TConfig` type.
-     */
-    configSchema: z.ZodType<TConfig, z.ZodTypeDef, unknown>;
-    /**
-     * Factory function to create a BlobStore instance.
-     * @param config - Validated configuration specific to this backend
-     * @param logger - Logger instance for the blob store
-     * @returns A BlobStore implementation
-     */
-    create(config: TConfig, logger: Logger): BlobStore | Promise<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 backend requires network connectivity */
-        requiresNetwork?: boolean;
-    };
-}
-
-export type { BlobStoreFactory };

package/dist/blob/index.d.cts

@@ -1,8 +0,0 @@
-export { BlobStoreFactory } from './factory.cjs';
-export { BlobData, BlobInput, BlobMetadata, BlobReference, BlobStats, BlobStore, StoredBlobMetadata } from '@dexto/core';
-export { localBlobStoreFactory } from './factories/local.cjs';
-export { inMemoryBlobStoreFactory } from './factories/memory.cjs';
-export { BLOB_STORE_TYPES, BlobStoreConfig, BlobStoreConfigSchema, BlobStoreType, InMemoryBlobStoreConfig, InMemoryBlobStoreConfigInput, InMemoryBlobStoreSchema, LocalBlobStoreConfig, LocalBlobStoreConfigInput, LocalBlobStoreSchema } from './schemas.cjs';
-export { LocalBlobStore } from './local-blob-store.cjs';
-export { MemoryBlobStore } from './memory-blob-store.cjs';
-import 'zod';

package/dist/blob/local-blob-store.d.cts

@@ -1,56 +0,0 @@
-import { BlobStore, Logger, BlobInput, BlobMetadata, BlobReference, BlobData, BlobStats } from '@dexto/core';
-import { LocalBlobStoreConfig } from './schemas.cjs';
-import 'zod';
-
-/**
- * Local filesystem blob store implementation.
- *
- * Stores blobs on the local filesystem with content-based deduplication
- * and metadata tracking. This is the default store for development
- * and single-machine deployments.
- */
-declare class LocalBlobStore implements BlobStore {
-    private config;
-    private storePath;
-    private connected;
-    private statsCache;
-    private statsCachePromise;
-    private lastStatsRefresh;
-    private logger;
-    private static readonly STATS_REFRESH_INTERVAL_MS;
-    constructor(config: LocalBlobStoreConfig, logger: Logger);
-    connect(): Promise<void>;
-    disconnect(): Promise<void>;
-    isConnected(): boolean;
-    getStoreType(): string;
-    store(input: BlobInput, metadata?: BlobMetadata): Promise<BlobReference>;
-    retrieve(reference: string, format?: 'base64' | 'buffer' | 'path' | 'stream' | 'url'): Promise<BlobData>;
-    exists(reference: string): Promise<boolean>;
-    delete(reference: string): Promise<void>;
-    cleanup(olderThan?: Date): Promise<number>;
-    getStats(): Promise<BlobStats>;
-    getStoragePath(): string | undefined;
-    listBlobs(): Promise<BlobReference[]>;
-    private ensureStatsCache;
-    private refreshStatsCache;
-    private updateStatsCacheAfterStore;
-    private updateStatsCacheAfterDelete;
-    /**
-     * Convert various input types to Buffer
-     */
-    private inputToBuffer;
-    /**
-     * Parse blob reference to extract ID
-     */
-    private parseReference;
-    /**
-     * Detect MIME type from buffer content and/or filename
-     */
-    private detectMimeType;
-    /**
-     * Check if buffer contains text content
-     */
-    private isTextBuffer;
-}
-
-export { LocalBlobStore };

package/dist/blob/memory-blob-store.d.cts

@@ -1,69 +0,0 @@
-import { BlobStore, Logger, BlobInput, BlobMetadata, BlobReference, BlobData, BlobStats } from '@dexto/core';
-import { InMemoryBlobStoreConfigInput } from './schemas.cjs';
-import 'zod';
-
-/**
- * In-memory blob store implementation.
- *
- * Stores blobs in memory with content-based deduplication and size limits.
- * Suitable for development, testing, and scenarios where blob persistence
- * across restarts is not required.
- *
- * Features:
- * - Content-based deduplication (same as LocalBlobStore)
- * - Configurable size limits (per-blob and total)
- * - Automatic cleanup of old blobs
- * - MIME type detection
- * - Multi-format retrieval (base64, buffer, stream, data URI)
- *
- * Limitations:
- * - Data lost on restart (no persistence)
- * - Path format not supported (no filesystem)
- * - Memory usage proportional to blob size
- */
-type MemoryBlobStoreOptions = Omit<InMemoryBlobStoreConfigInput, 'type'>;
-declare class MemoryBlobStore implements BlobStore {
-    private config;
-    private blobs;
-    private connected;
-    private logger;
-    constructor(options: MemoryBlobStoreOptions, logger: Logger);
-    connect(): Promise<void>;
-    disconnect(): Promise<void>;
-    isConnected(): boolean;
-    getStoreType(): string;
-    store(input: BlobInput, metadata?: BlobMetadata): Promise<BlobReference>;
-    retrieve(reference: string, format?: 'base64' | 'buffer' | 'path' | 'stream' | 'url'): Promise<BlobData>;
-    exists(reference: string): Promise<boolean>;
-    delete(reference: string): Promise<void>;
-    cleanup(olderThan?: Date): Promise<number>;
-    getStats(): Promise<BlobStats>;
-    listBlobs(): Promise<BlobReference[]>;
-    getStoragePath(): string | undefined;
-    /**
-     * Calculate total size of all blobs in memory
-     */
-    private getTotalSize;
-    /**
-     * Convert various input types to Buffer.
-     * Copied from LocalBlobStore with minor adaptations.
-     */
-    private inputToBuffer;
-    /**
-     * Parse blob reference to extract ID.
-     * Copied from LocalBlobStore.
-     */
-    private parseReference;
-    /**
-     * Detect MIME type from buffer content and/or filename.
-     * Copied from LocalBlobStore.
-     */
-    private detectMimeType;
-    /**
-     * Check if buffer contains text content.
-     * Copied from LocalBlobStore.
-     */
-    private isTextBuffer;
-}
-
-export { MemoryBlobStore, type MemoryBlobStoreOptions };

package/dist/blob/schemas.d.cts

@@ -1,87 +0,0 @@
-import { z } from 'zod';
-
-/**
- * Built-in blob store types shipped by `@dexto/storage`.
- * Custom backends shipped via images are not included in this list.
- */
-declare const BLOB_STORE_TYPES: readonly ["in-memory", "local"];
-type BlobStoreType = (typeof BLOB_STORE_TYPES)[number];
-/**
- * In-memory blob store configuration
- */
-declare const InMemoryBlobStoreSchema: 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;
-}>;
-type InMemoryBlobStoreConfigInput = z.input<typeof InMemoryBlobStoreSchema>;
-type InMemoryBlobStoreConfig = z.output<typeof InMemoryBlobStoreSchema>;
-/**
- * Local filesystem blob store configuration
- */
-declare const LocalBlobStoreSchema: 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;
-}>;
-type LocalBlobStoreConfigInput = z.input<typeof LocalBlobStoreSchema>;
-type LocalBlobStoreConfig = z.output<typeof LocalBlobStoreSchema>;
-/**
- * Blob store configuration schema.
- *
- * This schema uses `.passthrough()` to accept any backend-specific configuration.
- * It only validates that a `type` field exists as a string.
- *
- * Detailed validation happens in the product-layer resolver (`@dexto/agent-config`) via
- * each image factory's `configSchema`. Built-in backends are validated by their factory schemas.
- *
- * This approach allows:
- * - Custom backends to be provided by a custom image
- * - Each backend to define its own configuration structure and strict schema
- *
- * Example flow:
- * 1. Config passes this schema (basic structure check)
- * 2. Product layer resolves backend via image + validates against factory schema
- * 3. Core receives a concrete `BlobStore` instance (DI)
- */
-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 backends (local, in-memory) and a catch-all
- * for custom backends provided via images at runtime.
- */
-type BlobStoreConfig = InMemoryBlobStoreConfig | LocalBlobStoreConfig | {
-    type: string;
-    [key: string]: unknown;
-};
-
-export { BLOB_STORE_TYPES, type BlobStoreConfig, BlobStoreConfigSchema, type BlobStoreType, type InMemoryBlobStoreConfig, type InMemoryBlobStoreConfigInput, InMemoryBlobStoreSchema, type LocalBlobStoreConfig, type LocalBlobStoreConfigInput, LocalBlobStoreSchema };

package/dist/blob/types.d.cts

@@ -1 +0,0 @@
-export { BlobData, BlobInput, BlobMetadata, BlobReference, BlobStats, BlobStore, StoredBlobMetadata } from '@dexto/core';

package/dist/cache/factories/index.d.cts

@@ -1,6 +0,0 @@
-export { inMemoryCacheFactory } from './memory.cjs';
-export { redisCacheFactory } from './redis.cjs';
-import '../schemas.cjs';
-import 'zod';
-import '../factory.cjs';
-import '@dexto/core';

package/dist/cache/factories/memory.d.cts

@@ -1,21 +0,0 @@
-import { InMemoryCacheConfig } from '../schemas.cjs';
-import { CacheFactory } from '../factory.cjs';
-import 'zod';
-import '@dexto/core';
-
-/**
- * Factory for in-memory cache storage.
- *
- * This factory 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
- */
-declare const inMemoryCacheFactory: CacheFactory<InMemoryCacheConfig>;
-
-export { inMemoryCacheFactory };