@dexto/storage 1.6.0

package/dist/cache/factories/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, {
+  inMemoryCacheFactory: () => inMemoryCacheFactory
+});
+module.exports = __toCommonJS(memory_exports);
+var import_schemas = require("../schemas.js");
+var import_memory_cache_store = require("../memory-cache-store.js");
+const inMemoryCacheFactory = {
+  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 = {
+  inMemoryCacheFactory
+});

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

@@ -0,0 +1,21 @@
+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 };

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

@@ -0,0 +1,17 @@
+import type { InMemoryCacheConfig } from '../schemas.js';
+import type { CacheFactory } from '../factory.js';
+/**
+ * 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
+ */
+export declare const inMemoryCacheFactory: CacheFactory<InMemoryCacheConfig>;
+//# sourceMappingURL=memory.d.ts.map

package/dist/cache/factories/memory.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"memory.d.ts","sourceRoot":"","sources":["../../../src/cache/factories/memory.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,eAAe,CAAC;AAGzD,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,eAAe,CAAC;AAElD;;;;;;;;;;;;GAYG;AACH,eAAO,MAAM,oBAAoB,EAAE,YAAY,CAAC,mBAAmB,CASlE,CAAC"}

package/dist/cache/factories/memory.js

@@ -0,0 +1,15 @@
+import { InMemoryCacheSchema } from "../schemas.js";
+import { MemoryCacheStore } from "../memory-cache-store.js";
+const inMemoryCacheFactory = {
+  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 {
+  inMemoryCacheFactory
+};

package/dist/cache/factories/redis.cjs

@@ -0,0 +1,65 @@
+"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, {
+  redisCacheFactory: () => redisCacheFactory
+});
+module.exports = __toCommonJS(redis_exports);
+var import_schemas = require("../schemas.js");
+var import_core = require("@dexto/core");
+const redisCacheFactory = {
+  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_core.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 = {
+  redisCacheFactory
+});

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

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

package/dist/cache/factories/redis.d.ts

@@ -0,0 +1,20 @@
+import type { RedisCacheConfig } from '../schemas.js';
+import type { CacheFactory } from '../factory.js';
+/**
+ * Factory for Redis cache storage.
+ *
+ * This factory 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 redisCacheFactory: CacheFactory<RedisCacheConfig>;
+//# sourceMappingURL=redis.d.ts.map

package/dist/cache/factories/redis.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"redis.d.ts","sourceRoot":"","sources":["../../../src/cache/factories/redis.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,eAAe,CAAC;AAGtD,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,eAAe,CAAC;AAElD;;;;;;;;;;;;;;;GAeG;AACH,eAAO,MAAM,iBAAiB,EAAE,YAAY,CAAC,gBAAgB,CAyB5D,CAAC"}

package/dist/cache/factories/redis.js

@@ -0,0 +1,31 @@
+import { RedisCacheSchema } from "../schemas.js";
+import { StorageError } from "@dexto/core";
+const redisCacheFactory = {
+  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 {
+  redisCacheFactory
+};

package/dist/cache/factory.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 factory_exports = {};
+module.exports = __toCommonJS(factory_exports);

package/dist/cache/factory.d.cts

@@ -0,0 +1,42 @@
+import { Logger, Cache } from '@dexto/core';
+import { z } from 'zod';
+
+/**
+ * Factory interface for creating cache instances.
+ *
+ * Factories are plain exports (no global registries). Images decide which factories are
+ * available by including them in `image.storage.cache`.
+ */
+interface CacheFactory<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 Cache instance.
+     *
+     * Cache factories may return a Promise to support lazy loading of optional
+     * dependencies (e.g., `ioredis`).
+     *
+     * @param config - Validated configuration specific to this backend
+     * @param logger - Logger instance for the cache
+     * @returns A Cache implementation (or Promise for async backends)
+     */
+    create(config: TConfig, logger: Logger): 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 backend requires network connectivity */
+        requiresNetwork?: boolean;
+        /** Whether this backend supports TTL (time-to-live) */
+        supportsTTL?: boolean;
+    };
+}
+
+export type { CacheFactory };

package/dist/cache/factory.d.ts

@@ -0,0 +1,41 @@
+import type { Cache } from './types.js';
+import type { Logger } from '@dexto/core';
+import type { z } from 'zod';
+/**
+ * Factory interface for creating cache instances.
+ *
+ * Factories are plain exports (no global registries). Images decide which factories are
+ * available by including them in `image.storage.cache`.
+ */
+export interface CacheFactory<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 Cache instance.
+     *
+     * Cache factories may return a Promise to support lazy loading of optional
+     * dependencies (e.g., `ioredis`).
+     *
+     * @param config - Validated configuration specific to this backend
+     * @param logger - Logger instance for the cache
+     * @returns A Cache implementation (or Promise for async backends)
+     */
+    create(config: TConfig, logger: Logger): 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 backend requires network connectivity */
+        requiresNetwork?: boolean;
+        /** Whether this backend supports TTL (time-to-live) */
+        supportsTTL?: boolean;
+    };
+}
+//# sourceMappingURL=factory.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"factory.d.ts","sourceRoot":"","sources":["../../src/cache/factory.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,YAAY,CAAC;AACxC,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,aAAa,CAAC;AAC1C,OAAO,KAAK,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAE7B;;;;;GAKG;AACH,MAAM,WAAW,YAAY,CAAC,OAAO,GAAG,OAAO;IAC3C;;;OAGG;IACH,YAAY,EAAE,CAAC,CAAC,OAAO,CAAC,OAAO,EAAE,CAAC,CAAC,UAAU,EAAE,OAAO,CAAC,CAAC;IAExD;;;;;;;;;OASG;IACH,MAAM,CAAC,MAAM,EAAE,OAAO,EAAE,MAAM,EAAE,MAAM,GAAG,KAAK,GAAG,OAAO,CAAC,KAAK,CAAC,CAAC;IAEhE;;OAEG;IACH,QAAQ,CAAC,EAAE;QACP,uDAAuD;QACvD,WAAW,EAAE,MAAM,CAAC;QACpB,8CAA8C;QAC9C,WAAW,EAAE,MAAM,CAAC;QACpB,yDAAyD;QACzD,eAAe,CAAC,EAAE,OAAO,CAAC;QAC1B,uDAAuD;QACvD,WAAW,CAAC,EAAE,OAAO,CAAC;KACzB,CAAC;CACL"}

package/dist/cache/index.cjs

@@ -0,0 +1,42 @@
+"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,
+  InMemoryCacheSchema: () => import_schemas.InMemoryCacheSchema,
+  MemoryCacheStore: () => import_memory_cache_store.MemoryCacheStore,
+  RedisCacheSchema: () => import_schemas.RedisCacheSchema,
+  inMemoryCacheFactory: () => import_factories.inMemoryCacheFactory,
+  redisCacheFactory: () => import_factories.redisCacheFactory
+});
+module.exports = __toCommonJS(cache_exports);
+var import_factories = require("./factories/index.js");
+var import_schemas = require("./schemas.js");
+var import_memory_cache_store = require("./memory-cache-store.js");
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  CACHE_TYPES,
+  CacheConfigSchema,
+  InMemoryCacheSchema,
+  MemoryCacheStore,
+  RedisCacheSchema,
+  inMemoryCacheFactory,
+  redisCacheFactory
+});

package/dist/cache/index.d.cts

@@ -0,0 +1,7 @@
+export { CacheFactory } from './factory.cjs';
+export { Cache } from '@dexto/core';
+export { inMemoryCacheFactory } from './factories/memory.cjs';
+export { redisCacheFactory } from './factories/redis.cjs';
+export { CACHE_TYPES, CacheConfig, CacheConfigSchema, CacheType, InMemoryCacheConfig, InMemoryCacheSchema, RedisCacheConfig, RedisCacheSchema } from './schemas.cjs';
+export { MemoryCacheStore } from './memory-cache-store.cjs';
+import 'zod';

package/dist/cache/index.d.ts

@@ -0,0 +1,25 @@
+/**
+ * Cache Module
+ *
+ * This module provides a flexible caching system with support for
+ * multiple backends through a factory pattern.
+ *
+ * ## Built-in Factories
+ * - `in-memory`: Store data in RAM (for testing/development)
+ * - `redis`: Store data in Redis server
+ *
+ * ## Custom Factories
+ * Product layers (CLI/server/platform) decide which factories are available by including them
+ * in images (`DextoImage.storage.cache`).
+ *
+ * ## Usage
+ * Cache backends are typically constructed by the product-layer resolver (`@dexto/agent-config`)
+ * via image-provided factory maps. For direct usage, call a factory's `create()` after validating
+ * config with its `configSchema`.
+ */
+export type { CacheFactory } from './factory.js';
+export type { Cache } from './types.js';
+export { inMemoryCacheFactory, redisCacheFactory } from './factories/index.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/cache/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/cache/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;GAkBG;AAGH,YAAY,EAAE,YAAY,EAAE,MAAM,cAAc,CAAC;AAGjD,YAAY,EAAE,KAAK,EAAE,MAAM,YAAY,CAAC;AAGxC,OAAO,EAAE,oBAAoB,EAAE,iBAAiB,EAAE,MAAM,sBAAsB,CAAC;AAG/E,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/cache/index.js

@@ -0,0 +1,17 @@
+import { inMemoryCacheFactory, redisCacheFactory } from "./factories/index.js";
+import {
+  CACHE_TYPES,
+  CacheConfigSchema,
+  InMemoryCacheSchema,
+  RedisCacheSchema
+} from "./schemas.js";
+import { MemoryCacheStore } from "./memory-cache-store.js";
+export {
+  CACHE_TYPES,
+  CacheConfigSchema,
+  InMemoryCacheSchema,
+  MemoryCacheStore,
+  RedisCacheSchema,
+  inMemoryCacheFactory,
+  redisCacheFactory
+};

package/dist/cache/memory-cache-store.cjs

@@ -0,0 +1,106 @@
+"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_cache_store_exports = {};
+__export(memory_cache_store_exports, {
+  MemoryCacheStore: () => MemoryCacheStore
+});
+module.exports = __toCommonJS(memory_cache_store_exports);
+var import_core = require("@dexto/core");
+class MemoryCacheStore {
+  data = /* @__PURE__ */ new Map();
+  ttls = /* @__PURE__ */ new Map();
+  connected = false;
+  async connect() {
+    if (this.connected) return;
+    this.connected = true;
+  }
+  async disconnect() {
+    this.connected = false;
+    this.data.clear();
+    this.ttls.clear();
+  }
+  isConnected() {
+    return this.connected;
+  }
+  getStoreType() {
+    return "in-memory";
+  }
+  async get(key) {
+    this.checkConnection();
+    try {
+      this.checkTTL(key);
+      return this.data.get(key);
+    } catch (error) {
+      throw import_core.StorageError.readFailed(
+        "get",
+        error instanceof Error ? error.message : String(error),
+        { key }
+      );
+    }
+  }
+  async set(key, value, ttlSeconds) {
+    this.checkConnection();
+    try {
+      this.data.set(key, value);
+      if (ttlSeconds) {
+        this.ttls.set(key, Date.now() + ttlSeconds * 1e3);
+      } else {
+        this.ttls.delete(key);
+      }
+    } catch (error) {
+      throw import_core.StorageError.writeFailed(
+        "set",
+        error instanceof Error ? error.message : String(error),
+        { key }
+      );
+    }
+  }
+  async delete(key) {
+    this.checkConnection();
+    this.data.delete(key);
+    this.ttls.delete(key);
+  }
+  // Helper methods
+  checkConnection() {
+    if (!this.connected) {
+      throw import_core.StorageError.notConnected("MemoryCacheStore");
+    }
+  }
+  checkTTL(key) {
+    const expiry = this.ttls.get(key);
+    if (expiry && Date.now() > expiry) {
+      this.data.delete(key);
+      this.ttls.delete(key);
+    }
+  }
+  // Development helpers
+  async clear() {
+    this.data.clear();
+    this.ttls.clear();
+  }
+  async dump() {
+    return {
+      data: Object.fromEntries(this.data.entries())
+    };
+  }
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  MemoryCacheStore
+});

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

@@ -0,0 +1,27 @@
+import { Cache } from '@dexto/core';
+
+/**
+ * In-memory cache store for development and testing.
+ * Supports TTL for automatic cleanup of temporary data.
+ * Data is lost when the process restarts.
+ */
+declare class MemoryCacheStore implements Cache {
+    private data;
+    private ttls;
+    private connected;
+    connect(): Promise<void>;
+    disconnect(): Promise<void>;
+    isConnected(): boolean;
+    getStoreType(): string;
+    get<T>(key: string): Promise<T | undefined>;
+    set<T>(key: string, value: T, ttlSeconds?: number): Promise<void>;
+    delete(key: string): Promise<void>;
+    private checkConnection;
+    private checkTTL;
+    clear(): Promise<void>;
+    dump(): Promise<{
+        data: Record<string, unknown>;
+    }>;
+}
+
+export { MemoryCacheStore };

package/dist/cache/memory-cache-store.d.ts

@@ -0,0 +1,25 @@
+import type { Cache } from './types.js';
+/**
+ * In-memory cache store for development and testing.
+ * Supports TTL for automatic cleanup of temporary data.
+ * Data is lost when the process restarts.
+ */
+export declare class MemoryCacheStore implements Cache {
+    private data;
+    private ttls;
+    private connected;
+    connect(): Promise<void>;
+    disconnect(): Promise<void>;
+    isConnected(): boolean;
+    getStoreType(): string;
+    get<T>(key: string): Promise<T | undefined>;
+    set<T>(key: string, value: T, ttlSeconds?: number): Promise<void>;
+    delete(key: string): Promise<void>;
+    private checkConnection;
+    private checkTTL;
+    clear(): Promise<void>;
+    dump(): Promise<{
+        data: Record<string, unknown>;
+    }>;
+}
+//# sourceMappingURL=memory-cache-store.d.ts.map

package/dist/cache/memory-cache-store.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"memory-cache-store.d.ts","sourceRoot":"","sources":["../../src/cache/memory-cache-store.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,YAAY,CAAC;AAGxC;;;;GAIG;AACH,qBAAa,gBAAiB,YAAW,KAAK;IAC1C,OAAO,CAAC,IAAI,CAA8B;IAC1C,OAAO,CAAC,IAAI,CAA6B;IACzC,OAAO,CAAC,SAAS,CAAS;IAEpB,OAAO,IAAI,OAAO,CAAC,IAAI,CAAC;IAKxB,UAAU,IAAI,OAAO,CAAC,IAAI,CAAC;IAMjC,WAAW,IAAI,OAAO;IAItB,YAAY,IAAI,MAAM;IAIhB,GAAG,CAAC,CAAC,EAAE,GAAG,EAAE,MAAM,GAAG,OAAO,CAAC,CAAC,GAAG,SAAS,CAAC;IAc3C,GAAG,CAAC,CAAC,EAAE,GAAG,EAAE,MAAM,EAAE,KAAK,EAAE,CAAC,EAAE,UAAU,CAAC,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC;IAmBjE,MAAM,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC;IAOxC,OAAO,CAAC,eAAe;IAMvB,OAAO,CAAC,QAAQ;IASV,KAAK,IAAI,OAAO,CAAC,IAAI,CAAC;IAKtB,IAAI,IAAI,OAAO,CAAC;QAAE,IAAI,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAA;KAAE,CAAC;CAK3D"}