npm - @cequrebackends/cequre-ts - Versions diffs - 0.11.4 - Mend

@cequrebackends/cequre-ts 0.11.4

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (60) hide show

package/dist/adapters/bun/bun-cron.d.ts +20 -0
package/dist/adapters/bun/bun-media.d.ts +9 -0
package/dist/adapters/bun/bun-redis-cache.d.ts +33 -0
package/dist/adapters/bun/bun-response.d.ts +13 -0
package/dist/adapters/bun/bun-server.d.ts +6 -0
package/dist/adapters/bun/bun-storage.d.ts +10 -0
package/dist/adapters/bun/bun-websocket.d.ts +104 -0
package/dist/adapters/bun/index.d.ts +9 -0
package/dist/adapters/bun/index.js +547 -0
package/dist/adapters/node/index.d.ts +9 -0
package/dist/adapters/node/index.js +902 -0
package/dist/adapters/node/node-cron.d.ts +20 -0
package/dist/adapters/node/node-media.d.ts +9 -0
package/dist/adapters/node/node-redis-cache.d.ts +32 -0
package/dist/adapters/node/node-response.d.ts +13 -0
package/dist/adapters/node/node-server.d.ts +6 -0
package/dist/adapters/node/node-storage.d.ts +10 -0
package/dist/adapters/node/node-websocket.d.ts +102 -0
package/dist/index-17yswtmg.js +175 -0
package/dist/index-kyvy0s1x.js +2662 -0
package/dist/index-mfqj7cwr.js +165 -0
package/dist/index-rf1kdn5b.js +732 -0
package/dist/index.d.ts +18 -0
package/dist/index.js +3152 -0
package/dist/interface-map.d.ts +175 -0
package/dist/shared/core/adapter.d.ts +84 -0
package/dist/shared/core/base-sql-adapter.d.ts +34 -0
package/dist/shared/core/cache.d.ts +8 -0
package/dist/shared/core/email.d.ts +53 -0
package/dist/shared/core/index.d.ts +12 -0
package/dist/shared/core/index.js +47 -0
package/dist/shared/core/openapi.d.ts +24 -0
package/dist/shared/core/plugins.d.ts +2 -0
package/dist/shared/core/request.d.ts +32 -0
package/dist/shared/core/sdk.d.ts +3 -0
package/dist/shared/core/stream.d.ts +24 -0
package/dist/shared/core/types-generator.d.ts +0 -0
package/dist/shared/core/types.d.ts +304 -0
package/dist/shared/core/ulid.d.ts +5 -0
package/dist/shared/core/validator.d.ts +32 -0
package/dist/shared/main/access-evaluator.d.ts +13 -0
package/dist/shared/main/access.d.ts +34 -0
package/dist/shared/main/aot.d.ts +3 -0
package/dist/shared/main/hooks.d.ts +76 -0
package/dist/shared/main/population.d.ts +13 -0
package/dist/shared/main/router.d.ts +112 -0
package/dist/shared/main/runtime.d.ts +195 -0
package/dist/shared/main/sse.d.ts +87 -0
package/dist/shared/utils/crypto.d.ts +23 -0
package/dist/shared/utils/durable-queue.d.ts +20 -0
package/dist/shared/utils/duration.d.ts +15 -0
package/dist/shared/utils/error.d.ts +52 -0
package/dist/shared/utils/kv/adapters/memory.d.ts +20 -0
package/dist/shared/utils/kv/adapters/sqlite.d.ts +32 -0
package/dist/shared/utils/kv/index.d.ts +37 -0
package/dist/shared/utils/kv/types.d.ts +38 -0
package/dist/shared/utils/logger.d.ts +42 -0
package/dist/shared/utils/queue-manager.d.ts +64 -0
package/dist/shared/utils/url.d.ts +13 -0
package/package.json +63 -0

package/dist/index-kyvy0s1x.js ADDED Viewed

@@ -0,0 +1,2662 @@
+// @bun
+import {
+  CequreError,
+  __esm,
+  __export,
+  __toCommonJS
+} from "./index-17yswtmg.js";
+// shared/core/openapi.ts
+var exports_openapi = {};
+__export(exports_openapi, {
+  generateScalarHTML: () => generateScalarHTML,
+  generateOpenAPISpec: () => generateOpenAPISpec
+});
+function generateScalarHTML(specUrl, title = "Cequre API") {
+  return `
+<!DOCTYPE html>
+<html>
+  <head>
+    <title>${title} - API Reference</title>
+    <meta charset="utf-8" />
+    <meta name="viewport" content="width=device-width, initial-scale=1" />
+    <style>
+      @import url("https://fonts.googleapis.com/css2?family=Bricolage+Grotesque:opsz,wght@12..96,200..800&family=Plus+Jakarta+Sans:ital,wght@0,200..800;1,200..800&family=Recursive:wght@300..1000&display=swap");
+      body { margin: 0; }
+      * { font-family: 'Plus Jakarta Sans', sans-serif !important; }
+    </style>
+  </head>
+  <body>
+    <!-- Mount Scalar UI -->
+    <script
+      id="api-reference"
+      data-url="${specUrl}"
+      data-theme="purple"
+      data-layout="modern"
+    ></script>
+    <script src="https://cdn.jsdelivr.net/npm/@scalar/api-reference"></script>
+  </body>
+</html>
+  `;
+}
+function fieldToSchema(field) {
+  let type = "string";
+  let format = undefined;
+  let items = undefined;
+  let properties = undefined;
+  switch (field.type) {
+    case "upload":
+      type = "object";
+      properties = {
+        filename: { type: "string" },
+        originalName: { type: "string" },
+        mimetype: { type: "string" },
+        size: { type: "number" },
+        url: { type: "string" }
+      };
+      break;
+    case "string":
+    case "text":
+      type = "string";
+      break;
+    case "email":
+      type = "string";
+      format = "email";
+      break;
+    case "password":
+      type = "string";
+      format = "password";
+      break;
+    case "boolean":
+      type = "boolean";
+      break;
+    case "number":
+    case "integer":
+      type = "number";
+      break;
+    case "date":
+      type = "string";
+      format = "date-time";
+      break;
+    case "object":
+      type = "object";
+      if (field.fields && field.fields.length > 0) {
+        properties = {};
+        for (const f of field.fields) {
+          properties[f.name] = fieldToSchema(f);
+        }
+      } else {
+        properties = {};
+      }
+      break;
+    case "array":
+      type = "array";
+      items = { type: "object", additionalProperties: true };
+      break;
+    case "json":
+    case "richtext":
+      type = "object";
+      properties = {};
+      break;
+    case "upload":
+      type = "object";
+      properties = {};
+      break;
+    case "select":
+      type = "string";
+      break;
+    case "multiselect":
+      type = "array";
+      items = { type: "string" };
+      break;
+  }
+  let schema = { type };
+  if (format)
+    schema.format = format;
+  if (type === "array" && field.type === "multiselect") {
+    if (field.values)
+      items.enum = field.values;
+    if (field.options)
+      items.enum = field.options;
+  } else {
+    if (field.values)
+      schema.enum = field.values;
+    if (field.options)
+      schema.enum = field.options;
+  }
+  if (properties)
+    schema.properties = properties;
+  if (items)
+    schema.items = items;
+  if (field.isArray) {
+    schema = { type: "array", items: schema };
+  }
+  if (field.default !== undefined)
+    schema.default = field.default;
+  if (field.optional)
+    schema.nullable = true;
+  return schema;
+}
+function buildCollectionSchema(collection, isInput = false, isUpdateInput = false, depth = 0, ast, isAuthCollection = false) {
+  const properties = {};
+  if (!isInput && !isUpdateInput) {
+    properties.id = { type: "string", format: "ulid" };
+    properties.createdAt = { type: "string", format: "date-time" };
+    properties.updatedAt = { type: "string", format: "date-time" };
+  }
+  const required = [];
+  for (const field of collection.fields) {
+    if ((field.type === "password" || field.hidden) && !isInput && !isUpdateInput)
+      continue;
+    if ((field.type === "password" || field.omit) && (isInput || isUpdateInput))
+      continue;
+    if (isAuthCollection && isUpdateInput && (field.name === "email" || field.name === "password"))
+      continue;
+    if ((field.type === "link" || field.type === "relation" || field.type === "relationship") && field.target && depth > 0 && ast && !isInput && !isUpdateInput) {
+      const targetCol = ast.collections.find((c) => c.slug === field.target);
+      if (targetCol) {
+        const targetSchema = buildCollectionSchema(targetCol, false, false, depth - 1, ast);
+        if (field.type === "link") {
+          properties[field.name] = { type: "array", items: targetSchema };
+        } else {
+          properties[field.name] = targetSchema;
+        }
+      } else {
+        properties[field.name] = fieldToSchema(field);
+      }
+    } else {
+      properties[field.name] = fieldToSchema(field);
+    }
+    if (field.type === "upload" && (isInput || isUpdateInput)) {
+      properties[field.name] = {
+        oneOf: [
+          properties[field.name],
+          { type: "string", format: "binary" }
+        ]
+      };
+    }
+    if (!field.optional && !isUpdateInput) {
+      required.push(field.name);
+    }
+  }
+  if (!isInput && !isUpdateInput) {
+    required.push("id", "createdAt", "updatedAt");
+  }
+  return {
+    type: "object",
+    properties,
+    ...required.length > 0 ? { required } : {}
+  };
+}
+function buildWhereSchema(collection, schema, schemaRefName, depth = 0) {
+  const properties = {
+    id: {
+      oneOf: [
+        { type: "string", format: "ulid" },
+        { type: "object", additionalProperties: true }
+      ]
+    },
+    createdAt: {
+      oneOf: [
+        { type: "string", format: "date-time" },
+        { type: "object", additionalProperties: true }
+      ]
+    },
+    updatedAt: {
+      oneOf: [
+        { type: "string", format: "date-time" },
+        { type: "object", additionalProperties: true }
+      ]
+    }
+  };
+  for (const field of collection.fields) {
+    if (field.type === "password")
+      continue;
+    if ((field.type === "link" || field.type === "relation") && field.target) {
+      let fieldSchema;
+      if (depth === 0) {
+        const targetCol = schema.collections.find((c) => c.slug === field.target);
+        if (targetCol) {
+          const targetSchemaRefName = targetCol.slug.split(/[-_]/).map((w) => w.charAt(0).toUpperCase() + w.slice(1)).join("");
+          fieldSchema = {
+            oneOf: [
+              { type: "string" },
+              { type: "object", additionalProperties: true },
+              buildWhereSchema(targetCol, schema, targetSchemaRefName, depth + 1)
+            ]
+          };
+        } else {
+          fieldSchema = {
+            oneOf: [{ type: "string" }, { type: "object", additionalProperties: true }]
+          };
+        }
+      } else {
+        fieldSchema = {
+          oneOf: [{ type: "string" }, { type: "object", additionalProperties: true }]
+        };
+      }
+      if (field.type === "link") {
+        properties[field.name] = { type: "array", items: fieldSchema };
+      } else {
+        properties[field.name] = fieldSchema;
+      }
+    } else {
+      properties[field.name] = {
+        oneOf: [
+          fieldToSchema(field),
+          { type: "object", additionalProperties: true }
+        ]
+      };
+    }
+  }
+  return {
+    type: "object",
+    properties: {
+      ...properties,
+      AND: { type: "array", items: { $ref: `#/components/schemas/${schemaRefName}WhereInput` } },
+      OR: { type: "array", items: { $ref: `#/components/schemas/${schemaRefName}WhereInput` } }
+    }
+  };
+}
+function typeboxToOpenAPISchema(schema) {
+  if (!schema || typeof schema !== "object")
+    return {};
+  const s = schema;
+  const kind = s[_TB_KIND];
+  switch (kind) {
+    case "String":
+    case "RegExp":
+    case "TemplateLiteral":
+      return { type: "string" };
+    case "Number":
+      return { type: "number" };
+    case "Integer":
+      return { type: "integer" };
+    case "Boolean":
+      return { type: "boolean" };
+    case "Null":
+      return { type: "null" };
+    case "Any":
+    case "Unknown":
+      return {};
+    case "Void":
+      return {};
+    case "Date":
+      return { type: "string", format: "date-time" };
+    case "File":
+    case "Blob":
+      return { type: "string", format: "binary" };
+    case "Literal": {
+      const val = s["const"];
+      const t = typeof val;
+      return t === "string" ? { type: "string", enum: [val] } : t === "number" ? { type: "number", enum: [val] } : { type: "boolean", enum: [val] };
+    }
+    case "Array":
+      return { type: "array", items: typeboxToOpenAPISchema(s["items"]) };
+    case "Tuple": {
+      const items = s["items"] ?? [];
+      return { type: "array", prefixItems: items.map(typeboxToOpenAPISchema), maxItems: items.length };
+    }
+    case "Union": {
+      const variants = s["anyOf"] ?? [];
+      return { oneOf: variants.map(typeboxToOpenAPISchema) };
+    }
+    case "Intersect": {
+      const variants = s["allOf"] ?? [];
+      return { allOf: variants.map(typeboxToOpenAPISchema) };
+    }
+    case "Object": {
+      const properties = s["properties"] ?? {};
+      const required = s["required"] ?? [];
+      const props = {};
+      for (const [key, val] of Object.entries(properties)) {
+        props[key] = typeboxToOpenAPISchema(val);
+      }
+      return {
+        type: "object",
+        properties: props,
+        ...required.length > 0 ? { required } : {}
+      };
+    }
+    default: {
+      if (s[_TB_MODIFIER] === "Optional") {
+        const { [_TB_MODIFIER]: _m, ...rest } = s;
+        return typeboxToOpenAPISchema(rest);
+      }
+      try {
+        const clean = JSON.parse(JSON.stringify(schema));
+        delete clean["$schema"];
+        return clean;
+      } catch {
+        return {};
+      }
+    }
+  }
+}
+function schemaHasFileField(schema) {
+  if (!schema || typeof schema !== "object")
+    return false;
+  const s = schema;
+  const kind = s[_TB_KIND];
+  if (kind === "File" || kind === "Blob")
+    return true;
+  if (kind === "Object") {
+    const props = s["properties"] ?? {};
+    return Object.values(props).some(schemaHasFileField);
+  }
+  return false;
+}
+function buildRequestBody(bodySchema) {
+  const oaSchema = typeboxToOpenAPISchema(bodySchema);
+  const contentType = schemaHasFileField(bodySchema) ? "multipart/form-data" : "application/json";
+  return {
+    required: true,
+    content: { [contentType]: { schema: oaSchema } }
+  };
+}
+function buildQueryParameters(querySchema) {
+  if (!querySchema || typeof querySchema !== "object")
+    return [];
+  const s = querySchema;
+  if (s[_TB_KIND] !== "Object")
+    return [];
+  const properties = s["properties"] ?? {};
+  const required = new Set(s["required"] ?? []);
+  return Object.entries(properties).map(([name, val]) => ({
+    name,
+    in: "query",
+    required: required.has(name),
+    schema: typeboxToOpenAPISchema(val)
+  }));
+}
+function buildResponsesFromSchema(responseSchema) {
+  if (!responseSchema || typeof responseSchema !== "object") {
+    return { "200": { description: "OK" } };
+  }
+  const s = responseSchema;
+  const kind = s[_TB_KIND];
+  if (kind) {
+    const oaSchema = typeboxToOpenAPISchema(responseSchema);
+    const isEmpty = Object.keys(oaSchema).length === 0;
+    return {
+      "200": {
+        description: "OK",
+        ...!isEmpty ? { content: { "application/json": { schema: oaSchema } } } : {}
+      }
+    };
+  }
+  const responses = {};
+  for (const [statusCode, val] of Object.entries(s)) {
+    if (!/^\d{3}$/.test(statusCode))
+      continue;
+    const valSchema = typeboxToOpenAPISchema(val);
+    const isEmpty = Object.keys(valSchema).length === 0;
+    responses[statusCode] = {
+      description: httpStatusDescription(Number(statusCode)),
+      ...!isEmpty ? { content: { "application/json": { schema: valSchema } } } : {}
+    };
+  }
+  return Object.keys(responses).length > 0 ? responses : { "200": { description: "OK" } };
+}
+function httpStatusDescription(code) {
+  const map = {
+    200: "OK",
+    201: "Created",
+    204: "No Content",
+    400: "Bad Request",
+    401: "Unauthorized",
+    403: "Forbidden",
+    404: "Not Found",
+    409: "Conflict",
+    422: "Unprocessable Entity",
+    429: "Too Many Requests",
+    500: "Internal Server Error"
+  };
+  return map[code] ?? "Response";
+}
+function generateOpenAPISpec(schema, serverUrl, prefix, app, includeHidden = false) {
+  const paths = {};
+  const components = { schemas: {} };
+  for (const collection of schema.collections) {
+    if (collection.hidden && !includeHidden)
+      continue;
+    const slug = collection.slug;
+    const tag = slug.split(/[-_]/).map((w) => w.charAt(0).toUpperCase() + w.slice(1)).join("");
+    const schemaRefName = tag;
+    const isAuthCol = !!collection.auth;
+    components.schemas[schemaRefName] = buildCollectionSchema(collection, false, false, 0, schema, isAuthCol);
+    components.schemas[`${schemaRefName}CreateInput`] = buildCollectionSchema(collection, true, false, 0, schema, isAuthCol);
+    components.schemas[`${schemaRefName}UpdateInput`] = buildCollectionSchema(collection, false, true, 0, schema, isAuthCol);
+    components.schemas[`${schemaRefName}Populated`] = buildCollectionSchema(collection, false, false, 1, schema, isAuthCol);
+    components.schemas[`${schemaRefName}PopulatedDepth2`] = buildCollectionSchema(collection, false, false, 2, schema, isAuthCol);
+    components.schemas[`${schemaRefName}WhereInput`] = buildWhereSchema(collection, schema, schemaRefName);
+    components.schemas[`${schemaRefName}QueryInput`] = {
+      type: "object",
+      properties: {
+        where: { $ref: `#/components/schemas/${schemaRefName}WhereInput` },
+        sort: { type: "string" },
+        limit: { type: "number" },
+        page: { type: "number" },
+        depth: { type: "number" }
+      }
+    };
+    components.schemas[`Paginated${schemaRefName}`] = {
+      type: "object",
+      properties: {
+        docs: { type: "array", items: { $ref: `#/components/schemas/${schemaRefName}` } },
+        totalDocs: { type: "number" },
+        limit: { type: "number" },
+        page: { type: "number" },
+        totalPages: { type: "number" },
+        hasNextPage: { type: "boolean" },
+        hasPrevPage: { type: "boolean" }
+      },
+      required: ["docs", "totalDocs", "limit", "page", "totalPages", "hasNextPage", "hasPrevPage"]
+    };
+    components.schemas[`Paginated${schemaRefName}Populated`] = {
+      type: "object",
+      properties: {
+        docs: { type: "array", items: { $ref: `#/components/schemas/${schemaRefName}Populated` } },
+        totalDocs: { type: "number" },
+        limit: { type: "number" },
+        page: { type: "number" },
+        totalPages: { type: "number" },
+        hasNextPage: { type: "boolean" },
+        hasPrevPage: { type: "boolean" }
+      },
+      required: ["docs", "totalDocs", "limit", "page", "totalPages", "hasNextPage", "hasPrevPage"]
+    };
+    components.schemas[`Paginated${schemaRefName}PopulatedDepth2`] = {
+      type: "object",
+      properties: {
+        docs: { type: "array", items: { $ref: `#/components/schemas/${schemaRefName}PopulatedDepth2` } },
+        totalDocs: { type: "number" },
+        limit: { type: "number" },
+        page: { type: "number" },
+        totalPages: { type: "number" },
+        hasNextPage: { type: "boolean" },
+        hasPrevPage: { type: "boolean" }
+      },
+      required: ["docs", "totalDocs", "limit", "page", "totalPages", "hasNextPage", "hasPrevPage"]
+    };
+    const basePath = `${prefix}/${slug}`;
+    const itemPath = `${basePath}/{id}`;
+    paths[basePath] = {
+      get: {
+        tags: [tag],
+        summary: `List ${slug}`,
+        parameters: [{ name: "q", in: "query", description: "JSON stringified QueryArgs object", schema: { $ref: `#/components/schemas/${schemaRefName}QueryInput` } }],
+        responses: {
+          "200": {
+            description: "List of documents",
+            content: {
+              "application/json": {
+                schema: { $ref: `#/components/schemas/Paginated${schemaRefName}` }
+              }
+            }
+          }
+        }
+      },
+      post: {
+        tags: [tag],
+        summary: `Create ${slug}`,
+        requestBody: { content: { "application/json": { schema: { $ref: `#/components/schemas/${schemaRefName}CreateInput` } } } },
+        responses: {
+          "201": {
+            description: "Document created",
+            content: {
+              "application/json": {
+                schema: { $ref: `#/components/schemas/${schemaRefName}` }
+              }
+            }
+          }
+        }
+      }
+    };
+    paths[itemPath] = {
+      get: {
+        tags: [tag],
+        summary: `Get ${slug} by ID`,
+        parameters: [
+          { name: "id", in: "path", required: true, schema: { type: "string", format: "ulid" } },
+          { name: "q", in: "query", description: "JSON stringified QueryArgs object", schema: { type: "object", properties: { depth: { type: "number" } } } }
+        ],
+        responses: {
+          "200": {
+            description: "Document found",
+            content: { "application/json": { schema: { $ref: `#/components/schemas/${schemaRefName}` } } }
+          }
+        }
+      },
+      patch: {
+        tags: [tag],
+        summary: `Update ${slug}`,
+        parameters: [{ name: "id", in: "path", required: true, schema: { type: "string", format: "ulid" } }],
+        requestBody: { content: { "application/json": { schema: { $ref: `#/components/schemas/${schemaRefName}UpdateInput` } } } },
+        responses: {
+          "200": {
+            description: "Document updated",
+            content: {
+              "application/json": { schema: { $ref: `#/components/schemas/${schemaRefName}` } }
+            }
+          }
+        }
+      },
+      delete: {
+        tags: [tag],
+        summary: `Delete ${slug}`,
+        parameters: [{ name: "id", in: "path", required: true, schema: { type: "string" } }],
+        responses: {
+          "200": { description: "Document deleted" }
+        }
+      }
+    };
+    if (collection.auth) {
+      const registerRequired = ["email", "password"];
+      const registerProperties = {
+        email: { type: "string", format: "email" },
+        password: { type: "string", format: "password" }
+      };
+      for (const field of collection.fields) {
+        if (field.name !== "email" && field.name !== "password") {
+          if (field.omit)
+            continue;
+          registerProperties[field.name] = fieldToSchema(field);
+          if (!field.optional)
+            registerRequired.push(field.name);
+        }
+      }
+      const authSuccessSchemaRefName = `AuthResponse`;
+      components.schemas[authSuccessSchemaRefName] = {
+        type: "object",
+        properties: {
+          user: { $ref: `#/components/schemas/${schemaRefName}` },
+          accessToken: { type: "string" },
+          refreshToken: { type: "string" },
+          message: { type: "string" }
+        }
+      };
+      const registerSchemaRefName = `AuthRegisterInput`;
+      components.schemas[registerSchemaRefName] = {
+        type: "object",
+        required: registerRequired,
+        properties: registerProperties
+      };
+      const loginSchemaRefName = `AuthLoginInput`;
+      if (!components.schemas[loginSchemaRefName]) {
+        components.schemas[loginSchemaRefName] = {
+          type: "object",
+          required: ["email", "password"],
+          properties: {
+            email: { type: "string", format: "email" },
+            password: { type: "string", format: "password" }
+          }
+        };
+      }
+      const refreshSchemaRefName = `AuthRefreshInput`;
+      if (!components.schemas[refreshSchemaRefName]) {
+        components.schemas[refreshSchemaRefName] = {
+          type: "object",
+          required: ["refreshToken"],
+          properties: { refreshToken: { type: "string" } }
+        };
+      }
+      const forgotSchemaRefName = `AuthForgotPasswordInput`;
+      if (!components.schemas[forgotSchemaRefName]) {
+        components.schemas[forgotSchemaRefName] = {
+          type: "object",
+          required: ["email"],
+          properties: { email: { type: "string", format: "email" } }
+        };
+      }
+      const resetSchemaRefName = `AuthResetPasswordInput`;
+      if (!components.schemas[resetSchemaRefName]) {
+        components.schemas[resetSchemaRefName] = {
+          type: "object",
+          required: ["token", "newPassword"],
+          properties: {
+            token: { type: "string" },
+            newPassword: { type: "string", format: "password" }
+          }
+        };
+      }
+      paths[`${basePath}/register`] = {
+        post: {
+          tags: ["Auth"],
+          summary: "Register",
+          requestBody: {
+            required: true,
+            content: {
+              "application/json": {
+                schema: { $ref: `#/components/schemas/${registerSchemaRefName}` }
+              }
+            }
+          },
+          responses: {
+            "201": {
+              description: "Registration successful",
+              content: { "application/json": { schema: { $ref: `#/components/schemas/${authSuccessSchemaRefName}` } } }
+            }
+          }
+        }
+      };
+      paths[`${basePath}/login`] = {
+        post: {
+          tags: ["Auth"],
+          summary: "Login",
+          requestBody: {
+            required: true,
+            content: {
+              "application/json": {
+                schema: { $ref: `#/components/schemas/${loginSchemaRefName}` }
+              }
+            }
+          },
+          responses: {
+            "200": {
+              description: "Login successful",
+              content: { "application/json": { schema: { $ref: `#/components/schemas/${authSuccessSchemaRefName}` } } }
+            }
+          }
+        }
+      };
+      paths[`${basePath}/me`] = {
+        get: {
+          tags: ["Auth"],
+          summary: "Get Current User",
+          responses: {
+            "200": {
+              description: "Current user data",
+              content: { "application/json": { schema: { $ref: `#/components/schemas/${schemaRefName}` } } }
+            }
+          }
+        }
+      };
+      paths[`${basePath}/refresh`] = {
+        post: {
+          tags: ["Auth"],
+          summary: "Refresh token",
+          requestBody: {
+            required: true,
+            content: {
+              "application/json": {
+                schema: { $ref: `#/components/schemas/${refreshSchemaRefName}` }
+              }
+            }
+          },
+          responses: {
+            "200": {
+              description: "Tokens refreshed",
+              content: { "application/json": { schema: { $ref: `#/components/schemas/${authSuccessSchemaRefName}` } } }
+            }
+          }
+        }
+      };
+      paths[`${basePath}/logout`] = {
+        post: {
+          tags: ["Auth"],
+          summary: "Logout",
+          responses: {
+            "200": { description: "Logged out successfully" }
+          }
+        }
+      };
+      paths[`${basePath}/forgot-password`] = {
+        post: {
+          tags: ["Auth"],
+          summary: "Forgot Password",
+          requestBody: {
+            required: true,
+            content: {
+              "application/json": {
+                schema: { $ref: `#/components/schemas/${forgotSchemaRefName}` }
+              }
+            }
+          },
+          responses: {
+            "200": {
+              description: "Password reset email sent (if account exists)"
+            }
+          }
+        }
+      };
+      paths[`${basePath}/reset-password`] = {
+        post: {
+          tags: ["Auth"],
+          summary: "Reset Password",
+          requestBody: {
+            required: true,
+            content: {
+              "application/json": {
+                schema: { $ref: `#/components/schemas/${resetSchemaRefName}` }
+              }
+            }
+          },
+          responses: {
+            "200": {
+              description: "Password reset successfully"
+            },
+            "400": {
+              description: "Invalid or expired token"
+            }
+          }
+        }
+      };
+      const mfaVerifySchemaRefName = `AuthMfaVerifyInput`;
+      if (!components.schemas[mfaVerifySchemaRefName]) {
+        components.schemas[mfaVerifySchemaRefName] = {
+          type: "object",
+          required: ["mfaCode"],
+          properties: { mfaCode: { type: "string" } }
+        };
+      }
+      const mfaLoginSchemaRefName = `AuthMfaLoginInput`;
+      if (!components.schemas[mfaLoginSchemaRefName]) {
+        components.schemas[mfaLoginSchemaRefName] = {
+          type: "object",
+          required: ["mfaToken", "mfaCode"],
+          properties: {
+            mfaToken: { type: "string" },
+            mfaCode: { type: "string" }
+          }
+        };
+      }
+      paths[`${basePath}/mfa/enroll`] = {
+        post: {
+          tags: ["Auth"],
+          summary: "Enroll MFA",
+          responses: {
+            "200": {
+              description: "MFA enrollment started",
+              content: { "application/json": { schema: { type: "object", properties: { secret: { type: "string" }, uri: { type: "string" }, backupCodes: { type: "array", items: { type: "string" } } } } } }
+            }
+          }
+        }
+      };
+      paths[`${basePath}/mfa/verify`] = {
+        post: {
+          tags: ["Auth"],
+          summary: "Verify MFA Setup",
+          requestBody: {
+            required: true,
+            content: { "application/json": { schema: { $ref: `#/components/schemas/${mfaVerifySchemaRefName}` } } }
+          },
+          responses: { "200": { description: "MFA verified successfully" } }
+        }
+      };
+      paths[`${basePath}/mfa/login`] = {
+        post: {
+          tags: ["Auth"],
+          summary: "Complete MFA Login",
+          requestBody: {
+            required: true,
+            content: { "application/json": { schema: { $ref: `#/components/schemas/${mfaLoginSchemaRefName}` } } }
+          },
+          responses: {
+            "200": {
+              description: "Login successful",
+              content: { "application/json": { schema: { $ref: `#/components/schemas/${authSuccessSchemaRefName}` } } }
+            }
+          }
+        }
+      };
+      paths[`${basePath}/mfa/disable`] = {
+        post: {
+          tags: ["Auth"],
+          summary: "Disable MFA",
+          requestBody: {
+            required: true,
+            content: { "application/json": { schema: { $ref: `#/components/schemas/${mfaVerifySchemaRefName}` } } }
+          },
+          responses: { "200": { description: "MFA disabled successfully" } }
+        }
+      };
+    }
+  }
+  if (schema.globals) {
+    for (const glob of schema.globals) {
+      const slug = glob.slug;
+      const tag = "Globals";
+      const schemaRefName = slug.split(/[-_]/).map((w) => w.charAt(0).toUpperCase() + w.slice(1)).join("") + "Global";
+      components.schemas[schemaRefName] = buildCollectionSchema(glob);
+      components.schemas[`${schemaRefName}CreateInput`] = buildCollectionSchema(glob, true, false);
+      components.schemas[`${schemaRefName}UpdateInput`] = buildCollectionSchema(glob, false, true);
+      const basePath = `${prefix}/globals/${slug}`;
+      paths[basePath] = {
+        get: {
+          tags: [tag],
+          summary: `Get global configuration: ${slug}`,
+          responses: {
+            "200": {
+              description: "Global document",
+              content: {
+                "application/json": { schema: { $ref: `#/components/schemas/${schemaRefName}` } }
+              }
+            }
+          }
+        },
+        post: {
+          tags: [tag],
+          summary: `Create or Update global configuration: ${slug}`,
+          requestBody: {
+            required: true,
+            content: {
+              "application/json": { schema: { $ref: `#/components/schemas/${schemaRefName}CreateInput` } }
+            }
+          },
+          responses: {
+            "200": {
+              description: "Global document updated",
+              content: {
+                "application/json": { schema: { $ref: `#/components/schemas/${schemaRefName}` } }
+              }
+            }
+          }
+        },
+        patch: {
+          tags: [tag],
+          summary: `Patch global configuration: ${slug}`,
+          requestBody: {
+            required: true,
+            content: {
+              "application/json": { schema: { $ref: `#/components/schemas/${schemaRefName}UpdateInput` } }
+            }
+          },
+          responses: {
+            "200": {
+              description: "Global document updated",
+              content: {
+                "application/json": { schema: { $ref: `#/components/schemas/${schemaRefName}` } }
+              }
+            }
+          }
+        }
+      };
+    }
+  }
+  if (app?.routes) {
+    for (const route of app.routes) {
+      const method = route.method?.toLowerCase();
+      const rawPath = route.path;
+      if (!method || !rawPath)
+        continue;
+      const routePath = rawPath.replace(/:([a-zA-Z_][a-zA-Z0-9_]*)/g, "{$1}");
+      const options = route.options || route.hooks || {};
+      const detail = options.detail;
+      if (detail?.hide)
+        continue;
+      const routeTags = detail?.tags ?? options.tags ?? [];
+      if (method === "options" || paths[routePath]?.[method])
+        continue;
+      const isInternalPath = rawPath.startsWith(`${prefix}/docs`);
+      if (isInternalPath)
+        continue;
+      const isHiddenCollectionPath = schema.collections.some((c) => c.hidden && rawPath.startsWith(`${prefix}/${c.slug}`));
+      if (isHiddenCollectionPath)
+        continue;
+      const operationTags = routeTags.length ? routeTags : ["Custom"];
+      const operation = {
+        ...detail ?? {},
+        tags: operationTags
+      };
+      const bodySchema = options.body;
+      const querySchema = options.query;
+      const responseSchema = options.response;
+      if (bodySchema && !operation.requestBody && ["post", "put", "patch"].includes(method)) {
+        operation.requestBody = buildRequestBody(bodySchema);
+      }
+      if (querySchema) {
+        const generatedParams = buildQueryParameters(querySchema);
+        if (generatedParams.length > 0) {
+          operation.parameters = [
+            ...generatedParams,
+            ...operation.parameters ?? []
+          ];
+        }
+      }
+      if (responseSchema && !operation.responses) {
+        operation.responses = buildResponsesFromSchema(responseSchema);
+      } else if (!operation.responses) {
+        operation.responses = { "200": { description: "OK" } };
+      }
+      if (route.options?.stream || route.hooks?.stream) {
+        operation.responses = operation.responses || {};
+        operation.responses["200"] = operation.responses["200"] || { description: "OK" };
+        operation.responses["200"].content = operation.responses["200"].content || {};
+        operation.responses["200"].content["text/event-stream"] = { schema: { type: "string" } };
+      }
+      paths[routePath] ??= {};
+      paths[routePath][method] = operation;
+    }
+  }
+  return {
+    openapi: "3.0.3",
+    info: { title: "Cequre API", version: "1.0.0" },
+    servers: [{ url: serverUrl }],
+    paths,
+    components
+  };
+}
+var _TB_KIND, _TB_MODIFIER;
+var init_openapi = __esm(() => {
+  _TB_KIND = Symbol.for("TypeBox.Kind");
+  _TB_MODIFIER = Symbol.for("TypeBox.Modifier");
+});
+// shared/core/sdk.ts
+var exports_sdk = {};
+__export(exports_sdk, {
+  generateTypeScriptClientSDK: () => generateTypeScriptClientSDK,
+  generateSharedModels: () => generateSharedModels,
+  generateBackendSchemas: () => generateBackendSchemas
+});
+function generateSharedModels(schema, routes) {
+  const openApiSpec = generateOpenAPISpec(schema, "http://localhost:3000", "/api", { routes }, true);
+  const models = [];
+  const schemas = openApiSpec.components?.schemas || {};
+  function resolveType(s) {
+    if (!s)
+      return "any";
+    if (s.$ref) {
+      return s.$ref.split("/").pop();
+    }
+    switch (s.type) {
+      case "string":
+        if (s.format === "binary")
+          return "string | File | Blob";
+        if (s.format === "date-time")
+          return "string | Date";
+        return s.enum ? s.enum.map((e) => `"${e}"`).join(" | ") : "string";
+      case "number":
+      case "integer":
+        return s.enum ? s.enum.join(" | ") : "number";
+      case "boolean":
+        return s.enum ? s.enum.join(" | ") : "boolean";
+      case "array":
+        return `Array<${resolveType(s.items)}>`;
+      case "object":
+        if (s.properties) {
+          const props = Object.entries(s.properties).map(([key, val]) => {
+            const isRequired = s.required?.includes(key);
+            const safeKey = /^[a-zA-Z_$][a-zA-Z0-9_$]*$/.test(key) ? key : `"${key}"`;
+            return `  ${safeKey}${isRequired ? "" : "?"}: ${resolveType(val)};`;
+          }).join(`
+`);
+          return `{
+${props}
+}`;
+        }
+        return "Record<string, any>";
+      default:
+        if (s.enum) {
+          return s.enum.map((e) => `"${e}"`).join(" | ");
+        }
+        if (s.anyOf) {
+          return s.anyOf.map((s2) => resolveType(s2)).join(" | ");
+        }
+        if (s.allOf) {
+          return s.allOf.map((s2) => resolveType(s2)).join(" & ");
+        }
+        if (s.oneOf) {
+          return s.oneOf.map((s2) => resolveType(s2)).join(" | ");
+        }
+        return "any";
+    }
+  }
+  for (const [schemaName, schemaDef] of Object.entries(schemas)) {
+    const resolved = resolveType(schemaDef);
+    if (resolved.startsWith(`{
+`)) {
+      models.push(`export interface ${schemaName} ${resolved}`);
+    } else {
+      models.push(`export type ${schemaName} = ${resolved};`);
+    }
+  }
+  return models.join(`
+`) + `
+`;
+}
+function generateTypeScriptClientSDK(schema, routes) {
+  const openApiSpec = generateOpenAPISpec(schema, "http://localhost:3000", "/api", { routes });
+  const modelsString = generateSharedModels(schema, routes);
+  const models = [modelsString.trim()];
+  function resolveType(s) {
+    if (!s)
+      return "any";
+    if (s.$ref) {
+      return s.$ref.split("/").pop();
+    }
+    switch (s.type) {
+      case "string":
+        if (s.format === "binary")
+          return "string | File | Blob";
+        return s.enum ? s.enum.map((e) => `"${e}"`).join(" | ") : "string";
+      case "number":
+      case "integer":
+        return s.enum ? s.enum.join(" | ") : "number";
+      case "boolean":
+        return s.enum ? s.enum.join(" | ") : "boolean";
+      case "array":
+        return `Array<${resolveType(s.items)}>`;
+      case "object":
+        if (s.properties) {
+          const props = Object.entries(s.properties).map(([key, val]) => {
+            const isRequired = s.required?.includes(key);
+            const safeKey = /^[a-zA-Z_$][a-zA-Z0-9_$]*$/.test(key) ? key : `"${key}"`;
+            return `  ${safeKey}${isRequired ? "" : "?"}: ${resolveType(val)};`;
+          }).join(`
+`);
+          return `{
+${props}
+}`;
+        }
+        return "Record<string, any>";
+      default:
+        if (s.enum) {
+          return s.enum.map((e) => `"${e}"`).join(" | ");
+        }
+        if (s.anyOf) {
+          return s.anyOf.map((s2) => resolveType(s2)).join(" | ");
+        }
+        if (s.allOf) {
+          return s.allOf.map((s2) => resolveType(s2)).join(" & ");
+        }
+        if (s.oneOf) {
+          return s.oneOf.map((s2) => resolveType(s2)).join(" | ");
+        }
+        return "any";
+    }
+  }
+  function getTypeForPath(method, path) {
+    const op = openApiSpec.paths?.[path]?.[method];
+    if (!op)
+      return "any";
+    const successRes = op.responses?.["200"] || op.responses?.["201"];
+    if (successRes?.content?.["application/json"]?.schema) {
+      return resolveType(successRes.content["application/json"].schema);
+    } else if (successRes && !successRes.content) {
+      return "void";
+    }
+    return "any";
+  }
+  function getReqForPath(method, path) {
+    const op = openApiSpec.paths?.[path]?.[method];
+    if (!op)
+      return "any";
+    if (op.requestBody?.content?.["application/json"]?.schema) {
+      return resolveType(op.requestBody.content["application/json"].schema);
+    } else if (op.requestBody?.content?.["multipart/form-data"]?.schema) {
+      return "FormData | any";
+    }
+    return "any";
+  }
+  function getQueryTypeForPath(path) {
+    const op = openApiSpec.paths?.[path]?.get;
+    if (!op || !op.parameters)
+      return "any";
+    const qParam = op.parameters.find((p) => p.name === "q" && p.in === "query");
+    if (qParam?.schema) {
+      return resolveType(qParam.schema);
+    }
+    return "any";
+  }
+  const root = { methods: [], children: {} };
+  let hasRoutes = false;
+  const prefix = schema.core?.api?.prefix || "/api";
+  for (const col of schema.collections || []) {
+    if (col.hidden)
+      continue;
+    const className = col.slug.split(/[-_]/).map((w) => w.charAt(0).toUpperCase() + w.slice(1)).join("");
+    const getListRes = getTypeForPath("get", `${prefix}/${col.slug}`);
+    const getListQuery = getQueryTypeForPath(`${prefix}/${col.slug}`);
+    const getSingleRes = getTypeForPath("get", `${prefix}/${col.slug}/{id}`);
+    const postReq = getReqForPath("post", `${prefix}/${col.slug}`);
+    const postRes = getTypeForPath("post", `${prefix}/${col.slug}`);
+    const patchReq = getReqForPath("patch", `${prefix}/${col.slug}/{id}`);
+    const patchRes = getTypeForPath("patch", `${prefix}/${col.slug}/{id}`);
+    const deleteRes = getTypeForPath("delete", `${prefix}/${col.slug}/{id}`);
+    const publicFields = col.fields.filter((f) => f.type !== "password" && !f.hidden);
+    const schemaObjStr = JSON.stringify(publicFields.reduce((acc, f) => {
+      acc[f.name] = {
+        type: f.type,
+        required: !f.optional,
+        ...f.values ? { values: f.values } : {},
+        ...f.target ? { target: f.target } : {}
+      };
+      return acc;
+    }, {}));
+    const methods = [
+      `schema: ${schemaObjStr} as const,`,
+      `get: ((params?: { id?: string; query?: ${getListQuery} }) => {
+        if (params?.id) return parent.request<any>('GET', \`${prefix}/${col.slug}/\${params.id}\${params?.query ? '?' + new URLSearchParams({ q: JSON.stringify(params.query) }).toString() : ''}\`);
+        return parent.request<any>('GET', \`${prefix}/${col.slug}\${params?.query ? '?' + new URLSearchParams({ q: JSON.stringify(params.query) }).toString() : ''}\`);
+      }) as {
+        (params: { id: string, query: { depth: 2 } }): Promise<SDKResponse<${className}PopulatedDepth2>>;
+        (params: { id: string, query: { depth: 1 } }): Promise<SDKResponse<${className}Populated>>;
+        (params: { id: string, query?: { depth?: number } }): Promise<SDKResponse<${getSingleRes}>>;
+        (params: { query: ${getListQuery} & { depth: 2 } }): Promise<SDKResponse<Paginated${className}PopulatedDepth2>>;
+        (params: { query: ${getListQuery} & { depth: 1 } }): Promise<SDKResponse<Paginated${className}Populated>>;
+        (params?: { query?: ${getListQuery} }): Promise<SDKResponse<${getListRes}>>;
+      },`,
+      `post: (data: ${postReq}) => parent.request<${postRes}>('POST', \`${prefix}/${col.slug}\`, data),`,
+      `patch: (id: string, data: ${patchReq}) => parent.request<${patchRes}>('PATCH', \`${prefix}/${col.slug}/\${id}\`, data),`,
+      `delete: (id: string) => parent.request<${deleteRes}>('DELETE', \`${prefix}/${col.slug}/\${id}\`),`,
+      `subscribeSSE: async (onEvent: (event: { type: 'created' | 'updated' | 'deleted'; data: ${className} }) => void) => await parent.subscribeSSE(\`${prefix}/${col.slug}/_subscribe\`, onEvent),`,
+      `subscribeWS: async (onEvent: (event: { type: 'created' | 'updated' | 'deleted'; data: ${className} }) => void) => await parent.subscribeWS(\`${prefix}/${col.slug}/_subscribe\`, onEvent),`
+    ];
+    if (!root.children[col.slug]) {
+      root.children[col.slug] = { methods: [], children: {} };
+    }
+    root.children[col.slug].methods.push(...methods);
+    hasRoutes = true;
+    if (col.auth && !root.children["auth"]) {
+      root.children["auth"] = { methods: [], children: {} };
+      const meRes = getTypeForPath("get", `${prefix}/${col.slug}/me`);
+      root.children[col.slug].methods.push(`me: () => parent.request<${meRes}>('GET', \`${prefix}/${col.slug}/me\`),`);
+    }
+  }
+  for (const glob of schema.globals || []) {
+    const className = glob.slug.split(/[-_]/).map((w) => w.charAt(0).toUpperCase() + w.slice(1)).join("") + "Global";
+    const getRes = getTypeForPath("get", `${prefix}/globals/${glob.slug}`);
+    const patchReq = getReqForPath("patch", `${prefix}/globals/${glob.slug}`);
+    const patchRes = getTypeForPath("patch", `${prefix}/globals/${glob.slug}`);
+    const methods = [
+      `get: () => parent.request<${getRes}>('GET', \`${prefix}/globals/${glob.slug}\`),`,
+      `patch: (data: ${patchReq}) => parent.request<${patchRes}>('PATCH', \`${prefix}/globals/${glob.slug}\`, data),`
+    ];
+    if (!root.children["globals"]) {
+      root.children["globals"] = { methods: [], children: {} };
+    }
+    if (!root.children["globals"].children[glob.slug]) {
+      root.children["globals"].children[glob.slug] = { methods: [], children: {} };
+    }
+    root.children["globals"].children[glob.slug].methods.push(...methods);
+    hasRoutes = true;
+  }
+  const standardPaths = new Set;
+  for (const col of schema.collections || []) {
+    standardPaths.add(`get:${prefix}/${col.slug}`);
+    standardPaths.add(`get:${prefix}/${col.slug}/{id}`);
+    standardPaths.add(`post:${prefix}/${col.slug}`);
+    standardPaths.add(`patch:${prefix}/${col.slug}/{id}`);
+    standardPaths.add(`delete:${prefix}/${col.slug}/{id}`);
+    if (col.auth) {
+      standardPaths.add(`get:${prefix}/${col.slug}/me`);
+    }
+  }
+  for (const glob of schema.globals || []) {
+    standardPaths.add(`get:${prefix}/globals/${glob.slug}`);
+    standardPaths.add(`patch:${prefix}/globals/${glob.slug}`);
+    standardPaths.add(`post:${prefix}/globals/${glob.slug}`);
+  }
+  for (const [rawPath, pathItem] of Object.entries(openApiSpec.paths || {})) {
+    for (const [method, operationRaw] of Object.entries(pathItem)) {
+      const operation = operationRaw;
+      if (standardPaths.has(`${method.toLowerCase()}:${rawPath}`))
+        continue;
+      if (rawPath.startsWith(`${prefix}/docs`) || method === "options")
+        continue;
+      let reqType = "any";
+      let reqOptional = true;
+      if (operation.requestBody) {
+        reqOptional = !operation.requestBody.required;
+      }
+      if (operation.requestBody?.content?.["application/json"]?.schema) {
+        reqType = resolveType(operation.requestBody.content["application/json"].schema);
+      } else if (operation.requestBody?.content?.["multipart/form-data"]?.schema) {
+        reqType = "FormData | any";
+      }
+      let resType = "any";
+      let isStream = false;
+      let isMediaStream = false;
+      const successRes = operation.responses?.["200"] || operation.responses?.["201"];
+      if (operation.responses?.["206"]) {
+        isMediaStream = true;
+      }
+      if (successRes?.content?.["text/event-stream"]) {
+        isStream = true;
+      }
+      if (successRes?.content?.["application/json"]?.schema) {
+        resType = resolveType(successRes.content["application/json"].schema);
+      } else if (successRes && !successRes.content) {
+        resType = "Blob | any";
+      }
+      let p = rawPath;
+      if (p.startsWith(prefix))
+        p = p.slice(prefix.length);
+      if (p.startsWith("/"))
+        p = p.slice(1);
+      const segments = p.split("/").filter(Boolean);
+      let isAuthRoute = false;
+      if (segments.length === 2 && segments[1] !== undefined && ["login", "register", "refresh", "logout", "forgot-password", "reset-password"].includes(segments[1])) {
+        const isAuthCollectionRoute = schema.collections?.some((c) => c.slug === segments[0] && c.auth);
+        if (isAuthCollectionRoute) {
+          segments[0] = "auth";
+          isAuthRoute = true;
+          segments[1] = segments[1].replace(/-([a-z])/g, (g) => g[1].toUpperCase());
+        }
+      } else if (segments.length === 3 && segments[1] === "mfa" && segments[2] !== undefined && ["enroll", "verify", "login", "disable"].includes(segments[2])) {
+        const isAuthCollectionRoute = schema.collections?.some((c) => c.slug === segments[0] && c.auth);
+        if (isAuthCollectionRoute) {
+          segments[0] = "auth";
+          segments[1] = `mfa${segments[2].charAt(0).toUpperCase() + segments[2].slice(1)}`;
+          segments.pop();
+          isAuthRoute = true;
+        }
+      }
+      let current = root;
+      for (let i = 0;i < segments.length; i++) {
+        const seg = segments[i];
+        if (seg === undefined)
+          continue;
+        if (seg.startsWith("{") && seg.endsWith("}")) {
+          const paramName = seg.slice(1, -1).replace(/-([a-z])/g, (g) => g[1].toUpperCase());
+          if (!current.paramChild) {
+            current.paramChild = { paramName, node: { methods: [], children: {} } };
+          }
+          current = current.paramChild.node;
+          if (i === segments.length - 1) {
+            let argsStr = "";
+            let reqArgs = [`'${method.toUpperCase()}'`, `\`${rawPath.replace(/{/g, "${")}\``];
+            if (["post", "put", "patch"].includes(method.toLowerCase())) {
+              argsStr = `data${reqOptional ? "?" : ""}: ${reqType}`;
+              reqArgs.push("data");
+            }
+            const methodTitle = method.toLowerCase();
+            let methodStr = "";
+            if (isMediaStream) {
+              methodStr = `toUrl: (queryParams?: Record<string, any>) => parent.buildUrl(\`${rawPath.replace(/{/g, "${")}\`, queryParams),`;
+            } else if (isStream) {
+              methodStr = `${methodTitle}: (${argsStr}) => parent.streamRequest('${method.toUpperCase()}', \`${rawPath.replace(/{/g, "${")}\`${reqArgs.length > 2 ? ", data" : ""}),`;
+            } else {
+              methodStr = `${methodTitle}: (${argsStr}) => parent.request<${resType}>(${reqArgs.join(", ")}),`;
+            }
+            if (current.methods.some((m) => m.trim().startsWith(`${methodTitle}:`))) {
+              console.warn(`[sdk] Duplicate route: ${method.toUpperCase()} ${rawPath} \u2014 already registered, skipping`);
+            } else {
+              current.methods.push(methodStr);
+              hasRoutes = true;
+            }
+          }
+        } else {
+          if (i === segments.length - 1 && (isAuthRoute || current.children[seg])) {
+            let argsStr = "";
+            let reqArgs = [`'${method.toUpperCase()}'`, `\`${rawPath.replace(/{/g, "${")}\``];
+            if (["post", "put", "patch"].includes(method.toLowerCase())) {
+              argsStr = `data${reqOptional ? "?" : ""}: ${reqType}`;
+              reqArgs.push("data");
+            }
+            const camelSeg = seg.replace(/-([a-z])/g, (g) => g[1].toUpperCase());
+            const methodTitle = isAuthRoute ? camelSeg : `${method.toLowerCase()}${camelSeg.charAt(0).toUpperCase() + camelSeg.slice(1)}`;
+            let methodStr = "";
+            if (isMediaStream) {
+              methodStr = `toUrl: (queryParams?: Record<string, any>) => parent.buildUrl(\`${rawPath.replace(/{/g, "${")}\`, queryParams),`;
+            } else if (isStream) {
+              methodStr = `${methodTitle}: (${argsStr}) => parent.streamRequest('${method.toUpperCase()}', \`${rawPath.replace(/{/g, "${")}\`${reqArgs.length > 2 ? ", data" : ""}),`;
+            } else {
+              methodStr = `${methodTitle}: (${argsStr}) => parent.request<${resType}>(${reqArgs.join(", ")}),`;
+            }
+            if (current.methods.some((m) => m.trim().startsWith(`${methodTitle}:`))) {
+              console.warn(`[sdk] Duplicate route: ${method.toUpperCase()} ${rawPath} \u2014 already registered, skipping`);
+            } else {
+              current.methods.push(methodStr);
+              hasRoutes = true;
+            }
+            break;
+          } else if (i === segments.length - 1) {
+            let argsStr = "";
+            let reqArgs = [`'${method.toUpperCase()}'`, `\`${rawPath.replace(/{/g, "${")}\``];
+            if (["post", "put", "patch"].includes(method.toLowerCase())) {
+              argsStr = `data${reqOptional ? "?" : ""}: ${reqType}`;
+              reqArgs.push("data");
+            }
+            const cleanSeg2 = seg.replace(/-([a-z])/g, (g) => g[1].toUpperCase());
+            if (!current.children[cleanSeg2]) {
+              current.children[cleanSeg2] = { methods: [], children: {} };
+            }
+            const targetNode = current.children[cleanSeg2];
+            const methodTitle = i === 0 ? method.toLowerCase() : isAuthRoute ? cleanSeg2 : `${method.toLowerCase()}${cleanSeg2.charAt(0).toUpperCase() + cleanSeg2.slice(1)}`;
+            let methodStr = "";
+            if (isMediaStream) {
+              methodStr = `toUrl: (queryParams?: Record<string, any>) => parent.buildUrl(\`${rawPath.replace(/{/g, "${")}\`, queryParams),`;
+            } else if (isStream) {
+              methodStr = `${methodTitle}: (${argsStr}) => parent.streamRequest('${method.toUpperCase()}', \`${rawPath.replace(/{/g, "${")}\`${reqArgs.length > 2 ? ", data" : ""}),`;
+            } else {
+              methodStr = `${methodTitle}: (${argsStr}) => parent.request<${resType}>(${reqArgs.join(", ")}),`;
+            }
+            if (targetNode.methods.some((m) => m.trim().startsWith(`${methodTitle}:`))) {
+              console.warn(`[sdk] Duplicate route: ${method.toUpperCase()} ${rawPath} \u2014 already registered, skipping`);
+            } else {
+              targetNode.methods.push(methodStr);
+              hasRoutes = true;
+            }
+            break;
+          }
+          const cleanSeg = seg.replace(/-([a-z])/g, (g) => g[1].toUpperCase());
+          if (!current.children[cleanSeg]) {
+            current.children[cleanSeg] = { methods: [], children: {} };
+          }
+          current = current.children[cleanSeg];
+        }
+      }
+    }
+  }
+  function stringifyNode(node, indentLevel) {
+    const indent = "  ".repeat(indentLevel);
+    const hasMethods = node.methods.length > 0;
+    const hasChildren = Object.keys(node.children).length > 0;
+    const hasParam = !!node.paramChild;
+    if (!hasMethods && !hasChildren && !hasParam)
+      return "{}";
+    let childrenStr = "";
+    if (hasMethods || hasChildren) {
+      childrenStr += `{
+`;
+      if (hasMethods) {
+        childrenStr += node.methods.map((m) => `${indent}  ${m}`).join(`
+`) + `
+`;
+      }
+      for (const [key, child] of Object.entries(node.children)) {
+        childrenStr += `${indent}  ${key}: ${stringifyNode(child, indentLevel + 1).trim()},
+`;
+      }
+      childrenStr += `${indent}}`;
+    }
+    if (hasParam) {
+      const paramName = node.paramChild.paramName;
+      const paramChildStr = stringifyNode(node.paramChild.node, indentLevel + 1).trim();
+      const methodName = `by${paramName.charAt(0).toUpperCase() + paramName.slice(1)}`;
+      const paramMethod = `${indent}  ${methodName}: (${paramName}: string) => (${paramChildStr})`;
+      let combinedStr = `{
+`;
+      if (hasMethods) {
+        combinedStr += node.methods.map((m) => `${indent}  ${m}`).join(`
+`) + `
+`;
+      }
+      for (const [key, child] of Object.entries(node.children)) {
+        combinedStr += `${indent}  ${key}: ${stringifyNode(child, indentLevel + 1).trim()},
+`;
+      }
+      combinedStr += `${paramMethod}
+${indent}}`;
+      return combinedStr;
+    }
+    return childrenStr;
+  }
+  let treeBody = `  private _cache: Record<string, any> = {};
+`;
+  for (const [key, child] of Object.entries(root.children)) {
+    const safeKey = /^[a-zA-Z_$][a-zA-Z0-9_$]*$/.test(key) ? key : `"${key}"`;
+    const initName = `_init_${key.replace(/[^a-zA-Z0-9_]/g, "_")}`;
+    treeBody += `  private ${initName}() {
+    const parent = this;
+    return ${stringifyNode(child, 2).trim()};
+  }
+`;
+    treeBody += `  get ${safeKey}(): ReturnType<typeof this.${initName}> {
+    if (!this._cache['${key}']) {
+      this._cache['${key}'] = this.${initName}();
+    }
+    return this._cache['${key}'];
+  }
+`;
+  }
+  const engine = `
+// ==========================================
+// Cequre Core Engine
+// ==========================================
+export interface CequreClientConfig {
+  baseUrl?: string;
+  token?: string;
+  getToken?: () => string | null | Promise<string | null>;
+  credentials?: "omit" | "same-origin" | "include";
+  onResponse?: (response: SDKResponse<any>) => void | Promise<void>;
+}
+export interface CequreError {
+  code: string;
+  message: string;
+  statusCode: number;
+  timestamp: string;
+  path?: string;
+  stack?: string;
+}
+export interface SDKResponse<T> {
+  data: T | null;
+  error: CequreError | null;
+  status: number;
+  url: string;
+  headers: Headers | Record<string, string>;
+}
+export class CequreCore {
+  private config: CequreClientConfig;
+  constructor(config: CequreClientConfig = {}) {
+    this.config = { ...config, baseUrl: (config.baseUrl || "").replace(/\\/$/, "") };
+  }
+  withToken(token: string): CequreClient {
+    const cloned = Object.create(Object.getPrototypeOf(this));
+    cloned.config = { ...this.config, token };
+    cloned._cache = {};
+    return cloned;
+  }
+  async buildUrl(path: string, queryParams: Record<string, any> = {}): Promise<string> {
+    let url = \`\${this.config.baseUrl}\${path}\`;
+    const token = await this.resolveToken();
+    const params = new URLSearchParams();
+    for (const [key, val] of Object.entries(queryParams)) {
+      if (val !== undefined && val !== null) {
+        params.append(key, String(val));
+      }
+    }
+    if (token) params.set("token", token);
+    const qs = params.toString();
+    if (qs) url += (url.includes('?') ? '&' : '?') + qs;
+    return url;
+  }
+  private async resolveToken(): Promise<string | null> {
+    if (this.config.token) return this.config.token;
+    if (this.config.getToken) {
+      const t = await this.config.getToken();
+      if (t) return t;
+    }
+    return null;
+  }
+  private async getAuthHeader(): Promise<string | null> {
+    const t = await this.resolveToken();
+    return t ? \`Bearer \${t}\` : null;
+  }
+  private async fetchWithRetry(url: string, options: RequestInit, maxRetries = 2): Promise<Response> {
+    let lastError: unknown;
+    const method = (options.method || 'GET').toUpperCase();
+    const isIdempotent = method === 'GET' || method === 'HEAD' || method === 'OPTIONS';
+    const retries = isIdempotent ? maxRetries : 0;
+    for (let attempt = 0; attempt <= retries; attempt++) {
+      try {
+        const res = await fetch(url, options);
+        if (res.status >= 500 && res.status !== 501 && attempt < retries) {
+          await new Promise(r => setTimeout(r, 1000 * 2 ** attempt));
+          continue;
+        }
+        return res;
+      } catch (err: any) {
+        if (err?.name === 'AbortError') throw err;
+        lastError = err;
+        if (attempt < retries) {
+          await new Promise(r => setTimeout(r, 1000 * 2 ** attempt));
+          continue;
+        }
+      }
+    }
+    throw lastError;
+  }
+  async request<T>(
+    method: string,
+    path: string,
+    data?: any,
+    customHeaders: Record<string, string> = {},
+    signal?: AbortSignal
+  ): Promise<SDKResponse<T>> {
+    const headers: Record<string, string> = {
+      'X-Cequre-CSRF': '1',
+      ...customHeaders
+    };
+    const auth = await this.getAuthHeader();
+    if (auth) headers['Authorization'] = auth;
+    const options: RequestInit = {
+      method,
+      headers,
+      credentials: this.config.credentials,
+      signal
+    };
+    if (data) {
+      const hasFiles = this.containsFiles(data);
+      if (hasFiles) {
+        const formData = new FormData();
+        for (const key of Object.keys(data)) {
+          const val = data[key];
+          if (val == null) continue;
+          if (val instanceof File || val instanceof Blob) {
+            formData.append(key, val);
+          } else if (typeof val === 'boolean') {
+            formData.append(key, val ? 'true' : 'false');
+          } else if (typeof val === 'object') {
+            formData.append(key, JSON.stringify(val));
+          } else {
+            formData.append(key, String(val));
+          }
+        }
+        options.body = formData;
+      } else {
+        headers['Content-Type'] = 'application/json';
+        options.body = JSON.stringify(data);
+      }
+    }
+    try {
+      const res = await this.fetchWithRetry(\`\${this.config.baseUrl}\${path}\`, options);
+      if (!res.ok) {
+        let errData;
+        const errText = await res.text();
+        try {
+          errData = JSON.parse(errText);
+        } catch {
+          errData = {
+            code: "SERVER_ERROR",
+            message: errText || res.statusText || "Unknown server error",
+            statusCode: res.status,
+            timestamp: new Date().toISOString(),
+            path
+          };
+        }
+        const errorObject: CequreError = {
+          code: errData?.code || "UNKNOWN_ERROR",
+          message: errData?.message || (typeof errData?.error === "string" ? errData.error : "An unexpected error occurred"),
+          statusCode: errData?.statusCode || res.status,
+          timestamp: errData?.timestamp || new Date().toISOString(),
+          path: errData?.path || path,
+          stack: errData?.stack
+        };
+        const result = { data: null, error: errorObject, status: res.status, url: res.url || path, headers: res.headers };
+        if (this.config.onResponse) await this.config.onResponse(result);
+        return result;
+      }
+      if (res.status === 204 || res.headers.get('content-length') === '0') {
+        const result = { data: undefined as unknown as T, error: null, status: res.status, url: res.url || path, headers: res.headers };
+        if (this.config.onResponse) await this.config.onResponse(result);
+        return result;
+      }
+      const contentType = res.headers.get('content-type') || '';
+      if (!contentType.includes('application/json') && !contentType.includes('text/')) {
+        const blob = await res.blob();
+        const result = { data: blob as unknown as T, error: null, status: res.status, url: res.url || path, headers: res.headers };
+        if (this.config.onResponse) await this.config.onResponse(result);
+        return result;
+      }
+      const text = await res.text();
+      if (!text) {
+        const result = { data: undefined as unknown as T, error: null, status: res.status, url: res.url || path, headers: res.headers };
+        if (this.config.onResponse) await this.config.onResponse(result);
+        return result;
+      }
+      try {
+        const result = { data: JSON.parse(text) as T, error: null, status: res.status, url: res.url || path, headers: res.headers };
+        if (this.config.onResponse) await this.config.onResponse(result);
+        return result;
+      } catch {
+        const result = { data: text as unknown as T, error: null, status: res.status, url: res.url || path, headers: res.headers };
+        if (this.config.onResponse) await this.config.onResponse(result);
+        return result;
+      }
+    } catch (error: any) {
+      if (error?.name === 'AbortError') throw error;
+      if (error instanceof Response) throw error;
+      const networkError: CequreError = {
+        code: "NETWORK_ERROR",
+        message: error?.message || "Failed to connect to the server",
+        statusCode: 0,
+        timestamp: new Date().toISOString(),
+        path
+      };
+      const result = { data: null as any, error: networkError, status: 0, url: path, headers: {} };
+      if (this.config.onResponse) await this.config.onResponse(result);
+      return result;
+    }
+  }
+  private containsFiles(data: any): boolean {
+    if (!data || typeof data !== 'object') return false;
+    for (const key of Object.keys(data)) {
+      if (data[key] instanceof File || data[key] instanceof Blob) return true;
+    }
+    return false;
+  }
+  async uploadLargeFile(file: File, options?: { chunkSize?: number, onProgress?: (percent: number) => void }): Promise<SDKResponse<any>> {
+    const chunkSize = options?.chunkSize || 5 * 1024 * 1024; // 5MB default
+    const totalParts = Math.ceil(file.size / chunkSize);
+    // Determine the API prefix (default to /api if not dynamically available, though server maps it globally)
+    const prefix = "/api"; // The standard Cequre prefix
+    // 1. Init
+    const initRes = await this.request<any>("POST", \`\${prefix}/uploads/multipart/init\`, {
+      filename: file.name,
+      mimetype: file.type,
+      size: file.size
+    });
+    if (initRes.error) return initRes;
+    const { uploadId, parts } = initRes.data;
+    const completedParts = [];
+    const isDirect = Array.isArray(parts) && parts.length > 0;
+    for (let i = 0; i < totalParts; i++) {
+      const partNumber = i + 1;
+      const start = i * chunkSize;
+      const end = Math.min(start + chunkSize, file.size);
+      const chunk = (file as any).slice(start, end);
+      if (isDirect) {
+        // Direct-to-cloud using presigned URL
+        const presignedUrl = parts.find((p: any) => p.partNumber === partNumber)?.url;
+        if (!presignedUrl) {
+          return { data: null, error: { code: "UPLOAD_ERROR", message: "Missing presigned URL for part", statusCode: 500, timestamp: new Date().toISOString() }, status: 500, url: "", headers: new Headers() };
+        }
+        try {
+          const res = await fetch(presignedUrl, {
+            method: "PUT",
+            body: chunk,
+            headers: { "Content-Type": file.type }
+          });
+          if (!res.ok) throw new Error(\`Failed to upload part \${partNumber}\`);
+          let etag = res.headers.get("ETag") || res.headers.get("etag");
+          if (etag) etag = etag.replace(/"/g, ""); // AWS wraps ETags in quotes
+          completedParts.push({ partNumber, etag });
+        } catch (err: any) {
+          return { data: null, error: { code: "UPLOAD_ERROR", message: err.message, statusCode: 500, timestamp: new Date().toISOString() }, status: 500, url: "", headers: new Headers() };
+        }
+      } else {
+        // Fallback to Cequre Server
+        const res = await this.request<any>("POST", \`\${prefix}/uploads/multipart/chunk?uploadId=\${uploadId}&partNumber=\${partNumber}\`, chunk, {
+          "Content-Type": "application/octet-stream"
+        });
+        if (res.error) return res;
+        let etag = res.data.etag;
+        completedParts.push({ partNumber, etag });
+      }
+      if (options?.onProgress) {
+        options.onProgress(Math.round(((i + 1) / totalParts) * 100));
+      }
+    }
+    // 3. Complete
+    return this.request<any>("POST", \`\${prefix}/uploads/multipart/complete\`, {
+      uploadId,
+      filename: file.name,
+      parts: completedParts
+    });
+  }
+  async *streamRequest(method: string, path: string, data?: any, options?: RequestInit): AsyncGenerator<string, void, unknown> {
+    const headers = new Headers(options?.headers);
+    const token = await this.resolveToken();
+    if (token) {
+      headers.set('Authorization', \`Bearer \${token}\`);
+    }
+    const fetchOptions: RequestInit = {
+      ...options,
+      method,
+      headers
+    };
+    if (data !== undefined) {
+      if (this.containsFiles(data)) {
+        const formData = new FormData();
+        for (const key of Object.keys(data)) {
+          const val = data[key];
+          if (val == null) continue;
+          if (val instanceof File || val instanceof Blob) {
+            formData.append(key, val);
+          } else if (typeof val === 'boolean') {
+            formData.append(key, val ? 'true' : 'false');
+          } else if (typeof val === 'object') {
+            formData.append(key, JSON.stringify(val));
+          } else {
+            formData.append(key, String(val));
+          }
+        }
+        fetchOptions.body = formData;
+      } else {
+        headers.set('Content-Type', 'application/json');
+        fetchOptions.body = JSON.stringify(data);
+      }
+    }
+    const res = await this.fetchWithRetry(\`\${this.config.baseUrl}\${path}\`, fetchOptions);
+    if (!res.ok) {
+      let errText = await res.text().catch(() => "");
+      throw new Error(\`Stream request failed with status \${res.status}: \${errText}\`);
+    }
+    if (!res.body) return;
+    const reader = res.body.getReader();
+    const decoder = new TextDecoder();
+    try {
+      while (true) {
+        const { done, value } = await reader.read();
+        if (done) break;
+        if (value) {
+          yield decoder.decode(value, { stream: true });
+        }
+      }
+    } finally {
+      reader.cancel().catch(() => {});
+      reader.releaseLock();
+    }
+  }
+  /**
+   * @security
+   * Note: EventSource does not support custom headers. The authentication token
+   * is appended to the URL query string. This may be logged by proxies or the server.
+   */
+  async subscribeSSE(path: string, onEvent: (event: any) => void): Promise<() => void> {
+    let url = \`\${this.config.baseUrl}\${path}\`;
+    const token = await this.resolveToken();
+    if (token) {
+      url += (url.includes('?') ? '&' : '?') + \`token=\${encodeURIComponent(token)}\`;
+    }
+    const es = new (globalThis as any).EventSource(url);
+    let retryCount = 0;
+    const maxRetries = 5;
+    es.onmessage = (e: { data: string }) => {
+      retryCount = 0;
+      try {
+        onEvent(JSON.parse(e.data));
+      } catch (err) {}
+    };
+    es.onerror = (_e: any) => {
+      retryCount++;
+      if (retryCount >= maxRetries) {
+        es.close();
+        es.onmessage = null;
+        es.onerror = null;
+      }
+    };
+    return () => {
+      es.close();
+      es.onmessage = null;
+      es.onerror = null;
+    };
+  }
+  async subscribeWS(path: string, onEvent: (event: any) => void): Promise<() => void> {
+    const wsUrl = (this.config.baseUrl || "").replace(/^http/, 'ws') + path;
+    const token = await this.resolveToken();
+    let ws: WebSocket;
+    let retryCount = 0;
+    const maxRetries = 5;
+    let manualClose = false;
+    const connect = () => {
+      ws = new WebSocket(wsUrl);
+      ws.onopen = () => {
+        retryCount = 0;
+        if (token) ws.send(JSON.stringify({ type: 'auth', token }));
+      };
+      ws.onmessage = (e: { data: string }) => {
+        try { onEvent(JSON.parse(e.data)); } catch (err) {}
+      };
+      ws.onerror = () => { /* consumer observes via onclose */ };
+      ws.onclose = () => {
+        if (manualClose) return;
+        if (retryCount < maxRetries) {
+          retryCount++;
+          setTimeout(connect, Math.min(1000 * 2 ** retryCount, 30000));
+        }
+      };
+    };
+    connect();
+    return () => {
+      manualClose = true;
+      ws?.close();
+      if (ws) {
+        ws.onopen = null;
+        ws.onmessage = null;
+        ws.onerror = null;
+        ws.onclose = null;
+      }
+    };
+  }
+}
+`;
+  const exampleUsage = `/**
+ * ==========================================
+ * CEQURE SDK - EXAMPLE USAGE
+ * ==========================================
+ * This SDK is auto-generated and has zero dependencies.
+ * You can drop this file directly into your frontend, or use it in an AI Agent script.
+ *
+ * --- BROWSER / GLOBAL USAGE ---
+ * import { createCequreClient } from './cequre-sdk';
+ *
+ * export const api = createCequreClient({
+ *   baseUrl: "http://localhost:3000",
+ *   getToken: () => localStorage.getItem("token") // auto-injects auth
+ * });
+ *
+ * // Authentication (for auth-enabled collections)
+ * // const { data: session } = await api.auth.login({ email: "alice@example.com", password: "password123" });
+ * // localStorage.setItem("token", session.accessToken);
+ *
+ * // Create a record
+ * const { data: newUser, error, status } = await api.users.post({ name: "Alice", email: "alice@example.com" });
+ * if (error) {
+ *   console.error("Failed to create user:", error.message);
+ * } else {
+ *   console.log("Created user:", newUser);
+ * }
+ *
+ * // Subscribe to realtime updates
+ * const unsubscribe = api.users.subscribeWS((event) => console.log("User updated!", event.data));
+ *
+ * // Consume a custom streaming endpoint
+ * // const stream = await api.aiChat.get();
+ * // for await (const chunk of stream) {
+ * //   console.log(chunk);
+ * // }
+ *
+ * --- SERVER / SSR USAGE (Remix, Next.js, etc.) ---
+ * // Use .withToken() to create a safe clone for a specific user request
+ * const serverApi = api.withToken(requestToken);
+ * const { data, error } = await serverApi.users.get();
+ * ==========================================
+ */
+`;
+  const finalOutput = `// cequre-sdk.ts
+// This file is auto-generated by Cequre. Do NOT edit it manually.
+${exampleUsage}
+// ==========================================
+// Generated Types
+// ==========================================
+${models.join(`
+`)}
+${engine}
+export class CequreClient extends CequreCore {
+${treeBody}
+}
+/**
+ * Creates a new CequreClient instance.
+ */
+export function createCequreClient(config: CequreClientConfig = {}) {
+  return new CequreClient(config);
+}
+`;
+  return finalOutput;
+}
+function generateBackendSchemas(schema, routes) {
+  const { generateOpenAPISpec: generateOpenAPISpec2 } = (init_openapi(), __toCommonJS(exports_openapi));
+  const openApiSpec = generateOpenAPISpec2(schema, "http://localhost:3000", "/api", { routes });
+  const schemas = openApiSpec.components?.schemas || {};
+  const models = [];
+  function resolveTypeBox(s, currentSchemaName) {
+    if (!s)
+      return "t.Any()";
+    if (s.$ref) {
+      const refName = `${s.$ref.split("/").pop()}Schema`;
+      if (refName === currentSchemaName) {
+        return "t.Any()";
+      }
+      if (currentSchemaName.endsWith("WhereInputSchema") && refName.endsWith("WhereInputSchema")) {
+        return "t.Any()";
+      }
+      return refName;
+    }
+    switch (s.type) {
+      case "string":
+        if (s.enum)
+          return s.enum.length === 1 ? `t.Literal("${s.enum[0]}")` : `t.Union([${s.enum.map((e) => `t.Literal("${e}")`).join(", ")}])`;
+        if (s.format === "date-time")
+          return `t.Union([t.String({ format: "date-time" }), t.Date()])`;
+        if (s.format)
+          return `t.String({ format: "${s.format}" })`;
+        return "t.String()";
+      case "number":
+      case "integer":
+        return s.enum ? s.enum.length === 1 ? `t.Literal(${s.enum[0]})` : `t.Union([${s.enum.map((e) => `t.Literal(${e})`).join(", ")}])` : "t.Number()";
+      case "boolean":
+        return s.enum ? s.enum.length === 1 ? `t.Literal(${s.enum[0]})` : `t.Union([${s.enum.map((e) => `t.Literal(${e})`).join(", ")}])` : "t.Boolean()";
+      case "array":
+        return `t.Array(${resolveTypeBox(s.items, currentSchemaName)})`;
+      case "object":
+        if (s.properties) {
+          const props = Object.entries(s.properties).map(([key, val]) => {
+            const isRequired = s.required?.includes(key);
+            const safeKey = /^[a-zA-Z_$][a-zA-Z0-9_$]*$/.test(key) ? key : `"${key}"`;
+            let tb = resolveTypeBox(val, currentSchemaName);
+            if (!isRequired) {
+              tb = `t.Optional(${tb})`;
+            }
+            return `  ${safeKey}: ${tb}`;
+          }).join(`,
+`);
+          return `t.Object({
+${props}
+})`;
+        }
+        return "t.Record(t.String(), t.Any())";
+      default:
+        if (s.enum) {
+          return `t.Union([${s.enum.map((e) => typeof e === "string" ? `t.Literal("${e}")` : `t.Literal(${e})`).join(", ")}])`;
+        }
+        if (s.anyOf) {
+          return `t.Union([${s.anyOf.map((s2) => resolveTypeBox(s2, currentSchemaName)).join(", ")}])`;
+        }
+        if (s.allOf) {
+          return `t.Intersect([${s.allOf.map((s2) => resolveTypeBox(s2, currentSchemaName)).join(", ")}])`;
+        }
+        if (s.oneOf) {
+          return `t.Union([${s.oneOf.map((s2) => resolveTypeBox(s2, currentSchemaName)).join(", ")}])`;
+        }
+        return "t.Any()";
+    }
+  }
+  for (const [schemaName, schemaDef] of Object.entries(schemas)) {
+    models.push(`export const ${schemaName}Schema = ${resolveTypeBox(schemaDef, `${schemaName}Schema`)};`);
+  }
+  const finalOutput = `// cequre-schemas.ts
+// This file is auto-generated by Cequre. Do NOT edit it manually.
+import { t } from "@cequrebackends/cequre-ts";
+// ==========================================
+// Generated TypeBox Schemas
+// ==========================================
+${models.join(`
+`)}
+`;
+  return finalOutput;
+}
+var init_sdk = __esm(() => {
+  init_openapi();
+});
+// shared/core/base-sql-adapter.ts
+class BaseSqlAdapter {
+  _createdDbName = null;
+  _numericFields = new Map;
+  _jsonFields = new Map;
+  _relationshipTargets = new Map;
+  _searchableFields = new Map;
+  _knownFields = new Map;
+  get createdDbName() {
+    return this._createdDbName;
+  }
+  getStartupInfo() {
+    return { createdResourceName: this._createdDbName };
+  }
+  configureCollections(collections) {
+    for (const col of collections) {
+      const nums = new Set;
+      const jsons = new Set;
+      const searchable = new Set;
+      const known = new Set(["id"]);
+      for (const f of col.fields) {
+        known.add(f.name);
+        if (f.type === "number" || f.type === "integer") {
+          nums.add(f.name);
+        }
+        if (f.type === "json" || f.type === "richtext" || f.type === "array" || f.type === "upload" || f.type === "object") {
+          jsons.add(f.name);
+        }
+        if (f.type === "relationship" && f.target) {
+          this._relationshipTargets.set(`${col.slug}.${f.name}`, f.target);
+        }
+      }
+      known.add("createdAt");
+      known.add("updatedAt");
+      if (nums.size > 0)
+        this._numericFields.set(col.slug, nums);
+      if (jsons.size > 0)
+        this._jsonFields.set(col.slug, jsons);
+      if (searchable.size > 0)
+        this._searchableFields.set(col.slug, searchable);
+      this._knownFields.set(col.slug, known);
+    }
+  }
+  registerCollections(collections) {
+    this.configureCollections(collections);
+  }
+  parseConstraintError(error) {
+    const message = error instanceof Error ? error.message : String(error);
+    const rawMessage = message;
+    const pgFkMatch = message.match(/violates foreign key constraint [""]([^""]+)[""]/i) || message.match(/[""]([^""]+)[""] is not present in table [""]([^""]+)[""]/i);
+    if (pgFkMatch) {
+      const constraintMatch = message.match(/[""]([^""]+)[""]/);
+      const tableMatch = message.match(/on table [""]([^""]+)[""]/i);
+      const keyMatch = message.match(/Key \(([^)]+)\)=\(([^)]+)\)/i);
+      return {
+        type: "foreign_key",
+        table: tableMatch?.[1],
+        constraint: constraintMatch?.[1],
+        referencedTable: pgFkMatch[2] || constraintMatch?.[1]?.replace(/_[a-z_]+_fkey$/, ""),
+        column: keyMatch?.[1],
+        rawMessage
+      };
+    }
+    const pgUniqueMatch = message.match(/duplicate key.*unique constraint [""]([^""]+)[""]/i);
+    if (pgUniqueMatch) {
+      const tableMatch = message.match(/on table [""]([^""]+)[""]/i);
+      const keyMatch = message.match(/Key \(([^)]+)\)=\(([^)]+)\)/i);
+      return {
+        type: "unique",
+        table: tableMatch?.[1],
+        constraint: pgUniqueMatch[1],
+        column: keyMatch?.[1],
+        rawMessage
+      };
+    }
+    if (message.includes("UNIQUE constraint failed")) {
+      const parts = message.split(":");
+      return { type: "unique", rawMessage, constraint: parts[1]?.trim() };
+    }
+    const pgNotNullMatch = message.match(/null value in column [""]([^""]+)[""].*not-null constraint/i);
+    if (pgNotNullMatch) {
+      const tableMatch = message.match(/on table [""]([^""]+)[""]/i);
+      return {
+        type: "not_null",
+        table: tableMatch?.[1],
+        column: pgNotNullMatch[1],
+        rawMessage
+      };
+    }
+    const pgCheckMatch = message.match(/violates check constraint [""]([^""]+)[""]/i);
+    if (pgCheckMatch) {
+      const tableMatch = message.match(/for relation [""]([^""]+)[""]/i);
+      return {
+        type: "check",
+        table: tableMatch?.[1],
+        constraint: pgCheckMatch[1],
+        rawMessage
+      };
+    }
+    return null;
+  }
+}
+function sqlIdentifier(identifier) {
+  return `"${identifier.replace(/"/g, '""')}"`;
+}
+function sqlLiteral(value) {
+  return `'${value.replace(/'/g, "''")}'`;
+}
+// shared/core/cache.ts
+class MemoryCacheStore {
+  cache = new Map;
+  async get(key) {
+    const item = this.cache.get(key);
+    if (!item)
+      return null;
+    if (item.expiry !== null && Date.now() > item.expiry) {
+      this.cache.delete(key);
+      return null;
+    }
+    return item.value;
+  }
+  async set(key, value, ttlSeconds) {
+    const expiry = ttlSeconds ? Date.now() + ttlSeconds * 1000 : null;
+    this.cache.set(key, { value, expiry });
+  }
+  async del(...keys) {
+    let count = 0;
+    for (const key of keys) {
+      if (this.cache.delete(key)) {
+        count++;
+      }
+    }
+    return count;
+  }
+  close() {
+    this.cache.clear();
+  }
+}
+// shared/core/email.ts
+class CequreMailer {
+  transport;
+  appName;
+  resetTokenExpiryMinutes;
+  from;
+  templates;
+  constructor(config, transport) {
+    this.appName = config?.appName ?? process.env.SMTP_APP_NAME ?? "Cequre App";
+    this.resetTokenExpiryMinutes = config?.resetTokenExpiryMinutes ?? 60;
+    this.from = config?.from ?? process.env.SMTP_FROM ?? `"Cequre App" <no-reply@cequre.dev>`;
+    this.templates = config?.templates;
+    const resolvedTransport = transport ?? config?.transport;
+    if (!resolvedTransport) {
+      throw CequreError.NotConfigured("Email transport is required. Install an email provider plugin and pass email.transport.");
+    }
+    this.transport = resolvedTransport;
+  }
+  async send(options) {
+    if (!options.to) {
+      throw CequreError.BadRequest("Email 'to' address is required");
+    }
+    return this.transport.send({ from: this.from, ...options });
+  }
+  async verify() {
+    return this.transport.verify();
+  }
+  async sendWelcome(to, opts = {}) {
+    const appName = opts.appName ?? this.appName;
+    const custom = this.templates?.welcome?.({ to, appName });
+    await this.send({
+      to,
+      subject: custom?.subject ?? `Welcome to ${appName}`,
+      html: custom?.html ?? welcomeTemplate({ to, appName }),
+      text: custom?.text ?? `Welcome to ${appName}! Your account has been created successfully.`
+    });
+  }
+  async sendForgotPassword(to, resetUrl, opts = {}) {
+    const appName = opts.appName ?? this.appName;
+    const expiresInMinutes = opts.expiresInMinutes ?? this.resetTokenExpiryMinutes;
+    const custom = this.templates?.forgotPassword?.({ to, resetUrl, appName, expiresInMinutes });
+    await this.send({
+      to,
+      subject: custom?.subject ?? `Reset your ${appName} password`,
+      html: custom?.html ?? forgotPasswordTemplate({ to, resetUrl, appName, expiresInMinutes }),
+      text: custom?.text ?? `You requested a password reset for ${appName}.
+Click the link below to reset your password (valid for ${expiresInMinutes} minutes):
+${resetUrl}
+If you didn't request a reset, you can safely ignore this email.`
+    });
+  }
+  async sendPasswordResetSuccess(to, opts = {}) {
+    const appName = opts.appName ?? this.appName;
+    const custom = this.templates?.passwordResetSuccess?.({ to, appName });
+    await this.send({
+      to,
+      subject: custom?.subject ?? `Your ${appName} password has been reset`,
+      html: custom?.html ?? passwordResetSuccessTemplate({ to, appName }),
+      text: custom?.text ?? `Your ${appName} password has been successfully reset. If you did not perform this action, contact support immediately.`
+    });
+  }
+  async sendVerificationEmail(to, verifyUrl, opts = {}) {
+    const appName = opts.appName ?? this.appName;
+    const custom = this.templates?.verifyEmail?.({ to, verifyUrl, appName });
+    await this.send({
+      to,
+      subject: custom?.subject ?? `Verify your ${appName} email`,
+      html: custom?.html ?? verifyEmailTemplate({ to, verifyUrl, appName }),
+      text: custom?.text ?? `Welcome to ${appName}! Please verify your email address by clicking the link below:
+${verifyUrl}
+If you didn't create an account, you can safely ignore this email.`
+    });
+  }
+}
+function createMailer(config) {
+  const transport = config?.transport;
+  if (!transport)
+    return;
+  return new CequreMailer(config, transport);
+}
+function baseTemplate(content, appName) {
+  return `<!DOCTYPE html>
+<html lang="en">
+<head>
+  <meta charset="UTF-8" />
+  <meta name="viewport" content="width=device-width, initial-scale=1.0" />
+  <style>
+    body { font-family: -apple-system, BlinkMacSystemFont, 'Segoe UI', Roboto, sans-serif; background: #f4f4f7; margin: 0; padding: 0; }
+    .wrapper { max-width: 600px; margin: 40px auto; background: #ffffff; border-radius: 8px; overflow: hidden; box-shadow: 0 2px 8px rgba(0,0,0,0.08); }
+    .header { background: #6d28d9; padding: 32px 40px; }
+    .header h1 { color: #ffffff; margin: 0; font-size: 22px; font-weight: 600; }
+    .body { padding: 32px 40px; color: #374151; line-height: 1.6; }
+    .body p { margin: 0 0 16px; }
+    .btn { display: inline-block; padding: 12px 28px; background: #6d28d9; color: #ffffff !important; text-decoration: none; border-radius: 6px; font-weight: 600; font-size: 15px; margin: 8px 0 20px; }
+    .footer { padding: 20px 40px; background: #f9fafb; color: #9ca3af; font-size: 12px; line-height: 1.5; border-top: 1px solid #e5e7eb; }
+    .muted { color: #6b7280; font-size: 13px; }
+  </style>
+</head>
+<body>
+  <div class="wrapper">
+    <div class="header"><h1>${appName}</h1></div>
+    <div class="body">${content}</div>
+    <div class="footer">You received this email because an action was performed on your ${appName} account.<br/>If you didn't initiate this, please ignore this email or contact support.</div>
+  </div>
+</body>
+</html>`;
+}
+function welcomeTemplate({ to, appName }) {
+  return baseTemplate(`<p>Hi <strong>${to}</strong>,</p>
+     <p>Welcome to <strong>${appName}</strong>! Your account has been created successfully.</p>
+     <p>You can now log in and start using the platform.</p>`, appName);
+}
+function forgotPasswordTemplate({
+  to,
+  resetUrl,
+  appName,
+  expiresInMinutes
+}) {
+  return baseTemplate(`<p>Hi,</p>
+     <p>We received a request to reset the password for the account associated with <strong>${to}</strong>.</p>
+     <p>Click the button below to reset your password. This link will expire in <strong>${expiresInMinutes} minutes</strong>.</p>
+     <a href="${resetUrl}" class="btn">Reset Password</a>
+     <p class="muted">Or copy this link into your browser:<br/><a href="${resetUrl}">${resetUrl}</a></p>
+     <p class="muted">If you didn't request a password reset, you can safely ignore this email \u2014 your password will not change.</p>`, appName);
+}
+function passwordResetSuccessTemplate({ appName }) {
+  return baseTemplate(`<p>Your password for <strong>${appName}</strong> has been successfully reset.</p>
+     <p>If you performed this action, no further steps are needed.</p>
+     <p class="muted">If you did not reset your password, please contact support immediately and secure your account.</p>`, appName);
+}
+function verifyEmailTemplate({ to, verifyUrl, appName }) {
+  return baseTemplate(`<p>Hi <strong>${to}</strong>,</p>
+     <p>Welcome to <strong>${appName}</strong>! Please verify your email address by clicking the button below.</p>
+     <a href="${verifyUrl}" class="btn">Verify Email</a>
+     <p class="muted">Or copy this link into your browser:<br/><a href="${verifyUrl}">${verifyUrl}</a></p>
+     <p class="muted">If you didn't create an account, you can safely ignore this email.</p>`, appName);
+}
+// shared/core/index.ts
+init_openapi();
+// shared/core/plugins.ts
+function sortPlugins(plugins) {
+  const pluginMap = new Map;
+  for (const p of plugins)
+    pluginMap.set(p.name, p);
+  const graph = new Map;
+  const inDegree = new Map;
+  for (const p of plugins) {
+    if (!graph.has(p.name))
+      graph.set(p.name, new Set);
+    if (!inDegree.has(p.name))
+      inDegree.set(p.name, 0);
+  }
+  for (const p of plugins) {
+    if (p.runsBefore) {
+      for (const target of p.runsBefore) {
+        if (!pluginMap.has(target))
+          continue;
+        if (!graph.has(target))
+          graph.set(target, new Set);
+        if (!inDegree.has(target))
+          inDegree.set(target, 0);
+        if (!graph.get(p.name).has(target)) {
+          graph.get(p.name).add(target);
+          inDegree.set(target, inDegree.get(target) + 1);
+        }
+      }
+    }
+    if (p.runsAfter) {
+      for (const target of p.runsAfter) {
+        if (!pluginMap.has(target))
+          continue;
+        if (!graph.has(target))
+          graph.set(target, new Set);
+        if (!inDegree.has(p.name))
+          inDegree.set(p.name, 0);
+        if (!graph.get(target).has(p.name)) {
+          graph.get(target).add(p.name);
+          inDegree.set(p.name, inDegree.get(p.name) + 1);
+        }
+      }
+    }
+  }
+  const queue = [];
+  for (const [name, deg] of inDegree.entries()) {
+    if (deg === 0 && pluginMap.has(name)) {
+      queue.push(name);
+    }
+  }
+  const sorted = [];
+  while (queue.length > 0) {
+    const curr = queue.shift();
+    sorted.push(pluginMap.get(curr));
+    if (graph.has(curr)) {
+      for (const neighbor of graph.get(curr)) {
+        const deg = inDegree.get(neighbor) - 1;
+        inDegree.set(neighbor, deg);
+        if (deg === 0) {
+          queue.push(neighbor);
+        }
+      }
+    }
+  }
+  if (sorted.length !== plugins.length) {
+    throw new Error("Circular dependency detected in Cequre plugins topological ordering.");
+  }
+  return sorted;
+}
+// shared/core/request.ts
+function parseQuery(searchParams) {
+  const query = {};
+  for (const [key, value] of searchParams) {
+    if (key.includes("[")) {
+      const parts = key.split(/\[|\]/).filter(Boolean);
+      let current = query;
+      for (let i = 0;i < parts.length - 1; i++) {
+        const part = parts[i];
+        if (part === undefined)
+          continue;
+        const nextPart = parts[i + 1];
+        if (current[part] === undefined) {
+          current[part] = nextPart !== undefined && /^\d+$/.test(nextPart) ? [] : {};
+        }
+        current = current[part];
+      }
+      const last = parts[parts.length - 1];
+      if (last === undefined)
+        continue;
+      if (current[last] !== undefined) {
+        if (Array.isArray(current[last])) {
+          current[last].push(value);
+        } else {
+          current[last] = [current[last], value];
+        }
+      } else {
+        current[last] = value;
+      }
+    } else {
+      const existing = query[key];
+      if (existing === undefined) {
+        query[key] = value;
+      } else if (Array.isArray(existing)) {
+        existing.push(value);
+      } else {
+        query[key] = [existing, value];
+      }
+    }
+  }
+  return query;
+}
+function createRouteContext(request, params = {}, state, user = null, body, cequre) {
+  const url = new URL(request.url);
+  return {
+    request,
+    url,
+    params,
+    query: parseQuery(url.searchParams),
+    body,
+    cequre,
+    user,
+    state,
+    async stream(chunk, options) {
+      if (!this._streamInitiated) {
+        this._streamInitiated = true;
+        const { readable, writable } = new TransformStream;
+        this._streamWriter = writable.getWriter();
+        if (this._streamResolver) {
+          const headers = new Headers;
+          if (options?.event) {
+            headers.set("Content-Type", "text/event-stream");
+            headers.set("Cache-Control", "no-cache");
+            headers.set("Connection", "keep-alive");
+          } else {
+            headers.set("Content-Type", "text/plain");
+          }
+          this._streamResolver(new Response(readable, { headers }));
+        }
+      }
+      if (!this._streamWriter)
+        return;
+      const encoder = new TextEncoder;
+      let data = chunk;
+      if (options?.event) {
+        if (typeof data !== "string" && !(data instanceof Uint8Array)) {
+          data = JSON.stringify(data);
+        }
+        data = `event: ${options.event}
+data: ${data}
+`;
+      } else if (typeof data !== "string" && !(data instanceof Uint8Array)) {
+        data = JSON.stringify(data) + `
+`;
+      }
+      if (this.request.signal.aborted) {
+        throw new Error("ClientDisconnected: stream aborted by client");
+      }
+      if (typeof data === "string") {
+        data = encoder.encode(data);
+      }
+      try {
+        await this._streamWriter.write(data);
+      } catch (err) {
+        throw new Error("ClientDisconnected: stream write failed");
+      }
+      if (options?.delay) {
+        await new Promise((r) => setTimeout(r, options.delay));
+      }
+    }
+  };
+}
+// shared/core/index.ts
+init_sdk();
+// shared/core/validator.ts
+import { Type, FormatRegistry } from "@sinclair/typebox";
+import { TypeCompiler } from "@sinclair/typebox/compiler";
+FormatRegistry.Set("date-time", (value) => !isNaN(Date.parse(value)));
+FormatRegistry.Set("email", (value) => /^[a-z0-9._%+-]+@[a-z0-9.-]+\.[a-z]{2,}$/i.test(value));
+FormatRegistry.Set("ulid", (value) => /^[0-9A-HJKMNP-TV-Z]{26}$/i.test(value));
+var SYSTEM_FIELDS = new Set(["id", "createdAt", "updatedAt"]);
+function buildCollectionCreateSchema(collection) {
+  const properties = {};
+  const required = [];
+  for (const field of collection.fields) {
+    if (SYSTEM_FIELDS.has(field.name))
+      continue;
+    if (field.type === "password" || field.omit || field.type === "link")
+      continue;
+    const schema = fieldToTypeBox(field);
+    properties[field.name] = schema;
+    if (!field.optional && field.default === undefined) {
+      required.push(field.name);
+    }
+  }
+  return Type.Object(properties, { additionalProperties: false, required });
+}
+function buildCollectionUpdateSchema(collection) {
+  const properties = {};
+  for (const field of collection.fields) {
+    if (SYSTEM_FIELDS.has(field.name))
+      continue;
+    if (field.type === "password" || field.omit || field.type === "link")
+      continue;
+    const schema = fieldToTypeBox(field);
+    properties[field.name] = Type.Optional(schema);
+  }
+  return Type.Object(properties, { additionalProperties: false });
+}
+function fieldToTypeBox(field) {
+  let schema;
+  switch (field.type) {
+    case "string":
+    case "text":
+    case "textarea":
+    case "email":
+    case "password":
+      schema = Type.String();
+      break;
+    case "boolean":
+      schema = Type.Boolean();
+      break;
+    case "number":
+    case "integer":
+      schema = Type.Number();
+      break;
+    case "date":
+      schema = Type.String({ format: "date-time" });
+      break;
+    case "json":
+    case "richtext":
+      schema = Type.Unknown();
+      break;
+    case "select":
+      if (field.values && field.values.length > 0) {
+        schema = Type.Union(field.values.map((v) => Type.Literal(v)));
+      } else {
+        schema = Type.String();
+      }
+      break;
+    case "multiselect":
+      if (field.values && field.values.length > 0) {
+        schema = Type.Array(Type.Union(field.values.map((v) => Type.Literal(v))));
+      } else {
+        schema = Type.Array(Type.String());
+      }
+      break;
+    case "enum":
+      if (field.values && field.values.length > 0) {
+        schema = Type.Union(field.values.map((v) => Type.Literal(v)));
+      } else {
+        schema = Type.String();
+      }
+      break;
+    case "relationship":
+      schema = Type.String();
+      break;
+    case "upload":
+      schema = Type.Any();
+      break;
+    case "array":
+      schema = Type.Array(Type.Unknown());
+      break;
+    case "object":
+      if (field.fields && field.fields.length > 0) {
+        const props = {};
+        for (const f of field.fields) {
+          props[f.name] = fieldToTypeBox(f);
+        }
+        schema = Type.Object(props, { additionalProperties: false });
+      } else {
+        schema = Type.Record(Type.String(), Type.Unknown());
+      }
+      break;
+    default:
+      schema = Type.Unknown();
+  }
+  if (field.isArray) {
+    schema = Type.Array(schema);
+  }
+  if (field.optional || field.default !== undefined) {
+    schema = Type.Optional(schema);
+  }
+  return schema;
+}
+var compiledCreateCache = new Map;
+var compiledUpdateCache = new Map;
+function validateCreate(collection, data) {
+  if (!collection.fields || collection.fields.length === 0) {
+    return data;
+  }
+  console.log("Validating CREATE for", collection.slug, "FormatRegistry has date-time:", FormatRegistry.Has("date-time"));
+  let check = compiledCreateCache.get(collection.slug);
+  if (!check) {
+    const schema = buildCollectionCreateSchema(collection);
+    if (collection.slug === "kitchenSinks")
+      console.log("SCHEMA:", JSON.stringify(schema, null, 2));
+    check = TypeCompiler.Compile(schema);
+    compiledCreateCache.set(collection.slug, check);
+  }
+  if (!check.Check(data)) {
+    const firstError = check.Errors(data).First();
+    const path = firstError?.path ? ` at ${firstError.path}` : "";
+    const message = firstError?.message ? `Validation error${path}: ${firstError.message}` : `Validation error${path}`;
+    throw CequreError.BadRequest(message);
+  }
+  return data;
+}
+function validateUpdate(collection, data) {
+  if (!collection.fields || collection.fields.length === 0) {
+    return data;
+  }
+  let check = compiledUpdateCache.get(collection.slug);
+  if (!check) {
+    const schema = buildCollectionUpdateSchema(collection);
+    check = TypeCompiler.Compile(schema);
+    compiledUpdateCache.set(collection.slug, check);
+  }
+  if (!check.Check(data)) {
+    const firstError = check.Errors(data).First();
+    const path = firstError?.path ? ` at ${firstError.path}` : "";
+    const message = firstError?.message ? `Validation error${path}: ${firstError.message}` : `Validation error${path}`;
+    throw CequreError.BadRequest(message);
+  }
+  return data;
+}
+// shared/core/stream.ts
+class MemoryStreamStore {
+  streams = new Map;
+  maxCapacity;
+  constructor(maxCapacity = 1000) {
+    this.maxCapacity = maxCapacity;
+  }
+  async publish(collection, action, data) {
+    if (!this.streams.has(collection)) {
+      this.streams.set(collection, []);
+    }
+    const stream = this.streams.get(collection);
+    const timestamp = Date.now();
+    const id = `${timestamp}-${Math.random().toString(36).substring(2, 7)}`;
+    const event = {
+      id,
+      collection,
+      action,
+      data,
+      timestamp
+    };
+    stream.push(event);
+    if (stream.length > this.maxCapacity) {
+      stream.shift();
+    }
+    return id;
+  }
+  async read(collection, lastEventId) {
+    const stream = this.streams.get(collection) || [];
+    if (!lastEventId) {
+      return stream;
+    }
+    const index = stream.findIndex((e) => e.id === lastEventId);
+    if (index === -1) {
+      return stream;
+    }
+    return stream.slice(index + 1);
+  }
+}
+export { MemoryStreamStore, buildCollectionCreateSchema, buildCollectionUpdateSchema, validateCreate, validateUpdate, generateScalarHTML, generateOpenAPISpec, init_openapi, MemoryCacheStore, CequreMailer, createMailer, generateSharedModels, generateTypeScriptClientSDK, generateBackendSchemas, exports_sdk, init_sdk, BaseSqlAdapter, sqlIdentifier, sqlLiteral, sortPlugins, parseQuery, createRouteContext };