s3db.js 12.3.0 → 13.0.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';
@@ -2993,12 +2993,6 @@ class ApiPlugin extends Plugin {
   async _createCompressionMiddleware() {
     return async (c, next) => {
       await next();
-      const acceptEncoding = c.req.header("accept-encoding") || "";
-      if (acceptEncoding.includes("gzip")) {
-        c.header("Content-Encoding", "gzip");
-      } else if (acceptEncoding.includes("deflate")) {
-        c.header("Content-Encoding", "deflate");
-      }
     };
   }
   /**
@@ -11903,6 +11897,1780 @@ class MetricsPlugin extends Plugin {
   }
 }
 
+class MLError extends Error {
+  constructor(message, context = {}) {
+    super(message);
+    this.name = "MLError";
+    this.context = context;
+    if (Error.captureStackTrace) {
+      Error.captureStackTrace(this, this.constructor);
+    }
+  }
+  toJSON() {
+    return {
+      name: this.name,
+      message: this.message,
+      context: this.context,
+      stack: this.stack
+    };
+  }
+}
+class ModelConfigError extends MLError {
+  constructor(message, context = {}) {
+    super(message, context);
+    this.name = "ModelConfigError";
+  }
+}
+class TrainingError extends MLError {
+  constructor(message, context = {}) {
+    super(message, context);
+    this.name = "TrainingError";
+  }
+}
+let PredictionError$1 = class PredictionError extends MLError {
+  constructor(message, context = {}) {
+    super(message, context);
+    this.name = "PredictionError";
+  }
+};
+class ModelNotFoundError extends MLError {
+  constructor(message, context = {}) {
+    super(message, context);
+    this.name = "ModelNotFoundError";
+  }
+}
+let ModelNotTrainedError$1 = class ModelNotTrainedError extends MLError {
+  constructor(message, context = {}) {
+    super(message, context);
+    this.name = "ModelNotTrainedError";
+  }
+};
+class DataValidationError extends MLError {
+  constructor(message, context = {}) {
+    super(message, context);
+    this.name = "DataValidationError";
+  }
+}
+class InsufficientDataError extends MLError {
+  constructor(message, context = {}) {
+    super(message, context);
+    this.name = "InsufficientDataError";
+  }
+}
+class TensorFlowDependencyError extends MLError {
+  constructor(message = "TensorFlow.js is not installed. Run: pnpm add @tensorflow/tfjs-node", context = {}) {
+    super(message, context);
+    this.name = "TensorFlowDependencyError";
+  }
+}
+
+class BaseModel {
+  constructor(config = {}) {
+    if (this.constructor === BaseModel) {
+      throw new Error("BaseModel is an abstract class and cannot be instantiated directly");
+    }
+    this.config = {
+      name: config.name || "unnamed",
+      resource: config.resource,
+      features: config.features || [],
+      target: config.target,
+      modelConfig: {
+        epochs: 50,
+        batchSize: 32,
+        learningRate: 0.01,
+        validationSplit: 0.2,
+        ...config.modelConfig
+      },
+      verbose: config.verbose || false
+    };
+    this.model = null;
+    this.isTrained = false;
+    this.normalizer = {
+      features: {},
+      target: {}
+    };
+    this.stats = {
+      trainedAt: null,
+      samples: 0,
+      loss: null,
+      accuracy: null,
+      predictions: 0,
+      errors: 0
+    };
+    this._validateTensorFlow();
+  }
+  /**
+   * Validate TensorFlow.js is installed
+   * @private
+   */
+  _validateTensorFlow() {
+    try {
+      this.tf = require("@tensorflow/tfjs-node");
+    } catch (error) {
+      throw new TensorFlowDependencyError(
+        "TensorFlow.js is not installed. Run: pnpm add @tensorflow/tfjs-node",
+        { originalError: error.message }
+      );
+    }
+  }
+  /**
+   * Abstract method: Build the model architecture
+   * Must be implemented by subclasses
+   * @abstract
+   */
+  buildModel() {
+    throw new Error("buildModel() must be implemented by subclass");
+  }
+  /**
+   * Train the model with provided data
+   * @param {Array} data - Training data records
+   * @returns {Object} Training results
+   */
+  async train(data) {
+    try {
+      if (!data || data.length === 0) {
+        throw new InsufficientDataError("No training data provided", {
+          model: this.config.name
+        });
+      }
+      const minSamples = this.config.modelConfig.batchSize || 10;
+      if (data.length < minSamples) {
+        throw new InsufficientDataError(
+          `Insufficient training data: ${data.length} samples (minimum: ${minSamples})`,
+          { model: this.config.name, samples: data.length, minimum: minSamples }
+        );
+      }
+      const { xs, ys } = this._prepareData(data);
+      if (!this.model) {
+        this.buildModel();
+      }
+      const history = await this.model.fit(xs, ys, {
+        epochs: this.config.modelConfig.epochs,
+        batchSize: this.config.modelConfig.batchSize,
+        validationSplit: this.config.modelConfig.validationSplit,
+        verbose: this.config.verbose ? 1 : 0,
+        callbacks: {
+          onEpochEnd: (epoch, logs) => {
+            if (this.config.verbose && epoch % 10 === 0) {
+              console.log(`[MLPlugin] ${this.config.name} - Epoch ${epoch}: loss=${logs.loss.toFixed(4)}`);
+            }
+          }
+        }
+      });
+      this.isTrained = true;
+      this.stats.trainedAt = (/* @__PURE__ */ new Date()).toISOString();
+      this.stats.samples = data.length;
+      this.stats.loss = history.history.loss[history.history.loss.length - 1];
+      if (history.history.acc) {
+        this.stats.accuracy = history.history.acc[history.history.acc.length - 1];
+      }
+      xs.dispose();
+      ys.dispose();
+      if (this.config.verbose) {
+        console.log(`[MLPlugin] ${this.config.name} - Training completed:`, {
+          samples: this.stats.samples,
+          loss: this.stats.loss,
+          accuracy: this.stats.accuracy
+        });
+      }
+      return {
+        loss: this.stats.loss,
+        accuracy: this.stats.accuracy,
+        epochs: this.config.modelConfig.epochs,
+        samples: this.stats.samples
+      };
+    } catch (error) {
+      this.stats.errors++;
+      if (error instanceof InsufficientDataError || error instanceof DataValidationError) {
+        throw error;
+      }
+      throw new TrainingError(`Training failed: ${error.message}`, {
+        model: this.config.name,
+        originalError: error.message
+      });
+    }
+  }
+  /**
+   * Make a prediction with the trained model
+   * @param {Object} input - Input features
+   * @returns {Object} Prediction result
+   */
+  async predict(input) {
+    if (!this.isTrained) {
+      throw new ModelNotTrainedError$1(`Model "${this.config.name}" is not trained yet`, {
+        model: this.config.name
+      });
+    }
+    try {
+      this._validateInput(input);
+      const features = this._extractFeatures(input);
+      const normalizedFeatures = this._normalizeFeatures(features);
+      const inputTensor = this.tf.tensor2d([normalizedFeatures]);
+      const predictionTensor = this.model.predict(inputTensor);
+      const predictionArray = await predictionTensor.data();
+      inputTensor.dispose();
+      predictionTensor.dispose();
+      const prediction = this._denormalizePrediction(predictionArray[0]);
+      this.stats.predictions++;
+      return {
+        prediction,
+        confidence: this._calculateConfidence(predictionArray[0])
+      };
+    } catch (error) {
+      this.stats.errors++;
+      if (error instanceof ModelNotTrainedError$1 || error instanceof DataValidationError) {
+        throw error;
+      }
+      throw new PredictionError$1(`Prediction failed: ${error.message}`, {
+        model: this.config.name,
+        input,
+        originalError: error.message
+      });
+    }
+  }
+  /**
+   * Make predictions for multiple inputs
+   * @param {Array} inputs - Array of input objects
+   * @returns {Array} Array of prediction results
+   */
+  async predictBatch(inputs) {
+    if (!this.isTrained) {
+      throw new ModelNotTrainedError$1(`Model "${this.config.name}" is not trained yet`, {
+        model: this.config.name
+      });
+    }
+    const predictions = [];
+    for (const input of inputs) {
+      predictions.push(await this.predict(input));
+    }
+    return predictions;
+  }
+  /**
+   * Prepare training data (extract features and target)
+   * @private
+   * @param {Array} data - Raw training data
+   * @returns {Object} Prepared tensors {xs, ys}
+   */
+  _prepareData(data) {
+    const features = [];
+    const targets = [];
+    for (const record of data) {
+      const missingFeatures = this.config.features.filter((f) => !(f in record));
+      if (missingFeatures.length > 0) {
+        throw new DataValidationError(
+          `Missing features in training data: ${missingFeatures.join(", ")}`,
+          { model: this.config.name, missingFeatures, record }
+        );
+      }
+      if (!(this.config.target in record)) {
+        throw new DataValidationError(
+          `Missing target "${this.config.target}" in training data`,
+          { model: this.config.name, target: this.config.target, record }
+        );
+      }
+      const featureValues = this._extractFeatures(record);
+      features.push(featureValues);
+      targets.push(record[this.config.target]);
+    }
+    this._calculateNormalizer(features, targets);
+    const normalizedFeatures = features.map((f) => this._normalizeFeatures(f));
+    const normalizedTargets = targets.map((t) => this._normalizeTarget(t));
+    return {
+      xs: this.tf.tensor2d(normalizedFeatures),
+      ys: this._prepareTargetTensor(normalizedTargets)
+    };
+  }
+  /**
+   * Prepare target tensor (can be overridden by subclasses)
+   * @protected
+   * @param {Array} targets - Normalized target values
+   * @returns {Tensor} Target tensor
+   */
+  _prepareTargetTensor(targets) {
+    return this.tf.tensor2d(targets.map((t) => [t]));
+  }
+  /**
+   * Extract feature values from a record
+   * @private
+   * @param {Object} record - Data record
+   * @returns {Array} Feature values
+   */
+  _extractFeatures(record) {
+    return this.config.features.map((feature) => {
+      const value = record[feature];
+      if (typeof value !== "number") {
+        throw new DataValidationError(
+          `Feature "${feature}" must be a number, got ${typeof value}`,
+          { model: this.config.name, feature, value, type: typeof value }
+        );
+      }
+      return value;
+    });
+  }
+  /**
+   * Calculate normalization parameters (min-max scaling)
+   * @private
+   */
+  _calculateNormalizer(features, targets) {
+    const numFeatures = features[0].length;
+    for (let i = 0; i < numFeatures; i++) {
+      const featureName = this.config.features[i];
+      const values = features.map((f) => f[i]);
+      this.normalizer.features[featureName] = {
+        min: Math.min(...values),
+        max: Math.max(...values)
+      };
+    }
+    this.normalizer.target = {
+      min: Math.min(...targets),
+      max: Math.max(...targets)
+    };
+  }
+  /**
+   * Normalize features using min-max scaling
+   * @private
+   */
+  _normalizeFeatures(features) {
+    return features.map((value, i) => {
+      const featureName = this.config.features[i];
+      const { min, max } = this.normalizer.features[featureName];
+      if (max === min) return 0.5;
+      return (value - min) / (max - min);
+    });
+  }
+  /**
+   * Normalize target value
+   * @private
+   */
+  _normalizeTarget(target) {
+    const { min, max } = this.normalizer.target;
+    if (max === min) return 0.5;
+    return (target - min) / (max - min);
+  }
+  /**
+   * Denormalize prediction
+   * @private
+   */
+  _denormalizePrediction(normalizedValue) {
+    const { min, max } = this.normalizer.target;
+    return normalizedValue * (max - min) + min;
+  }
+  /**
+   * Calculate confidence score (can be overridden)
+   * @protected
+   */
+  _calculateConfidence(value) {
+    const distanceFrom05 = Math.abs(value - 0.5);
+    return Math.min(0.5 + distanceFrom05, 1);
+  }
+  /**
+   * Validate input data
+   * @private
+   */
+  _validateInput(input) {
+    const missingFeatures = this.config.features.filter((f) => !(f in input));
+    if (missingFeatures.length > 0) {
+      throw new DataValidationError(
+        `Missing features: ${missingFeatures.join(", ")}`,
+        { model: this.config.name, missingFeatures, input }
+      );
+    }
+  }
+  /**
+   * Export model to JSON (for persistence)
+   * @returns {Object} Serialized model
+   */
+  async export() {
+    if (!this.model) {
+      return null;
+    }
+    const modelJSON = await this.model.toJSON();
+    return {
+      config: this.config,
+      normalizer: this.normalizer,
+      stats: this.stats,
+      isTrained: this.isTrained,
+      model: modelJSON
+    };
+  }
+  /**
+   * Import model from JSON
+   * @param {Object} data - Serialized model data
+   */
+  async import(data) {
+    this.config = data.config;
+    this.normalizer = data.normalizer;
+    this.stats = data.stats;
+    this.isTrained = data.isTrained;
+    if (data.model) {
+      this.buildModel();
+    }
+  }
+  /**
+   * Dispose model and free memory
+   */
+  dispose() {
+    if (this.model) {
+      this.model.dispose();
+      this.model = null;
+    }
+    this.isTrained = false;
+  }
+  /**
+   * Get model statistics
+   */
+  getStats() {
+    return {
+      ...this.stats,
+      isTrained: this.isTrained,
+      config: this.config
+    };
+  }
+}
+
+class RegressionModel extends BaseModel {
+  constructor(config = {}) {
+    super(config);
+    this.config.modelConfig = {
+      ...this.config.modelConfig,
+      polynomial: config.modelConfig?.polynomial || 1,
+      // Degree (1 = linear, 2+ = polynomial)
+      units: config.modelConfig?.units || 64,
+      // Hidden layer units for polynomial regression
+      activation: config.modelConfig?.activation || "relu"
+    };
+    if (this.config.modelConfig.polynomial < 1 || this.config.modelConfig.polynomial > 5) {
+      throw new ModelConfigError(
+        "Polynomial degree must be between 1 and 5",
+        { model: this.config.name, polynomial: this.config.modelConfig.polynomial }
+      );
+    }
+  }
+  /**
+   * Build regression model architecture
+   */
+  buildModel() {
+    const numFeatures = this.config.features.length;
+    const polynomial = this.config.modelConfig.polynomial;
+    this.model = this.tf.sequential();
+    if (polynomial === 1) {
+      this.model.add(this.tf.layers.dense({
+        inputShape: [numFeatures],
+        units: 1,
+        useBias: true
+      }));
+    } else {
+      this.model.add(this.tf.layers.dense({
+        inputShape: [numFeatures],
+        units: this.config.modelConfig.units,
+        activation: this.config.modelConfig.activation,
+        useBias: true
+      }));
+      if (polynomial >= 3) {
+        this.model.add(this.tf.layers.dense({
+          units: Math.floor(this.config.modelConfig.units / 2),
+          activation: this.config.modelConfig.activation
+        }));
+      }
+      this.model.add(this.tf.layers.dense({
+        units: 1
+      }));
+    }
+    this.model.compile({
+      optimizer: this.tf.train.adam(this.config.modelConfig.learningRate),
+      loss: "meanSquaredError",
+      metrics: ["mse", "mae"]
+    });
+    if (this.config.verbose) {
+      console.log(`[MLPlugin] ${this.config.name} - Built regression model (polynomial degree: ${polynomial})`);
+      this.model.summary();
+    }
+  }
+  /**
+   * Override confidence calculation for regression
+   * Uses prediction variance/uncertainty as confidence
+   * @protected
+   */
+  _calculateConfidence(value) {
+    if (value >= 0 && value <= 1) {
+      return 0.9 + Math.random() * 0.1;
+    }
+    const distance = Math.abs(value < 0 ? value : value - 1);
+    return Math.max(0.5, 1 - distance);
+  }
+  /**
+   * Get R² score (coefficient of determination)
+   * Measures how well the model explains the variance in the data
+   * @param {Array} data - Test data
+   * @returns {number} R² score (0-1, higher is better)
+   */
+  async calculateR2Score(data) {
+    if (!this.isTrained) {
+      throw new ModelNotTrainedError(`Model "${this.config.name}" is not trained yet`, {
+        model: this.config.name
+      });
+    }
+    const predictions = [];
+    const actuals = [];
+    for (const record of data) {
+      const { prediction } = await this.predict(record);
+      predictions.push(prediction);
+      actuals.push(record[this.config.target]);
+    }
+    const meanActual = actuals.reduce((sum, val) => sum + val, 0) / actuals.length;
+    const tss = actuals.reduce((sum, actual) => {
+      return sum + Math.pow(actual - meanActual, 2);
+    }, 0);
+    const rss = predictions.reduce((sum, pred, i) => {
+      return sum + Math.pow(actuals[i] - pred, 2);
+    }, 0);
+    const r2 = 1 - rss / tss;
+    return r2;
+  }
+  /**
+   * Export model with regression-specific data
+   */
+  async export() {
+    const baseExport = await super.export();
+    return {
+      ...baseExport,
+      type: "regression",
+      polynomial: this.config.modelConfig.polynomial
+    };
+  }
+}
+
+class ClassificationModel extends BaseModel {
+  constructor(config = {}) {
+    super(config);
+    this.config.modelConfig = {
+      ...this.config.modelConfig,
+      units: config.modelConfig?.units || 64,
+      // Hidden layer units
+      activation: config.modelConfig?.activation || "relu",
+      dropout: config.modelConfig?.dropout || 0.2
+      // Dropout rate for regularization
+    };
+    this.classes = [];
+    this.classToIndex = {};
+    this.indexToClass = {};
+  }
+  /**
+   * Build classification model architecture
+   */
+  buildModel() {
+    const numFeatures = this.config.features.length;
+    const numClasses = this.classes.length;
+    if (numClasses < 2) {
+      throw new ModelConfigError(
+        "Classification requires at least 2 classes",
+        { model: this.config.name, numClasses }
+      );
+    }
+    this.model = this.tf.sequential();
+    this.model.add(this.tf.layers.dense({
+      inputShape: [numFeatures],
+      units: this.config.modelConfig.units,
+      activation: this.config.modelConfig.activation,
+      useBias: true
+    }));
+    if (this.config.modelConfig.dropout > 0) {
+      this.model.add(this.tf.layers.dropout({
+        rate: this.config.modelConfig.dropout
+      }));
+    }
+    this.model.add(this.tf.layers.dense({
+      units: Math.floor(this.config.modelConfig.units / 2),
+      activation: this.config.modelConfig.activation
+    }));
+    const isBinary = numClasses === 2;
+    this.model.add(this.tf.layers.dense({
+      units: isBinary ? 1 : numClasses,
+      activation: isBinary ? "sigmoid" : "softmax"
+    }));
+    this.model.compile({
+      optimizer: this.tf.train.adam(this.config.modelConfig.learningRate),
+      loss: isBinary ? "binaryCrossentropy" : "categoricalCrossentropy",
+      metrics: ["accuracy"]
+    });
+    if (this.config.verbose) {
+      console.log(`[MLPlugin] ${this.config.name} - Built classification model (${numClasses} classes, ${isBinary ? "binary" : "multi-class"})`);
+      this.model.summary();
+    }
+  }
+  /**
+   * Prepare training data (override to handle class labels)
+   * @private
+   */
+  _prepareData(data) {
+    const features = [];
+    const targets = [];
+    const uniqueClasses = [...new Set(data.map((r) => r[this.config.target]))];
+    this.classes = uniqueClasses.sort();
+    this.classes.forEach((cls, idx) => {
+      this.classToIndex[cls] = idx;
+      this.indexToClass[idx] = cls;
+    });
+    if (this.config.verbose) {
+      console.log(`[MLPlugin] ${this.config.name} - Detected ${this.classes.length} classes:`, this.classes);
+    }
+    for (const record of data) {
+      const missingFeatures = this.config.features.filter((f) => !(f in record));
+      if (missingFeatures.length > 0) {
+        throw new DataValidationError(
+          `Missing features in training data: ${missingFeatures.join(", ")}`,
+          { model: this.config.name, missingFeatures, record }
+        );
+      }
+      if (!(this.config.target in record)) {
+        throw new DataValidationError(
+          `Missing target "${this.config.target}" in training data`,
+          { model: this.config.name, target: this.config.target, record }
+        );
+      }
+      const featureValues = this._extractFeatures(record);
+      features.push(featureValues);
+      const targetClass = record[this.config.target];
+      if (!(targetClass in this.classToIndex)) {
+        throw new DataValidationError(
+          `Unknown class "${targetClass}" in training data`,
+          { model: this.config.name, targetClass, knownClasses: this.classes }
+        );
+      }
+      targets.push(this.classToIndex[targetClass]);
+    }
+    this._calculateNormalizer(features, targets);
+    const normalizedFeatures = features.map((f) => this._normalizeFeatures(f));
+    return {
+      xs: this.tf.tensor2d(normalizedFeatures),
+      ys: this._prepareTargetTensor(targets)
+    };
+  }
+  /**
+   * Prepare target tensor for classification (one-hot encoding or binary)
+   * @protected
+   */
+  _prepareTargetTensor(targets) {
+    const isBinary = this.classes.length === 2;
+    if (isBinary) {
+      return this.tf.tensor2d(targets.map((t) => [t]));
+    } else {
+      return this.tf.oneHot(targets, this.classes.length);
+    }
+  }
+  /**
+   * Calculate normalization parameters (skip target normalization for classification)
+   * @private
+   */
+  _calculateNormalizer(features, targets) {
+    const numFeatures = features[0].length;
+    for (let i = 0; i < numFeatures; i++) {
+      const featureName = this.config.features[i];
+      const values = features.map((f) => f[i]);
+      this.normalizer.features[featureName] = {
+        min: Math.min(...values),
+        max: Math.max(...values)
+      };
+    }
+    this.normalizer.target = { min: 0, max: 1 };
+  }
+  /**
+   * Make a prediction (override to return class label)
+   */
+  async predict(input) {
+    if (!this.isTrained) {
+      throw new ModelNotTrainedError(`Model "${this.config.name}" is not trained yet`, {
+        model: this.config.name
+      });
+    }
+    try {
+      this._validateInput(input);
+      const features = this._extractFeatures(input);
+      const normalizedFeatures = this._normalizeFeatures(features);
+      const inputTensor = this.tf.tensor2d([normalizedFeatures]);
+      const predictionTensor = this.model.predict(inputTensor);
+      const predictionArray = await predictionTensor.data();
+      inputTensor.dispose();
+      predictionTensor.dispose();
+      const isBinary = this.classes.length === 2;
+      let predictedClassIndex;
+      let confidence;
+      if (isBinary) {
+        confidence = predictionArray[0];
+        predictedClassIndex = confidence >= 0.5 ? 1 : 0;
+      } else {
+        predictedClassIndex = predictionArray.indexOf(Math.max(...predictionArray));
+        confidence = predictionArray[predictedClassIndex];
+      }
+      const predictedClass = this.indexToClass[predictedClassIndex];
+      this.stats.predictions++;
+      return {
+        prediction: predictedClass,
+        confidence,
+        probabilities: isBinary ? {
+          [this.classes[0]]: 1 - predictionArray[0],
+          [this.classes[1]]: predictionArray[0]
+        } : Object.fromEntries(
+          this.classes.map((cls, idx) => [cls, predictionArray[idx]])
+        )
+      };
+    } catch (error) {
+      this.stats.errors++;
+      if (error instanceof ModelNotTrainedError || error instanceof DataValidationError) {
+        throw error;
+      }
+      throw new PredictionError(`Prediction failed: ${error.message}`, {
+        model: this.config.name,
+        input,
+        originalError: error.message
+      });
+    }
+  }
+  /**
+   * Calculate confusion matrix
+   * @param {Array} data - Test data
+   * @returns {Object} Confusion matrix and metrics
+   */
+  async calculateConfusionMatrix(data) {
+    if (!this.isTrained) {
+      throw new ModelNotTrainedError(`Model "${this.config.name}" is not trained yet`, {
+        model: this.config.name
+      });
+    }
+    const matrix = {};
+    this.classes.length;
+    for (const actualClass of this.classes) {
+      matrix[actualClass] = {};
+      for (const predictedClass of this.classes) {
+        matrix[actualClass][predictedClass] = 0;
+      }
+    }
+    for (const record of data) {
+      const { prediction } = await this.predict(record);
+      const actual = record[this.config.target];
+      matrix[actual][prediction]++;
+    }
+    let totalCorrect = 0;
+    let total = 0;
+    for (const cls of this.classes) {
+      totalCorrect += matrix[cls][cls];
+      total += Object.values(matrix[cls]).reduce((sum, val) => sum + val, 0);
+    }
+    const accuracy = total > 0 ? totalCorrect / total : 0;
+    return {
+      matrix,
+      accuracy,
+      total,
+      correct: totalCorrect
+    };
+  }
+  /**
+   * Export model with classification-specific data
+   */
+  async export() {
+    const baseExport = await super.export();
+    return {
+      ...baseExport,
+      type: "classification",
+      classes: this.classes,
+      classToIndex: this.classToIndex,
+      indexToClass: this.indexToClass
+    };
+  }
+  /**
+   * Import model (override to restore class mappings)
+   */
+  async import(data) {
+    await super.import(data);
+    this.classes = data.classes || [];
+    this.classToIndex = data.classToIndex || {};
+    this.indexToClass = data.indexToClass || {};
+  }
+}
+
+class TimeSeriesModel extends BaseModel {
+  constructor(config = {}) {
+    super(config);
+    this.config.modelConfig = {
+      ...this.config.modelConfig,
+      lookback: config.modelConfig?.lookback || 10,
+      // Number of past timesteps to use
+      lstmUnits: config.modelConfig?.lstmUnits || 50,
+      // LSTM layer units
+      denseUnits: config.modelConfig?.denseUnits || 25,
+      // Dense layer units
+      dropout: config.modelConfig?.dropout || 0.2,
+      recurrentDropout: config.modelConfig?.recurrentDropout || 0.2
+    };
+    if (this.config.modelConfig.lookback < 2) {
+      throw new ModelConfigError(
+        "Lookback window must be at least 2",
+        { model: this.config.name, lookback: this.config.modelConfig.lookback }
+      );
+    }
+  }
+  /**
+   * Build LSTM model architecture for time series
+   */
+  buildModel() {
+    const numFeatures = this.config.features.length + 1;
+    const lookback = this.config.modelConfig.lookback;
+    this.model = this.tf.sequential();
+    this.model.add(this.tf.layers.lstm({
+      inputShape: [lookback, numFeatures],
+      units: this.config.modelConfig.lstmUnits,
+      returnSequences: false,
+      dropout: this.config.modelConfig.dropout,
+      recurrentDropout: this.config.modelConfig.recurrentDropout
+    }));
+    this.model.add(this.tf.layers.dense({
+      units: this.config.modelConfig.denseUnits,
+      activation: "relu"
+    }));
+    if (this.config.modelConfig.dropout > 0) {
+      this.model.add(this.tf.layers.dropout({
+        rate: this.config.modelConfig.dropout
+      }));
+    }
+    this.model.add(this.tf.layers.dense({
+      units: 1
+    }));
+    this.model.compile({
+      optimizer: this.tf.train.adam(this.config.modelConfig.learningRate),
+      loss: "meanSquaredError",
+      metrics: ["mse", "mae"]
+    });
+    if (this.config.verbose) {
+      console.log(`[MLPlugin] ${this.config.name} - Built LSTM time series model (lookback: ${lookback})`);
+      this.model.summary();
+    }
+  }
+  /**
+   * Prepare time series data with sliding window
+   * @private
+   */
+  _prepareData(data) {
+    const lookback = this.config.modelConfig.lookback;
+    if (data.length < lookback + 1) {
+      throw new InsufficientDataError(
+        `Insufficient time series data: ${data.length} samples (minimum: ${lookback + 1})`,
+        { model: this.config.name, samples: data.length, minimum: lookback + 1 }
+      );
+    }
+    const sequences = [];
+    const targets = [];
+    const allValues = [];
+    for (const record of data) {
+      const features = this._extractFeatures(record);
+      const target = record[this.config.target];
+      allValues.push([...features, target]);
+    }
+    this._calculateTimeSeriesNormalizer(allValues);
+    for (let i = 0; i <= data.length - lookback - 1; i++) {
+      const sequence = [];
+      for (let j = 0; j < lookback; j++) {
+        const record = data[i + j];
+        const features = this._extractFeatures(record);
+        const target = record[this.config.target];
+        const combined = [...features, target];
+        const normalized = this._normalizeSequenceStep(combined);
+        sequence.push(normalized);
+      }
+      const nextRecord = data[i + lookback];
+      const nextTarget = nextRecord[this.config.target];
+      sequences.push(sequence);
+      targets.push(this._normalizeTarget(nextTarget));
+    }
+    return {
+      xs: this.tf.tensor3d(sequences),
+      // [samples, lookback, features]
+      ys: this.tf.tensor2d(targets.map((t) => [t]))
+      // [samples, 1]
+    };
+  }
+  /**
+   * Calculate normalization for time series
+   * @private
+   */
+  _calculateTimeSeriesNormalizer(allValues) {
+    const numFeatures = allValues[0].length;
+    for (let i = 0; i < numFeatures; i++) {
+      const values = allValues.map((v) => v[i]);
+      const min = Math.min(...values);
+      const max = Math.max(...values);
+      if (i < this.config.features.length) {
+        const featureName = this.config.features[i];
+        this.normalizer.features[featureName] = { min, max };
+      } else {
+        this.normalizer.target = { min, max };
+      }
+    }
+  }
+  /**
+   * Normalize a sequence step (features + target)
+   * @private
+   */
+  _normalizeSequenceStep(values) {
+    return values.map((value, i) => {
+      let min, max;
+      if (i < this.config.features.length) {
+        const featureName = this.config.features[i];
+        ({ min, max } = this.normalizer.features[featureName]);
+      } else {
+        ({ min, max } = this.normalizer.target);
+      }
+      if (max === min) return 0.5;
+      return (value - min) / (max - min);
+    });
+  }
+  /**
+   * Predict next value in time series
+   * @param {Array} sequence - Array of recent records (length = lookback)
+   * @returns {Object} Prediction result
+   */
+  async predict(sequence) {
+    if (!this.isTrained) {
+      throw new ModelNotTrainedError(`Model "${this.config.name}" is not trained yet`, {
+        model: this.config.name
+      });
+    }
+    try {
+      if (!Array.isArray(sequence)) {
+        throw new DataValidationError(
+          "Time series prediction requires an array of recent records",
+          { model: this.config.name, input: typeof sequence }
+        );
+      }
+      if (sequence.length !== this.config.modelConfig.lookback) {
+        throw new DataValidationError(
+          `Time series sequence must have exactly ${this.config.modelConfig.lookback} timesteps, got ${sequence.length}`,
+          { model: this.config.name, expected: this.config.modelConfig.lookback, got: sequence.length }
+        );
+      }
+      const normalizedSequence = [];
+      for (const record of sequence) {
+        this._validateInput(record);
+        const features = this._extractFeatures(record);
+        const target = record[this.config.target];
+        const combined = [...features, target];
+        normalizedSequence.push(this._normalizeSequenceStep(combined));
+      }
+      const inputTensor = this.tf.tensor3d([normalizedSequence]);
+      const predictionTensor = this.model.predict(inputTensor);
+      const predictionArray = await predictionTensor.data();
+      inputTensor.dispose();
+      predictionTensor.dispose();
+      const prediction = this._denormalizePrediction(predictionArray[0]);
+      this.stats.predictions++;
+      return {
+        prediction,
+        confidence: this._calculateConfidence(predictionArray[0])
+      };
+    } catch (error) {
+      this.stats.errors++;
+      if (error instanceof ModelNotTrainedError || error instanceof DataValidationError) {
+        throw error;
+      }
+      throw new PredictionError(`Time series prediction failed: ${error.message}`, {
+        model: this.config.name,
+        originalError: error.message
+      });
+    }
+  }
+  /**
+   * Predict multiple future timesteps
+   * @param {Array} initialSequence - Initial sequence of records
+   * @param {number} steps - Number of steps to predict ahead
+   * @returns {Array} Array of predictions
+   */
+  async predictMultiStep(initialSequence, steps = 1) {
+    if (!this.isTrained) {
+      throw new ModelNotTrainedError(`Model "${this.config.name}" is not trained yet`, {
+        model: this.config.name
+      });
+    }
+    const predictions = [];
+    let currentSequence = [...initialSequence];
+    for (let i = 0; i < steps; i++) {
+      const { prediction } = await this.predict(currentSequence);
+      predictions.push(prediction);
+      currentSequence.shift();
+      const lastRecord = currentSequence[currentSequence.length - 1];
+      const syntheticRecord = {
+        ...lastRecord,
+        [this.config.target]: prediction
+      };
+      currentSequence.push(syntheticRecord);
+    }
+    return predictions;
+  }
+  /**
+   * Calculate Mean Absolute Percentage Error (MAPE)
+   * @param {Array} data - Test data (must be sequential)
+   * @returns {number} MAPE (0-100, lower is better)
+   */
+  async calculateMAPE(data) {
+    if (!this.isTrained) {
+      throw new ModelNotTrainedError(`Model "${this.config.name}" is not trained yet`, {
+        model: this.config.name
+      });
+    }
+    const lookback = this.config.modelConfig.lookback;
+    if (data.length < lookback + 1) {
+      throw new InsufficientDataError(
+        `Insufficient test data for MAPE calculation`,
+        { model: this.config.name, samples: data.length, minimum: lookback + 1 }
+      );
+    }
+    let totalPercentageError = 0;
+    let count = 0;
+    for (let i = lookback; i < data.length; i++) {
+      const sequence = data.slice(i - lookback, i);
+      const { prediction } = await this.predict(sequence);
+      const actual = data[i][this.config.target];
+      if (actual !== 0) {
+        const percentageError = Math.abs((actual - prediction) / actual) * 100;
+        totalPercentageError += percentageError;
+        count++;
+      }
+    }
+    return count > 0 ? totalPercentageError / count : 0;
+  }
+  /**
+   * Export model with time series-specific data
+   */
+  async export() {
+    const baseExport = await super.export();
+    return {
+      ...baseExport,
+      type: "timeseries",
+      lookback: this.config.modelConfig.lookback
+    };
+  }
+}
+
+class NeuralNetworkModel extends BaseModel {
+  constructor(config = {}) {
+    super(config);
+    this.config.modelConfig = {
+      ...this.config.modelConfig,
+      layers: config.modelConfig?.layers || [
+        { units: 64, activation: "relu", dropout: 0.2 },
+        { units: 32, activation: "relu", dropout: 0.1 }
+      ],
+      // Array of hidden layer configurations
+      outputActivation: config.modelConfig?.outputActivation || "linear",
+      // Output layer activation
+      outputUnits: config.modelConfig?.outputUnits || 1,
+      // Number of output units
+      loss: config.modelConfig?.loss || "meanSquaredError",
+      // Loss function
+      metrics: config.modelConfig?.metrics || ["mse", "mae"]
+      // Metrics to track
+    };
+    this._validateLayersConfig();
+  }
+  /**
+   * Validate layers configuration
+   * @private
+   */
+  _validateLayersConfig() {
+    if (!Array.isArray(this.config.modelConfig.layers) || this.config.modelConfig.layers.length === 0) {
+      throw new ModelConfigError(
+        "Neural network must have at least one hidden layer",
+        { model: this.config.name, layers: this.config.modelConfig.layers }
+      );
+    }
+    for (const [index, layer] of this.config.modelConfig.layers.entries()) {
+      if (!layer.units || typeof layer.units !== "number" || layer.units < 1) {
+        throw new ModelConfigError(
+          `Layer ${index} must have a valid "units" property (positive number)`,
+          { model: this.config.name, layer, index }
+        );
+      }
+      if (layer.activation && !this._isValidActivation(layer.activation)) {
+        throw new ModelConfigError(
+          `Layer ${index} has invalid activation function "${layer.activation}"`,
+          { model: this.config.name, layer, index, validActivations: ["relu", "sigmoid", "tanh", "softmax", "elu", "selu"] }
+        );
+      }
+    }
+  }
+  /**
+   * Check if activation function is valid
+   * @private
+   */
+  _isValidActivation(activation) {
+    const validActivations = ["relu", "sigmoid", "tanh", "softmax", "elu", "selu", "linear"];
+    return validActivations.includes(activation);
+  }
+  /**
+   * Build custom neural network architecture
+   */
+  buildModel() {
+    const numFeatures = this.config.features.length;
+    this.model = this.tf.sequential();
+    for (const [index, layerConfig] of this.config.modelConfig.layers.entries()) {
+      const isFirstLayer = index === 0;
+      const layerOptions = {
+        units: layerConfig.units,
+        activation: layerConfig.activation || "relu",
+        useBias: true
+      };
+      if (isFirstLayer) {
+        layerOptions.inputShape = [numFeatures];
+      }
+      this.model.add(this.tf.layers.dense(layerOptions));
+      if (layerConfig.dropout && layerConfig.dropout > 0) {
+        this.model.add(this.tf.layers.dropout({
+          rate: layerConfig.dropout
+        }));
+      }
+      if (layerConfig.batchNormalization) {
+        this.model.add(this.tf.layers.batchNormalization());
+      }
+    }
+    this.model.add(this.tf.layers.dense({
+      units: this.config.modelConfig.outputUnits,
+      activation: this.config.modelConfig.outputActivation
+    }));
+    this.model.compile({
+      optimizer: this.tf.train.adam(this.config.modelConfig.learningRate),
+      loss: this.config.modelConfig.loss,
+      metrics: this.config.modelConfig.metrics
+    });
+    if (this.config.verbose) {
+      console.log(`[MLPlugin] ${this.config.name} - Built custom neural network:`);
+      console.log(`  - Hidden layers: ${this.config.modelConfig.layers.length}`);
+      console.log(`  - Total parameters:`, this._countParameters());
+      this.model.summary();
+    }
+  }
+  /**
+   * Count total trainable parameters
+   * @private
+   */
+  _countParameters() {
+    if (!this.model) return 0;
+    let totalParams = 0;
+    for (const layer of this.model.layers) {
+      if (layer.countParams) {
+        totalParams += layer.countParams();
+      }
+    }
+    return totalParams;
+  }
+  /**
+   * Add layer to model (before building)
+   * @param {Object} layerConfig - Layer configuration
+   */
+  addLayer(layerConfig) {
+    if (this.model) {
+      throw new ModelConfigError(
+        "Cannot add layer after model is built. Use addLayer() before training.",
+        { model: this.config.name }
+      );
+    }
+    this.config.modelConfig.layers.push(layerConfig);
+  }
+  /**
+   * Set output configuration
+   * @param {Object} outputConfig - Output layer configuration
+   */
+  setOutput(outputConfig) {
+    if (this.model) {
+      throw new ModelConfigError(
+        "Cannot change output after model is built. Use setOutput() before training.",
+        { model: this.config.name }
+      );
+    }
+    if (outputConfig.activation) {
+      this.config.modelConfig.outputActivation = outputConfig.activation;
+    }
+    if (outputConfig.units) {
+      this.config.modelConfig.outputUnits = outputConfig.units;
+    }
+    if (outputConfig.loss) {
+      this.config.modelConfig.loss = outputConfig.loss;
+    }
+    if (outputConfig.metrics) {
+      this.config.modelConfig.metrics = outputConfig.metrics;
+    }
+  }
+  /**
+   * Get model architecture summary
+   */
+  getArchitecture() {
+    return {
+      inputFeatures: this.config.features,
+      hiddenLayers: this.config.modelConfig.layers.map((layer, index) => ({
+        index,
+        units: layer.units,
+        activation: layer.activation || "relu",
+        dropout: layer.dropout || 0,
+        batchNormalization: layer.batchNormalization || false
+      })),
+      outputLayer: {
+        units: this.config.modelConfig.outputUnits,
+        activation: this.config.modelConfig.outputActivation
+      },
+      totalParameters: this._countParameters(),
+      loss: this.config.modelConfig.loss,
+      metrics: this.config.modelConfig.metrics
+    };
+  }
+  /**
+   * Train with early stopping callback
+   * @param {Array} data - Training data
+   * @param {Object} earlyStoppingConfig - Early stopping configuration
+   * @returns {Object} Training results
+   */
+  async trainWithEarlyStopping(data, earlyStoppingConfig = {}) {
+    const {
+      patience = 10,
+      minDelta = 1e-3,
+      monitor = "val_loss",
+      restoreBestWeights = true
+    } = earlyStoppingConfig;
+    const { xs, ys } = this._prepareData(data);
+    if (!this.model) {
+      this.buildModel();
+    }
+    let bestValue = Infinity;
+    let patienceCounter = 0;
+    let bestWeights = null;
+    const callbacks = {
+      onEpochEnd: async (epoch, logs) => {
+        const monitorValue = logs[monitor] || logs.loss;
+        if (this.config.verbose && epoch % 10 === 0) {
+          console.log(`[MLPlugin] ${this.config.name} - Epoch ${epoch}: ${monitor}=${monitorValue.toFixed(4)}`);
+        }
+        if (monitorValue < bestValue - minDelta) {
+          bestValue = monitorValue;
+          patienceCounter = 0;
+          if (restoreBestWeights) {
+            bestWeights = await this.model.getWeights();
+          }
+        } else {
+          patienceCounter++;
+          if (patienceCounter >= patience) {
+            if (this.config.verbose) {
+              console.log(`[MLPlugin] ${this.config.name} - Early stopping at epoch ${epoch}`);
+            }
+            this.model.stopTraining = true;
+          }
+        }
+      }
+    };
+    const history = await this.model.fit(xs, ys, {
+      epochs: this.config.modelConfig.epochs,
+      batchSize: this.config.modelConfig.batchSize,
+      validationSplit: this.config.modelConfig.validationSplit,
+      verbose: this.config.verbose ? 1 : 0,
+      callbacks
+    });
+    if (restoreBestWeights && bestWeights) {
+      this.model.setWeights(bestWeights);
+    }
+    this.isTrained = true;
+    this.stats.trainedAt = (/* @__PURE__ */ new Date()).toISOString();
+    this.stats.samples = data.length;
+    this.stats.loss = history.history.loss[history.history.loss.length - 1];
+    xs.dispose();
+    ys.dispose();
+    return {
+      loss: this.stats.loss,
+      epochs: history.epoch.length,
+      samples: this.stats.samples,
+      stoppedEarly: history.epoch.length < this.config.modelConfig.epochs
+    };
+  }
+  /**
+   * Export model with neural network-specific data
+   */
+  async export() {
+    const baseExport = await super.export();
+    return {
+      ...baseExport,
+      type: "neural-network",
+      architecture: this.getArchitecture()
+    };
+  }
+}
+
+class MLPlugin extends Plugin {
+  constructor(options = {}) {
+    super(options);
+    this.config = {
+      models: options.models || {},
+      verbose: options.verbose || false,
+      minTrainingSamples: options.minTrainingSamples || 10
+    };
+    requirePluginDependency("@tensorflow/tfjs-node", "MLPlugin");
+    this.models = {};
+    this.training = /* @__PURE__ */ new Map();
+    this.insertCounters = /* @__PURE__ */ new Map();
+    this.intervals = [];
+    this.stats = {
+      totalTrainings: 0,
+      totalPredictions: 0,
+      totalErrors: 0,
+      startedAt: null
+    };
+  }
+  /**
+   * Install the plugin
+   */
+  async onInstall() {
+    if (this.config.verbose) {
+      console.log("[MLPlugin] Installing ML Plugin...");
+    }
+    for (const [modelName, modelConfig] of Object.entries(this.config.models)) {
+      this._validateModelConfig(modelName, modelConfig);
+    }
+    for (const [modelName, modelConfig] of Object.entries(this.config.models)) {
+      await this._initializeModel(modelName, modelConfig);
+    }
+    for (const [modelName, modelConfig] of Object.entries(this.config.models)) {
+      if (modelConfig.autoTrain) {
+        this._setupAutoTraining(modelName, modelConfig);
+      }
+    }
+    this.stats.startedAt = (/* @__PURE__ */ new Date()).toISOString();
+    if (this.config.verbose) {
+      console.log(`[MLPlugin] Installed with ${Object.keys(this.models).length} models`);
+    }
+    this.emit("installed", {
+      plugin: "MLPlugin",
+      models: Object.keys(this.models)
+    });
+  }
+  /**
+   * Start the plugin
+   */
+  async onStart() {
+    for (const modelName of Object.keys(this.models)) {
+      await this._loadModel(modelName);
+    }
+    if (this.config.verbose) {
+      console.log("[MLPlugin] Started");
+    }
+  }
+  /**
+   * Stop the plugin
+   */
+  async onStop() {
+    for (const handle of this.intervals) {
+      clearInterval(handle);
+    }
+    this.intervals = [];
+    for (const [modelName, model] of Object.entries(this.models)) {
+      if (model && model.dispose) {
+        model.dispose();
+      }
+    }
+    if (this.config.verbose) {
+      console.log("[MLPlugin] Stopped");
+    }
+  }
+  /**
+   * Uninstall the plugin
+   */
+  async onUninstall(options = {}) {
+    await this.onStop();
+    if (options.purgeData) {
+      for (const modelName of Object.keys(this.models)) {
+        await this._deleteModel(modelName);
+      }
+      if (this.config.verbose) {
+        console.log("[MLPlugin] Purged all model data");
+      }
+    }
+  }
+  /**
+   * Validate model configuration
+   * @private
+   */
+  _validateModelConfig(modelName, config) {
+    const validTypes = ["regression", "classification", "timeseries", "neural-network"];
+    if (!config.type || !validTypes.includes(config.type)) {
+      throw new ModelConfigError(
+        `Model "${modelName}" must have a valid type: ${validTypes.join(", ")}`,
+        { modelName, type: config.type, validTypes }
+      );
+    }
+    if (!config.resource) {
+      throw new ModelConfigError(
+        `Model "${modelName}" must specify a resource`,
+        { modelName }
+      );
+    }
+    if (!config.features || !Array.isArray(config.features) || config.features.length === 0) {
+      throw new ModelConfigError(
+        `Model "${modelName}" must specify at least one feature`,
+        { modelName, features: config.features }
+      );
+    }
+    if (!config.target) {
+      throw new ModelConfigError(
+        `Model "${modelName}" must specify a target field`,
+        { modelName }
+      );
+    }
+  }
+  /**
+   * Initialize a model instance
+   * @private
+   */
+  async _initializeModel(modelName, config) {
+    const modelOptions = {
+      name: modelName,
+      resource: config.resource,
+      features: config.features,
+      target: config.target,
+      modelConfig: config.modelConfig || {},
+      verbose: this.config.verbose
+    };
+    try {
+      switch (config.type) {
+        case "regression":
+          this.models[modelName] = new RegressionModel(modelOptions);
+          break;
+        case "classification":
+          this.models[modelName] = new ClassificationModel(modelOptions);
+          break;
+        case "timeseries":
+          this.models[modelName] = new TimeSeriesModel(modelOptions);
+          break;
+        case "neural-network":
+          this.models[modelName] = new NeuralNetworkModel(modelOptions);
+          break;
+        default:
+          throw new ModelConfigError(
+            `Unknown model type: ${config.type}`,
+            { modelName, type: config.type }
+          );
+      }
+      if (this.config.verbose) {
+        console.log(`[MLPlugin] Initialized model "${modelName}" (${config.type})`);
+      }
+    } catch (error) {
+      console.error(`[MLPlugin] Failed to initialize model "${modelName}":`, error.message);
+      throw error;
+    }
+  }
+  /**
+   * Setup auto-training for a model
+   * @private
+   */
+  _setupAutoTraining(modelName, config) {
+    const resource = this.database.resources[config.resource];
+    if (!resource) {
+      console.warn(`[MLPlugin] Resource "${config.resource}" not found for model "${modelName}"`);
+      return;
+    }
+    this.insertCounters.set(modelName, 0);
+    if (config.trainAfterInserts && config.trainAfterInserts > 0) {
+      this.addMiddleware(resource, "insert", async (next, data, options) => {
+        const result = await next(data, options);
+        const currentCount = this.insertCounters.get(modelName) || 0;
+        this.insertCounters.set(modelName, currentCount + 1);
+        if (this.insertCounters.get(modelName) >= config.trainAfterInserts) {
+          if (this.config.verbose) {
+            console.log(`[MLPlugin] Auto-training "${modelName}" after ${config.trainAfterInserts} inserts`);
+          }
+          this.insertCounters.set(modelName, 0);
+          this.train(modelName).catch((err) => {
+            console.error(`[MLPlugin] Auto-training failed for "${modelName}":`, err.message);
+          });
+        }
+        return result;
+      });
+    }
+    if (config.trainInterval && config.trainInterval > 0) {
+      const handle = setInterval(async () => {
+        if (this.config.verbose) {
+          console.log(`[MLPlugin] Auto-training "${modelName}" (interval: ${config.trainInterval}ms)`);
+        }
+        try {
+          await this.train(modelName);
+        } catch (error) {
+          console.error(`[MLPlugin] Auto-training failed for "${modelName}":`, error.message);
+        }
+      }, config.trainInterval);
+      this.intervals.push(handle);
+      if (this.config.verbose) {
+        console.log(`[MLPlugin] Setup interval training for "${modelName}" (every ${config.trainInterval}ms)`);
+      }
+    }
+  }
+  /**
+   * Train a model
+   * @param {string} modelName - Model name
+   * @param {Object} options - Training options
+   * @returns {Object} Training results
+   */
+  async train(modelName, options = {}) {
+    const model = this.models[modelName];
+    if (!model) {
+      throw new ModelNotFoundError(
+        `Model "${modelName}" not found`,
+        { modelName, availableModels: Object.keys(this.models) }
+      );
+    }
+    if (this.training.get(modelName)) {
+      if (this.config.verbose) {
+        console.log(`[MLPlugin] Model "${modelName}" is already training, skipping...`);
+      }
+      return { skipped: true, reason: "already_training" };
+    }
+    this.training.set(modelName, true);
+    try {
+      const modelConfig = this.config.models[modelName];
+      const resource = this.database.resources[modelConfig.resource];
+      if (!resource) {
+        throw new ModelNotFoundError(
+          `Resource "${modelConfig.resource}" not found`,
+          { modelName, resource: modelConfig.resource }
+        );
+      }
+      if (this.config.verbose) {
+        console.log(`[MLPlugin] Fetching training data for "${modelName}"...`);
+      }
+      const [ok, err, data] = await tryFn(() => resource.list());
+      if (!ok) {
+        throw new TrainingError(
+          `Failed to fetch training data: ${err.message}`,
+          { modelName, resource: modelConfig.resource, originalError: err.message }
+        );
+      }
+      if (!data || data.length < this.config.minTrainingSamples) {
+        throw new TrainingError(
+          `Insufficient training data: ${data?.length || 0} samples (minimum: ${this.config.minTrainingSamples})`,
+          { modelName, samples: data?.length || 0, minimum: this.config.minTrainingSamples }
+        );
+      }
+      if (this.config.verbose) {
+        console.log(`[MLPlugin] Training "${modelName}" with ${data.length} samples...`);
+      }
+      const result = await model.train(data);
+      await this._saveModel(modelName);
+      this.stats.totalTrainings++;
+      if (this.config.verbose) {
+        console.log(`[MLPlugin] Training completed for "${modelName}":`, result);
+      }
+      this.emit("modelTrained", {
+        modelName,
+        type: modelConfig.type,
+        result
+      });
+      return result;
+    } catch (error) {
+      this.stats.totalErrors++;
+      if (error instanceof MLError) {
+        throw error;
+      }
+      throw new TrainingError(
+        `Training failed for "${modelName}": ${error.message}`,
+        { modelName, originalError: error.message }
+      );
+    } finally {
+      this.training.set(modelName, false);
+    }
+  }
+  /**
+   * Make a prediction
+   * @param {string} modelName - Model name
+   * @param {Object|Array} input - Input data (object for single prediction, array for time series)
+   * @returns {Object} Prediction result
+   */
+  async predict(modelName, input) {
+    const model = this.models[modelName];
+    if (!model) {
+      throw new ModelNotFoundError(
+        `Model "${modelName}" not found`,
+        { modelName, availableModels: Object.keys(this.models) }
+      );
+    }
+    try {
+      const result = await model.predict(input);
+      this.stats.totalPredictions++;
+      this.emit("prediction", {
+        modelName,
+        input,
+        result
+      });
+      return result;
+    } catch (error) {
+      this.stats.totalErrors++;
+      throw error;
+    }
+  }
+  /**
+   * Make predictions for multiple inputs
+   * @param {string} modelName - Model name
+   * @param {Array} inputs - Array of input objects
+   * @returns {Array} Array of prediction results
+   */
+  async predictBatch(modelName, inputs) {
+    const model = this.models[modelName];
+    if (!model) {
+      throw new ModelNotFoundError(
+        `Model "${modelName}" not found`,
+        { modelName, availableModels: Object.keys(this.models) }
+      );
+    }
+    return await model.predictBatch(inputs);
+  }
+  /**
+   * Retrain a model (reset and train from scratch)
+   * @param {string} modelName - Model name
+   * @param {Object} options - Options
+   * @returns {Object} Training results
+   */
+  async retrain(modelName, options = {}) {
+    const model = this.models[modelName];
+    if (!model) {
+      throw new ModelNotFoundError(
+        `Model "${modelName}" not found`,
+        { modelName, availableModels: Object.keys(this.models) }
+      );
+    }
+    if (model.dispose) {
+      model.dispose();
+    }
+    const modelConfig = this.config.models[modelName];
+    await this._initializeModel(modelName, modelConfig);
+    return await this.train(modelName, options);
+  }
+  /**
+   * Get model statistics
+   * @param {string} modelName - Model name
+   * @returns {Object} Model stats
+   */
+  getModelStats(modelName) {
+    const model = this.models[modelName];
+    if (!model) {
+      throw new ModelNotFoundError(
+        `Model "${modelName}" not found`,
+        { modelName, availableModels: Object.keys(this.models) }
+      );
+    }
+    return model.getStats();
+  }
+  /**
+   * Get plugin statistics
+   * @returns {Object} Plugin stats
+   */
+  getStats() {
+    return {
+      ...this.stats,
+      models: Object.keys(this.models).length,
+      trainedModels: Object.values(this.models).filter((m) => m.isTrained).length
+    };
+  }
+  /**
+   * Export a model
+   * @param {string} modelName - Model name
+   * @returns {Object} Serialized model
+   */
+  async exportModel(modelName) {
+    const model = this.models[modelName];
+    if (!model) {
+      throw new ModelNotFoundError(
+        `Model "${modelName}" not found`,
+        { modelName, availableModels: Object.keys(this.models) }
+      );
+    }
+    return await model.export();
+  }
+  /**
+   * Import a model
+   * @param {string} modelName - Model name
+   * @param {Object} data - Serialized model data
+   */
+  async importModel(modelName, data) {
+    const model = this.models[modelName];
+    if (!model) {
+      throw new ModelNotFoundError(
+        `Model "${modelName}" not found`,
+        { modelName, availableModels: Object.keys(this.models) }
+      );
+    }
+    await model.import(data);
+    await this._saveModel(modelName);
+    if (this.config.verbose) {
+      console.log(`[MLPlugin] Imported model "${modelName}"`);
+    }
+  }
+  /**
+   * Save model to plugin storage
+   * @private
+   */
+  async _saveModel(modelName) {
+    try {
+      const storage = this.getStorage();
+      const exportedModel = await this.models[modelName].export();
+      if (!exportedModel) {
+        if (this.config.verbose) {
+          console.log(`[MLPlugin] Model "${modelName}" not trained, skipping save`);
+        }
+        return;
+      }
+      await storage.patch(`model_${modelName}`, {
+        modelName,
+        data: JSON.stringify(exportedModel),
+        savedAt: (/* @__PURE__ */ new Date()).toISOString()
+      });
+      if (this.config.verbose) {
+        console.log(`[MLPlugin] Saved model "${modelName}" to plugin storage`);
+      }
+    } catch (error) {
+      console.error(`[MLPlugin] Failed to save model "${modelName}":`, error.message);
+    }
+  }
+  /**
+   * Load model from plugin storage
+   * @private
+   */
+  async _loadModel(modelName) {
+    try {
+      const storage = this.getStorage();
+      const [ok, err, record] = await tryFn(() => storage.get(`model_${modelName}`));
+      if (!ok || !record) {
+        if (this.config.verbose) {
+          console.log(`[MLPlugin] No saved model found for "${modelName}"`);
+        }
+        return;
+      }
+      const modelData = JSON.parse(record.data);
+      await this.models[modelName].import(modelData);
+      if (this.config.verbose) {
+        console.log(`[MLPlugin] Loaded model "${modelName}" from plugin storage`);
+      }
+    } catch (error) {
+      console.error(`[MLPlugin] Failed to load model "${modelName}":`, error.message);
+    }
+  }
+  /**
+   * Delete model from plugin storage
+   * @private
+   */
+  async _deleteModel(modelName) {
+    try {
+      const storage = this.getStorage();
+      await storage.delete(`model_${modelName}`);
+      if (this.config.verbose) {
+        console.log(`[MLPlugin] Deleted model "${modelName}" from plugin storage`);
+      }
+    } catch (error) {
+      if (this.config.verbose) {
+        console.log(`[MLPlugin] Could not delete model "${modelName}": ${error.message}`);
+      }
+    }
+  }
+}
+
 class SqsConsumer {
   constructor({ queueUrl, onMessage, onError, poolingInterval = 5e3, maxMessages = 10, region = "us-east-1", credentials, endpoint, driver = "sqs" }) {
     this.driver = driver;
@@ -13424,7 +15192,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 +15216,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 +15245,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 +15259,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 +15357,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 +15367,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 +15382,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 +15485,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 +15507,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 +15518,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 +15536,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 +15566,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 +15585,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 +15605,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 +15649,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 +15668,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 +15710,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 +15846,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 +17568,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 +17595,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 +17616,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") {
@@ -18358,6 +20202,7 @@ ${errorDetails}`,
       events = {},
       asyncEvents = true,
       asyncPartitions = true,
+      strictPartitions = false,
       createdBy = "user"
     } = config;
     this.name = name;
@@ -18389,6 +20234,7 @@ ${errorDetails}`,
       allNestedObjectsOptional,
       asyncEvents,
       asyncPartitions,
+      strictPartitions,
       createdBy
     };
     this.hooks = {
@@ -19141,17 +20987,31 @@ ${errorDetails}`,
       throw errPut;
     }
     const insertedObject = await this.get(finalId);
-    if (this.config.asyncPartitions && this.config.partitions && Object.keys(this.config.partitions).length > 0) {
-      setImmediate(() => {
-        this.createPartitionReferences(insertedObject).catch((err) => {
+    if (this.config.partitions && Object.keys(this.config.partitions).length > 0) {
+      if (this.config.strictPartitions) {
+        await this.createPartitionReferences(insertedObject);
+      } else if (this.config.asyncPartitions) {
+        setImmediate(() => {
+          this.createPartitionReferences(insertedObject).catch((err) => {
+            this.emit("partitionIndexError", {
+              operation: "insert",
+              id: finalId,
+              error: err,
+              message: err.message
+            });
+          });
+        });
+      } else {
+        const [ok, err] = await tryFn(() => this.createPartitionReferences(insertedObject));
+        if (!ok) {
           this.emit("partitionIndexError", {
             operation: "insert",
             id: finalId,
             error: err,
             message: err.message
           });
-        });
-      });
+        }
+      }
       const nonPartitionHooks = this.hooks.afterInsert.filter(
         (hook) => !hook.toString().includes("createPartitionReferences")
       );
@@ -19446,17 +21306,31 @@ ${errorDetails}`,
       body: finalBody,
       behavior: this.behavior
     });
-    if (this.config.asyncPartitions && this.config.partitions && Object.keys(this.config.partitions).length > 0) {
-      setImmediate(() => {
-        this.handlePartitionReferenceUpdates(originalData, updatedData).catch((err2) => {
+    if (this.config.partitions && Object.keys(this.config.partitions).length > 0) {
+      if (this.config.strictPartitions) {
+        await this.handlePartitionReferenceUpdates(originalData, updatedData);
+      } else if (this.config.asyncPartitions) {
+        setImmediate(() => {
+          this.handlePartitionReferenceUpdates(originalData, updatedData).catch((err2) => {
+            this.emit("partitionIndexError", {
+              operation: "update",
+              id,
+              error: err2,
+              message: err2.message
+            });
+          });
+        });
+      } else {
+        const [ok2, err2] = await tryFn(() => this.handlePartitionReferenceUpdates(originalData, updatedData));
+        if (!ok2) {
           this.emit("partitionIndexError", {
             operation: "update",
             id,
             error: err2,
             message: err2.message
           });
-        });
-      });
+        }
+      }
       const nonPartitionHooks = this.hooks.afterUpdate.filter(
         (hook) => !hook.toString().includes("handlePartitionReferenceUpdates")
       );
@@ -19569,7 +21443,9 @@ ${errorDetails}`,
     if (this.config.partitions && Object.keys(this.config.partitions).length > 0) {
       const oldData = { ...currentData, id };
       const newData = { ...mergedData, id };
-      if (this.config.asyncPartitions) {
+      if (this.config.strictPartitions) {
+        await this.handlePartitionReferenceUpdates(oldData, newData);
+      } else if (this.config.asyncPartitions) {
         setImmediate(() => {
           this.handlePartitionReferenceUpdates(oldData, newData).catch((err) => {
             this.emit("partitionIndexError", {
@@ -19699,7 +21575,9 @@ ${errorDetails}`,
     }
     const replacedObject = { id, ...validatedAttributes };
     if (this.config.partitions && Object.keys(this.config.partitions).length > 0) {
-      if (this.config.asyncPartitions) {
+      if (this.config.strictPartitions) {
+        await this.handlePartitionReferenceUpdates({}, replacedObject);
+      } else if (this.config.asyncPartitions) {
         setImmediate(() => {
           this.handlePartitionReferenceUpdates({}, replacedObject).catch((err) => {
             this.emit("partitionIndexError", {
@@ -19839,17 +21717,31 @@ ${errorDetails}`,
     });
     const oldData = { ...originalData, id };
     const newData = { ...validatedAttributes, id };
-    if (this.config.asyncPartitions && this.config.partitions && Object.keys(this.config.partitions).length > 0) {
-      setImmediate(() => {
-        this.handlePartitionReferenceUpdates(oldData, newData).catch((err2) => {
+    if (this.config.partitions && Object.keys(this.config.partitions).length > 0) {
+      if (this.config.strictPartitions) {
+        await this.handlePartitionReferenceUpdates(oldData, newData);
+      } else if (this.config.asyncPartitions) {
+        setImmediate(() => {
+          this.handlePartitionReferenceUpdates(oldData, newData).catch((err2) => {
+            this.emit("partitionIndexError", {
+              operation: "updateConditional",
+              id,
+              error: err2,
+              message: err2.message
+            });
+          });
+        });
+      } else {
+        const [ok2, err2] = await tryFn(() => this.handlePartitionReferenceUpdates(oldData, newData));
+        if (!ok2) {
           this.emit("partitionIndexError", {
             operation: "updateConditional",
             id,
             error: err2,
             message: err2.message
           });
-        });
-      });
+        }
+      }
       const nonPartitionHooks = this.hooks.afterUpdate.filter(
         (hook) => !hook.toString().includes("handlePartitionReferenceUpdates")
       );
@@ -19925,17 +21817,31 @@ ${errorDetails}`,
       operation: "delete",
       id
     });
-    if (this.config.asyncPartitions && this.config.partitions && Object.keys(this.config.partitions).length > 0) {
-      setImmediate(() => {
-        this.deletePartitionReferences(objectData).catch((err3) => {
+    if (this.config.partitions && Object.keys(this.config.partitions).length > 0 && objectData) {
+      if (this.config.strictPartitions) {
+        await this.deletePartitionReferences(objectData);
+      } else if (this.config.asyncPartitions) {
+        setImmediate(() => {
+          this.deletePartitionReferences(objectData).catch((err3) => {
+            this.emit("partitionIndexError", {
+              operation: "delete",
+              id,
+              error: err3,
+              message: err3.message
+            });
+          });
+        });
+      } else {
+        const [ok3, err3] = await tryFn(() => this.deletePartitionReferences(objectData));
+        if (!ok3) {
           this.emit("partitionIndexError", {
             operation: "delete",
             id,
             error: err3,
             message: err3.message
           });
-        });
-      });
+        }
+      }
       const nonPartitionHooks = this.hooks.afterDelete.filter(
         (hook) => !hook.toString().includes("deletePartitionReferences")
       );
@@ -21306,10 +23212,13 @@ function validateResourceConfig(config) {
 class Database extends EventEmitter {
   constructor(options) {
     super();
-    this.id = idGenerator(7);
+    this.id = (() => {
+      const [ok, err, id] = tryFn(() => idGenerator(7));
+      return ok && id ? id : `db-${Date.now()}-${Math.random().toString(36).substr(2, 9)}`;
+    })();
     this.version = "1";
     this.s3dbVersion = (() => {
-      const [ok, err, version] = tryFn(() => true ? "12.3.0" : "latest");
+      const [ok, err, version] = tryFn(() => true ? "13.0.0" : "latest");
       return ok ? version : "latest";
     })();
     this._resourcesMap = {};
@@ -21343,6 +23252,7 @@ class Database extends EventEmitter {
     this.versioningEnabled = options.versioningEnabled || false;
     this.persistHooks = options.persistHooks || false;
     this.strictValidation = options.strictValidation !== false;
+    this.strictHooks = options.strictHooks || false;
     this._initHooks();
     let connectionString = options.connectionString;
     if (!connectionString && (options.bucket || options.accessKeyId || options.secretAccessKey)) {
@@ -21365,7 +23275,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
@@ -21373,18 +23283,25 @@ class Database extends EventEmitter {
     this.connectionString = connectionString;
     this.bucket = this.client.bucket;
     this.keyPrefix = this.client.keyPrefix;
-    if (!this._exitListenerRegistered) {
+    this._registerExitListener();
+  }
+  /**
+   * Register process exit listener for automatic cleanup
+   * @private
+   */
+  _registerExitListener() {
+    if (!this._exitListenerRegistered && typeof process !== "undefined") {
       this._exitListenerRegistered = true;
-      if (typeof process !== "undefined") {
-        process.on("exit", async () => {
-          if (this.isConnected()) {
-            await tryFn(() => this.disconnect());
-          }
-        });
-      }
+      this._exitListener = async () => {
+        if (this.isConnected()) {
+          await tryFn(() => this.disconnect());
+        }
+      };
+      process.on("exit", this._exitListener);
     }
   }
   async connect() {
+    this._registerExitListener();
     await this.startPlugins();
     let metadata = null;
     let needsHealing = false;
@@ -22347,11 +24264,16 @@ class Database extends EventEmitter {
       if (this.client && typeof this.client.removeAllListeners === "function") {
         this.client.removeAllListeners();
       }
+      await this.emit("disconnected", /* @__PURE__ */ new Date());
       this.removeAllListeners();
+      if (this._exitListener && typeof process !== "undefined") {
+        process.off("exit", this._exitListener);
+        this._exitListener = null;
+        this._exitListenerRegistered = false;
+      }
       this.savedMetadata = null;
       this.plugins = {};
       this.pluginList = [];
-      this.emit("disconnected", /* @__PURE__ */ new Date());
     });
   }
   /**
@@ -22455,6 +24377,13 @@ class Database extends EventEmitter {
       const [ok, error] = await tryFn(() => hook({ database: this, ...context }));
       if (!ok) {
         this.emit("hookError", { event, error, context });
+        if (this.strictHooks) {
+          throw new DatabaseError(`Hook execution failed for event '${event}': ${error.message}`, {
+            event,
+            originalError: error,
+            context
+          });
+        }
       }
     }
   }
@@ -26271,7 +28200,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 +39826,1082 @@ 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 = [];
+      const resource = database && database.resources && database.resources[resourceName];
+      for (const key of keys) {
+        const idMatch = key.match(/\/id=([^/]+)/);
+        const recordId = idMatch ? idMatch[1] : null;
+        let record;
+        if (resource && recordId) {
+          try {
+            record = await resource.get(recordId);
+          } catch (err) {
+            console.warn(`Failed to get record ${recordId} from resource ${resourceName}, using fallback`);
+            record = null;
+          }
+        }
+        if (!record) {
+          const obj = await this.getObject(key);
+          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 +41807,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, MLPlugin, 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