s3db.js 12.2.0 → 12.2.2

package/dist/s3db.cjs.js

@@ -5,9 +5,6 @@ Object.defineProperty(exports, '__esModule', { value: true });
 var crypto$1 = require('crypto');
 var nanoid = require('nanoid');
 var EventEmitter = require('events');
-var hono = require('hono');
-var nodeServer = require('@hono/node-server');
-var swaggerUi = require('@hono/swagger-ui');
 var promises = require('fs/promises');
 var fs = require('fs');
 var promises$1 = require('stream/promises');
@@ -2474,1968 +2471,6 @@ const PluginObject = {
   }
 };
 
-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 createResourceRoutes(resource, version, config = {}) {
-  const app = new hono.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 (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) {
-  const app = new hono.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 attributes = resource.config?.attributes || resource.attributes || {};
-  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 attributes = resource.config?.attributes || resource.attributes || {};
-    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 = new hono.Hono();
-    this.server = null;
-    this.isRunning = false;
-    this.openAPISpec = null;
-    this.relationsPlugin = this.options.database?.plugins?.relation || this.options.database?.plugins?.RelationPlugin || null;
-    this._setupRoutes();
-  }
-  /**
-   * 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", swaggerUi.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.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);
-        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;
-    }
-    const { port, host } = this.options;
-    return new Promise((resolve, reject) => {
-      try {
-        this.server = nodeServer.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
-    });
-  }
-}
-
 const PLUGIN_DEPENDENCIES = {
   "postgresql-replicator": {
     name: "PostgreSQL Replicator",
@@ -4996,6 +3031,11 @@ 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,
@@ -12605,6 +10645,605 @@ class FullTextPlugin extends Plugin {
   }
 }
 
+class GeoPlugin extends Plugin {
+  constructor(config = {}) {
+    super(config);
+    this.resources = config.resources || {};
+    this.verbose = config.verbose !== void 0 ? config.verbose : false;
+    this.base32 = "0123456789bcdefghjkmnpqrstuvwxyz";
+  }
+  /**
+   * Install the plugin
+   */
+  async install(database) {
+    await super.install(database);
+    for (const [resourceName, config] of Object.entries(this.resources)) {
+      await this._setupResource(resourceName, config);
+    }
+    this.database.addHook("afterCreateResource", async (context) => {
+      const { resource, config: resourceConfig } = context;
+      const geoConfig = this.resources[resource.name];
+      if (geoConfig) {
+        await this._setupResource(resource.name, geoConfig);
+      }
+    });
+    if (this.verbose) {
+      console.log(`[GeoPlugin] Installed with ${Object.keys(this.resources).length} resources`);
+    }
+    this.emit("installed", {
+      plugin: "GeoPlugin",
+      resources: Object.keys(this.resources)
+    });
+  }
+  /**
+   * Setup a resource with geo capabilities
+   */
+  async _setupResource(resourceName, config) {
+    if (!this.database.resources[resourceName]) {
+      if (this.verbose) {
+        console.warn(`[GeoPlugin] Resource "${resourceName}" not found, will setup when created`);
+      }
+      return;
+    }
+    const resource = this.database.resources[resourceName];
+    if (!resource || typeof resource.addHook !== "function") {
+      if (this.verbose) {
+        console.warn(`[GeoPlugin] Resource "${resourceName}" not found or invalid`);
+      }
+      return;
+    }
+    if (!config.latField || !config.lonField) {
+      throw new Error(
+        `[GeoPlugin] Resource "${resourceName}" must have "latField" and "lonField" configured`
+      );
+    }
+    if (!config.precision || config.precision < 1 || config.precision > 12) {
+      config.precision = 5;
+    }
+    resource._geoConfig = config;
+    const latField = resource.attributes[config.latField];
+    const lonField = resource.attributes[config.lonField];
+    const isLatOptional = typeof latField === "object" && latField.optional === true;
+    const isLonOptional = typeof lonField === "object" && lonField.optional === true;
+    const areCoordinatesOptional = isLatOptional || isLonOptional;
+    const geohashType = areCoordinatesOptional ? "string|optional" : "string";
+    let needsUpdate = false;
+    const newAttributes = { ...resource.attributes };
+    if (config.addGeohash && !newAttributes.geohash) {
+      newAttributes.geohash = geohashType;
+      needsUpdate = true;
+    }
+    if (!newAttributes._geohash) {
+      newAttributes._geohash = geohashType;
+      needsUpdate = true;
+    }
+    if (config.zoomLevels && Array.isArray(config.zoomLevels)) {
+      for (const zoom of config.zoomLevels) {
+        const fieldName = `_geohash_zoom${zoom}`;
+        if (!newAttributes[fieldName]) {
+          newAttributes[fieldName] = geohashType;
+          needsUpdate = true;
+        }
+      }
+    }
+    if (needsUpdate) {
+      resource.updateAttributes(newAttributes);
+      if (this.database.uploadMetadataFile) {
+        await this.database.uploadMetadataFile();
+      }
+    }
+    if (config.usePartitions) {
+      await this._setupPartitions(resource, config);
+    }
+    this._addHooks(resource, config);
+    this._addHelperMethods(resource, config);
+    if (this.verbose) {
+      console.log(
+        `[GeoPlugin] Setup resource "${resourceName}" with precision ${config.precision} (~${this._getPrecisionDistance(config.precision)}km cells)` + (config.usePartitions ? " [Partitions enabled]" : "")
+      );
+    }
+  }
+  /**
+   * Setup geohash partitions for efficient spatial queries
+   * Creates multiple zoom-level partitions if zoomLevels configured
+   */
+  async _setupPartitions(resource, config) {
+    const updatedConfig = { ...resource.config };
+    updatedConfig.partitions = updatedConfig.partitions || {};
+    let partitionsCreated = 0;
+    if (config.zoomLevels && Array.isArray(config.zoomLevels)) {
+      for (const zoom of config.zoomLevels) {
+        const partitionName = `byGeohashZoom${zoom}`;
+        const fieldName = `_geohash_zoom${zoom}`;
+        if (!updatedConfig.partitions[partitionName]) {
+          updatedConfig.partitions[partitionName] = {
+            fields: {
+              [fieldName]: "string"
+            }
+          };
+          partitionsCreated++;
+          if (this.verbose) {
+            console.log(
+              `[GeoPlugin] Created ${partitionName} partition for "${resource.name}" (precision ${zoom}, ~${this._getPrecisionDistance(zoom)}km cells)`
+            );
+          }
+        }
+      }
+    } else {
+      const hasGeohashPartition = resource.config.partitions && resource.config.partitions.byGeohash;
+      if (!hasGeohashPartition) {
+        updatedConfig.partitions.byGeohash = {
+          fields: {
+            _geohash: "string"
+          }
+        };
+        partitionsCreated++;
+        if (this.verbose) {
+          console.log(`[GeoPlugin] Created byGeohash partition for "${resource.name}"`);
+        }
+      }
+    }
+    if (partitionsCreated > 0) {
+      resource.config = updatedConfig;
+      resource.setupPartitionHooks();
+      if (this.database.uploadMetadataFile) {
+        await this.database.uploadMetadataFile();
+      }
+    }
+  }
+  /**
+   * Add hooks to automatically calculate geohash at all zoom levels
+   */
+  _addHooks(resource, config) {
+    const calculateGeohash = async (data) => {
+      const lat = data[config.latField];
+      const lon = data[config.lonField];
+      if (lat !== void 0 && lon !== void 0) {
+        const geohash = this.encodeGeohash(lat, lon, config.precision);
+        if (config.addGeohash) {
+          data.geohash = geohash;
+        }
+        data._geohash = geohash;
+        if (config.zoomLevels && Array.isArray(config.zoomLevels)) {
+          for (const zoom of config.zoomLevels) {
+            const zoomGeohash = this.encodeGeohash(lat, lon, zoom);
+            data[`_geohash_zoom${zoom}`] = zoomGeohash;
+          }
+        }
+      }
+      return data;
+    };
+    resource.addHook("beforeInsert", calculateGeohash);
+    resource.addHook("beforeUpdate", calculateGeohash);
+  }
+  /**
+   * Add helper methods to resource
+   */
+  _addHelperMethods(resource, config) {
+    const plugin = this;
+    resource.findNearby = async function({ lat, lon, radius = 10, limit = 100 }) {
+      if (lat === void 0 || lon === void 0) {
+        throw new Error("lat and lon are required for findNearby");
+      }
+      const longitude = lon;
+      let allRecords = [];
+      if (config.usePartitions) {
+        let partitionName, fieldName, precision;
+        if (config.zoomLevels && config.zoomLevels.length > 0) {
+          const optimalZoom = plugin._selectOptimalZoom(config.zoomLevels, radius);
+          partitionName = `byGeohashZoom${optimalZoom}`;
+          fieldName = `_geohash_zoom${optimalZoom}`;
+          precision = optimalZoom;
+          if (plugin.verbose) {
+            console.log(
+              `[GeoPlugin] Auto-selected zoom${optimalZoom} (${plugin._getPrecisionDistance(optimalZoom)}km cells) for ${radius}km radius query`
+            );
+          }
+        } else {
+          partitionName = "byGeohash";
+          fieldName = "_geohash";
+          precision = config.precision;
+        }
+        if (this.config.partitions?.[partitionName]) {
+          const centerGeohash = plugin.encodeGeohash(lat, longitude, precision);
+          const neighbors = plugin.getNeighbors(centerGeohash);
+          const geohashesToSearch = [centerGeohash, ...neighbors];
+          const partitionResults = await Promise.all(
+            geohashesToSearch.map(async (geohash) => {
+              const [ok, err, records] = await tryFn(async () => {
+                return await this.listPartition({
+                  partition: partitionName,
+                  partitionValues: { [fieldName]: geohash },
+                  limit: limit * 2
+                });
+              });
+              return ok ? records : [];
+            })
+          );
+          allRecords = partitionResults.flat();
+          if (plugin.verbose) {
+            console.log(
+              `[GeoPlugin] findNearby searched ${geohashesToSearch.length} ${partitionName} partitions, found ${allRecords.length} candidates`
+            );
+          }
+        } else {
+          allRecords = await this.list({ limit: limit * 10 });
+        }
+      } else {
+        allRecords = await this.list({ limit: limit * 10 });
+      }
+      const withDistances = allRecords.map((record) => {
+        const recordLat = record[config.latField];
+        const recordLon = record[config.lonField];
+        if (recordLat === void 0 || recordLon === void 0) {
+          return null;
+        }
+        const distance = plugin.calculateDistance(lat, longitude, recordLat, recordLon);
+        return {
+          ...record,
+          _distance: distance
+        };
+      }).filter((record) => record !== null && record._distance <= radius).sort((a, b) => a._distance - b._distance).slice(0, limit);
+      return withDistances;
+    };
+    resource.findInBounds = async function({ north, south, east, west, limit = 100 }) {
+      if (north === void 0 || south === void 0 || east === void 0 || west === void 0) {
+        throw new Error("north, south, east, west are required for findInBounds");
+      }
+      let allRecords = [];
+      if (config.usePartitions) {
+        let partitionName, precision;
+        if (config.zoomLevels && config.zoomLevels.length > 0) {
+          const centerLat = (north + south) / 2;
+          const centerLon = (east + west) / 2;
+          const latRadius = plugin.calculateDistance(centerLat, centerLon, north, centerLon);
+          const lonRadius = plugin.calculateDistance(centerLat, centerLon, centerLat, east);
+          const approximateRadius = Math.max(latRadius, lonRadius);
+          const optimalZoom = plugin._selectOptimalZoom(config.zoomLevels, approximateRadius);
+          partitionName = `byGeohashZoom${optimalZoom}`;
+          precision = optimalZoom;
+          if (plugin.verbose) {
+            console.log(
+              `[GeoPlugin] Auto-selected zoom${optimalZoom} (${plugin._getPrecisionDistance(optimalZoom)}km cells) for ${approximateRadius.toFixed(1)}km bounding box`
+            );
+          }
+        } else {
+          partitionName = "byGeohash";
+          precision = config.precision;
+        }
+        if (this.config.partitions?.[partitionName]) {
+          const geohashesToSearch = plugin._getGeohashesInBounds({
+            north,
+            south,
+            east,
+            west,
+            precision
+          });
+          const partitionResults = await Promise.all(
+            geohashesToSearch.map(async (geohash) => {
+              const [ok, err, records] = await tryFn(async () => {
+                const fieldName = config.zoomLevels ? `_geohash_zoom${precision}` : "_geohash";
+                return await this.listPartition({
+                  partition: partitionName,
+                  partitionValues: { [fieldName]: geohash },
+                  limit: limit * 2
+                });
+              });
+              return ok ? records : [];
+            })
+          );
+          allRecords = partitionResults.flat();
+          if (plugin.verbose) {
+            console.log(
+              `[GeoPlugin] findInBounds searched ${geohashesToSearch.length} ${partitionName} partitions, found ${allRecords.length} candidates`
+            );
+          }
+        } else {
+          allRecords = await this.list({ limit: limit * 10 });
+        }
+      } else {
+        allRecords = await this.list({ limit: limit * 10 });
+      }
+      const inBounds = allRecords.filter((record) => {
+        const lat = record[config.latField];
+        const lon = record[config.lonField];
+        if (lat === void 0 || lon === void 0) {
+          return false;
+        }
+        return lat <= north && lat >= south && lon <= east && lon >= west;
+      }).slice(0, limit);
+      return inBounds;
+    };
+    resource.getDistance = async function(id1, id2) {
+      let record1, record2;
+      try {
+        [record1, record2] = await Promise.all([
+          this.get(id1),
+          this.get(id2)
+        ]);
+      } catch (err) {
+        if (err.name === "NoSuchKey" || err.message?.includes("No such key")) {
+          throw new Error("One or both records not found");
+        }
+        throw err;
+      }
+      if (!record1 || !record2) {
+        throw new Error("One or both records not found");
+      }
+      const lat1 = record1[config.latField];
+      const lon1 = record1[config.lonField];
+      const lat2 = record2[config.latField];
+      const lon2 = record2[config.lonField];
+      if (lat1 === void 0 || lon1 === void 0 || lat2 === void 0 || lon2 === void 0) {
+        throw new Error("One or both records missing coordinates");
+      }
+      const distance = plugin.calculateDistance(lat1, lon1, lat2, lon2);
+      return {
+        distance,
+        unit: "km",
+        from: id1,
+        to: id2
+      };
+    };
+  }
+  /**
+   * Encode coordinates to geohash
+   * @param {number} latitude - Latitude (-90 to 90)
+   * @param {number} longitude - Longitude (-180 to 180)
+   * @param {number} precision - Number of characters in geohash
+   * @returns {string} Geohash string
+   */
+  encodeGeohash(latitude, longitude, precision = 5) {
+    let idx = 0;
+    let bit = 0;
+    let evenBit = true;
+    let geohash = "";
+    let latMin = -90;
+    let latMax = 90;
+    let lonMin = -180;
+    let lonMax = 180;
+    while (geohash.length < precision) {
+      if (evenBit) {
+        const lonMid = (lonMin + lonMax) / 2;
+        if (longitude > lonMid) {
+          idx |= 1 << 4 - bit;
+          lonMin = lonMid;
+        } else {
+          lonMax = lonMid;
+        }
+      } else {
+        const latMid = (latMin + latMax) / 2;
+        if (latitude > latMid) {
+          idx |= 1 << 4 - bit;
+          latMin = latMid;
+        } else {
+          latMax = latMid;
+        }
+      }
+      evenBit = !evenBit;
+      if (bit < 4) {
+        bit++;
+      } else {
+        geohash += this.base32[idx];
+        bit = 0;
+        idx = 0;
+      }
+    }
+    return geohash;
+  }
+  /**
+   * Decode geohash to coordinates
+   * @param {string} geohash - Geohash string
+   * @returns {Object} { latitude, longitude, error }
+   */
+  decodeGeohash(geohash) {
+    let evenBit = true;
+    let latMin = -90;
+    let latMax = 90;
+    let lonMin = -180;
+    let lonMax = 180;
+    for (let i = 0; i < geohash.length; i++) {
+      const chr = geohash[i];
+      const idx = this.base32.indexOf(chr);
+      if (idx === -1) {
+        throw new Error(`Invalid geohash character: ${chr}`);
+      }
+      for (let n = 4; n >= 0; n--) {
+        const bitN = idx >> n & 1;
+        if (evenBit) {
+          const lonMid = (lonMin + lonMax) / 2;
+          if (bitN === 1) {
+            lonMin = lonMid;
+          } else {
+            lonMax = lonMid;
+          }
+        } else {
+          const latMid = (latMin + latMax) / 2;
+          if (bitN === 1) {
+            latMin = latMid;
+          } else {
+            latMax = latMid;
+          }
+        }
+        evenBit = !evenBit;
+      }
+    }
+    const latitude = (latMin + latMax) / 2;
+    const longitude = (lonMin + lonMax) / 2;
+    return {
+      latitude,
+      longitude,
+      error: {
+        latitude: latMax - latMin,
+        longitude: lonMax - lonMin
+      }
+    };
+  }
+  /**
+   * Calculate distance between two coordinates using Haversine formula
+   * @param {number} lat1 - Latitude of point 1
+   * @param {number} lon1 - Longitude of point 1
+   * @param {number} lat2 - Latitude of point 2
+   * @param {number} lon2 - Longitude of point 2
+   * @returns {number} Distance in kilometers
+   */
+  calculateDistance(lat1, lon1, lat2, lon2) {
+    const R = 6371;
+    const dLat = this._toRadians(lat2 - lat1);
+    const dLon = this._toRadians(lon2 - lon1);
+    const a = Math.sin(dLat / 2) * Math.sin(dLat / 2) + Math.cos(this._toRadians(lat1)) * Math.cos(this._toRadians(lat2)) * Math.sin(dLon / 2) * Math.sin(dLon / 2);
+    const c = 2 * Math.atan2(Math.sqrt(a), Math.sqrt(1 - a));
+    return R * c;
+  }
+  /**
+   * Get geohash neighbors (8 surrounding cells)
+   * @param {string} geohash - Center geohash
+   * @returns {Array<string>} Array of 8 neighboring geohashes
+   */
+  getNeighbors(geohash) {
+    const decoded = this.decodeGeohash(geohash);
+    const { latitude, longitude, error } = decoded;
+    const latStep = error.latitude;
+    const lonStep = error.longitude;
+    const neighbors = [];
+    const directions = [
+      [-latStep, -lonStep],
+      // SW
+      [-latStep, 0],
+      // S
+      [-latStep, lonStep],
+      // SE
+      [0, -lonStep],
+      // W
+      [0, lonStep],
+      // E
+      [latStep, -lonStep],
+      // NW
+      [latStep, 0],
+      // N
+      [latStep, lonStep]
+      // NE
+    ];
+    for (const [latDelta, lonDelta] of directions) {
+      const neighborHash = this.encodeGeohash(
+        latitude + latDelta,
+        longitude + lonDelta,
+        geohash.length
+      );
+      neighbors.push(neighborHash);
+    }
+    return neighbors;
+  }
+  /**
+   * Get all geohashes that cover a bounding box
+   * @param {Object} bounds - Bounding box { north, south, east, west, precision }
+   * @returns {Array<string>} Array of unique geohashes covering the area
+   */
+  _getGeohashesInBounds({ north, south, east, west, precision }) {
+    const geohashes = /* @__PURE__ */ new Set();
+    const cellSize = this._getPrecisionDistance(precision);
+    const latStep = cellSize / 111;
+    const lonStep = cellSize / (111 * Math.cos(this._toRadians((north + south) / 2)));
+    for (let lat = south; lat <= north; lat += latStep) {
+      for (let lon = west; lon <= east; lon += lonStep) {
+        const geohash = this.encodeGeohash(lat, lon, precision);
+        geohashes.add(geohash);
+      }
+    }
+    const corners = [
+      [north, west],
+      [north, east],
+      [south, west],
+      [south, east],
+      [(north + south) / 2, west],
+      [(north + south) / 2, east],
+      [north, (east + west) / 2],
+      [south, (east + west) / 2]
+    ];
+    for (const [lat, lon] of corners) {
+      const geohash = this.encodeGeohash(lat, lon, precision);
+      geohashes.add(geohash);
+    }
+    return Array.from(geohashes);
+  }
+  /**
+   * Convert degrees to radians
+   */
+  _toRadians(degrees) {
+    return degrees * (Math.PI / 180);
+  }
+  /**
+   * Get approximate cell size for precision level
+   */
+  _getPrecisionDistance(precision) {
+    const distances = {
+      1: 5e3,
+      2: 1250,
+      3: 156,
+      4: 39,
+      5: 4.9,
+      6: 1.2,
+      7: 0.15,
+      8: 0.038,
+      9: 47e-4,
+      10: 12e-4,
+      11: 15e-5,
+      12: 37e-6
+    };
+    return distances[precision] || 5;
+  }
+  /**
+   * Select optimal zoom level based on search radius
+   * @param {Array<number>} zoomLevels - Available zoom levels
+   * @param {number} radiusKm - Search radius in kilometers
+   * @returns {number} Optimal zoom precision
+   */
+  _selectOptimalZoom(zoomLevels, radiusKm) {
+    if (!zoomLevels || zoomLevels.length === 0) {
+      return null;
+    }
+    const targetCellSize = radiusKm / 2.5;
+    let bestZoom = zoomLevels[0];
+    let bestDiff = Math.abs(this._getPrecisionDistance(bestZoom) - targetCellSize);
+    for (const zoom of zoomLevels) {
+      const cellSize = this._getPrecisionDistance(zoom);
+      const diff = Math.abs(cellSize - targetCellSize);
+      if (diff < bestDiff) {
+        bestDiff = diff;
+        bestZoom = zoom;
+      }
+    }
+    return bestZoom;
+  }
+  /**
+   * Get plugin statistics
+   */
+  getStats() {
+    return {
+      resources: Object.keys(this.resources).length,
+      configurations: Object.entries(this.resources).map(([name, config]) => ({
+        resource: name,
+        latField: config.latField,
+        lonField: config.lonField,
+        precision: config.precision,
+        cellSize: `~${this._getPrecisionDistance(config.precision)}km`
+      }))
+    };
+  }
+  /**
+   * Uninstall the plugin
+   */
+  async uninstall() {
+    if (this.verbose) {
+      console.log("[GeoPlugin] Uninstalled");
+    }
+    this.emit("uninstalled", {
+      plugin: "GeoPlugin"
+    });
+    await super.uninstall();
+  }
+}
+
 class MetricsPlugin extends Plugin {
   constructor(options = {}) {
     super();
@@ -22414,7 +21053,7 @@ class Database extends EventEmitter {
     this.id = idGenerator(7);
     this.version = "1";
     this.s3dbVersion = (() => {
-      const [ok, err, version] = tryFn(() => true ? "12.2.0" : "latest");
+      const [ok, err, version] = tryFn(() => true ? "12.2.2" : "latest");
       return ok ? version : "latest";
     })();
     this._resourcesMap = {};
@@ -37329,6 +35968,532 @@ class TfStatePlugin extends Plugin {
   }
 }
 
+const GRANULARITIES = {
+  minute: {
+    threshold: 3600,
+    // TTL < 1 hour
+    interval: 1e4,
+    // Check every 10 seconds
+    cohortsToCheck: 3,
+    // Check last 3 minutes
+    cohortFormat: (date) => date.toISOString().substring(0, 16)
+    // '2024-10-25T14:30'
+  },
+  hour: {
+    threshold: 86400,
+    // TTL < 24 hours
+    interval: 6e5,
+    // Check every 10 minutes
+    cohortsToCheck: 2,
+    // Check last 2 hours
+    cohortFormat: (date) => date.toISOString().substring(0, 13)
+    // '2024-10-25T14'
+  },
+  day: {
+    threshold: 2592e3,
+    // TTL < 30 days
+    interval: 36e5,
+    // Check every 1 hour
+    cohortsToCheck: 2,
+    // Check last 2 days
+    cohortFormat: (date) => date.toISOString().substring(0, 10)
+    // '2024-10-25'
+  },
+  week: {
+    threshold: Infinity,
+    // TTL >= 30 days
+    interval: 864e5,
+    // Check every 24 hours
+    cohortsToCheck: 2,
+    // Check last 2 weeks
+    cohortFormat: (date) => {
+      const year = date.getUTCFullYear();
+      const week = getWeekNumber(date);
+      return `${year}-W${String(week).padStart(2, "0")}`;
+    }
+  }
+};
+function getWeekNumber(date) {
+  const d = new Date(Date.UTC(date.getFullYear(), date.getMonth(), date.getDate()));
+  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);
+}
+function detectGranularity(ttl) {
+  if (!ttl) return "day";
+  if (ttl < GRANULARITIES.minute.threshold) return "minute";
+  if (ttl < GRANULARITIES.hour.threshold) return "hour";
+  if (ttl < GRANULARITIES.day.threshold) return "day";
+  return "week";
+}
+function getExpiredCohorts(granularity, count) {
+  const config = GRANULARITIES[granularity];
+  const cohorts = [];
+  const now = /* @__PURE__ */ new Date();
+  for (let i = 0; i < count; i++) {
+    let checkDate;
+    switch (granularity) {
+      case "minute":
+        checkDate = new Date(now.getTime() - i * 6e4);
+        break;
+      case "hour":
+        checkDate = new Date(now.getTime() - i * 36e5);
+        break;
+      case "day":
+        checkDate = new Date(now.getTime() - i * 864e5);
+        break;
+      case "week":
+        checkDate = new Date(now.getTime() - i * 6048e5);
+        break;
+    }
+    cohorts.push(config.cohortFormat(checkDate));
+  }
+  return cohorts;
+}
+class TTLPlugin extends Plugin {
+  constructor(config = {}) {
+    super(config);
+    this.verbose = config.verbose !== void 0 ? config.verbose : false;
+    this.resources = config.resources || {};
+    this.batchSize = config.batchSize || 100;
+    this.stats = {
+      totalScans: 0,
+      totalExpired: 0,
+      totalDeleted: 0,
+      totalArchived: 0,
+      totalSoftDeleted: 0,
+      totalCallbacks: 0,
+      totalErrors: 0,
+      lastScanAt: null,
+      lastScanDuration: 0
+    };
+    this.intervals = [];
+    this.isRunning = false;
+    this.expirationIndex = null;
+  }
+  /**
+   * Install the plugin
+   */
+  async install(database) {
+    await super.install(database);
+    for (const [resourceName, config] of Object.entries(this.resources)) {
+      this._validateResourceConfig(resourceName, config);
+    }
+    await this._createExpirationIndex();
+    for (const [resourceName, config] of Object.entries(this.resources)) {
+      this._setupResourceHooks(resourceName, config);
+    }
+    this._startIntervals();
+    if (this.verbose) {
+      console.log(`[TTLPlugin] Installed with ${Object.keys(this.resources).length} resources`);
+    }
+    this.emit("installed", {
+      plugin: "TTLPlugin",
+      resources: Object.keys(this.resources)
+    });
+  }
+  /**
+   * Validate resource configuration
+   */
+  _validateResourceConfig(resourceName, config) {
+    if (!config.ttl && !config.field) {
+      throw new Error(
+        `[TTLPlugin] Resource "${resourceName}" must have either "ttl" (seconds) or "field" (timestamp field name)`
+      );
+    }
+    const validStrategies = ["soft-delete", "hard-delete", "archive", "callback"];
+    if (!config.onExpire || !validStrategies.includes(config.onExpire)) {
+      throw new Error(
+        `[TTLPlugin] Resource "${resourceName}" must have an "onExpire" value. Valid options: ${validStrategies.join(", ")}`
+      );
+    }
+    if (config.onExpire === "soft-delete" && !config.deleteField) {
+      config.deleteField = "deletedat";
+    }
+    if (config.onExpire === "archive" && !config.archiveResource) {
+      throw new Error(
+        `[TTLPlugin] Resource "${resourceName}" with onExpire="archive" must have an "archiveResource" specified`
+      );
+    }
+    if (config.onExpire === "callback" && typeof config.callback !== "function") {
+      throw new Error(
+        `[TTLPlugin] Resource "${resourceName}" with onExpire="callback" must have a "callback" function`
+      );
+    }
+    if (!config.field) {
+      config.field = "_createdAt";
+    }
+    if (config.field === "_createdAt" && this.database) {
+      const resource = this.database.resources[resourceName];
+      if (resource && resource.config && resource.config.timestamps === false) {
+        console.warn(
+          `[TTLPlugin] WARNING: Resource "${resourceName}" uses TTL with field "_createdAt" but timestamps are disabled. TTL will be calculated from indexing time, not creation time.`
+        );
+      }
+    }
+    config.granularity = detectGranularity(config.ttl);
+  }
+  /**
+   * Create expiration index (plugin resource)
+   */
+  async _createExpirationIndex() {
+    this.expirationIndex = await this.database.createResource({
+      name: "plg_ttl_expiration_index",
+      attributes: {
+        resourceName: "string|required",
+        recordId: "string|required",
+        expiresAtCohort: "string|required",
+        expiresAtTimestamp: "number|required",
+        // Exact expiration timestamp for precise checking
+        granularity: "string|required",
+        createdAt: "number"
+      },
+      partitions: {
+        byExpiresAtCohort: {
+          fields: { expiresAtCohort: "string" }
+        }
+      },
+      asyncPartitions: false
+      // Sync partitions for deterministic behavior
+    });
+    if (this.verbose) {
+      console.log("[TTLPlugin] Created expiration index with partition");
+    }
+  }
+  /**
+   * Setup hooks for a resource
+   */
+  _setupResourceHooks(resourceName, config) {
+    if (!this.database.resources[resourceName]) {
+      if (this.verbose) {
+        console.warn(`[TTLPlugin] Resource "${resourceName}" not found, skipping hooks`);
+      }
+      return;
+    }
+    const resource = this.database.resources[resourceName];
+    if (typeof resource.insert !== "function" || typeof resource.delete !== "function") {
+      if (this.verbose) {
+        console.warn(`[TTLPlugin] Resource "${resourceName}" missing insert/delete methods, skipping hooks`);
+      }
+      return;
+    }
+    this.addMiddleware(resource, "insert", async (next, data, options) => {
+      const result = await next(data, options);
+      await this._addToIndex(resourceName, result, config);
+      return result;
+    });
+    this.addMiddleware(resource, "delete", async (next, id, options) => {
+      const result = await next(id, options);
+      await this._removeFromIndex(resourceName, id);
+      return result;
+    });
+    if (this.verbose) {
+      console.log(`[TTLPlugin] Setup hooks for resource "${resourceName}"`);
+    }
+  }
+  /**
+   * Add record to expiration index
+   */
+  async _addToIndex(resourceName, record, config) {
+    try {
+      let baseTime = record[config.field];
+      if (!baseTime && config.field === "_createdAt") {
+        baseTime = Date.now();
+      }
+      if (!baseTime) {
+        if (this.verbose) {
+          console.warn(
+            `[TTLPlugin] Record ${record.id} in ${resourceName} missing field "${config.field}", skipping index`
+          );
+        }
+        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 cohortConfig = GRANULARITIES[config.granularity];
+      const cohort = cohortConfig.cohortFormat(expiresAt);
+      const indexId = `${resourceName}:${record.id}`;
+      await this.expirationIndex.insert({
+        id: indexId,
+        resourceName,
+        recordId: record.id,
+        expiresAtCohort: cohort,
+        expiresAtTimestamp: expiresAt.getTime(),
+        // Store exact timestamp for precise checking
+        granularity: config.granularity,
+        createdAt: Date.now()
+      });
+      if (this.verbose) {
+        console.log(
+          `[TTLPlugin] Added ${resourceName}:${record.id} to index (cohort: ${cohort}, granularity: ${config.granularity})`
+        );
+      }
+    } catch (error) {
+      console.error(`[TTLPlugin] Error adding to index:`, error);
+      this.stats.totalErrors++;
+    }
+  }
+  /**
+   * Remove record from expiration index (O(1) using deterministic ID)
+   */
+  async _removeFromIndex(resourceName, recordId) {
+    try {
+      const indexId = `${resourceName}:${recordId}`;
+      const [ok, err] = await tryFn(() => this.expirationIndex.delete(indexId));
+      if (this.verbose && ok) {
+        console.log(`[TTLPlugin] Removed index entry for ${resourceName}:${recordId}`);
+      }
+      if (!ok && err?.code !== "NoSuchKey") {
+        throw err;
+      }
+    } catch (error) {
+      console.error(`[TTLPlugin] Error removing from index:`, error);
+    }
+  }
+  /**
+   * Start interval-based cleanup for each granularity
+   */
+  _startIntervals() {
+    const byGranularity = {
+      minute: [],
+      hour: [],
+      day: [],
+      week: []
+    };
+    for (const [name, config] of Object.entries(this.resources)) {
+      byGranularity[config.granularity].push({ name, config });
+    }
+    for (const [granularity, resources] of Object.entries(byGranularity)) {
+      if (resources.length === 0) continue;
+      const granularityConfig = GRANULARITIES[granularity];
+      const handle = setInterval(
+        () => this._cleanupGranularity(granularity, resources),
+        granularityConfig.interval
+      );
+      this.intervals.push(handle);
+      if (this.verbose) {
+        console.log(
+          `[TTLPlugin] Started ${granularity} interval (${granularityConfig.interval}ms) for ${resources.length} resources`
+        );
+      }
+    }
+    this.isRunning = true;
+  }
+  /**
+   * Stop all intervals
+   */
+  _stopIntervals() {
+    for (const handle of this.intervals) {
+      clearInterval(handle);
+    }
+    this.intervals = [];
+    this.isRunning = false;
+    if (this.verbose) {
+      console.log("[TTLPlugin] Stopped all intervals");
+    }
+  }
+  /**
+   * Cleanup expired records for a specific granularity
+   */
+  async _cleanupGranularity(granularity, resources) {
+    const startTime = Date.now();
+    this.stats.totalScans++;
+    try {
+      const granularityConfig = GRANULARITIES[granularity];
+      const cohorts = getExpiredCohorts(granularity, granularityConfig.cohortsToCheck);
+      if (this.verbose) {
+        console.log(`[TTLPlugin] Cleaning ${granularity} granularity, checking cohorts:`, cohorts);
+      }
+      for (const cohort of cohorts) {
+        const expired = await this.expirationIndex.listPartition({
+          partition: "byExpiresAtCohort",
+          partitionValues: { expiresAtCohort: cohort }
+        });
+        const resourceNames = new Set(resources.map((r) => r.name));
+        const filtered = expired.filter((e) => resourceNames.has(e.resourceName));
+        if (this.verbose && filtered.length > 0) {
+          console.log(`[TTLPlugin] Found ${filtered.length} expired records in cohort ${cohort}`);
+        }
+        for (let i = 0; i < filtered.length; i += this.batchSize) {
+          const batch = filtered.slice(i, i + this.batchSize);
+          for (const entry of batch) {
+            const config = this.resources[entry.resourceName];
+            await this._processExpiredEntry(entry, config);
+          }
+        }
+      }
+      this.stats.lastScanAt = (/* @__PURE__ */ new Date()).toISOString();
+      this.stats.lastScanDuration = Date.now() - startTime;
+      this.emit("scanCompleted", {
+        granularity,
+        duration: this.stats.lastScanDuration,
+        cohorts
+      });
+    } catch (error) {
+      console.error(`[TTLPlugin] Error in ${granularity} cleanup:`, error);
+      this.stats.totalErrors++;
+      this.emit("cleanupError", { granularity, error });
+    }
+  }
+  /**
+   * Process a single expired index entry
+   */
+  async _processExpiredEntry(entry, config) {
+    try {
+      if (!this.database.resources[entry.resourceName]) {
+        if (this.verbose) {
+          console.warn(`[TTLPlugin] Resource "${entry.resourceName}" not found during cleanup, skipping`);
+        }
+        return;
+      }
+      const resource = this.database.resources[entry.resourceName];
+      const [ok, err, record] = await tryFn(() => resource.get(entry.recordId));
+      if (!ok || !record) {
+        await this.expirationIndex.delete(entry.id);
+        return;
+      }
+      if (entry.expiresAtTimestamp && Date.now() < entry.expiresAtTimestamp) {
+        return;
+      }
+      switch (config.onExpire) {
+        case "soft-delete":
+          await this._softDelete(resource, record, config);
+          this.stats.totalSoftDeleted++;
+          break;
+        case "hard-delete":
+          await this._hardDelete(resource, record);
+          this.stats.totalDeleted++;
+          break;
+        case "archive":
+          await this._archive(resource, record, config);
+          this.stats.totalArchived++;
+          this.stats.totalDeleted++;
+          break;
+        case "callback":
+          const shouldDelete = await config.callback(record, resource);
+          this.stats.totalCallbacks++;
+          if (shouldDelete) {
+            await this._hardDelete(resource, record);
+            this.stats.totalDeleted++;
+          }
+          break;
+      }
+      await this.expirationIndex.delete(entry.id);
+      this.stats.totalExpired++;
+      this.emit("recordExpired", { resource: entry.resourceName, record });
+    } catch (error) {
+      console.error(`[TTLPlugin] Error processing expired entry:`, error);
+      this.stats.totalErrors++;
+    }
+  }
+  /**
+   * Soft delete: Mark record as deleted
+   */
+  async _softDelete(resource, record, config) {
+    const deleteField = config.deleteField || "deletedat";
+    const updates = {
+      [deleteField]: (/* @__PURE__ */ new Date()).toISOString(),
+      isdeleted: "true"
+      // Add isdeleted field for partition compatibility
+    };
+    await resource.update(record.id, updates);
+    if (this.verbose) {
+      console.log(`[TTLPlugin] Soft-deleted record ${record.id} in ${resource.name}`);
+    }
+  }
+  /**
+   * Hard delete: Remove record from S3
+   */
+  async _hardDelete(resource, record) {
+    await resource.delete(record.id);
+    if (this.verbose) {
+      console.log(`[TTLPlugin] Hard-deleted record ${record.id} in ${resource.name}`);
+    }
+  }
+  /**
+   * Archive: Copy to another resource then delete
+   */
+  async _archive(resource, record, config) {
+    if (!this.database.resources[config.archiveResource]) {
+      throw new Error(`Archive resource "${config.archiveResource}" not found`);
+    }
+    const archiveResource = this.database.resources[config.archiveResource];
+    const archiveData = {};
+    for (const [key, value] of Object.entries(record)) {
+      if (!key.startsWith("_")) {
+        archiveData[key] = value;
+      }
+    }
+    archiveData.archivedAt = (/* @__PURE__ */ new Date()).toISOString();
+    archiveData.archivedFrom = resource.name;
+    archiveData.originalId = record.id;
+    if (!config.keepOriginalId) {
+      delete archiveData.id;
+    }
+    await archiveResource.insert(archiveData);
+    await resource.delete(record.id);
+    if (this.verbose) {
+      console.log(`[TTLPlugin] Archived record ${record.id} from ${resource.name} to ${config.archiveResource}`);
+    }
+  }
+  /**
+   * Manual cleanup of a specific resource
+   */
+  async cleanupResource(resourceName) {
+    const config = this.resources[resourceName];
+    if (!config) {
+      throw new Error(`Resource "${resourceName}" not configured in TTLPlugin`);
+    }
+    const granularity = config.granularity;
+    await this._cleanupGranularity(granularity, [{ name: resourceName, config }]);
+    return {
+      resource: resourceName,
+      granularity
+    };
+  }
+  /**
+   * Manual cleanup of all resources
+   */
+  async runCleanup() {
+    const byGranularity = {
+      minute: [],
+      hour: [],
+      day: [],
+      week: []
+    };
+    for (const [name, config] of Object.entries(this.resources)) {
+      byGranularity[config.granularity].push({ name, config });
+    }
+    for (const [granularity, resources] of Object.entries(byGranularity)) {
+      if (resources.length > 0) {
+        await this._cleanupGranularity(granularity, resources);
+      }
+    }
+  }
+  /**
+   * Get plugin statistics
+   */
+  getStats() {
+    return {
+      ...this.stats,
+      resources: Object.keys(this.resources).length,
+      isRunning: this.isRunning,
+      intervals: this.intervals.length
+    };
+  }
+  /**
+   * Uninstall the plugin
+   */
+  async uninstall() {
+    this._stopIntervals();
+    await super.uninstall();
+    if (this.verbose) {
+      console.log("[TTLPlugin] Uninstalled");
+    }
+  }
+}
+
 function cosineDistance(a, b) {
   if (a.length !== b.length) {
     throw new Error(`Dimension mismatch: ${a.length} vs ${b.length}`);
@@ -39130,6 +38295,7 @@ exports.Factory = Factory;
 exports.FilesystemBackupDriver = FilesystemBackupDriver;
 exports.FilesystemCache = FilesystemCache;
 exports.FullTextPlugin = FullTextPlugin;
+exports.GeoPlugin = GeoPlugin;
 exports.InvalidResourceItem = InvalidResourceItem;
 exports.MemoryCache = MemoryCache;
 exports.MetadataLimitError = MetadataLimitError;
@@ -39177,6 +38343,7 @@ exports.SqsConsumer = SqsConsumer;
 exports.SqsReplicator = SqsReplicator;
 exports.StateMachinePlugin = StateMachinePlugin;
 exports.StreamError = StreamError;
+exports.TTLPlugin = TTLPlugin;
 exports.TfStatePlugin = TfStatePlugin;
 exports.TursoReplicator = TursoReplicator;
 exports.UnknownError = UnknownError;