s3db.js 12.3.0 → 12.4.0

package/dist/s3db.es.js

@@ -5,7 +5,7 @@ import { mkdir, copyFile, unlink, stat, access, readdir, writeFile, readFile, rm
 import fs, { createReadStream, createWriteStream, realpathSync as realpathSync$1, readlinkSync, readdirSync, readdir as readdir$2, lstatSync, existsSync } from 'fs';
 import { pipeline } from 'stream/promises';
 import path$1, { join, dirname } from 'path';
-import { Transform, Writable } from 'stream';
+import { Transform, Writable, Readable } from 'stream';
 import zlib from 'node:zlib';
 import os from 'os';
 import jsonStableStringify from 'json-stable-stringify';
@@ -15,7 +15,7 @@ import { chunk, merge, isString, isEmpty, invert, uniq, cloneDeep, get, set, isO
 import { Agent } from 'http';
 import { Agent as Agent$1 } from 'https';
 import { NodeHttpHandler } from '@smithy/node-http-handler';
-import { S3Client, PutObjectCommand, GetObjectCommand, HeadObjectCommand, CopyObjectCommand, DeleteObjectCommand, DeleteObjectsCommand, ListObjectsV2Command } from '@aws-sdk/client-s3';
+import { S3Client as S3Client$1, PutObjectCommand, GetObjectCommand, HeadObjectCommand, CopyObjectCommand, DeleteObjectCommand, DeleteObjectsCommand, ListObjectsV2Command } from '@aws-sdk/client-s3';
 import { flatten, unflatten } from 'flat';
 import FastestValidator from 'fastest-validator';
 import { ReadableStream } from 'node:stream/web';
@@ -13424,7 +13424,7 @@ function generateMySQLAlterTable(tableName, attributes, existingSchema) {
   }
   return alterStatements;
 }
-function generateBigQuerySchema(attributes) {
+function generateBigQuerySchema(attributes, mutability = "append-only") {
   const fields = [];
   fields.push({
     name: "id",
@@ -13448,6 +13448,14 @@ function generateBigQuerySchema(attributes) {
   if (!attributes.updatedAt) {
     fields.push({ name: "updated_at", type: "TIMESTAMP", mode: "NULLABLE" });
   }
+  if (mutability === "append-only" || mutability === "immutable") {
+    fields.push({ name: "_operation_type", type: "STRING", mode: "NULLABLE" });
+    fields.push({ name: "_operation_timestamp", type: "TIMESTAMP", mode: "NULLABLE" });
+  }
+  if (mutability === "immutable") {
+    fields.push({ name: "_is_deleted", type: "BOOL", mode: "NULLABLE" });
+    fields.push({ name: "_version", type: "INT64", mode: "NULLABLE" });
+  }
   return fields;
 }
 async function getBigQueryTableSchema(bigqueryClient, datasetId, tableId) {
@@ -13469,7 +13477,7 @@ async function getBigQueryTableSchema(bigqueryClient, datasetId, tableId) {
   }
   return schema;
 }
-function generateBigQuerySchemaUpdate(attributes, existingSchema) {
+function generateBigQuerySchemaUpdate(attributes, existingSchema, mutability = "append-only") {
   const newFields = [];
   for (const [fieldName, fieldConfig] of Object.entries(attributes)) {
     if (fieldName === "id") continue;
@@ -13483,6 +13491,22 @@ function generateBigQuerySchemaUpdate(attributes, existingSchema) {
       mode: required ? "REQUIRED" : "NULLABLE"
     });
   }
+  if (mutability === "append-only" || mutability === "immutable") {
+    if (!existingSchema["_operation_type"]) {
+      newFields.push({ name: "_operation_type", type: "STRING", mode: "NULLABLE" });
+    }
+    if (!existingSchema["_operation_timestamp"]) {
+      newFields.push({ name: "_operation_timestamp", type: "TIMESTAMP", mode: "NULLABLE" });
+    }
+  }
+  if (mutability === "immutable") {
+    if (!existingSchema["_is_deleted"]) {
+      newFields.push({ name: "_is_deleted", type: "BOOL", mode: "NULLABLE" });
+    }
+    if (!existingSchema["_version"]) {
+      newFields.push({ name: "_version", type: "INT64", mode: "NULLABLE" });
+    }
+  }
   return newFields;
 }
 function s3dbTypeToSQLite(fieldType, fieldOptions = {}) {
@@ -13565,6 +13589,8 @@ class BigqueryReplicator extends BaseReplicator {
     this.credentials = config.credentials;
     this.location = config.location || "US";
     this.logTable = config.logTable;
+    this.mutability = config.mutability || "append-only";
+    this._validateMutability(this.mutability);
     this.schemaSync = {
       enabled: config.schemaSync?.enabled || false,
       strategy: config.schemaSync?.strategy || "alter",
@@ -13573,6 +13599,13 @@ class BigqueryReplicator extends BaseReplicator {
       autoCreateColumns: config.schemaSync?.autoCreateColumns !== false
     };
     this.resources = this.parseResourcesConfig(resources);
+    this.versionCounters = /* @__PURE__ */ new Map();
+  }
+  _validateMutability(mutability) {
+    const validModes = ["append-only", "mutable", "immutable"];
+    if (!validModes.includes(mutability)) {
+      throw new Error(`Invalid mutability mode: ${mutability}. Must be one of: ${validModes.join(", ")}`);
+    }
   }
   parseResourcesConfig(resources) {
     const parsed = {};
@@ -13581,24 +13614,31 @@ class BigqueryReplicator extends BaseReplicator {
         parsed[resourceName] = [{
           table: config,
           actions: ["insert"],
-          transform: null
+          transform: null,
+          mutability: this.mutability
         }];
       } else if (Array.isArray(config)) {
         parsed[resourceName] = config.map((item) => {
           if (typeof item === "string") {
-            return { table: item, actions: ["insert"], transform: null };
+            return { table: item, actions: ["insert"], transform: null, mutability: this.mutability };
           }
+          const itemMutability = item.mutability || this.mutability;
+          this._validateMutability(itemMutability);
           return {
             table: item.table,
             actions: item.actions || ["insert"],
-            transform: item.transform || null
+            transform: item.transform || null,
+            mutability: itemMutability
           };
         });
       } else if (typeof config === "object") {
+        const configMutability = config.mutability || this.mutability;
+        this._validateMutability(configMutability);
         parsed[resourceName] = [{
           table: config.table,
           actions: config.actions || ["insert"],
-          transform: config.transform || null
+          transform: config.transform || null,
+          mutability: configMutability
         }];
       }
     }
@@ -13677,8 +13717,9 @@ class BigqueryReplicator extends BaseReplicator {
       );
       for (const tableConfig of tableConfigs) {
         const tableName = tableConfig.table;
+        const mutability = tableConfig.mutability;
         const [okSync, errSync] = await tryFn(async () => {
-          await this.syncTableSchema(tableName, attributes);
+          await this.syncTableSchema(tableName, attributes, mutability);
         });
         if (!okSync) {
           const message = `Schema sync failed for table ${tableName}: ${errSync.message}`;
@@ -13698,7 +13739,7 @@ class BigqueryReplicator extends BaseReplicator {
   /**
    * Sync a single table schema in BigQuery
    */
-  async syncTableSchema(tableName, attributes) {
+  async syncTableSchema(tableName, attributes, mutability = "append-only") {
     const dataset = this.bigqueryClient.dataset(this.datasetId);
     const table = dataset.table(tableName);
     const [exists] = await table.exists();
@@ -13709,15 +13750,16 @@ class BigqueryReplicator extends BaseReplicator {
       if (this.schemaSync.strategy === "validate-only") {
         throw new Error(`Table ${tableName} does not exist (validate-only mode)`);
       }
-      const schema = generateBigQuerySchema(attributes);
+      const schema = generateBigQuerySchema(attributes, mutability);
       if (this.config.verbose) {
-        console.log(`[BigQueryReplicator] Creating table ${tableName} with schema:`, schema);
+        console.log(`[BigQueryReplicator] Creating table ${tableName} with schema (mutability: ${mutability}):`, schema);
       }
       await dataset.createTable(tableName, { schema });
       this.emit("table_created", {
         replicator: this.name,
         tableName,
-        attributes: Object.keys(attributes)
+        attributes: Object.keys(attributes),
+        mutability
       });
       return;
     }
@@ -13726,18 +13768,19 @@ class BigqueryReplicator extends BaseReplicator {
         console.warn(`[BigQueryReplicator] Dropping and recreating table ${tableName}`);
       }
       await table.delete();
-      const schema = generateBigQuerySchema(attributes);
+      const schema = generateBigQuerySchema(attributes, mutability);
       await dataset.createTable(tableName, { schema });
       this.emit("table_recreated", {
         replicator: this.name,
         tableName,
-        attributes: Object.keys(attributes)
+        attributes: Object.keys(attributes),
+        mutability
       });
       return;
     }
     if (this.schemaSync.strategy === "alter" && this.schemaSync.autoCreateColumns) {
       const existingSchema = await getBigQueryTableSchema(this.bigqueryClient, this.datasetId, tableName);
-      const newFields = generateBigQuerySchemaUpdate(attributes, existingSchema);
+      const newFields = generateBigQuerySchemaUpdate(attributes, existingSchema, mutability);
       if (newFields.length > 0) {
         if (this.config.verbose) {
           console.log(`[BigQueryReplicator] Adding ${newFields.length} field(s) to table ${tableName}:`, newFields);
@@ -13755,7 +13798,7 @@ class BigqueryReplicator extends BaseReplicator {
     }
     if (this.schemaSync.strategy === "validate-only") {
       const existingSchema = await getBigQueryTableSchema(this.bigqueryClient, this.datasetId, tableName);
-      const newFields = generateBigQuerySchemaUpdate(attributes, existingSchema);
+      const newFields = generateBigQuerySchemaUpdate(attributes, existingSchema, mutability);
       if (newFields.length > 0) {
         throw new Error(`Table ${tableName} schema mismatch. Missing columns: ${newFields.length}`);
       }
@@ -13774,7 +13817,8 @@ class BigqueryReplicator extends BaseReplicator {
     if (!this.resources[resourceName]) return [];
     return this.resources[resourceName].filter((tableConfig) => tableConfig.actions.includes(operation)).map((tableConfig) => ({
       table: tableConfig.table,
-      transform: tableConfig.transform
+      transform: tableConfig.transform,
+      mutability: tableConfig.mutability
     }));
   }
   applyTransform(data, transformFn) {
@@ -13793,6 +13837,32 @@ class BigqueryReplicator extends BaseReplicator {
     });
     return cleanData;
   }
+  /**
+   * Add tracking fields for append-only and immutable modes
+   * @private
+   */
+  _addTrackingFields(data, operation, mutability, id) {
+    const tracked = { ...data };
+    if (mutability === "append-only" || mutability === "immutable") {
+      tracked._operation_type = operation;
+      tracked._operation_timestamp = (/* @__PURE__ */ new Date()).toISOString();
+    }
+    if (mutability === "immutable") {
+      tracked._is_deleted = operation === "delete";
+      tracked._version = this._getNextVersion(id);
+    }
+    return tracked;
+  }
+  /**
+   * Get next version number for immutable mode
+   * @private
+   */
+  _getNextVersion(id) {
+    const current = this.versionCounters.get(id) || 0;
+    const next = current + 1;
+    this.versionCounters.set(id, next);
+    return next;
+  }
   async replicate(resourceName, operation, data, id, beforeData = null) {
     if (!this.enabled || !this.shouldReplicateResource(resourceName)) {
       return { skipped: true, reason: "resource_not_included" };
@@ -13811,9 +13881,14 @@ class BigqueryReplicator extends BaseReplicator {
       for (const tableConfig of tableConfigs) {
         const [okTable, errTable] = await tryFn(async () => {
           const table = dataset.table(tableConfig.table);
+          const mutability = tableConfig.mutability;
           let job;
-          if (operation === "insert") {
-            const transformedData = this.applyTransform(data, tableConfig.transform);
+          const shouldConvertToInsert = (mutability === "append-only" || mutability === "immutable") && (operation === "update" || operation === "delete");
+          if (operation === "insert" || shouldConvertToInsert) {
+            let transformedData = this.applyTransform(data, tableConfig.transform);
+            if (shouldConvertToInsert) {
+              transformedData = this._addTrackingFields(transformedData, operation, mutability, id);
+            }
             try {
               job = await table.insert([transformedData]);
             } catch (error) {
@@ -13825,7 +13900,7 @@ class BigqueryReplicator extends BaseReplicator {
               }
               throw error;
             }
-          } else if (operation === "update") {
+          } else if (operation === "update" && mutability === "mutable") {
             const transformedData = this.applyTransform(data, tableConfig.transform);
             const keys = Object.keys(transformedData).filter((k) => k !== "id");
             const setClause = keys.map((k) => `${k} = @${k}`).join(", ");
@@ -13867,7 +13942,7 @@ class BigqueryReplicator extends BaseReplicator {
               }
             }
             if (!job) throw lastError;
-          } else if (operation === "delete") {
+          } else if (operation === "delete" && mutability === "mutable") {
             const query = `DELETE FROM \`${this.projectId}.${this.datasetId}.${tableConfig.table}\` WHERE id = @id`;
             try {
               const [deleteJob] = await this.bigqueryClient.createQueryJob({
@@ -14003,7 +14078,8 @@ class BigqueryReplicator extends BaseReplicator {
       datasetId: this.datasetId,
       resources: this.resources,
       logTable: this.logTable,
-      schemaSync: this.schemaSync
+      schemaSync: this.schemaSync,
+      mutability: this.mutability
     };
   }
 }
@@ -15724,11 +15800,11 @@ class ConnectionString {
   }
 }
 
-class Client extends EventEmitter {
+class S3Client extends EventEmitter {
   constructor({
     verbose = false,
     id = null,
-    AwsS3Client,
+    AwsS3Client: AwsS3Client2,
     connectionString,
     parallelism = 10,
     httpClientOptions = {}
@@ -15751,7 +15827,7 @@ class Client extends EventEmitter {
       // 60 second timeout
       ...httpClientOptions
     };
-    this.client = AwsS3Client || this.createClient();
+    this.client = AwsS3Client2 || this.createClient();
   }
   createClient() {
     const httpAgent = new Agent(this.httpClientOptions);
@@ -15772,7 +15848,7 @@ class Client extends EventEmitter {
         secretAccessKey: this.config.secretAccessKey
       };
     }
-    const client = new S3Client(options);
+    const client = new S3Client$1(options);
     client.middlewareStack.add(
       (next, context) => async (args) => {
         if (context.commandName === "DeleteObjectsCommand") {
@@ -21309,7 +21385,7 @@ class Database extends EventEmitter {
     this.id = idGenerator(7);
     this.version = "1";
     this.s3dbVersion = (() => {
-      const [ok, err, version] = tryFn(() => true ? "12.3.0" : "latest");
+      const [ok, err, version] = tryFn(() => true ? "12.4.0" : "latest");
       return ok ? version : "latest";
     })();
     this._resourcesMap = {};
@@ -21365,7 +21441,7 @@ class Database extends EventEmitter {
         connectionString = `s3://${encodeURIComponent(accessKeyId)}:${encodeURIComponent(secretAccessKey)}@${bucket || "s3db"}?${params.toString()}`;
       }
     }
-    this.client = options.client || new Client({
+    this.client = options.client || new S3Client({
       verbose: this.verbose,
       parallelism: this.parallelism,
       connectionString
@@ -26271,7 +26347,7 @@ class S3TfStateDriver extends TfStateDriver {
    */
   async initialize() {
     const { bucket, credentials, region } = this.connectionConfig;
-    this.client = new Client({
+    this.client = new S3Client({
       bucketName: bucket,
       credentials,
       region
@@ -37897,6 +37973,1070 @@ class VectorPlugin extends Plugin {
   }
 }
 
+class MemoryStorage {
+  constructor(config = {}) {
+    this.objects = /* @__PURE__ */ new Map();
+    this.bucket = config.bucket || "s3db";
+    this.enforceLimits = config.enforceLimits || false;
+    this.metadataLimit = config.metadataLimit || 2048;
+    this.maxObjectSize = config.maxObjectSize || 5 * 1024 * 1024 * 1024;
+    this.persistPath = config.persistPath;
+    this.autoPersist = config.autoPersist || false;
+    this.verbose = config.verbose || false;
+  }
+  /**
+   * Generate ETag (MD5 hash) for object body
+   */
+  _generateETag(body) {
+    const buffer = Buffer.isBuffer(body) ? body : Buffer.from(body || "");
+    return createHash("md5").update(buffer).digest("hex");
+  }
+  /**
+   * Calculate metadata size in bytes
+   */
+  _calculateMetadataSize(metadata) {
+    if (!metadata) return 0;
+    let size = 0;
+    for (const [key, value] of Object.entries(metadata)) {
+      size += Buffer.byteLength(key, "utf8");
+      size += Buffer.byteLength(String(value), "utf8");
+    }
+    return size;
+  }
+  /**
+   * Validate limits if enforceLimits is enabled
+   */
+  _validateLimits(body, metadata) {
+    if (!this.enforceLimits) return;
+    const metadataSize = this._calculateMetadataSize(metadata);
+    if (metadataSize > this.metadataLimit) {
+      throw new Error(
+        `Metadata size (${metadataSize} bytes) exceeds limit of ${this.metadataLimit} bytes`
+      );
+    }
+    const bodySize = Buffer.isBuffer(body) ? body.length : Buffer.byteLength(body || "", "utf8");
+    if (bodySize > this.maxObjectSize) {
+      throw new Error(
+        `Object size (${bodySize} bytes) exceeds limit of ${this.maxObjectSize} bytes`
+      );
+    }
+  }
+  /**
+   * Store an object
+   */
+  async put(key, { body, metadata, contentType, contentEncoding, contentLength, ifMatch }) {
+    this._validateLimits(body, metadata);
+    if (ifMatch !== void 0) {
+      const existing = this.objects.get(key);
+      if (existing && existing.etag !== ifMatch) {
+        throw new Error(`Precondition failed: ETag mismatch for key "${key}"`);
+      }
+    }
+    const buffer = Buffer.isBuffer(body) ? body : Buffer.from(body || "");
+    const etag = this._generateETag(buffer);
+    const lastModified = (/* @__PURE__ */ new Date()).toISOString();
+    const size = buffer.length;
+    const objectData = {
+      body: buffer,
+      metadata: metadata || {},
+      contentType: contentType || "application/octet-stream",
+      etag,
+      lastModified,
+      size,
+      contentEncoding,
+      contentLength: contentLength || size
+    };
+    this.objects.set(key, objectData);
+    if (this.verbose) {
+      console.log(`[MemoryStorage] PUT ${key} (${size} bytes, etag: ${etag})`);
+    }
+    if (this.autoPersist && this.persistPath) {
+      await this.saveToDisk();
+    }
+    return {
+      ETag: etag,
+      VersionId: null,
+      // Memory storage doesn't support versioning
+      ServerSideEncryption: null,
+      Location: `/${this.bucket}/${key}`
+    };
+  }
+  /**
+   * Retrieve an object
+   */
+  async get(key) {
+    const obj = this.objects.get(key);
+    if (!obj) {
+      const error = new Error(`Object not found: ${key}`);
+      error.name = "NoSuchKey";
+      error.$metadata = {
+        httpStatusCode: 404,
+        requestId: "memory-" + Date.now(),
+        attempts: 1,
+        totalRetryDelay: 0
+      };
+      throw error;
+    }
+    if (this.verbose) {
+      console.log(`[MemoryStorage] GET ${key} (${obj.size} bytes)`);
+    }
+    const bodyStream = Readable.from(obj.body);
+    return {
+      Body: bodyStream,
+      Metadata: { ...obj.metadata },
+      ContentType: obj.contentType,
+      ContentLength: obj.size,
+      ETag: obj.etag,
+      LastModified: new Date(obj.lastModified),
+      ContentEncoding: obj.contentEncoding
+    };
+  }
+  /**
+   * Get object metadata only (like S3 HeadObject)
+   */
+  async head(key) {
+    const obj = this.objects.get(key);
+    if (!obj) {
+      const error = new Error(`Object not found: ${key}`);
+      error.name = "NoSuchKey";
+      error.$metadata = {
+        httpStatusCode: 404,
+        requestId: "memory-" + Date.now(),
+        attempts: 1,
+        totalRetryDelay: 0
+      };
+      throw error;
+    }
+    if (this.verbose) {
+      console.log(`[MemoryStorage] HEAD ${key}`);
+    }
+    return {
+      Metadata: { ...obj.metadata },
+      ContentType: obj.contentType,
+      ContentLength: obj.size,
+      ETag: obj.etag,
+      LastModified: new Date(obj.lastModified),
+      ContentEncoding: obj.contentEncoding
+    };
+  }
+  /**
+   * Copy an object
+   */
+  async copy(from, to, { metadata, metadataDirective, contentType }) {
+    const source = this.objects.get(from);
+    if (!source) {
+      const error = new Error(`Source object not found: ${from}`);
+      error.name = "NoSuchKey";
+      throw error;
+    }
+    let finalMetadata = { ...source.metadata };
+    if (metadataDirective === "REPLACE" && metadata) {
+      finalMetadata = metadata;
+    } else if (metadata) {
+      finalMetadata = { ...finalMetadata, ...metadata };
+    }
+    const result = await this.put(to, {
+      body: source.body,
+      metadata: finalMetadata,
+      contentType: contentType || source.contentType,
+      contentEncoding: source.contentEncoding
+    });
+    if (this.verbose) {
+      console.log(`[MemoryStorage] COPY ${from} \u2192 ${to}`);
+    }
+    return result;
+  }
+  /**
+   * Check if object exists
+   */
+  exists(key) {
+    return this.objects.has(key);
+  }
+  /**
+   * Delete an object
+   */
+  async delete(key) {
+    const existed = this.objects.has(key);
+    this.objects.delete(key);
+    if (this.verbose) {
+      console.log(`[MemoryStorage] DELETE ${key} (existed: ${existed})`);
+    }
+    if (this.autoPersist && this.persistPath) {
+      await this.saveToDisk();
+    }
+    return {
+      DeleteMarker: false,
+      VersionId: null
+    };
+  }
+  /**
+   * Delete multiple objects (batch)
+   */
+  async deleteMultiple(keys) {
+    const deleted = [];
+    const errors = [];
+    for (const key of keys) {
+      try {
+        await this.delete(key);
+        deleted.push({ Key: key });
+      } catch (error) {
+        errors.push({
+          Key: key,
+          Code: error.name || "InternalError",
+          Message: error.message
+        });
+      }
+    }
+    if (this.verbose) {
+      console.log(`[MemoryStorage] DELETE BATCH (${deleted.length} deleted, ${errors.length} errors)`);
+    }
+    return { Deleted: deleted, Errors: errors };
+  }
+  /**
+   * List objects with prefix/delimiter support
+   */
+  async list({ prefix = "", delimiter = null, maxKeys = 1e3, continuationToken = null }) {
+    const allKeys = Array.from(this.objects.keys());
+    let filteredKeys = prefix ? allKeys.filter((key) => key.startsWith(prefix)) : allKeys;
+    filteredKeys.sort();
+    let startIndex = 0;
+    if (continuationToken) {
+      startIndex = parseInt(continuationToken) || 0;
+    }
+    const paginatedKeys = filteredKeys.slice(startIndex, startIndex + maxKeys);
+    const isTruncated = startIndex + maxKeys < filteredKeys.length;
+    const nextContinuationToken = isTruncated ? String(startIndex + maxKeys) : null;
+    const commonPrefixes = /* @__PURE__ */ new Set();
+    const contents = [];
+    for (const key of paginatedKeys) {
+      if (delimiter && prefix) {
+        const suffix = key.substring(prefix.length);
+        const delimiterIndex = suffix.indexOf(delimiter);
+        if (delimiterIndex !== -1) {
+          const commonPrefix = prefix + suffix.substring(0, delimiterIndex + 1);
+          commonPrefixes.add(commonPrefix);
+          continue;
+        }
+      }
+      const obj = this.objects.get(key);
+      contents.push({
+        Key: key,
+        Size: obj.size,
+        LastModified: new Date(obj.lastModified),
+        ETag: obj.etag,
+        StorageClass: "STANDARD"
+      });
+    }
+    if (this.verbose) {
+      console.log(`[MemoryStorage] LIST prefix="${prefix}" (${contents.length} objects, ${commonPrefixes.size} prefixes)`);
+    }
+    return {
+      Contents: contents,
+      CommonPrefixes: Array.from(commonPrefixes).map((prefix2) => ({ Prefix: prefix2 })),
+      IsTruncated: isTruncated,
+      NextContinuationToken: nextContinuationToken,
+      KeyCount: contents.length + commonPrefixes.size,
+      MaxKeys: maxKeys,
+      Prefix: prefix,
+      Delimiter: delimiter
+    };
+  }
+  /**
+   * Create a snapshot of current state
+   */
+  snapshot() {
+    const snapshot = {
+      timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+      bucket: this.bucket,
+      objectCount: this.objects.size,
+      objects: {}
+    };
+    for (const [key, obj] of this.objects.entries()) {
+      snapshot.objects[key] = {
+        body: obj.body.toString("base64"),
+        metadata: obj.metadata,
+        contentType: obj.contentType,
+        etag: obj.etag,
+        lastModified: obj.lastModified,
+        size: obj.size,
+        contentEncoding: obj.contentEncoding,
+        contentLength: obj.contentLength
+      };
+    }
+    return snapshot;
+  }
+  /**
+   * Restore from a snapshot
+   */
+  restore(snapshot) {
+    if (!snapshot || !snapshot.objects) {
+      throw new Error("Invalid snapshot format");
+    }
+    this.objects.clear();
+    for (const [key, obj] of Object.entries(snapshot.objects)) {
+      this.objects.set(key, {
+        body: Buffer.from(obj.body, "base64"),
+        metadata: obj.metadata,
+        contentType: obj.contentType,
+        etag: obj.etag,
+        lastModified: obj.lastModified,
+        size: obj.size,
+        contentEncoding: obj.contentEncoding,
+        contentLength: obj.contentLength
+      });
+    }
+    if (this.verbose) {
+      console.log(`[MemoryStorage] Restored snapshot with ${this.objects.size} objects`);
+    }
+  }
+  /**
+   * Save current state to disk
+   */
+  async saveToDisk(customPath) {
+    const path = customPath || this.persistPath;
+    if (!path) {
+      throw new Error("No persist path configured");
+    }
+    const snapshot = this.snapshot();
+    const json = JSON.stringify(snapshot, null, 2);
+    const [ok, err] = await tryFn(() => writeFile(path, json, "utf-8"));
+    if (!ok) {
+      throw new Error(`Failed to save to disk: ${err.message}`);
+    }
+    if (this.verbose) {
+      console.log(`[MemoryStorage] Saved ${this.objects.size} objects to ${path}`);
+    }
+    return path;
+  }
+  /**
+   * Load state from disk
+   */
+  async loadFromDisk(customPath) {
+    const path = customPath || this.persistPath;
+    if (!path) {
+      throw new Error("No persist path configured");
+    }
+    const [ok, err, json] = await tryFn(() => readFile(path, "utf-8"));
+    if (!ok) {
+      throw new Error(`Failed to load from disk: ${err.message}`);
+    }
+    const snapshot = JSON.parse(json);
+    this.restore(snapshot);
+    if (this.verbose) {
+      console.log(`[MemoryStorage] Loaded ${this.objects.size} objects from ${path}`);
+    }
+    return snapshot;
+  }
+  /**
+   * Get storage statistics
+   */
+  getStats() {
+    let totalSize = 0;
+    const keys = [];
+    for (const [key, obj] of this.objects.entries()) {
+      totalSize += obj.size;
+      keys.push(key);
+    }
+    return {
+      objectCount: this.objects.size,
+      totalSize,
+      totalSizeFormatted: this._formatBytes(totalSize),
+      keys: keys.sort(),
+      bucket: this.bucket
+    };
+  }
+  /**
+   * Format bytes for human reading
+   */
+  _formatBytes(bytes) {
+    if (bytes === 0) return "0 Bytes";
+    const k = 1024;
+    const sizes = ["Bytes", "KB", "MB", "GB"];
+    const i = Math.floor(Math.log(bytes) / Math.log(k));
+    return Math.round(bytes / Math.pow(k, i) * 100) / 100 + " " + sizes[i];
+  }
+  /**
+   * Clear all objects
+   */
+  clear() {
+    this.objects.clear();
+    if (this.verbose) {
+      console.log(`[MemoryStorage] Cleared all objects`);
+    }
+  }
+}
+
+class MemoryClient extends EventEmitter {
+  constructor(config = {}) {
+    super();
+    this.id = config.id || idGenerator(77);
+    this.verbose = config.verbose || false;
+    this.parallelism = config.parallelism || 10;
+    this.bucket = config.bucket || "s3db";
+    this.keyPrefix = config.keyPrefix || "";
+    this.region = config.region || "us-east-1";
+    this.storage = new MemoryStorage({
+      bucket: this.bucket,
+      enforceLimits: config.enforceLimits || false,
+      metadataLimit: config.metadataLimit || 2048,
+      maxObjectSize: config.maxObjectSize || 5 * 1024 * 1024 * 1024,
+      persistPath: config.persistPath,
+      autoPersist: config.autoPersist || false,
+      verbose: this.verbose
+    });
+    this.config = {
+      bucket: this.bucket,
+      keyPrefix: this.keyPrefix,
+      region: this.region,
+      endpoint: "memory://localhost",
+      forcePathStyle: true
+    };
+    if (this.verbose) {
+      console.log(`[MemoryClient] Initialized (id: ${this.id}, bucket: ${this.bucket})`);
+    }
+  }
+  /**
+   * Simulate sendCommand from AWS SDK
+   * Used by Database/Resource to send AWS SDK commands
+   */
+  async sendCommand(command) {
+    const commandName = command.constructor.name;
+    const input = command.input || {};
+    this.emit("command.request", commandName, input);
+    let response;
+    try {
+      switch (commandName) {
+        case "PutObjectCommand":
+          response = await this._handlePutObject(input);
+          break;
+        case "GetObjectCommand":
+          response = await this._handleGetObject(input);
+          break;
+        case "HeadObjectCommand":
+          response = await this._handleHeadObject(input);
+          break;
+        case "CopyObjectCommand":
+          response = await this._handleCopyObject(input);
+          break;
+        case "DeleteObjectCommand":
+          response = await this._handleDeleteObject(input);
+          break;
+        case "DeleteObjectsCommand":
+          response = await this._handleDeleteObjects(input);
+          break;
+        case "ListObjectsV2Command":
+          response = await this._handleListObjects(input);
+          break;
+        default:
+          throw new Error(`Unsupported command: ${commandName}`);
+      }
+      this.emit("command.response", commandName, response, input);
+      return response;
+    } catch (error) {
+      const mappedError = mapAwsError(error, {
+        bucket: this.bucket,
+        key: input.Key,
+        commandName,
+        commandInput: input
+      });
+      throw mappedError;
+    }
+  }
+  /**
+   * PutObjectCommand handler
+   */
+  async _handlePutObject(input) {
+    const key = input.Key;
+    const metadata = input.Metadata || {};
+    const contentType = input.ContentType;
+    const body = input.Body;
+    const contentEncoding = input.ContentEncoding;
+    const contentLength = input.ContentLength;
+    const ifMatch = input.IfMatch;
+    return await this.storage.put(key, {
+      body,
+      metadata,
+      contentType,
+      contentEncoding,
+      contentLength,
+      ifMatch
+    });
+  }
+  /**
+   * GetObjectCommand handler
+   */
+  async _handleGetObject(input) {
+    const key = input.Key;
+    return await this.storage.get(key);
+  }
+  /**
+   * HeadObjectCommand handler
+   */
+  async _handleHeadObject(input) {
+    const key = input.Key;
+    return await this.storage.head(key);
+  }
+  /**
+   * CopyObjectCommand handler
+   */
+  async _handleCopyObject(input) {
+    const copySource = input.CopySource;
+    const parts = copySource.split("/");
+    const sourceKey = parts.slice(1).join("/");
+    const destinationKey = input.Key;
+    const metadata = input.Metadata;
+    const metadataDirective = input.MetadataDirective;
+    const contentType = input.ContentType;
+    return await this.storage.copy(sourceKey, destinationKey, {
+      metadata,
+      metadataDirective,
+      contentType
+    });
+  }
+  /**
+   * DeleteObjectCommand handler
+   */
+  async _handleDeleteObject(input) {
+    const key = input.Key;
+    return await this.storage.delete(key);
+  }
+  /**
+   * DeleteObjectsCommand handler
+   */
+  async _handleDeleteObjects(input) {
+    const objects = input.Delete?.Objects || [];
+    const keys = objects.map((obj) => obj.Key);
+    return await this.storage.deleteMultiple(keys);
+  }
+  /**
+   * ListObjectsV2Command handler
+   */
+  async _handleListObjects(input) {
+    const fullPrefix = this.keyPrefix && input.Prefix ? path$1.join(this.keyPrefix, input.Prefix) : this.keyPrefix || input.Prefix || "";
+    return await this.storage.list({
+      prefix: fullPrefix,
+      delimiter: input.Delimiter,
+      maxKeys: input.MaxKeys,
+      continuationToken: input.ContinuationToken
+    });
+  }
+  /**
+   * Put an object (Client interface method)
+   */
+  async putObject({ key, metadata, contentType, body, contentEncoding, contentLength, ifMatch }) {
+    const fullKey = this.keyPrefix ? path$1.join(this.keyPrefix, key) : key;
+    const stringMetadata = {};
+    if (metadata) {
+      for (const [k, v] of Object.entries(metadata)) {
+        const validKey = String(k).replace(/[^a-zA-Z0-9\-_]/g, "_");
+        const { encoded } = metadataEncode(v);
+        stringMetadata[validKey] = encoded;
+      }
+    }
+    const response = await this.storage.put(fullKey, {
+      body,
+      metadata: stringMetadata,
+      contentType,
+      contentEncoding,
+      contentLength,
+      ifMatch
+    });
+    this.emit("putObject", null, { key, metadata, contentType, body, contentEncoding, contentLength });
+    return response;
+  }
+  /**
+   * Get an object (Client interface method)
+   */
+  async getObject(key) {
+    const fullKey = this.keyPrefix ? path$1.join(this.keyPrefix, key) : key;
+    const response = await this.storage.get(fullKey);
+    const decodedMetadata = {};
+    if (response.Metadata) {
+      for (const [k, v] of Object.entries(response.Metadata)) {
+        decodedMetadata[k] = metadataDecode(v);
+      }
+    }
+    this.emit("getObject", null, { key });
+    return {
+      ...response,
+      Metadata: decodedMetadata
+    };
+  }
+  /**
+   * Head object (get metadata only)
+   */
+  async headObject(key) {
+    const fullKey = this.keyPrefix ? path$1.join(this.keyPrefix, key) : key;
+    const response = await this.storage.head(fullKey);
+    const decodedMetadata = {};
+    if (response.Metadata) {
+      for (const [k, v] of Object.entries(response.Metadata)) {
+        decodedMetadata[k] = metadataDecode(v);
+      }
+    }
+    this.emit("headObject", null, { key });
+    return {
+      ...response,
+      Metadata: decodedMetadata
+    };
+  }
+  /**
+   * Copy an object
+   */
+  async copyObject({ from, to, metadata, metadataDirective, contentType }) {
+    const fullFrom = this.keyPrefix ? path$1.join(this.keyPrefix, from) : from;
+    const fullTo = this.keyPrefix ? path$1.join(this.keyPrefix, to) : to;
+    const encodedMetadata = {};
+    if (metadata) {
+      for (const [k, v] of Object.entries(metadata)) {
+        const validKey = String(k).replace(/[^a-zA-Z0-9\-_]/g, "_");
+        const { encoded } = metadataEncode(v);
+        encodedMetadata[validKey] = encoded;
+      }
+    }
+    const response = await this.storage.copy(fullFrom, fullTo, {
+      metadata: encodedMetadata,
+      metadataDirective,
+      contentType
+    });
+    this.emit("copyObject", null, { from, to, metadata, metadataDirective });
+    return response;
+  }
+  /**
+   * Check if object exists
+   */
+  async exists(key) {
+    const fullKey = this.keyPrefix ? path$1.join(this.keyPrefix, key) : key;
+    return this.storage.exists(fullKey);
+  }
+  /**
+   * Delete an object
+   */
+  async deleteObject(key) {
+    const fullKey = this.keyPrefix ? path$1.join(this.keyPrefix, key) : key;
+    const response = await this.storage.delete(fullKey);
+    this.emit("deleteObject", null, { key });
+    return response;
+  }
+  /**
+   * Delete multiple objects (batch)
+   */
+  async deleteObjects(keys) {
+    const fullKeys = keys.map(
+      (key) => this.keyPrefix ? path$1.join(this.keyPrefix, key) : key
+    );
+    const batches = chunk(fullKeys, this.parallelism);
+    const allResults = { Deleted: [], Errors: [] };
+    const { results } = await PromisePool.withConcurrency(this.parallelism).for(batches).process(async (batch) => {
+      return await this.storage.deleteMultiple(batch);
+    });
+    for (const result of results) {
+      allResults.Deleted.push(...result.Deleted);
+      allResults.Errors.push(...result.Errors);
+    }
+    this.emit("deleteObjects", null, { keys, count: allResults.Deleted.length });
+    return allResults;
+  }
+  /**
+   * List objects with pagination support
+   */
+  async listObjects({ prefix = "", delimiter = null, maxKeys = 1e3, continuationToken = null }) {
+    const fullPrefix = this.keyPrefix ? path$1.join(this.keyPrefix, prefix) : prefix;
+    const response = await this.storage.list({
+      prefix: fullPrefix,
+      delimiter,
+      maxKeys,
+      continuationToken
+    });
+    this.emit("listObjects", null, { prefix, count: response.Contents.length });
+    return response;
+  }
+  /**
+   * Get a page of keys with offset/limit pagination
+   */
+  async getKeysPage(params = {}) {
+    const { prefix = "", offset = 0, amount = 100 } = params;
+    let keys = [];
+    let truncated = true;
+    let continuationToken;
+    if (offset > 0) {
+      const fullPrefix = this.keyPrefix ? path$1.join(this.keyPrefix, prefix) : prefix;
+      const response = await this.storage.list({
+        prefix: fullPrefix,
+        maxKeys: offset + amount
+      });
+      keys = response.Contents.map((x) => x.Key).slice(offset, offset + amount);
+    } else {
+      while (truncated) {
+        const options = {
+          prefix,
+          continuationToken,
+          maxKeys: amount - keys.length
+        };
+        const res = await this.listObjects(options);
+        if (res.Contents) {
+          keys = keys.concat(res.Contents.map((x) => x.Key));
+        }
+        truncated = res.IsTruncated || false;
+        continuationToken = res.NextContinuationToken;
+        if (keys.length >= amount) {
+          keys = keys.slice(0, amount);
+          break;
+        }
+      }
+    }
+    if (this.keyPrefix) {
+      keys = keys.map((x) => x.replace(this.keyPrefix, "")).map((x) => x.startsWith("/") ? x.replace("/", "") : x);
+    }
+    this.emit("getKeysPage", keys, params);
+    return keys;
+  }
+  /**
+   * Get all keys with a given prefix
+   */
+  async getAllKeys({ prefix = "" }) {
+    const fullPrefix = this.keyPrefix ? path$1.join(this.keyPrefix, prefix) : prefix;
+    const response = await this.storage.list({
+      prefix: fullPrefix,
+      maxKeys: 1e5
+      // Large number to get all
+    });
+    let keys = response.Contents.map((x) => x.Key);
+    if (this.keyPrefix) {
+      keys = keys.map((x) => x.replace(this.keyPrefix, "")).map((x) => x.startsWith("/") ? x.replace("/", "") : x);
+    }
+    this.emit("getAllKeys", keys, { prefix });
+    return keys;
+  }
+  /**
+   * Count total objects under a prefix
+   */
+  async count({ prefix = "" } = {}) {
+    const keys = await this.getAllKeys({ prefix });
+    const count = keys.length;
+    this.emit("count", count, { prefix });
+    return count;
+  }
+  /**
+   * Delete all objects under a prefix
+   */
+  async deleteAll({ prefix = "" } = {}) {
+    const keys = await this.getAllKeys({ prefix });
+    let totalDeleted = 0;
+    if (keys.length > 0) {
+      const result = await this.deleteObjects(keys);
+      totalDeleted = result.Deleted.length;
+      this.emit("deleteAll", {
+        prefix,
+        batch: totalDeleted,
+        total: totalDeleted
+      });
+    }
+    this.emit("deleteAllComplete", {
+      prefix,
+      totalDeleted
+    });
+    return totalDeleted;
+  }
+  /**
+   * Get continuation token after skipping offset items
+   */
+  async getContinuationTokenAfterOffset({ prefix = "", offset = 1e3 } = {}) {
+    if (offset === 0) return null;
+    const keys = await this.getAllKeys({ prefix });
+    if (offset >= keys.length) {
+      this.emit("getContinuationTokenAfterOffset", null, { prefix, offset });
+      return null;
+    }
+    const token = keys[offset];
+    this.emit("getContinuationTokenAfterOffset", token, { prefix, offset });
+    return token;
+  }
+  /**
+   * Move an object from one key to another
+   */
+  async moveObject({ from, to }) {
+    await this.copyObject({ from, to, metadataDirective: "COPY" });
+    await this.deleteObject(from);
+  }
+  /**
+   * Move all objects from one prefix to another
+   */
+  async moveAllObjects({ prefixFrom, prefixTo }) {
+    const keys = await this.getAllKeys({ prefix: prefixFrom });
+    const results = [];
+    const errors = [];
+    for (const key of keys) {
+      try {
+        const to = key.replace(prefixFrom, prefixTo);
+        await this.moveObject({ from: key, to });
+        results.push(to);
+      } catch (error) {
+        errors.push({
+          message: error.message,
+          raw: error,
+          key
+        });
+      }
+    }
+    this.emit("moveAllObjects", { results, errors }, { prefixFrom, prefixTo });
+    if (errors.length > 0) {
+      const error = new Error("Some objects could not be moved");
+      error.context = {
+        bucket: this.bucket,
+        operation: "moveAllObjects",
+        prefixFrom,
+        prefixTo,
+        totalKeys: keys.length,
+        failedCount: errors.length,
+        successCount: results.length,
+        errors
+      };
+      throw error;
+    }
+    return results;
+  }
+  /**
+   * Create a snapshot of current storage state
+   */
+  snapshot() {
+    return this.storage.snapshot();
+  }
+  /**
+   * Restore from a snapshot
+   */
+  restore(snapshot) {
+    return this.storage.restore(snapshot);
+  }
+  /**
+   * Save current state to disk (persistence)
+   */
+  async saveToDisk(path2) {
+    return await this.storage.saveToDisk(path2);
+  }
+  /**
+   * Load state from disk
+   */
+  async loadFromDisk(path2) {
+    return await this.storage.loadFromDisk(path2);
+  }
+  /**
+   * Export to BackupPlugin-compatible format (s3db.json + JSONL files)
+   * Compatible with BackupPlugin for easy migration
+   *
+   * @param {string} outputDir - Output directory path
+   * @param {Object} options - Export options
+   * @param {Array<string>} options.resources - Resource names to export (default: all)
+   * @param {boolean} options.compress - Use gzip compression (default: true)
+   * @param {Object} options.database - Database instance for schema metadata
+   * @returns {Promise<Object>} Export manifest with file paths and stats
+   */
+  async exportBackup(outputDir, options = {}) {
+    const { mkdir, writeFile } = await import('fs/promises');
+    const zlib = await import('zlib');
+    const { promisify } = await import('util');
+    const gzip = promisify(zlib.gzip);
+    await mkdir(outputDir, { recursive: true });
+    const compress = options.compress !== false;
+    const database = options.database;
+    const resourceFilter = options.resources;
+    const allKeys = await this.getAllKeys({});
+    const resourceMap = /* @__PURE__ */ new Map();
+    for (const key of allKeys) {
+      const match = key.match(/^resource=([^/]+)\//);
+      if (match) {
+        const resourceName = match[1];
+        if (!resourceFilter || resourceFilter.includes(resourceName)) {
+          if (!resourceMap.has(resourceName)) {
+            resourceMap.set(resourceName, []);
+          }
+          resourceMap.get(resourceName).push(key);
+        }
+      }
+    }
+    const exportedFiles = {};
+    const resourceStats = {};
+    for (const [resourceName, keys] of resourceMap.entries()) {
+      const records = [];
+      for (const key of keys) {
+        const obj = await this.getObject(key);
+        const idMatch = key.match(/\/id=([^/]+)/);
+        const recordId = idMatch ? idMatch[1] : null;
+        const record = { ...obj.Metadata };
+        if (recordId && !record.id) {
+          record.id = recordId;
+        }
+        if (obj.Body) {
+          const chunks = [];
+          for await (const chunk2 of obj.Body) {
+            chunks.push(chunk2);
+          }
+          const bodyBuffer = Buffer.concat(chunks);
+          const bodyStr = bodyBuffer.toString("utf-8");
+          if (bodyStr.startsWith("{") || bodyStr.startsWith("[")) {
+            try {
+              const bodyData = JSON.parse(bodyStr);
+              Object.assign(record, bodyData);
+            } catch {
+              record._body = bodyStr;
+            }
+          } else if (bodyStr) {
+            record._body = bodyStr;
+          }
+        }
+        records.push(record);
+      }
+      const jsonl = records.map((r) => JSON.stringify(r)).join("\n");
+      const filename = compress ? `${resourceName}.jsonl.gz` : `${resourceName}.jsonl`;
+      const filePath = `${outputDir}/${filename}`;
+      if (compress) {
+        const compressed = await gzip(jsonl);
+        await writeFile(filePath, compressed);
+      } else {
+        await writeFile(filePath, jsonl, "utf-8");
+      }
+      exportedFiles[resourceName] = filePath;
+      resourceStats[resourceName] = {
+        recordCount: records.length,
+        fileSize: compress ? (await gzip(jsonl)).length : Buffer.byteLength(jsonl)
+      };
+    }
+    const s3dbMetadata = {
+      version: "1.0",
+      timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+      bucket: this.bucket,
+      keyPrefix: this.keyPrefix || "",
+      compressed: compress,
+      resources: {},
+      totalRecords: 0,
+      totalSize: 0
+    };
+    if (database && database.resources) {
+      for (const [resourceName, resource] of Object.entries(database.resources)) {
+        if (resourceMap.has(resourceName)) {
+          s3dbMetadata.resources[resourceName] = {
+            schema: resource.schema ? {
+              attributes: resource.schema.attributes,
+              partitions: resource.schema.partitions,
+              behavior: resource.schema.behavior,
+              timestamps: resource.schema.timestamps
+            } : null,
+            stats: resourceStats[resourceName]
+          };
+        }
+      }
+    } else {
+      for (const [resourceName, stats] of Object.entries(resourceStats)) {
+        s3dbMetadata.resources[resourceName] = { stats };
+      }
+    }
+    for (const stats of Object.values(resourceStats)) {
+      s3dbMetadata.totalRecords += stats.recordCount;
+      s3dbMetadata.totalSize += stats.fileSize;
+    }
+    const s3dbPath = `${outputDir}/s3db.json`;
+    await writeFile(s3dbPath, JSON.stringify(s3dbMetadata, null, 2), "utf-8");
+    return {
+      manifest: s3dbPath,
+      files: exportedFiles,
+      stats: s3dbMetadata,
+      resourceCount: resourceMap.size,
+      totalRecords: s3dbMetadata.totalRecords,
+      totalSize: s3dbMetadata.totalSize
+    };
+  }
+  /**
+   * Import from BackupPlugin-compatible format
+   * Loads data from s3db.json + JSONL files created by BackupPlugin or exportBackup()
+   *
+   * @param {string} backupDir - Backup directory path containing s3db.json
+   * @param {Object} options - Import options
+   * @param {Array<string>} options.resources - Resource names to import (default: all)
+   * @param {boolean} options.clear - Clear existing data first (default: false)
+   * @param {Object} options.database - Database instance to recreate schemas
+   * @returns {Promise<Object>} Import stats
+   */
+  async importBackup(backupDir, options = {}) {
+    const { readFile, readdir } = await import('fs/promises');
+    const zlib = await import('zlib');
+    const { promisify } = await import('util');
+    const gunzip = promisify(zlib.gunzip);
+    if (options.clear) {
+      this.clear();
+    }
+    const s3dbPath = `${backupDir}/s3db.json`;
+    const s3dbContent = await readFile(s3dbPath, "utf-8");
+    const metadata = JSON.parse(s3dbContent);
+    const database = options.database;
+    const resourceFilter = options.resources;
+    const importStats = {
+      resourcesImported: 0,
+      recordsImported: 0,
+      errors: []
+    };
+    if (database && metadata.resources) {
+      for (const [resourceName, resourceMeta] of Object.entries(metadata.resources)) {
+        if (resourceFilter && !resourceFilter.includes(resourceName)) continue;
+        if (resourceMeta.schema) {
+          try {
+            await database.createResource({
+              name: resourceName,
+              ...resourceMeta.schema
+            });
+          } catch (error) {
+          }
+        }
+      }
+    }
+    const files = await readdir(backupDir);
+    for (const file of files) {
+      if (!file.endsWith(".jsonl") && !file.endsWith(".jsonl.gz")) continue;
+      const resourceName = file.replace(/\.jsonl(\.gz)?$/, "");
+      if (resourceFilter && !resourceFilter.includes(resourceName)) continue;
+      const filePath = `${backupDir}/${file}`;
+      let content = await readFile(filePath);
+      if (file.endsWith(".gz")) {
+        content = await gunzip(content);
+      }
+      const jsonl = content.toString("utf-8");
+      const lines = jsonl.split("\n").filter((line) => line.trim());
+      for (const line of lines) {
+        try {
+          const record = JSON.parse(line);
+          const id = record.id || record._id || `imported_${Date.now()}_${Math.random()}`;
+          const { _body, id: _, _id: __, ...metadata2 } = record;
+          await this.putObject({
+            key: `resource=${resourceName}/id=${id}`,
+            metadata: metadata2,
+            body: _body ? Buffer.from(_body) : void 0
+          });
+          importStats.recordsImported++;
+        } catch (error) {
+          importStats.errors.push({
+            resource: resourceName,
+            error: error.message,
+            line
+          });
+        }
+      }
+      importStats.resourcesImported++;
+    }
+    return importStats;
+  }
+  /**
+   * Get storage statistics
+   */
+  getStats() {
+    return this.storage.getStats();
+  }
+  /**
+   * Clear all objects
+   */
+  clear() {
+    this.storage.clear();
+  }
+}
+
 function mapFieldTypeToTypeScript(fieldType) {
   const baseType = fieldType.split("|")[0].trim();
   const typeMap = {
@@ -38802,5 +39942,5 @@ var metrics = /*#__PURE__*/Object.freeze({
   silhouetteScore: silhouetteScore
 });
 
-export { AVAILABLE_BEHAVIORS, AnalyticsNotEnabledError, ApiPlugin, AuditPlugin, AuthenticationError, BACKUP_DRIVERS, BackupPlugin, BaseBackupDriver, BaseError, BaseReplicator, BehaviorError, BigqueryReplicator, CONSUMER_DRIVERS, Cache, CachePlugin, Client, ConnectionString, ConnectionStringError, CostsPlugin, CryptoError, DEFAULT_BEHAVIOR, Database, DatabaseError, DynamoDBReplicator, EncryptionError, ErrorMap, EventualConsistencyPlugin, Factory, FilesystemBackupDriver, FilesystemCache, FullTextPlugin, GeoPlugin, InvalidResourceItem, MemoryCache, MetadataLimitError, MetricsPlugin, MissingMetadata, MongoDBReplicator, MultiBackupDriver, MySQLReplicator, NoSuchBucket, NoSuchKey, NotFound, PartitionAwareFilesystemCache, PartitionDriverError, PartitionError, PermissionError, PlanetScaleReplicator, Plugin, PluginError, PluginObject, PluginStorageError, PostgresReplicator, QueueConsumerPlugin, REPLICATOR_DRIVERS, RabbitMqConsumer, RelationPlugin, ReplicatorPlugin, Resource, ResourceError, ResourceIdsPageReader, ResourceIdsReader, ResourceNotFound, ResourceReader, ResourceWriter, S3BackupDriver, S3Cache, S3QueuePlugin, Database as S3db, S3dbError, S3dbReplicator, SchedulerPlugin, Schema, SchemaError, Seeder, SqsConsumer, SqsReplicator, StateMachinePlugin, StreamError, TTLPlugin, TfStatePlugin, TursoReplicator, UnknownError, ValidationError, Validator, VectorPlugin, WebhookReplicator, behaviors, calculateAttributeNamesSize, calculateAttributeSizes, calculateEffectiveLimit, calculateSystemOverhead, calculateTotalSize, calculateUTF8Bytes, clearUTF8Memory, createBackupDriver, createConsumer, createReplicator, decode, decodeDecimal, decodeFixedPoint, decodeFixedPointBatch, decrypt, S3db as default, encode, encodeDecimal, encodeFixedPoint, encodeFixedPointBatch, encrypt, generateTypes, getBehavior, getSizeBreakdown, idGenerator, mapAwsError, md5, passwordGenerator, printTypes, sha256, streamToString, transformValue, tryFn, tryFnSync, validateBackupConfig, validateReplicatorConfig };
+export { AVAILABLE_BEHAVIORS, AnalyticsNotEnabledError, ApiPlugin, AuditPlugin, AuthenticationError, BACKUP_DRIVERS, BackupPlugin, BaseBackupDriver, BaseError, BaseReplicator, BehaviorError, BigqueryReplicator, CONSUMER_DRIVERS, Cache, CachePlugin, S3Client as Client, ConnectionString, ConnectionStringError, CostsPlugin, CryptoError, DEFAULT_BEHAVIOR, Database, DatabaseError, DynamoDBReplicator, EncryptionError, ErrorMap, EventualConsistencyPlugin, Factory, FilesystemBackupDriver, FilesystemCache, FullTextPlugin, GeoPlugin, InvalidResourceItem, MemoryCache, MemoryClient, MemoryStorage, MetadataLimitError, MetricsPlugin, MissingMetadata, MongoDBReplicator, MultiBackupDriver, MySQLReplicator, NoSuchBucket, NoSuchKey, NotFound, PartitionAwareFilesystemCache, PartitionDriverError, PartitionError, PermissionError, PlanetScaleReplicator, Plugin, PluginError, PluginObject, PluginStorageError, PostgresReplicator, QueueConsumerPlugin, REPLICATOR_DRIVERS, RabbitMqConsumer, RelationPlugin, ReplicatorPlugin, Resource, ResourceError, ResourceIdsPageReader, ResourceIdsReader, ResourceNotFound, ResourceReader, ResourceWriter, S3BackupDriver, S3Cache, S3Client, S3QueuePlugin, Database as S3db, S3dbError, S3dbReplicator, SchedulerPlugin, Schema, SchemaError, Seeder, SqsConsumer, SqsReplicator, StateMachinePlugin, StreamError, TTLPlugin, TfStatePlugin, TursoReplicator, UnknownError, ValidationError, Validator, VectorPlugin, WebhookReplicator, behaviors, calculateAttributeNamesSize, calculateAttributeSizes, calculateEffectiveLimit, calculateSystemOverhead, calculateTotalSize, calculateUTF8Bytes, clearUTF8Memory, createBackupDriver, createConsumer, createReplicator, decode, decodeDecimal, decodeFixedPoint, decodeFixedPointBatch, decrypt, S3db as default, encode, encodeDecimal, encodeFixedPoint, encodeFixedPointBatch, encrypt, generateTypes, getBehavior, getSizeBreakdown, idGenerator, mapAwsError, md5, passwordGenerator, printTypes, sha256, streamToString, transformValue, tryFn, tryFnSync, validateBackupConfig, validateReplicatorConfig };
 //# sourceMappingURL=s3db.es.js.map