@dexto/storage 1.6.0

package/dist/blob/memory-blob-store.js

@@ -0,0 +1,303 @@
+import { createHash } from "crypto";
+import { Readable } from "stream";
+import { DextoLogComponent, StorageError } from "@dexto/core";
+import { InMemoryBlobStoreSchema } from "./schemas.js";
+const MemoryBlobStoreOptionsSchema = InMemoryBlobStoreSchema.omit({ type: true });
+class MemoryBlobStore {
+  config;
+  blobs = /* @__PURE__ */ new Map();
+  connected = false;
+  logger;
+  constructor(options, logger) {
+    this.config = MemoryBlobStoreOptionsSchema.parse(options);
+    this.logger = logger.createChild(DextoLogComponent.STORAGE);
+  }
+  async connect() {
+    if (this.connected) return;
+    this.connected = true;
+    this.logger.debug("MemoryBlobStore connected");
+  }
+  async disconnect() {
+    this.blobs.clear();
+    this.connected = false;
+    this.logger.debug("MemoryBlobStore disconnected");
+  }
+  isConnected() {
+    return this.connected;
+  }
+  getStoreType() {
+    return "in-memory";
+  }
+  async store(input, metadata = {}) {
+    if (!this.connected) {
+      throw StorageError.blobBackendNotConnected("in-memory");
+    }
+    const buffer = await this.inputToBuffer(input);
+    if (buffer.length > this.config.maxBlobSize) {
+      throw StorageError.blobSizeExceeded(buffer.length, this.config.maxBlobSize);
+    }
+    const hash = createHash("sha256").update(buffer).digest("hex").substring(0, 16);
+    const id = hash;
+    const existing = this.blobs.get(id);
+    if (existing) {
+      this.logger.debug(
+        `Blob ${id} already exists, returning existing reference (deduplication)`
+      );
+      return {
+        id,
+        uri: `blob:${id}`,
+        metadata: existing.metadata
+      };
+    }
+    const currentSize = this.getTotalSize();
+    if (currentSize + buffer.length > this.config.maxTotalSize) {
+      throw StorageError.blobTotalSizeExceeded(
+        currentSize + buffer.length,
+        this.config.maxTotalSize
+      );
+    }
+    const storedMetadata = {
+      id,
+      mimeType: metadata.mimeType || this.detectMimeType(buffer, metadata.originalName),
+      originalName: metadata.originalName,
+      createdAt: metadata.createdAt || /* @__PURE__ */ new Date(),
+      source: metadata.source || "system",
+      size: buffer.length,
+      hash
+    };
+    this.blobs.set(id, { data: buffer, metadata: storedMetadata });
+    this.logger.debug(`Stored blob ${id} (${buffer.length} bytes, ${storedMetadata.mimeType})`);
+    return {
+      id,
+      uri: `blob:${id}`,
+      metadata: storedMetadata
+    };
+  }
+  async retrieve(reference, format = "base64") {
+    if (!this.connected) {
+      throw StorageError.blobBackendNotConnected("in-memory");
+    }
+    const id = this.parseReference(reference);
+    const blob = this.blobs.get(id);
+    if (!blob) {
+      throw StorageError.blobNotFound(reference);
+    }
+    switch (format) {
+      case "base64":
+        return {
+          format: "base64",
+          data: blob.data.toString("base64"),
+          metadata: blob.metadata
+        };
+      case "buffer":
+        return {
+          format: "buffer",
+          data: Buffer.from(blob.data),
+          metadata: { ...blob.metadata }
+        };
+      case "path":
+        throw new Error(
+          "Path format not supported for in-memory blobs. Use local blob storage for filesystem paths."
+        );
+      case "stream": {
+        const stream = Readable.from(blob.data);
+        return {
+          format: "stream",
+          data: stream,
+          metadata: blob.metadata
+        };
+      }
+      case "url": {
+        const base64 = blob.data.toString("base64");
+        const mimeType = blob.metadata.mimeType || "application/octet-stream";
+        const dataUrl = `data:${mimeType};base64,${base64}`;
+        return {
+          format: "url",
+          data: dataUrl,
+          metadata: blob.metadata
+        };
+      }
+      default:
+        throw StorageError.blobInvalidInput(format, `Unsupported format: ${format}`);
+    }
+  }
+  async exists(reference) {
+    if (!this.connected) {
+      throw StorageError.blobBackendNotConnected("in-memory");
+    }
+    const id = this.parseReference(reference);
+    return this.blobs.has(id);
+  }
+  async delete(reference) {
+    if (!this.connected) {
+      throw StorageError.blobBackendNotConnected("in-memory");
+    }
+    const id = this.parseReference(reference);
+    if (!this.blobs.has(id)) {
+      throw StorageError.blobNotFound(reference);
+    }
+    this.blobs.delete(id);
+    this.logger.debug(`Deleted blob: ${id}`);
+  }
+  async cleanup(olderThan) {
+    if (!this.connected) {
+      throw StorageError.blobBackendNotConnected("in-memory");
+    }
+    const cutoffDate = olderThan || new Date(Date.now() - 30 * 24 * 60 * 60 * 1e3);
+    let deletedCount = 0;
+    for (const [id, { metadata }] of this.blobs.entries()) {
+      if (metadata.createdAt < cutoffDate) {
+        this.blobs.delete(id);
+        deletedCount++;
+        this.logger.debug(`Cleaned up old blob: ${id}`);
+      }
+    }
+    if (deletedCount > 0) {
+      this.logger.info(`Blob cleanup: removed ${deletedCount} old blobs from memory`);
+    }
+    return deletedCount;
+  }
+  async getStats() {
+    if (!this.connected) {
+      throw StorageError.blobBackendNotConnected("in-memory");
+    }
+    return {
+      count: this.blobs.size,
+      totalSize: this.getTotalSize(),
+      backendType: "in-memory",
+      storePath: "memory://"
+    };
+  }
+  async listBlobs() {
+    if (!this.connected) {
+      throw StorageError.blobBackendNotConnected("in-memory");
+    }
+    return Array.from(this.blobs.entries()).map(([id, { metadata }]) => ({
+      id,
+      uri: `blob:${id}`,
+      metadata
+    }));
+  }
+  getStoragePath() {
+    return void 0;
+  }
+  /**
+   * Calculate total size of all blobs in memory
+   */
+  getTotalSize() {
+    return Array.from(this.blobs.values()).reduce((sum, { data }) => sum + data.length, 0);
+  }
+  /**
+   * Convert various input types to Buffer.
+   * Copied from LocalBlobStore with minor adaptations.
+   */
+  async inputToBuffer(input) {
+    if (Buffer.isBuffer(input)) {
+      return input;
+    }
+    if (input instanceof Uint8Array) {
+      return Buffer.from(input);
+    }
+    if (input instanceof ArrayBuffer) {
+      return Buffer.from(new Uint8Array(input));
+    }
+    if (typeof input === "string") {
+      if (input.startsWith("data:")) {
+        const commaIndex = input.indexOf(",");
+        if (commaIndex !== -1 && input.includes(";base64,")) {
+          const base64Data = input.substring(commaIndex + 1);
+          return Buffer.from(base64Data, "base64");
+        }
+        throw StorageError.blobEncodingError(
+          "inputToBuffer",
+          "Unsupported data URI format"
+        );
+      }
+      try {
+        return Buffer.from(input, "base64");
+      } catch {
+        throw StorageError.blobEncodingError("inputToBuffer", "Invalid base64 string");
+      }
+    }
+    throw StorageError.blobInvalidInput(input, `Unsupported input type: ${typeof input}`);
+  }
+  /**
+   * Parse blob reference to extract ID.
+   * Copied from LocalBlobStore.
+   */
+  parseReference(reference) {
+    if (!reference) {
+      throw StorageError.blobInvalidReference(reference, "Empty reference");
+    }
+    if (reference.startsWith("blob:")) {
+      const id = reference.substring(5);
+      if (!id) {
+        throw StorageError.blobInvalidReference(reference, "Empty blob ID after prefix");
+      }
+      return id;
+    }
+    return reference;
+  }
+  /**
+   * Detect MIME type from buffer content and/or filename.
+   * Copied from LocalBlobStore.
+   */
+  detectMimeType(buffer, filename) {
+    const header = buffer.subarray(0, 16);
+    if (header.length >= 3) {
+      const jpegSignature = header.subarray(0, 3);
+      if (jpegSignature.equals(Buffer.from([255, 216, 255]))) {
+        return "image/jpeg";
+      }
+    }
+    if (header.length >= 4) {
+      const signature = header.subarray(0, 4);
+      if (signature.equals(Buffer.from([137, 80, 78, 71]))) return "image/png";
+      if (signature.equals(Buffer.from([71, 73, 70, 56]))) return "image/gif";
+      if (signature.equals(Buffer.from([37, 80, 68, 70]))) return "application/pdf";
+    }
+    if (filename) {
+      const ext = filename.split(".").pop()?.toLowerCase();
+      const mimeTypes = {
+        jpg: "image/jpeg",
+        jpeg: "image/jpeg",
+        png: "image/png",
+        gif: "image/gif",
+        pdf: "application/pdf",
+        txt: "text/plain",
+        json: "application/json",
+        xml: "text/xml",
+        html: "text/html",
+        css: "text/css",
+        js: "text/javascript",
+        md: "text/markdown",
+        mp3: "audio/mpeg",
+        mp4: "video/mp4",
+        wav: "audio/wav"
+      };
+      if (ext && mimeTypes[ext]) return mimeTypes[ext];
+    }
+    if (this.isTextBuffer(buffer)) {
+      return "text/plain";
+    }
+    return "application/octet-stream";
+  }
+  /**
+   * Check if buffer contains text content.
+   * Copied from LocalBlobStore.
+   */
+  isTextBuffer(buffer) {
+    let printableCount = 0;
+    const sampleSize = Math.min(512, buffer.length);
+    for (let i = 0; i < sampleSize; i++) {
+      const byte = buffer[i];
+      if (byte !== void 0 && (byte >= 32 && byte <= 126 || byte === 9 || byte === 10 || byte === 13)) {
+        printableCount++;
+      }
+    }
+    return printableCount / sampleSize > 0.7;
+  }
+}
+export {
+  MemoryBlobStore
+};

package/dist/blob/schemas.cjs

@@ -0,0 +1,52 @@
+"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 schemas_exports = {};
+__export(schemas_exports, {
+  BLOB_STORE_TYPES: () => BLOB_STORE_TYPES,
+  BlobStoreConfigSchema: () => BlobStoreConfigSchema,
+  InMemoryBlobStoreSchema: () => InMemoryBlobStoreSchema,
+  LocalBlobStoreSchema: () => LocalBlobStoreSchema
+});
+module.exports = __toCommonJS(schemas_exports);
+var import_zod = require("zod");
+const BLOB_STORE_TYPES = ["in-memory", "local"];
+const InMemoryBlobStoreSchema = import_zod.z.object({
+  type: import_zod.z.literal("in-memory").describe("Blob store type identifier"),
+  maxBlobSize: import_zod.z.number().int().positive().optional().default(10 * 1024 * 1024).describe("Maximum size per blob in bytes"),
+  maxTotalSize: import_zod.z.number().int().positive().optional().default(100 * 1024 * 1024).describe("Maximum total storage size in bytes")
+}).strict();
+const LocalBlobStoreSchema = import_zod.z.object({
+  type: import_zod.z.literal("local").describe("Blob store type identifier"),
+  storePath: import_zod.z.string().describe(
+    "Blob storage directory path (required for local storage - CLI enrichment provides per-agent default)"
+  ),
+  maxBlobSize: import_zod.z.number().int().positive().optional().default(50 * 1024 * 1024).describe("Maximum size per blob in bytes"),
+  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.object({
+  type: import_zod.z.string().describe("Blob store backend type")
+}).passthrough().describe("Blob store configuration (validated by image factory)");
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  BLOB_STORE_TYPES,
+  BlobStoreConfigSchema,
+  InMemoryBlobStoreSchema,
+  LocalBlobStoreSchema
+});

package/dist/blob/schemas.d.cts

@@ -0,0 +1,87 @@
+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/schemas.d.ts

@@ -0,0 +1,86 @@
+import { z } from 'zod';
+/**
+ * Built-in blob store types shipped by `@dexto/storage`.
+ * Custom backends shipped via images are not included in this list.
+ */
+export declare const BLOB_STORE_TYPES: readonly ["in-memory", "local"];
+export 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;
+}>;
+export type InMemoryBlobStoreConfigInput = z.input<typeof InMemoryBlobStoreSchema>;
+export 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;
+}>;
+export type LocalBlobStoreConfigInput = z.input<typeof LocalBlobStoreSchema>;
+export 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)
+ */
+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 backends (local, in-memory) and a catch-all
+ * for custom backends provided via images at runtime.
+ */
+export type BlobStoreConfig = InMemoryBlobStoreConfig | LocalBlobStoreConfig | {
+    type: string;
+    [key: string]: unknown;
+};
+export { InMemoryBlobStoreSchema, LocalBlobStoreSchema };
+//# sourceMappingURL=schemas.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"schemas.d.ts","sourceRoot":"","sources":["../../src/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,4BAA4B,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,uBAAuB,CAAC,CAAC;AACnF,MAAM,MAAM,uBAAuB,GAAG,CAAC,CAAC,MAAM,CAAC,OAAO,uBAAuB,CAAC,CAAC;AAE/E;;GAEG;AACH,QAAA,MAAM,oBAAoB;;;;;;;;;;;;;;;;;;EA8Bb,CAAC;AAEd,MAAM,MAAM,yBAAyB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,oBAAoB,CAAC,CAAC;AAC7E,MAAM,MAAM,oBAAoB,GAAG,CAAC,CAAC,MAAM,CAAC,OAAO,oBAAoB,CAAC,CAAC;AAEzE;;;;;;;;;;;;;;;;;GAiBG;AACH,eAAO,MAAM,qBAAqB;;;;;;gCAKoC,CAAC;AAEvE;;;;;GAKG;AACH,MAAM,MAAM,eAAe,GACrB,uBAAuB,GACvB,oBAAoB,GACpB;IAAE,IAAI,EAAE,MAAM,CAAC;IAAC,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO,CAAA;CAAE,CAAC;AAG/C,OAAO,EAAE,uBAAuB,EAAE,oBAAoB,EAAE,CAAC"}

package/dist/blob/schemas.js

@@ -0,0 +1,25 @@
+import { z } from "zod";
+const BLOB_STORE_TYPES = ["in-memory", "local"];
+const InMemoryBlobStoreSchema = z.object({
+  type: z.literal("in-memory").describe("Blob store type identifier"),
+  maxBlobSize: z.number().int().positive().optional().default(10 * 1024 * 1024).describe("Maximum size per blob in bytes"),
+  maxTotalSize: z.number().int().positive().optional().default(100 * 1024 * 1024).describe("Maximum total storage size in bytes")
+}).strict();
+const LocalBlobStoreSchema = z.object({
+  type: z.literal("local").describe("Blob store type identifier"),
+  storePath: z.string().describe(
+    "Blob storage directory path (required for local storage - CLI enrichment provides per-agent default)"
+  ),
+  maxBlobSize: z.number().int().positive().optional().default(50 * 1024 * 1024).describe("Maximum size per blob in bytes"),
+  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.object({
+  type: z.string().describe("Blob store backend type")
+}).passthrough().describe("Blob store configuration (validated by image factory)");
+export {
+  BLOB_STORE_TYPES,
+  BlobStoreConfigSchema,
+  InMemoryBlobStoreSchema,
+  LocalBlobStoreSchema
+};

package/dist/blob/types.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 types_exports = {};
+module.exports = __toCommonJS(types_exports);

package/dist/blob/types.d.cts

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

package/dist/blob/types.d.ts

@@ -0,0 +1,2 @@
+export type { BlobStore, BlobInput, BlobMetadata, StoredBlobMetadata, BlobReference, BlobData, BlobStats, } from '@dexto/core';
+//# sourceMappingURL=types.d.ts.map

package/dist/blob/types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../src/blob/types.ts"],"names":[],"mappings":"AAAA,YAAY,EACR,SAAS,EACT,SAAS,EACT,YAAY,EACZ,kBAAkB,EAClB,aAAa,EACb,QAAQ,EACR,SAAS,GACZ,MAAM,aAAa,CAAC"}

package/dist/cache/factories/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 factories_exports = {};
+__export(factories_exports, {
+  inMemoryCacheFactory: () => import_memory.inMemoryCacheFactory,
+  redisCacheFactory: () => import_redis.redisCacheFactory
+});
+module.exports = __toCommonJS(factories_exports);
+var import_memory = require("./memory.js");
+var import_redis = require("./redis.js");
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  inMemoryCacheFactory,
+  redisCacheFactory
+});

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

@@ -0,0 +1,6 @@
+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/index.d.ts

@@ -0,0 +1,6 @@
+/**
+ * Built-in cache factories.
+ */
+export { inMemoryCacheFactory } from './memory.js';
+export { redisCacheFactory } from './redis.js';
+//# sourceMappingURL=index.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/cache/factories/index.ts"],"names":[],"mappings":"AAAA;;GAEG;AAEH,OAAO,EAAE,oBAAoB,EAAE,MAAM,aAAa,CAAC;AACnD,OAAO,EAAE,iBAAiB,EAAE,MAAM,YAAY,CAAC"}

package/dist/cache/factories/index.js

@@ -0,0 +1,6 @@
+import { inMemoryCacheFactory } from "./memory.js";
+import { redisCacheFactory } from "./redis.js";
+export {
+  inMemoryCacheFactory,
+  redisCacheFactory
+};