@kyro-cms/core 0.10.4 → 0.10.6

package/dist/chunk-74YSDAWE.cjs

@@ -1,2749 +0,0 @@
-'use strict';
-
-var chunk3KTWGODI_cjs = require('./chunk-3KTWGODI.cjs');
-var chunkTQG7G7YI_cjs = require('./chunk-TQG7G7YI.cjs');
-var chunkN4GN6Q3V_cjs = require('./chunk-N4GN6Q3V.cjs');
-var chunkB6X3LN25_cjs = require('./chunk-B6X3LN25.cjs');
-var chunkLNTFRAHF_cjs = require('./chunk-LNTFRAHF.cjs');
-var chunk4OCMVGEY_cjs = require('./chunk-4OCMVGEY.cjs');
-var chunkEEJUFDMF_cjs = require('./chunk-EEJUFDMF.cjs');
-var chunkOIRG6ZRV_cjs = require('./chunk-OIRG6ZRV.cjs');
-var chunkDPA3KWPY_cjs = require('./chunk-DPA3KWPY.cjs');
-var chunkGUUB5EAG_cjs = require('./chunk-GUUB5EAG.cjs');
-var zod = require('zod');
-var graphqlYoga = require('graphql-yoga');
-var module$1 = require('module');
-var crypto = require('crypto');
-
-var _documentCurrentScript = typeof document !== 'undefined' ? document.currentScript : null;
-// src/registry/validator.ts
-function findFieldByName(fields, name) {
-  for (const field of fields) {
-    if (field.name === name) {
-      return true;
-    }
-    if ("tabs" in field && field.tabs) {
-      for (const tab of field.tabs) {
-        if (findFieldByName(tab.fields, name)) {
-          return true;
-        }
-      }
-    }
-    if ("fields" in field && field.fields) {
-      if (findFieldByName(field.fields, name)) {
-        return true;
-      }
-    }
-  }
-  return false;
-}
-var ConfigValidationError = class extends Error {
-  errors;
-  constructor(errors) {
-    super(`Configuration validation failed:
-${errors.join("\n")}`);
-    this.name = "ConfigValidationError";
-    this.errors = errors;
-  }
-};
-function validateCollection(config) {
-  const errors = [];
-  if (!config.slug) {
-    errors.push(`Collection is missing a "slug" property`);
-  } else if (!/^[a-z][a-z0-9_-]*$/.test(config.slug)) {
-    errors.push(`Collection slug "${config.slug}" must be lowercase alphanumeric with dashes`);
-  }
-  if (!config.fields || config.fields.length === 0) {
-    errors.push(`Collection "${config.slug}" has no fields defined`);
-  } else {
-    const fieldErrors = validateFields(config.fields, config.slug);
-    errors.push(...fieldErrors);
-  }
-  if (config.access) {
-    for (const [action, handler] of Object.entries(config.access)) {
-      if (typeof handler !== "boolean" && typeof handler !== "function") {
-        errors.push(`Collection "${config.slug}" has invalid access.${action} (must be boolean or function)`);
-      }
-    }
-  }
-  if (config.admin?.useAsTitle) {
-    const fieldExists = findFieldByName(config.fields, config.admin.useAsTitle);
-    if (!fieldExists) {
-      errors.push(`Collection "${config.slug}" admin.useAsTitle references unknown field "${config.admin.useAsTitle}"`);
-    }
-  }
-  if (config.admin?.defaultColumns) {
-    for (const col of config.admin.defaultColumns) {
-      const fieldExists = findFieldByName(config.fields, col);
-      if (!fieldExists) {
-        errors.push(`Collection "${config.slug}" admin.defaultColumns references unknown field "${col}"`);
-      }
-    }
-  }
-  if (config.upload) {
-    if (config.upload.fileSize && config.upload.fileSize <= 0) {
-      errors.push(`Collection "${config.slug}" upload.fileSize must be positive`);
-    }
-  }
-  if (config.versions) {
-    if (config.versions.maxPerDoc && config.versions.maxPerDoc <= 0) {
-      errors.push(`Collection "${config.slug}" versions.maxPerDoc must be positive`);
-    }
-  }
-  if (config.auth) {
-    const hasEmailField = config.fields.some((f) => f.name === "email");
-    const hasPasswordField = config.fields.some((f) => f.name === "password");
-    if (!hasEmailField) {
-      errors.push(`Collection "${config.slug}" with auth enabled requires an "email" field`);
-    }
-    if (!hasPasswordField) {
-      errors.push(`Collection "${config.slug}" with auth enabled requires a "password" field`);
-    }
-  }
-  return errors;
-}
-function validateGlobal(config) {
-  const errors = [];
-  if (!config.slug) {
-    errors.push(`Global is missing a "slug" property`);
-  } else if (!/^[a-z][a-z0-9_-]*$/.test(config.slug)) {
-    errors.push(`Global slug "${config.slug}" must be lowercase alphanumeric with dashes`);
-  }
-  if (!config.fields || config.fields.length === 0) {
-    errors.push(`Global "${config.slug}" has no fields defined`);
-  } else {
-    const fieldErrors = validateFields(config.fields, `global:${config.slug}`);
-    errors.push(...fieldErrors);
-  }
-  return errors;
-}
-function validateFields(fields, context) {
-  const errors = [];
-  const fieldNames = /* @__PURE__ */ new Set();
-  for (let i = 0; i < fields.length; i++) {
-    const field = fields[i];
-    if (field.type === "row" || field.type === "collapsible" || field.type === "tabs") {
-      if ("fields" in field && field.fields) {
-        const nestedErrors = validateFields(field.fields, context);
-        errors.push(...nestedErrors);
-      } else if ("tabs" in field) {
-        for (const tab of field.tabs) {
-          const tabErrors = validateFields(tab.fields, context);
-          errors.push(...tabErrors);
-        }
-      }
-      continue;
-    }
-    const fieldName = field.name;
-    if (!fieldName) {
-      errors.push(`${context}: Field at index ${i} is missing a "name" property`);
-      continue;
-    }
-    if (fieldNames.has(fieldName)) {
-      errors.push(`${context}: Duplicate field name "${fieldName}"`);
-    }
-    fieldNames.add(fieldName);
-    if (!/^[a-zA-Z][a-zA-Z0-9_]*$/.test(fieldName)) {
-      errors.push(`${context}: Field name "${fieldName}" must be alphanumeric with underscores`);
-    }
-    if (!field.type) {
-      errors.push(`${context}: Field "${fieldName}" is missing a "type" property`);
-      continue;
-    }
-    switch (field.type) {
-      case "relationship":
-        if (!field.relationTo) {
-          errors.push(`${context}: Relationship field "${fieldName}" is missing "relationTo"`);
-        }
-        break;
-      case "array":
-        if (!field.fields || field.fields.length === 0) {
-          errors.push(`${context}: Array field "${fieldName}" has no fields defined`);
-        } else {
-          const arrayErrors = validateFields(field.fields, `${context}.${fieldName}`);
-          errors.push(...arrayErrors);
-        }
-        break;
-      case "group":
-        if (!field.fields || field.fields.length === 0) {
-          errors.push(`${context}: Group field "${fieldName}" has no fields defined`);
-        } else {
-          const groupErrors = validateFields(field.fields, `${context}.${fieldName}`);
-          errors.push(...groupErrors);
-        }
-        break;
-      case "blocks":
-        if (!field.blocks || field.blocks.length === 0) {
-          errors.push(`${context}: Blocks field "${fieldName}" has no blocks defined`);
-        } else {
-          const blockErrors = validateBlocks(field.blocks, `${context}.${fieldName}`);
-          errors.push(...blockErrors);
-        }
-        break;
-      case "select":
-      case "radio":
-        if ((!field.options || field.options.length === 0) && !field.dynamicOptions) {
-          errors.push(`${context}: ${field.type} field "${fieldName}" has no options defined`);
-        } else if (field.options) {
-          const values = field.options.map((o) => o.value);
-          const uniqueValues = new Set(values);
-          if (values.length !== uniqueValues.size) {
-            errors.push(`${context}: ${field.type} field "${fieldName}" has duplicate option values`);
-          }
-        }
-        break;
-      case "upload":
-        if (!field.relationTo) {
-          errors.push(`${context}: Upload field "${fieldName}" is missing "relationTo"`);
-        }
-        break;
-    }
-    if ("min" in field && "max" in field && field.min > field.max) {
-      errors.push(`${context}: Field "${fieldName}" has min greater than max`);
-    }
-    if ("minLength" in field && "maxLength" in field && field.minLength > field.maxLength) {
-      errors.push(`${context}: Field "${fieldName}" has minLength greater than maxLength`);
-    }
-    if ("minRows" in field && "maxRows" in field && field.minRows > field.maxRows) {
-      errors.push(`${context}: Field "${fieldName}" has minRows greater than maxRows`);
-    }
-  }
-  return errors;
-}
-function validateBlocks(blocks, context) {
-  const errors = [];
-  const slugs = /* @__PURE__ */ new Set();
-  for (const block of blocks) {
-    if (!block.slug) {
-      errors.push(`${context}: Block is missing a "slug" property`);
-      continue;
-    }
-    if (slugs.has(block.slug)) {
-      errors.push(`${context}: Duplicate block slug "${block.slug}"`);
-    }
-    slugs.add(block.slug);
-    if (!block.label) {
-      errors.push(`${context}: Block "${block.slug}" is missing a "label" property`);
-    }
-    if (!block.fields || block.fields.length === 0) {
-      errors.push(`${context}: Block "${block.slug}" has no fields defined`);
-    } else {
-      const blockErrors = validateFields(block.fields, `${context}.${block.slug}`);
-      errors.push(...blockErrors);
-    }
-  }
-  return errors;
-}
-function validateConfig(collections, globals = []) {
-  const errors = [];
-  const slugs = /* @__PURE__ */ new Set();
-  for (const collection of collections) {
-    if (slugs.has(collection.slug)) {
-      errors.push(`Duplicate collection slug "${collection.slug}"`);
-    }
-    slugs.add(collection.slug);
-  }
-  for (const global of globals) {
-    if (slugs.has(global.slug)) {
-      errors.push(`Duplicate global slug "${global.slug}"`);
-    }
-    slugs.add(global.slug);
-  }
-  for (const collection of collections) {
-    const collectionErrors = validateCollection(collection);
-    errors.push(...collectionErrors);
-  }
-  for (const global of globals) {
-    const globalErrors = validateGlobal(global);
-    errors.push(...globalErrors);
-  }
-  for (const collection of collections) {
-    const relationshipErrors = validateRelationships(collection.fields, collections);
-    errors.push(...relationshipErrors);
-  }
-  if (errors.length > 0) {
-    throw new ConfigValidationError(errors);
-  }
-}
-function validateRelationships(fields, collections) {
-  const errors = [];
-  const collectionSlugs = new Set(collections.map((c) => c.slug));
-  for (const field of fields) {
-    if (field.type === "relationship") {
-      const targets = Array.isArray(field.relationTo) ? field.relationTo : [field.relationTo];
-      for (const target of targets) {
-        if (!collectionSlugs.has(target)) {
-          console.warn(`[Kyro Config Warning]: Relationship field "${field.name}" references unknown collection "${target}". Select options will not be available until this collection is registered.`);
-        }
-      }
-    }
-    if (field.type === "upload") {
-      const targets = Array.isArray(field.relationTo) ? field.relationTo : [field.relationTo];
-      for (const target of targets) {
-        if (!collectionSlugs.has(target)) {
-          errors.push(`Upload field "${field.name}" references unknown collection "${target}"`);
-        }
-      }
-    }
-    if ("fields" in field && field.fields) {
-      const nestedErrors = validateRelationships(field.fields, collections);
-      errors.push(...nestedErrors);
-    }
-    if ("tabs" in field) {
-      for (const tab of field.tabs) {
-        const tabErrors = validateRelationships(tab.fields, collections);
-        errors.push(...tabErrors);
-      }
-    }
-    if ("blocks" in field) {
-      for (const block of field.blocks) {
-        const blockErrors = validateRelationships(block.fields, collections);
-        errors.push(...blockErrors);
-      }
-    }
-  }
-  return errors;
-}
-function fieldToZod(field) {
-  switch (field.type) {
-    case "text":
-      return textToZod(field);
-    case "number":
-      return numberToZod(field);
-    case "checkbox":
-      return checkboxToZod(field);
-    case "date":
-      return dateToZod(field);
-    case "email":
-      return emailToZod(field);
-    case "password":
-      return passwordToZod(field);
-    case "textarea":
-      return textareaToZod(field);
-    case "select":
-      return selectToZod(field);
-    case "radio":
-      return radioToZod(field);
-    case "color":
-      return colorToZod(field);
-    case "richtext":
-      return richTextToZod(field);
-    case "json":
-      return jsonToZod(field);
-    case "code":
-      return codeToZod(field);
-    case "upload":
-      return uploadToZod(field);
-    case "image":
-      return uploadToZod(field);
-    case "markdown":
-      return markdownToZod(field);
-    case "relationship":
-      return relationshipToZod(field);
-    case "relationship-block":
-      return relationshipToZod(field);
-    case "array":
-      return arrayToZod(field);
-    case "list":
-      return listToZod(field);
-    case "group":
-      return groupToZod(field);
-    case "blocks":
-      return blocksToZod(field);
-    case "row":
-      return rowToZod(field);
-    case "collapsible":
-      return collapsibleToZod(field);
-    case "tabs":
-      return tabsToZod(field);
-    default:
-      return zod.z.any();
-  }
-}
-function textToZod(field) {
-  let schema = zod.z.string();
-  if (field.minLength) schema = schema.min(field.minLength);
-  if (field.maxLength) schema = schema.max(field.maxLength);
-  if (field.pattern) schema = schema.regex(new RegExp(field.pattern));
-  if (field.variant === "email") schema = schema.email();
-  if (field.variant === "url") schema = schema.url();
-  if (field.hasMany) schema = zod.z.array(schema);
-  if (!field.required) schema = schema.optional().nullable();
-  if (field.validate) schema = addCustomValidation(schema, field.validate);
-  return schema;
-}
-function numberToZod(field) {
-  let schema = field.integer ? zod.z.coerce.number().int() : zod.z.coerce.number();
-  if (field.min !== void 0) schema = schema.min(field.min);
-  if (field.max !== void 0) schema = schema.max(field.max);
-  if (field.step) {
-    schema = schema.refine(
-      (val) => Number.isInteger(val / field.step),
-      `Value must be divisible by ${field.step}`
-    );
-  }
-  if (field.hasMany) schema = zod.z.array(schema);
-  if (!field.required) schema = schema.optional().nullable();
-  if (field.validate) schema = addCustomValidation(schema, field.validate);
-  return schema;
-}
-function checkboxToZod(field) {
-  let schema = zod.z.boolean();
-  if (!field.required) schema = schema.optional().nullable();
-  if (field.validate) schema = addCustomValidation(schema, field.validate);
-  return schema;
-}
-function dateToZod(field) {
-  let schema = zod.z.string().refine((val) => !isNaN(Date.parse(val)), "Invalid date format");
-  if (field.minDate) {
-    schema = schema.refine(
-      (val) => new Date(val) >= new Date(field.minDate),
-      `Date must be after ${field.minDate}`
-    );
-  }
-  if (field.maxDate) {
-    schema = schema.refine(
-      (val) => new Date(val) <= new Date(field.maxDate),
-      `Date must be before ${field.maxDate}`
-    );
-  }
-  if (!field.required) schema = schema.optional().nullable();
-  if (field.validate) schema = addCustomValidation(schema, field.validate);
-  return schema;
-}
-function emailToZod(field) {
-  let schema = zod.z.string().email("Invalid email");
-  if (!field.required) schema = schema.optional().nullable();
-  if (field.validate) schema = addCustomValidation(schema, field.validate);
-  return schema;
-}
-function passwordToZod(field) {
-  let schema = zod.z.string().min(6, "Password must be at least 6 characters");
-  if (!field.required) schema = schema.optional().nullable();
-  if (field.validate) schema = addCustomValidation(schema, field.validate);
-  return schema;
-}
-function textareaToZod(field) {
-  let schema = zod.z.string();
-  if (field.minLength) schema = schema.min(field.minLength);
-  if (field.maxLength) schema = schema.max(field.maxLength);
-  if (!field.required) schema = schema.optional().nullable();
-  if (field.validate) schema = addCustomValidation(schema, field.validate);
-  return schema;
-}
-function selectToZod(field) {
-  let schema;
-  if (field.options && field.options.length > 0) {
-    const values = field.options.map((opt) => opt.value);
-    if (field.hasMany) {
-      schema = zod.z.array(zod.z.enum(values));
-    } else {
-      schema = zod.z.enum(values);
-    }
-  } else {
-    schema = field.hasMany ? zod.z.array(zod.z.string()) : zod.z.string();
-  }
-  if (!field.required) schema = schema.optional().nullable();
-  if (field.validate) schema = addCustomValidation(schema, field.validate);
-  return schema;
-}
-function radioToZod(field) {
-  const values = field.options.map((opt) => opt.value);
-  let schema = zod.z.enum(values);
-  if (!field.required) schema = schema.optional().nullable();
-  if (field.validate) schema = addCustomValidation(schema, field.validate);
-  return schema;
-}
-function colorToZod(field) {
-  let schema = zod.z.string();
-  if (field.format === "hex")
-    schema = schema.regex(/^#[0-9A-Fa-f]{6}$/);
-  if (field.format === "rgb")
-    schema = schema.regex(
-      /^rgb\(\s*\d{1,3}\s*,\s*\d{1,3}\s*,\s*\d{1,3}\s*\)$/
-    );
-  if (field.format === "hsl")
-    schema = schema.regex(
-      /^hsl\(\s*\d{1,3}\s*,\s*\d{1,3}%\s*,\s*\d{1,3}%\s*\)$/
-    );
-  if (!field.required) schema = schema.optional().nullable();
-  if (field.validate) schema = addCustomValidation(schema, field.validate);
-  return schema;
-}
-function richTextToZod(field) {
-  let schema = zod.z.array(zod.z.record(zod.z.any()));
-  if (!field.required) schema = schema.optional().nullable();
-  if (field.validate) schema = addCustomValidation(schema, field.validate);
-  return schema;
-}
-function jsonToZod(field) {
-  let schema = zod.z.union([zod.z.record(zod.z.any()), zod.z.array(zod.z.any())]);
-  if (!field.required) schema = schema.optional().nullable();
-  if (field.validate) schema = addCustomValidation(schema, field.validate);
-  return schema;
-}
-function codeToZod(field) {
-  let schema = zod.z.string();
-  if (!field.required) schema = schema.optional().nullable();
-  if (field.validate) schema = addCustomValidation(schema, field.validate);
-  return schema;
-}
-function uploadToZod(field) {
-  let schema;
-  if (field.relationTo) {
-    const mediaSchema = zod.z.object({
-      id: zod.z.string(),
-      url: zod.z.string().optional(),
-      filename: zod.z.string().optional(),
-      mimeType: zod.z.string().optional()
-    });
-    schema = zod.z.union([zod.z.string(), mediaSchema]);
-  } else {
-    schema = zod.z.string();
-  }
-  if (field.hasMany) {
-    schema = zod.z.array(schema);
-  }
-  if (!field.required) {
-    schema = schema.optional().nullable();
-  }
-  if (field.validate) {
-    schema = addCustomValidation(schema, field.validate);
-  }
-  return schema;
-}
-function markdownToZod(field) {
-  let schema = zod.z.string();
-  if (!field.required) schema = schema.optional().nullable();
-  if (field.validate) schema = addCustomValidation(schema, field.validate);
-  return schema;
-}
-function relationshipToZod(field) {
-  let schema;
-  if (Array.isArray(field.relationTo)) {
-    schema = zod.z.object({
-      relationTo: zod.z.enum(field.relationTo),
-      value: zod.z.string()
-    });
-  } else {
-    schema = zod.z.union([
-      zod.z.string(),
-      zod.z.object({ relationTo: zod.z.string(), value: zod.z.string() })
-    ]);
-  }
-  if (field.hasMany) schema = zod.z.array(schema);
-  if (!field.required) schema = schema.optional().nullable();
-  if (field.validate) schema = addCustomValidation(schema, field.validate);
-  return schema;
-}
-function arrayToZod(field) {
-  const itemSchema = zod.z.object(
-    Object.fromEntries(
-      field.fields.filter((f) => f.name).map((f) => [f.name, fieldToZod(f)])
-    )
-  );
-  let schema = zod.z.array(itemSchema);
-  if (field.minRows) schema = schema.min(field.minRows);
-  if (field.maxRows) schema = schema.max(field.maxRows);
-  if (!field.required) schema = schema.optional().nullable();
-  if (field.validate) schema = addCustomValidation(schema, field.validate);
-  return schema;
-}
-function listToZod(field) {
-  let schema = zod.z.array(zod.z.string());
-  if (!field.required) schema = schema.optional().nullable();
-  return schema;
-}
-function groupToZod(field) {
-  const schema = zod.z.object(
-    Object.fromEntries(
-      field.fields.filter((f) => f.name).map((f) => [f.name, fieldToZod(f)])
-    )
-  );
-  if (!field.required) return schema.optional().nullable();
-  return schema;
-}
-function blocksToZod(field) {
-  const blocks = field.blocks || [];
-  blocks.map((block) => {
-    return zod.z.object({
-      blockType: zod.z.literal(block.slug),
-      ...Object.fromEntries(
-        block.fields.filter((f) => f.name).map((f) => [f.name, fieldToZod(f)])
-      )
-    });
-  });
-  const knownTypes = blocks.map((b) => b.slug);
-  let schema;
-  if (knownTypes.length > 0) {
-    const knownSchema = zod.z.object({
-      blockType: zod.z.enum(knownTypes)
-    }).catchall(zod.z.any());
-    const unknownSchema = zod.z.object({
-      blockType: zod.z.string()
-    }).catchall(zod.z.any());
-    schema = zod.z.array(zod.z.union([knownSchema, unknownSchema, zod.z.record(zod.z.any())]));
-  } else {
-    schema = zod.z.array(zod.z.union([zod.z.object({ blockType: zod.z.string() }).catchall(zod.z.any()), zod.z.record(zod.z.any())]));
-  }
-  if (field.minRows) schema = schema.min(field.minRows);
-  if (field.maxRows) schema = schema.max(field.maxRows);
-  if (!field.required) schema = schema.optional().nullable();
-  if (field.validate) schema = addCustomValidation(schema, field.validate);
-  return schema;
-}
-function rowToZod(field) {
-  const schema = zod.z.object(
-    Object.fromEntries(
-      field.fields.filter((f) => f.name).map((f) => [f.name, fieldToZod(f)])
-    )
-  );
-  return schema;
-}
-function collapsibleToZod(field) {
-  const schema = zod.z.object(
-    Object.fromEntries(
-      field.fields.filter((f) => f.name).map((f) => [f.name, fieldToZod(f)])
-    )
-  );
-  return schema;
-}
-function tabsToZod(field) {
-  const schemas = {};
-  for (const tab of field.tabs) {
-    for (const f of tab.fields) {
-      if (f.name) {
-        schemas[f.name] = fieldToZod(f);
-      }
-    }
-  }
-  return zod.z.object(schemas).passthrough().optional();
-}
-function addCustomValidation(schema, validate) {
-  return schema.refine(
-    async (val) => {
-      const result = await validate(val, { required: false });
-      return result === true;
-    },
-    {
-      message: "Custom validation failed"
-    }
-  );
-}
-function buildNestedShape(fields) {
-  const shape = {};
-  for (const field of fields) {
-    if (!field.name) continue;
-    if (field.type === "tabs" && "tabs" in field) {
-      const tabShape = {};
-      for (const tab of field.tabs) {
-        const nestedShape = buildNestedShape(tab.fields);
-        Object.assign(tabShape, nestedShape);
-      }
-      shape[field.name] = zod.z.object(tabShape).passthrough().optional();
-    } else if (field.type === "row" && "fields" in field) {
-      const rowShape = buildNestedShape(field.fields);
-      Object.assign(shape, rowShape);
-    } else if (field.type === "collapsible" && "fields" in field) {
-      shape[field.name] = zod.z.object(buildNestedShape(field.fields)).passthrough().optional();
-    } else {
-      shape[field.name] = fieldToZod(field);
-    }
-  }
-  return shape;
-}
-function buildUpdateNestedShape(fields) {
-  const shape = {};
-  for (const field of fields) {
-    if (!field.name) continue;
-    if (field.type === "tabs" && "tabs" in field) {
-      const tabShape = {};
-      for (const tab of field.tabs) {
-        const nestedShape = buildUpdateNestedShape(tab.fields);
-        Object.assign(tabShape, nestedShape);
-      }
-      shape[field.name] = zod.z.object(tabShape).passthrough().optional().nullable();
-    } else if (field.type === "row" && "fields" in field) {
-      const rowShape = buildUpdateNestedShape(field.fields);
-      Object.assign(shape, rowShape);
-    } else if (field.type === "collapsible" && "fields" in field) {
-      shape[field.name] = zod.z.object(buildUpdateNestedShape(field.fields)).passthrough().optional().nullable();
-    } else if (field.type === "group" && "fields" in field) {
-      shape[field.name] = zod.z.object(buildUpdateNestedShape(field.fields)).passthrough().optional().nullable();
-    } else {
-      shape[field.name] = fieldToZod(field).optional().nullable();
-    }
-  }
-  return shape;
-}
-function collectionToZod(collection) {
-  const shape = buildNestedShape(collection.fields);
-  if (collection.timestamps) {
-    shape["createdAt"] = zod.z.string().optional();
-    shape["updatedAt"] = zod.z.string().optional();
-  }
-  if (collection.tenantScoped) {
-    shape["tenantID"] = zod.z.string().optional();
-  }
-  shape["id"] = zod.z.string().optional();
-  return zod.z.object(shape).passthrough();
-}
-function collectionToCreateZod(collection) {
-  const shape = buildNestedShape(collection.fields);
-  return zod.z.object(shape).passthrough();
-}
-function collectionToUpdateZod(collection) {
-  const shape = {};
-  for (const field of collection.fields) {
-    if (!field.name) continue;
-    if (field.type === "tabs" && "tabs" in field) {
-      const tabShape = {};
-      for (const tab of field.tabs) {
-        for (const tabField of tab.fields) {
-          if (tabField.name) {
-            tabShape[tabField.name] = fieldToZod(tabField).optional().nullable();
-          }
-        }
-      }
-      shape[field.name] = zod.z.object(tabShape).optional().nullable();
-    } else if (field.type === "row" && "fields" in field) {
-      const rowShape = {};
-      for (const rowField of field.fields) {
-        if (rowField.name) {
-          rowShape[rowField.name] = fieldToZod(rowField).optional().nullable();
-        }
-      }
-      Object.assign(shape, rowShape);
-    } else if (field.type === "collapsible" && "fields" in field) {
-      shape[field.name] = zod.z.object(buildUpdateNestedShape(field.fields)).optional().nullable();
-    } else if (field.type === "group" && "fields" in field) {
-      shape[field.name] = zod.z.object(buildUpdateNestedShape(field.fields)).optional().nullable();
-    } else {
-      shape[field.name] = fieldToZod(field).optional().nullable();
-    }
-  }
-  return zod.z.object(shape).passthrough();
-}
-function collectionToWhereZod(collection) {
-  const shape = {};
-  for (const field of collection.fields) {
-    if (field.name) {
-      shape[field.name] = zod.z.object({
-        equals: zod.z.any().optional(),
-        not_equals: zod.z.any().optional(),
-        in: zod.z.array(zod.z.any()).optional(),
-        not_in: zod.z.array(zod.z.any()).optional(),
-        greater_than: zod.z.number().optional(),
-        greater_than_equal: zod.z.number().optional(),
-        less_than: zod.z.number().optional(),
-        less_than_equal: zod.z.number().optional(),
-        like: zod.z.string().optional(),
-        not_like: zod.z.string().optional(),
-        contains: zod.z.string().optional(),
-        exists: zod.z.boolean().optional()
-      }).optional();
-    }
-  }
-  shape["AND"] = zod.z.array(zod.z.lazy(() => zod.z.object(shape))).optional();
-  shape["OR"] = zod.z.array(zod.z.lazy(() => zod.z.object(shape))).optional();
-  return zod.z.object(shape).optional();
-}
-function globalToZod(global) {
-  const shape = buildNestedShape(global.fields);
-  shape["id"] = zod.z.string().optional();
-  return zod.z.object(shape).passthrough();
-}
-function globalToUpdateZod(global) {
-  const shape = {};
-  for (const field of global.fields) {
-    if (!field.name) continue;
-    if (field.type === "tabs" && "tabs" in field) {
-      const tabShape = {};
-      for (const tab of field.tabs) {
-        for (const tabField of tab.fields) {
-          if (tabField.name) {
-            tabShape[tabField.name] = fieldToZod(tabField).optional().nullable();
-          }
-        }
-      }
-      shape[field.name] = zod.z.object(tabShape).optional().nullable();
-    } else if (field.type === "collapsible" && "fields" in field) {
-      shape[field.name] = zod.z.object(buildUpdateNestedShape(field.fields)).optional().nullable();
-    } else if (field.type === "group" && "fields" in field) {
-      shape[field.name] = zod.z.object(buildUpdateNestedShape(field.fields)).optional().nullable();
-    } else {
-      shape[field.name] = fieldToZod(field).optional().nullable();
-    }
-  }
-  return zod.z.object(shape).passthrough();
-}
-
-// src/registry/index.ts
-var Registry = class {
-  storageProviders = chunkB6X3LN25_cjs.getDefaultRegistry();
-  collections = /* @__PURE__ */ new Map();
-  globals = /* @__PURE__ */ new Map();
-  plugins = [];
-  schemaCache = /* @__PURE__ */ new Map();
-  initialized = false;
-  // ========================================================================
-  // Collection Management
-  // ========================================================================
-  addCollection(config) {
-    if (this.initialized) {
-      throw new Error(
-        "Cannot add collections after Registry has been initialized"
-      );
-    }
-    if (this.collections.has(config.slug)) {
-      console.warn(
-        `[Registry] Duplicate collection slug "${config.slug}" \u2014 skipping`
-      );
-      return;
-    }
-    let finalConfig = { ...config };
-    for (const plugin of this.plugins) {
-      if (plugin.extendCollection) {
-        finalConfig = plugin.extendCollection(finalConfig.slug, finalConfig);
-      }
-    }
-    finalConfig.fields = this.applyFieldDefaults(finalConfig);
-    const errors = validateCollection(finalConfig);
-    if (errors.length > 0) {
-      throw new Error(`Invalid collection config: ${errors.join(", ")}`);
-    }
-    this.collections.set(finalConfig.slug, finalConfig);
-    this.clearSchemaCache(finalConfig.slug);
-  }
-  addCollections(configs) {
-    for (const config of configs) {
-      this.addCollection(config);
-    }
-  }
-  getCollection(slug) {
-    return this.collections.get(slug);
-  }
-  getCollections() {
-    return Array.from(this.collections.values());
-  }
-  getCollectionSlugs() {
-    return Array.from(this.collections.keys());
-  }
-  hasCollection(slug) {
-    return this.collections.has(slug);
-  }
-  removeCollection(slug) {
-    if (this.initialized) {
-      throw new Error(
-        "Cannot remove collections after Registry has been initialized"
-      );
-    }
-    this.clearSchemaCache(slug);
-    return this.collections.delete(slug);
-  }
-  // ========================================================================
-  // Global Management
-  // ========================================================================
-  addGlobal(config) {
-    if (this.initialized) {
-      throw new Error("Cannot add globals after Registry has been initialized");
-    }
-    this._addGlobalUnsafe(config);
-  }
-  /**
-   * Add a global after the registry is already initialized.
-   * Only for internal use (e.g. storage settings form built at startup).
-   */
-  addGlobalPostInit(config) {
-    if (this.globals.has(config.slug)) {
-      this.globals.delete(config.slug);
-    }
-    this._addGlobalUnsafe(config);
-  }
-  _addGlobalUnsafe(config) {
-    if (this.globals.has(config.slug)) {
-      console.warn(
-        `[Registry] Duplicate global slug "${config.slug}" \u2014 skipping`
-      );
-      return;
-    }
-    const errors = validateGlobal(config);
-    if (errors.length > 0) {
-      throw new Error(`Invalid global config: ${errors.join(", ")}`);
-    }
-    let finalConfig = { ...config };
-    for (const plugin of this.plugins) {
-      if (plugin.extendGlobal) {
-        finalConfig = plugin.extendGlobal(finalConfig.slug, finalConfig);
-      }
-    }
-    this.globals.set(finalConfig.slug, finalConfig);
-    this.clearSchemaCache(`global:${finalConfig.slug}`);
-  }
-  addGlobals(configs) {
-    for (const config of configs) {
-      this.addGlobal(config);
-    }
-  }
-  getGlobal(slug) {
-    return this.globals.get(slug);
-  }
-  getGlobals() {
-    return Array.from(this.globals.values());
-  }
-  getGlobalSlugs() {
-    return Array.from(this.globals.keys());
-  }
-  hasGlobal(slug) {
-    return this.globals.has(slug);
-  }
-  removeGlobal(slug) {
-    if (this.initialized) {
-      throw new Error(
-        "Cannot remove globals after Registry has been initialized"
-      );
-    }
-    this.clearSchemaCache(`global:${slug}`);
-    return this.globals.delete(slug);
-  }
-  // ========================================================================
-  // Plugin Management
-  // ========================================================================
-  addPlugin(plugin) {
-    if (this.initialized) {
-      throw new Error("Cannot add plugins after Registry has been initialized");
-    }
-    this.plugins.push(plugin);
-  }
-  getPlugins() {
-    return [...this.plugins];
-  }
-  // ========================================================================
-  // Schema Generation
-  // ========================================================================
-  getZodSchema(slug) {
-    const cached = this.schemaCache.get(slug);
-    if (cached) return cached;
-    const collection = this.collections.get(slug);
-    if (collection) {
-      const schema = collectionToZod(collection);
-      this.schemaCache.set(slug, schema);
-      return schema;
-    }
-    const global = this.globals.get(slug);
-    if (global) {
-      const schema = globalToZod(global);
-      this.schemaCache.set(`global:${slug}`, schema);
-      return schema;
-    }
-    throw new Error(`No collection or global found with slug "${slug}"`);
-  }
-  getCreateZodSchema(slug) {
-    const cacheKey = `${slug}:create`;
-    const cached = this.schemaCache.get(cacheKey);
-    if (cached) return cached;
-    const collection = this.collections.get(slug);
-    if (collection) {
-      const schema = collectionToCreateZod(collection);
-      this.schemaCache.set(cacheKey, schema);
-      return schema;
-    }
-    throw new Error(`No collection found with slug "${slug}"`);
-  }
-  getUpdateZodSchema(slug) {
-    const cacheKey = `${slug}:update`;
-    const cached = this.schemaCache.get(cacheKey);
-    if (cached) return cached;
-    const collection = this.collections.get(slug);
-    if (collection) {
-      const schema = collectionToUpdateZod(collection);
-      this.schemaCache.set(cacheKey, schema);
-      return schema;
-    }
-    const global = this.globals.get(slug);
-    if (global) {
-      const schema = globalToUpdateZod(global);
-      this.schemaCache.set(`global:${slug}:update`, schema);
-      return schema;
-    }
-    throw new Error(`No collection or global found with slug "${slug}"`);
-  }
-  getWhereZodSchema(slug) {
-    const cacheKey = `${slug}:where`;
-    const cached = this.schemaCache.get(cacheKey);
-    if (cached) return cached;
-    const collection = this.collections.get(slug);
-    if (collection) {
-      const schema = collectionToWhereZod(collection);
-      this.schemaCache.set(cacheKey, schema);
-      return schema;
-    }
-    throw new Error(`No collection found with slug "${slug}"`);
-  }
-  getFieldZodSchema(field) {
-    return fieldToZod(field);
-  }
-  clearSchemaCache(slug) {
-    this.schemaCache.delete(slug);
-    this.schemaCache.delete(`${slug}:create`);
-    this.schemaCache.delete(`${slug}:update`);
-    this.schemaCache.delete(`${slug}:where`);
-  }
-  // ========================================================================
-  // Field Helpers
-  // ========================================================================
-  applyFieldDefaults(config) {
-    const fields = [...config.fields];
-    if (!fields.some((f) => f.name === "id")) {
-      fields.unshift({
-        name: "id",
-        type: "text",
-        admin: { readOnly: true, hidden: true }
-      });
-    }
-    if (config.tenantScoped && !fields.some((f) => f.name === "tenantID")) {
-      fields.push({
-        name: "tenantID",
-        type: "text",
-        required: true,
-        admin: { readOnly: true, hidden: true }
-      });
-    }
-    if (config.timestamps && !fields.some((f) => f.name === "createdAt")) {
-      fields.push({
-        name: "createdAt",
-        type: "date",
-        admin: { readOnly: true, hidden: true }
-      });
-      fields.push({
-        name: "updatedAt",
-        type: "date",
-        admin: { readOnly: true, hidden: true }
-      });
-    }
-    if (config.versions?.drafts && !fields.some((f) => f.name === "status")) {
-      fields.push({
-        name: "status",
-        type: "select",
-        options: [
-          { value: "draft", label: "Draft" },
-          { value: "published", label: "Published" }
-        ],
-        admin: { readOnly: true, hidden: true }
-      });
-    }
-    if (config.auth && !fields.some((f) => f.name === "password")) {
-      fields.push({
-        name: "password",
-        type: "password",
-        required: true,
-        admin: { hidden: true }
-      });
-    }
-    return fields;
-  }
-  getFields(slug) {
-    const collection = this.collections.get(slug);
-    if (collection) return collection.fields;
-    const global = this.globals.get(slug);
-    if (global) return global.fields;
-    throw new Error(`No collection or global found with slug "${slug}"`);
-  }
-  getFieldMap(slug) {
-    const fields = this.getFields(slug);
-    const map = /* @__PURE__ */ new Map();
-    const addFields = (fields2) => {
-      for (const field of fields2) {
-        if (field.name) {
-          map.set(field.name, field);
-        }
-        if ("fields" in field && field.fields) {
-          addFields(field.fields);
-        }
-        if ("tabs" in field) {
-          for (const tab of field.tabs) {
-            addFields(tab.fields);
-          }
-        }
-        if ("blocks" in field) {
-          for (const block of field.blocks) {
-            addFields(block.fields);
-          }
-        }
-      }
-    };
-    addFields(fields);
-    return map;
-  }
-  getVisibleFields(slug) {
-    const fields = this.getFields(slug);
-    return fields.filter((f) => !f.admin?.hidden);
-  }
-  // ========================================================================
-  // Initialization
-  // ========================================================================
-  validate() {
-    const collections = this.getCollections();
-    const globals = this.getGlobals();
-    validateConfig(collections, globals);
-  }
-  async init() {
-    this.validate();
-    for (const plugin of this.plugins) {
-      if (plugin.init) {
-        await plugin.init(this);
-      }
-    }
-    this.initialized = true;
-  }
-  isInitialized() {
-    return this.initialized;
-  }
-  // ========================================================================
-  // Query Helpers
-  // ========================================================================
-  getPaginationDefaults(slug) {
-    const collection = this.collections.get(slug);
-    return {
-      defaultLimit: collection?.admin?.pagination?.defaultLimit || 10,
-      limits: collection?.admin?.pagination?.limits || [10, 25, 50, 100]
-    };
-  }
-  getDefaultSort(slug) {
-    const collection = this.collections.get(slug);
-    const useAsTitle = collection?.admin?.useAsTitle;
-    if (useAsTitle) return useAsTitle;
-    return "createdAt";
-  }
-  getDefaultColumns(slug) {
-    const collection = this.collections.get(slug);
-    if (collection?.admin?.defaultColumns) {
-      return collection.admin.defaultColumns;
-    }
-    const fields = this.getVisibleFields(slug);
-    return fields.slice(0, 4).map((f) => f.name);
-  }
-  // ========================================================================
-  // Admin Helpers
-  // ========================================================================
-  getAdminTitle(slug) {
-    const collection = this.collections.get(slug);
-    return collection?.label || collection?.admin?.description || slug;
-  }
-  getAdminLabel(slug) {
-    const collection = this.collections.get(slug);
-    return collection?.singularLabel || collection?.label || slug;
-  }
-  getAdminGroup(slug) {
-    return this.collections.get(slug)?.admin?.group;
-  }
-  // ========================================================================
-  // Debug / Stats
-  // ========================================================================
-  getStats() {
-    let totalFields = 0;
-    for (const collection of this.collections.values()) {
-      totalFields += collection.fields.length;
-    }
-    for (const global of this.globals.values()) {
-      totalFields += global.fields.length;
-    }
-    return {
-      collections: this.collections.size,
-      globals: this.globals.size,
-      plugins: this.plugins.length,
-      fields: totalFields
-    };
-  }
-  toJSON() {
-    return {
-      collections: this.getCollections(),
-      globals: this.getGlobals()
-    };
-  }
-};
-var instance = null;
-function getRegistry() {
-  if (!instance) {
-    instance = new Registry();
-  }
-  return instance;
-}
-function resetRegistry() {
-  instance = null;
-}
-function createRegistry() {
-  instance = new Registry();
-  return instance;
-}
-
-// src/plugins/storage-s3.ts
-var s3Variants = {
-  aws: {
-    type: "aws",
-    configKey: "s3",
-    displayName: "S3 Compatible (AWS, Backblaze, Wasabi, etc.)",
-    configFields: [
-      { name: "bucket", type: "text", label: "Bucket Name", required: true },
-      { name: "region", type: "text", label: "Region", defaultValue: "us-east-1", admin: { placeholder: "us-east-1" } },
-      { name: "accessKeyId", type: "text", label: "Access Key ID", required: true },
-      { name: "secretAccessKey", type: "password", label: "Secret Access Key", required: true },
-      { name: "endpoint", type: "text", label: "Endpoint URL", admin: { placeholder: "https://s3.custom.com" } },
-      { name: "cdnUrl", type: "text", label: "CDN URL", admin: { placeholder: "https://cdn.example.com" } },
-      { name: "prefix", type: "text", label: "Path Prefix", admin: { placeholder: "uploads" } }
-    ]
-  },
-  r2: {
-    type: "r2",
-    configKey: "r2",
-    displayName: "Cloudflare R2",
-    configFields: [
-      { name: "accountId", type: "text", label: "Account ID", required: true, admin: { placeholder: "Your Cloudflare Account ID" } },
-      { name: "accessKeyId", type: "text", label: "Access Key ID", required: true },
-      { name: "secretAccessKey", type: "password", label: "Secret Access Key", required: true },
-      { name: "bucket", type: "text", label: "Bucket Name", required: true },
-      {
-        name: "publicDevUrl",
-        type: "text",
-        label: "Public Dev URL ID",
-        admin: {
-          placeholder: "pub-xxxxxxxxxxxxxxxx",
-          description: "Enter ONLY the ID (e.g., pub-b8d8c4cc8bcf4d868ddd95efc1b305aa). Do NOT include https:// or the full URL. Found in R2 Dashboard \u2192 Public Dev URL."
-        }
-      },
-      { name: "cdnUrl", type: "text", label: "Custom CDN URL", admin: { placeholder: "https://assets.example.com (optional)" } },
-      { name: "prefix", type: "text", label: "Path Prefix", admin: { placeholder: "uploads (optional)", description: "Optional prefix for all object keys. Do not use '/' as prefix." } }
-    ]
-  },
-  gcs: {
-    type: "gcs",
-    configKey: "gcs",
-    displayName: "Google Cloud Storage",
-    configFields: [
-      { name: "bucket", type: "text", label: "Bucket Name", required: true },
-      { name: "projectId", type: "text", label: "Project ID" },
-      { name: "clientEmail", type: "text", label: "Client Email" },
-      { name: "privateKey", type: "password", label: "Private Key" },
-      { name: "cdnUrl", type: "text", label: "CDN URL" },
-      { name: "prefix", type: "text", label: "Path Prefix" }
-    ]
-  },
-  digitalocean: {
-    type: "digitalocean",
-    configKey: "digitalocean",
-    displayName: "DigitalOcean Spaces",
-    configFields: [
-      { name: "bucket", type: "text", label: "Bucket Name", required: true },
-      { name: "region", type: "text", label: "Region", defaultValue: "nyc3" },
-      { name: "accessKeyId", type: "text", label: "Access Key ID", required: true },
-      { name: "secretAccessKey", type: "password", label: "Secret Access Key", required: true },
-      { name: "cdnUrl", type: "text", label: "CDN URL" },
-      { name: "prefix", type: "text", label: "Path Prefix" }
-    ]
-  },
-  backblaze: {
-    type: "backblaze",
-    configKey: "backblaze",
-    displayName: "Backblaze B2",
-    configFields: [
-      { name: "bucket", type: "text", label: "Bucket Name", required: true },
-      { name: "accountId", type: "text", label: "Account ID" },
-      { name: "applicationKeyId", type: "text", label: "Application Key ID", required: true },
-      { name: "applicationKey", type: "password", label: "Application Key", required: true },
-      { name: "cdnUrl", type: "text", label: "CDN URL" },
-      { name: "prefix", type: "text", label: "Path Prefix" }
-    ]
-  },
-  wasabi: {
-    type: "wasabi",
-    configKey: "wasabi",
-    displayName: "Wasabi",
-    configFields: [
-      { name: "bucket", type: "text", label: "Bucket Name", required: true },
-      { name: "region", type: "text", label: "Region", defaultValue: "us-east-1" },
-      { name: "accessKeyId", type: "text", label: "Access Key ID", required: true },
-      { name: "secretAccessKey", type: "password", label: "Secret Access Key", required: true },
-      { name: "cdnUrl", type: "text", label: "CDN URL" },
-      { name: "prefix", type: "text", label: "Path Prefix" }
-    ]
-  }
-};
-function getEndpoint(type, config) {
-  switch (type) {
-    case "r2":
-      return config?.endpoint || `https://${config?.accountId || ""}.r2.cloudflarestorage.com`;
-    case "digitalocean":
-      return config?.endpoint || `https://${config?.region || "nyc3"}.digitaloceanspaces.com`;
-    case "backblaze":
-      return config?.endpoint || `https://s3.backblazeb2.com`;
-    case "wasabi":
-      return config?.endpoint || `https://s3.${config?.region || "us-east-1"}.wasabisys.com`;
-    default:
-      return config?.endpoint;
-  }
-}
-function buildS3Config(type, c) {
-  return {
-    provider: type,
-    bucket: c?.bucket || "",
-    region: c?.region || "us-east-1",
-    accessKeyId: c?.accessKeyId || c?.clientEmail || c?.applicationKeyId || "",
-    secretAccessKey: c?.secretAccessKey || c?.privateKey || c?.applicationKey || "",
-    endpoint: getEndpoint(type, c),
-    cdnUrl: c?.cdnUrl,
-    prefix: c?.prefix,
-    accountId: c?.accountId,
-    publicDevUrl: c?.publicDevUrl
-  };
-}
-function buildS3ConfigFromStorageConfig(type, def, sc) {
-  const c = sc[def.configKey] || {};
-  return buildS3Config(type, c);
-}
-function buildS3ConfigFromRaw(type, def, raw) {
-  const c = raw?.[def.configKey] || raw;
-  return buildS3Config(type, c);
-}
-var s3StoragePlugin = {
-  name: "@kyro-cms/storage-s3",
-  version: "1.0.0",
-  description: "S3-compatible storage (AWS R2 GCS DigitalOcean Backblaze Wasabi)",
-  init: (kyro) => {
-    const registry = kyro.storageProviders;
-    if (!registry) return;
-    const pluginName = "@kyro-cms/storage-s3";
-    for (const v of Object.values(s3Variants)) {
-      registry.register({
-        type: v.type,
-        displayName: v.displayName,
-        pluginName,
-        configKey: v.configKey,
-        configFields: v.configFields,
-        extractConfig: (sc) => buildS3ConfigFromStorageConfig(v.type, v, sc),
-        extractRawConfig: (raw) => buildS3ConfigFromRaw(v.type, v, raw),
-        factory: (c) => chunkB6X3LN25_cjs.createS3Storage(c)
-      });
-    }
-  }
-};
-
-// src/plugins/storage-cloudinary.ts
-var cloudinaryStoragePlugin = {
-  name: "@kyro-cms/storage-cloudinary",
-  version: "1.0.0",
-  description: "Cloudinary image and video storage",
-  init: (kyro) => {
-    const registry = kyro.storageProviders;
-    if (!registry) return;
-    registry.register({
-      type: "cloudinary",
-      displayName: "Cloudinary",
-      pluginName: "@kyro-cms/storage-cloudinary",
-      configKey: "cloudinary",
-      configFields: [
-        { name: "cloudName", type: "text", label: "Cloud Name", required: true },
-        { name: "apiKey", type: "text", label: "API Key", required: true },
-        { name: "apiSecret", type: "password", label: "API Secret", required: true },
-        { name: "folder", type: "text", label: "Folder", admin: { placeholder: "Optional folder path" } },
-        {
-          name: "uploadPreset",
-          type: "text",
-          label: "Upload Preset (optional)",
-          admin: { placeholder: "Leave empty for signed uploads", description: "If not set, uploads will be signed with API Secret" }
-        }
-      ],
-      extractConfig: (sc) => ({
-        cloudName: sc.cloudinary?.cloudName || "",
-        apiKey: sc.cloudinary?.apiKey || "",
-        apiSecret: sc.cloudinary?.apiSecret || "",
-        folder: sc.cloudinary?.folder,
-        uploadPreset: sc.cloudinary?.uploadPreset
-      }),
-      extractRawConfig: (c) => {
-        const cl = c?.cloudinary || c;
-        return {
-          cloudName: cl?.cloudName || "",
-          apiKey: cl?.apiKey || "",
-          apiSecret: cl?.apiSecret || "",
-          folder: cl?.folder,
-          uploadPreset: cl?.uploadPreset
-        };
-      },
-      factory: (c) => chunkB6X3LN25_cjs.createCloudinaryStorage(c)
-    });
-  }
-};
-
-// src/plugins/storage-ftp.ts
-var ftpStoragePlugin = {
-  name: "@kyro-cms/storage-ftp",
-  version: "1.0.0",
-  description: "FTP/SFTP storage provider",
-  init: (kyro) => {
-    const registry = kyro.storageProviders;
-    if (!registry) return;
-    registry.register({
-      type: "ftp",
-      displayName: "FTP",
-      pluginName: "@kyro-cms/storage-ftp",
-      configKey: "ftp",
-      configFields: [
-        { name: "host", type: "text", label: "Host", required: true, admin: { placeholder: "ftp.example.com" } },
-        { name: "port", type: "number", label: "Port", defaultValue: 21, admin: { placeholder: "21 for FTP" } },
-        { name: "user", type: "text", label: "Username", required: true },
-        { name: "password", type: "password", label: "Password", required: true },
-        { name: "secure", type: "checkbox", label: "Use TLS/SSL", defaultValue: false, admin: { description: "Enable TLS/SSL for secure connections (FTP only)" } },
-        { name: "baseUrl", type: "text", label: "Base URL", required: true, admin: { placeholder: "https://files.example.com" } },
-        { name: "prefix", type: "text", label: "Path Prefix", admin: { placeholder: "uploads" } }
-      ],
-      extractConfig: (sc) => ({
-        host: sc.ftp?.host || "",
-        port: sc.ftp?.port || 21,
-        user: sc.ftp?.user || "",
-        password: sc.ftp?.password || "",
-        secure: sc.ftp?.secure || false,
-        baseUrl: sc.ftp?.baseUrl || "",
-        prefix: sc.ftp?.prefix,
-        type: "ftp"
-      }),
-      extractRawConfig: (c) => {
-        const ftp = c?.ftp || c;
-        return {
-          host: ftp?.host || "",
-          port: ftp?.port || 21,
-          user: ftp?.user || "",
-          password: ftp?.password || "",
-          secure: ftp?.secure || false,
-          baseUrl: ftp?.baseUrl || "",
-          prefix: ftp?.prefix,
-          type: "ftp"
-        };
-      },
-      factory: (c) => chunkB6X3LN25_cjs.createFtpStorage(c)
-    });
-  }
-};
-var builtinStoragePlugins = [
-  s3StoragePlugin,
-  cloudinaryStoragePlugin,
-  ftpStoragePlugin
-];
-function updateFieldByPath(fields, path, updates) {
-  const parts = path.split(".");
-  if (parts.length === 0) return false;
-  const currentPart = parts[0];
-  const remainingPath = parts.slice(1).join(".");
-  for (const field of fields) {
-    if (field.name === currentPart) {
-      if (remainingPath) {
-        if (field.fields && Array.isArray(field.fields)) {
-          return updateFieldByPath(field.fields, remainingPath, updates);
-        }
-        if (field.type === "array" && field.fields && Array.isArray(field.fields)) {
-          return updateFieldByPath(field.fields, remainingPath, updates);
-        }
-        return false;
-      } else {
-        Object.assign(field, updates);
-        return true;
-      }
-    }
-  }
-  return false;
-}
-function applyCollectionOverrides(collections, overrides) {
-  if (!overrides) return;
-  for (const col of collections) {
-    const override = overrides[col.slug];
-    if (override) {
-      const { fields: fieldOverrides, ...adminOverrides } = override;
-      col.admin = { ...col.admin, ...adminOverrides };
-      if (fieldOverrides && col.fields && Array.isArray(col.fields)) {
-        for (const [fieldPath, fieldUpdates] of Object.entries(fieldOverrides)) {
-          updateFieldByPath(col.fields, fieldPath, fieldUpdates);
-        }
-      }
-    }
-  }
-}
-var Kyro = class {
-  registry;
-  db;
-  pubsub;
-  webhookService;
-  settings;
-  wsServer;
-  config;
-  constructor(config) {
-    this.config = config;
-    this.registry = createRegistry();
-    this.db = config.adapter;
-    this.pubsub = new chunkEEJUFDMF_cjs.KyroPubSub(this.registry);
-    this.webhookService = chunkLNTFRAHF_cjs.createWebhookService(this.db);
-    if (config.collections && config.admin?.collectionOverrides) {
-      applyCollectionOverrides(config.collections, config.admin.collectionOverrides);
-    }
-    if (config.collections) {
-      this.registry.addCollections(config.collections);
-    }
-    if (config.globals) {
-      this.registry.addGlobals(config.globals);
-    }
-    for (const plugin of builtinStoragePlugins) {
-      this.registry.addPlugin(plugin);
-    }
-    if (config.plugins) {
-      for (const plugin of config.plugins) {
-        this.registry.addPlugin(plugin);
-      }
-    }
-  }
-  async init() {
-    await this.registry.init();
-    const storageGlobal = chunk3KTWGODI_cjs.createStorageSettingsGlobal(
-      this.registry.storageProviders,
-      (name) => this.registry.storageProviders.isPluginEnabled(name)
-    );
-    this.registry.addGlobalPostInit(storageGlobal);
-    const pluginSettingsGlobal = {
-      slug: "plugin-settings",
-      admin: { hidden: true },
-      fields: [{ name: "states", type: "json" }]
-    };
-    this.registry.addGlobalPostInit(pluginSettingsGlobal);
-    if (!this.db) {
-      throw new Error(
-        `Database adapter is null \u2014 failed to load at startup. Check the server console for the exact error.`
-      );
-    }
-    const systemCollection = {
-      slug: chunk4OCMVGEY_cjs.API_KEY_COLLECTION,
-      fields: [
-        { name: "userId", type: "text", required: true },
-        { name: "name", type: "text", required: true },
-        { name: "key", type: "text", required: true },
-        { name: "keyPrefix", type: "text", required: true },
-        { name: "permissions", type: "json" },
-        { name: "lastUsedAt", type: "date" },
-        { name: "expiresAt", type: "date" }
-      ]
-    };
-    const webhookCollection = {
-      slug: chunkLNTFRAHF_cjs.WEBHOOK_COLLECTION,
-      fields: [
-        { name: "name", type: "text", required: true },
-        { name: "url", type: "text", required: true },
-        { name: "events", type: "json", required: true },
-        { name: "status", type: "text", required: true },
-        { name: "secret", type: "text" },
-        { name: "headers", type: "json" },
-        { name: "lastTriggered", type: "date" },
-        { name: "lastError", type: "text" }
-      ]
-    };
-    const webhookDeliveryCollection = {
-      slug: chunkLNTFRAHF_cjs.WEBHOOK_DELIVERY_COLLECTION,
-      fields: [
-        { name: "webhookId", type: "text", required: true },
-        { name: "event", type: "text", required: true },
-        { name: "payload", type: "json", required: true },
-        { name: "attempt", type: "number", required: true },
-        { name: "status", type: "text", required: true },
-        { name: "responseStatus", type: "number" },
-        { name: "responseBody", type: "text" },
-        { name: "error", type: "text" },
-        { name: "duration", type: "number" },
-        { name: "deliveredAt", type: "date" },
-        { name: "nextRetryAt", type: "date" }
-      ]
-    };
-    const allGlobals = this.registry.getGlobals();
-    if (this.db instanceof chunkOIRG6ZRV_cjs.DrizzleAdapter && this.db.dialect === "postgres") {
-      const drizzle = this.db;
-      const tableName = chunk4OCMVGEY_cjs.API_KEY_COLLECTION.replace(/-/g, "_");
-      if (!drizzle.schema[tableName]) {
-        drizzle.schema[tableName] = chunkDPA3KWPY_cjs.apiKeys;
-      }
-    }
-    await this.db.init(
-      [
-        ...this.registry.getCollections(),
-        systemCollection,
-        webhookCollection,
-        webhookDeliveryCollection
-      ],
-      allGlobals
-    );
-    await this.loadPluginState();
-    this.pubsub.autoRegisterHooks();
-  }
-  // ============================================================================
-  // API Methods
-  // ============================================================================
-  // Load settings from globals if not already loaded
-  async loadSettings() {
-    if (this.settings) return this.settings;
-    try {
-      const doc = await this.db.findOne({
-        collection: "_globals_access-settings",
-        where: {}
-      });
-      if (doc) {
-        this.settings = { access: doc };
-      }
-    } catch (e) {
-    }
-    return this.settings || {};
-  }
-  async loadPluginState() {
-    const storageRegistry = this.registry.storageProviders;
-    const pluginNames = storageRegistry.getAllPluginNames();
-    let pluginStates = {};
-    try {
-      const doc = await this.db.findOne({
-        collection: "_globals_plugin-settings",
-        where: {}
-      });
-      if (doc && doc.states) {
-        pluginStates = doc.states;
-      }
-    } catch (e) {
-    }
-    for (const name of pluginNames) {
-      if (pluginStates[name] !== void 0) {
-        storageRegistry.setPluginEnabled(name, pluginStates[name]);
-      }
-    }
-  }
-  getREST(options) {
-    const authObj = typeof this.config.auth === "object" ? this.config.auth : null;
-    const authSecret = authObj?.secret;
-    const checkSession = authObj?.checkSession !== false;
-    return chunkB6X3LN25_cjs.createHonoApp({
-      registry: this.registry,
-      db: this.db,
-      authSecret,
-      authAdapter: this.config.authAdapter,
-      checkSession,
-      ...options,
-      cors: this.config.cors,
-      webhookService: this.webhookService,
-      settings: this.settings
-    });
-  }
-  getGraphQL(options) {
-    const schema = chunkN4GN6Q3V_cjs.buildGraphQLSchema({
-      registry: this.registry,
-      db: this.db,
-      settings: this.settings
-    });
-    const yoga = graphqlYoga.createYoga({
-      schema,
-      context: async ({ request }) => {
-        const apiKeyRaw = chunk4OCMVGEY_cjs.extractApiKeyFromRequest(request);
-        let gqlUser;
-        let apiKeyCtx;
-        if (apiKeyRaw && this.db) {
-          const apiKeyResult = await chunk4OCMVGEY_cjs.validateApiKey(apiKeyRaw, this.db);
-          if (apiKeyResult.user) {
-            gqlUser = apiKeyResult.user;
-            apiKeyCtx = chunk4OCMVGEY_cjs.createApiKeyContext(apiKeyResult);
-          }
-        }
-        const tenantID = options?.tenantID;
-        return {
-          db: this.db,
-          registry: this.registry,
-          user: gqlUser,
-          req: request,
-          tenantID,
-          apiKey: apiKeyCtx,
-          relationLoader: new chunkN4GN6Q3V_cjs.RelationLoader({ db: this.db, tenantID, user: gqlUser })
-        };
-      },
-      graphiql: false,
-      plugins: []
-    });
-    return {
-      fetch: yoga.fetch,
-      schema
-    };
-  }
-  getTRPC(options) {
-    return {
-      fetch: async (request, locals) => {
-        const url = new URL(request.url);
-        const path = url.pathname.replace(/^\/api\/trpc\//, "");
-        const [slug, ...rest] = path.split(".");
-        let procedureName = rest.join(".");
-        procedureName = procedureName.replace(/\.(query|mutate|subscribe)$/, "");
-        if (!slug || !procedureName) {
-          return new Response(
-            JSON.stringify({
-              error: {
-                message: "Invalid tRPC path",
-                code: -32600,
-                data: { code: "BAD_REQUEST", httpStatus: 400 }
-              }
-            }),
-            { status: 400, headers: { "Content-Type": "application/json" } }
-          );
-        }
-        const ctx = await chunkTQG7G7YI_cjs.createContext({
-          db: this.db,
-          registry: this.registry,
-          req: request,
-          user: options?.user,
-          tenantID: options?.tenantID,
-          settings: this.settings
-        });
-        const kyroRouter = chunkTQG7G7YI_cjs.createKyroServer(ctx);
-        const collectionRouter = kyroRouter[slug];
-        if (!collectionRouter) {
-          return new Response(
-            JSON.stringify({
-              error: {
-                message: `Collection '${slug}' not found`,
-                code: -32601,
-                data: { code: "NOT_FOUND", httpStatus: 404 }
-              }
-            }),
-            { status: 404, headers: { "Content-Type": "application/json" } }
-          );
-        }
-        const procedure = collectionRouter[procedureName];
-        if (typeof procedure !== "function") {
-          return new Response(
-            JSON.stringify({
-              error: {
-                message: `Procedure '${procedureName}' not found`,
-                code: -32601,
-                data: { code: "NOT_FOUND", httpStatus: 404 }
-              }
-            }),
-            { status: 404, headers: { "Content-Type": "application/json" } }
-          );
-        }
-        try {
-          let raw = {};
-          if (request.method === "POST" || request.method === "PATCH") {
-            raw = await request.json().catch(() => ({}));
-          } else {
-            const qs = new URL(request.url).searchParams.get("input");
-            if (qs) {
-              try {
-                raw = JSON.parse(decodeURIComponent(qs));
-              } catch {
-              }
-            }
-          }
-          const input = raw?.["0"] ?? raw;
-          const result = await procedure({ ...input, collection: slug });
-          return new Response(JSON.stringify({ result: { data: result } }), {
-            status: 200,
-            headers: { "Content-Type": "application/json" }
-          });
-        } catch (err) {
-          const msg = err.message || "Internal error";
-          const httpStatus = msg.includes("not found") ? 404 : msg.includes("denied") || msg.includes("authentication required") ? 403 : msg.includes("conflict") ? 409 : 500;
-          const code = httpStatus === 404 ? -32601 : httpStatus === 403 ? -32001 : httpStatus === 409 ? -32002 : -32603;
-          return new Response(
-            JSON.stringify({
-              error: {
-                message: msg,
-                code,
-                data: {
-                  code: "INTERNAL_SERVER_ERROR",
-                  httpStatus
-                }
-              }
-            }),
-            { status: httpStatus, headers: { "Content-Type": "application/json" } }
-          );
-        }
-      },
-      router: null
-    };
-  }
-  getWS() {
-    return this.wsServer;
-  }
-  async startWebSocket(options) {
-    const apiAccess = this.settings?.access?.apiAccess;
-    if (apiAccess?.wsEnabled === false) {
-      return null;
-    }
-    const defaultVerifyToken = async (token) => {
-      const result = await chunk4OCMVGEY_cjs.validateApiKey(token, this.db);
-      if (!result.valid) throw new Error(result.error || "Invalid API key");
-      if (!result.user) throw new Error("API key has no associated user");
-      return result.user;
-    };
-    this.wsServer = chunkEEJUFDMF_cjs.createWSServer({
-      pubsub: this.pubsub,
-      port: options?.port || 8080,
-      requireAuth: options?.requireAuth ?? apiAccess?.requireAuth,
-      verifyToken: options?.verifyToken || defaultVerifyToken
-    });
-    return this.wsServer;
-  }
-  // ============================================================================
-  // Lifecycle
-  // ============================================================================
-  async shutdown() {
-    if (this.wsServer) {
-      await this.wsServer.close();
-    }
-    await this.db.disconnect();
-  }
-};
-function createKyro(config) {
-  return new Kyro(config);
-}
-var _require = module$1.createRequire((typeof document === 'undefined' ? require('u' + 'rl').pathToFileURL(__filename).href : (_documentCurrentScript && _documentCurrentScript.tagName.toUpperCase() === 'SCRIPT' && _documentCurrentScript.src || new URL('chunk-74YSDAWE.cjs', document.baseURI).href)));
-var modPath = "node:sqlite";
-var { DatabaseSync } = _require(modPath);
-function flattenFields(fields) {
-  const result = [];
-  for (const field of fields) {
-    if (field.type === "tabs" && "tabs" in field) {
-      for (const tab of field.tabs) {
-        result.push(...flattenFields(tab.fields));
-      }
-    } else if (field.type === "row" && "fields" in field) {
-      result.push(...flattenFields(field.fields));
-    } else if (field.type === "collapsible" && "fields" in field) {
-      result.push(...flattenFields(field.fields));
-    } else {
-      result.push(field);
-    }
-  }
-  return result;
-}
-function processFieldValue(row, field) {
-  const f = field;
-  let value = row[f.name];
-  if (f.type === "json" || f.type === "richtext" || f.type === "array" || f.type === "group" || f.type === "blocks" || f.type === "list" || f.type === "relationship-block") {
-    try {
-      value = value ? JSON.parse(value) : null;
-    } catch {
-      value = null;
-    }
-  }
-  if (f.type === "checkbox") {
-    value = Boolean(value);
-  }
-  if (f.type === "date" && value) {
-    try {
-      const d = new Date(value);
-      if (isNaN(d.getTime())) {
-        value = null;
-      } else {
-        value = d.toISOString();
-      }
-    } catch {
-      value = null;
-    }
-  }
-  if ((f.type === "upload" || f.type === "image") && value) {
-    try {
-      const parsed = JSON.parse(value);
-      if (Array.isArray(parsed)) {
-        value = parsed.map((item) => {
-          if (typeof item === "object" && item !== null) {
-            return item;
-          }
-          return { id: item };
-        });
-      } else {
-        value = typeof parsed === "object" ? parsed : { id: parsed };
-      }
-    } catch {
-      value = { id: value };
-    }
-  }
-  if (f.type === "relationship" && value) {
-    try {
-      const parsed = JSON.parse(value);
-      if (Array.isArray(parsed)) {
-        value = parsed;
-      } else {
-        value = parsed;
-      }
-    } catch {
-      value = { relationTo: Array.isArray(f.relationTo) ? f.relationTo[0] : f.relationTo, value };
-    }
-  }
-  if (f.type === "list" && value) {
-    try {
-      const parsed = JSON.parse(value);
-      value = Array.isArray(parsed) ? parsed : [];
-    } catch {
-      value = [];
-    }
-  }
-  if (f.type === "relationship-block" && value) {
-    try {
-      const parsed = JSON.parse(value);
-      value = Array.isArray(parsed) ? parsed : [];
-    } catch {
-      value = [];
-    }
-  }
-  return value;
-}
-function getTableColumns(db, tableName) {
-  try {
-    const rows = db.prepare(`PRAGMA table_info(${tableName})`).all();
-    return rows.map((r) => r.name);
-  } catch {
-    return [];
-  }
-}
-var LocalAdapter = class extends chunkGUUB5EAG_cjs.AbstractBaseAdapter {
-  db;
-  path;
-  migrations = /* @__PURE__ */ new Map();
-  versionsTableName = "kyro_versions";
-  constructor(options) {
-    super();
-    this.path = options.path;
-    if (options.db) {
-      this.db = options.db;
-    } else {
-      this.db = null;
-    }
-  }
-  async connect() {
-    if (!this.db) {
-      this.db = new DatabaseSync(this.path || ":memory:");
-    }
-    if (this.db && typeof this.db.prepare === "function" && !this.db.prepare.__wrapped) {
-      const originalPrepare = this.db.prepare.bind(this.db);
-      const wrappedPrepare = (sql) => {
-        const stmt = originalPrepare(sql);
-        const serialize = (val) => {
-          if (typeof val === "boolean") return val ? 1 : 0;
-          if (val === void 0) return null;
-          return val;
-        };
-        return new Proxy(stmt, {
-          get(target, prop, receiver) {
-            if (prop === "all") {
-              return (...params) => target.all(...params.map(serialize));
-            }
-            if (prop === "get") {
-              return (...params) => target.get(...params.map(serialize));
-            }
-            if (prop === "run") {
-              return (...params) => target.run(...params.map(serialize));
-            }
-            const val = Reflect.get(target, prop, receiver);
-            return typeof val === "function" ? val.bind(target) : val;
-          }
-        });
-      };
-      wrappedPrepare.__wrapped = true;
-      this.db.prepare = wrappedPrepare;
-    }
-    this.db.exec("PRAGMA journal_mode = WAL");
-    this.db.exec("PRAGMA foreign_keys = ON");
-    this.connected = true;
-  }
-  async disconnect() {
-    if (this.db) {
-      this.db.close();
-    }
-    this.connected = false;
-  }
-  // ========================================================================
-  // Schema Management
-  // ========================================================================
-  ensureTable(config, tableName) {
-    const name = tableName || this.getTableNameFor(config.slug);
-    const columns = [`id TEXT PRIMARY KEY`];
-    for (const field of flattenFields(config.fields)) {
-      if (!field.name || field.name === "id") continue;
-      const colDef = this.fieldToSQL(field);
-      if (colDef) columns.push(colDef);
-    }
-    columns.push(`${this.col("createdAt")} TEXT DEFAULT (datetime('now'))`);
-    columns.push(`${this.col("updatedAt")} TEXT DEFAULT (datetime('now'))`);
-    columns.push(`status TEXT DEFAULT 'draft'`);
-    columns.push(`hasDraft INTEGER DEFAULT 0`);
-    if (config.tenantScoped) {
-      columns.push(`tenant_id TEXT NOT NULL`);
-    }
-    const existingColumns = getTableColumns(this.db, name);
-    if (existingColumns.length === 0) {
-      const createSQL = `CREATE TABLE IF NOT EXISTS ${name} (${columns.join(", ")})`;
-      this.db.exec(createSQL);
-      this.db.exec(`CREATE INDEX IF NOT EXISTS idx_${name}_status ON ${name}(status)`);
-      for (const field of flattenFields(config.fields)) {
-        if (field.name && field.indexed) {
-          this.db.exec(
-            `CREATE INDEX IF NOT EXISTS idx_${name}_${field.name} ON ${name}(${this.col(field.name)})`
-          );
-        }
-        if (field.name && field.unique) {
-          this.db.exec(
-            `CREATE UNIQUE INDEX IF NOT EXISTS idx_${name}_${field.name}_unique ON ${name}(${this.col(field.name)})`
-          );
-        }
-      }
-    } else {
-      const existingSet = new Set(existingColumns);
-      for (const colDef of columns) {
-        const colName = colDef.split(" ")[0].replace(/^"/, "").replace(/"$/, "");
-        if (!existingSet.has(colName) && colName !== "id") {
-          try {
-            if (colName === "status") {
-              this.db.exec(`ALTER TABLE ${name} ADD COLUMN ${this.col(colName)} TEXT DEFAULT 'published'`);
-            } else if (colName === "hasDraft") {
-              this.db.exec(`ALTER TABLE ${name} ADD COLUMN ${this.col(colName)} INTEGER DEFAULT 0`);
-            } else {
-              this.db.exec(`ALTER TABLE ${name} ADD COLUMN ${this.col(colName)} TEXT`);
-            }
-          } catch {
-          }
-        }
-      }
-    }
-    this.migrations.set(name, true);
-  }
-  ensureVersionsTable() {
-    this.db.exec(`
-      CREATE TABLE IF NOT EXISTS ${this.versionsTableName} (
-        id TEXT PRIMARY KEY,
-        collection_slug TEXT NOT NULL,
-        document_id TEXT NOT NULL,
-        tenant_id TEXT,
-        version INTEGER NOT NULL,
-        status TEXT NOT NULL DEFAULT 'draft',
-        autosave INTEGER NOT NULL DEFAULT 0,
-        data TEXT NOT NULL,
-        created_by TEXT,
-        change_description TEXT,
-        published_at TEXT,
-        created_at TEXT DEFAULT (datetime('now')),
-        updated_at TEXT DEFAULT (datetime('now'))
-      )
-    `);
-    try {
-      this.db.exec(`ALTER TABLE ${this.versionsTableName} ADD COLUMN autosave INTEGER NOT NULL DEFAULT 0`);
-    } catch {
-    }
-    this.db.exec(
-      `CREATE INDEX IF NOT EXISTS idx_${this.versionsTableName}_doc ON ${this.versionsTableName}(collection_slug, document_id)`
-    );
-    this.db.exec(
-      `CREATE INDEX IF NOT EXISTS idx_${this.versionsTableName}_status ON ${this.versionsTableName}(status)`
-    );
-    this.db.exec(
-      `CREATE INDEX IF NOT EXISTS idx_${this.versionsTableName}_autosave ON ${this.versionsTableName}(autosave)`
-    );
-  }
-  // ========================================================================
-  // SQL Quoting
-  // ========================================================================
-  col(name) {
-    return `"${name}"`;
-  }
-  fieldToSQL(field) {
-    switch (field.type) {
-      case "text":
-      case "email":
-      case "password":
-      case "textarea":
-      case "color":
-      case "code":
-      case "markdown":
-      case "url":
-        return this.col(field.name) + " TEXT";
-      case "number":
-        return this.col(field.name) + " REAL";
-      case "checkbox":
-        return this.col(field.name) + " INTEGER DEFAULT 0";
-      case "date":
-        return this.col(field.name) + " TEXT";
-      case "select":
-      case "radio":
-        return this.col(field.name) + " TEXT";
-      case "relationship":
-      case "upload":
-        return this.col(field.name) + " TEXT";
-      case "json":
-      case "richtext":
-      case "array":
-      case "group":
-      case "blocks":
-        return this.col(field.name) + " TEXT";
-      default:
-        return null;
-    }
-  }
-  // ========================================================================
-  // CRUD Operations
-  // ========================================================================
-  parseGlobalsSlug(slug) {
-    if (slug.startsWith("_globals_")) {
-      const globalSlug = slug.replace("_globals_", "");
-      return {
-        isGlobal: true,
-        globalSlug,
-        tableName: `global_${globalSlug.replace(/-/g, "_")}`
-      };
-    }
-    return {
-      isGlobal: false,
-      globalSlug: "",
-      tableName: this.getTableNameFor(slug)
-    };
-  }
-  async find(args) {
-    const {
-      collection: slug,
-      where = {},
-      sort,
-      limit = 10,
-      page = 1,
-      tenantID,
-      draft = false
-    } = args;
-    const parsed = this.parseGlobalsSlug(slug);
-    const config = parsed.isGlobal ? this.globals.get(parsed.globalSlug) : this.getCollection(slug);
-    this.ensureTable(config, parsed.tableName);
-    const tableName = parsed.tableName;
-    let sql = `SELECT * FROM ${tableName}`;
-    const params = [];
-    const conditions = [];
-    let effectiveWhere = { ...where };
-    if (this.tenantContext && config.tenantScoped) {
-      const rlsQuery = chunkGUUB5EAG_cjs.applyRLS({ where: effectiveWhere }, slug, this.tenantContext, chunkGUUB5EAG_cjs.DEFAULT_RLS_CONFIG);
-      effectiveWhere = rlsQuery.where || {};
-    }
-    if (!draft) {
-      conditions.push(`status = ?`);
-      params.push("published");
-    }
-    if (tenantID && config.tenantScoped) {
-      conditions.push(`tenant_id = ?`);
-      params.push(tenantID);
-    }
-    for (const [key, value] of Object.entries(effectiveWhere)) {
-      if (key === "AND" || key === "OR") continue;
-      if (typeof value === "object" && value !== null) {
-        if (value.equals !== void 0) {
-          conditions.push(`${this.col(key)} = ?`);
-          params.push(value.equals);
-        }
-        if (value.in !== void 0) {
-          conditions.push(`${this.col(key)} IN (${value.in.map(() => "?").join(", ")})`);
-          params.push(...value.in);
-        }
-        if (value.not_equals !== void 0) {
-          conditions.push(`${this.col(key)} != ?`);
-          params.push(value.not_equals);
-        }
-      } else {
-        conditions.push(`${this.col(key)} = ?`);
-        params.push(value);
-      }
-    }
-    if (conditions.length > 0) {
-      sql += ` WHERE ${conditions.join(" AND ")}`;
-    }
-    const sortField = this.col(sort?.replace("-", "") || "createdAt");
-    const sortDir = sort?.startsWith("-") ? "DESC" : "ASC";
-    sql += ` ORDER BY ${sortField} ${sortDir}`;
-    const countSql = sql.replace("SELECT *", "SELECT COUNT(*) as count");
-    const countResult = this.db.prepare(countSql).get(...params);
-    const totalDocs = countResult?.count || 0;
-    sql += ` LIMIT ? OFFSET ?`;
-    params.push(limit, (page - 1) * limit);
-    const rows = this.db.prepare(sql).all(...params);
-    let docs = rows.map((row) => this.rowToDoc(row, config));
-    if (this.tenantContext && !this.tenantContext.isSuperAdmin) {
-      docs = docs.filter((doc) => chunkGUUB5EAG_cjs.canAccessDocument(doc, slug, this.tenantContext, chunkGUUB5EAG_cjs.DEFAULT_RLS_CONFIG));
-    }
-    if (draft) {
-      docs = await Promise.all(docs.map(async (doc) => {
-        const version = this.db.prepare(`SELECT * FROM ${this.versionsTableName} WHERE collection_slug = ? AND document_id = ? AND tenant_id IS NULL ORDER BY version DESC LIMIT 1`).get(slug, doc.id);
-        if (version) {
-          const versionData = version.data ? JSON.parse(version.data) : {};
-          return { ...doc, ...versionData, status: doc.status };
-        }
-        return doc;
-      }));
-    }
-    return {
-      docs,
-      totalDocs,
-      limit,
-      totalPages: Math.ceil(totalDocs / limit),
-      page,
-      pagingCounter: (page - 1) * limit + 1,
-      hasPrevPage: page > 1,
-      hasNextPage: page < Math.ceil(totalDocs / limit),
-      prevPage: page > 1 ? page - 1 : null,
-      nextPage: page < Math.ceil(totalDocs / limit) ? page + 1 : null
-    };
-  }
-  async findByID(args) {
-    const { collection: slug, id, tenantID, draft = false } = args;
-    const parsed = this.parseGlobalsSlug(slug);
-    const config = parsed.isGlobal ? this.globals.get(parsed.globalSlug) : this.getCollection(slug);
-    this.ensureTable(config, parsed.tableName);
-    const tableName = parsed.tableName;
-    let sql = `SELECT * FROM ${tableName} WHERE id = ?`;
-    const params = [id];
-    if (this.tenantContext && config.tenantScoped) {
-      const tempDoc = { id, tenant_id: this.tenantContext.tenantId };
-      if (!chunkGUUB5EAG_cjs.canAccessDocument(tempDoc, slug, this.tenantContext, chunkGUUB5EAG_cjs.DEFAULT_RLS_CONFIG)) {
-        return null;
-      }
-    }
-    if (!draft) {
-      sql += ` AND status = ?`;
-      params.push("published");
-    }
-    if (tenantID && config.tenantScoped) {
-      sql += ` AND tenant_id = ?`;
-      params.push(tenantID);
-    }
-    const row = this.db.prepare(sql).get(...params);
-    if (!row) return null;
-    let doc = this.rowToDoc(row, config);
-    if (draft) {
-      const version = this.db.prepare(`SELECT * FROM ${this.versionsTableName} WHERE collection_slug = ? AND document_id = ? AND tenant_id IS NULL ORDER BY version DESC LIMIT 1`).get(slug, doc.id);
-      if (version) {
-        const versionData = version.data ? JSON.parse(version.data) : {};
-        doc = { ...doc, ...versionData, status: doc.status };
-      }
-    }
-    return doc;
-  }
-  async create(args) {
-    const { collection: slug, data, tenantID } = args;
-    const parsed = this.parseGlobalsSlug(slug);
-    const config = parsed.isGlobal ? this.globals.get(parsed.globalSlug) : this.getCollection(slug);
-    this.ensureTable(config, parsed.tableName);
-    const tableName = parsed.tableName;
-    const id = parsed.isGlobal ? parsed.globalSlug : data.id || this.generateId();
-    const insertData = this.prepareData(data, config);
-    insertData.id = id;
-    insertData.created_at = (/* @__PURE__ */ new Date()).toISOString();
-    insertData.updated_at = (/* @__PURE__ */ new Date()).toISOString();
-    if (tenantID && config.tenantScoped) {
-      insertData.tenant_id = tenantID;
-    }
-    const columns = Object.keys(insertData);
-    const validColumns = getTableColumns(this.db, tableName);
-    const filteredData = {};
-    for (const key of columns) {
-      if (validColumns.includes(key)) {
-        filteredData[key] = insertData[key];
-      }
-    }
-    const filteredColumns = Object.keys(filteredData);
-    const quotedColumns = filteredColumns.map((c) => this.col(c));
-    const placeholders = filteredColumns.map(() => "?").join(", ");
-    const values = Object.values(filteredData).map(
-      (v) => v !== null && typeof v === "object" ? JSON.stringify(v) : v
-    );
-    this.db.prepare(
-      `INSERT OR REPLACE INTO ${tableName} (${quotedColumns.join(", ")}) VALUES (${placeholders})`
-    ).run(...values);
-    this.ensureVersionsTable();
-    return this.findByID({ collection: slug, id, tenantID, draft: true });
-  }
-  async update(args) {
-    const { collection: slug, id, data, tenantID } = args;
-    const parsed = this.parseGlobalsSlug(slug);
-    const config = parsed.isGlobal ? this.globals.get(parsed.globalSlug) : this.getCollection(slug);
-    this.ensureTable(config, parsed.tableName);
-    const tableName = parsed.tableName;
-    const updateData = this.prepareData(data, config);
-    updateData.updated_at = (/* @__PURE__ */ new Date()).toISOString();
-    const validColumns = getTableColumns(this.db, tableName);
-    const filteredData = {};
-    for (const key of Object.keys(updateData)) {
-      if (validColumns.includes(key)) {
-        filteredData[key] = updateData[key];
-      }
-    }
-    const columns = Object.keys(filteredData);
-    const setClause = columns.map((c) => `${this.col(c)} = ?`).join(", ");
-    const values = Object.values(filteredData).map(
-      (v) => v !== null && typeof v === "object" ? JSON.stringify(v) : v
-    );
-    let sql = `UPDATE ${tableName} SET ${setClause} WHERE id = ?`;
-    const params = [...values, id];
-    if (tenantID && config.tenantScoped) {
-      sql += ` AND tenant_id = ?`;
-      params.push(tenantID);
-    }
-    this.db.prepare(sql).run(...params);
-    this.ensureVersionsTable();
-    return this.findByID({ collection: slug, id, tenantID, draft: true });
-  }
-  async delete(args) {
-    const { collection: slug, id, tenantID } = args;
-    const parsed = this.parseGlobalsSlug(slug);
-    const config = parsed.isGlobal ? this.globals.get(parsed.globalSlug) : this.getCollection(slug);
-    this.ensureTable(config, parsed.tableName);
-    this.ensureVersionsTable();
-    const doc = await this.findByID({ collection: slug, id, tenantID, draft: true });
-    if (!doc) throw new Error(`Document not found: ${slug}/${id}`);
-    const tableName = parsed.tableName;
-    let sql = `DELETE FROM ${tableName} WHERE id = ?`;
-    const params = [id];
-    if (tenantID && config.tenantScoped) {
-      sql += ` AND tenant_id = ?`;
-      params.push(tenantID);
-    }
-    this.db.prepare(sql).run(...params);
-    return doc;
-  }
-  async count(args) {
-    const { collection: slug, tenantID } = args;
-    const parsed = this.parseGlobalsSlug(slug);
-    const config = parsed.isGlobal ? this.globals.get(parsed.globalSlug) : this.getCollection(slug);
-    this.ensureTable(config, parsed.tableName);
-    const tableName = parsed.tableName;
-    let sql = `SELECT COUNT(*) as count FROM ${tableName}`;
-    const params = [];
-    if (tenantID && config.tenantScoped) {
-      sql += ` WHERE tenant_id = ?`;
-      params.push(tenantID);
-    }
-    const result = this.db.prepare(sql).get(...params);
-    return result?.count || 0;
-  }
-  async findOne(args) {
-    const parsed = this.parseGlobalsSlug(args.collection);
-    if (parsed.isGlobal) {
-      const globalConfig = this.globals.get(parsed.globalSlug);
-      if (!globalConfig) {
-        throw new Error(`Global "${parsed.globalSlug}" not found in adapter`);
-      }
-      this.ensureTable(globalConfig, parsed.tableName);
-      let sql = `SELECT * FROM ${parsed.tableName}`;
-      const conditions = [];
-      const params = [];
-      if (!args.draft && globalConfig.versions) {
-        conditions.push("status = 'published'");
-      }
-      if (conditions.length > 0) {
-        sql += ` WHERE ${conditions.join(" AND ")}`;
-      }
-      sql += " LIMIT 1";
-      const result2 = this.db.prepare(sql).get(...params);
-      if (result2) {
-        let doc = this.rowToDoc(result2, globalConfig);
-        if (args.draft) {
-          const version = this.db.prepare(`SELECT * FROM ${this.versionsTableName} WHERE collection_slug = ? AND document_id = ? AND tenant_id IS NULL ORDER BY version DESC LIMIT 1`).get(args.collection, parsed.globalSlug);
-          if (version) {
-            const versionData = version.data ? JSON.parse(version.data) : {};
-            doc = { ...doc, ...versionData, status: doc.status };
-          }
-        }
-        return doc;
-      }
-      return null;
-    }
-    const result = await this.find({ ...args, limit: 1 });
-    return result.docs[0] || null;
-  }
-  // ========================================================================
-  // Version History
-  // ========================================================================
-  async findVersions(args) {
-    this.ensureVersionsTable();
-    const { collection, documentId, tenantID, limit = 20, page = 1 } = args;
-    const conditions = [`collection_slug = ?`, `document_id = ?`, `autosave = 0`];
-    const params = [collection, documentId];
-    if (tenantID) {
-      conditions.push(`tenant_id = ?`);
-      params.push(tenantID);
-    } else {
-      conditions.push(`tenant_id IS NULL`);
-    }
-    const where = `WHERE ${conditions.join(" AND ")}`;
-    const countResult = this.db.prepare(`SELECT COUNT(*) as count FROM ${this.versionsTableName} ${where}`).get(...params);
-    const totalDocs = countResult?.count || 0;
-    const offset = (page - 1) * limit;
-    const rows = this.db.prepare(`SELECT * FROM ${this.versionsTableName} ${where} ORDER BY version DESC LIMIT ? OFFSET ?`).all(...params, limit, offset);
-    const docs = rows.map((r) => this.rowToVersion(r));
-    return {
-      docs,
-      totalDocs,
-      limit,
-      totalPages: Math.ceil(totalDocs / limit),
-      page,
-      pagingCounter: (page - 1) * limit + 1,
-      hasPrevPage: page > 1,
-      hasNextPage: page < Math.ceil(totalDocs / limit),
-      prevPage: page > 1 ? page - 1 : null,
-      nextPage: page < Math.ceil(totalDocs / limit) ? page + 1 : null
-    };
-  }
-  async findVersionByID(args) {
-    this.ensureVersionsTable();
-    const row = this.db.prepare(`SELECT * FROM ${this.versionsTableName} WHERE id = ? AND collection_slug = ? LIMIT 1`).get(args.versionId, args.collection);
-    return row ? this.rowToVersion(row) : null;
-  }
-  async createVersion(args) {
-    this.ensureVersionsTable();
-    const now = (/* @__PURE__ */ new Date()).toISOString();
-    if (args.autosave) {
-      let sql = `SELECT * FROM ${this.versionsTableName} WHERE collection_slug = ? AND document_id = ? AND autosave = 1`;
-      const params = [args.collection, args.documentId];
-      if (args.tenantID) {
-        sql += ` AND tenant_id = ?`;
-        params.push(args.tenantID);
-      } else {
-        sql += ` AND tenant_id IS NULL`;
-      }
-      sql += ` LIMIT 1`;
-      const existing = this.db.prepare(sql).get(...params);
-      if (existing) {
-        this.db.prepare(`UPDATE ${this.versionsTableName} SET data = ?, status = ?, updated_at = ? WHERE id = ?`).run(JSON.stringify(args.data), args.status, now, existing.id);
-        const result = await this.findVersionByID({ collection: args.collection, versionId: existing.id });
-        if (result) return result;
-      }
-    }
-    const id = this.generateId();
-    const latestRow = this.db.prepare(`SELECT version FROM ${this.versionsTableName} WHERE collection_slug = ? AND document_id = ? AND autosave = 0 ORDER BY version DESC LIMIT 1`).get(args.collection, args.documentId);
-    const nextVersion = (latestRow?.version ?? 0) + 1;
-    this.db.prepare(
-      `INSERT INTO ${this.versionsTableName} (
-          id, collection_slug, document_id, tenant_id, version, status, autosave, data, created_by, change_description, published_at, created_at, updated_at
-        ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`
-    ).run(
-      id,
-      args.collection,
-      args.documentId,
-      args.tenantID ?? null,
-      nextVersion,
-      args.status,
-      args.autosave ? 1 : 0,
-      JSON.stringify(args.data),
-      args.createdBy ?? null,
-      args.changeDescription ?? null,
-      args.status === "published" ? now : null,
-      now,
-      now
-    );
-    if (!args.autosave) {
-      const collectionConfig = this.collections.get(args.collection);
-      const maxPerDoc = collectionConfig?.versions?.maxPerDoc;
-      if (maxPerDoc && maxPerDoc > 0) {
-        await this.deleteVersions({ collection: args.collection, documentId: args.documentId, keepLatest: maxPerDoc, tenantID: args.tenantID });
-      }
-    }
-    const saved = await this.findVersionByID({ collection: args.collection, versionId: id });
-    return saved;
-  }
-  async updateLatestVersion(args) {
-    return this.createVersion({ ...args, autosave: true });
-  }
-  async deleteVersions(args) {
-    this.ensureVersionsTable();
-    const { collection, documentId, keepLatest, tenantID } = args;
-    if (keepLatest && keepLatest > 0) {
-      const rows = this.db.prepare(`SELECT id, status, autosave FROM ${this.versionsTableName} WHERE collection_slug = ? AND document_id = ? ORDER BY version DESC`).all(collection, documentId);
-      let draftCount = 0;
-      const toDelete = [];
-      for (const row of rows) {
-        if (row.status === "published" || row.autosave === 1) continue;
-        draftCount++;
-        if (draftCount > keepLatest) toDelete.push(row.id);
-      }
-      for (const vid of toDelete) {
-        this.db.prepare(`DELETE FROM ${this.versionsTableName} WHERE id = ?`).run(vid);
-      }
-    } else {
-      let sql = `DELETE FROM ${this.versionsTableName} WHERE collection_slug = ? AND document_id = ?`;
-      const params = [collection, documentId];
-      if (tenantID) {
-        sql += ` AND tenant_id = ?`;
-        params.push(tenantID);
-      }
-      this.db.prepare(sql).run(...params);
-    }
-  }
-  rowToVersion(row) {
-    return {
-      id: String(row.id),
-      collection: row.collection_slug,
-      documentId: row.document_id,
-      version: row.version,
-      status: row.status,
-      data: row.data ? JSON.parse(row.data) : {},
-      createdBy: row.created_by ?? void 0,
-      changeDescription: row.change_description ?? void 0,
-      publishedAt: row.published_at ?? null,
-      createdAt: row.created_at,
-      updatedAt: row.updated_at
-    };
-  }
-  // ========================================================================
-  // Helpers
-  // ========================================================================
-  prepareData(data, config) {
-    const result = {};
-    const fields = flattenFields(config.fields);
-    const processValue = (field, value) => {
-      const f = field;
-      if (f.type === "json" || f.type === "richtext" || f.type === "array" || f.type === "group" || f.type === "blocks" || f.type === "list" || f.type === "relationship-block") {
-        return value !== null && value !== void 0 ? JSON.stringify(value) : null;
-      } else if (f.type === "checkbox") {
-        return value ? 1 : 0;
-      } else if (f.type === "number") {
-        return value !== null && value !== "" ? Number(value) : null;
-      } else if (f.type === "upload" || f.type === "image") {
-        if (value === null || value === void 0) return null;
-        if (Array.isArray(value)) {
-          const items = value.map((v) => {
-            if (typeof v === "string") return v;
-            if (typeof v === "object") return v.id || v._id || v;
-            return String(v);
-          });
-          return JSON.stringify(items);
-        }
-        if (typeof value === "string") return value;
-        if (typeof value === "object") return JSON.stringify(value);
-        return String(value);
-      } else if (field.type === "relationship") {
-        if (value === null || value === void 0) return null;
-        if (Array.isArray(value)) {
-          const rels = value.map((v) => {
-            if (typeof v === "string") return v;
-            if (typeof v === "object") return JSON.stringify({ relationTo: field.relationTo, value: v.id || v });
-            return String(v);
-          });
-          return JSON.stringify(rels);
-        }
-        if (typeof value === "string") return value;
-        if (typeof value === "object") return JSON.stringify({ relationTo: field.relationTo, value: value.id || value });
-        return String(value);
-      }
-      return value;
-    };
-    for (const field of fields) {
-      if (!field.name || field.name === "id") continue;
-      const isInTab = config.fields.some(
-        (f) => f.type === "tabs" && "tabs" in f && f.tabs.some((t) => t.fields.some((tf) => tf.name === field.name))
-      );
-      if (isInTab) continue;
-      const value = data[field.name];
-      if (value !== void 0) {
-        result[field.name] = processValue(field, value);
-      }
-    }
-    for (const field of config.fields) {
-      if (field.type === "tabs" && "tabs" in field && field.name) {
-        const tabData = data[field.name];
-        if (tabData && typeof tabData === "object") {
-          for (const tab of field.tabs) {
-            for (const tabField of tab.fields) {
-              if (tabField.name && tabField.name !== "id") {
-                const value = tabData[tabField.name];
-                if (value !== void 0) {
-                  result[tabField.name] = processValue(tabField, value);
-                }
-              }
-            }
-          }
-        }
-      }
-    }
-    return result;
-  }
-  rowToDoc(row, config) {
-    const doc = { id: row.id };
-    for (const field of flattenFields(config.fields)) {
-      if (!field.name || field.name === "id") continue;
-      const f = field;
-      let value = row[f.name];
-      if (f.type === "json" || f.type === "richtext" || f.type === "array" || f.type === "group" || f.type === "blocks" || f.type === "list" || f.type === "relationship-block") {
-        try {
-          value = value ? JSON.parse(value) : null;
-        } catch {
-          value = null;
-        }
-      }
-      if (field.type === "checkbox") {
-        value = Boolean(value);
-      }
-      if (field.type === "date" && value) {
-        try {
-          const d = new Date(value);
-          if (isNaN(d.getTime())) {
-            console.warn(`[LocalAdapter] Invalid date value for field "${field.name}":`, value);
-            value = null;
-          } else {
-            value = d.toISOString();
-          }
-        } catch {
-          value = null;
-        }
-      }
-      if ((field.type === "upload" || field.type === "image") && value) {
-        try {
-          const parsed = JSON.parse(value);
-          if (Array.isArray(parsed)) {
-            value = parsed.map((item) => {
-              if (typeof item === "object" && item !== null) {
-                return item;
-              }
-              return { id: item };
-            });
-          } else {
-            value = typeof parsed === "object" ? parsed : { id: parsed };
-          }
-        } catch {
-          value = { id: value };
-        }
-      }
-      if (field.type === "relationship" && value) {
-        try {
-          const parsed = JSON.parse(value);
-          if (Array.isArray(parsed)) {
-            value = parsed;
-          } else {
-            value = parsed;
-          }
-        } catch {
-          value = { relationTo: Array.isArray(field.relationTo) ? field.relationTo[0] : field.relationTo, value };
-        }
-      }
-      doc[field.name] = value;
-    }
-    for (const field of config.fields) {
-      if (!field.name || field.name === "id" || field.name === "row" || field.name === "collapsible") continue;
-      if (field.type === "tabs" && "tabs" in field) {
-        const tabData = {};
-        for (const tab of field.tabs) {
-          for (const tabField of tab.fields) {
-            if (tabField.name && tabField.name !== "id") {
-              tabData[tabField.name] = processFieldValue(row, tabField);
-            }
-          }
-        }
-        doc[field.name] = tabData;
-      }
-    }
-    if (config.timestamps) {
-      const cAt = row.createdAt || row.created_at;
-      const uAt = row.updatedAt || row.updated_at;
-      if (cAt) {
-        try {
-          const d = new Date(cAt);
-          if (!isNaN(d.getTime())) doc.createdAt = d.toISOString();
-        } catch {
-        }
-      }
-      if (uAt) {
-        try {
-          const d = new Date(uAt);
-          if (!isNaN(d.getTime())) doc.updatedAt = d.toISOString();
-        } catch {
-        }
-      }
-    }
-    if (config.tenantScoped) {
-      doc.tenantID = row.tenant_id;
-    }
-    doc.status = row.status ?? "published";
-    doc.hasDraft = row.hasDraft ? Boolean(row.hasDraft) : false;
-    return doc;
-  }
-  generateId() {
-    const timestamp = Date.now().toString(16).padStart(12, "0");
-    const random = crypto.randomBytes(6).toString("hex");
-    return timestamp + random;
-  }
-  getMediaById(mediaId) {
-    try {
-      const tableName = this.getTableNameFor("media");
-      const row = this.db.prepare(`SELECT id, url, thumbnail_url FROM ${tableName} WHERE id = ?`).get(mediaId);
-      if (row) {
-        return {
-          id: row.id,
-          url: row.url,
-          thumbnailUrl: row.thumbnail_url || row.url
-        };
-      }
-    } catch (err) {
-    }
-    return null;
-  }
-  getTableNameFor(slug) {
-    return slug.replace(/-/g, "_");
-  }
-  // ========================================================================
-  // Migrations
-  // ========================================================================
-  async migrate() {
-    for (const config of this.collections.values()) {
-      this.ensureTable(config);
-    }
-  }
-  async rollback() {
-  }
-  // ========================================================================
-  // Transaction Support
-  // ========================================================================
-  async transaction(fn) {
-    return new Promise((resolve, reject) => {
-      const tx = this.db.transaction(async () => {
-        return fn({ db: this.db });
-      });
-      try {
-        const result = tx();
-        resolve(result);
-      } catch (error) {
-        reject(error);
-      }
-    });
-  }
-  // ========================================================================
-  // Direct DB Access
-  // ========================================================================
-  getDatabase() {
-    return this.db;
-  }
-  exec(sql) {
-    this.db.exec(sql);
-  }
-  prepare(sql) {
-    return this.db.prepare(sql);
-  }
-};
-function createLocalAdapter(options) {
-  return new LocalAdapter(options || {});
-}
-
-exports.ConfigValidationError = ConfigValidationError;
-exports.Kyro = Kyro;
-exports.LocalAdapter = LocalAdapter;
-exports.Registry = Registry;
-exports.collectionToCreateZod = collectionToCreateZod;
-exports.collectionToUpdateZod = collectionToUpdateZod;
-exports.collectionToWhereZod = collectionToWhereZod;
-exports.collectionToZod = collectionToZod;
-exports.createKyro = createKyro;
-exports.createLocalAdapter = createLocalAdapter;
-exports.createRegistry = createRegistry;
-exports.fieldToZod = fieldToZod;
-exports.getRegistry = getRegistry;
-exports.globalToZod = globalToZod;
-exports.resetRegistry = resetRegistry;
-exports.validateCollection = validateCollection;
-exports.validateConfig = validateConfig;
-exports.validateFields = validateFields;
-exports.validateGlobal = validateGlobal;
-//# sourceMappingURL=chunk-74YSDAWE.cjs.map
-//# sourceMappingURL=chunk-74YSDAWE.cjs.map