s3db.js 13.1.0 → 13.2.2

package/dist/s3db.cjs.js

@@ -2567,6 +2567,18 @@ const PLUGIN_DEPENDENCIES = {
         npmUrl: "https://www.npmjs.com/package/@hono/swagger-ui"
       }
     }
+  },
+  "ml-plugin": {
+    name: "ML Plugin",
+    docsUrl: "https://github.com/forattini-dev/s3db.js/blob/main/docs/plugins/ml-plugin.md",
+    dependencies: {
+      "@tensorflow/tfjs-node": {
+        version: "^4.0.0",
+        description: "TensorFlow.js for Node.js with native bindings",
+        installCommand: "pnpm add @tensorflow/tfjs-node",
+        npmUrl: "https://www.npmjs.com/package/@tensorflow/tfjs-node"
+      }
+    }
   }
 };
 function isVersionCompatible(actual, required) {
@@ -6616,7 +6628,7 @@ class BackupPlugin extends Plugin {
       const storageInfo = this.driver.getStorageInfo();
       console.log(`[BackupPlugin] Initialized with driver: ${storageInfo.type}`);
     }
-    this.emit("initialized", {
+    this.emit("db:plugin:initialized", {
       driver: this.driver.getType(),
       config: this.driver.getStorageInfo()
     });
@@ -6664,7 +6676,7 @@ class BackupPlugin extends Plugin {
       if (this.config.onBackupStart) {
         await this._executeHook(this.config.onBackupStart, type, { backupId });
       }
-      this.emit("backup_start", { id: backupId, type });
+      this.emit("plg:backup:start", { id: backupId, type });
       const metadata = await this._createBackupMetadata(backupId, type);
       const tempBackupDir = path$1.join(this.config.tempDir, backupId);
       await promises.mkdir(tempBackupDir, { recursive: true });
@@ -6697,7 +6709,7 @@ class BackupPlugin extends Plugin {
           const stats = { backupId, type, size: totalSize, duration, driverInfo: uploadResult };
           await this._executeHook(this.config.onBackupComplete, type, stats);
         }
-        this.emit("backup_complete", {
+        this.emit("plg:backup:complete", {
           id: backupId,
           type,
           size: totalSize,
@@ -6725,7 +6737,7 @@ class BackupPlugin extends Plugin {
         error: error.message,
         duration: Date.now() - startTime
       });
-      this.emit("backup_error", { id: backupId, type, error: error.message });
+      this.emit("plg:backup:error", { id: backupId, type, error: error.message });
       throw error;
     } finally {
       this.activeBackups.delete(backupId);
@@ -6946,7 +6958,7 @@ class BackupPlugin extends Plugin {
       if (this.config.onRestoreStart) {
         await this._executeHook(this.config.onRestoreStart, backupId, options);
       }
-      this.emit("restore_start", { id: backupId, options });
+      this.emit("plg:backup:restore-start", { id: backupId, options });
       const backup = await this.getBackupStatus(backupId);
       if (!backup) {
         throw new Error(`Backup '${backupId}' not found`);
@@ -6969,7 +6981,7 @@ class BackupPlugin extends Plugin {
         if (this.config.onRestoreComplete) {
           await this._executeHook(this.config.onRestoreComplete, backupId, { restored: restoredResources });
         }
-        this.emit("restore_complete", {
+        this.emit("plg:backup:restore-complete", {
           id: backupId,
           restored: restoredResources
         });
@@ -6984,7 +6996,7 @@ class BackupPlugin extends Plugin {
       if (this.config.onRestoreError) {
         await this._executeHook(this.config.onRestoreError, backupId, { error });
       }
-      this.emit("restore_error", { id: backupId, error: error.message });
+      this.emit("plg:backup:restore-error", { id: backupId, error: error.message });
       throw error;
     }
   }
@@ -7234,7 +7246,7 @@ class BackupPlugin extends Plugin {
   }
   async stop() {
     for (const backupId of this.activeBackups) {
-      this.emit("backup_cancelled", { id: backupId });
+      this.emit("plg:backup:cancelled", { id: backupId });
     }
     this.activeBackups.clear();
     if (this.driver) {
@@ -8758,7 +8770,7 @@ class CachePlugin extends Plugin {
         const specificKey = await this.generateCacheKey(resource, method, { id: data.id });
         const [ok2, err2] = await this.clearCacheWithRetry(resource.cache, specificKey);
         if (!ok2) {
-          this.emit("cache_clear_error", {
+          this.emit("plg:cache:clear-error", {
             resource: resource.name,
             method,
             id: data.id,
@@ -8776,7 +8788,7 @@ class CachePlugin extends Plugin {
             const partitionKeyPrefix = path$1.join(keyPrefix, `partition=${partitionName}`);
             const [ok2, err2] = await this.clearCacheWithRetry(resource.cache, partitionKeyPrefix);
             if (!ok2) {
-              this.emit("cache_clear_error", {
+              this.emit("plg:cache:clear-error", {
                 resource: resource.name,
                 partition: partitionName,
                 error: err2.message
@@ -8791,7 +8803,7 @@ class CachePlugin extends Plugin {
     }
     const [ok, err] = await this.clearCacheWithRetry(resource.cache, keyPrefix);
     if (!ok) {
-      this.emit("cache_clear_error", {
+      this.emit("plg:cache:clear-error", {
         resource: resource.name,
         type: "broad",
         error: err.message
@@ -12691,7 +12703,7 @@ class GeoPlugin extends Plugin {
     if (this.verbose) {
       console.log(`[GeoPlugin] Installed with ${Object.keys(this.resources).length} resources`);
     }
-    this.emit("installed", {
+    this.emit("db:plugin:installed", {
       plugin: "GeoPlugin",
       resources: Object.keys(this.resources)
     });
@@ -13258,7 +13270,7 @@ class GeoPlugin extends Plugin {
     if (this.verbose) {
       console.log("[GeoPlugin] Uninstalled");
     }
-    this.emit("uninstalled", {
+    this.emit("db:plugin:uninstalled", {
       plugin: "GeoPlugin"
     });
     await super.uninstall();
@@ -15260,7 +15272,7 @@ class MLPlugin extends Plugin {
       enableVersioning: options.enableVersioning !== false
       // Default true
     };
-    requirePluginDependency("@tensorflow/tfjs-node", "MLPlugin");
+    requirePluginDependency("ml-plugin");
     this.models = {};
     this.modelVersions = /* @__PURE__ */ new Map();
     this.modelCache = /* @__PURE__ */ new Map();
@@ -15298,7 +15310,7 @@ class MLPlugin extends Plugin {
     if (this.config.verbose) {
       console.log(`[MLPlugin] Installed with ${Object.keys(this.models).length} models`);
     }
-    this.emit("installed", {
+    this.emit("db:plugin:installed", {
       plugin: "MLPlugin",
       models: Object.keys(this.models)
     });
@@ -15649,6 +15661,22 @@ class MLPlugin extends Plugin {
         }
         data = allData;
       }
+      if (modelConfig.filter && typeof modelConfig.filter === "function") {
+        if (this.config.verbose) {
+          console.log(`[MLPlugin] Applying custom filter function...`);
+        }
+        const originalLength = data.length;
+        data = data.filter(modelConfig.filter);
+        if (this.config.verbose) {
+          console.log(`[MLPlugin] Filter reduced dataset from ${originalLength} to ${data.length} samples`);
+        }
+      }
+      if (modelConfig.map && typeof modelConfig.map === "function") {
+        if (this.config.verbose) {
+          console.log(`[MLPlugin] Applying custom map function...`);
+        }
+        data = data.map(modelConfig.map);
+      }
       if (!data || data.length < this.config.minTrainingSamples) {
         throw new TrainingError(
           `Insufficient training data: ${data?.length || 0} samples (minimum: ${this.config.minTrainingSamples})`,
@@ -15671,7 +15699,7 @@ class MLPlugin extends Plugin {
       if (this.config.verbose) {
         console.log(`[MLPlugin] Training completed for "${modelName}":`, result);
       }
-      this.emit("modelTrained", {
+      this.emit("plg:ml:model-trained", {
         modelName,
         type: modelConfig.type,
         result
@@ -15707,7 +15735,7 @@ class MLPlugin extends Plugin {
     try {
       const result = await model.predict(input);
       this.stats.totalPredictions++;
-      this.emit("prediction", {
+      this.emit("plg:ml:prediction", {
         modelName,
         input,
         result
@@ -15822,7 +15850,11 @@ class MLPlugin extends Plugin {
   async _initializeVersioning(modelName) {
     try {
       const storage = this.getStorage();
-      const [ok, err, versionInfo] = await tryFn(() => storage.get(`version_${modelName}`));
+      const modelConfig = this.config.models[modelName];
+      const resourceName = modelConfig.resource;
+      const [ok, err, versionInfo] = await tryFn(
+        () => storage.get(storage.getPluginKey(resourceName, "metadata", modelName, "versions"))
+      );
       if (ok && versionInfo) {
         this.modelVersions.set(modelName, {
           currentVersion: versionInfo.currentVersion || 1,
@@ -15861,16 +15893,22 @@ class MLPlugin extends Plugin {
   async _updateVersionInfo(modelName, version) {
     try {
       const storage = this.getStorage();
+      const modelConfig = this.config.models[modelName];
+      const resourceName = modelConfig.resource;
       const versionInfo = this.modelVersions.get(modelName) || { currentVersion: 1, latestVersion: 0 };
       versionInfo.latestVersion = Math.max(versionInfo.latestVersion, version);
       versionInfo.currentVersion = version;
       this.modelVersions.set(modelName, versionInfo);
-      await storage.patch(`version_${modelName}`, {
-        modelName,
-        currentVersion: versionInfo.currentVersion,
-        latestVersion: versionInfo.latestVersion,
-        updatedAt: (/* @__PURE__ */ new Date()).toISOString()
-      });
+      await storage.set(
+        storage.getPluginKey(resourceName, "metadata", modelName, "versions"),
+        {
+          modelName,
+          currentVersion: versionInfo.currentVersion,
+          latestVersion: versionInfo.latestVersion,
+          updatedAt: (/* @__PURE__ */ new Date()).toISOString()
+        },
+        { behavior: "body-overflow" }
+      );
       if (this.config.verbose) {
         console.log(`[MLPlugin] Updated version info for "${modelName}": current=v${versionInfo.currentVersion}, latest=v${versionInfo.latestVersion}`);
       }
@@ -15885,6 +15923,8 @@ class MLPlugin extends Plugin {
   async _saveModel(modelName) {
     try {
       const storage = this.getStorage();
+      const modelConfig = this.config.models[modelName];
+      const resourceName = modelConfig.resource;
       const exportedModel = await this.models[modelName].export();
       if (!exportedModel) {
         if (this.config.verbose) {
@@ -15896,37 +15936,52 @@ class MLPlugin extends Plugin {
       if (enableVersioning) {
         const version = this._getNextVersion(modelName);
         const modelStats = this.models[modelName].getStats();
-        await storage.patch(`model_${modelName}_v${version}`, {
-          modelName,
-          version,
-          type: "model",
-          data: JSON.stringify(exportedModel),
-          metrics: JSON.stringify({
-            loss: modelStats.loss,
-            accuracy: modelStats.accuracy,
-            samples: modelStats.samples
-          }),
-          savedAt: (/* @__PURE__ */ new Date()).toISOString()
-        });
+        await storage.set(
+          storage.getPluginKey(resourceName, "models", modelName, `v${version}`),
+          {
+            modelName,
+            version,
+            type: "model",
+            modelData: exportedModel,
+            // TensorFlow.js model object (will go to body)
+            metrics: {
+              loss: modelStats.loss,
+              accuracy: modelStats.accuracy,
+              samples: modelStats.samples
+            },
+            savedAt: (/* @__PURE__ */ new Date()).toISOString()
+          },
+          { behavior: "body-only" }
+          // Large binary data goes to S3 body
+        );
         await this._updateVersionInfo(modelName, version);
-        await storage.patch(`model_${modelName}_active`, {
-          modelName,
-          version,
-          type: "reference",
-          updatedAt: (/* @__PURE__ */ new Date()).toISOString()
-        });
+        await storage.set(
+          storage.getPluginKey(resourceName, "metadata", modelName, "active"),
+          {
+            modelName,
+            version,
+            type: "reference",
+            updatedAt: (/* @__PURE__ */ new Date()).toISOString()
+          },
+          { behavior: "body-overflow" }
+          // Small metadata
+        );
         if (this.config.verbose) {
-          console.log(`[MLPlugin] Saved model "${modelName}" v${version} to plugin storage (S3)`);
+          console.log(`[MLPlugin] Saved model "${modelName}" v${version} to S3 (resource=${resourceName}/plugin=ml/models/${modelName}/v${version})`);
         }
       } else {
-        await storage.patch(`model_${modelName}`, {
-          modelName,
-          type: "model",
-          data: JSON.stringify(exportedModel),
-          savedAt: (/* @__PURE__ */ new Date()).toISOString()
-        });
+        await storage.set(
+          storage.getPluginKey(resourceName, "models", modelName, "latest"),
+          {
+            modelName,
+            type: "model",
+            modelData: exportedModel,
+            savedAt: (/* @__PURE__ */ new Date()).toISOString()
+          },
+          { behavior: "body-only" }
+        );
         if (this.config.verbose) {
-          console.log(`[MLPlugin] Saved model "${modelName}" to plugin storage (S3)`);
+          console.log(`[MLPlugin] Saved model "${modelName}" to S3 (resource=${resourceName}/plugin=ml/models/${modelName}/latest)`);
         }
       }
     } catch (error) {
@@ -15934,7 +15989,7 @@ class MLPlugin extends Plugin {
     }
   }
   /**
-   * Save intermediate training data to plugin storage (incremental)
+   * Save intermediate training data to plugin storage (incremental - only new samples)
    * @private
    */
   async _saveTrainingData(modelName, rawData) {
@@ -15942,64 +15997,106 @@ class MLPlugin extends Plugin {
       const storage = this.getStorage();
       const model = this.models[modelName];
       const modelConfig = this.config.models[modelName];
+      const resourceName = modelConfig.resource;
       const modelStats = model.getStats();
       const enableVersioning = this.config.enableVersioning;
-      const trainingEntry = {
-        version: enableVersioning ? this.modelVersions.get(modelName)?.latestVersion || 1 : void 0,
-        samples: rawData.length,
-        features: modelConfig.features,
-        target: modelConfig.target,
-        data: rawData.map((item) => {
-          const features = {};
-          modelConfig.features.forEach((feature) => {
-            features[feature] = item[feature];
-          });
-          return {
-            features,
-            target: item[modelConfig.target]
-          };
-        }),
-        metrics: {
-          loss: modelStats.loss,
-          accuracy: modelStats.accuracy,
-          r2: modelStats.r2
-        },
-        trainedAt: (/* @__PURE__ */ new Date()).toISOString()
-      };
+      const processedData = rawData.map((item) => {
+        const features = {};
+        modelConfig.features.forEach((feature) => {
+          features[feature] = item[feature];
+        });
+        return {
+          id: item.id || `${Date.now()}_${Math.random()}`,
+          // Use record ID or generate
+          features,
+          target: item[modelConfig.target]
+        };
+      });
       if (enableVersioning) {
-        const [ok, err, existing] = await tryFn(() => storage.get(`training_history_${modelName}`));
+        const version = this._getNextVersion(modelName);
+        const [ok, err, existing] = await tryFn(
+          () => storage.get(storage.getPluginKey(resourceName, "training", "history", modelName))
+        );
         let history = [];
+        let previousSampleIds = /* @__PURE__ */ new Set();
         if (ok && existing && existing.history) {
-          try {
-            history = JSON.parse(existing.history);
-          } catch (e) {
-            history = [];
-          }
+          history = existing.history;
+          history.forEach((entry) => {
+            if (entry.sampleIds) {
+              entry.sampleIds.forEach((id) => previousSampleIds.add(id));
+            }
+          });
         }
-        history.push(trainingEntry);
-        await storage.patch(`training_history_${modelName}`, {
-          modelName,
-          type: "training_history",
-          totalTrainings: history.length,
-          latestVersion: trainingEntry.version,
-          history: JSON.stringify(history),
-          updatedAt: (/* @__PURE__ */ new Date()).toISOString()
-        });
+        const currentSampleIds = new Set(processedData.map((d) => d.id));
+        const newSamples = processedData.filter((d) => !previousSampleIds.has(d.id));
+        const newSampleIds = newSamples.map((d) => d.id);
+        if (newSamples.length > 0) {
+          await storage.set(
+            storage.getPluginKey(resourceName, "training", "data", modelName, `v${version}`),
+            {
+              modelName,
+              version,
+              samples: newSamples,
+              // Only new samples
+              features: modelConfig.features,
+              target: modelConfig.target,
+              savedAt: (/* @__PURE__ */ new Date()).toISOString()
+            },
+            { behavior: "body-only" }
+            // Dataset goes to S3 body
+          );
+        }
+        const historyEntry = {
+          version,
+          totalSamples: processedData.length,
+          // Total cumulative
+          newSamples: newSamples.length,
+          // Only new in this version
+          sampleIds: Array.from(currentSampleIds),
+          // All IDs for this version
+          newSampleIds,
+          // IDs of new samples
+          storageKey: newSamples.length > 0 ? `training/data/${modelName}/v${version}` : null,
+          metrics: {
+            loss: modelStats.loss,
+            accuracy: modelStats.accuracy,
+            r2: modelStats.r2
+          },
+          trainedAt: (/* @__PURE__ */ new Date()).toISOString()
+        };
+        history.push(historyEntry);
+        await storage.set(
+          storage.getPluginKey(resourceName, "training", "history", modelName),
+          {
+            modelName,
+            type: "training_history",
+            totalTrainings: history.length,
+            latestVersion: version,
+            history,
+            // Array of metadata entries (not full data)
+            updatedAt: (/* @__PURE__ */ new Date()).toISOString()
+          },
+          { behavior: "body-overflow" }
+          // History metadata
+        );
         if (this.config.verbose) {
-          console.log(`[MLPlugin] Appended training data for "${modelName}" v${trainingEntry.version} (${trainingEntry.samples} samples, total: ${history.length} trainings)`);
+          console.log(`[MLPlugin] Saved training data for "${modelName}" v${version}: ${newSamples.length} new samples (total: ${processedData.length}, storage: resource=${resourceName}/plugin=ml/training/data/${modelName}/v${version})`);
         }
       } else {
-        await storage.patch(`training_data_${modelName}`, {
-          modelName,
-          type: "training_data",
-          samples: trainingEntry.samples,
-          features: JSON.stringify(trainingEntry.features),
-          target: trainingEntry.target,
-          data: JSON.stringify(trainingEntry.data),
-          savedAt: trainingEntry.trainedAt
-        });
+        await storage.set(
+          storage.getPluginKey(resourceName, "training", "data", modelName, "latest"),
+          {
+            modelName,
+            type: "training_data",
+            samples: processedData,
+            features: modelConfig.features,
+            target: modelConfig.target,
+            savedAt: (/* @__PURE__ */ new Date()).toISOString()
+          },
+          { behavior: "body-only" }
+        );
         if (this.config.verbose) {
-          console.log(`[MLPlugin] Saved training data for "${modelName}" (${trainingEntry.samples} samples) to plugin storage (S3)`);
+          console.log(`[MLPlugin] Saved training data for "${modelName}" (${processedData.length} samples) to S3 (resource=${resourceName}/plugin=ml/training/data/${modelName}/latest)`);
         }
       }
     } catch (error) {
@@ -16013,17 +16110,22 @@ class MLPlugin extends Plugin {
   async _loadModel(modelName) {
     try {
       const storage = this.getStorage();
+      const modelConfig = this.config.models[modelName];
+      const resourceName = modelConfig.resource;
       const enableVersioning = this.config.enableVersioning;
       if (enableVersioning) {
-        const [okRef, errRef, activeRef] = await tryFn(() => storage.get(`model_${modelName}_active`));
+        const [okRef, errRef, activeRef] = await tryFn(
+          () => storage.get(storage.getPluginKey(resourceName, "metadata", modelName, "active"))
+        );
         if (okRef && activeRef && activeRef.version) {
           const version = activeRef.version;
-          const [ok, err, versionData] = await tryFn(() => storage.get(`model_${modelName}_v${version}`));
-          if (ok && versionData) {
-            const modelData = JSON.parse(versionData.data);
-            await this.models[modelName].import(modelData);
+          const [ok, err, versionData] = await tryFn(
+            () => storage.get(storage.getPluginKey(resourceName, "models", modelName, `v${version}`))
+          );
+          if (ok && versionData && versionData.modelData) {
+            await this.models[modelName].import(versionData.modelData);
             if (this.config.verbose) {
-              console.log(`[MLPlugin] Loaded model "${modelName}" v${version} (active) from plugin storage (S3)`);
+              console.log(`[MLPlugin] Loaded model "${modelName}" v${version} (active) from S3 (resource=${resourceName}/plugin=ml/models/${modelName}/v${version})`);
             }
             return;
           }
@@ -16031,12 +16133,13 @@ class MLPlugin extends Plugin {
         const versionInfo = this.modelVersions.get(modelName);
         if (versionInfo && versionInfo.latestVersion > 0) {
           const version = versionInfo.latestVersion;
-          const [ok, err, versionData] = await tryFn(() => storage.get(`model_${modelName}_v${version}`));
-          if (ok && versionData) {
-            const modelData = JSON.parse(versionData.data);
-            await this.models[modelName].import(modelData);
+          const [ok, err, versionData] = await tryFn(
+            () => storage.get(storage.getPluginKey(resourceName, "models", modelName, `v${version}`))
+          );
+          if (ok && versionData && versionData.modelData) {
+            await this.models[modelName].import(versionData.modelData);
             if (this.config.verbose) {
-              console.log(`[MLPlugin] Loaded model "${modelName}" v${version} (latest) from plugin storage (S3)`);
+              console.log(`[MLPlugin] Loaded model "${modelName}" v${version} (latest) from S3`);
             }
             return;
           }
@@ -16045,17 +16148,18 @@ class MLPlugin extends Plugin {
           console.log(`[MLPlugin] No saved model versions found for "${modelName}"`);
         }
       } else {
-        const [ok, err, record] = await tryFn(() => storage.get(`model_${modelName}`));
-        if (!ok || !record) {
+        const [ok, err, record] = await tryFn(
+          () => storage.get(storage.getPluginKey(resourceName, "models", modelName, "latest"))
+        );
+        if (!ok || !record || !record.modelData) {
           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);
+        await this.models[modelName].import(record.modelData);
         if (this.config.verbose) {
-          console.log(`[MLPlugin] Loaded model "${modelName}" from plugin storage (S3)`);
+          console.log(`[MLPlugin] Loaded model "${modelName}" from S3 (resource=${resourceName}/plugin=ml/models/${modelName}/latest)`);
         }
       }
     } catch (error) {
@@ -16063,27 +16167,68 @@ class MLPlugin extends Plugin {
     }
   }
   /**
-   * Load training data from plugin storage
+   * Load training data from plugin storage (reconstructs specific version from incremental data)
    * @param {string} modelName - Model name
+   * @param {number} version - Version number (optional, defaults to latest)
    * @returns {Object|null} Training data or null if not found
    */
-  async getTrainingData(modelName) {
+  async getTrainingData(modelName, version = null) {
     try {
       const storage = this.getStorage();
-      const [ok, err, record] = await tryFn(() => storage.get(`training_data_${modelName}`));
-      if (!ok || !record) {
+      const modelConfig = this.config.models[modelName];
+      const resourceName = modelConfig.resource;
+      const enableVersioning = this.config.enableVersioning;
+      if (!enableVersioning) {
+        const [ok, err, record] = await tryFn(
+          () => storage.get(storage.getPluginKey(resourceName, "training", "data", modelName, "latest"))
+        );
+        if (!ok || !record) {
+          if (this.config.verbose) {
+            console.log(`[MLPlugin] No saved training data found for "${modelName}"`);
+          }
+          return null;
+        }
+        return {
+          modelName: record.modelName,
+          samples: record.samples,
+          features: record.features,
+          target: record.target,
+          data: record.samples,
+          savedAt: record.savedAt
+        };
+      }
+      const [okHistory, errHistory, historyData] = await tryFn(
+        () => storage.get(storage.getPluginKey(resourceName, "training", "history", modelName))
+      );
+      if (!okHistory || !historyData || !historyData.history) {
         if (this.config.verbose) {
-          console.log(`[MLPlugin] No saved training data found for "${modelName}"`);
+          console.log(`[MLPlugin] No training history found for "${modelName}"`);
         }
         return null;
       }
+      const targetVersion = version || historyData.latestVersion;
+      const reconstructedSamples = [];
+      for (const entry of historyData.history) {
+        if (entry.version > targetVersion) break;
+        if (entry.storageKey && entry.newSamples > 0) {
+          const [ok, err, versionData] = await tryFn(
+            () => storage.get(storage.getPluginKey(resourceName, "training", "data", modelName, `v${entry.version}`))
+          );
+          if (ok && versionData && versionData.samples) {
+            reconstructedSamples.push(...versionData.samples);
+          }
+        }
+      }
+      const targetEntry = historyData.history.find((e) => e.version === targetVersion);
       return {
-        modelName: record.modelName,
-        samples: record.samples,
-        features: JSON.parse(record.features),
-        target: record.target,
-        data: JSON.parse(record.data),
-        savedAt: record.savedAt
+        modelName,
+        version: targetVersion,
+        samples: reconstructedSamples,
+        totalSamples: reconstructedSamples.length,
+        features: modelConfig.features,
+        target: modelConfig.target,
+        metrics: targetEntry?.metrics,
+        savedAt: targetEntry?.trainedAt
       };
     } catch (error) {
       console.error(`[MLPlugin] Failed to load training data for "${modelName}":`, error.message);
@@ -16091,15 +16236,29 @@ class MLPlugin extends Plugin {
     }
   }
   /**
-   * Delete model from plugin storage
+   * Delete model from plugin storage (all versions)
    * @private
    */
   async _deleteModel(modelName) {
     try {
       const storage = this.getStorage();
-      await storage.delete(`model_${modelName}`);
+      const modelConfig = this.config.models[modelName];
+      const resourceName = modelConfig.resource;
+      const enableVersioning = this.config.enableVersioning;
+      if (enableVersioning) {
+        const versionInfo = this.modelVersions.get(modelName);
+        if (versionInfo && versionInfo.latestVersion > 0) {
+          for (let v = 1; v <= versionInfo.latestVersion; v++) {
+            await storage.delete(storage.getPluginKey(resourceName, "models", modelName, `v${v}`));
+          }
+        }
+        await storage.delete(storage.getPluginKey(resourceName, "metadata", modelName, "active"));
+        await storage.delete(storage.getPluginKey(resourceName, "metadata", modelName, "versions"));
+      } else {
+        await storage.delete(storage.getPluginKey(resourceName, "models", modelName, "latest"));
+      }
       if (this.config.verbose) {
-        console.log(`[MLPlugin] Deleted model "${modelName}" from plugin storage`);
+        console.log(`[MLPlugin] Deleted model "${modelName}" from S3 (resource=${resourceName}/plugin=ml/models/${modelName}/)`);
       }
     } catch (error) {
       if (this.config.verbose) {
@@ -16108,15 +16267,32 @@ class MLPlugin extends Plugin {
     }
   }
   /**
-   * Delete training data from plugin storage
+   * Delete training data from plugin storage (all versions)
    * @private
    */
   async _deleteTrainingData(modelName) {
     try {
       const storage = this.getStorage();
-      await storage.delete(`training_data_${modelName}`);
+      const modelConfig = this.config.models[modelName];
+      const resourceName = modelConfig.resource;
+      const enableVersioning = this.config.enableVersioning;
+      if (enableVersioning) {
+        const [ok, err, historyData] = await tryFn(
+          () => storage.get(storage.getPluginKey(resourceName, "training", "history", modelName))
+        );
+        if (ok && historyData && historyData.history) {
+          for (const entry of historyData.history) {
+            if (entry.storageKey) {
+              await storage.delete(storage.getPluginKey(resourceName, "training", "data", modelName, `v${entry.version}`));
+            }
+          }
+        }
+        await storage.delete(storage.getPluginKey(resourceName, "training", "history", modelName));
+      } else {
+        await storage.delete(storage.getPluginKey(resourceName, "training", "data", modelName, "latest"));
+      }
       if (this.config.verbose) {
-        console.log(`[MLPlugin] Deleted training data for "${modelName}" from plugin storage`);
+        console.log(`[MLPlugin] Deleted training data for "${modelName}" from S3 (resource=${resourceName}/plugin=ml/training/)`);
       }
     } catch (error) {
       if (this.config.verbose) {
@@ -16135,17 +16311,18 @@ class MLPlugin extends Plugin {
     }
     try {
       const storage = this.getStorage();
+      const modelConfig = this.config.models[modelName];
+      const resourceName = modelConfig.resource;
       const versionInfo = this.modelVersions.get(modelName) || { latestVersion: 0 };
       const versions = [];
       for (let v = 1; v <= versionInfo.latestVersion; v++) {
-        const [ok, err, versionData] = await tryFn(() => storage.get(`model_${modelName}_v${v}`));
+        const [ok, err, versionData] = await tryFn(() => storage.get(storage.getPluginKey(resourceName, "models", modelName, `v${v}`)));
         if (ok && versionData) {
-          const metrics = versionData.metrics ? JSON.parse(versionData.metrics) : {};
           versions.push({
             version: v,
             savedAt: versionData.savedAt,
             isCurrent: v === versionInfo.currentVersion,
-            metrics
+            metrics: versionData.metrics
           });
         }
       }
@@ -16169,12 +16346,16 @@ class MLPlugin extends Plugin {
     }
     try {
       const storage = this.getStorage();
-      const [ok, err, versionData] = await tryFn(() => storage.get(`model_${modelName}_v${version}`));
+      const modelConfig = this.config.models[modelName];
+      const resourceName = modelConfig.resource;
+      const [ok, err, versionData] = await tryFn(() => storage.get(storage.getPluginKey(resourceName, "models", modelName, `v${version}`)));
       if (!ok || !versionData) {
         throw new MLError(`Version ${version} not found for model "${modelName}"`, { modelName, version });
       }
-      const modelData = JSON.parse(versionData.data);
-      await this.models[modelName].import(modelData);
+      if (!versionData.modelData) {
+        throw new MLError(`Model data not found in version ${version}`, { modelName, version });
+      }
+      await this.models[modelName].import(versionData.modelData);
       const versionInfo = this.modelVersions.get(modelName);
       if (versionInfo) {
         versionInfo.currentVersion = version;
@@ -16202,10 +16383,12 @@ class MLPlugin extends Plugin {
     if (!this.config.enableVersioning) {
       throw new MLError("Versioning is not enabled", { modelName });
     }
+    const modelConfig = this.config.models[modelName];
+    const resourceName = modelConfig.resource;
     await this.loadModelVersion(modelName, version);
     await this._updateVersionInfo(modelName, version);
     const storage = this.getStorage();
-    await storage.patch(`model_${modelName}_active`, {
+    await storage.set(storage.getPluginKey(resourceName, "metadata", modelName, "active"), {
       modelName,
       version,
       type: "reference",
@@ -16227,7 +16410,9 @@ class MLPlugin extends Plugin {
     }
     try {
       const storage = this.getStorage();
-      const [ok, err, historyData] = await tryFn(() => storage.get(`training_history_${modelName}`));
+      const modelConfig = this.config.models[modelName];
+      const resourceName = modelConfig.resource;
+      const [ok, err, historyData] = await tryFn(() => storage.get(storage.getPluginKey(resourceName, "training", "history", modelName)));
       if (!ok || !historyData) {
         return null;
       }
@@ -16256,8 +16441,10 @@ class MLPlugin extends Plugin {
     }
     try {
       const storage = this.getStorage();
-      const [ok1, err1, v1Data] = await tryFn(() => storage.get(`model_${modelName}_v${version1}`));
-      const [ok2, err2, v2Data] = await tryFn(() => storage.get(`model_${modelName}_v${version2}`));
+      const modelConfig = this.config.models[modelName];
+      const resourceName = modelConfig.resource;
+      const [ok1, err1, v1Data] = await tryFn(() => storage.get(storage.getPluginKey(resourceName, "models", modelName, `v${version1}`)));
+      const [ok2, err2, v2Data] = await tryFn(() => storage.get(storage.getPluginKey(resourceName, "models", modelName, `v${version2}`)));
       if (!ok1 || !v1Data) {
         throw new MLError(`Version ${version1} not found`, { modelName, version: version1 });
       }
@@ -16713,7 +16900,7 @@ class RelationPlugin extends Plugin {
     if (this.verbose) {
       console.log(`[RelationPlugin] Installed with ${Object.keys(this.relations).length} resources`);
     }
-    this.emit("installed", {
+    this.emit("db:plugin:installed", {
       plugin: "RelationPlugin",
       resources: Object.keys(this.relations)
     });
@@ -20288,7 +20475,7 @@ class S3Client extends EventEmitter {
     return client;
   }
   async sendCommand(command) {
-    this.emit("command.request", command.constructor.name, command.input);
+    this.emit("cl:request", command.constructor.name, command.input);
     const [ok, err, response] = await tryFn(() => this.client.send(command));
     if (!ok) {
       const bucket = this.config.bucket;
@@ -20300,7 +20487,7 @@ class S3Client extends EventEmitter {
         commandInput: command.input
       });
     }
-    this.emit("command.response", command.constructor.name, response, command.input);
+    this.emit("cl:response", command.constructor.name, response, command.input);
     return response;
   }
   async putObject({ key, metadata, contentType, body, contentEncoding, contentLength, ifMatch }) {
@@ -20325,7 +20512,7 @@ class S3Client extends EventEmitter {
     if (contentLength !== void 0) options.ContentLength = contentLength;
     if (ifMatch !== void 0) options.IfMatch = ifMatch;
     const [ok, err, response] = await tryFn(() => this.sendCommand(new clientS3.PutObjectCommand(options)));
-    this.emit("putObject", err || response, { key, metadata, contentType, body, contentEncoding, contentLength });
+    this.emit("cl:PutObject", err || response, { key, metadata, contentType, body, contentEncoding, contentLength });
     if (!ok) {
       throw mapAwsError(err, {
         bucket: this.config.bucket,
@@ -20353,7 +20540,7 @@ class S3Client extends EventEmitter {
       }
       return res;
     });
-    this.emit("getObject", err || response, { key });
+    this.emit("cl:GetObject", err || response, { key });
     if (!ok) {
       throw mapAwsError(err, {
         bucket: this.config.bucket,
@@ -20381,7 +20568,7 @@ class S3Client extends EventEmitter {
       }
       return res;
     });
-    this.emit("headObject", err || response, { key });
+    this.emit("cl:HeadObject", err || response, { key });
     if (!ok) {
       throw mapAwsError(err, {
         bucket: this.config.bucket,
@@ -20414,7 +20601,7 @@ class S3Client extends EventEmitter {
       options.ContentType = contentType;
     }
     const [ok, err, response] = await tryFn(() => this.sendCommand(new clientS3.CopyObjectCommand(options)));
-    this.emit("copyObject", err || response, { from, to, metadataDirective });
+    this.emit("cl:CopyObject", err || response, { from, to, metadataDirective });
     if (!ok) {
       throw mapAwsError(err, {
         bucket: this.config.bucket,
@@ -20439,7 +20626,7 @@ class S3Client extends EventEmitter {
       Key: keyPrefix ? path$1.join(keyPrefix, key) : key
     };
     const [ok, err, response] = await tryFn(() => this.sendCommand(new clientS3.DeleteObjectCommand(options)));
-    this.emit("deleteObject", err || response, { key });
+    this.emit("cl:DeleteObject", err || response, { key });
     if (!ok) {
       throw mapAwsError(err, {
         bucket: this.config.bucket,
@@ -20479,7 +20666,7 @@ class S3Client extends EventEmitter {
       deleted: results,
       notFound: errors
     };
-    this.emit("deleteObjects", report, keys);
+    this.emit("cl:DeleteObjects", report, keys);
     return report;
   }
   /**
@@ -20509,7 +20696,7 @@ class S3Client extends EventEmitter {
         const deleteResponse = await this.client.send(deleteCommand);
         const deletedCount = deleteResponse.Deleted ? deleteResponse.Deleted.length : 0;
         totalDeleted += deletedCount;
-        this.emit("deleteAll", {
+        this.emit("cl:DeleteAll", {
           prefix,
           batch: deletedCount,
           total: totalDeleted
@@ -20517,7 +20704,7 @@ class S3Client extends EventEmitter {
       }
       continuationToken = listResponse.IsTruncated ? listResponse.NextContinuationToken : void 0;
     } while (continuationToken);
-    this.emit("deleteAllComplete", {
+    this.emit("cl:DeleteAllComplete", {
       prefix,
       totalDeleted
     });
@@ -20548,7 +20735,7 @@ class S3Client extends EventEmitter {
     if (!ok) {
       throw new UnknownError("Unknown error in listObjects", { prefix, bucket: this.config.bucket, original: err });
     }
-    this.emit("listObjects", response, options);
+    this.emit("cl:ListObjects", response, options);
     return response;
   }
   async count({ prefix } = {}) {
@@ -20565,7 +20752,7 @@ class S3Client extends EventEmitter {
       truncated = response.IsTruncated || false;
       continuationToken = response.NextContinuationToken;
     }
-    this.emit("count", count, { prefix });
+    this.emit("cl:Count", count, { prefix });
     return count;
   }
   async getAllKeys({ prefix } = {}) {
@@ -20587,7 +20774,7 @@ class S3Client extends EventEmitter {
     if (this.config.keyPrefix) {
       keys = keys.map((x) => x.replace(this.config.keyPrefix, "")).map((x) => x.startsWith("/") ? x.replace(`/`, "") : x);
     }
-    this.emit("getAllKeys", keys, { prefix });
+    this.emit("cl:GetAllKeys", keys, { prefix });
     return keys;
   }
   async getContinuationTokenAfterOffset(params = {}) {
@@ -20616,7 +20803,7 @@ class S3Client extends EventEmitter {
         break;
       }
     }
-    this.emit("getContinuationTokenAfterOffset", continuationToken || null, params);
+    this.emit("cl:GetContinuationTokenAfterOffset", continuationToken || null, params);
     return continuationToken || null;
   }
   async getKeysPage(params = {}) {
@@ -20634,7 +20821,7 @@ class S3Client extends EventEmitter {
         offset
       });
       if (!continuationToken) {
-        this.emit("getKeysPage", [], params);
+        this.emit("cl:GetKeysPage", [], params);
         return [];
       }
     }
@@ -20657,7 +20844,7 @@ class S3Client extends EventEmitter {
     if (this.config.keyPrefix) {
       keys = keys.map((x) => x.replace(this.config.keyPrefix, "")).map((x) => x.startsWith("/") ? x.replace(`/`, "") : x);
     }
-    this.emit("getKeysPage", keys, params);
+    this.emit("cl:GetKeysPage", keys, params);
     return keys;
   }
   async moveAllObjects({ prefixFrom, prefixTo }) {
@@ -20675,7 +20862,7 @@ class S3Client extends EventEmitter {
       }
       return to;
     });
-    this.emit("moveAllObjects", { results, errors }, { prefixFrom, prefixTo });
+    this.emit("cl:MoveAllObjects", { results, errors }, { prefixFrom, prefixTo });
     if (errors.length > 0) {
       throw new UnknownError("Some objects could not be moved", {
         bucket: this.config.bucket,
@@ -23530,6 +23717,20 @@ ${errorDetails}`,
     if (typeof body === "object") return Buffer.byteLength(JSON.stringify(body), "utf8");
     return Buffer.byteLength(String(body), "utf8");
   }
+  /**
+   * Emit standardized events with optional ID-specific variant
+   *
+   * @private
+   * @param {string} event - Event name
+   * @param {Object} payload - Event payload
+   * @param {string} [id] - Optional ID for ID-specific events
+   */
+  _emitStandardized(event, payload, id = null) {
+    this.emit(event, payload);
+    if (id) {
+      this.emit(`${event}:${id}`, payload);
+    }
+  }
   /**
    * Insert a new resource object
    * @param {Object} attributes - Resource attributes
@@ -23670,11 +23871,11 @@ ${errorDetails}`,
       for (const hook of nonPartitionHooks) {
         finalResult = await hook(finalResult);
       }
-      this.emit("insert", finalResult);
+      this._emitStandardized("inserted", finalResult, finalResult?.id || insertedObject?.id);
       return finalResult;
     } else {
       const finalResult = await this.executeHooks("afterInsert", insertedObject);
-      this.emit("insert", finalResult);
+      this._emitStandardized("inserted", finalResult, finalResult?.id || insertedObject?.id);
       return finalResult;
     }
   }
@@ -23738,7 +23939,7 @@ ${errorDetails}`,
       data = await this.applyVersionMapping(data, objectVersion, this.version);
     }
     data = await this.executeHooks("afterGet", data);
-    this.emit("get", data);
+    this._emitStandardized("get", "fetched", data, data.id);
     const value = data;
     return value;
   }
@@ -23989,19 +24190,19 @@ ${errorDetails}`,
       for (const hook of nonPartitionHooks) {
         finalResult = await hook(finalResult);
       }
-      this.emit("update", {
+      this._emitStandardized("updated", {
         ...updatedData,
         $before: { ...originalData },
         $after: { ...finalResult }
-      });
+      }, updatedData.id);
       return finalResult;
     } else {
       const finalResult = await this.executeHooks("afterUpdate", updatedData);
-      this.emit("update", {
+      this._emitStandardized("updated", {
         ...updatedData,
         $before: { ...originalData },
         $after: { ...finalResult }
-      });
+      }, updatedData.id);
       return finalResult;
     }
   }
@@ -24400,11 +24601,11 @@ ${errorDetails}`,
       for (const hook of nonPartitionHooks) {
         finalResult = await hook(finalResult);
       }
-      this.emit("update", {
+      this._emitStandardized("updated", {
         ...updatedData,
         $before: { ...originalData },
         $after: { ...finalResult }
-      });
+      }, updatedData.id);
       return {
         success: true,
         data: finalResult,
@@ -24413,11 +24614,11 @@ ${errorDetails}`,
     } else {
       await this.handlePartitionReferenceUpdates(oldData, newData);
       const finalResult = await this.executeHooks("afterUpdate", updatedData);
-      this.emit("update", {
+      this._emitStandardized("updated", {
         ...updatedData,
         $before: { ...originalData },
         $after: { ...finalResult }
-      });
+      }, updatedData.id);
       return {
         success: true,
         data: finalResult,
@@ -24448,11 +24649,11 @@ ${errorDetails}`,
     await this.executeHooks("beforeDelete", objectData);
     const key = this.getResourceKey(id);
     const [ok2, err2, response] = await tryFn(() => this.client.deleteObject(key));
-    this.emit("delete", {
+    this._emitStandardized("delete", "deleted", {
       ...objectData,
       $before: { ...objectData },
       $after: null
-    });
+    }, id);
     if (deleteError) {
       throw mapAwsError(deleteError, {
         bucket: this.client.config.bucket,
@@ -24576,7 +24777,7 @@ ${errorDetails}`,
     }
     const count = await this.client.count({ prefix });
     await this.executeHooks("afterCount", { count, partition, partitionValues });
-    this.emit("count", count);
+    this._emitStandardized("count", "counted", count);
     return count;
   }
   /**
@@ -24599,7 +24800,7 @@ ${errorDetails}`,
       const result = await this.insert(attributes);
       return result;
     });
-    this.emit("insertMany", objects.length);
+    this._emitStandardized("insertMany", "inserted-many", objects.length);
     return results;
   }
   /**
@@ -24634,7 +24835,7 @@ ${errorDetails}`,
       return response;
     });
     await this.executeHooks("afterDeleteMany", { ids, results });
-    this.emit("deleteMany", ids.length);
+    this._emitStandardized("deleteMany", "deleted-many", ids.length);
     return results;
   }
   async deleteAll() {
@@ -24643,7 +24844,7 @@ ${errorDetails}`,
     }
     const prefix = `resource=${this.name}/data`;
     const deletedCount = await this.client.deleteAll({ prefix });
-    this.emit("deleteAll", {
+    this._emitStandardized("deleteAll", "deleted-all", {
       version: this.version,
       prefix,
       deletedCount
@@ -24660,7 +24861,7 @@ ${errorDetails}`,
     }
     const prefix = `resource=${this.name}`;
     const deletedCount = await this.client.deleteAll({ prefix });
-    this.emit("deleteAllData", {
+    this._emitStandardized("deleteAllData", "deleted-all-data", {
       resource: this.name,
       prefix,
       deletedCount
@@ -24730,7 +24931,7 @@ ${errorDetails}`,
       const idPart = parts.find((part) => part.startsWith("id="));
       return idPart ? idPart.replace("id=", "") : null;
     }).filter(Boolean);
-    this.emit("listIds", ids.length);
+    this._emitStandardized("listIds", "listed-ids", ids.length);
     return ids;
   }
   /**
@@ -24772,12 +24973,12 @@ ${errorDetails}`,
     const [ok, err, ids] = await tryFn(() => this.listIds({ limit, offset }));
     if (!ok) throw err;
     const results = await this.processListResults(ids, "main");
-    this.emit("list", { count: results.length, errors: 0 });
+    this._emitStandardized("list", "listed", { count: results.length, errors: 0 });
     return results;
   }
   async listPartition({ partition, partitionValues, limit, offset = 0 }) {
     if (!this.config.partitions?.[partition]) {
-      this.emit("list", { partition, partitionValues, count: 0, errors: 0 });
+      this._emitStandardized("list", "listed", { partition, partitionValues, count: 0, errors: 0 });
       return [];
     }
     const partitionDef = this.config.partitions[partition];
@@ -24787,7 +24988,7 @@ ${errorDetails}`,
     const ids = this.extractIdsFromKeys(keys).slice(offset);
     const filteredIds = limit ? ids.slice(0, limit) : ids;
     const results = await this.processPartitionResults(filteredIds, partition, partitionDef, keys);
-    this.emit("list", { partition, partitionValues, count: results.length, errors: 0 });
+    this._emitStandardized("list", "listed", { partition, partitionValues, count: results.length, errors: 0 });
     return results;
   }
   /**
@@ -24832,7 +25033,7 @@ ${errorDetails}`,
       }
       return this.handleResourceError(err, id, context);
     });
-    this.emit("list", { count: results.length, errors: 0 });
+    this._emitStandardized("list", "listed", { count: results.length, errors: 0 });
     return results;
   }
   /**
@@ -24895,10 +25096,10 @@ ${errorDetails}`,
    */
   handleListError(error, { partition, partitionValues }) {
     if (error.message.includes("Partition '") && error.message.includes("' not found")) {
-      this.emit("list", { partition, partitionValues, count: 0, errors: 1 });
+      this._emitStandardized("list", "listed", { partition, partitionValues, count: 0, errors: 1 });
       return [];
     }
-    this.emit("list", { partition, partitionValues, count: 0, errors: 1 });
+    this._emitStandardized("list", "listed", { partition, partitionValues, count: 0, errors: 1 });
     return [];
   }
   /**
@@ -24931,7 +25132,7 @@ ${errorDetails}`,
       throw err;
     });
     const finalResults = await this.executeHooks("afterGetMany", results);
-    this.emit("getMany", ids.length);
+    this._emitStandardized("getMany", "fetched-many", ids.length);
     return finalResults;
   }
   /**
@@ -25017,7 +25218,7 @@ ${errorDetails}`,
           hasTotalItems: totalItems !== null
         }
       };
-      this.emit("page", result2);
+      this._emitStandardized("page", "paginated", result2);
       return result2;
     });
     if (ok) return result;
@@ -25087,7 +25288,7 @@ ${errorDetails}`,
       contentType
     }));
     if (!ok2) throw err2;
-    this.emit("setContent", { id, contentType, contentLength: buffer.length });
+    this._emitStandardized("setContent", "content-set", { id, contentType, contentLength: buffer.length }, id);
     return updatedData;
   }
   /**
@@ -25116,7 +25317,7 @@ ${errorDetails}`,
     }
     const buffer = Buffer.from(await response.Body.transformToByteArray());
     const contentType = response.ContentType || null;
-    this.emit("content", id, buffer.length, contentType);
+    this._emitStandardized("content", "content-fetched", { id, contentLength: buffer.length, contentType }, id);
     return {
       buffer,
       contentType
@@ -25148,7 +25349,7 @@ ${errorDetails}`,
       metadata: existingMetadata
     }));
     if (!ok2) throw err2;
-    this.emit("deleteContent", id);
+    this._emitStandardized("deleteContent", "content-deleted", id, id);
     return response;
   }
   /**
@@ -25460,7 +25661,7 @@ ${errorDetails}`,
     const data = await this.get(id);
     data._partition = partitionName;
     data._partitionValues = partitionValues;
-    this.emit("getFromPartition", data);
+    this._emitStandardized("getFromPartition", "partition-fetched", data, data.id);
     return data;
   }
   /**
@@ -25709,6 +25910,123 @@ ${errorDetails}`,
     }
     return out;
   }
+  // ============================================================================
+  // STATE MACHINE METHODS
+  // ============================================================================
+  /**
+   * Send an event to trigger a state transition
+   * @param {string} id - Entity ID
+   * @param {string} event - Event name
+   * @param {Object} [eventData] - Event data
+   * @returns {Promise<Object>} Transition result
+   * @throws {Error} If no state machine is configured for this resource
+   * @example
+   * await orders.state('order-123', 'CONFIRM', { confirmedBy: 'user-456' });
+   */
+  async state(id, event, eventData) {
+    if (!this._stateMachine) {
+      throw new Error(
+        `No state machine configured for resource '${this.name}'. Ensure StateMachinePlugin is installed and configured for this resource.`
+      );
+    }
+    return this._stateMachine.send(id, event, eventData);
+  }
+  /**
+   * Get current state of an entity
+   * @param {string} id - Entity ID
+   * @returns {Promise<string>} Current state
+   * @throws {Error} If no state machine is configured for this resource
+   * @example
+   * const currentState = await orders.getState('order-123');
+   */
+  async getState(id) {
+    if (!this._stateMachine) {
+      throw new Error(
+        `No state machine configured for resource '${this.name}'. Ensure StateMachinePlugin is installed and configured for this resource.`
+      );
+    }
+    return this._stateMachine.getState(id);
+  }
+  /**
+   * Check if a transition is valid
+   * @param {string} id - Entity ID
+   * @param {string} event - Event name
+   * @returns {Promise<boolean>} True if transition is valid
+   * @throws {Error} If no state machine is configured for this resource
+   * @example
+   * const canConfirm = await orders.canTransition('order-123', 'CONFIRM');
+   */
+  async canTransition(id, event) {
+    if (!this._stateMachine) {
+      throw new Error(
+        `No state machine configured for resource '${this.name}'. Ensure StateMachinePlugin is installed and configured for this resource.`
+      );
+    }
+    return this._stateMachine.canTransition(id, event);
+  }
+  /**
+   * Get all valid events for the current state
+   * @param {string} id - Entity ID
+   * @returns {Promise<Array<string>>} Array of valid event names
+   * @throws {Error} If no state machine is configured for this resource
+   * @example
+   * const events = await orders.getValidEvents('order-123');
+   * // Returns: ['SHIP', 'CANCEL']
+   */
+  async getValidEvents(id) {
+    if (!this._stateMachine) {
+      throw new Error(
+        `No state machine configured for resource '${this.name}'. Ensure StateMachinePlugin is installed and configured for this resource.`
+      );
+    }
+    return this._stateMachine.getValidEvents(id);
+  }
+  /**
+   * Initialize entity with initial state
+   * @param {string} id - Entity ID
+   * @param {Object} [context] - Initial context data
+   * @returns {Promise<void>}
+   * @throws {Error} If no state machine is configured for this resource
+   * @example
+   * await orders.initializeState('order-456', { customerId: 'user-123' });
+   */
+  async initializeState(id, context) {
+    if (!this._stateMachine) {
+      throw new Error(
+        `No state machine configured for resource '${this.name}'. Ensure StateMachinePlugin is installed and configured for this resource.`
+      );
+    }
+    return this._stateMachine.initializeEntity(id, context);
+  }
+  /**
+   * Get transition history for an entity
+   * @param {string} id - Entity ID
+   * @param {Object} [options] - Query options
+   * @param {number} [options.limit=100] - Maximum number of transitions
+   * @param {Date} [options.fromDate] - Filter from date
+   * @param {Date} [options.toDate] - Filter to date
+   * @returns {Promise<Array<Object>>} Transition history
+   * @throws {Error} If no state machine is configured for this resource
+   * @example
+   * const history = await orders.getStateHistory('order-123', { limit: 50 });
+   */
+  async getStateHistory(id, options) {
+    if (!this._stateMachine) {
+      throw new Error(
+        `No state machine configured for resource '${this.name}'. Ensure StateMachinePlugin is installed and configured for this resource.`
+      );
+    }
+    return this._stateMachine.getTransitionHistory(id, options);
+  }
+  /**
+   * Internal method to attach state machine instance
+   * This is called by StateMachinePlugin during initialization
+   * @private
+   * @param {Object} stateMachine - State machine instance
+   */
+  _attachStateMachine(stateMachine) {
+    this._stateMachine = stateMachine;
+  }
 }
 function validateResourceConfig(config) {
   const errors = [];
@@ -25869,7 +26187,7 @@ class Database extends EventEmitter {
     })();
     this.version = "1";
     this.s3dbVersion = (() => {
-      const [ok, err, version] = tryFn(() => true ? "13.1.0" : "latest");
+      const [ok, err, version] = tryFn(() => true ? "13.2.2" : "latest");
       return ok ? version : "latest";
     })();
     this._resourcesMap = {};
@@ -26039,12 +26357,12 @@ class Database extends EventEmitter {
       }
     }
     if (definitionChanges.length > 0) {
-      this.emit("resourceDefinitionsChanged", {
+      this.emit("db:resource-definitions-changed", {
         changes: definitionChanges,
         metadata: this.savedMetadata
       });
     }
-    this.emit("connected", /* @__PURE__ */ new Date());
+    this.emit("db:connected", /* @__PURE__ */ new Date());
   }
   /**
    * Detect changes in resource definitions compared to saved metadata
@@ -26258,7 +26576,7 @@ class Database extends EventEmitter {
     if (index > -1) {
       this.pluginList.splice(index, 1);
     }
-    this.emit("plugin.uninstalled", { name: pluginName, plugin });
+    this.emit("db:plugin:uninstalled", { name: pluginName, plugin });
   }
   async uploadMetadataFile() {
     const metadata = {
@@ -26317,7 +26635,7 @@ class Database extends EventEmitter {
       contentType: "application/json"
     });
     this.savedMetadata = metadata;
-    this.emit("metadataUploaded", metadata);
+    this.emit("db:metadata-uploaded", metadata);
   }
   blankMetadataStructure() {
     return {
@@ -26574,7 +26892,7 @@ class Database extends EventEmitter {
         body: JSON.stringify(metadata, null, 2),
         contentType: "application/json"
       });
-      this.emit("metadataHealed", { healingLog, metadata });
+      this.emit("db:metadata-healed", { healingLog, metadata });
       if (this.verbose) {
         console.warn("S3DB: Successfully uploaded healed metadata");
       }
@@ -26714,7 +27032,7 @@ class Database extends EventEmitter {
       if (!existingVersionData || existingVersionData.hash !== newHash) {
         await this.uploadMetadataFile();
       }
-      this.emit("s3db.resourceUpdated", name);
+      this.emit("db:resource:updated", name);
       return existingResource;
     }
     const existingMetadata = this.savedMetadata?.resources?.[name];
@@ -26751,7 +27069,7 @@ class Database extends EventEmitter {
       this._applyMiddlewares(resource, middlewares);
     }
     await this.uploadMetadataFile();
-    this.emit("s3db.resourceCreated", name);
+    this.emit("db:resource:created", name);
     return resource;
   }
   /**
@@ -26915,7 +27233,7 @@ class Database extends EventEmitter {
       if (this.client && typeof this.client.removeAllListeners === "function") {
         this.client.removeAllListeners();
       }
-      await this.emit("disconnected", /* @__PURE__ */ new Date());
+      await this.emit("db:disconnected", /* @__PURE__ */ new Date());
       this.removeAllListeners();
       if (this._exitListener && typeof process !== "undefined") {
         process.off("exit", this._exitListener);
@@ -27027,7 +27345,7 @@ class Database extends EventEmitter {
     for (const hook of hooks) {
       const [ok, error] = await tryFn(() => hook({ database: this, ...context }));
       if (!ok) {
-        this.emit("hookError", { event, error, context });
+        this.emit("db:hook-error", { event, error, context });
         if (this.strictHooks) {
           throw new DatabaseError(`Hook execution failed for event '${event}': ${error.message}`, {
             event,
@@ -28603,7 +28921,7 @@ class ReplicatorPlugin extends Plugin {
         if (this.config.verbose) {
           console.warn(`[ReplicatorPlugin] Insert event failed for resource ${resource.name}: ${error.message}`);
         }
-        this.emit("error", { operation: "insert", error: error.message, resource: resource.name });
+        this.emit("plg:replicator:error", { operation: "insert", error: error.message, resource: resource.name });
       }
     };
     const updateHandler = async (data, beforeData) => {
@@ -28616,7 +28934,7 @@ class ReplicatorPlugin extends Plugin {
         if (this.config.verbose) {
           console.warn(`[ReplicatorPlugin] Update event failed for resource ${resource.name}: ${error.message}`);
         }
-        this.emit("error", { operation: "update", error: error.message, resource: resource.name });
+        this.emit("plg:replicator:error", { operation: "update", error: error.message, resource: resource.name });
       }
     };
     const deleteHandler = async (data) => {
@@ -28627,7 +28945,7 @@ class ReplicatorPlugin extends Plugin {
         if (this.config.verbose) {
           console.warn(`[ReplicatorPlugin] Delete event failed for resource ${resource.name}: ${error.message}`);
         }
-        this.emit("error", { operation: "delete", error: error.message, resource: resource.name });
+        this.emit("plg:replicator:error", { operation: "delete", error: error.message, resource: resource.name });
       }
     };
     this.eventHandlers.set(resource.name, {
@@ -28748,7 +29066,7 @@ class ReplicatorPlugin extends Plugin {
       if (this.config.verbose) {
         console.warn(`[ReplicatorPlugin] Failed to log error for ${resourceName}: ${logError.message}`);
       }
-      this.emit("replicator_log_error", {
+      this.emit("plg:replicator:log-error", {
         replicator: replicator.name || replicator.id,
         resourceName,
         operation,
@@ -28773,7 +29091,7 @@ class ReplicatorPlugin extends Plugin {
           () => replicator.replicate(resourceName, operation, data, recordId, beforeData),
           this.config.maxRetries
         );
-        this.emit("replicated", {
+        this.emit("plg:replicator:replicated", {
           replicator: replicator.name || replicator.id,
           resourceName,
           operation,
@@ -28789,7 +29107,7 @@ class ReplicatorPlugin extends Plugin {
         if (this.config.verbose) {
           console.warn(`[ReplicatorPlugin] Replication failed for ${replicator.name || replicator.id} on ${resourceName}: ${error.message}`);
         }
-        this.emit("replicator_error", {
+        this.emit("plg:replicator:error", {
           replicator: replicator.name || replicator.id,
           resourceName,
           operation,
@@ -28821,7 +29139,7 @@ class ReplicatorPlugin extends Plugin {
           if (this.config.verbose) {
             console.warn(`[ReplicatorPlugin] Replicator item processing failed for ${replicator.name || replicator.id} on ${item.resourceName}: ${err.message}`);
           }
-          this.emit("replicator_error", {
+          this.emit("plg:replicator:error", {
             replicator: replicator.name || replicator.id,
             resourceName: item.resourceName,
             operation: item.operation,
@@ -28833,7 +29151,7 @@ class ReplicatorPlugin extends Plugin {
           }
           return { success: false, error: err.message };
         }
-        this.emit("replicated", {
+        this.emit("plg:replicator:replicated", {
           replicator: replicator.name || replicator.id,
           resourceName: item.resourceName,
           operation: item.operation,
@@ -28849,7 +29167,7 @@ class ReplicatorPlugin extends Plugin {
         if (this.config.verbose) {
           console.warn(`[ReplicatorPlugin] Wrapper processing failed for ${replicator.name || replicator.id} on ${item.resourceName}: ${wrapperError.message}`);
         }
-        this.emit("replicator_error", {
+        this.emit("plg:replicator:error", {
           replicator: replicator.name || replicator.id,
           resourceName: item.resourceName,
           operation: item.operation,
@@ -28867,7 +29185,7 @@ class ReplicatorPlugin extends Plugin {
   async logReplicator(item) {
     const logRes = this.replicatorLog || this.database.resources[normalizeResourceName(this.config.replicatorLogResource)];
     if (!logRes) {
-      this.emit("replicator.log.failed", { error: "replicator log resource not found", item });
+      this.emit("plg:replicator:log-failed", { error: "replicator log resource not found", item });
       return;
     }
     const logItem = {
@@ -28885,7 +29203,7 @@ class ReplicatorPlugin extends Plugin {
       if (this.config.verbose) {
         console.warn(`[ReplicatorPlugin] Failed to log replicator item: ${err.message}`);
       }
-      this.emit("replicator.log.failed", { error: err, item });
+      this.emit("plg:replicator:log-failed", { error: err, item });
     }
   }
   async updateReplicatorLog(logId, updates) {
@@ -28897,7 +29215,7 @@ class ReplicatorPlugin extends Plugin {
       });
     });
     if (!ok) {
-      this.emit("replicator.updateLog.failed", { error: err.message, logId, updates });
+      this.emit("plg:replicator:update-log-failed", { error: err.message, logId, updates });
     }
   }
   // Utility methods
@@ -28981,7 +29299,7 @@ class ReplicatorPlugin extends Plugin {
     for (const resourceName in this.database.resources) {
       if (normalizeResourceName(resourceName) === normalizeResourceName("plg_replicator_logs")) continue;
       if (replicator.shouldReplicateResource(resourceName)) {
-        this.emit("replicator.sync.resource", { resourceName, replicatorId });
+        this.emit("plg:replicator:sync-resource", { resourceName, replicatorId });
         const resource = this.database.resources[resourceName];
         let offset = 0;
         const pageSize = this.config.batchSize || 100;
@@ -28997,7 +29315,7 @@ class ReplicatorPlugin extends Plugin {
         }
       }
     }
-    this.emit("replicator.sync.completed", { replicatorId, stats: this.stats });
+    this.emit("plg:replicator:sync-completed", { replicatorId, stats: this.stats });
   }
   async stop() {
     const [ok, error] = await tryFn(async () => {
@@ -29012,7 +29330,7 @@ class ReplicatorPlugin extends Plugin {
             if (this.config.verbose) {
               console.warn(`[ReplicatorPlugin] Failed to stop replicator ${replicator.name || replicator.id}: ${replicatorError.message}`);
             }
-            this.emit("replicator_stop_error", {
+            this.emit("plg:replicator:stop-error", {
               replicator: replicator.name || replicator.id || "unknown",
               driver: replicator.driver || "unknown",
               error: replicatorError.message
@@ -29043,7 +29361,7 @@ class ReplicatorPlugin extends Plugin {
       if (this.config.verbose) {
         console.warn(`[ReplicatorPlugin] Failed to stop plugin: ${error.message}`);
       }
-      this.emit("replicator_plugin_stop_error", {
+      this.emit("plg:replicator:plugin-stop-error", {
         error: error.message
       });
     }
@@ -29200,7 +29518,7 @@ class S3QueuePlugin extends Plugin {
     if (this.config.verbose) {
       console.log(`[S3QueuePlugin] Started ${concurrency} workers`);
     }
-    this.emit("workers.started", { concurrency, workerId: this.workerId });
+    this.emit("plg:s3-queue:workers-started", { concurrency, workerId: this.workerId });
   }
   async stopProcessing() {
     if (!this.isRunning) return;
@@ -29215,7 +29533,7 @@ class S3QueuePlugin extends Plugin {
     if (this.config.verbose) {
       console.log("[S3QueuePlugin] Stopped all workers");
     }
-    this.emit("workers.stopped", { workerId: this.workerId });
+    this.emit("plg:s3-queue:workers-stopped", { workerId: this.workerId });
   }
   createWorker(handler, workerIndex) {
     return (async () => {
@@ -29383,7 +29701,7 @@ class S3QueuePlugin extends Plugin {
       });
       await this.completeMessage(message.queueId, result);
       const duration = Date.now() - startTime;
-      this.emit("message.completed", {
+      this.emit("plg:s3-queue:message-completed", {
         queueId: message.queueId,
         originalId: message.record.id,
         duration,
@@ -29396,7 +29714,7 @@ class S3QueuePlugin extends Plugin {
       const shouldRetry = message.attempts < message.maxAttempts;
       if (shouldRetry) {
         await this.retryMessage(message.queueId, message.attempts, error.message);
-        this.emit("message.retry", {
+        this.emit("plg:s3-queue:message-retry", {
           queueId: message.queueId,
           originalId: message.record.id,
           attempts: message.attempts,
@@ -29404,7 +29722,7 @@ class S3QueuePlugin extends Plugin {
         });
       } else {
         await this.moveToDeadLetter(message.queueId, message.record, error.message);
-        this.emit("message.dead", {
+        this.emit("plg:s3-queue:message-dead", {
           queueId: message.queueId,
           originalId: message.record.id,
           error: error.message
@@ -29636,7 +29954,7 @@ class SchedulerPlugin extends Plugin {
       });
     }
     await this._startScheduling();
-    this.emit("initialized", { jobs: this.jobs.size });
+    this.emit("db:plugin:initialized", { jobs: this.jobs.size });
   }
   async _createJobHistoryResource() {
     const [ok] = await tryFn(() => this.database.createResource({
@@ -29774,7 +30092,7 @@ class SchedulerPlugin extends Plugin {
       if (this.config.onJobStart) {
         await this._executeHook(this.config.onJobStart, jobName, context);
       }
-      this.emit("job_start", { jobName, executionId, startTime });
+      this.emit("plg:scheduler:job-start", { jobName, executionId, startTime });
       let attempt = 0;
       let lastError = null;
       let result = null;
@@ -29841,7 +30159,7 @@ class SchedulerPlugin extends Plugin {
       } else if (status !== "success" && this.config.onJobError) {
         await this._executeHook(this.config.onJobError, jobName, lastError, attempt);
       }
-      this.emit("job_complete", {
+      this.emit("plg:scheduler:job-complete", {
         jobName,
         executionId,
         status,
@@ -29927,7 +30245,7 @@ class SchedulerPlugin extends Plugin {
     }
     job.enabled = true;
     this._scheduleNextExecution(jobName);
-    this.emit("job_enabled", { jobName });
+    this.emit("plg:scheduler:job-enabled", { jobName });
   }
   /**
    * Disable a job
@@ -29948,7 +30266,7 @@ class SchedulerPlugin extends Plugin {
       clearTimeout(timer);
       this.timers.delete(jobName);
     }
-    this.emit("job_disabled", { jobName });
+    this.emit("plg:scheduler:job-disabled", { jobName });
   }
   /**
    * Get job status and statistics
@@ -30086,7 +30404,7 @@ class SchedulerPlugin extends Plugin {
     if (job.enabled) {
       this._scheduleNextExecution(jobName);
     }
-    this.emit("job_added", { jobName });
+    this.emit("plg:scheduler:job-added", { jobName });
   }
   /**
    * Remove a job
@@ -30109,7 +30427,7 @@ class SchedulerPlugin extends Plugin {
     this.jobs.delete(jobName);
     this.statistics.delete(jobName);
     this.activeJobs.delete(jobName);
-    this.emit("job_removed", { jobName });
+    this.emit("plg:scheduler:job-removed", { jobName });
   }
   /**
    * Get plugin instance by name (for job actions that need other plugins)
@@ -30150,9 +30468,14 @@ class SchedulerPlugin extends Plugin {
   }
 }
 
+var scheduler_plugin = /*#__PURE__*/Object.freeze({
+  __proto__: null,
+  SchedulerPlugin: SchedulerPlugin
+});
+
 class StateMachineError extends S3dbError {
   constructor(message, details = {}) {
-    const { currentState, targetState, resourceName, operation = "unknown", ...rest } = details;
+    const { currentState, targetState, resourceName, operation = "unknown", retriable, ...rest } = details;
     let description = details.description;
     if (!description) {
       description = `
@@ -30177,6 +30500,158 @@ Docs: https://github.com/forattini-dev/s3db.js/blob/main/docs/plugins/state-mach
 `.trim();
     }
     super(message, { ...rest, currentState, targetState, resourceName, operation, description });
+    if (retriable !== void 0) {
+      this.retriable = retriable;
+    }
+  }
+}
+
+const RETRIABLE = "RETRIABLE";
+const NON_RETRIABLE = "NON_RETRIABLE";
+const RETRIABLE_NETWORK_CODES = /* @__PURE__ */ new Set([
+  "ECONNREFUSED",
+  "ETIMEDOUT",
+  "ECONNRESET",
+  "EPIPE",
+  "ENOTFOUND",
+  "NetworkError",
+  "NETWORK_ERROR",
+  "TimeoutError",
+  "TIMEOUT"
+]);
+const RETRIABLE_AWS_CODES = /* @__PURE__ */ new Set([
+  "ThrottlingException",
+  "TooManyRequestsException",
+  "RequestLimitExceeded",
+  "ProvisionedThroughputExceededException",
+  "RequestThrottledException",
+  "SlowDown",
+  "ServiceUnavailable"
+]);
+const RETRIABLE_AWS_CONFLICTS = /* @__PURE__ */ new Set([
+  "ConditionalCheckFailedException",
+  "TransactionConflictException"
+]);
+const RETRIABLE_STATUS_CODES = /* @__PURE__ */ new Set([
+  429,
+  // Too Many Requests
+  500,
+  // Internal Server Error
+  502,
+  // Bad Gateway
+  503,
+  // Service Unavailable
+  504,
+  // Gateway Timeout
+  507,
+  // Insufficient Storage
+  509
+  // Bandwidth Limit Exceeded
+]);
+const NON_RETRIABLE_ERROR_NAMES = /* @__PURE__ */ new Set([
+  "ValidationError",
+  "StateMachineError",
+  "SchemaError",
+  "AuthenticationError",
+  "PermissionError",
+  "BusinessLogicError",
+  "InvalidStateTransition"
+]);
+const NON_RETRIABLE_STATUS_CODES = /* @__PURE__ */ new Set([
+  400,
+  // Bad Request
+  401,
+  // Unauthorized
+  403,
+  // Forbidden
+  404,
+  // Not Found
+  405,
+  // Method Not Allowed
+  406,
+  // Not Acceptable
+  409,
+  // Conflict
+  410,
+  // Gone
+  422
+  // Unprocessable Entity
+]);
+class ErrorClassifier {
+  /**
+   * Classify an error as RETRIABLE or NON_RETRIABLE
+   *
+   * @param {Error} error - The error to classify
+   * @param {Object} options - Classification options
+   * @param {Array<string>} options.retryableErrors - Custom retriable error names/codes
+   * @param {Array<string>} options.nonRetriableErrors - Custom non-retriable error names/codes
+   * @returns {string} 'RETRIABLE' or 'NON_RETRIABLE'
+   */
+  static classify(error, options = {}) {
+    if (!error) return NON_RETRIABLE;
+    const {
+      retryableErrors = [],
+      nonRetriableErrors = []
+    } = options;
+    if (retryableErrors.length > 0) {
+      const isCustomRetriable = retryableErrors.some(
+        (errType) => error.code === errType || error.name === errType || error.message?.includes(errType)
+      );
+      if (isCustomRetriable) return RETRIABLE;
+    }
+    if (nonRetriableErrors.length > 0) {
+      const isCustomNonRetriable = nonRetriableErrors.some(
+        (errType) => error.code === errType || error.name === errType || error.message?.includes(errType)
+      );
+      if (isCustomNonRetriable) return NON_RETRIABLE;
+    }
+    if (error.retriable === false) return NON_RETRIABLE;
+    if (error.retriable === true) return RETRIABLE;
+    if (NON_RETRIABLE_ERROR_NAMES.has(error.name)) {
+      return NON_RETRIABLE;
+    }
+    if (error.statusCode && NON_RETRIABLE_STATUS_CODES.has(error.statusCode)) {
+      return NON_RETRIABLE;
+    }
+    if (error.code && RETRIABLE_NETWORK_CODES.has(error.code)) {
+      return RETRIABLE;
+    }
+    if (error.code && RETRIABLE_AWS_CODES.has(error.code)) {
+      return RETRIABLE;
+    }
+    if (error.code && RETRIABLE_AWS_CONFLICTS.has(error.code)) {
+      return RETRIABLE;
+    }
+    if (error.statusCode && RETRIABLE_STATUS_CODES.has(error.statusCode)) {
+      return RETRIABLE;
+    }
+    if (error.message && typeof error.message === "string") {
+      const lowerMessage = error.message.toLowerCase();
+      if (lowerMessage.includes("timeout") || lowerMessage.includes("timed out") || lowerMessage.includes("network") || lowerMessage.includes("connection")) {
+        return RETRIABLE;
+      }
+    }
+    return RETRIABLE;
+  }
+  /**
+   * Check if an error is retriable
+   *
+   * @param {Error} error - The error to check
+   * @param {Object} options - Classification options
+   * @returns {boolean} true if retriable
+   */
+  static isRetriable(error, options = {}) {
+    return this.classify(error, options) === RETRIABLE;
+  }
+  /**
+   * Check if an error is non-retriable
+   *
+   * @param {Error} error - The error to check
+   * @param {Object} options - Classification options
+   * @returns {boolean} true if non-retriable
+   */
+  static isNonRetriable(error, options = {}) {
+    return this.classify(error, options) === NON_RETRIABLE;
   }
 }
 
@@ -30197,11 +30672,23 @@ class StateMachinePlugin extends Plugin {
       workerId: options.workerId || "default",
       lockTimeout: options.lockTimeout || 1e3,
       // Wait up to 1s for lock
-      lockTTL: options.lockTTL || 5
+      lockTTL: options.lockTTL || 5,
       // Lock expires after 5s (prevent deadlock)
+      // Global retry configuration for action execution
+      retryConfig: options.retryConfig || null,
+      // Trigger system configuration
+      enableScheduler: options.enableScheduler || false,
+      schedulerConfig: options.schedulerConfig || {},
+      enableDateTriggers: options.enableDateTriggers !== false,
+      enableFunctionTriggers: options.enableFunctionTriggers !== false,
+      enableEventTriggers: options.enableEventTriggers !== false,
+      triggerCheckInterval: options.triggerCheckInterval || 6e4
+      // Check triggers every 60s by default
     };
     this.database = null;
     this.machines = /* @__PURE__ */ new Map();
+    this.triggerIntervals = [];
+    this.schedulerPlugin = null;
     this._validateConfiguration();
   }
   _validateConfiguration() {
@@ -30250,7 +30737,9 @@ class StateMachinePlugin extends Plugin {
         // entityId -> currentState
       });
     }
-    this.emit("initialized", { machines: Array.from(this.machines.keys()) });
+    await this._attachStateMachinesToResources();
+    await this._setupTriggers();
+    this.emit("db:plugin:initialized", { machines: Array.from(this.machines.keys()) });
   }
   async _createStateResources() {
     const [logOk] = await tryFn(() => this.database.createResource({
@@ -30281,6 +30770,8 @@ class StateMachinePlugin extends Plugin {
         currentState: "string|required",
         context: "json|default:{}",
         lastTransition: "string|default:null",
+        triggerCounts: "json|default:{}",
+        // Track trigger execution counts
         updatedAt: "string|required"
       },
       behavior: "body-overflow"
@@ -30344,7 +30835,7 @@ class StateMachinePlugin extends Plugin {
       if (targetStateConfig && targetStateConfig.entry) {
         await this._executeAction(targetStateConfig.entry, context, event, machineId, entityId);
       }
-      this.emit("transition", {
+      this.emit("plg:state-machine:transition", {
         machineId,
         entityId,
         from: currentState,
@@ -30370,14 +30861,97 @@ class StateMachinePlugin extends Plugin {
       }
       return;
     }
-    const [ok, error] = await tryFn(
-      () => action(context, event, { database: this.database, machineId, entityId })
-    );
-    if (!ok) {
-      if (this.config.verbose) {
-        console.error(`[StateMachinePlugin] Action '${actionName}' failed:`, error.message);
+    const machine = this.machines.get(machineId);
+    const currentState = await this.getState(machineId, entityId);
+    const stateConfig = machine?.config?.states?.[currentState];
+    const retryConfig = {
+      ...this.config.retryConfig || {},
+      ...machine?.config?.retryConfig || {},
+      ...stateConfig?.retryConfig || {}
+    };
+    const maxAttempts = retryConfig.maxAttempts ?? 0;
+    const retryEnabled = maxAttempts > 0;
+    let attempt = 0;
+    while (attempt <= maxAttempts) {
+      try {
+        const result = await action(context, event, { database: this.database, machineId, entityId });
+        if (attempt > 0) {
+          this.emit("plg:state-machine:action-retry-success", {
+            machineId,
+            entityId,
+            action: actionName,
+            attempts: attempt + 1,
+            state: currentState
+          });
+          if (this.config.verbose) {
+            console.log(`[StateMachinePlugin] Action '${actionName}' succeeded after ${attempt + 1} attempts`);
+          }
+        }
+        return result;
+      } catch (error) {
+        if (!retryEnabled) {
+          if (this.config.verbose) {
+            console.error(`[StateMachinePlugin] Action '${actionName}' failed:`, error.message);
+          }
+          this.emit("plg:state-machine:action-error", { actionName, error: error.message, machineId, entityId });
+          return;
+        }
+        const classification = ErrorClassifier.classify(error, {
+          retryableErrors: retryConfig.retryableErrors,
+          nonRetriableErrors: retryConfig.nonRetriableErrors
+        });
+        if (classification === "NON_RETRIABLE") {
+          this.emit("plg:state-machine:action-error-non-retriable", {
+            machineId,
+            entityId,
+            action: actionName,
+            error: error.message,
+            state: currentState
+          });
+          if (this.config.verbose) {
+            console.error(`[StateMachinePlugin] Action '${actionName}' failed with non-retriable error:`, error.message);
+          }
+          throw error;
+        }
+        if (attempt >= maxAttempts) {
+          this.emit("plg:state-machine:action-retry-exhausted", {
+            machineId,
+            entityId,
+            action: actionName,
+            attempts: attempt + 1,
+            error: error.message,
+            state: currentState
+          });
+          if (this.config.verbose) {
+            console.error(`[StateMachinePlugin] Action '${actionName}' failed after ${attempt + 1} attempts:`, error.message);
+          }
+          throw error;
+        }
+        attempt++;
+        const delay = this._calculateBackoff(attempt, retryConfig);
+        if (retryConfig.onRetry) {
+          try {
+            await retryConfig.onRetry(attempt, error, context);
+          } catch (hookError) {
+            if (this.config.verbose) {
+              console.warn(`[StateMachinePlugin] onRetry hook failed:`, hookError.message);
+            }
+          }
+        }
+        this.emit("plg:state-machine:action-retry-attempt", {
+          machineId,
+          entityId,
+          action: actionName,
+          attempt,
+          delay,
+          error: error.message,
+          state: currentState
+        });
+        if (this.config.verbose) {
+          console.warn(`[StateMachinePlugin] Action '${actionName}' failed (attempt ${attempt + 1}/${maxAttempts + 1}), retrying in ${delay}ms:`, error.message);
+        }
+        await new Promise((resolve) => setTimeout(resolve, delay));
       }
-      this.emit("action_error", { actionName, error: error.message, machineId, entityId });
     }
   }
   async _transition(machineId, entityId, fromState, toState, event, context) {
@@ -30475,6 +31049,27 @@ class StateMachinePlugin extends Plugin {
       console.warn(`[StateMachinePlugin] Failed to release lock '${lockName}':`, err.message);
     }
   }
+  /**
+   * Calculate backoff delay for retry attempts
+   * @private
+   */
+  _calculateBackoff(attempt, retryConfig) {
+    const {
+      backoffStrategy = "exponential",
+      baseDelay = 1e3,
+      maxDelay = 3e4
+    } = retryConfig || {};
+    let delay;
+    if (backoffStrategy === "exponential") {
+      delay = Math.min(baseDelay * Math.pow(2, attempt - 1), maxDelay);
+    } else if (backoffStrategy === "linear") {
+      delay = Math.min(baseDelay * attempt, maxDelay);
+    } else {
+      delay = baseDelay;
+    }
+    const jitter = delay * 0.2 * (Math.random() - 0.5);
+    return Math.round(delay + jitter);
+  }
   /**
    * Get current state for an entity
    */
@@ -30604,7 +31199,7 @@ class StateMachinePlugin extends Plugin {
     if (initialStateConfig && initialStateConfig.entry) {
       await this._executeAction(initialStateConfig.entry, context, "INIT", machineId, entityId);
     }
-    this.emit("entity_initialized", { machineId, entityId, initialState });
+    this.emit("plg:state-machine:entity-initialized", { machineId, entityId, initialState });
     return initialState;
   }
   /**
@@ -30661,12 +31256,395 @@ class StateMachinePlugin extends Plugin {
 `;
     return dot;
   }
+  /**
+   * Get all entities currently in a specific state
+   * @private
+   */
+  async _getEntitiesInState(machineId, stateName) {
+    if (!this.config.persistTransitions) {
+      const machine = this.machines.get(machineId);
+      if (!machine) return [];
+      const entities = [];
+      for (const [entityId, currentState] of machine.currentStates) {
+        if (currentState === stateName) {
+          entities.push({ entityId, currentState, context: {}, triggerCounts: {} });
+        }
+      }
+      return entities;
+    }
+    const [ok, err, records] = await tryFn(
+      () => this.database.resources[this.config.stateResource].query({
+        machineId,
+        currentState: stateName
+      })
+    );
+    if (!ok) {
+      if (this.config.verbose) {
+        console.warn(`[StateMachinePlugin] Failed to query entities in state '${stateName}':`, err.message);
+      }
+      return [];
+    }
+    return records || [];
+  }
+  /**
+   * Increment trigger execution count for an entity
+   * @private
+   */
+  async _incrementTriggerCount(machineId, entityId, triggerName) {
+    if (!this.config.persistTransitions) {
+      return;
+    }
+    const stateId = `${machineId}_${entityId}`;
+    const [ok, err, stateRecord] = await tryFn(
+      () => this.database.resources[this.config.stateResource].get(stateId)
+    );
+    if (ok && stateRecord) {
+      const triggerCounts = stateRecord.triggerCounts || {};
+      triggerCounts[triggerName] = (triggerCounts[triggerName] || 0) + 1;
+      await tryFn(
+        () => this.database.resources[this.config.stateResource].patch(stateId, { triggerCounts })
+      );
+    }
+  }
+  /**
+   * Setup trigger system for all state machines
+   * @private
+   */
+  async _setupTriggers() {
+    if (!this.config.enableScheduler && !this.config.enableDateTriggers && !this.config.enableFunctionTriggers && !this.config.enableEventTriggers) {
+      return;
+    }
+    const cronJobs = {};
+    for (const [machineId, machineData] of this.machines) {
+      const machineConfig = machineData.config;
+      for (const [stateName, stateConfig] of Object.entries(machineConfig.states)) {
+        const triggers = stateConfig.triggers || [];
+        for (let i = 0; i < triggers.length; i++) {
+          const trigger = triggers[i];
+          const triggerName = `${trigger.action}_${i}`;
+          if (trigger.type === "cron" && this.config.enableScheduler) {
+            const jobName = `${machineId}_${stateName}_${triggerName}`;
+            cronJobs[jobName] = await this._createCronJob(machineId, stateName, trigger, triggerName);
+          } else if (trigger.type === "date" && this.config.enableDateTriggers) {
+            await this._setupDateTrigger(machineId, stateName, trigger, triggerName);
+          } else if (trigger.type === "function" && this.config.enableFunctionTriggers) {
+            await this._setupFunctionTrigger(machineId, stateName, trigger, triggerName);
+          } else if (trigger.type === "event" && this.config.enableEventTriggers) {
+            await this._setupEventTrigger(machineId, stateName, trigger, triggerName);
+          }
+        }
+      }
+    }
+    if (Object.keys(cronJobs).length > 0 && this.config.enableScheduler) {
+      const { SchedulerPlugin } = await Promise.resolve().then(function () { return scheduler_plugin; });
+      this.schedulerPlugin = new SchedulerPlugin({
+        jobs: cronJobs,
+        persistJobs: false,
+        // Don't persist trigger jobs
+        verbose: this.config.verbose,
+        ...this.config.schedulerConfig
+      });
+      await this.database.usePlugin(this.schedulerPlugin);
+      if (this.config.verbose) {
+        console.log(`[StateMachinePlugin] Installed SchedulerPlugin with ${Object.keys(cronJobs).length} cron triggers`);
+      }
+    }
+  }
+  /**
+   * Create a SchedulerPlugin job for a cron trigger
+   * @private
+   */
+  async _createCronJob(machineId, stateName, trigger, triggerName) {
+    return {
+      schedule: trigger.schedule,
+      description: `Trigger '${triggerName}' for ${machineId}.${stateName}`,
+      action: async (database, context) => {
+        const entities = await this._getEntitiesInState(machineId, stateName);
+        let executedCount = 0;
+        for (const entity of entities) {
+          try {
+            if (trigger.condition) {
+              const shouldTrigger = await trigger.condition(entity.context, entity.entityId);
+              if (!shouldTrigger) continue;
+            }
+            if (trigger.maxTriggers !== void 0) {
+              const triggerCount = entity.triggerCounts?.[triggerName] || 0;
+              if (triggerCount >= trigger.maxTriggers) {
+                if (trigger.onMaxTriggersReached) {
+                  await this.send(machineId, entity.entityId, trigger.onMaxTriggersReached, entity.context);
+                }
+                continue;
+              }
+            }
+            const result = await this._executeAction(
+              trigger.action,
+              entity.context,
+              "TRIGGER",
+              machineId,
+              entity.entityId
+            );
+            await this._incrementTriggerCount(machineId, entity.entityId, triggerName);
+            executedCount++;
+            if (trigger.eventOnSuccess) {
+              await this.send(machineId, entity.entityId, trigger.eventOnSuccess, {
+                ...entity.context,
+                triggerResult: result
+              });
+            } else if (trigger.event) {
+              await this.send(machineId, entity.entityId, trigger.event, {
+                ...entity.context,
+                triggerResult: result
+              });
+            }
+            this.emit("plg:state-machine:trigger-executed", {
+              machineId,
+              entityId: entity.entityId,
+              state: stateName,
+              trigger: triggerName,
+              type: "cron"
+            });
+          } catch (error) {
+            if (trigger.event) {
+              await tryFn(() => this.send(machineId, entity.entityId, trigger.event, {
+                ...entity.context,
+                triggerError: error.message
+              }));
+            }
+            if (this.config.verbose) {
+              console.error(`[StateMachinePlugin] Trigger '${triggerName}' failed for entity ${entity.entityId}:`, error.message);
+            }
+          }
+        }
+        return { processed: entities.length, executed: executedCount };
+      }
+    };
+  }
+  /**
+   * Setup a date-based trigger
+   * @private
+   */
+  async _setupDateTrigger(machineId, stateName, trigger, triggerName) {
+    const checkInterval = setInterval(async () => {
+      const entities = await this._getEntitiesInState(machineId, stateName);
+      for (const entity of entities) {
+        try {
+          const triggerDateValue = entity.context?.[trigger.field];
+          if (!triggerDateValue) continue;
+          const triggerDate = new Date(triggerDateValue);
+          const now = /* @__PURE__ */ new Date();
+          if (now >= triggerDate) {
+            if (trigger.maxTriggers !== void 0) {
+              const triggerCount = entity.triggerCounts?.[triggerName] || 0;
+              if (triggerCount >= trigger.maxTriggers) {
+                if (trigger.onMaxTriggersReached) {
+                  await this.send(machineId, entity.entityId, trigger.onMaxTriggersReached, entity.context);
+                }
+                continue;
+              }
+            }
+            const result = await this._executeAction(trigger.action, entity.context, "TRIGGER", machineId, entity.entityId);
+            await this._incrementTriggerCount(machineId, entity.entityId, triggerName);
+            if (trigger.event) {
+              await this.send(machineId, entity.entityId, trigger.event, {
+                ...entity.context,
+                triggerResult: result
+              });
+            }
+            this.emit("plg:state-machine:trigger-executed", {
+              machineId,
+              entityId: entity.entityId,
+              state: stateName,
+              trigger: triggerName,
+              type: "date"
+            });
+          }
+        } catch (error) {
+          if (this.config.verbose) {
+            console.error(`[StateMachinePlugin] Date trigger '${triggerName}' failed:`, error.message);
+          }
+        }
+      }
+    }, this.config.triggerCheckInterval);
+    this.triggerIntervals.push(checkInterval);
+  }
+  /**
+   * Setup a function-based trigger
+   * @private
+   */
+  async _setupFunctionTrigger(machineId, stateName, trigger, triggerName) {
+    const interval = trigger.interval || this.config.triggerCheckInterval;
+    const checkInterval = setInterval(async () => {
+      const entities = await this._getEntitiesInState(machineId, stateName);
+      for (const entity of entities) {
+        try {
+          if (trigger.maxTriggers !== void 0) {
+            const triggerCount = entity.triggerCounts?.[triggerName] || 0;
+            if (triggerCount >= trigger.maxTriggers) {
+              if (trigger.onMaxTriggersReached) {
+                await this.send(machineId, entity.entityId, trigger.onMaxTriggersReached, entity.context);
+              }
+              continue;
+            }
+          }
+          const shouldTrigger = await trigger.condition(entity.context, entity.entityId);
+          if (shouldTrigger) {
+            const result = await this._executeAction(trigger.action, entity.context, "TRIGGER", machineId, entity.entityId);
+            await this._incrementTriggerCount(machineId, entity.entityId, triggerName);
+            if (trigger.event) {
+              await this.send(machineId, entity.entityId, trigger.event, {
+                ...entity.context,
+                triggerResult: result
+              });
+            }
+            this.emit("plg:state-machine:trigger-executed", {
+              machineId,
+              entityId: entity.entityId,
+              state: stateName,
+              trigger: triggerName,
+              type: "function"
+            });
+          }
+        } catch (error) {
+          if (this.config.verbose) {
+            console.error(`[StateMachinePlugin] Function trigger '${triggerName}' failed:`, error.message);
+          }
+        }
+      }
+    }, interval);
+    this.triggerIntervals.push(checkInterval);
+  }
+  /**
+   * Setup an event-based trigger
+   * @private
+   */
+  async _setupEventTrigger(machineId, stateName, trigger, triggerName) {
+    const eventName = trigger.event;
+    const eventHandler = async (eventData) => {
+      const entities = await this._getEntitiesInState(machineId, stateName);
+      for (const entity of entities) {
+        try {
+          if (trigger.condition) {
+            const shouldTrigger = await trigger.condition(entity.context, entity.entityId, eventData);
+            if (!shouldTrigger) continue;
+          }
+          if (trigger.maxTriggers !== void 0) {
+            const triggerCount = entity.triggerCounts?.[triggerName] || 0;
+            if (triggerCount >= trigger.maxTriggers) {
+              if (trigger.onMaxTriggersReached) {
+                await this.send(machineId, entity.entityId, trigger.onMaxTriggersReached, entity.context);
+              }
+              continue;
+            }
+          }
+          const result = await this._executeAction(
+            trigger.action,
+            { ...entity.context, eventData },
+            "TRIGGER",
+            machineId,
+            entity.entityId
+          );
+          await this._incrementTriggerCount(machineId, entity.entityId, triggerName);
+          if (trigger.sendEvent) {
+            await this.send(machineId, entity.entityId, trigger.sendEvent, {
+              ...entity.context,
+              triggerResult: result,
+              eventData
+            });
+          }
+          this.emit("plg:state-machine:trigger-executed", {
+            machineId,
+            entityId: entity.entityId,
+            state: stateName,
+            trigger: triggerName,
+            type: "event",
+            eventName
+          });
+        } catch (error) {
+          if (this.config.verbose) {
+            console.error(`[StateMachinePlugin] Event trigger '${triggerName}' failed:`, error.message);
+          }
+        }
+      }
+    };
+    if (eventName.startsWith("db:")) {
+      const dbEventName = eventName.substring(3);
+      this.database.on(dbEventName, eventHandler);
+      if (this.config.verbose) {
+        console.log(`[StateMachinePlugin] Listening to database event '${dbEventName}' for trigger '${triggerName}'`);
+      }
+    } else {
+      this.on(eventName, eventHandler);
+      if (this.config.verbose) {
+        console.log(`[StateMachinePlugin] Listening to plugin event '${eventName}' for trigger '${triggerName}'`);
+      }
+    }
+  }
+  /**
+   * Attach state machine instances to their associated resources
+   * This enables the resource API: resource.state(id, event)
+   * @private
+   */
+  async _attachStateMachinesToResources() {
+    for (const [machineName, machineConfig] of Object.entries(this.config.stateMachines)) {
+      const resourceConfig = machineConfig.config || machineConfig;
+      if (!resourceConfig.resource) {
+        if (this.config.verbose) {
+          console.log(`[StateMachinePlugin] Machine '${machineName}' has no resource configured, skipping attachment`);
+        }
+        continue;
+      }
+      let resource;
+      if (typeof resourceConfig.resource === "string") {
+        resource = this.database.resources[resourceConfig.resource];
+        if (!resource) {
+          console.warn(
+            `[StateMachinePlugin] Resource '${resourceConfig.resource}' not found for machine '${machineName}'. Resource API will not be available.`
+          );
+          continue;
+        }
+      } else {
+        resource = resourceConfig.resource;
+      }
+      const machineProxy = {
+        send: async (id, event, eventData) => {
+          return this.send(machineName, id, event, eventData);
+        },
+        getState: async (id) => {
+          return this.getState(machineName, id);
+        },
+        canTransition: async (id, event) => {
+          return this.canTransition(machineName, id, event);
+        },
+        getValidEvents: async (id) => {
+          return this.getValidEvents(machineName, id);
+        },
+        initializeEntity: async (id, context) => {
+          return this.initializeEntity(machineName, id, context);
+        },
+        getTransitionHistory: async (id, options) => {
+          return this.getTransitionHistory(machineName, id, options);
+        }
+      };
+      resource._attachStateMachine(machineProxy);
+      if (this.config.verbose) {
+        console.log(`[StateMachinePlugin] Attached machine '${machineName}' to resource '${resource.name}'`);
+      }
+    }
+  }
   async start() {
     if (this.config.verbose) {
       console.log(`[StateMachinePlugin] Started with ${this.machines.size} state machines`);
     }
   }
   async stop() {
+    for (const interval of this.triggerIntervals) {
+      clearInterval(interval);
+    }
+    this.triggerIntervals = [];
+    if (this.schedulerPlugin) {
+      await this.schedulerPlugin.stop();
+      this.schedulerPlugin = null;
+    }
     this.machines.clear();
     this.removeAllListeners();
   }
@@ -40938,7 +41916,7 @@ class TTLPlugin extends Plugin {
     if (this.verbose) {
       console.log(`[TTLPlugin] Installed with ${Object.keys(this.resources).length} resources`);
     }
-    this.emit("installed", {
+    this.emit("db:plugin:installed", {
       plugin: "TTLPlugin",
       resources: Object.keys(this.resources)
     });
@@ -41175,7 +42153,7 @@ class TTLPlugin extends Plugin {
       }
       this.stats.lastScanAt = (/* @__PURE__ */ new Date()).toISOString();
       this.stats.lastScanDuration = Date.now() - startTime;
-      this.emit("scanCompleted", {
+      this.emit("plg:ttl:scan-completed", {
         granularity,
         duration: this.stats.lastScanDuration,
         cohorts
@@ -41183,7 +42161,7 @@ class TTLPlugin extends Plugin {
     } catch (error) {
       console.error(`[TTLPlugin] Error in ${granularity} cleanup:`, error);
       this.stats.totalErrors++;
-      this.emit("cleanupError", { granularity, error });
+      this.emit("plg:ttl:cleanup-error", { granularity, error });
     }
   }
   /**
@@ -41231,7 +42209,7 @@ class TTLPlugin extends Plugin {
       }
       await this.expirationIndex.delete(entry.id);
       this.stats.totalExpired++;
-      this.emit("recordExpired", { resource: entry.resourceName, record });
+      this.emit("plg:ttl:record-expired", { resource: entry.resourceName, record });
     } catch (error) {
       console.error(`[TTLPlugin] Error processing expired entry:`, error);
       this.stats.totalErrors++;
@@ -41702,15 +42680,15 @@ class VectorPlugin extends Plugin {
     this._throttleState = /* @__PURE__ */ new Map();
   }
   async onInstall() {
-    this.emit("installed", { plugin: "VectorPlugin" });
+    this.emit("db:plugin:installed", { plugin: "VectorPlugin" });
     this.validateVectorStorage();
     this.installResourceMethods();
   }
   async onStart() {
-    this.emit("started", { plugin: "VectorPlugin" });
+    this.emit("db:plugin:started", { plugin: "VectorPlugin" });
   }
   async onStop() {
-    this.emit("stopped", { plugin: "VectorPlugin" });
+    this.emit("db:plugin:stopped", { plugin: "VectorPlugin" });
   }
   async onUninstall(options) {
     for (const resource of Object.values(this.database.resources)) {
@@ -41721,7 +42699,7 @@ class VectorPlugin extends Plugin {
       delete resource.findSimilar;
       delete resource.distance;
     }
-    this.emit("uninstalled", { plugin: "VectorPlugin" });
+    this.emit("db:plugin:uninstalled", { plugin: "VectorPlugin" });
   }
   /**
    * Validate vector storage configuration for all resources
@@ -41750,10 +42728,10 @@ class VectorPlugin extends Plugin {
             currentBehavior: resource.behavior || "default",
             recommendation: "body-overflow"
           };
-          this.emit("vector:storage-warning", warning);
+          this.emit("plg:vector:storage-warning", warning);
           if (this.config.autoFixBehavior) {
             resource.behavior = "body-overflow";
-            this.emit("vector:behavior-fixed", {
+            this.emit("plg:vector:behavior-fixed", {
               resource: resource.name,
               newBehavior: "body-overflow"
             });
@@ -41785,7 +42763,7 @@ class VectorPlugin extends Plugin {
       const partitionName = `byHas${this.capitalize(vectorField.name.replace(/\./g, "_"))}`;
       const trackingFieldName = `_has${this.capitalize(vectorField.name.replace(/\./g, "_"))}`;
       if (resource.config.partitions && resource.config.partitions[partitionName]) {
-        this.emit("vector:partition-exists", {
+        this.emit("plg:vector:partition-exists", {
           resource: resource.name,
           vectorField: vectorField.name,
           partition: partitionName,
@@ -41808,7 +42786,7 @@ class VectorPlugin extends Plugin {
           default: false
         }, "VectorPlugin");
       }
-      this.emit("vector:partition-created", {
+      this.emit("plg:vector:partition-created", {
         resource: resource.name,
         vectorField: vectorField.name,
         partition: partitionName,
@@ -41883,7 +42861,7 @@ class VectorPlugin extends Plugin {
       }
       return updates;
     });
-    this.emit("vector:hooks-installed", {
+    this.emit("plg:vector:hooks-installed", {
       resource: resource.name,
       vectorField,
       trackingField,
@@ -41992,7 +42970,7 @@ class VectorPlugin extends Plugin {
     const vectorField = this._findEmbeddingField(resource.schema.attributes);
     this._vectorFieldCache.set(resource.name, vectorField);
     if (vectorField && this.config.emitEvents) {
-      this.emit("vector:field-detected", {
+      this.emit("plg:vector:field-detected", {
         resource: resource.name,
         vectorField,
         timestamp: Date.now()
@@ -42916,7 +43894,7 @@ class MemoryClient extends EventEmitter {
   async sendCommand(command) {
     const commandName = command.constructor.name;
     const input = command.input || {};
-    this.emit("command.request", commandName, input);
+    this.emit("cl:request", commandName, input);
     let response;
     try {
       switch (commandName) {
@@ -42944,7 +43922,7 @@ class MemoryClient extends EventEmitter {
         default:
           throw new Error(`Unsupported command: ${commandName}`);
       }
-      this.emit("command.response", commandName, response, input);
+      this.emit("cl:response", commandName, response, input);
       return response;
     } catch (error) {
       const mappedError = mapAwsError(error, {
@@ -43055,7 +44033,7 @@ class MemoryClient extends EventEmitter {
       contentLength,
       ifMatch
     });
-    this.emit("putObject", null, { key, metadata, contentType, body, contentEncoding, contentLength });
+    this.emit("cl:PutObject", null, { key, metadata, contentType, body, contentEncoding, contentLength });
     return response;
   }
   /**
@@ -43070,7 +44048,7 @@ class MemoryClient extends EventEmitter {
         decodedMetadata[k] = metadataDecode(v);
       }
     }
-    this.emit("getObject", null, { key });
+    this.emit("cl:GetObject", null, { key });
     return {
       ...response,
       Metadata: decodedMetadata
@@ -43088,7 +44066,7 @@ class MemoryClient extends EventEmitter {
         decodedMetadata[k] = metadataDecode(v);
       }
     }
-    this.emit("headObject", null, { key });
+    this.emit("cl:HeadObject", null, { key });
     return {
       ...response,
       Metadata: decodedMetadata
@@ -43113,7 +44091,7 @@ class MemoryClient extends EventEmitter {
       metadataDirective,
       contentType
     });
-    this.emit("copyObject", null, { from, to, metadata, metadataDirective });
+    this.emit("cl:CopyObject", null, { from, to, metadata, metadataDirective });
     return response;
   }
   /**
@@ -43129,7 +44107,7 @@ class MemoryClient extends EventEmitter {
   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 });
+    this.emit("cl:DeleteObject", null, { key });
     return response;
   }
   /**
@@ -43162,7 +44140,7 @@ class MemoryClient extends EventEmitter {
       maxKeys,
       continuationToken
     });
-    this.emit("listObjects", null, { prefix, count: response.Contents.length });
+    this.emit("cl:ListObjects", null, { prefix, count: response.Contents.length });
     return response;
   }
   /**
@@ -43202,7 +44180,7 @@ class MemoryClient extends EventEmitter {
     if (this.keyPrefix) {
       keys = keys.map((x) => x.replace(this.keyPrefix, "")).map((x) => x.startsWith("/") ? x.replace("/", "") : x);
     }
-    this.emit("getKeysPage", keys, params);
+    this.emit("cl:GetKeysPage", keys, params);
     return keys;
   }
   /**
@@ -43219,7 +44197,7 @@ class MemoryClient extends EventEmitter {
     if (this.keyPrefix) {
       keys = keys.map((x) => x.replace(this.keyPrefix, "")).map((x) => x.startsWith("/") ? x.replace("/", "") : x);
     }
-    this.emit("getAllKeys", keys, { prefix });
+    this.emit("cl:GetAllKeys", keys, { prefix });
     return keys;
   }
   /**
@@ -43228,7 +44206,7 @@ class MemoryClient extends EventEmitter {
   async count({ prefix = "" } = {}) {
     const keys = await this.getAllKeys({ prefix });
     const count = keys.length;
-    this.emit("count", count, { prefix });
+    this.emit("cl:Count", count, { prefix });
     return count;
   }
   /**
@@ -43240,13 +44218,13 @@ class MemoryClient extends EventEmitter {
     if (keys.length > 0) {
       const result = await this.deleteObjects(keys);
       totalDeleted = result.Deleted.length;
-      this.emit("deleteAll", {
+      this.emit("cl:DeleteAll", {
         prefix,
         batch: totalDeleted,
         total: totalDeleted
       });
     }
-    this.emit("deleteAllComplete", {
+    this.emit("cl:DeleteAllComplete", {
       prefix,
       totalDeleted
     });
@@ -43259,11 +44237,11 @@ class MemoryClient extends EventEmitter {
     if (offset === 0) return null;
     const keys = await this.getAllKeys({ prefix });
     if (offset >= keys.length) {
-      this.emit("getContinuationTokenAfterOffset", null, { prefix, offset });
+      this.emit("cl:GetContinuationTokenAfterOffset", null, { prefix, offset });
       return null;
     }
     const token = keys[offset];
-    this.emit("getContinuationTokenAfterOffset", token, { prefix, offset });
+    this.emit("cl:GetContinuationTokenAfterOffset", token, { prefix, offset });
     return token;
   }
   /**
@@ -43293,7 +44271,7 @@ class MemoryClient extends EventEmitter {
         });
       }
     }
-    this.emit("moveAllObjects", { results, errors }, { prefixFrom, prefixTo });
+    this.emit("cl:MoveAllObjects", { results, errors }, { prefixFrom, prefixTo });
     if (errors.length > 0) {
       const error = new Error("Some objects could not be moved");
       error.context = {