s3db.js 13.0.0 → 13.2.1

package/dist/s3db.es.js

@@ -2544,6 +2544,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) {
@@ -2680,6 +2692,2037 @@ async function requirePluginDependency(pluginId, options = {}) {
   return { valid, missing, incompatible, messages };
 }
 
+function success(data, options = {}) {
+  const { status = 200, meta = {} } = options;
+  return {
+    success: true,
+    data,
+    meta: {
+      timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+      ...meta
+    },
+    _status: status
+  };
+}
+function error(error2, options = {}) {
+  const { status = 500, code = "INTERNAL_ERROR", details = {} } = options;
+  const errorMessage = error2 instanceof Error ? error2.message : error2;
+  const errorStack = error2 instanceof Error && process.env.NODE_ENV !== "production" ? error2.stack : void 0;
+  return {
+    success: false,
+    error: {
+      message: errorMessage,
+      code,
+      details,
+      stack: errorStack
+    },
+    meta: {
+      timestamp: (/* @__PURE__ */ new Date()).toISOString()
+    },
+    _status: status
+  };
+}
+function list(items, pagination = {}) {
+  const { total, page, pageSize, pageCount } = pagination;
+  return {
+    success: true,
+    data: items,
+    pagination: {
+      total: total || items.length,
+      page: page || 1,
+      pageSize: pageSize || items.length,
+      pageCount: pageCount || 1
+    },
+    meta: {
+      timestamp: (/* @__PURE__ */ new Date()).toISOString()
+    },
+    _status: 200
+  };
+}
+function created(data, location) {
+  return {
+    success: true,
+    data,
+    meta: {
+      timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+      location
+    },
+    _status: 201
+  };
+}
+function noContent() {
+  return {
+    success: true,
+    data: null,
+    meta: {
+      timestamp: (/* @__PURE__ */ new Date()).toISOString()
+    },
+    _status: 204
+  };
+}
+function notFound(resource, id) {
+  return error(`${resource} with id '${id}' not found`, {
+    status: 404,
+    code: "NOT_FOUND",
+    details: { resource, id }
+  });
+}
+function payloadTooLarge(size, limit) {
+  return error("Request payload too large", {
+    status: 413,
+    code: "PAYLOAD_TOO_LARGE",
+    details: {
+      receivedSize: size,
+      maxSize: limit,
+      receivedMB: (size / 1024 / 1024).toFixed(2),
+      maxMB: (limit / 1024 / 1024).toFixed(2)
+    }
+  });
+}
+
+const errorStatusMap = {
+  "ValidationError": 400,
+  "InvalidResourceItem": 400,
+  "ResourceNotFound": 404,
+  "NoSuchKey": 404,
+  "NoSuchBucket": 404,
+  "PartitionError": 400,
+  "CryptoError": 500,
+  "SchemaError": 400,
+  "QueueError": 500,
+  "ResourceError": 500
+};
+function getStatusFromError(err) {
+  if (err.name && errorStatusMap[err.name]) {
+    return errorStatusMap[err.name];
+  }
+  if (err.constructor && err.constructor.name && errorStatusMap[err.constructor.name]) {
+    return errorStatusMap[err.constructor.name];
+  }
+  if (err.message) {
+    if (err.message.includes("not found") || err.message.includes("does not exist")) {
+      return 404;
+    }
+    if (err.message.includes("validation") || err.message.includes("invalid")) {
+      return 400;
+    }
+    if (err.message.includes("unauthorized") || err.message.includes("authentication")) {
+      return 401;
+    }
+    if (err.message.includes("forbidden") || err.message.includes("permission")) {
+      return 403;
+    }
+  }
+  return 500;
+}
+function errorHandler(err, c) {
+  const status = getStatusFromError(err);
+  const code = err.name || "INTERNAL_ERROR";
+  const details = {};
+  if (err.resource) details.resource = err.resource;
+  if (err.bucket) details.bucket = err.bucket;
+  if (err.key) details.key = err.key;
+  if (err.operation) details.operation = err.operation;
+  if (err.suggestion) details.suggestion = err.suggestion;
+  if (err.availableResources) details.availableResources = err.availableResources;
+  const response = error(err, {
+    status,
+    code,
+    details
+  });
+  if (status >= 500) {
+    console.error("[API Plugin] Error:", {
+      message: err.message,
+      code,
+      status,
+      stack: err.stack,
+      details
+    });
+  } else if (status >= 400 && status < 500 && c.get("verbose")) {
+    console.warn("[API Plugin] Client error:", {
+      message: err.message,
+      code,
+      status,
+      details
+    });
+  }
+  return c.json(response, response._status);
+}
+function asyncHandler(fn) {
+  return async (c) => {
+    try {
+      return await fn(c);
+    } catch (err) {
+      return errorHandler(err, c);
+    }
+  };
+}
+
+function parseCustomRoute(routeDef) {
+  let def = routeDef.trim();
+  const isAsync = def.startsWith("async ");
+  if (isAsync) {
+    def = def.substring(6).trim();
+  }
+  const parts = def.split(/\s+/);
+  if (parts.length < 2) {
+    throw new Error(`Invalid route definition: "${routeDef}". Expected format: "METHOD /path" or "async METHOD /path"`);
+  }
+  const method = parts[0].toUpperCase();
+  const path = parts.slice(1).join(" ").trim();
+  const validMethods = ["GET", "POST", "PUT", "PATCH", "DELETE", "HEAD", "OPTIONS"];
+  if (!validMethods.includes(method)) {
+    throw new Error(`Invalid HTTP method: "${method}". Must be one of: ${validMethods.join(", ")}`);
+  }
+  if (!path.startsWith("/")) {
+    throw new Error(`Invalid route path: "${path}". Path must start with "/"`);
+  }
+  return { method, path, isAsync };
+}
+function createResourceRoutes(resource, version, config = {}, Hono) {
+  const app = new Hono();
+  const {
+    methods = ["GET", "POST", "PUT", "PATCH", "DELETE", "HEAD", "OPTIONS"],
+    customMiddleware = [],
+    enableValidation = true
+  } = config;
+  const resourceName = resource.name;
+  const basePath = `/${version}/${resourceName}`;
+  customMiddleware.forEach((middleware) => {
+    app.use("*", middleware);
+  });
+  if (resource.config?.api && typeof resource.config.api === "object") {
+    for (const [routeDef, handler] of Object.entries(resource.config.api)) {
+      try {
+        const { method, path } = parseCustomRoute(routeDef);
+        if (typeof handler !== "function") {
+          throw new Error(`Handler for route "${routeDef}" must be a function`);
+        }
+        app.on(method, path, asyncHandler(async (c) => {
+          const result = await handler(c, { resource, database: resource.database });
+          if (result && result.constructor && result.constructor.name === "Response") {
+            return result;
+          }
+          if (result !== void 0 && result !== null) {
+            return c.json(success(result));
+          }
+          return c.json(noContent(), 204);
+        }));
+        if (config.verbose || resource.database?.verbose) {
+          console.log(`[API Plugin] Registered custom route for ${resourceName}: ${method} ${path}`);
+        }
+      } catch (error) {
+        console.error(`[API Plugin] Error registering custom route "${routeDef}" for ${resourceName}:`, error.message);
+        throw error;
+      }
+    }
+  }
+  if (methods.includes("GET")) {
+    app.get("/", asyncHandler(async (c) => {
+      const query = c.req.query();
+      const limit = parseInt(query.limit) || 100;
+      const offset = parseInt(query.offset) || 0;
+      const partition = query.partition;
+      const partitionValues = query.partitionValues ? JSON.parse(query.partitionValues) : void 0;
+      const reservedKeys = ["limit", "offset", "partition", "partitionValues", "sort"];
+      const filters = {};
+      for (const [key, value] of Object.entries(query)) {
+        if (!reservedKeys.includes(key)) {
+          try {
+            filters[key] = JSON.parse(value);
+          } catch {
+            filters[key] = value;
+          }
+        }
+      }
+      let items;
+      let total;
+      if (Object.keys(filters).length > 0) {
+        items = await resource.query(filters, { limit: limit + offset });
+        items = items.slice(offset, offset + limit);
+        total = items.length;
+      } else if (partition && partitionValues) {
+        items = await resource.listPartition({
+          partition,
+          partitionValues,
+          limit: limit + offset
+        });
+        items = items.slice(offset, offset + limit);
+        total = items.length;
+      } else {
+        items = await resource.list({ limit: limit + offset });
+        items = items.slice(offset, offset + limit);
+        total = items.length;
+      }
+      const response = list(items, {
+        total,
+        page: Math.floor(offset / limit) + 1,
+        pageSize: limit,
+        pageCount: Math.ceil(total / limit)
+      });
+      c.header("X-Total-Count", total.toString());
+      c.header("X-Page-Count", Math.ceil(total / limit).toString());
+      return c.json(response, response._status);
+    }));
+  }
+  if (methods.includes("GET")) {
+    app.get("/:id", asyncHandler(async (c) => {
+      const id = c.req.param("id");
+      const query = c.req.query();
+      const partition = query.partition;
+      const partitionValues = query.partitionValues ? JSON.parse(query.partitionValues) : void 0;
+      let item;
+      if (partition && partitionValues) {
+        item = await resource.getFromPartition({
+          id,
+          partitionName: partition,
+          partitionValues
+        });
+      } else {
+        item = await resource.get(id);
+      }
+      if (!item) {
+        const response2 = notFound(resourceName, id);
+        return c.json(response2, response2._status);
+      }
+      const response = success(item);
+      return c.json(response, response._status);
+    }));
+  }
+  if (methods.includes("POST")) {
+    app.post("/", asyncHandler(async (c) => {
+      const data = await c.req.json();
+      const item = await resource.insert(data);
+      const location = `${basePath}/${item.id}`;
+      const response = created(item, location);
+      c.header("Location", location);
+      return c.json(response, response._status);
+    }));
+  }
+  if (methods.includes("PUT")) {
+    app.put("/:id", asyncHandler(async (c) => {
+      const id = c.req.param("id");
+      const data = await c.req.json();
+      const existing = await resource.get(id);
+      if (!existing) {
+        const response2 = notFound(resourceName, id);
+        return c.json(response2, response2._status);
+      }
+      const updated = await resource.update(id, data);
+      const response = success(updated);
+      return c.json(response, response._status);
+    }));
+  }
+  if (methods.includes("PATCH")) {
+    app.patch("/:id", asyncHandler(async (c) => {
+      const id = c.req.param("id");
+      const data = await c.req.json();
+      const existing = await resource.get(id);
+      if (!existing) {
+        const response2 = notFound(resourceName, id);
+        return c.json(response2, response2._status);
+      }
+      const merged = { ...existing, ...data, id };
+      const updated = await resource.update(id, merged);
+      const response = success(updated);
+      return c.json(response, response._status);
+    }));
+  }
+  if (methods.includes("DELETE")) {
+    app.delete("/:id", asyncHandler(async (c) => {
+      const id = c.req.param("id");
+      const existing = await resource.get(id);
+      if (!existing) {
+        const response2 = notFound(resourceName, id);
+        return c.json(response2, response2._status);
+      }
+      await resource.delete(id);
+      const response = noContent();
+      return c.json(response, response._status);
+    }));
+  }
+  if (methods.includes("HEAD")) {
+    app.on("HEAD", "/", asyncHandler(async (c) => {
+      const total = await resource.count();
+      const allItems = await resource.list({ limit: 1e3 });
+      const stats = {
+        total,
+        version: resource.config?.currentVersion || resource.version || "v1"
+      };
+      c.header("X-Total-Count", total.toString());
+      c.header("X-Resource-Version", stats.version);
+      c.header("X-Schema-Fields", Object.keys(resource.config?.attributes || {}).length.toString());
+      return c.body(null, 200);
+    }));
+    app.on("HEAD", "/:id", asyncHandler(async (c) => {
+      const id = c.req.param("id");
+      const item = await resource.get(id);
+      if (!item) {
+        return c.body(null, 404);
+      }
+      if (item.updatedAt) {
+        c.header("Last-Modified", new Date(item.updatedAt).toUTCString());
+      }
+      return c.body(null, 200);
+    }));
+  }
+  if (methods.includes("OPTIONS")) {
+    app.options("/", asyncHandler(async (c) => {
+      c.header("Allow", methods.join(", "));
+      const total = await resource.count();
+      const schema = resource.config?.attributes || {};
+      const version2 = resource.config?.currentVersion || resource.version || "v1";
+      const metadata = {
+        resource: resourceName,
+        version: version2,
+        totalRecords: total,
+        allowedMethods: methods,
+        schema: Object.entries(schema).map(([name, def]) => ({
+          name,
+          type: typeof def === "string" ? def.split("|")[0] : def.type,
+          rules: typeof def === "string" ? def.split("|").slice(1) : []
+        })),
+        endpoints: {
+          list: `/${version2}/${resourceName}`,
+          get: `/${version2}/${resourceName}/:id`,
+          create: `/${version2}/${resourceName}`,
+          update: `/${version2}/${resourceName}/:id`,
+          delete: `/${version2}/${resourceName}/:id`
+        },
+        queryParameters: {
+          limit: "number (1-1000, default: 100)",
+          offset: "number (min: 0, default: 0)",
+          partition: "string (partition name)",
+          partitionValues: "JSON string",
+          "[any field]": "any (filter by field value)"
+        }
+      };
+      return c.json(metadata);
+    }));
+    app.options("/:id", (c) => {
+      c.header("Allow", methods.filter((m) => m !== "POST").join(", "));
+      return c.body(null, 204);
+    });
+  }
+  return app;
+}
+function createRelationalRoutes(sourceResource, relationName, relationConfig, version, Hono) {
+  const app = new Hono();
+  const resourceName = sourceResource.name;
+  const relatedResourceName = relationConfig.resource;
+  app.get("/:id", asyncHandler(async (c) => {
+    const id = c.req.param("id");
+    const query = c.req.query();
+    const source = await sourceResource.get(id);
+    if (!source) {
+      const response = notFound(resourceName, id);
+      return c.json(response, response._status);
+    }
+    const result = await sourceResource.get(id, {
+      include: [relationName]
+    });
+    const relatedData = result[relationName];
+    if (!relatedData) {
+      if (relationConfig.type === "hasMany" || relationConfig.type === "belongsToMany") {
+        const response = list([], {
+          total: 0,
+          page: 1,
+          pageSize: 100,
+          pageCount: 0
+        });
+        return c.json(response, response._status);
+      } else {
+        const response = notFound(relatedResourceName, "related resource");
+        return c.json(response, response._status);
+      }
+    }
+    if (relationConfig.type === "hasMany" || relationConfig.type === "belongsToMany") {
+      const items = Array.isArray(relatedData) ? relatedData : [relatedData];
+      const limit = parseInt(query.limit) || 100;
+      const offset = parseInt(query.offset) || 0;
+      const paginatedItems = items.slice(offset, offset + limit);
+      const response = list(paginatedItems, {
+        total: items.length,
+        page: Math.floor(offset / limit) + 1,
+        pageSize: limit,
+        pageCount: Math.ceil(items.length / limit)
+      });
+      c.header("X-Total-Count", items.length.toString());
+      c.header("X-Page-Count", Math.ceil(items.length / limit).toString());
+      return c.json(response, response._status);
+    } else {
+      const response = success(relatedData);
+      return c.json(response, response._status);
+    }
+  }));
+  return app;
+}
+
+function mapFieldTypeToOpenAPI(fieldType) {
+  const type = fieldType.split("|")[0].trim();
+  const typeMap = {
+    "string": { type: "string" },
+    "number": { type: "number" },
+    "integer": { type: "integer" },
+    "boolean": { type: "boolean" },
+    "array": { type: "array", items: { type: "string" } },
+    "object": { type: "object" },
+    "json": { type: "object" },
+    "secret": { type: "string", format: "password" },
+    "email": { type: "string", format: "email" },
+    "url": { type: "string", format: "uri" },
+    "date": { type: "string", format: "date" },
+    "datetime": { type: "string", format: "date-time" },
+    "ip4": { type: "string", format: "ipv4", description: "IPv4 address" },
+    "ip6": { type: "string", format: "ipv6", description: "IPv6 address" },
+    "embedding": { type: "array", items: { type: "number" }, description: "Vector embedding" }
+  };
+  if (type.startsWith("embedding:")) {
+    const length = parseInt(type.split(":")[1]);
+    return {
+      type: "array",
+      items: { type: "number" },
+      minItems: length,
+      maxItems: length,
+      description: `Vector embedding (${length} dimensions)`
+    };
+  }
+  return typeMap[type] || { type: "string" };
+}
+function extractValidationRules(fieldDef) {
+  const rules = {};
+  const parts = fieldDef.split("|");
+  for (const part of parts) {
+    const [rule, value] = part.split(":").map((s) => s.trim());
+    switch (rule) {
+      case "required":
+        rules.required = true;
+        break;
+      case "min":
+        rules.minimum = parseFloat(value);
+        break;
+      case "max":
+        rules.maximum = parseFloat(value);
+        break;
+      case "minlength":
+        rules.minLength = parseInt(value);
+        break;
+      case "maxlength":
+        rules.maxLength = parseInt(value);
+        break;
+      case "pattern":
+        rules.pattern = value;
+        break;
+      case "enum":
+        rules.enum = value.split(",").map((v) => v.trim());
+        break;
+      case "default":
+        rules.default = value;
+        break;
+    }
+  }
+  return rules;
+}
+function generateResourceSchema(resource) {
+  const properties = {};
+  const required = [];
+  const allAttributes = resource.config?.attributes || resource.attributes || {};
+  const pluginAttrNames = resource.schema?._pluginAttributes ? Object.values(resource.schema._pluginAttributes).flat() : [];
+  const attributes = Object.fromEntries(
+    Object.entries(allAttributes).filter(([name]) => !pluginAttrNames.includes(name))
+  );
+  const resourceDescription = resource.config?.description;
+  const attributeDescriptions = typeof resourceDescription === "object" ? resourceDescription.attributes || {} : {};
+  properties.id = {
+    type: "string",
+    description: "Unique identifier for the resource",
+    example: "2_gDTpeU6EI0e8B92n_R3Y",
+    readOnly: true
+  };
+  for (const [fieldName, fieldDef] of Object.entries(attributes)) {
+    if (typeof fieldDef === "object" && fieldDef.type) {
+      const baseType = mapFieldTypeToOpenAPI(fieldDef.type);
+      properties[fieldName] = {
+        ...baseType,
+        description: fieldDef.description || attributeDescriptions[fieldName] || void 0
+      };
+      if (fieldDef.required) {
+        required.push(fieldName);
+      }
+      if (fieldDef.type === "object" && fieldDef.props) {
+        properties[fieldName].properties = {};
+        for (const [propName, propDef] of Object.entries(fieldDef.props)) {
+          const propType = typeof propDef === "string" ? propDef : propDef.type;
+          properties[fieldName].properties[propName] = mapFieldTypeToOpenAPI(propType);
+        }
+      }
+      if (fieldDef.type === "array" && fieldDef.items) {
+        properties[fieldName].items = mapFieldTypeToOpenAPI(fieldDef.items);
+      }
+    } else if (typeof fieldDef === "string") {
+      const baseType = mapFieldTypeToOpenAPI(fieldDef);
+      const rules = extractValidationRules(fieldDef);
+      properties[fieldName] = {
+        ...baseType,
+        ...rules,
+        description: attributeDescriptions[fieldName] || void 0
+      };
+      if (rules.required) {
+        required.push(fieldName);
+        delete properties[fieldName].required;
+      }
+    }
+  }
+  return {
+    type: "object",
+    properties,
+    required: required.length > 0 ? required : void 0
+  };
+}
+function generateResourcePaths(resource, version, config = {}) {
+  const resourceName = resource.name;
+  const basePath = `/${version}/${resourceName}`;
+  const schema = generateResourceSchema(resource);
+  const methods = config.methods || ["GET", "POST", "PUT", "PATCH", "DELETE"];
+  const authMethods = config.auth || [];
+  const requiresAuth = authMethods && authMethods.length > 0;
+  const paths = {};
+  const security = [];
+  if (requiresAuth) {
+    if (authMethods.includes("jwt")) security.push({ bearerAuth: [] });
+    if (authMethods.includes("apiKey")) security.push({ apiKeyAuth: [] });
+    if (authMethods.includes("basic")) security.push({ basicAuth: [] });
+  }
+  const partitions = resource.config?.options?.partitions || resource.config?.partitions || resource.partitions || {};
+  const partitionNames = Object.keys(partitions);
+  const hasPartitions = partitionNames.length > 0;
+  let partitionDescription = "Partition name for filtering";
+  let partitionValuesDescription = "Partition values as JSON string";
+  let partitionExample = void 0;
+  let partitionValuesExample = void 0;
+  if (hasPartitions) {
+    const partitionDocs = partitionNames.map((name) => {
+      const partition = partitions[name];
+      const fields = Object.keys(partition.fields || {});
+      const fieldTypes = Object.entries(partition.fields || {}).map(([field, type]) => `${field}: ${type}`).join(", ");
+      return `- **${name}**: Filters by ${fields.join(", ")} (${fieldTypes})`;
+    }).join("\n");
+    partitionDescription = `Available partitions:
+${partitionDocs}`;
+    const examplePartition = partitionNames[0];
+    const exampleFields = partitions[examplePartition]?.fields || {};
+    Object.entries(exampleFields).map(([field, type]) => `"${field}": <${type} value>`).join(", ");
+    partitionValuesDescription = `Partition field values as JSON string. Must match the structure of the selected partition.
+
+Example for "${examplePartition}" partition: \`{"${Object.keys(exampleFields)[0]}": "value"}\``;
+    partitionExample = examplePartition;
+    const firstField = Object.keys(exampleFields)[0];
+    const firstFieldType = exampleFields[firstField];
+    let exampleValue = "example";
+    if (firstFieldType === "number" || firstFieldType === "integer") {
+      exampleValue = 123;
+    } else if (firstFieldType === "boolean") {
+      exampleValue = true;
+    }
+    partitionValuesExample = JSON.stringify({ [firstField]: exampleValue });
+  }
+  const attributeQueryParams = [];
+  if (hasPartitions) {
+    const partitionFieldsSet = /* @__PURE__ */ new Set();
+    for (const [partitionName, partition] of Object.entries(partitions)) {
+      const fields = partition.fields || {};
+      for (const fieldName of Object.keys(fields)) {
+        partitionFieldsSet.add(fieldName);
+      }
+    }
+    const allAttributes = resource.config?.attributes || resource.attributes || {};
+    const pluginAttrNames = resource.schema?._pluginAttributes ? Object.values(resource.schema._pluginAttributes).flat() : [];
+    const attributes = Object.fromEntries(
+      Object.entries(allAttributes).filter(([name]) => !pluginAttrNames.includes(name))
+    );
+    for (const fieldName of partitionFieldsSet) {
+      const fieldDef = attributes[fieldName];
+      if (!fieldDef) continue;
+      let fieldType;
+      if (typeof fieldDef === "object" && fieldDef.type) {
+        fieldType = fieldDef.type;
+      } else if (typeof fieldDef === "string") {
+        fieldType = fieldDef.split("|")[0].trim();
+      } else {
+        fieldType = "string";
+      }
+      const openAPIType = mapFieldTypeToOpenAPI(fieldType);
+      attributeQueryParams.push({
+        name: fieldName,
+        in: "query",
+        description: `Filter by ${fieldName} field (indexed via partitions for efficient querying). Value will be parsed as JSON if possible, otherwise treated as string.`,
+        required: false,
+        schema: openAPIType
+      });
+    }
+  }
+  if (methods.includes("GET")) {
+    paths[basePath] = {
+      get: {
+        tags: [resourceName],
+        summary: `List ${resourceName}`,
+        description: `Retrieve a paginated list of ${resourceName}. Supports filtering by passing any resource field as a query parameter (e.g., ?status=active&year=2024). Values are parsed as JSON if possible, otherwise treated as strings.
+
+**Pagination**: Use \`limit\` and \`offset\` to paginate results. For example:
+- First page (10 items): \`?limit=10&offset=0\`
+- Second page: \`?limit=10&offset=10\`
+- Third page: \`?limit=10&offset=20\`
+
+The response includes pagination metadata in the \`pagination\` object with total count and page information.${hasPartitions ? "\n\n**Partitioning**: This resource supports partitioned queries for optimized filtering. Use the `partition` and `partitionValues` parameters together." : ""}`,
+        parameters: [
+          {
+            name: "limit",
+            in: "query",
+            description: "Maximum number of items to return per page (page size)",
+            schema: { type: "integer", default: 100, minimum: 1, maximum: 1e3 },
+            example: 10
+          },
+          {
+            name: "offset",
+            in: "query",
+            description: "Number of items to skip before starting to return results. Use for pagination: offset = (page - 1) * limit",
+            schema: { type: "integer", default: 0, minimum: 0 },
+            example: 0
+          },
+          ...hasPartitions ? [
+            {
+              name: "partition",
+              in: "query",
+              description: partitionDescription,
+              schema: {
+                type: "string",
+                enum: partitionNames
+              },
+              example: partitionExample
+            },
+            {
+              name: "partitionValues",
+              in: "query",
+              description: partitionValuesDescription,
+              schema: { type: "string" },
+              example: partitionValuesExample
+            }
+          ] : [],
+          ...attributeQueryParams
+        ],
+        responses: {
+          200: {
+            description: "Successful response",
+            content: {
+              "application/json": {
+                schema: {
+                  type: "object",
+                  properties: {
+                    success: { type: "boolean", example: true },
+                    data: {
+                      type: "array",
+                      items: schema
+                    },
+                    pagination: {
+                      type: "object",
+                      description: "Pagination metadata for the current request",
+                      properties: {
+                        total: {
+                          type: "integer",
+                          description: "Total number of items available",
+                          example: 150
+                        },
+                        page: {
+                          type: "integer",
+                          description: "Current page number (1-indexed)",
+                          example: 1
+                        },
+                        pageSize: {
+                          type: "integer",
+                          description: "Number of items per page (same as limit parameter)",
+                          example: 10
+                        },
+                        pageCount: {
+                          type: "integer",
+                          description: "Total number of pages available",
+                          example: 15
+                        }
+                      }
+                    }
+                  }
+                }
+              }
+            },
+            headers: {
+              "X-Total-Count": {
+                description: "Total number of records",
+                schema: { type: "integer" }
+              },
+              "X-Page-Count": {
+                description: "Total number of pages",
+                schema: { type: "integer" }
+              }
+            }
+          }
+        },
+        security: security.length > 0 ? security : void 0
+      }
+    };
+  }
+  if (methods.includes("GET")) {
+    paths[`${basePath}/{id}`] = {
+      get: {
+        tags: [resourceName],
+        summary: `Get ${resourceName} by ID`,
+        description: `Retrieve a single ${resourceName} by its ID${hasPartitions ? ". Optionally specify a partition for more efficient retrieval." : ""}`,
+        parameters: [
+          {
+            name: "id",
+            in: "path",
+            required: true,
+            description: `${resourceName} ID`,
+            schema: { type: "string" }
+          },
+          ...hasPartitions ? [
+            {
+              name: "partition",
+              in: "query",
+              description: partitionDescription,
+              schema: {
+                type: "string",
+                enum: partitionNames
+              },
+              example: partitionExample
+            },
+            {
+              name: "partitionValues",
+              in: "query",
+              description: partitionValuesDescription,
+              schema: { type: "string" },
+              example: partitionValuesExample
+            }
+          ] : []
+        ],
+        responses: {
+          200: {
+            description: "Successful response",
+            content: {
+              "application/json": {
+                schema: {
+                  type: "object",
+                  properties: {
+                    success: { type: "boolean", example: true },
+                    data: schema
+                  }
+                }
+              }
+            }
+          },
+          404: {
+            description: "Resource not found",
+            content: {
+              "application/json": {
+                schema: { $ref: "#/components/schemas/Error" }
+              }
+            }
+          }
+        },
+        security: security.length > 0 ? security : void 0
+      }
+    };
+  }
+  if (methods.includes("POST")) {
+    if (!paths[basePath]) paths[basePath] = {};
+    paths[basePath].post = {
+      tags: [resourceName],
+      summary: `Create ${resourceName}`,
+      description: `Create a new ${resourceName}`,
+      requestBody: {
+        required: true,
+        content: {
+          "application/json": {
+            schema
+          }
+        }
+      },
+      responses: {
+        201: {
+          description: "Resource created successfully",
+          content: {
+            "application/json": {
+              schema: {
+                type: "object",
+                properties: {
+                  success: { type: "boolean", example: true },
+                  data: schema
+                }
+              }
+            }
+          },
+          headers: {
+            Location: {
+              description: "URL of the created resource",
+              schema: { type: "string" }
+            }
+          }
+        },
+        400: {
+          description: "Validation error",
+          content: {
+            "application/json": {
+              schema: { $ref: "#/components/schemas/ValidationError" }
+            }
+          }
+        }
+      },
+      security: security.length > 0 ? security : void 0
+    };
+  }
+  if (methods.includes("PUT")) {
+    if (!paths[`${basePath}/{id}`]) paths[`${basePath}/{id}`] = {};
+    paths[`${basePath}/{id}`].put = {
+      tags: [resourceName],
+      summary: `Update ${resourceName} (full)`,
+      description: `Fully update a ${resourceName}`,
+      parameters: [
+        {
+          name: "id",
+          in: "path",
+          required: true,
+          schema: { type: "string" }
+        }
+      ],
+      requestBody: {
+        required: true,
+        content: {
+          "application/json": {
+            schema
+          }
+        }
+      },
+      responses: {
+        200: {
+          description: "Resource updated successfully",
+          content: {
+            "application/json": {
+              schema: {
+                type: "object",
+                properties: {
+                  success: { type: "boolean", example: true },
+                  data: schema
+                }
+              }
+            }
+          }
+        },
+        404: {
+          description: "Resource not found",
+          content: {
+            "application/json": {
+              schema: { $ref: "#/components/schemas/Error" }
+            }
+          }
+        }
+      },
+      security: security.length > 0 ? security : void 0
+    };
+  }
+  if (methods.includes("PATCH")) {
+    if (!paths[`${basePath}/{id}`]) paths[`${basePath}/{id}`] = {};
+    paths[`${basePath}/{id}`].patch = {
+      tags: [resourceName],
+      summary: `Update ${resourceName} (partial)`,
+      description: `Partially update a ${resourceName}`,
+      parameters: [
+        {
+          name: "id",
+          in: "path",
+          required: true,
+          schema: { type: "string" }
+        }
+      ],
+      requestBody: {
+        required: true,
+        content: {
+          "application/json": {
+            schema: {
+              ...schema,
+              required: void 0
+              // Partial updates don't require all fields
+            }
+          }
+        }
+      },
+      responses: {
+        200: {
+          description: "Resource updated successfully",
+          content: {
+            "application/json": {
+              schema: {
+                type: "object",
+                properties: {
+                  success: { type: "boolean", example: true },
+                  data: schema
+                }
+              }
+            }
+          }
+        },
+        404: {
+          description: "Resource not found",
+          content: {
+            "application/json": {
+              schema: { $ref: "#/components/schemas/Error" }
+            }
+          }
+        }
+      },
+      security: security.length > 0 ? security : void 0
+    };
+  }
+  if (methods.includes("DELETE")) {
+    if (!paths[`${basePath}/{id}`]) paths[`${basePath}/{id}`] = {};
+    paths[`${basePath}/{id}`].delete = {
+      tags: [resourceName],
+      summary: `Delete ${resourceName}`,
+      description: `Delete a ${resourceName} by ID`,
+      parameters: [
+        {
+          name: "id",
+          in: "path",
+          required: true,
+          schema: { type: "string" }
+        }
+      ],
+      responses: {
+        204: {
+          description: "Resource deleted successfully"
+        },
+        404: {
+          description: "Resource not found",
+          content: {
+            "application/json": {
+              schema: { $ref: "#/components/schemas/Error" }
+            }
+          }
+        }
+      },
+      security: security.length > 0 ? security : void 0
+    };
+  }
+  if (methods.includes("HEAD")) {
+    if (!paths[basePath]) paths[basePath] = {};
+    paths[basePath].head = {
+      tags: [resourceName],
+      summary: `Get ${resourceName} statistics`,
+      description: `Get statistics about ${resourceName} collection without retrieving data. Returns statistics in response headers.`,
+      responses: {
+        200: {
+          description: "Statistics retrieved successfully",
+          headers: {
+            "X-Total-Count": {
+              description: "Total number of records",
+              schema: { type: "integer" }
+            },
+            "X-Resource-Version": {
+              description: "Current resource version",
+              schema: { type: "string" }
+            },
+            "X-Schema-Fields": {
+              description: "Number of schema fields",
+              schema: { type: "integer" }
+            }
+          }
+        }
+      },
+      security: security.length > 0 ? security : void 0
+    };
+    if (!paths[`${basePath}/{id}`]) paths[`${basePath}/{id}`] = {};
+    paths[`${basePath}/{id}`].head = {
+      tags: [resourceName],
+      summary: `Check if ${resourceName} exists`,
+      description: `Check if a ${resourceName} exists without retrieving its data`,
+      parameters: [
+        {
+          name: "id",
+          in: "path",
+          required: true,
+          schema: { type: "string" }
+        }
+      ],
+      responses: {
+        200: {
+          description: "Resource exists",
+          headers: {
+            "Last-Modified": {
+              description: "Last modification date",
+              schema: { type: "string", format: "date-time" }
+            }
+          }
+        },
+        404: {
+          description: "Resource not found"
+        }
+      },
+      security: security.length > 0 ? security : void 0
+    };
+  }
+  if (methods.includes("OPTIONS")) {
+    if (!paths[basePath]) paths[basePath] = {};
+    paths[basePath].options = {
+      tags: [resourceName],
+      summary: `Get ${resourceName} metadata`,
+      description: `Get complete metadata about ${resourceName} resource including schema, allowed methods, endpoints, and query parameters`,
+      responses: {
+        200: {
+          description: "Metadata retrieved successfully",
+          headers: {
+            "Allow": {
+              description: "Allowed HTTP methods",
+              schema: { type: "string", example: "GET, POST, PUT, PATCH, DELETE, HEAD, OPTIONS" }
+            }
+          },
+          content: {
+            "application/json": {
+              schema: {
+                type: "object",
+                properties: {
+                  resource: { type: "string" },
+                  version: { type: "string" },
+                  totalRecords: { type: "integer" },
+                  allowedMethods: {
+                    type: "array",
+                    items: { type: "string" }
+                  },
+                  schema: {
+                    type: "array",
+                    items: {
+                      type: "object",
+                      properties: {
+                        name: { type: "string" },
+                        type: { type: "string" },
+                        rules: { type: "array", items: { type: "string" } }
+                      }
+                    }
+                  },
+                  endpoints: {
+                    type: "object",
+                    properties: {
+                      list: { type: "string" },
+                      get: { type: "string" },
+                      create: { type: "string" },
+                      update: { type: "string" },
+                      delete: { type: "string" }
+                    }
+                  },
+                  queryParameters: { type: "object" }
+                }
+              }
+            }
+          }
+        }
+      }
+    };
+    if (!paths[`${basePath}/{id}`]) paths[`${basePath}/{id}`] = {};
+    paths[`${basePath}/{id}`].options = {
+      tags: [resourceName],
+      summary: `Get allowed methods for ${resourceName} item`,
+      description: `Get allowed HTTP methods for individual ${resourceName} operations`,
+      parameters: [
+        {
+          name: "id",
+          in: "path",
+          required: true,
+          schema: { type: "string" }
+        }
+      ],
+      responses: {
+        204: {
+          description: "Methods retrieved successfully",
+          headers: {
+            "Allow": {
+              description: "Allowed HTTP methods",
+              schema: { type: "string", example: "GET, PUT, PATCH, DELETE, HEAD, OPTIONS" }
+            }
+          }
+        }
+      }
+    };
+  }
+  return paths;
+}
+function generateRelationalPaths(resource, relationName, relationConfig, version, relatedSchema) {
+  const resourceName = resource.name;
+  const basePath = `/${version}/${resourceName}/{id}/${relationName}`;
+  relationConfig.resource;
+  const isToMany = relationConfig.type === "hasMany" || relationConfig.type === "belongsToMany";
+  const paths = {};
+  paths[basePath] = {
+    get: {
+      tags: [resourceName],
+      summary: `Get ${relationName} of ${resourceName}`,
+      description: `Retrieve ${relationName} (${relationConfig.type}) associated with this ${resourceName}. This endpoint uses the RelationPlugin to efficiently load related data` + (relationConfig.partitionHint ? ` via the '${relationConfig.partitionHint}' partition.` : "."),
+      parameters: [
+        {
+          name: "id",
+          in: "path",
+          required: true,
+          description: `${resourceName} ID`,
+          schema: { type: "string" }
+        },
+        ...isToMany ? [
+          {
+            name: "limit",
+            in: "query",
+            description: "Maximum number of items to return",
+            schema: { type: "integer", default: 100, minimum: 1, maximum: 1e3 }
+          },
+          {
+            name: "offset",
+            in: "query",
+            description: "Number of items to skip",
+            schema: { type: "integer", default: 0, minimum: 0 }
+          }
+        ] : []
+      ],
+      responses: {
+        200: {
+          description: "Successful response",
+          content: {
+            "application/json": {
+              schema: isToMany ? {
+                type: "object",
+                properties: {
+                  success: { type: "boolean", example: true },
+                  data: {
+                    type: "array",
+                    items: relatedSchema
+                  },
+                  pagination: {
+                    type: "object",
+                    properties: {
+                      total: { type: "integer" },
+                      page: { type: "integer" },
+                      pageSize: { type: "integer" },
+                      pageCount: { type: "integer" }
+                    }
+                  }
+                }
+              } : {
+                type: "object",
+                properties: {
+                  success: { type: "boolean", example: true },
+                  data: relatedSchema
+                }
+              }
+            }
+          },
+          ...isToMany ? {
+            headers: {
+              "X-Total-Count": {
+                description: "Total number of related records",
+                schema: { type: "integer" }
+              },
+              "X-Page-Count": {
+                description: "Total number of pages",
+                schema: { type: "integer" }
+              }
+            }
+          } : {}
+        },
+        404: {
+          description: `${resourceName} not found` + (isToMany ? "" : " or no related resource exists"),
+          content: {
+            "application/json": {
+              schema: { $ref: "#/components/schemas/Error" }
+            }
+          }
+        }
+      }
+    }
+  };
+  return paths;
+}
+function generateOpenAPISpec(database, config = {}) {
+  const {
+    title = "s3db.js API",
+    version = "1.0.0",
+    description = "Auto-generated REST API documentation for s3db.js resources",
+    serverUrl = "http://localhost:3000",
+    auth = {},
+    resources: resourceConfigs = {}
+  } = config;
+  const resourcesTableRows = [];
+  for (const [name, resource] of Object.entries(database.resources)) {
+    if (name.startsWith("plg_") && !resourceConfigs[name]) {
+      continue;
+    }
+    const version2 = resource.config?.currentVersion || resource.version || "v1";
+    const resourceDescription = resource.config?.description;
+    const descText = typeof resourceDescription === "object" ? resourceDescription.resource : resourceDescription || "No description";
+    resourcesTableRows.push(`| ${name} | ${descText} | \`/${version2}/${name}\` |`);
+  }
+  const enhancedDescription = `${description}
+
+## Available Resources
+
+| Resource | Description | Base Path |
+|----------|-------------|-----------|
+${resourcesTableRows.join("\n")}
+
+---
+
+For detailed information about each endpoint, see the sections below.`;
+  const spec = {
+    openapi: "3.1.0",
+    info: {
+      title,
+      version,
+      description: enhancedDescription,
+      contact: {
+        name: "s3db.js",
+        url: "https://github.com/forattini-dev/s3db.js"
+      }
+    },
+    servers: [
+      {
+        url: serverUrl,
+        description: "API Server"
+      }
+    ],
+    paths: {},
+    components: {
+      schemas: {
+        Error: {
+          type: "object",
+          properties: {
+            success: { type: "boolean", example: false },
+            error: {
+              type: "object",
+              properties: {
+                message: { type: "string" },
+                code: { type: "string" },
+                details: { type: "object" }
+              }
+            }
+          }
+        },
+        ValidationError: {
+          type: "object",
+          properties: {
+            success: { type: "boolean", example: false },
+            error: {
+              type: "object",
+              properties: {
+                message: { type: "string", example: "Validation failed" },
+                code: { type: "string", example: "VALIDATION_ERROR" },
+                details: {
+                  type: "object",
+                  properties: {
+                    errors: {
+                      type: "array",
+                      items: {
+                        type: "object",
+                        properties: {
+                          field: { type: "string" },
+                          message: { type: "string" },
+                          expected: { type: "string" },
+                          actual: {}
+                        }
+                      }
+                    }
+                  }
+                }
+              }
+            }
+          }
+        }
+      },
+      securitySchemes: {}
+    },
+    tags: []
+  };
+  if (auth.jwt?.enabled) {
+    spec.components.securitySchemes.bearerAuth = {
+      type: "http",
+      scheme: "bearer",
+      bearerFormat: "JWT",
+      description: "JWT authentication"
+    };
+  }
+  if (auth.apiKey?.enabled) {
+    spec.components.securitySchemes.apiKeyAuth = {
+      type: "apiKey",
+      in: "header",
+      name: auth.apiKey.headerName || "X-API-Key",
+      description: "API Key authentication"
+    };
+  }
+  if (auth.basic?.enabled) {
+    spec.components.securitySchemes.basicAuth = {
+      type: "http",
+      scheme: "basic",
+      description: "HTTP Basic authentication"
+    };
+  }
+  const resources = database.resources;
+  const relationsPlugin = database.plugins?.relation || database.plugins?.RelationPlugin || null;
+  for (const [name, resource] of Object.entries(resources)) {
+    if (name.startsWith("plg_") && !resourceConfigs[name]) {
+      continue;
+    }
+    const config2 = resourceConfigs[name] || {
+      methods: ["GET", "POST", "PUT", "PATCH", "DELETE"],
+      auth: false
+    };
+    const version2 = resource.config?.currentVersion || resource.version || "v1";
+    const paths = generateResourcePaths(resource, version2, config2);
+    Object.assign(spec.paths, paths);
+    const resourceDescription = resource.config?.description;
+    const tagDescription = typeof resourceDescription === "object" ? resourceDescription.resource : resourceDescription || `Operations for ${name} resource`;
+    spec.tags.push({
+      name,
+      description: tagDescription
+    });
+    spec.components.schemas[name] = generateResourceSchema(resource);
+    if (relationsPlugin && relationsPlugin.relations && relationsPlugin.relations[name]) {
+      const relationsDef = relationsPlugin.relations[name];
+      for (const [relationName, relationConfig] of Object.entries(relationsDef)) {
+        if (relationConfig.type === "belongsTo") {
+          continue;
+        }
+        const exposeRelation = config2?.relations?.[relationName]?.expose !== false;
+        if (!exposeRelation) {
+          continue;
+        }
+        const relatedResource = database.resources[relationConfig.resource];
+        if (!relatedResource) {
+          continue;
+        }
+        const relatedSchema = generateResourceSchema(relatedResource);
+        const relationalPaths = generateRelationalPaths(
+          resource,
+          relationName,
+          relationConfig,
+          version2,
+          relatedSchema
+        );
+        Object.assign(spec.paths, relationalPaths);
+      }
+    }
+  }
+  if (auth.jwt?.enabled || auth.apiKey?.enabled || auth.basic?.enabled) {
+    spec.paths["/auth/login"] = {
+      post: {
+        tags: ["Authentication"],
+        summary: "Login",
+        description: "Authenticate with username and password",
+        requestBody: {
+          required: true,
+          content: {
+            "application/json": {
+              schema: {
+                type: "object",
+                properties: {
+                  username: { type: "string" },
+                  password: { type: "string", format: "password" }
+                },
+                required: ["username", "password"]
+              }
+            }
+          }
+        },
+        responses: {
+          200: {
+            description: "Login successful",
+            content: {
+              "application/json": {
+                schema: {
+                  type: "object",
+                  properties: {
+                    success: { type: "boolean", example: true },
+                    data: {
+                      type: "object",
+                      properties: {
+                        token: { type: "string" },
+                        user: { type: "object" }
+                      }
+                    }
+                  }
+                }
+              }
+            }
+          },
+          401: {
+            description: "Invalid credentials",
+            content: {
+              "application/json": {
+                schema: { $ref: "#/components/schemas/Error" }
+              }
+            }
+          }
+        }
+      }
+    };
+    spec.paths["/auth/register"] = {
+      post: {
+        tags: ["Authentication"],
+        summary: "Register",
+        description: "Register a new user",
+        requestBody: {
+          required: true,
+          content: {
+            "application/json": {
+              schema: {
+                type: "object",
+                properties: {
+                  username: { type: "string", minLength: 3 },
+                  password: { type: "string", format: "password", minLength: 8 },
+                  email: { type: "string", format: "email" }
+                },
+                required: ["username", "password"]
+              }
+            }
+          }
+        },
+        responses: {
+          201: {
+            description: "User registered successfully",
+            content: {
+              "application/json": {
+                schema: {
+                  type: "object",
+                  properties: {
+                    success: { type: "boolean", example: true },
+                    data: {
+                      type: "object",
+                      properties: {
+                        token: { type: "string" },
+                        user: { type: "object" }
+                      }
+                    }
+                  }
+                }
+              }
+            }
+          }
+        }
+      }
+    };
+    spec.tags.push({
+      name: "Authentication",
+      description: "Authentication endpoints"
+    });
+  }
+  spec.paths["/health"] = {
+    get: {
+      tags: ["Health"],
+      summary: "Generic Health Check",
+      description: "Generic health check endpoint that includes references to liveness and readiness probes",
+      responses: {
+        200: {
+          description: "API is healthy",
+          content: {
+            "application/json": {
+              schema: {
+                type: "object",
+                properties: {
+                  success: { type: "boolean", example: true },
+                  data: {
+                    type: "object",
+                    properties: {
+                      status: { type: "string", example: "ok" },
+                      uptime: { type: "number", description: "Process uptime in seconds" },
+                      timestamp: { type: "string", format: "date-time" },
+                      checks: {
+                        type: "object",
+                        properties: {
+                          liveness: { type: "string", example: "/health/live" },
+                          readiness: { type: "string", example: "/health/ready" }
+                        }
+                      }
+                    }
+                  }
+                }
+              }
+            }
+          }
+        }
+      }
+    }
+  };
+  spec.paths["/health/live"] = {
+    get: {
+      tags: ["Health"],
+      summary: "Liveness Probe",
+      description: "Kubernetes liveness probe - checks if the application is alive. If this fails, Kubernetes will restart the pod.",
+      responses: {
+        200: {
+          description: "Application is alive",
+          content: {
+            "application/json": {
+              schema: {
+                type: "object",
+                properties: {
+                  success: { type: "boolean", example: true },
+                  data: {
+                    type: "object",
+                    properties: {
+                      status: { type: "string", example: "alive" },
+                      timestamp: { type: "string", format: "date-time" }
+                    }
+                  }
+                }
+              }
+            }
+          }
+        }
+      }
+    }
+  };
+  spec.paths["/health/ready"] = {
+    get: {
+      tags: ["Health"],
+      summary: "Readiness Probe",
+      description: "Kubernetes readiness probe - checks if the application is ready to receive traffic. If this fails, Kubernetes will remove the pod from service endpoints.",
+      responses: {
+        200: {
+          description: "Application is ready to receive traffic",
+          content: {
+            "application/json": {
+              schema: {
+                type: "object",
+                properties: {
+                  success: { type: "boolean", example: true },
+                  data: {
+                    type: "object",
+                    properties: {
+                      status: { type: "string", example: "ready" },
+                      database: {
+                        type: "object",
+                        properties: {
+                          connected: { type: "boolean", example: true },
+                          resources: { type: "integer", example: 5 }
+                        }
+                      },
+                      timestamp: { type: "string", format: "date-time" }
+                    }
+                  }
+                }
+              }
+            }
+          }
+        },
+        503: {
+          description: "Application is not ready",
+          content: {
+            "application/json": {
+              schema: {
+                type: "object",
+                properties: {
+                  success: { type: "boolean", example: false },
+                  error: {
+                    type: "object",
+                    properties: {
+                      message: { type: "string", example: "Service not ready" },
+                      code: { type: "string", example: "NOT_READY" },
+                      details: {
+                        type: "object",
+                        properties: {
+                          database: {
+                            type: "object",
+                            properties: {
+                              connected: { type: "boolean", example: false },
+                              resources: { type: "integer", example: 0 }
+                            }
+                          }
+                        }
+                      }
+                    }
+                  }
+                }
+              }
+            }
+          }
+        }
+      }
+    }
+  };
+  spec.tags.push({
+    name: "Health",
+    description: "Health check endpoints for monitoring and Kubernetes probes"
+  });
+  const metricsPlugin = database.plugins?.metrics || database.plugins?.MetricsPlugin;
+  if (metricsPlugin && metricsPlugin.config?.prometheus?.enabled) {
+    const metricsPath = metricsPlugin.config.prometheus.path || "/metrics";
+    const isIntegrated = metricsPlugin.config.prometheus.mode !== "standalone";
+    if (isIntegrated) {
+      spec.paths[metricsPath] = {
+        get: {
+          tags: ["Monitoring"],
+          summary: "Prometheus Metrics",
+          description: "Exposes application metrics in Prometheus text-based exposition format for monitoring and observability. Metrics include operation counts, durations, errors, uptime, and resource statistics.",
+          responses: {
+            200: {
+              description: "Metrics in Prometheus format",
+              content: {
+                "text/plain": {
+                  schema: {
+                    type: "string",
+                    example: '# HELP s3db_operations_total Total number of operations by type and resource\n# TYPE s3db_operations_total counter\ns3db_operations_total{operation="insert",resource="cars"} 1523\ns3db_operations_total{operation="update",resource="cars"} 342\n\n# HELP s3db_operation_duration_seconds Average operation duration in seconds\n# TYPE s3db_operation_duration_seconds gauge\ns3db_operation_duration_seconds{operation="insert",resource="cars"} 0.045\n\n# HELP s3db_operation_errors_total Total number of operation errors\n# TYPE s3db_operation_errors_total counter\ns3db_operation_errors_total{operation="insert",resource="cars"} 12\n'
+                  }
+                }
+              }
+            }
+          }
+        }
+      };
+      spec.tags.push({
+        name: "Monitoring",
+        description: "Monitoring and observability endpoints (Prometheus)"
+      });
+    }
+  }
+  return spec;
+}
+
+class ApiServer {
+  /**
+   * Create API server
+   * @param {Object} options - Server options
+   * @param {number} options.port - Server port
+   * @param {string} options.host - Server host
+   * @param {Object} options.database - s3db.js database instance
+   * @param {Object} options.resources - Resource configuration
+   * @param {Array} options.middlewares - Global middlewares
+   */
+  constructor(options = {}) {
+    this.options = {
+      port: options.port || 3e3,
+      host: options.host || "0.0.0.0",
+      database: options.database,
+      resources: options.resources || {},
+      middlewares: options.middlewares || [],
+      verbose: options.verbose || false,
+      auth: options.auth || {},
+      docsEnabled: options.docsEnabled !== false,
+      // Enable /docs by default
+      docsUI: options.docsUI || "redoc",
+      // 'swagger' or 'redoc'
+      maxBodySize: options.maxBodySize || 10 * 1024 * 1024,
+      // 10MB default
+      rootHandler: options.rootHandler,
+      // Custom handler for root path, if not provided redirects to /docs
+      apiInfo: {
+        title: options.apiTitle || "s3db.js API",
+        version: options.apiVersion || "1.0.0",
+        description: options.apiDescription || "Auto-generated REST API for s3db.js resources"
+      }
+    };
+    this.app = null;
+    this.server = null;
+    this.isRunning = false;
+    this.openAPISpec = null;
+    this.initialized = false;
+    this.relationsPlugin = this.options.database?.plugins?.relation || this.options.database?.plugins?.RelationPlugin || null;
+  }
+  /**
+   * Setup all routes
+   * @private
+   */
+  _setupRoutes() {
+    this.options.middlewares.forEach((middleware) => {
+      this.app.use("*", middleware);
+    });
+    this.app.use("*", async (c, next) => {
+      const method = c.req.method;
+      if (["POST", "PUT", "PATCH"].includes(method)) {
+        const contentLength = c.req.header("content-length");
+        if (contentLength) {
+          const size = parseInt(contentLength);
+          if (size > this.options.maxBodySize) {
+            const response = payloadTooLarge(size, this.options.maxBodySize);
+            c.header("Connection", "close");
+            return c.json(response, response._status);
+          }
+        }
+      }
+      await next();
+    });
+    this.app.get("/health/live", (c) => {
+      const response = success({
+        status: "alive",
+        timestamp: (/* @__PURE__ */ new Date()).toISOString()
+      });
+      return c.json(response);
+    });
+    this.app.get("/health/ready", (c) => {
+      const isReady = this.options.database && this.options.database.connected && Object.keys(this.options.database.resources).length > 0;
+      if (!isReady) {
+        const response2 = error("Service not ready", {
+          status: 503,
+          code: "NOT_READY",
+          details: {
+            database: {
+              connected: this.options.database?.connected || false,
+              resources: Object.keys(this.options.database?.resources || {}).length
+            }
+          }
+        });
+        return c.json(response2, 503);
+      }
+      const response = success({
+        status: "ready",
+        database: {
+          connected: true,
+          resources: Object.keys(this.options.database.resources).length
+        },
+        timestamp: (/* @__PURE__ */ new Date()).toISOString()
+      });
+      return c.json(response);
+    });
+    this.app.get("/health", (c) => {
+      const response = success({
+        status: "ok",
+        uptime: process.uptime(),
+        timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+        checks: {
+          liveness: "/health/live",
+          readiness: "/health/ready"
+        }
+      });
+      return c.json(response);
+    });
+    this.app.get("/", (c) => {
+      if (this.options.rootHandler) {
+        return this.options.rootHandler(c);
+      }
+      return c.redirect("/docs", 302);
+    });
+    if (this.options.docsEnabled) {
+      this.app.get("/openapi.json", (c) => {
+        if (!this.openAPISpec) {
+          this.openAPISpec = this._generateOpenAPISpec();
+        }
+        return c.json(this.openAPISpec);
+      });
+      if (this.options.docsUI === "swagger") {
+        this.app.get("/docs", this.swaggerUI({
+          url: "/openapi.json"
+        }));
+      } else {
+        this.app.get("/docs", (c) => {
+          return c.html(`<!DOCTYPE html>
+<html lang="en">
+<head>
+  <meta charset="UTF-8">
+  <meta name="viewport" content="width=device-width, initial-scale=1.0">
+  <title>${this.options.apiInfo.title} - API Documentation</title>
+  <style>
+    body {
+      margin: 0;
+      padding: 0;
+    }
+  </style>
+</head>
+<body>
+  <redoc spec-url="/openapi.json"></redoc>
+  <script src="https://cdn.redoc.ly/redoc/v2.5.1/bundles/redoc.standalone.js"><\/script>
+</body>
+</html>`);
+        });
+      }
+    }
+    this._setupResourceRoutes();
+    if (this.relationsPlugin) {
+      this._setupRelationalRoutes();
+    }
+    this.app.onError((err, c) => {
+      return errorHandler(err, c);
+    });
+    this.app.notFound((c) => {
+      const response = error("Route not found", {
+        status: 404,
+        code: "NOT_FOUND",
+        details: {
+          path: c.req.path,
+          method: c.req.method
+        }
+      });
+      return c.json(response, 404);
+    });
+  }
+  /**
+   * Setup routes for all resources
+   * @private
+   */
+  _setupResourceRoutes() {
+    const { database, resources: resourceConfigs } = this.options;
+    const resources = database.resources;
+    for (const [name, resource] of Object.entries(resources)) {
+      if (name.startsWith("plg_") && !resourceConfigs[name]) {
+        continue;
+      }
+      const config = resourceConfigs[name] || {
+        methods: ["GET", "POST", "PUT", "PATCH", "DELETE", "HEAD", "OPTIONS"]};
+      const version = resource.config?.currentVersion || resource.version || "v1";
+      const resourceApp = createResourceRoutes(resource, version, {
+        methods: config.methods,
+        customMiddleware: config.customMiddleware || [],
+        enableValidation: config.validation !== false
+      }, this.Hono);
+      this.app.route(`/${version}/${name}`, resourceApp);
+      if (this.options.verbose) {
+        console.log(`[API Plugin] Mounted routes for resource '${name}' at /${version}/${name}`);
+      }
+    }
+  }
+  /**
+   * Setup relational routes (when RelationPlugin is active)
+   * @private
+   */
+  _setupRelationalRoutes() {
+    if (!this.relationsPlugin || !this.relationsPlugin.relations) {
+      return;
+    }
+    const { database } = this.options;
+    const relations = this.relationsPlugin.relations;
+    if (this.options.verbose) {
+      console.log("[API Plugin] Setting up relational routes...");
+    }
+    for (const [resourceName, relationsDef] of Object.entries(relations)) {
+      const resource = database.resources[resourceName];
+      if (!resource) {
+        if (this.options.verbose) {
+          console.warn(`[API Plugin] Resource '${resourceName}' not found for relational routes`);
+        }
+        continue;
+      }
+      if (resourceName.startsWith("plg_") && !this.options.resources[resourceName]) {
+        continue;
+      }
+      const version = resource.config?.currentVersion || resource.version || "v1";
+      for (const [relationName, relationConfig] of Object.entries(relationsDef)) {
+        if (relationConfig.type === "belongsTo") {
+          continue;
+        }
+        const resourceConfig = this.options.resources[resourceName];
+        const exposeRelation = resourceConfig?.relations?.[relationName]?.expose !== false;
+        if (!exposeRelation) {
+          continue;
+        }
+        const relationalApp = createRelationalRoutes(
+          resource,
+          relationName,
+          relationConfig,
+          version,
+          this.Hono
+        );
+        this.app.route(`/${version}/${resourceName}/:id/${relationName}`, relationalApp);
+        if (this.options.verbose) {
+          console.log(
+            `[API Plugin] Mounted relational route: /${version}/${resourceName}/:id/${relationName} (${relationConfig.type} -> ${relationConfig.resource})`
+          );
+        }
+      }
+    }
+  }
+  /**
+   * Start the server
+   * @returns {Promise<void>}
+   */
+  async start() {
+    if (this.isRunning) {
+      console.warn("[API Plugin] Server is already running");
+      return;
+    }
+    if (!this.initialized) {
+      const { Hono } = await import('hono');
+      const { serve } = await import('@hono/node-server');
+      const { swaggerUI } = await import('@hono/swagger-ui');
+      this.Hono = Hono;
+      this.serve = serve;
+      this.swaggerUI = swaggerUI;
+      this.app = new Hono();
+      this._setupRoutes();
+      this.initialized = true;
+    }
+    const { port, host } = this.options;
+    return new Promise((resolve, reject) => {
+      try {
+        this.server = this.serve({
+          fetch: this.app.fetch,
+          port,
+          hostname: host
+        }, (info) => {
+          this.isRunning = true;
+          console.log(`[API Plugin] Server listening on http://${info.address}:${info.port}`);
+          resolve();
+        });
+      } catch (err) {
+        reject(err);
+      }
+    });
+  }
+  /**
+   * Stop the server
+   * @returns {Promise<void>}
+   */
+  async stop() {
+    if (!this.isRunning) {
+      console.warn("[API Plugin] Server is not running");
+      return;
+    }
+    if (this.server && typeof this.server.close === "function") {
+      await new Promise((resolve) => {
+        this.server.close(() => {
+          this.isRunning = false;
+          console.log("[API Plugin] Server stopped");
+          resolve();
+        });
+      });
+    } else {
+      this.isRunning = false;
+      console.log("[API Plugin] Server stopped");
+    }
+  }
+  /**
+   * Get server info
+   * @returns {Object} Server information
+   */
+  getInfo() {
+    return {
+      isRunning: this.isRunning,
+      port: this.options.port,
+      host: this.options.host,
+      resources: Object.keys(this.options.database.resources).length
+    };
+  }
+  /**
+   * Get Hono app instance
+   * @returns {Hono} Hono app
+   */
+  getApp() {
+    return this.app;
+  }
+  /**
+   * Generate OpenAPI specification
+   * @private
+   * @returns {Object} OpenAPI spec
+   */
+  _generateOpenAPISpec() {
+    const { port, host, database, resources, auth, apiInfo } = this.options;
+    return generateOpenAPISpec(database, {
+      title: apiInfo.title,
+      version: apiInfo.version,
+      description: apiInfo.description,
+      serverUrl: `http://${host === "0.0.0.0" ? "localhost" : host}:${port}`,
+      auth,
+      resources
+    });
+  }
+}
+
 class ApiPlugin extends Plugin {
   /**
    * Create API Plugin instance
@@ -3002,11 +5045,6 @@ class ApiPlugin extends Plugin {
     if (this.config.verbose) {
       console.log("[API Plugin] Starting server...");
     }
-    const serverPath = "./server.js";
-    const { ApiServer } = await import(
-      /* @vite-ignore */
-      serverPath
-    );
     this.server = new ApiServer({
       port: this.config.port,
       host: this.config.host,
@@ -4567,7 +6605,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()
     });
@@ -4615,7 +6653,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 mkdir(tempBackupDir, { recursive: true });
@@ -4648,7 +6686,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,
@@ -4676,7 +6714,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);
@@ -4897,7 +6935,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`);
@@ -4920,7 +6958,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
         });
@@ -4935,7 +6973,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;
     }
   }
@@ -5185,7 +7223,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) {
@@ -6709,7 +8747,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,
@@ -6727,7 +8765,7 @@ class CachePlugin extends Plugin {
             const partitionKeyPrefix = 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
@@ -6742,7 +8780,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
@@ -10642,7 +12680,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)
     });
@@ -11209,7 +13247,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();
@@ -13204,10 +15242,17 @@ class MLPlugin extends Plugin {
     this.config = {
       models: options.models || {},
       verbose: options.verbose || false,
-      minTrainingSamples: options.minTrainingSamples || 10
+      minTrainingSamples: options.minTrainingSamples || 10,
+      saveModel: options.saveModel !== false,
+      // Default true
+      saveTrainingData: options.saveTrainingData || false,
+      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();
     this.training = /* @__PURE__ */ new Map();
     this.insertCounters = /* @__PURE__ */ new Map();
     this.intervals = [];
@@ -13231,6 +15276,8 @@ class MLPlugin extends Plugin {
     for (const [modelName, modelConfig] of Object.entries(this.config.models)) {
       await this._initializeModel(modelName, modelConfig);
     }
+    this._buildModelCache();
+    this._injectResourceMethods();
     for (const [modelName, modelConfig] of Object.entries(this.config.models)) {
       if (modelConfig.autoTrain) {
         this._setupAutoTraining(modelName, modelConfig);
@@ -13240,7 +15287,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)
     });
@@ -13249,6 +15296,11 @@ class MLPlugin extends Plugin {
    * Start the plugin
    */
   async onStart() {
+    if (this.config.enableVersioning) {
+      for (const modelName of Object.keys(this.models)) {
+        await this._initializeVersioning(modelName);
+      }
+    }
     for (const modelName of Object.keys(this.models)) {
       await this._loadModel(modelName);
     }
@@ -13281,12 +15333,135 @@ class MLPlugin extends Plugin {
     if (options.purgeData) {
       for (const modelName of Object.keys(this.models)) {
         await this._deleteModel(modelName);
+        await this._deleteTrainingData(modelName);
+      }
+      if (this.config.verbose) {
+        console.log("[MLPlugin] Purged all model data and training data");
       }
+    }
+  }
+  /**
+   * Build model cache for fast lookup
+   * @private
+   */
+  _buildModelCache() {
+    for (const [modelName, modelConfig] of Object.entries(this.config.models)) {
+      const cacheKey = `${modelConfig.resource}_${modelConfig.target}`;
+      this.modelCache.set(cacheKey, modelName);
       if (this.config.verbose) {
-        console.log("[MLPlugin] Purged all model data");
+        console.log(`[MLPlugin] Cached model "${modelName}" for ${modelConfig.resource}.predict(..., '${modelConfig.target}')`);
       }
     }
   }
+  /**
+   * Inject ML methods into Resource instances
+   * @private
+   */
+  _injectResourceMethods() {
+    if (!this.database._mlPlugin) {
+      this.database._mlPlugin = this;
+    }
+    if (!this.database.Resource.prototype.predict) {
+      this.database.Resource.prototype.predict = async function(input, targetAttribute) {
+        const mlPlugin = this.database._mlPlugin;
+        if (!mlPlugin) {
+          throw new Error("MLPlugin not installed");
+        }
+        return await mlPlugin._resourcePredict(this.name, input, targetAttribute);
+      };
+    }
+    if (!this.database.Resource.prototype.trainModel) {
+      this.database.Resource.prototype.trainModel = async function(targetAttribute, options = {}) {
+        const mlPlugin = this.database._mlPlugin;
+        if (!mlPlugin) {
+          throw new Error("MLPlugin not installed");
+        }
+        return await mlPlugin._resourceTrainModel(this.name, targetAttribute, options);
+      };
+    }
+    if (!this.database.Resource.prototype.listModels) {
+      this.database.Resource.prototype.listModels = function() {
+        const mlPlugin = this.database._mlPlugin;
+        if (!mlPlugin) {
+          throw new Error("MLPlugin not installed");
+        }
+        return mlPlugin._resourceListModels(this.name);
+      };
+    }
+    if (this.config.verbose) {
+      console.log("[MLPlugin] Injected ML methods into Resource prototype");
+    }
+  }
+  /**
+   * Find model for a resource and target attribute
+   * @private
+   */
+  _findModelForResource(resourceName, targetAttribute) {
+    const cacheKey = `${resourceName}_${targetAttribute}`;
+    if (this.modelCache.has(cacheKey)) {
+      return this.modelCache.get(cacheKey);
+    }
+    for (const [modelName, modelConfig] of Object.entries(this.config.models)) {
+      if (modelConfig.resource === resourceName && modelConfig.target === targetAttribute) {
+        this.modelCache.set(cacheKey, modelName);
+        return modelName;
+      }
+    }
+    return null;
+  }
+  /**
+   * Resource predict implementation
+   * @private
+   */
+  async _resourcePredict(resourceName, input, targetAttribute) {
+    const modelName = this._findModelForResource(resourceName, targetAttribute);
+    if (!modelName) {
+      throw new ModelNotFoundError(
+        `No model found for resource "${resourceName}" with target "${targetAttribute}"`,
+        { resourceName, targetAttribute, availableModels: Object.keys(this.models) }
+      );
+    }
+    if (this.config.verbose) {
+      console.log(`[MLPlugin] Resource prediction: ${resourceName}.predict(..., '${targetAttribute}') -> model "${modelName}"`);
+    }
+    return await this.predict(modelName, input);
+  }
+  /**
+   * Resource trainModel implementation
+   * @private
+   */
+  async _resourceTrainModel(resourceName, targetAttribute, options = {}) {
+    const modelName = this._findModelForResource(resourceName, targetAttribute);
+    if (!modelName) {
+      throw new ModelNotFoundError(
+        `No model found for resource "${resourceName}" with target "${targetAttribute}"`,
+        { resourceName, targetAttribute, availableModels: Object.keys(this.models) }
+      );
+    }
+    if (this.config.verbose) {
+      console.log(`[MLPlugin] Resource training: ${resourceName}.trainModel('${targetAttribute}') -> model "${modelName}"`);
+    }
+    return await this.train(modelName, options);
+  }
+  /**
+   * List models for a resource
+   * @private
+   */
+  _resourceListModels(resourceName) {
+    const models = [];
+    for (const [modelName, modelConfig] of Object.entries(this.config.models)) {
+      if (modelConfig.resource === resourceName) {
+        models.push({
+          name: modelName,
+          type: modelConfig.type,
+          target: modelConfig.target,
+          features: modelConfig.features,
+          isTrained: this.models[modelName]?.isTrained || false
+        });
+      }
+    }
+    return models;
+  }
   /**
    * Validate model configuration
    * @private
@@ -13437,12 +15612,47 @@ class MLPlugin extends Plugin {
       if (this.config.verbose) {
         console.log(`[MLPlugin] Fetching training data for "${modelName}"...`);
       }
-      const [ok, err, data] = await tryFn(() => resource.list());
-      if (!ok) {
-        throw new TrainingError(
-          `Failed to fetch training data: ${err.message}`,
-          { modelName, resource: modelConfig.resource, originalError: err.message }
+      let data;
+      const partition = modelConfig.partition;
+      if (partition && partition.name) {
+        if (this.config.verbose) {
+          console.log(`[MLPlugin] Using partition "${partition.name}" with values:`, partition.values);
+        }
+        const [ok, err, partitionData] = await tryFn(
+          () => resource.listPartition(partition.name, partition.values)
         );
+        if (!ok) {
+          throw new TrainingError(
+            `Failed to fetch training data from partition: ${err.message}`,
+            { modelName, resource: modelConfig.resource, partition: partition.name, originalError: err.message }
+          );
+        }
+        data = partitionData;
+      } else {
+        const [ok, err, allData] = await tryFn(() => resource.list());
+        if (!ok) {
+          throw new TrainingError(
+            `Failed to fetch training data: ${err.message}`,
+            { modelName, resource: modelConfig.resource, originalError: err.message }
+          );
+        }
+        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(
@@ -13453,13 +15663,20 @@ class MLPlugin extends Plugin {
       if (this.config.verbose) {
         console.log(`[MLPlugin] Training "${modelName}" with ${data.length} samples...`);
       }
+      const shouldSaveTrainingData = modelConfig.saveTrainingData !== void 0 ? modelConfig.saveTrainingData : this.config.saveTrainingData;
+      if (shouldSaveTrainingData) {
+        await this._saveTrainingData(modelName, data);
+      }
       const result = await model.train(data);
-      await this._saveModel(modelName);
+      const shouldSaveModel = modelConfig.saveModel !== void 0 ? modelConfig.saveModel : this.config.saveModel;
+      if (shouldSaveModel) {
+        await this._saveModel(modelName);
+      }
       this.stats.totalTrainings++;
       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
@@ -13495,7 +15712,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
@@ -13603,6 +15820,79 @@ class MLPlugin extends Plugin {
       console.log(`[MLPlugin] Imported model "${modelName}"`);
     }
   }
+  /**
+   * Initialize versioning for a model
+   * @private
+   */
+  async _initializeVersioning(modelName) {
+    try {
+      const storage = this.getStorage();
+      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,
+          latestVersion: versionInfo.latestVersion || 1
+        });
+        if (this.config.verbose) {
+          console.log(`[MLPlugin] Loaded version info for "${modelName}": v${versionInfo.currentVersion}`);
+        }
+      } else {
+        this.modelVersions.set(modelName, {
+          currentVersion: 1,
+          latestVersion: 0
+          // No versions yet
+        });
+        if (this.config.verbose) {
+          console.log(`[MLPlugin] Initialized versioning for "${modelName}"`);
+        }
+      }
+    } catch (error) {
+      console.error(`[MLPlugin] Failed to initialize versioning for "${modelName}":`, error.message);
+      this.modelVersions.set(modelName, { currentVersion: 1, latestVersion: 0 });
+    }
+  }
+  /**
+   * Get next version number for a model
+   * @private
+   */
+  _getNextVersion(modelName) {
+    const versionInfo = this.modelVersions.get(modelName) || { latestVersion: 0 };
+    return versionInfo.latestVersion + 1;
+  }
+  /**
+   * Update version info in storage
+   * @private
+   */
+  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.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}`);
+      }
+    } catch (error) {
+      console.error(`[MLPlugin] Failed to update version info for "${modelName}":`, error.message);
+    }
+  }
   /**
    * Save model to plugin storage
    * @private
@@ -13610,6 +15900,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) {
@@ -13617,18 +15909,177 @@ class MLPlugin extends Plugin {
         }
         return;
       }
-      await storage.patch(`model_${modelName}`, {
-        modelName,
-        data: JSON.stringify(exportedModel),
-        savedAt: (/* @__PURE__ */ new Date()).toISOString()
-      });
-      if (this.config.verbose) {
-        console.log(`[MLPlugin] Saved model "${modelName}" to plugin storage`);
+      const enableVersioning = this.config.enableVersioning;
+      if (enableVersioning) {
+        const version = this._getNextVersion(modelName);
+        const modelStats = this.models[modelName].getStats();
+        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.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 S3 (resource=${resourceName}/plugin=ml/models/${modelName}/v${version})`);
+        }
+      } else {
+        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 S3 (resource=${resourceName}/plugin=ml/models/${modelName}/latest)`);
+        }
       }
     } catch (error) {
       console.error(`[MLPlugin] Failed to save model "${modelName}":`, error.message);
     }
   }
+  /**
+   * Save intermediate training data to plugin storage (incremental - only new samples)
+   * @private
+   */
+  async _saveTrainingData(modelName, rawData) {
+    try {
+      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 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 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) {
+          history = existing.history;
+          history.forEach((entry) => {
+            if (entry.sampleIds) {
+              entry.sampleIds.forEach((id) => previousSampleIds.add(id));
+            }
+          });
+        }
+        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] 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.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}" (${processedData.length} samples) to S3 (resource=${resourceName}/plugin=ml/training/data/${modelName}/latest)`);
+        }
+      }
+    } catch (error) {
+      console.error(`[MLPlugin] Failed to save training data for "${modelName}":`, error.message);
+    }
+  }
   /**
    * Load model from plugin storage
    * @private
@@ -13636,32 +16087,155 @@ class MLPlugin extends Plugin {
   async _loadModel(modelName) {
     try {
       const storage = this.getStorage();
-      const [ok, err, record] = await tryFn(() => storage.get(`model_${modelName}`));
-      if (!ok || !record) {
+      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(storage.getPluginKey(resourceName, "metadata", modelName, "active"))
+        );
+        if (okRef && activeRef && activeRef.version) {
+          const version = activeRef.version;
+          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 S3 (resource=${resourceName}/plugin=ml/models/${modelName}/v${version})`);
+            }
+            return;
+          }
+        }
+        const versionInfo = this.modelVersions.get(modelName);
+        if (versionInfo && versionInfo.latestVersion > 0) {
+          const version = versionInfo.latestVersion;
+          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 S3`);
+            }
+            return;
+          }
+        }
         if (this.config.verbose) {
-          console.log(`[MLPlugin] No saved model found for "${modelName}"`);
+          console.log(`[MLPlugin] No saved model versions found for "${modelName}"`);
+        }
+      } else {
+        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;
+        }
+        await this.models[modelName].import(record.modelData);
+        if (this.config.verbose) {
+          console.log(`[MLPlugin] Loaded model "${modelName}" from S3 (resource=${resourceName}/plugin=ml/models/${modelName}/latest)`);
         }
-        return;
-      }
-      const modelData = JSON.parse(record.data);
-      await this.models[modelName].import(modelData);
-      if (this.config.verbose) {
-        console.log(`[MLPlugin] Loaded model "${modelName}" from plugin storage`);
       }
     } catch (error) {
       console.error(`[MLPlugin] Failed to load model "${modelName}":`, error.message);
     }
   }
   /**
-   * Delete model from plugin storage
+   * 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, version = null) {
+    try {
+      const storage = this.getStorage();
+      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 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,
+        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);
+      return null;
+    }
+  }
+  /**
+   * 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) {
@@ -13669,6 +16243,247 @@ class MLPlugin extends Plugin {
       }
     }
   }
+  /**
+   * Delete training data from plugin storage (all versions)
+   * @private
+   */
+  async _deleteTrainingData(modelName) {
+    try {
+      const storage = this.getStorage();
+      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 S3 (resource=${resourceName}/plugin=ml/training/)`);
+      }
+    } catch (error) {
+      if (this.config.verbose) {
+        console.log(`[MLPlugin] Could not delete training data "${modelName}": ${error.message}`);
+      }
+    }
+  }
+  /**
+   * List all versions of a model
+   * @param {string} modelName - Model name
+   * @returns {Array} List of version info
+   */
+  async listModelVersions(modelName) {
+    if (!this.config.enableVersioning) {
+      throw new MLError("Versioning is not enabled", { modelName });
+    }
+    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(storage.getPluginKey(resourceName, "models", modelName, `v${v}`)));
+        if (ok && versionData) {
+          versions.push({
+            version: v,
+            savedAt: versionData.savedAt,
+            isCurrent: v === versionInfo.currentVersion,
+            metrics: versionData.metrics
+          });
+        }
+      }
+      return versions;
+    } catch (error) {
+      console.error(`[MLPlugin] Failed to list versions for "${modelName}":`, error.message);
+      return [];
+    }
+  }
+  /**
+   * Load a specific version of a model
+   * @param {string} modelName - Model name
+   * @param {number} version - Version number
+   */
+  async loadModelVersion(modelName, version) {
+    if (!this.config.enableVersioning) {
+      throw new MLError("Versioning is not enabled", { modelName });
+    }
+    if (!this.models[modelName]) {
+      throw new ModelNotFoundError(`Model "${modelName}" not found`, { modelName });
+    }
+    try {
+      const storage = this.getStorage();
+      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 });
+      }
+      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;
+        this.modelVersions.set(modelName, versionInfo);
+      }
+      if (this.config.verbose) {
+        console.log(`[MLPlugin] Loaded model "${modelName}" v${version}`);
+      }
+      return {
+        version,
+        metrics: versionData.metrics ? JSON.parse(versionData.metrics) : {},
+        savedAt: versionData.savedAt
+      };
+    } catch (error) {
+      console.error(`[MLPlugin] Failed to load version ${version} for "${modelName}":`, error.message);
+      throw error;
+    }
+  }
+  /**
+   * Set active version for a model (used for predictions)
+   * @param {string} modelName - Model name
+   * @param {number} version - Version number
+   */
+  async setActiveVersion(modelName, version) {
+    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.set(storage.getPluginKey(resourceName, "metadata", modelName, "active"), {
+      modelName,
+      version,
+      type: "reference",
+      updatedAt: (/* @__PURE__ */ new Date()).toISOString()
+    });
+    if (this.config.verbose) {
+      console.log(`[MLPlugin] Set model "${modelName}" active version to v${version}`);
+    }
+    return { modelName, version };
+  }
+  /**
+   * Get training history for a model
+   * @param {string} modelName - Model name
+   * @returns {Array} Training history
+   */
+  async getTrainingHistory(modelName) {
+    if (!this.config.enableVersioning) {
+      return await this.getTrainingData(modelName);
+    }
+    try {
+      const storage = this.getStorage();
+      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;
+      }
+      return {
+        modelName: historyData.modelName,
+        totalTrainings: historyData.totalTrainings,
+        latestVersion: historyData.latestVersion,
+        history: JSON.parse(historyData.history),
+        updatedAt: historyData.updatedAt
+      };
+    } catch (error) {
+      console.error(`[MLPlugin] Failed to load training history for "${modelName}":`, error.message);
+      return null;
+    }
+  }
+  /**
+   * Compare metrics between two versions
+   * @param {string} modelName - Model name
+   * @param {number} version1 - First version
+   * @param {number} version2 - Second version
+   * @returns {Object} Comparison results
+   */
+  async compareVersions(modelName, version1, version2) {
+    if (!this.config.enableVersioning) {
+      throw new MLError("Versioning is not enabled", { modelName });
+    }
+    try {
+      const storage = this.getStorage();
+      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 });
+      }
+      if (!ok2 || !v2Data) {
+        throw new MLError(`Version ${version2} not found`, { modelName, version: version2 });
+      }
+      const metrics1 = v1Data.metrics ? JSON.parse(v1Data.metrics) : {};
+      const metrics2 = v2Data.metrics ? JSON.parse(v2Data.metrics) : {};
+      return {
+        modelName,
+        version1: {
+          version: version1,
+          savedAt: v1Data.savedAt,
+          metrics: metrics1
+        },
+        version2: {
+          version: version2,
+          savedAt: v2Data.savedAt,
+          metrics: metrics2
+        },
+        improvement: {
+          loss: metrics1.loss && metrics2.loss ? ((metrics1.loss - metrics2.loss) / metrics1.loss * 100).toFixed(2) + "%" : "N/A",
+          accuracy: metrics1.accuracy && metrics2.accuracy ? ((metrics2.accuracy - metrics1.accuracy) / metrics1.accuracy * 100).toFixed(2) + "%" : "N/A"
+        }
+      };
+    } catch (error) {
+      console.error(`[MLPlugin] Failed to compare versions for "${modelName}":`, error.message);
+      throw error;
+    }
+  }
+  /**
+   * Rollback to a previous version
+   * @param {string} modelName - Model name
+   * @param {number} version - Version to rollback to (defaults to previous version)
+   * @returns {Object} Rollback info
+   */
+  async rollbackVersion(modelName, version = null) {
+    if (!this.config.enableVersioning) {
+      throw new MLError("Versioning is not enabled", { modelName });
+    }
+    const versionInfo = this.modelVersions.get(modelName);
+    if (!versionInfo) {
+      throw new MLError(`No version info found for model "${modelName}"`, { modelName });
+    }
+    const targetVersion = version !== null ? version : Math.max(1, versionInfo.currentVersion - 1);
+    if (targetVersion === versionInfo.currentVersion) {
+      throw new MLError("Cannot rollback to the same version", { modelName, version: targetVersion });
+    }
+    if (targetVersion < 1 || targetVersion > versionInfo.latestVersion) {
+      throw new MLError(`Invalid version ${targetVersion}`, { modelName, version: targetVersion, latestVersion: versionInfo.latestVersion });
+    }
+    const result = await this.setActiveVersion(modelName, targetVersion);
+    if (this.config.verbose) {
+      console.log(`[MLPlugin] Rolled back model "${modelName}" from v${versionInfo.currentVersion} to v${targetVersion}`);
+    }
+    return {
+      modelName,
+      previousVersion: versionInfo.currentVersion,
+      currentVersion: targetVersion,
+      ...result
+    };
+  }
 }
 
 class SqsConsumer {
@@ -14062,7 +16877,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)
     });
@@ -17637,7 +20452,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;
@@ -17649,7 +20464,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 }) {
@@ -17674,7 +20489,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 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,
@@ -17702,7 +20517,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,
@@ -17730,7 +20545,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,
@@ -17763,7 +20578,7 @@ class S3Client extends EventEmitter {
       options.ContentType = contentType;
     }
     const [ok, err, response] = await tryFn(() => this.sendCommand(new 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,
@@ -17788,7 +20603,7 @@ class S3Client extends EventEmitter {
       Key: keyPrefix ? path$1.join(keyPrefix, key) : key
     };
     const [ok, err, response] = await tryFn(() => this.sendCommand(new DeleteObjectCommand(options)));
-    this.emit("deleteObject", err || response, { key });
+    this.emit("cl:DeleteObject", err || response, { key });
     if (!ok) {
       throw mapAwsError(err, {
         bucket: this.config.bucket,
@@ -17828,7 +20643,7 @@ class S3Client extends EventEmitter {
       deleted: results,
       notFound: errors
     };
-    this.emit("deleteObjects", report, keys);
+    this.emit("cl:DeleteObjects", report, keys);
     return report;
   }
   /**
@@ -17858,7 +20673,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
@@ -17866,7 +20681,7 @@ class S3Client extends EventEmitter {
       }
       continuationToken = listResponse.IsTruncated ? listResponse.NextContinuationToken : void 0;
     } while (continuationToken);
-    this.emit("deleteAllComplete", {
+    this.emit("cl:DeleteAllComplete", {
       prefix,
       totalDeleted
     });
@@ -17897,7 +20712,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 } = {}) {
@@ -17914,7 +20729,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 } = {}) {
@@ -17936,7 +20751,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 = {}) {
@@ -17965,7 +20780,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 = {}) {
@@ -17983,7 +20798,7 @@ class S3Client extends EventEmitter {
         offset
       });
       if (!continuationToken) {
-        this.emit("getKeysPage", [], params);
+        this.emit("cl:GetKeysPage", [], params);
         return [];
       }
     }
@@ -18006,7 +20821,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 }) {
@@ -18024,7 +20839,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,
@@ -20879,6 +23694,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
@@ -21019,11 +23848,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;
     }
   }
@@ -21087,7 +23916,7 @@ ${errorDetails}`,
       data = await this.applyVersionMapping(data, objectVersion, this.version);
     }
     data = await this.executeHooks("afterGet", data);
-    this.emit("get", data);
+    this._emitWithDeprecation("get", "fetched", data, data.id);
     const value = data;
     return value;
   }
@@ -21338,19 +24167,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;
     }
   }
@@ -21749,11 +24578,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,
@@ -21762,11 +24591,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,
@@ -21797,11 +24626,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._emitWithDeprecation("delete", "deleted", {
       ...objectData,
       $before: { ...objectData },
       $after: null
-    });
+    }, id);
     if (deleteError) {
       throw mapAwsError(deleteError, {
         bucket: this.client.config.bucket,
@@ -21925,7 +24754,7 @@ ${errorDetails}`,
     }
     const count = await this.client.count({ prefix });
     await this.executeHooks("afterCount", { count, partition, partitionValues });
-    this.emit("count", count);
+    this._emitWithDeprecation("count", "counted", count);
     return count;
   }
   /**
@@ -21948,7 +24777,7 @@ ${errorDetails}`,
       const result = await this.insert(attributes);
       return result;
     });
-    this.emit("insertMany", objects.length);
+    this._emitWithDeprecation("insertMany", "inserted-many", objects.length);
     return results;
   }
   /**
@@ -21983,7 +24812,7 @@ ${errorDetails}`,
       return response;
     });
     await this.executeHooks("afterDeleteMany", { ids, results });
-    this.emit("deleteMany", ids.length);
+    this._emitWithDeprecation("deleteMany", "deleted-many", ids.length);
     return results;
   }
   async deleteAll() {
@@ -21992,7 +24821,7 @@ ${errorDetails}`,
     }
     const prefix = `resource=${this.name}/data`;
     const deletedCount = await this.client.deleteAll({ prefix });
-    this.emit("deleteAll", {
+    this._emitWithDeprecation("deleteAll", "deleted-all", {
       version: this.version,
       prefix,
       deletedCount
@@ -22009,7 +24838,7 @@ ${errorDetails}`,
     }
     const prefix = `resource=${this.name}`;
     const deletedCount = await this.client.deleteAll({ prefix });
-    this.emit("deleteAllData", {
+    this._emitWithDeprecation("deleteAllData", "deleted-all-data", {
       resource: this.name,
       prefix,
       deletedCount
@@ -22079,7 +24908,7 @@ ${errorDetails}`,
       const idPart = parts.find((part) => part.startsWith("id="));
       return idPart ? idPart.replace("id=", "") : null;
     }).filter(Boolean);
-    this.emit("listIds", ids.length);
+    this._emitWithDeprecation("listIds", "listed-ids", ids.length);
     return ids;
   }
   /**
@@ -22121,12 +24950,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._emitWithDeprecation("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._emitWithDeprecation("list", "listed", { partition, partitionValues, count: 0, errors: 0 });
       return [];
     }
     const partitionDef = this.config.partitions[partition];
@@ -22136,7 +24965,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._emitWithDeprecation("list", "listed", { partition, partitionValues, count: results.length, errors: 0 });
     return results;
   }
   /**
@@ -22181,7 +25010,7 @@ ${errorDetails}`,
       }
       return this.handleResourceError(err, id, context);
     });
-    this.emit("list", { count: results.length, errors: 0 });
+    this._emitWithDeprecation("list", "listed", { count: results.length, errors: 0 });
     return results;
   }
   /**
@@ -22244,10 +25073,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._emitWithDeprecation("list", "listed", { partition, partitionValues, count: 0, errors: 1 });
       return [];
     }
-    this.emit("list", { partition, partitionValues, count: 0, errors: 1 });
+    this._emitWithDeprecation("list", "listed", { partition, partitionValues, count: 0, errors: 1 });
     return [];
   }
   /**
@@ -22280,7 +25109,7 @@ ${errorDetails}`,
       throw err;
     });
     const finalResults = await this.executeHooks("afterGetMany", results);
-    this.emit("getMany", ids.length);
+    this._emitWithDeprecation("getMany", "fetched-many", ids.length);
     return finalResults;
   }
   /**
@@ -22366,7 +25195,7 @@ ${errorDetails}`,
           hasTotalItems: totalItems !== null
         }
       };
-      this.emit("page", result2);
+      this._emitWithDeprecation("page", "paginated", result2);
       return result2;
     });
     if (ok) return result;
@@ -22436,7 +25265,7 @@ ${errorDetails}`,
       contentType
     }));
     if (!ok2) throw err2;
-    this.emit("setContent", { id, contentType, contentLength: buffer.length });
+    this._emitWithDeprecation("setContent", "content-set", { id, contentType, contentLength: buffer.length }, id);
     return updatedData;
   }
   /**
@@ -22465,7 +25294,7 @@ ${errorDetails}`,
     }
     const buffer = Buffer.from(await response.Body.transformToByteArray());
     const contentType = response.ContentType || null;
-    this.emit("content", id, buffer.length, contentType);
+    this._emitWithDeprecation("content", "content-fetched", { id, contentLength: buffer.length, contentType }, id);
     return {
       buffer,
       contentType
@@ -22497,7 +25326,7 @@ ${errorDetails}`,
       metadata: existingMetadata
     }));
     if (!ok2) throw err2;
-    this.emit("deleteContent", id);
+    this._emitWithDeprecation("deleteContent", "content-deleted", id, id);
     return response;
   }
   /**
@@ -22809,7 +25638,7 @@ ${errorDetails}`,
     const data = await this.get(id);
     data._partition = partitionName;
     data._partitionValues = partitionValues;
-    this.emit("getFromPartition", data);
+    this._emitWithDeprecation("getFromPartition", "partition-fetched", data, data.id);
     return data;
   }
   /**
@@ -23218,7 +26047,7 @@ class Database extends EventEmitter {
     })();
     this.version = "1";
     this.s3dbVersion = (() => {
-      const [ok, err, version] = tryFn(() => true ? "13.0.0" : "latest");
+      const [ok, err, version] = tryFn(() => true ? "13.2.1" : "latest");
       return ok ? version : "latest";
     })();
     this._resourcesMap = {};
@@ -23388,12 +26217,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
@@ -23607,7 +26436,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 = {
@@ -23666,7 +26495,7 @@ class Database extends EventEmitter {
       contentType: "application/json"
     });
     this.savedMetadata = metadata;
-    this.emit("metadataUploaded", metadata);
+    this.emit("db:metadata-uploaded", metadata);
   }
   blankMetadataStructure() {
     return {
@@ -23923,7 +26752,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");
       }
@@ -24063,7 +26892,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];
@@ -24100,7 +26929,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;
   }
   /**
@@ -24264,7 +27093,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);
@@ -24376,7 +27205,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,
@@ -25952,7 +28781,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) => {
@@ -25965,7 +28794,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) => {
@@ -25976,7 +28805,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, {
@@ -26097,7 +28926,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,
@@ -26122,7 +28951,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,
@@ -26138,7 +28967,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,
@@ -26170,7 +28999,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,
@@ -26182,7 +29011,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,
@@ -26198,7 +29027,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,
@@ -26216,7 +29045,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 = {
@@ -26234,7 +29063,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) {
@@ -26246,7 +29075,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
@@ -26330,7 +29159,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;
@@ -26346,7 +29175,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 () => {
@@ -26361,7 +29190,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
@@ -26392,7 +29221,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
       });
     }
@@ -26549,7 +29378,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;
@@ -26564,7 +29393,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 () => {
@@ -26732,7 +29561,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,
@@ -26745,7 +29574,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,
@@ -26753,7 +29582,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
@@ -26985,7 +29814,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({
@@ -27123,7 +29952,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;
@@ -27190,7 +30019,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,
@@ -27276,7 +30105,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
@@ -27297,7 +30126,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
@@ -27435,7 +30264,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
@@ -27458,7 +30287,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)
@@ -27499,9 +30328,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 = `
@@ -27526,6 +30360,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;
   }
 }
 
@@ -27546,11 +30532,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() {
@@ -27599,7 +30597,8 @@ class StateMachinePlugin extends Plugin {
         // entityId -> currentState
       });
     }
-    this.emit("initialized", { machines: Array.from(this.machines.keys()) });
+    await this._setupTriggers();
+    this.emit("db:plugin:initialized", { machines: Array.from(this.machines.keys()) });
   }
   async _createStateResources() {
     const [logOk] = await tryFn(() => this.database.createResource({
@@ -27630,6 +30629,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"
@@ -27693,7 +30694,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,
@@ -27719,14 +30720,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) {
@@ -27824,6 +30908,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
    */
@@ -27953,7 +31058,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;
   }
   /**
@@ -28010,12 +31115,343 @@ 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}'`);
+      }
+    }
+  }
   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();
   }
@@ -38157,11 +41593,21 @@ class TfStatePlugin extends Plugin {
   }
 }
 
+const ONE_HOUR_SEC = 3600;
+const ONE_DAY_SEC = 86400;
+const THIRTY_DAYS_SEC = 2592e3;
+const TEN_SECONDS_MS = 1e4;
+const ONE_MINUTE_MS = 6e4;
+const TEN_MINUTES_MS = 6e5;
+const ONE_HOUR_MS = 36e5;
+const ONE_DAY_MS = 864e5;
+const ONE_WEEK_MS = 6048e5;
+const SECONDS_TO_MS = 1e3;
 const GRANULARITIES = {
   minute: {
-    threshold: 3600,
+    threshold: ONE_HOUR_SEC,
     // TTL < 1 hour
-    interval: 1e4,
+    interval: TEN_SECONDS_MS,
     // Check every 10 seconds
     cohortsToCheck: 3,
     // Check last 3 minutes
@@ -38169,9 +41615,9 @@ const GRANULARITIES = {
     // '2024-10-25T14:30'
   },
   hour: {
-    threshold: 86400,
+    threshold: ONE_DAY_SEC,
     // TTL < 24 hours
-    interval: 6e5,
+    interval: TEN_MINUTES_MS,
     // Check every 10 minutes
     cohortsToCheck: 2,
     // Check last 2 hours
@@ -38179,9 +41625,9 @@ const GRANULARITIES = {
     // '2024-10-25T14'
   },
   day: {
-    threshold: 2592e3,
+    threshold: THIRTY_DAYS_SEC,
     // TTL < 30 days
-    interval: 36e5,
+    interval: ONE_HOUR_MS,
     // Check every 1 hour
     cohortsToCheck: 2,
     // Check last 2 days
@@ -38191,7 +41637,7 @@ const GRANULARITIES = {
   week: {
     threshold: Infinity,
     // TTL >= 30 days
-    interval: 864e5,
+    interval: ONE_DAY_MS,
     // Check every 24 hours
     cohortsToCheck: 2,
     // Check last 2 weeks
@@ -38207,7 +41653,7 @@ function getWeekNumber(date) {
   const dayNum = d.getUTCDay() || 7;
   d.setUTCDate(d.getUTCDate() + 4 - dayNum);
   const yearStart = new Date(Date.UTC(d.getUTCFullYear(), 0, 1));
-  return Math.ceil(((d - yearStart) / 864e5 + 1) / 7);
+  return Math.ceil(((d - yearStart) / ONE_DAY_MS + 1) / 7);
 }
 function detectGranularity(ttl) {
   if (!ttl) return "day";
@@ -38224,16 +41670,16 @@ function getExpiredCohorts(granularity, count) {
     let checkDate;
     switch (granularity) {
       case "minute":
-        checkDate = new Date(now.getTime() - i * 6e4);
+        checkDate = new Date(now.getTime() - i * ONE_MINUTE_MS);
         break;
       case "hour":
-        checkDate = new Date(now.getTime() - i * 36e5);
+        checkDate = new Date(now.getTime() - i * ONE_HOUR_MS);
         break;
       case "day":
-        checkDate = new Date(now.getTime() - i * 864e5);
+        checkDate = new Date(now.getTime() - i * ONE_DAY_MS);
         break;
       case "week":
-        checkDate = new Date(now.getTime() - i * 6048e5);
+        checkDate = new Date(now.getTime() - i * ONE_WEEK_MS);
         break;
     }
     cohorts.push(config.cohortFormat(checkDate));
@@ -38277,7 +41723,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)
     });
@@ -38399,7 +41845,7 @@ class TTLPlugin extends Plugin {
         return;
       }
       const baseTimestamp = typeof baseTime === "number" ? baseTime : new Date(baseTime).getTime();
-      const expiresAt = config.ttl ? new Date(baseTimestamp + config.ttl * 1e3) : new Date(baseTimestamp);
+      const expiresAt = config.ttl ? new Date(baseTimestamp + config.ttl * SECONDS_TO_MS) : new Date(baseTimestamp);
       const cohortConfig = GRANULARITIES[config.granularity];
       const cohort = cohortConfig.cohortFormat(expiresAt);
       const indexId = `${resourceName}:${record.id}`;
@@ -38514,7 +41960,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
@@ -38522,7 +41968,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 });
     }
   }
   /**
@@ -38570,7 +42016,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++;
@@ -39041,15 +42487,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)) {
@@ -39060,7 +42506,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
@@ -39089,10 +42535,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"
             });
@@ -39124,7 +42570,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,
@@ -39147,7 +42593,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,
@@ -39222,7 +42668,7 @@ class VectorPlugin extends Plugin {
       }
       return updates;
     });
-    this.emit("vector:hooks-installed", {
+    this.emit("plg:vector:hooks-installed", {
       resource: resource.name,
       vectorField,
       trackingField,
@@ -39331,7 +42777,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()
@@ -40255,7 +43701,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) {
@@ -40283,7 +43729,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, {
@@ -40394,7 +43840,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;
   }
   /**
@@ -40409,7 +43855,7 @@ class MemoryClient extends EventEmitter {
         decodedMetadata[k] = metadataDecode(v);
       }
     }
-    this.emit("getObject", null, { key });
+    this.emit("cl:GetObject", null, { key });
     return {
       ...response,
       Metadata: decodedMetadata
@@ -40427,7 +43873,7 @@ class MemoryClient extends EventEmitter {
         decodedMetadata[k] = metadataDecode(v);
       }
     }
-    this.emit("headObject", null, { key });
+    this.emit("cl:HeadObject", null, { key });
     return {
       ...response,
       Metadata: decodedMetadata
@@ -40452,7 +43898,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;
   }
   /**
@@ -40468,7 +43914,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;
   }
   /**
@@ -40501,7 +43947,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;
   }
   /**
@@ -40541,7 +43987,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;
   }
   /**
@@ -40558,7 +44004,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;
   }
   /**
@@ -40567,7 +44013,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;
   }
   /**
@@ -40579,13 +44025,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
     });
@@ -40598,11 +44044,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;
   }
   /**
@@ -40632,7 +44078,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 = {