s3db.js 12.2.4 → 12.4.0

package/dist/s3db.cjs.js

@@ -13447,7 +13447,7 @@ function generateMySQLAlterTable(tableName, attributes, existingSchema) {
   }
   return alterStatements;
 }
-function generateBigQuerySchema(attributes) {
+function generateBigQuerySchema(attributes, mutability = "append-only") {
   const fields = [];
   fields.push({
     name: "id",
@@ -13471,6 +13471,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) {
@@ -13492,7 +13500,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;
@@ -13506,6 +13514,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 = {}) {
@@ -13588,6 +13612,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",
@@ -13596,6 +13622,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 = {};
@@ -13604,24 +13637,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
         }];
       }
     }
@@ -13693,11 +13733,16 @@ class BigqueryReplicator extends BaseReplicator {
         }
         continue;
       }
-      const attributes = resource.config.versions[resource.config.currentVersion]?.attributes || {};
+      const allAttributes = resource.config.versions[resource.config.currentVersion]?.attributes || {};
+      const pluginAttrNames = resource.schema?._pluginAttributes ? Object.values(resource.schema._pluginAttributes).flat() : [];
+      const attributes = Object.fromEntries(
+        Object.entries(allAttributes).filter(([name]) => !pluginAttrNames.includes(name))
+      );
       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}`;
@@ -13717,7 +13762,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();
@@ -13728,15 +13773,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;
     }
@@ -13745,18 +13791,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);
@@ -13774,7 +13821,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}`);
       }
@@ -13793,7 +13840,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) {
@@ -13812,6 +13860,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" };
@@ -13830,9 +13904,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) {
@@ -13844,7 +13923,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(", ");
@@ -13886,7 +13965,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({
@@ -14022,7 +14101,8 @@ class BigqueryReplicator extends BaseReplicator {
       datasetId: this.datasetId,
       resources: this.resources,
       logTable: this.logTable,
-      schemaSync: this.schemaSync
+      schemaSync: this.schemaSync,
+      mutability: this.mutability
     };
   }
 }
@@ -14711,7 +14791,11 @@ class MySQLReplicator extends BaseReplicator {
         }
         continue;
       }
-      const attributes = resource.config.versions[resource.config.currentVersion]?.attributes || {};
+      const allAttributes = resource.config.versions[resource.config.currentVersion]?.attributes || {};
+      const pluginAttrNames = resource.schema?._pluginAttributes ? Object.values(resource.schema._pluginAttributes).flat() : [];
+      const attributes = Object.fromEntries(
+        Object.entries(allAttributes).filter(([name]) => !pluginAttrNames.includes(name))
+      );
       for (const tableConfig of tableConfigs) {
         const tableName = tableConfig.table;
         const [okSync, errSync] = await tryFn(async () => {
@@ -15090,7 +15174,11 @@ class PlanetScaleReplicator extends BaseReplicator {
         }
         continue;
       }
-      const attributes = resource.config.versions[resource.config.currentVersion]?.attributes || {};
+      const allAttributes = resource.config.versions[resource.config.currentVersion]?.attributes || {};
+      const pluginAttrNames = resource.schema?._pluginAttributes ? Object.values(resource.schema._pluginAttributes).flat() : [];
+      const attributes = Object.fromEntries(
+        Object.entries(allAttributes).filter(([name]) => !pluginAttrNames.includes(name))
+      );
       for (const tableConfig of tableConfigs) {
         const tableName = tableConfig.table;
         const [okSync, errSync] = await tryFn(async () => {
@@ -15411,7 +15499,11 @@ class PostgresReplicator extends BaseReplicator {
         }
         continue;
       }
-      const attributes = resource.config.versions[resource.config.currentVersion]?.attributes || {};
+      const allAttributes = resource.config.versions[resource.config.currentVersion]?.attributes || {};
+      const pluginAttrNames = resource.schema?._pluginAttributes ? Object.values(resource.schema._pluginAttributes).flat() : [];
+      const attributes = Object.fromEntries(
+        Object.entries(allAttributes).filter(([name]) => !pluginAttrNames.includes(name))
+      );
       for (const tableConfig of tableConfigs) {
         const tableName = tableConfig.table;
         const [okSync, errSync] = await tryFn(async () => {
@@ -15731,11 +15823,11 @@ class ConnectionString {
   }
 }
 
-class Client extends EventEmitter {
+class S3Client extends EventEmitter {
   constructor({
     verbose = false,
     id = null,
-    AwsS3Client,
+    AwsS3Client: AwsS3Client2,
     connectionString,
     parallelism = 10,
     httpClientOptions = {}
@@ -15758,7 +15850,7 @@ class Client extends EventEmitter {
       // 60 second timeout
       ...httpClientOptions
     };
-    this.client = AwsS3Client || this.createClient();
+    this.client = AwsS3Client2 || this.createClient();
   }
   createClient() {
     const httpAgent = new http.Agent(this.httpClientOptions);
@@ -16533,6 +16625,32 @@ function generateBase62Mapping(keys) {
   });
   return { mapping, reversedMapping };
 }
+function generatePluginAttributeHash(pluginName, attributeName) {
+  const input = `${pluginName}:${attributeName}`;
+  const hash = crypto$1.createHash("sha256").update(input).digest();
+  const num = hash.readUInt32BE(0);
+  const base62Hash = encode(num);
+  const paddedHash = base62Hash.padStart(3, "0").substring(0, 3);
+  return "p" + paddedHash.toLowerCase();
+}
+function generatePluginMapping(attributes) {
+  const mapping = {};
+  const reversedMapping = {};
+  const usedHashes = /* @__PURE__ */ new Set();
+  for (const { key, pluginName } of attributes) {
+    let hash = generatePluginAttributeHash(pluginName, key);
+    let counter = 1;
+    let finalHash = hash;
+    while (usedHashes.has(finalHash)) {
+      finalHash = `${hash}${counter}`;
+      counter++;
+    }
+    usedHashes.add(finalHash);
+    mapping[key] = finalHash;
+    reversedMapping[finalHash] = key;
+  }
+  return { mapping, reversedMapping };
+}
 const SchemaActions = {
   trim: (value) => value == null ? value : value.trim(),
   encrypt: async (value, { passphrase }) => {
@@ -16923,11 +17041,14 @@ class Schema {
   constructor(args) {
     const {
       map,
+      pluginMap,
       name,
       attributes,
       passphrase,
       version = 1,
-      options = {}
+      options = {},
+      _pluginAttributeMetadata,
+      _pluginAttributes
     } = args;
     this.name = name;
     this.version = version;
@@ -16935,6 +17056,8 @@ class Schema {
     this.passphrase = passphrase ?? "secret";
     this.options = lodashEs.merge({}, this.defaultOptions(), options);
     this.allNestedObjectsOptional = this.options.allNestedObjectsOptional ?? false;
+    this._pluginAttributeMetadata = _pluginAttributeMetadata || {};
+    this._pluginAttributes = _pluginAttributes || {};
     const processedAttributes = this.preprocessAttributesForValidation(this.attributes);
     this.validator = new ValidatorManager({ autoEncrypt: false }).compile(lodashEs.merge(
       { $$async: true, $$strict: false },
@@ -16949,9 +17072,43 @@ class Schema {
       const leafKeys = Object.keys(flatAttrs).filter((k) => !k.includes("$$"));
       const objectKeys = this.extractObjectKeys(this.attributes);
       const allKeys = [.../* @__PURE__ */ new Set([...leafKeys, ...objectKeys])];
-      const { mapping, reversedMapping } = generateBase62Mapping(allKeys);
+      const userKeys = [];
+      const pluginAttributes = [];
+      for (const key of allKeys) {
+        const attrDef = this.getAttributeDefinition(key);
+        if (typeof attrDef === "object" && attrDef !== null && attrDef.__plugin__) {
+          pluginAttributes.push({ key, pluginName: attrDef.__plugin__ });
+        } else if (typeof attrDef === "string" && this._pluginAttributeMetadata && this._pluginAttributeMetadata[key]) {
+          const pluginName = this._pluginAttributeMetadata[key].__plugin__;
+          pluginAttributes.push({ key, pluginName });
+        } else {
+          userKeys.push(key);
+        }
+      }
+      const { mapping, reversedMapping } = generateBase62Mapping(userKeys);
       this.map = mapping;
       this.reversedMap = reversedMapping;
+      const { mapping: pMapping, reversedMapping: pReversedMapping } = generatePluginMapping(pluginAttributes);
+      this.pluginMap = pMapping;
+      this.reversedPluginMap = pReversedMapping;
+      this._pluginAttributes = {};
+      for (const { key, pluginName } of pluginAttributes) {
+        if (!this._pluginAttributes[pluginName]) {
+          this._pluginAttributes[pluginName] = [];
+        }
+        this._pluginAttributes[pluginName].push(key);
+      }
+    }
+    if (!lodashEs.isEmpty(pluginMap)) {
+      this.pluginMap = pluginMap;
+      this.reversedPluginMap = lodashEs.invert(pluginMap);
+    }
+    if (!this.pluginMap) {
+      this.pluginMap = {};
+      this.reversedPluginMap = {};
+    }
+    if (!this._pluginAttributes) {
+      this._pluginAttributes = {};
     }
   }
   defaultOptions() {
@@ -17180,6 +17337,8 @@ class Schema {
   static import(data) {
     let {
       map,
+      pluginMap,
+      _pluginAttributeMetadata,
       name,
       options,
       version,
@@ -17190,11 +17349,15 @@ class Schema {
     attributes = attrs;
     const schema = new Schema({
       map,
+      pluginMap: pluginMap || {},
       name,
       options,
       version,
       attributes
     });
+    if (_pluginAttributeMetadata) {
+      schema._pluginAttributeMetadata = _pluginAttributeMetadata;
+    }
     return schema;
   }
   /**
@@ -17232,7 +17395,10 @@ class Schema {
       name: this.name,
       options: this.options,
       attributes: this._exportAttributes(this.attributes),
-      map: this.map
+      map: this.map,
+      pluginMap: this.pluginMap || {},
+      _pluginAttributeMetadata: this._pluginAttributeMetadata || {},
+      _pluginAttributes: this._pluginAttributes || {}
     };
     return data;
   }
@@ -17285,7 +17451,7 @@ class Schema {
     const flattenedObj = flat.flatten(obj, { safe: true });
     const rest = { "_v": this.version + "" };
     for (const [key, value] of Object.entries(flattenedObj)) {
-      const mappedKey = this.map[key] || key;
+      const mappedKey = this.pluginMap[key] || this.map[key] || key;
       const attrDef = this.getAttributeDefinition(key);
       if (typeof value === "number" && typeof attrDef === "string" && attrDef.includes("number")) {
         rest[mappedKey] = encode(value);
@@ -17306,14 +17472,18 @@ class Schema {
     await this.applyHooksActions(rest, "afterMap");
     return rest;
   }
-  async unmapper(mappedResourceItem, mapOverride) {
+  async unmapper(mappedResourceItem, mapOverride, pluginMapOverride) {
     let obj = lodashEs.cloneDeep(mappedResourceItem);
     delete obj._v;
     obj = await this.applyHooksActions(obj, "beforeUnmap");
     const reversedMap = mapOverride ? lodashEs.invert(mapOverride) : this.reversedMap;
+    const reversedPluginMap = pluginMapOverride ? lodashEs.invert(pluginMapOverride) : this.reversedPluginMap;
     const rest = {};
     for (const [key, value] of Object.entries(obj)) {
-      const originalKey = reversedMap && reversedMap[key] ? reversedMap[key] : key;
+      let originalKey = reversedPluginMap[key] || reversedMap[key] || key;
+      if (!originalKey) {
+        originalKey = key;
+      }
       let parsedValue = value;
       const attrDef = this.getAttributeDefinition(originalKey);
       const hasAfterUnmapHook = this.options.hooks?.afterUnmap?.[originalKey];
@@ -17380,6 +17550,37 @@ class Schema {
     }
     return def;
   }
+  /**
+   * Regenerate plugin attribute mapping
+   * Called when plugin attributes are added or removed
+   * @returns {void}
+   */
+  regeneratePluginMapping() {
+    const flatAttrs = flat.flatten(this.attributes, { safe: true });
+    const leafKeys = Object.keys(flatAttrs).filter((k) => !k.includes("$$"));
+    const objectKeys = this.extractObjectKeys(this.attributes);
+    const allKeys = [.../* @__PURE__ */ new Set([...leafKeys, ...objectKeys])];
+    const pluginAttributes = [];
+    for (const key of allKeys) {
+      const attrDef = this.getAttributeDefinition(key);
+      if (typeof attrDef === "object" && attrDef !== null && attrDef.__plugin__) {
+        pluginAttributes.push({ key, pluginName: attrDef.__plugin__ });
+      } else if (typeof attrDef === "string" && this._pluginAttributeMetadata && this._pluginAttributeMetadata[key]) {
+        const pluginName = this._pluginAttributeMetadata[key].__plugin__;
+        pluginAttributes.push({ key, pluginName });
+      }
+    }
+    const { mapping, reversedMapping } = generatePluginMapping(pluginAttributes);
+    this.pluginMap = mapping;
+    this.reversedPluginMap = reversedMapping;
+    this._pluginAttributes = {};
+    for (const { key, pluginName } of pluginAttributes) {
+      if (!this._pluginAttributes[pluginName]) {
+        this._pluginAttributes[pluginName] = [];
+      }
+      this._pluginAttributes[pluginName].push(key);
+    }
+  }
   /**
    * Preprocess attributes to convert nested objects into validator-compatible format
    * @param {Object} attributes - Original attributes
@@ -17449,37 +17650,38 @@ class Schema {
       } else if (typeof value === "object" && value !== null && !Array.isArray(value)) {
         const hasValidatorType = value.type !== void 0 && key !== "$$type";
         if (hasValidatorType) {
-          if (value.type === "ip4") {
-            processed[key] = { ...value, type: "string" };
-          } else if (value.type === "ip6") {
-            processed[key] = { ...value, type: "string" };
-          } else if (value.type === "money" || value.type === "crypto") {
-            processed[key] = { ...value, type: "number", min: value.min !== void 0 ? value.min : 0 };
-          } else if (value.type === "decimal") {
-            processed[key] = { ...value, type: "number" };
-          } else if (value.type === "geo:lat" || value.type === "geo-lat") {
+          const { __plugin__, __pluginCreated__, ...cleanValue } = value;
+          if (cleanValue.type === "ip4") {
+            processed[key] = { ...cleanValue, type: "string" };
+          } else if (cleanValue.type === "ip6") {
+            processed[key] = { ...cleanValue, type: "string" };
+          } else if (cleanValue.type === "money" || cleanValue.type === "crypto") {
+            processed[key] = { ...cleanValue, type: "number", min: cleanValue.min !== void 0 ? cleanValue.min : 0 };
+          } else if (cleanValue.type === "decimal") {
+            processed[key] = { ...cleanValue, type: "number" };
+          } else if (cleanValue.type === "geo:lat" || cleanValue.type === "geo-lat") {
             processed[key] = {
-              ...value,
+              ...cleanValue,
               type: "number",
-              min: value.min !== void 0 ? value.min : -90,
-              max: value.max !== void 0 ? value.max : 90
+              min: cleanValue.min !== void 0 ? cleanValue.min : -90,
+              max: cleanValue.max !== void 0 ? cleanValue.max : 90
             };
-          } else if (value.type === "geo:lon" || value.type === "geo-lon") {
+          } else if (cleanValue.type === "geo:lon" || cleanValue.type === "geo-lon") {
             processed[key] = {
-              ...value,
+              ...cleanValue,
               type: "number",
-              min: value.min !== void 0 ? value.min : -180,
-              max: value.max !== void 0 ? value.max : 180
+              min: cleanValue.min !== void 0 ? cleanValue.min : -180,
+              max: cleanValue.max !== void 0 ? cleanValue.max : 180
             };
-          } else if (value.type === "geo:point" || value.type === "geo-point") {
-            processed[key] = { ...value, type: "any" };
-          } else if (value.type === "object" && value.properties) {
+          } else if (cleanValue.type === "geo:point" || cleanValue.type === "geo-point") {
+            processed[key] = { ...cleanValue, type: "any" };
+          } else if (cleanValue.type === "object" && cleanValue.properties) {
             processed[key] = {
-              ...value,
-              properties: this.preprocessAttributesForValidation(value.properties)
+              ...cleanValue,
+              properties: this.preprocessAttributesForValidation(cleanValue.properties)
             };
           } else {
-            processed[key] = value;
+            processed[key] = cleanValue;
           }
         } else {
           const isExplicitRequired = value.$$type && value.$$type.includes("required");
@@ -17797,7 +17999,11 @@ async function handleInsert$3({ resource, data, mappedData, originalData }) {
       excess: totalSize - 2047,
       data: originalData || data
     });
-    return { mappedData: { _v: mappedData._v }, body: JSON.stringify(mappedData) };
+    const metadataOnly = { _v: mappedData._v };
+    if (resource.schema?.pluginMap && Object.keys(resource.schema.pluginMap).length > 0) {
+      metadataOnly._pluginMap = JSON.stringify(resource.schema.pluginMap);
+    }
+    return { mappedData: metadataOnly, body: JSON.stringify(mappedData) };
   }
   return { mappedData, body: "" };
 }
@@ -18000,6 +18206,12 @@ async function handleInsert$1({ resource, data, mappedData, originalData }) {
     metadataFields._v = mappedData._v;
     currentSize += attributeSizes._v;
   }
+  if (resource.schema?.pluginMap && Object.keys(resource.schema.pluginMap).length > 0) {
+    const pluginMapStr = JSON.stringify(resource.schema.pluginMap);
+    const pluginMapSize = calculateUTF8Bytes("_pluginMap") + calculateUTF8Bytes(pluginMapStr);
+    metadataFields._pluginMap = pluginMapStr;
+    currentSize += pluginMapSize;
+  }
   let reservedLimit = effectiveLimit;
   for (const [fieldName, size] of sortedFields) {
     if (fieldName === "_v") continue;
@@ -18059,6 +18271,9 @@ async function handleInsert({ resource, data, mappedData }) {
     "_v": mappedData._v || String(resource.version)
   };
   metadataOnly._map = JSON.stringify(resource.schema.map);
+  if (resource.schema.pluginMap && Object.keys(resource.schema.pluginMap).length > 0) {
+    metadataOnly._pluginMap = JSON.stringify(resource.schema.pluginMap);
+  }
   const body = JSON.stringify(mappedData);
   return { mappedData: metadataOnly, body };
 }
@@ -18067,6 +18282,9 @@ async function handleUpdate({ resource, id, data, mappedData }) {
     "_v": mappedData._v || String(resource.version)
   };
   metadataOnly._map = JSON.stringify(resource.schema.map);
+  if (resource.schema.pluginMap && Object.keys(resource.schema.pluginMap).length > 0) {
+    metadataOnly._pluginMap = JSON.stringify(resource.schema.pluginMap);
+  }
   const body = JSON.stringify(mappedData);
   return { mappedData: metadataOnly, body };
 }
@@ -18447,6 +18665,118 @@ ${errorDetails}`,
     this.applyConfiguration();
     return { oldAttributes, newAttributes };
   }
+  /**
+   * Add a plugin-created attribute to the resource schema
+   * This ensures plugin attributes don't interfere with user-defined attributes
+   * by using a separate mapping namespace (p0, p1, p2, ...)
+   *
+   * @param {string} name - Attribute name (e.g., '_hasEmbedding', 'clusterId')
+   * @param {Object|string} definition - Attribute definition
+   * @param {string} pluginName - Name of plugin adding the attribute
+   * @returns {void}
+   *
+   * @example
+   * // VectorPlugin adding tracking field
+   * resource.addPluginAttribute('_hasEmbedding', {
+   *   type: 'boolean',
+   *   optional: true,
+   *   default: false
+   * }, 'VectorPlugin');
+   *
+   * // Shorthand notation
+   * resource.addPluginAttribute('clusterId', 'string|optional', 'VectorPlugin');
+   */
+  addPluginAttribute(name, definition, pluginName) {
+    if (!pluginName) {
+      throw new ResourceError(
+        "Plugin name is required when adding plugin attributes",
+        { resource: this.name, attribute: name }
+      );
+    }
+    const existingDef = this.schema.getAttributeDefinition(name);
+    if (existingDef && (!existingDef.__plugin__ || existingDef.__plugin__ !== pluginName)) {
+      throw new ResourceError(
+        `Attribute '${name}' already exists and is not from plugin '${pluginName}'`,
+        { resource: this.name, attribute: name, plugin: pluginName }
+      );
+    }
+    let defObject = definition;
+    if (typeof definition === "object" && definition !== null) {
+      defObject = { ...definition };
+    }
+    if (typeof defObject === "object" && defObject !== null) {
+      defObject.__plugin__ = pluginName;
+      defObject.__pluginCreated__ = Date.now();
+    }
+    this.schema.attributes[name] = defObject;
+    this.attributes[name] = defObject;
+    if (typeof defObject === "string") {
+      if (!this.schema._pluginAttributeMetadata) {
+        this.schema._pluginAttributeMetadata = {};
+      }
+      this.schema._pluginAttributeMetadata[name] = {
+        __plugin__: pluginName,
+        __pluginCreated__: Date.now()
+      };
+    }
+    this.schema.regeneratePluginMapping();
+    if (this.schema.options.generateAutoHooks) {
+      this.schema.generateAutoHooks();
+    }
+    const processedAttributes = this.schema.preprocessAttributesForValidation(this.schema.attributes);
+    this.schema.validator = new ValidatorManager({ autoEncrypt: false }).compile(lodashEs.merge(
+      { $$async: true, $$strict: false },
+      processedAttributes
+    ));
+    if (this.database) {
+      this.database.emit("plugin-attribute-added", {
+        resource: this.name,
+        attribute: name,
+        plugin: pluginName,
+        definition: defObject
+      });
+    }
+  }
+  /**
+   * Remove a plugin-created attribute from the resource schema
+   * Called when a plugin is uninstalled or no longer needs the attribute
+   *
+   * @param {string} name - Attribute name to remove
+   * @param {string} [pluginName] - Optional plugin name for safety check
+   * @returns {boolean} True if attribute was removed, false if not found
+   *
+   * @example
+   * resource.removePluginAttribute('_hasEmbedding', 'VectorPlugin');
+   */
+  removePluginAttribute(name, pluginName = null) {
+    const attrDef = this.schema.getAttributeDefinition(name);
+    const metadata = this.schema._pluginAttributeMetadata?.[name];
+    const isPluginAttr = typeof attrDef === "object" && attrDef?.__plugin__ || metadata;
+    if (!attrDef || !isPluginAttr) {
+      return false;
+    }
+    const actualPlugin = attrDef?.__plugin__ || metadata?.__plugin__;
+    if (pluginName && actualPlugin !== pluginName) {
+      throw new ResourceError(
+        `Attribute '${name}' belongs to plugin '${actualPlugin}', not '${pluginName}'`,
+        { resource: this.name, attribute: name, actualPlugin, requestedPlugin: pluginName }
+      );
+    }
+    delete this.schema.attributes[name];
+    delete this.attributes[name];
+    if (this.schema._pluginAttributeMetadata?.[name]) {
+      delete this.schema._pluginAttributeMetadata[name];
+    }
+    this.schema.regeneratePluginMapping();
+    if (this.database) {
+      this.database.emit("plugin-attribute-removed", {
+        resource: this.name,
+        attribute: name,
+        plugin: actualPlugin
+      });
+    }
+    return true;
+  }
   /**
    * Add a hook function for a specific event
    * @param {string} event - Hook event (beforeInsert, afterInsert, etc.)
@@ -20748,8 +21078,9 @@ ${errorDetails}`,
     const filterInternalFields = (obj) => {
       if (!obj || typeof obj !== "object") return obj;
       const filtered2 = {};
+      const pluginAttrNames = this.schema._pluginAttributes ? Object.values(this.schema._pluginAttributes).flat() : [];
       for (const [key, value] of Object.entries(obj)) {
-        if (!key.startsWith("_") || key === "_geohash" || key.startsWith("_geohash_zoom")) {
+        if (!key.startsWith("_") || key === "_geohash" || key.startsWith("_geohash_zoom") || pluginAttrNames.includes(key)) {
           filtered2[key] = value;
         }
       }
@@ -20775,7 +21106,16 @@ ${errorDetails}`,
       if (hasOverflow && body) {
         const [okBody, errBody, parsedBody] = await tryFn(() => Promise.resolve(JSON.parse(body)));
         if (okBody) {
-          const [okUnmap, errUnmap, unmappedBody] = await tryFn(() => this.schema.unmapper(parsedBody));
+          let pluginMapFromMeta = null;
+          if (metadata && metadata._pluginmap) {
+            const [okPluginMap, errPluginMap, parsedPluginMap] = await tryFn(
+              () => Promise.resolve(typeof metadata._pluginmap === "string" ? JSON.parse(metadata._pluginmap) : metadata._pluginmap)
+            );
+            pluginMapFromMeta = okPluginMap ? parsedPluginMap : null;
+          }
+          const [okUnmap, errUnmap, unmappedBody] = await tryFn(
+            () => this.schema.unmapper(parsedBody, void 0, pluginMapFromMeta)
+          );
           bodyData = okUnmap ? unmappedBody : {};
         }
       }
@@ -20792,11 +21132,16 @@ ${errorDetails}`,
     if (behavior === "body-only") {
       const [okBody, errBody, parsedBody] = await tryFn(() => Promise.resolve(body ? JSON.parse(body) : {}));
       let mapFromMeta = this.schema.map;
+      let pluginMapFromMeta = null;
       if (metadata && metadata._map) {
         const [okMap, errMap, parsedMap] = await tryFn(() => Promise.resolve(typeof metadata._map === "string" ? JSON.parse(metadata._map) : metadata._map));
         mapFromMeta = okMap ? parsedMap : this.schema.map;
       }
-      const [okUnmap, errUnmap, unmappedBody] = await tryFn(() => this.schema.unmapper(parsedBody, mapFromMeta));
+      if (metadata && metadata._pluginmap) {
+        const [okPluginMap, errPluginMap, parsedPluginMap] = await tryFn(() => Promise.resolve(typeof metadata._pluginmap === "string" ? JSON.parse(metadata._pluginmap) : metadata._pluginmap));
+        pluginMapFromMeta = okPluginMap ? parsedPluginMap : null;
+      }
+      const [okUnmap, errUnmap, unmappedBody] = await tryFn(() => this.schema.unmapper(parsedBody, mapFromMeta, pluginMapFromMeta));
       const result2 = okUnmap ? { ...unmappedBody, id } : { id };
       Object.keys(result2).forEach((k) => {
         result2[k] = fixValue(result2[k]);
@@ -20806,7 +21151,16 @@ ${errorDetails}`,
     if (behavior === "user-managed" && body && body.trim() !== "") {
       const [okBody, errBody, parsedBody] = await tryFn(() => Promise.resolve(JSON.parse(body)));
       if (okBody) {
-        const [okUnmap, errUnmap, unmappedBody] = await tryFn(() => this.schema.unmapper(parsedBody));
+        let pluginMapFromMeta = null;
+        if (metadata && metadata._pluginmap) {
+          const [okPluginMap, errPluginMap, parsedPluginMap] = await tryFn(
+            () => Promise.resolve(typeof metadata._pluginmap === "string" ? JSON.parse(metadata._pluginmap) : metadata._pluginmap)
+          );
+          pluginMapFromMeta = okPluginMap ? parsedPluginMap : null;
+        }
+        const [okUnmap, errUnmap, unmappedBody] = await tryFn(
+          () => this.schema.unmapper(parsedBody, void 0, pluginMapFromMeta)
+        );
         const bodyData = okUnmap ? unmappedBody : {};
         const merged = { ...bodyData, ...unmappedMetadata, id };
         Object.keys(merged).forEach((k) => {
@@ -21054,7 +21408,7 @@ class Database extends EventEmitter {
     this.id = idGenerator(7);
     this.version = "1";
     this.s3dbVersion = (() => {
-      const [ok, err, version] = tryFn(() => true ? "12.2.4" : "latest");
+      const [ok, err, version] = tryFn(() => true ? "12.4.0" : "latest");
       return ok ? version : "latest";
     })();
     this._resourcesMap = {};
@@ -21110,7 +21464,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
@@ -23044,7 +23398,11 @@ class TursoReplicator extends BaseReplicator {
         }
         continue;
       }
-      const attributes = resource.config.versions[resource.config.currentVersion]?.attributes || {};
+      const allAttributes = resource.config.versions[resource.config.currentVersion]?.attributes || {};
+      const pluginAttrNames = resource.schema?._pluginAttributes ? Object.values(resource.schema._pluginAttributes).flat() : [];
+      const attributes = Object.fromEntries(
+        Object.entries(allAttributes).filter(([name]) => !pluginAttrNames.includes(name))
+      );
       for (const tableConfig of tableConfigs) {
         const tableName = tableConfig.table;
         const [okSync, errSync] = await tryFn(async () => {
@@ -26012,7 +26370,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
@@ -36953,11 +37311,11 @@ class VectorPlugin extends Plugin {
         }
       };
       if (!resource.schema.attributes[trackingFieldName]) {
-        resource.schema.attributes[trackingFieldName] = {
+        resource.addPluginAttribute(trackingFieldName, {
           type: "boolean",
           optional: true,
           default: false
-        };
+        }, "VectorPlugin");
       }
       this.emit("vector:partition-created", {
         resource: resource.name,
@@ -37638,114 +37996,1182 @@ class VectorPlugin extends Plugin {
   }
 }
 
-function mapFieldTypeToTypeScript(fieldType) {
-  const baseType = fieldType.split("|")[0].trim();
-  const typeMap = {
-    "string": "string",
-    "number": "number",
-    "integer": "number",
-    "boolean": "boolean",
-    "array": "any[]",
-    "object": "Record<string, any>",
-    "json": "Record<string, any>",
-    "secret": "string",
-    "email": "string",
-    "url": "string",
-    "date": "string",
-    // ISO date string
-    "datetime": "string",
-    // ISO datetime string
-    "ip4": "string",
-    "ip6": "string"
-  };
-  if (baseType.startsWith("embedding:")) {
-    const dimensions = parseInt(baseType.split(":")[1]);
-    return `number[] /* ${dimensions} dimensions */`;
+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;
   }
-  return typeMap[baseType] || "any";
-}
-function isFieldRequired(fieldDef) {
-  if (typeof fieldDef === "string") {
-    return fieldDef.includes("|required");
+  /**
+   * Generate ETag (MD5 hash) for object body
+   */
+  _generateETag(body) {
+    const buffer = Buffer.isBuffer(body) ? body : Buffer.from(body || "");
+    return crypto$1.createHash("md5").update(buffer).digest("hex");
   }
-  if (typeof fieldDef === "object" && fieldDef.required) {
-    return true;
+  /**
+   * 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;
   }
-  return false;
-}
-function generateResourceInterface(resourceName, attributes, timestamps = false) {
-  const interfaceName = toPascalCase(resourceName);
-  const lines = [];
-  lines.push(`export interface ${interfaceName} {`);
-  lines.push(`  /** Resource ID (auto-generated) */`);
-  lines.push(`  id: string;`);
-  lines.push("");
-  for (const [fieldName, fieldDef] of Object.entries(attributes)) {
-    const required = isFieldRequired(fieldDef);
-    const optional = required ? "" : "?";
-    let tsType;
-    if (typeof fieldDef === "string") {
-      tsType = mapFieldTypeToTypeScript(fieldDef);
-    } else if (typeof fieldDef === "object" && fieldDef.type) {
-      tsType = mapFieldTypeToTypeScript(fieldDef.type);
-      if (fieldDef.type === "object" && fieldDef.props) {
-        tsType = "{\n";
-        for (const [propName, propDef] of Object.entries(fieldDef.props)) {
-          const propType = typeof propDef === "string" ? mapFieldTypeToTypeScript(propDef) : mapFieldTypeToTypeScript(propDef.type);
-          const propRequired = isFieldRequired(propDef);
-          tsType += `    ${propName}${propRequired ? "" : "?"}: ${propType};
-`;
-        }
-        tsType += "  }";
-      }
-      if (fieldDef.type === "array" && fieldDef.items) {
-        const itemType = mapFieldTypeToTypeScript(fieldDef.items);
-        tsType = `Array<${itemType}>`;
+  /**
+   * 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}"`);
       }
-    } else {
-      tsType = "any";
     }
-    if (fieldDef.description) {
-      lines.push(`  /** ${fieldDef.description} */`);
+    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})`);
     }
-    lines.push(`  ${fieldName}${optional}: ${tsType};`);
+    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}`
+    };
   }
-  if (timestamps) {
-    lines.push("");
-    lines.push(`  /** Creation timestamp (ISO 8601) */`);
-    lines.push(`  createdAt: string;`);
-    lines.push(`  /** Last update timestamp (ISO 8601) */`);
-    lines.push(`  updatedAt: string;`);
+  /**
+   * 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 = stream$1.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
+    };
   }
-  lines.push("}");
-  lines.push("");
-  return lines.join("\n");
-}
-function toPascalCase(str) {
-  return str.split(/[_-]/).map((word) => word.charAt(0).toUpperCase() + word.slice(1)).join("");
-}
-async function generateTypes(database, options = {}) {
-  const {
-    outputPath = "./types/database.d.ts",
-    moduleName = "s3db.js",
-    includeResource = true
-  } = options;
-  const lines = [];
-  lines.push("/**");
-  lines.push(" * Auto-generated TypeScript definitions for s3db.js resources");
-  lines.push(" * Generated at: " + (/* @__PURE__ */ new Date()).toISOString());
-  lines.push(" * DO NOT EDIT - This file is auto-generated");
-  lines.push(" */");
-  lines.push("");
-  if (includeResource) {
-    lines.push(`import { Resource, Database } from '${moduleName}';`);
-    lines.push("");
+  /**
+   * 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
+    };
   }
-  const resourceInterfaces = [];
-  for (const [name, resource] of Object.entries(database.resources)) {
-    const attributes = resource.config?.attributes || resource.attributes || {};
-    const timestamps = resource.config?.timestamps || false;
-    const interfaceDef = generateResourceInterface(name, attributes, timestamps);
+  /**
+   * 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(() => promises.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(() => promises.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 = lodashEs.chunk(fullKeys, this.parallelism);
+    const allResults = { Deleted: [], Errors: [] };
+    const { results } = await promisePool.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 = {
+    "string": "string",
+    "number": "number",
+    "integer": "number",
+    "boolean": "boolean",
+    "array": "any[]",
+    "object": "Record<string, any>",
+    "json": "Record<string, any>",
+    "secret": "string",
+    "email": "string",
+    "url": "string",
+    "date": "string",
+    // ISO date string
+    "datetime": "string",
+    // ISO datetime string
+    "ip4": "string",
+    "ip6": "string"
+  };
+  if (baseType.startsWith("embedding:")) {
+    const dimensions = parseInt(baseType.split(":")[1]);
+    return `number[] /* ${dimensions} dimensions */`;
+  }
+  return typeMap[baseType] || "any";
+}
+function isFieldRequired(fieldDef) {
+  if (typeof fieldDef === "string") {
+    return fieldDef.includes("|required");
+  }
+  if (typeof fieldDef === "object" && fieldDef.required) {
+    return true;
+  }
+  return false;
+}
+function generateResourceInterface(resourceName, attributes, timestamps = false) {
+  const interfaceName = toPascalCase(resourceName);
+  const lines = [];
+  lines.push(`export interface ${interfaceName} {`);
+  lines.push(`  /** Resource ID (auto-generated) */`);
+  lines.push(`  id: string;`);
+  lines.push("");
+  for (const [fieldName, fieldDef] of Object.entries(attributes)) {
+    const required = isFieldRequired(fieldDef);
+    const optional = required ? "" : "?";
+    let tsType;
+    if (typeof fieldDef === "string") {
+      tsType = mapFieldTypeToTypeScript(fieldDef);
+    } else if (typeof fieldDef === "object" && fieldDef.type) {
+      tsType = mapFieldTypeToTypeScript(fieldDef.type);
+      if (fieldDef.type === "object" && fieldDef.props) {
+        tsType = "{\n";
+        for (const [propName, propDef] of Object.entries(fieldDef.props)) {
+          const propType = typeof propDef === "string" ? mapFieldTypeToTypeScript(propDef) : mapFieldTypeToTypeScript(propDef.type);
+          const propRequired = isFieldRequired(propDef);
+          tsType += `    ${propName}${propRequired ? "" : "?"}: ${propType};
+`;
+        }
+        tsType += "  }";
+      }
+      if (fieldDef.type === "array" && fieldDef.items) {
+        const itemType = mapFieldTypeToTypeScript(fieldDef.items);
+        tsType = `Array<${itemType}>`;
+      }
+    } else {
+      tsType = "any";
+    }
+    if (fieldDef.description) {
+      lines.push(`  /** ${fieldDef.description} */`);
+    }
+    lines.push(`  ${fieldName}${optional}: ${tsType};`);
+  }
+  if (timestamps) {
+    lines.push("");
+    lines.push(`  /** Creation timestamp (ISO 8601) */`);
+    lines.push(`  createdAt: string;`);
+    lines.push(`  /** Last update timestamp (ISO 8601) */`);
+    lines.push(`  updatedAt: string;`);
+  }
+  lines.push("}");
+  lines.push("");
+  return lines.join("\n");
+}
+function toPascalCase(str) {
+  return str.split(/[_-]/).map((word) => word.charAt(0).toUpperCase() + word.slice(1)).join("");
+}
+async function generateTypes(database, options = {}) {
+  const {
+    outputPath = "./types/database.d.ts",
+    moduleName = "s3db.js",
+    includeResource = true
+  } = options;
+  const lines = [];
+  lines.push("/**");
+  lines.push(" * Auto-generated TypeScript definitions for s3db.js resources");
+  lines.push(" * Generated at: " + (/* @__PURE__ */ new Date()).toISOString());
+  lines.push(" * DO NOT EDIT - This file is auto-generated");
+  lines.push(" */");
+  lines.push("");
+  if (includeResource) {
+    lines.push(`import { Resource, Database } from '${moduleName}';`);
+    lines.push("");
+  }
+  const resourceInterfaces = [];
+  for (const [name, resource] of Object.entries(database.resources)) {
+    const allAttributes = resource.config?.attributes || resource.attributes || {};
+    const timestamps = resource.config?.timestamps || false;
+    const pluginAttrNames = resource.schema?._pluginAttributes ? Object.values(resource.schema._pluginAttributes).flat() : [];
+    const userAttributes = Object.fromEntries(
+      Object.entries(allAttributes).filter(([name2]) => !pluginAttrNames.includes(name2))
+    );
+    const interfaceDef = generateResourceInterface(name, userAttributes, timestamps);
     lines.push(interfaceDef);
     resourceInterfaces.push({
       name,
@@ -38554,7 +39980,7 @@ exports.BigqueryReplicator = BigqueryReplicator;
 exports.CONSUMER_DRIVERS = CONSUMER_DRIVERS;
 exports.Cache = Cache;
 exports.CachePlugin = CachePlugin;
-exports.Client = Client;
+exports.Client = S3Client;
 exports.ConnectionString = ConnectionString;
 exports.ConnectionStringError = ConnectionStringError;
 exports.CostsPlugin = CostsPlugin;
@@ -38573,6 +39999,8 @@ exports.FullTextPlugin = FullTextPlugin;
 exports.GeoPlugin = GeoPlugin;
 exports.InvalidResourceItem = InvalidResourceItem;
 exports.MemoryCache = MemoryCache;
+exports.MemoryClient = MemoryClient;
+exports.MemoryStorage = MemoryStorage;
 exports.MetadataLimitError = MetadataLimitError;
 exports.MetricsPlugin = MetricsPlugin;
 exports.MissingMetadata = MissingMetadata;
@@ -38606,6 +40034,7 @@ exports.ResourceReader = ResourceReader;
 exports.ResourceWriter = ResourceWriter;
 exports.S3BackupDriver = S3BackupDriver;
 exports.S3Cache = S3Cache;
+exports.S3Client = S3Client;
 exports.S3QueuePlugin = S3QueuePlugin;
 exports.S3db = Database;
 exports.S3dbError = S3dbError;