@kyro-cms/core 0.1.0

package/dist/index.cjs

@@ -0,0 +1,2506 @@
+'use strict';
+
+var chunk3VZCX4DF_cjs = require('./chunk-3VZCX4DF.cjs');
+var chunkK7QF2QCM_cjs = require('./chunk-K7QF2QCM.cjs');
+var chunkUEG7KMKC_cjs = require('./chunk-UEG7KMKC.cjs');
+var chunkR3XIBBAW_cjs = require('./chunk-R3XIBBAW.cjs');
+var chunkDVD5P72E_cjs = require('./chunk-DVD5P72E.cjs');
+var chunk3Q3FS5J4_cjs = require('./chunk-3Q3FS5J4.cjs');
+var chunkHT6VE4NW_cjs = require('./chunk-HT6VE4NW.cjs');
+var chunkRLTG4YZM_cjs = require('./chunk-RLTG4YZM.cjs');
+var zod = require('zod');
+var bcrypt = require('bcrypt');
+var jwt = require('jsonwebtoken');
+var crypto = require('crypto');
+
+function _interopDefault (e) { return e && e.__esModule ? e : { default: e }; }
+
+var bcrypt__default = /*#__PURE__*/_interopDefault(bcrypt);
+var jwt__default = /*#__PURE__*/_interopDefault(jwt);
+
+// src/registry/validator.ts
+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 = config.fields.some((f) => f.name === 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 = config.fields.some((f) => f.name === 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) {
+          errors.push(`${context}: ${field.type} field "${fieldName}" has no options defined`);
+        } else {
+          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)) {
+          errors.push(`Relationship field "${field.name}" references unknown collection "${target}"`);
+        }
+      }
+    }
+    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 "markdown":
+      return markdownToZod(field);
+    case "relationship":
+      return relationshipToZod(field);
+    case "array":
+      return arrayToZod(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();
+  if (field.validate) schema = addCustomValidation(schema, field.validate);
+  return schema;
+}
+function numberToZod(field) {
+  let schema = field.integer ? zod.z.number().int() : zod.z.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();
+  if (field.validate) schema = addCustomValidation(schema, field.validate);
+  return schema;
+}
+function checkboxToZod(field) {
+  let schema = zod.z.boolean();
+  if (!field.required) schema = schema.optional();
+  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();
+  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();
+  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();
+  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();
+  if (field.validate) schema = addCustomValidation(schema, field.validate);
+  return schema;
+}
+function selectToZod(field) {
+  const values = field.options.map((opt) => opt.value);
+  let schema;
+  if (field.hasMany) {
+    schema = zod.z.array(zod.z.enum(values));
+  } else {
+    schema = zod.z.enum(values);
+  }
+  if (!field.required) schema = schema.optional();
+  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();
+  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();
+  if (field.validate) schema = addCustomValidation(schema, field.validate);
+  return schema;
+}
+function richTextToZod(field) {
+  let schema = zod.z.array(zod.z.object({
+    type: zod.z.string(),
+    data: zod.z.record(zod.z.any()),
+    children: zod.z.array(zod.z.any()).optional()
+  }));
+  if (!field.required) schema = schema.optional();
+  if (field.validate) schema = addCustomValidation(schema, field.validate);
+  return schema;
+}
+function jsonToZod(field) {
+  let schema = zod.z.record(zod.z.any());
+  if (!field.required) schema = schema.optional();
+  if (field.validate) schema = addCustomValidation(schema, field.validate);
+  return schema;
+}
+function codeToZod(field) {
+  let schema = zod.z.string();
+  if (!field.required) schema = schema.optional();
+  if (field.validate) schema = addCustomValidation(schema, field.validate);
+  return schema;
+}
+function uploadToZod(field) {
+  let schema = zod.z.string();
+  if (field.hasMany) schema = zod.z.array(zod.z.string());
+  if (!field.required) schema = schema.optional();
+  if (field.validate) schema = addCustomValidation(schema, field.validate);
+  return schema;
+}
+function markdownToZod(field) {
+  let schema = zod.z.string();
+  if (!field.required) schema = schema.optional();
+  if (field.validate) schema = addCustomValidation(schema, field.validate);
+  return schema;
+}
+function relationshipToZod(field) {
+  let schema = zod.z.string();
+  if (Array.isArray(field.relationTo)) {
+    schema = zod.z.object({
+      relationTo: zod.z.enum(field.relationTo),
+      value: zod.z.string()
+    });
+  }
+  if (field.hasMany) schema = zod.z.array(schema);
+  if (!field.required) schema = schema.optional();
+  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();
+  if (field.validate) schema = addCustomValidation(schema, field.validate);
+  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();
+  return schema;
+}
+function blocksToZod(field) {
+  const blockSchemas = field.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)])
+      )
+    });
+  });
+  let schema = zod.z.array(zod.z.discriminatedUnion("blockType", blockSchemas));
+  if (field.minRows) schema = schema.min(field.minRows);
+  if (field.maxRows) schema = schema.max(field.maxRows);
+  if (!field.required) schema = schema.optional();
+  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);
+}
+function addCustomValidation(schema, validate) {
+  return schema.refine(
+    async (val) => {
+      const result = await validate(val, { required: false });
+      return result === true;
+    },
+    {
+      message: "Custom validation failed"
+    }
+  );
+}
+function collectionToZod(collection) {
+  const shape = {};
+  for (const field of collection.fields) {
+    if (field.name) {
+      shape[field.name] = fieldToZod(field);
+    }
+  }
+  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);
+}
+function collectionToCreateZod(collection) {
+  const shape = {};
+  for (const field of collection.fields) {
+    if (field.name) {
+      shape[field.name] = fieldToZod(field);
+    }
+  }
+  return zod.z.object(shape);
+}
+function collectionToUpdateZod(collection) {
+  const shape = {};
+  for (const field of collection.fields) {
+    if (field.name) {
+      shape[field.name] = fieldToZod(field).optional();
+    }
+  }
+  return zod.z.object(shape);
+}
+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 = {};
+  for (const field of global.fields) {
+    if (field.name) {
+      shape[field.name] = fieldToZod(field);
+    }
+  }
+  shape["id"] = zod.z.string().optional();
+  return zod.z.object(shape);
+}
+
+// src/registry/index.ts
+var Registry = class {
+  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");
+    }
+    const errors = validateCollection(config);
+    if (errors.length > 0) {
+      throw new Error(`Invalid collection config: ${errors.join(", ")}`);
+    }
+    let finalConfig = { ...config };
+    for (const plugin of this.plugins) {
+      if (plugin.extendCollection) {
+        finalConfig = plugin.extendCollection(finalConfig.slug, finalConfig);
+      }
+    }
+    finalConfig.fields = this.applyFieldDefaults(finalConfig);
+    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");
+    }
+    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;
+    }
+    throw new Error(`No collection 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 }
+      });
+    }
+    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;
+}
+var Kyro = class {
+  registry;
+  db;
+  pubsub;
+  wsServer;
+  config;
+  constructor(config) {
+    this.config = config;
+    this.registry = createRegistry();
+    this.db = config.adapter;
+    this.pubsub = new chunkDVD5P72E_cjs.KyroPubSub(this.registry);
+    if (config.collections) {
+      this.registry.addCollections(config.collections);
+    }
+    if (config.globals) {
+      this.registry.addGlobals(config.globals);
+    }
+    if (config.plugins) {
+      for (const plugin of config.plugins) {
+        this.registry.addPlugin(plugin);
+      }
+    }
+  }
+  async init() {
+    await this.registry.init();
+    await this.db.init(this.registry.getCollections(), this.registry.getGlobals());
+    this.pubsub.autoRegisterHooks();
+    console.log("\u2705 Kyro CMS initialized");
+    console.log(`   Collections: ${this.registry.getCollections().length}`);
+    console.log(`   Globals: ${this.registry.getGlobals().length}`);
+  }
+  // ============================================================================
+  // API Methods
+  // ============================================================================
+  getREST(options) {
+    return chunkUEG7KMKC_cjs.createHonoApp({
+      registry: this.registry,
+      db: this.db,
+      ...options,
+      cors: this.config.cors
+    });
+  }
+  getGraphQL(options) {
+    return chunkK7QF2QCM_cjs.buildGraphQLSchema({
+      registry: this.registry,
+      db: this.db,
+      ...options
+    });
+  }
+  getTRPC(options) {
+    return chunk3VZCX4DF_cjs.createKyroServer({
+      registry: this.registry,
+      db: this.db,
+      req: options?.req || { headers: {} },
+      ...options
+    });
+  }
+  async startWebSocket(options) {
+    this.wsServer = chunkDVD5P72E_cjs.createWSServer({
+      pubsub: this.pubsub,
+      port: options?.port || 8080,
+      requireAuth: options?.requireAuth,
+      verifyToken: options?.verifyToken
+    });
+    console.log(`\u{1F50C} WebSocket server started on port ${options?.port || 8080}`);
+    return this.wsServer;
+  }
+  // ============================================================================
+  // Lifecycle
+  // ============================================================================
+  async shutdown() {
+    if (this.wsServer) {
+      await this.wsServer.close();
+    }
+    await this.db.disconnect();
+    console.log("\u{1F44B} Kyro CMS shut down");
+  }
+};
+function createKyro(config) {
+  return new Kyro(config);
+}
+
+// src/fields/types.ts
+function isTextField(field) {
+  return field.type === "text";
+}
+function isNumberField(field) {
+  return field.type === "number";
+}
+function isRelationshipField(field) {
+  return field.type === "relationship";
+}
+function isArrayField(field) {
+  return field.type === "array";
+}
+function isGroupField(field) {
+  return field.type === "group";
+}
+function isBlocksField(field) {
+  return field.type === "blocks";
+}
+function isUploadField(field) {
+  return field.type === "upload";
+}
+function isRichTextField(field) {
+  return field.type === "richtext";
+}
+function isSelectField(field) {
+  return field.type === "select";
+}
+function isLayoutField(field) {
+  return field.type === "row" || field.type === "collapsible" || field.type === "tabs";
+}
+var PRIMITIVE_FIELD_TYPES = [
+  "text",
+  "number",
+  "checkbox",
+  "date",
+  "email",
+  "password",
+  "textarea",
+  "select",
+  "radio",
+  "color"
+];
+var COMPLEX_FIELD_TYPES = [
+  "richtext",
+  "json",
+  "code",
+  "upload",
+  "markdown"
+];
+var RELATIONAL_FIELD_TYPES = [
+  "relationship",
+  "array",
+  "group",
+  "blocks"
+];
+var LAYOUT_FIELD_TYPES = [
+  "row",
+  "collapsible",
+  "tabs"
+];
+var ALL_FIELD_TYPES = [
+  ...PRIMITIVE_FIELD_TYPES,
+  ...COMPLEX_FIELD_TYPES,
+  ...RELATIONAL_FIELD_TYPES,
+  ...LAYOUT_FIELD_TYPES
+];
+
+// src/hooks/types.ts
+async function runHooks(hooks, args) {
+  let result = args.data;
+  for (const hook of hooks) {
+    const hookResult = await hook({
+      ...args,
+      data: result
+    });
+    if (hookResult !== void 0) {
+      result = hookResult;
+    }
+  }
+  return result;
+}
+async function runFieldHooks(hooks, args) {
+  return runHooks(hooks, args);
+}
+
+// src/database/local/adapter.ts
+var LocalAdapter = class extends chunkRLTG4YZM_cjs.AbstractBaseAdapter {
+  db;
+  migrations = /* @__PURE__ */ new Map();
+  constructor(options) {
+    super();
+    if (options.db) {
+      this.db = options.db;
+    } else if (options.path) {
+      this.db = null;
+    } else {
+      this.db = null;
+    }
+  }
+  async connect() {
+    if (!this.db) {
+      const Database = (await import('better-sqlite3')).default;
+      this.db = new Database(":memory:");
+    }
+    this.db.pragma("journal_mode = WAL");
+    this.db.pragma("foreign_keys = ON");
+    this.connected = true;
+    console.log("[LocalAdapter] Connected to SQLite");
+  }
+  async disconnect() {
+    if (this.db) {
+      this.db.close();
+    }
+    this.connected = false;
+    console.log("[LocalAdapter] Disconnected");
+  }
+  // ========================================================================
+  // Schema Management
+  // ========================================================================
+  ensureTable(config) {
+    const tableName = this.getTableNameFor(config.slug);
+    if (this.migrations.has(tableName)) return;
+    const columns = [
+      `id TEXT PRIMARY KEY`
+    ];
+    for (const field of config.fields) {
+      if (!field.name || field.name === "id") continue;
+      const colDef = this.fieldToSQL(field);
+      if (colDef) columns.push(colDef);
+    }
+    if (config.timestamps) {
+      columns.push(`created_at TEXT DEFAULT (datetime('now'))`);
+      columns.push(`updated_at TEXT DEFAULT (datetime('now'))`);
+    }
+    if (config.tenantScoped) {
+      columns.push(`tenant_id TEXT NOT NULL`);
+    }
+    const createSQL = `CREATE TABLE IF NOT EXISTS ${tableName} (${columns.join(", ")})`;
+    this.db.exec(createSQL);
+    for (const field of config.fields) {
+      if (field.name && field.indexed) {
+        this.db.exec(`CREATE INDEX IF NOT EXISTS idx_${tableName}_${field.name} ON ${tableName}(${field.name})`);
+      }
+      if (field.name && field.unique) {
+        this.db.exec(`CREATE UNIQUE INDEX IF NOT EXISTS idx_${tableName}_${field.name}_unique ON ${tableName}(${field.name})`);
+      }
+    }
+    this.migrations.set(tableName, true);
+  }
+  fieldToSQL(field) {
+    switch (field.type) {
+      case "text":
+      case "email":
+      case "password":
+      case "textarea":
+      case "color":
+      case "code":
+      case "markdown":
+      case "url":
+        return `${field.name} TEXT`;
+      case "number":
+        return `${field.name} REAL`;
+      case "checkbox":
+        return `${field.name} INTEGER DEFAULT 0`;
+      case "date":
+        return `${field.name} TEXT`;
+      case "select":
+      case "radio":
+        return `${field.name} TEXT`;
+      case "relationship":
+      case "upload":
+        return `${field.name} TEXT`;
+      case "json":
+      case "richtext":
+      case "array":
+      case "group":
+      case "blocks":
+        return `${field.name} TEXT`;
+      default:
+        return null;
+    }
+  }
+  // ========================================================================
+  // CRUD Operations
+  // ========================================================================
+  async find(args) {
+    const { collection: slug, where = {}, sort, limit = 10, page = 1, tenantID } = args;
+    const config = this.getCollection(slug);
+    this.ensureTable(config);
+    const tableName = this.getTableNameFor(slug);
+    let sql = `SELECT * FROM ${tableName}`;
+    const params = [];
+    const conditions = [];
+    if (tenantID && config.tenantScoped) {
+      conditions.push(`tenant_id = ?`);
+      params.push(tenantID);
+    }
+    for (const [key, value] of Object.entries(where)) {
+      if (key === "AND" || key === "OR") continue;
+      if (typeof value === "object" && value !== null) {
+        if (value.equals !== void 0) {
+          conditions.push(`${key} = ?`);
+          params.push(value.equals);
+        }
+        if (value.in !== void 0) {
+          conditions.push(`${key} IN (${value.in.map(() => "?").join(", ")})`);
+          params.push(...value.in);
+        }
+        if (value.not_equals !== void 0) {
+          conditions.push(`${key} != ?`);
+          params.push(value.not_equals);
+        }
+      } else {
+        conditions.push(`${key} = ?`);
+        params.push(value);
+      }
+    }
+    if (conditions.length > 0) {
+      sql += ` WHERE ${conditions.join(" AND ")}`;
+    }
+    const sortField = sort?.replace("-", "") || "created_at";
+    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);
+    const docs = rows.map((row) => this.rowToDoc(row, config));
+    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 } = args;
+    const config = this.getCollection(slug);
+    this.ensureTable(config);
+    const tableName = this.getTableNameFor(slug);
+    let sql = `SELECT * FROM ${tableName} WHERE id = ?`;
+    const params = [id];
+    if (tenantID && config.tenantScoped) {
+      sql += ` AND tenant_id = ?`;
+      params.push(tenantID);
+    }
+    const row = this.db.prepare(sql).get(...params);
+    if (!row) return null;
+    return this.rowToDoc(row, config);
+  }
+  async create(args) {
+    const { collection: slug, data, tenantID } = args;
+    const config = this.getCollection(slug);
+    this.ensureTable(config);
+    const tableName = this.getTableNameFor(slug);
+    const id = 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 placeholders = columns.map(() => "?").join(", ");
+    const values = Object.values(insertData).map(
+      (v) => typeof v === "object" ? JSON.stringify(v) : v
+    );
+    this.db.prepare(
+      `INSERT INTO ${tableName} (${columns.join(", ")}) VALUES (${placeholders})`
+    ).run(...values);
+    return { ...insertData, id };
+  }
+  async update(args) {
+    const { collection: slug, id, data, tenantID } = args;
+    const config = this.getCollection(slug);
+    this.ensureTable(config);
+    const tableName = this.getTableNameFor(slug);
+    const updateData = this.prepareData(data, config);
+    updateData.updated_at = (/* @__PURE__ */ new Date()).toISOString();
+    const columns = Object.keys(updateData);
+    const setClause = columns.map((c) => `${c} = ?`).join(", ");
+    const values = Object.values(updateData).map(
+      (v) => 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);
+    return this.findByID({ collection: slug, id, tenantID });
+  }
+  async delete(args) {
+    const { collection: slug, id, tenantID } = args;
+    const config = this.getCollection(slug);
+    this.ensureTable(config);
+    const doc = await this.findByID({ collection: slug, id, tenantID });
+    if (!doc) throw new Error(`Document not found: ${slug}/${id}`);
+    const tableName = this.getTableNameFor(slug);
+    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 config = this.getCollection(slug);
+    this.ensureTable(config);
+    const tableName = this.getTableNameFor(slug);
+    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 result = await this.find({ ...args, limit: 1 });
+    return result.docs[0] || null;
+  }
+  // ========================================================================
+  // Version Support (Placeholder)
+  // ========================================================================
+  async findVersions() {
+    return { docs: [], totalDocs: 0, limit: 10, totalPages: 0, page: 1, pagingCounter: 0, hasPrevPage: false, hasNextPage: false, prevPage: null, nextPage: null };
+  }
+  async findVersionByID() {
+    return null;
+  }
+  async createVersion() {
+    return {};
+  }
+  async deleteVersions() {
+  }
+  // ========================================================================
+  // Helpers
+  // ========================================================================
+  rowToDoc(row, config) {
+    const doc = { id: row.id };
+    for (const field of config.fields) {
+      if (!field.name || field.name === "id") continue;
+      let value = row[field.name];
+      if (field.type === "json" || field.type === "richtext" || field.type === "array" || field.type === "group" || field.type === "blocks") {
+        try {
+          value = value ? JSON.parse(value) : null;
+        } catch {
+          value = null;
+        }
+      }
+      if (field.type === "checkbox") {
+        value = Boolean(value);
+      }
+      if (field.type === "date" && value) {
+        value = new Date(value).toISOString();
+      }
+      doc[field.name] = value;
+    }
+    if (config.timestamps) {
+      doc.createdAt = row.created_at;
+      doc.updatedAt = row.updated_at;
+    }
+    if (config.tenantScoped) {
+      doc.tenantID = row.tenant_id;
+    }
+    return doc;
+  }
+  generateId() {
+    return `${Date.now().toString(36)}-${Math.random().toString(36).slice(2, 9)}`;
+  }
+  getTableNameFor(slug) {
+    return slug.replace(/-/g, "_");
+  }
+  // ========================================================================
+  // Migrations
+  // ========================================================================
+  async migrate() {
+    for (const config of this.collections.values()) {
+      this.ensureTable(config);
+    }
+    console.log("[LocalAdapter] Migrations complete");
+  }
+  async rollback() {
+    console.log("[LocalAdapter] Rollback not supported for schema changes");
+  }
+  // ========================================================================
+  // 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 || {});
+}
+
+// src/plugins/index.ts
+var KyroPlugin = class {
+  name;
+  version;
+  description;
+  hooks = {};
+  collections = [];
+  globals = [];
+  fields = [];
+  extensions = { collections: [], globals: [] };
+  adminComponents = {};
+  adminStyles = [];
+  serverMiddleware;
+  clientMiddleware;
+  constructor(name) {
+    this.name = name;
+  }
+  async init(api) {
+  }
+  async beforeInit(api) {
+  }
+  async afterInit(api) {
+  }
+  getCollections() {
+    return this.collections;
+  }
+  getGlobals() {
+    return this.globals;
+  }
+  getHooks() {
+    return this.hooks;
+  }
+};
+var PluginManager = class {
+  plugins = /* @__PURE__ */ new Map();
+  hooks = /* @__PURE__ */ new Map();
+  register(plugin) {
+    if (this.plugins.has(plugin.name)) {
+      throw new Error(`Plugin "${plugin.name}" is already registered`);
+    }
+    this.plugins.set(plugin.name, plugin);
+    const pluginHooks = plugin.getHooks?.() || {};
+    for (const [event, handlers] of Object.entries(pluginHooks)) {
+      if (Array.isArray(handlers)) {
+        for (const handler of handlers) {
+          this.registerHook(event, handler);
+        }
+      }
+    }
+    console.log(`[PluginManager] Registered plugin: ${plugin.name}`);
+  }
+  unregister(name) {
+    const plugin = this.plugins.get(name);
+    if (!plugin) return;
+    const pluginHooks = plugin.getHooks?.() || {};
+    for (const [event, handlers] of Object.entries(pluginHooks)) {
+      if (Array.isArray(handlers)) {
+        for (const handler of handlers) {
+          this.unregisterHook(event, handler);
+        }
+      }
+    }
+    this.plugins.delete(name);
+    console.log(`[PluginManager] Unregistered plugin: ${name}`);
+  }
+  get(name) {
+    return this.plugins.get(name);
+  }
+  getAll() {
+    return Array.from(this.plugins.values());
+  }
+  has(name) {
+    return this.plugins.has(name);
+  }
+  registerHook(event, handler) {
+    if (!this.hooks.has(event)) {
+      this.hooks.set(event, []);
+    }
+    this.hooks.get(event).push(handler);
+  }
+  unregisterHook(event, handler) {
+    const handlers = this.hooks.get(event);
+    if (handlers) {
+      const index = handlers.indexOf(handler);
+      if (index > -1) {
+        handlers.splice(index, 1);
+      }
+    }
+  }
+  async executeHook(event, args) {
+    const handlers = this.hooks.get(event) || [];
+    let result = args;
+    for (const handler of handlers) {
+      try {
+        const hookResult = await handler({ ...args, data: result });
+        if (hookResult !== void 0) {
+          result = hookResult;
+        }
+      } catch (error) {
+        console.error(`[PluginManager] Error in hook "${event}":`, error);
+      }
+    }
+    return result;
+  }
+  // ========================================================================
+  // Collection/Field Extensions
+  // ========================================================================
+  getAllCollections() {
+    const collections = [];
+    for (const plugin of this.plugins.values()) {
+      const pluginCollections = plugin.getCollections?.() || [];
+      collections.push(...pluginCollections);
+    }
+    return collections;
+  }
+  getAllGlobals() {
+    const globals = [];
+    for (const plugin of this.plugins.values()) {
+      const pluginGlobals = plugin.getGlobals?.() || [];
+      globals.push(...pluginGlobals);
+    }
+    return globals;
+  }
+  getAllFields() {
+    const fields = [];
+    for (const plugin of this.plugins.values()) {
+      fields.push(...plugin.fields);
+    }
+    return fields;
+  }
+  getAdminComponents() {
+    const components = {};
+    for (const plugin of this.plugins.values()) {
+      Object.assign(components, plugin.adminComponents);
+    }
+    return components;
+  }
+  getAdminStyles() {
+    const styles = [];
+    for (const plugin of this.plugins.values()) {
+      styles.push(...plugin.adminStyles);
+    }
+    return styles;
+  }
+};
+var SEOPLugin = class extends KyroPlugin {
+  constructor() {
+    super("seo");
+    this.description = "Advanced SEO features including sitemaps, robots.txt, and structured data";
+    this.collections.push({
+      slug: "seo-settings",
+      label: "SEO Settings",
+      fields: [
+        { name: "sitemap", type: "checkbox", label: "Enable Sitemap", defaultValue: true },
+        { name: "robotsTxt", type: "textarea", label: "robots.txt Content" },
+        { name: "canonicalUrl", type: "text", variant: "url", label: "Canonical URL" },
+        { name: "ogImage", type: "text", label: "Default OG Image URL" }
+      ]
+    });
+  }
+};
+var AnalyticsPlugin = class extends KyroPlugin {
+  constructor() {
+    super("analytics");
+    this.description = "Analytics integration for tracking page views and events";
+    this.collections.push({
+      slug: "analytics-events",
+      label: "Analytics Events",
+      fields: [
+        { name: "name", type: "text", required: true },
+        { name: "properties", type: "json", label: "Event Properties" },
+        { name: "timestamp", type: "date", required: true },
+        { name: "userId", type: "text", label: "User ID" },
+        { name: "sessionId", type: "text", label: "Session ID" }
+      ]
+    });
+    this.adminComponents["AnalyticsDashboard"] = {};
+  }
+};
+var CommentsPlugin = class extends KyroPlugin {
+  constructor() {
+    super("comments");
+    this.description = "Commenting system for products and posts";
+    this.collections.push({
+      slug: "comments",
+      label: "Comments",
+      fields: [
+        { name: "content", type: "textarea", required: true },
+        { name: "author", type: "text", required: true },
+        { name: "email", type: "email" },
+        { name: "approved", type: "checkbox", defaultValue: false },
+        { name: "parent", type: "text", label: "Parent Comment ID" },
+        { name: "resourceType", type: "text", required: true },
+        { name: "resourceId", type: "text", required: true }
+      ]
+    });
+    this.adminComponents["CommentModeration"] = {};
+  }
+};
+var ReviewsPlugin = class extends KyroPlugin {
+  constructor() {
+    super("reviews");
+    this.description = "Product reviews and ratings";
+    this.collections.push({
+      slug: "reviews",
+      label: "Reviews",
+      fields: [
+        { name: "rating", type: "number", required: true, min: 1, max: 5 },
+        { name: "title", type: "text" },
+        { name: "content", type: "textarea", required: true },
+        { name: "author", type: "relationship", relationTo: "customers" },
+        { name: "product", type: "relationship", relationTo: "products", required: true },
+        { name: "approved", type: "checkbox", defaultValue: false },
+        { name: "verified", type: "checkbox", label: "Verified Purchase" },
+        { name: "helpful", type: "number", label: "Helpful Count", defaultValue: 0 }
+      ]
+    });
+    this.adminComponents["ReviewModeration"] = {};
+  }
+};
+var WishlistPlugin = class extends KyroPlugin {
+  constructor() {
+    super("wishlist");
+    this.description = "Customer wishlists";
+    this.collections.push({
+      slug: "wishlists",
+      label: "Wishlists",
+      fields: [
+        { name: "customer", type: "relationship", relationTo: "customers", required: true },
+        { name: "name", type: "text", label: "Wishlist Name", defaultValue: "My Wishlist" },
+        { name: "items", type: "blocks", label: "Items", blocks: [
+          {
+            slug: "wishlist-item",
+            label: "Item",
+            fields: [
+              { name: "product", type: "relationship", relationTo: "products" },
+              { name: "quantity", type: "number", defaultValue: 1 },
+              { name: "addedAt", type: "date" },
+              { name: "priority", type: "select", options: [
+                { label: "Low", value: "low" },
+                { label: "Medium", value: "medium" },
+                { label: "High", value: "high" }
+              ] }
+            ]
+          }
+        ] }
+      ]
+    });
+  }
+};
+var presetPlugins = {
+  SEO: SEOPLugin,
+  Analytics: AnalyticsPlugin,
+  Comments: CommentsPlugin,
+  Reviews: ReviewsPlugin,
+  Wishlist: WishlistPlugin
+};
+
+// src/styling/index.ts
+var CSSGenerator = class {
+  constructor(config) {
+    this.config = config;
+  }
+  config;
+  css = [];
+  addRule(selector, properties) {
+    const props = Object.entries(properties).map(([k, v]) => `  ${k}: ${v};`).join("\n");
+    this.css.push(`${selector} {
+${props}
+}`);
+    return this;
+  }
+  addMediaQuery(breakpoint, rules) {
+    this.css.push(`@media (min-width: ${breakpoint}) {
+  ${rules.join("\n  ")}
+}`);
+    return this;
+  }
+  generate() {
+    return this.css.join("\n\n");
+  }
+};
+function generateTailwindConfig(theme) {
+  return {
+    theme: {
+      extend: {
+        colors: theme.colors || {},
+        fontFamily: theme.fonts || {},
+        spacing: theme.spacing || {},
+        borderRadius: theme.borderRadius || {},
+        boxShadow: theme.shadows || {},
+        screens: theme.breakpoints || {}
+      }
+    }
+  };
+}
+var defaultLightTheme = {
+  colors: {
+    primary: "#3b82f6",
+    secondary: "#6366f1",
+    accent: "#ec4899",
+    background: "#ffffff",
+    surface: "#f9fafb",
+    text: "#111827",
+    textMuted: "#6b7280",
+    border: "#e5e7eb",
+    error: "#ef4444",
+    warning: "#f59e0b",
+    success: "#10b981",
+    info: "#3b82f6"
+  },
+  fonts: {
+    sans: "system-ui, -apple-system, sans-serif",
+    serif: "Georgia, serif",
+    mono: "Menlo, monospace"
+  },
+  spacing: {
+    xs: "0.25rem",
+    sm: "0.5rem",
+    md: "1rem",
+    lg: "1.5rem",
+    xl: "2rem",
+    "2xl": "3rem",
+    "3xl": "4rem"
+  },
+  borderRadius: {
+    sm: "0.125rem",
+    md: "0.375rem",
+    lg: "0.5rem",
+    xl: "0.75rem",
+    full: "9999px"
+  },
+  shadows: {
+    sm: "0 1px 2px 0 rgb(0 0 0 / 0.05)",
+    md: "0 4px 6px -1px rgb(0 0 0 / 0.1)",
+    lg: "0 10px 15px -3px rgb(0 0 0 / 0.1)",
+    xl: "0 20px 25px -5px rgb(0 0 0 / 0.1)"
+  }
+};
+var defaultDarkTheme = {
+  colors: {
+    primary: "#60a5fa",
+    secondary: "#818cf8",
+    accent: "#f472b6",
+    background: "#111827",
+    surface: "#1f2937",
+    text: "#f9fafb",
+    textMuted: "#9ca3af",
+    border: "#374151",
+    error: "#f87171",
+    warning: "#fbbf24",
+    success: "#34d399",
+    info: "#60a5fa"
+  },
+  fonts: defaultLightTheme.fonts,
+  spacing: defaultLightTheme.spacing,
+  borderRadius: defaultLightTheme.borderRadius,
+  shadows: {
+    sm: "0 1px 2px 0 rgb(0 0 0 / 0.3)",
+    md: "0 4px 6px -1px rgb(0 0 0 / 0.4)",
+    lg: "0 10px 15px -3px rgb(0 0 0 / 0.5)",
+    xl: "0 20px 25px -5px rgb(0 0 0 / 0.6)"
+  }
+};
+var ecommerce2026Theme = {
+  colors: {
+    primary: "#FF6B35",
+    secondary: "#1A1A2E",
+    accent: "#16C79A",
+    background: "#FFFFFF",
+    surface: "#F8F9FA",
+    text: "#1A1A2E",
+    textMuted: "#6B7280",
+    border: "#E5E7EB",
+    error: "#EF4444",
+    warning: "#F59E0B",
+    success: "#16C79A",
+    info: "#3B82F6"
+  },
+  fonts: {
+    sans: '"Inter", "Satoshi", system-ui, sans-serif',
+    serif: '"Playfair Display", Georgia, serif',
+    mono: '"JetBrains Mono", monospace'
+  },
+  spacing: {
+    xs: "0.125rem",
+    sm: "0.25rem",
+    md: "0.5rem",
+    lg: "1rem",
+    xl: "1.5rem",
+    "2xl": "2rem",
+    "3xl": "3rem",
+    "4xl": "4rem"
+  },
+  borderRadius: {
+    sm: "0",
+    md: "0",
+    lg: "0",
+    xl: "0",
+    full: "9999px"
+  },
+  shadows: {
+    sm: "0 1px 2px rgba(0,0,0,0.05)",
+    md: "0 4px 6px rgba(0,0,0,0.07)",
+    lg: "0 10px 15px rgba(0,0,0,0.1)",
+    xl: "0 20px 25px rgba(0,0,0,0.15)"
+  }
+};
+function generateCSSVariables(theme) {
+  const variables = [];
+  if (theme.colors) {
+    for (const [key, value] of Object.entries(theme.colors)) {
+      variables.push(`  --color-${key}: ${value};`);
+    }
+  }
+  if (theme.fonts) {
+    for (const [key, value] of Object.entries(theme.fonts)) {
+      variables.push(`  --font-${key}: ${value};`);
+    }
+  }
+  if (theme.spacing) {
+    for (const [key, value] of Object.entries(theme.spacing)) {
+      variables.push(`  --spacing-${key}: ${value};`);
+    }
+  }
+  if (theme.borderRadius) {
+    for (const [key, value] of Object.entries(theme.borderRadius)) {
+      variables.push(`  --radius-${key}: ${value};`);
+    }
+  }
+  if (theme.shadows) {
+    for (const [key, value] of Object.entries(theme.shadows)) {
+      variables.push(`  --shadow-${key}: ${value};`);
+    }
+  }
+  return `:root {
+${variables.join("\n")}
+}`;
+}
+function createAdminStyling(config) {
+  const cssVars = generateCSSVariables(config.theme || defaultLightTheme);
+  const componentStyles = [];
+  if (config.componentOverrides) {
+    for (const [selector, styles] of Object.entries(config.componentOverrides)) {
+      const props = Object.entries(styles).map(([k, v]) => `  ${k}: ${v};`).join("\n");
+      componentStyles.push(`${selector} {
+${props}
+}`);
+    }
+  }
+  return `
+    ${cssVars}
+    ${config.customStyles || ""}
+    ${componentStyles.join("\n")}
+  `;
+}
+var defaultFieldStyling = {
+  text: {
+    wrapper: { marginBottom: "var(--spacing-md)" },
+    label: {
+      display: "block",
+      marginBottom: "var(--spacing-xs)",
+      fontWeight: "500",
+      color: "var(--color-text)"
+    },
+    input: {
+      width: "100%",
+      padding: "var(--spacing-sm) var(--spacing-md)",
+      border: "1px solid var(--color-border)",
+      borderRadius: "var(--radius-md)",
+      fontSize: "0.875rem"
+    },
+    error: {
+      color: "var(--color-error)",
+      fontSize: "0.75rem",
+      marginTop: "var(--spacing-xs)"
+    }
+  },
+  number: {
+    wrapper: { marginBottom: "var(--spacing-md)" },
+    label: { display: "block", marginBottom: "var(--spacing-xs)", fontWeight: "500" },
+    input: {
+      width: "100%",
+      padding: "var(--spacing-sm) var(--spacing-md)",
+      border: "1px solid var(--color-border)",
+      borderRadius: "var(--radius-md)"
+    }
+  },
+  checkbox: {
+    wrapper: { display: "flex", alignItems: "center", gap: "var(--spacing-sm)" },
+    input: { width: "1rem", height: "1rem" },
+    label: { cursor: "pointer" }
+  },
+  select: {
+    wrapper: { marginBottom: "var(--spacing-md)" },
+    input: {
+      width: "100%",
+      padding: "var(--spacing-sm) var(--spacing-md)",
+      border: "1px solid var(--color-border)",
+      borderRadius: "var(--radius-md)",
+      backgroundColor: "white"
+    }
+  }
+};
+var DEFAULT_SALT_ROUNDS = 12;
+var DEFAULT_EXPIRES_IN = "24h";
+var DEFAULT_REFRESH_EXPIRES_IN = "7d";
+var Auth = class {
+  adapter;
+  config;
+  constructor(adapter, config) {
+    this.adapter = adapter;
+    this.config = {
+      secret: config.secret,
+      expiresIn: config.expiresIn ?? DEFAULT_EXPIRES_IN,
+      refreshExpiresIn: config.refreshExpiresIn ?? DEFAULT_REFRESH_EXPIRES_IN,
+      issuer: config.issuer ?? "kyro-cms",
+      audience: config.audience ?? [],
+      saltRounds: config.saltRounds ?? DEFAULT_SALT_ROUNDS
+    };
+  }
+  async register(data) {
+    try {
+      const existing = await this.adapter.findUserByEmail(data.email);
+      if (existing) {
+        return { success: false, error: "Email already registered" };
+      }
+      const passwordHash = await this.hashPassword(data.password);
+      const user = await this.adapter.createUser({
+        email: data.email,
+        passwordHash,
+        role: data.role ?? "customer",
+        tenant: data.tenant
+      });
+      return this.createSessionForUser(user);
+    } catch (error) {
+      return { success: false, error: String(error) };
+    }
+  }
+  async login(credentials) {
+    try {
+      const user = await this.adapter.findUserByEmail(credentials.email);
+      if (!user || !user.passwordHash) {
+        return { success: false, error: "Invalid credentials" };
+      }
+      const valid = await this.adapter.verifyPassword(
+        credentials.password,
+        user.passwordHash
+      );
+      if (!valid) {
+        return { success: false, error: "Invalid credentials" };
+      }
+      return this.createSessionForUser(user);
+    } catch (error) {
+      return { success: false, error: String(error) };
+    }
+  }
+  async logout(token) {
+    await this.adapter.deleteSession(token);
+  }
+  async refreshToken(refreshToken) {
+    try {
+      const session = await this.adapter.findSessionByToken(refreshToken);
+      if (!session || session.expiresAt < /* @__PURE__ */ new Date()) {
+        return { success: false, error: "Invalid or expired refresh token" };
+      }
+      const user = await this.adapter.findUserById(session.userId);
+      if (!user) {
+        return { success: false, error: "User not found" };
+      }
+      await this.adapter.deleteSession(refreshToken);
+      return this.createSessionForUser(user);
+    } catch (error) {
+      return { success: false, error: String(error) };
+    }
+  }
+  async verifyToken(token) {
+    try {
+      const decoded = jwt__default.default.verify(token, this.config.secret, {
+        issuer: this.config.issuer,
+        audience: this.config.audience.length > 0 ? this.config.audience[0] : void 0
+      });
+      return decoded;
+    } catch {
+      return null;
+    }
+  }
+  async getUserFromToken(token) {
+    const payload = await this.verifyToken(token);
+    if (!payload) return null;
+    return this.adapter.findUserById(payload.sub);
+  }
+  async changePassword(userId, currentPassword, newPassword) {
+    try {
+      const user = await this.adapter.findUserById(userId);
+      if (!user || !user.passwordHash) {
+        return { success: false, error: "User not found" };
+      }
+      const valid = await this.adapter.verifyPassword(
+        currentPassword,
+        user.passwordHash
+      );
+      if (!valid) {
+        return { success: false, error: "Current password is incorrect" };
+      }
+      const newHash = await this.hashPassword(newPassword);
+      await this.adapter.updateUser(userId, { passwordHash: newHash });
+      await this.adapter.deleteUserSessions(userId);
+      return { success: true, user };
+    } catch (error) {
+      return { success: false, error: String(error) };
+    }
+  }
+  async resetPassword(email, newPassword) {
+    try {
+      const user = await this.adapter.findUserByEmail(email);
+      if (!user) {
+        return { success: false, error: "User not found" };
+      }
+      const passwordHash = await this.hashPassword(newPassword);
+      await this.adapter.updateUser(user.id, { passwordHash });
+      await this.adapter.deleteUserSessions(user.id);
+      return { success: true, user };
+    } catch (error) {
+      return { success: false, error: String(error) };
+    }
+  }
+  async deleteAccount(userId) {
+    try {
+      const user = await this.adapter.findUserById(userId);
+      if (!user) {
+        return { success: false, error: "User not found" };
+      }
+      await this.adapter.deleteUserSessions(userId);
+      await this.adapter.deleteUser(userId);
+      return { success: true };
+    } catch (error) {
+      return { success: false, error: String(error) };
+    }
+  }
+  async createSessionForUser(user) {
+    const token = this.generateToken(user);
+    const refreshToken = crypto.randomUUID();
+    const expiresAt = new Date(Date.now() + this.parseExpiresIn(this.config.refreshExpiresIn));
+    const session = await this.adapter.createSession(user.id, refreshToken, expiresAt);
+    return {
+      success: true,
+      user,
+      session,
+      token
+    };
+  }
+  generateToken(user) {
+    const payload = {
+      sub: user.id,
+      email: user.email,
+      role: user.role,
+      tenant: user.tenant
+    };
+    const signOptions = {
+      expiresIn: this.parseExpiresIn(this.config.expiresIn) / 1e3,
+      issuer: this.config.issuer
+    };
+    if (this.config.audience.length > 0) {
+      signOptions.audience = this.config.audience[0];
+    }
+    return jwt__default.default.sign(payload, this.config.secret, signOptions);
+  }
+  async hashPassword(password) {
+    return bcrypt__default.default.hash(password, this.config.saltRounds);
+  }
+  parseExpiresIn(value) {
+    if (typeof value === "number") return value;
+    const match = value.match(/^(\d+)([smhd])$/);
+    if (!match) return 864e5;
+    const num = parseInt(match[1], 10);
+    switch (match[2]) {
+      case "s":
+        return num * 1e3;
+      case "m":
+        return num * 6e4;
+      case "h":
+        return num * 36e5;
+      case "d":
+        return num * 864e5;
+      default:
+        return 864e5;
+    }
+  }
+};
+function createAuth(adapter, config) {
+  return new Auth(adapter, config);
+}
+
+// src/versions/types.ts
+function getDefaultDraftPublishConfig() {
+  return {
+    enabled: true,
+    draftsEnabled: true,
+    publishEnabled: true,
+    scheduleEnabled: false,
+    versioningEnabled: true,
+    maxVersionsPerDocument: 50,
+    autoPublish: false,
+    requirePublishPermission: true
+  };
+}
+
+// src/versions/index.ts
+var VersionManager = class {
+  adapter;
+  config;
+  constructor(adapter, config) {
+    this.adapter = adapter;
+    this.config = { ...getDefaultDraftPublishConfig(), ...config };
+  }
+  async createVersion(options) {
+    const latestVersion = await this.adapter.getLatestVersion(options.collection, options.documentId);
+    const nextVersion = (latestVersion?.version ?? 0) + 1;
+    const versionOptions = {
+      ...options,
+      version: nextVersion
+    };
+    const version = await this.adapter.createVersion(versionOptions);
+    if (this.config.maxVersionsPerDocument > 0) {
+      await this.pruneOldVersions(options.collection, options.documentId);
+    }
+    return version;
+  }
+  async publishVersion(options) {
+    const version = await this.adapter.getVersion(options.collection, options.versionId);
+    if (!version) {
+      throw new Error("Version not found");
+    }
+    if (version.status === "published") {
+      throw new Error("Version is already published");
+    }
+    await this.adapter.publishVersion(options);
+  }
+  async unpublishDocument(collection, documentId) {
+    const versions = await this.adapter.getVersions({
+      collection,
+      documentId,
+      limit: 1e3
+    });
+    for (const version of versions) {
+      if (version.status === "published") {
+        await this.createVersion({
+          collection,
+          documentId,
+          data: version.data,
+          status: "draft",
+          createdBy: "system",
+          changeDescription: "Unpublished document"
+        });
+        break;
+      }
+    }
+  }
+  async revertToVersion(collection, documentId, versionId, userId) {
+    const targetVersion = await this.adapter.getVersion(collection, versionId);
+    if (!targetVersion) {
+      throw new Error("Version not found");
+    }
+    const newVersion = await this.adapter.revertToVersion({
+      collection,
+      documentId,
+      versionId,
+      userId
+    });
+    return newVersion;
+  }
+  async getVersionHistory(collection, documentId, limit = 20, offset = 0) {
+    return this.adapter.getVersions({
+      collection,
+      documentId,
+      limit,
+      offset
+    });
+  }
+  async compareTwoVersions(collection, documentId, versionA, versionB) {
+    return this.adapter.compareVersions({
+      collection,
+      documentId,
+      versionA,
+      versionB
+    });
+  }
+  async getLatestDraft(collection, documentId) {
+    return this.adapter.getLatestVersion(collection, documentId);
+  }
+  async getPublishedVersion(collection, documentId) {
+    return this.adapter.getPublishedVersion(collection, documentId);
+  }
+  async getVersion(collection, versionId) {
+    return this.adapter.getVersion(collection, versionId);
+  }
+  async schedulePublish(collection, documentId, versionId, scheduledFor) {
+    if (!this.config.scheduleEnabled) {
+      throw new Error("Scheduled publishing is not enabled");
+    }
+    const version = await this.adapter.getVersion(collection, versionId);
+    if (!version) {
+      throw new Error("Version not found");
+    }
+  }
+  async deleteVersionHistory(collection, documentId) {
+    await this.adapter.deleteVersions(collection, documentId);
+  }
+  async pruneOldVersions(collection, documentId) {
+    const versions = await this.adapter.getVersions({
+      collection,
+      documentId,
+      limit: this.config.maxVersionsPerDocument + 100
+    });
+    if (versions.length <= this.config.maxVersionsPerDocument) {
+      return;
+    }
+    versions.slice(0, this.config.maxVersionsPerDocument);
+    const versionsToDelete = versions.slice(this.config.maxVersionsPerDocument);
+    for (const version of versionsToDelete) {
+      if (version.status !== "published") {
+        await this.adapter.deleteVersions(collection, documentId);
+        break;
+      }
+    }
+  }
+};
+function createVersionManager(adapter, config) {
+  return new VersionManager(adapter, config);
+}
+function isPublished(status) {
+  return status === "published";
+}
+function isDraft(status) {
+  return status === "draft";
+}
+function isArchived(status) {
+  return status === "archived";
+}
+
+Object.defineProperty(exports, "createContext", {
+  enumerable: true,
+  get: function () { return chunk3VZCX4DF_cjs.createContext; }
+});
+Object.defineProperty(exports, "createCountProcedure", {
+  enumerable: true,
+  get: function () { return chunk3VZCX4DF_cjs.createCountProcedure; }
+});
+Object.defineProperty(exports, "createCreateProcedure", {
+  enumerable: true,
+  get: function () { return chunk3VZCX4DF_cjs.createCreateProcedure; }
+});
+Object.defineProperty(exports, "createDeleteProcedure", {
+  enumerable: true,
+  get: function () { return chunk3VZCX4DF_cjs.createDeleteProcedure; }
+});
+Object.defineProperty(exports, "createDynamicRouter", {
+  enumerable: true,
+  get: function () { return chunk3VZCX4DF_cjs.createDynamicRouter; }
+});
+Object.defineProperty(exports, "createFindByIDProcedure", {
+  enumerable: true,
+  get: function () { return chunk3VZCX4DF_cjs.createFindByIDProcedure; }
+});
+Object.defineProperty(exports, "createFindProcedure", {
+  enumerable: true,
+  get: function () { return chunk3VZCX4DF_cjs.createFindProcedure; }
+});
+Object.defineProperty(exports, "createKyroServer", {
+  enumerable: true,
+  get: function () { return chunk3VZCX4DF_cjs.createKyroServer; }
+});
+Object.defineProperty(exports, "createUpdateProcedure", {
+  enumerable: true,
+  get: function () { return chunk3VZCX4DF_cjs.createUpdateProcedure; }
+});
+Object.defineProperty(exports, "buildGraphQLSchema", {
+  enumerable: true,
+  get: function () { return chunkK7QF2QCM_cjs.buildGraphQLSchema; }
+});
+Object.defineProperty(exports, "createGraphQLSchema", {
+  enumerable: true,
+  get: function () { return chunkK7QF2QCM_cjs.createGraphQLSchema; }
+});
+Object.defineProperty(exports, "createHonoApp", {
+  enumerable: true,
+  get: function () { return chunkUEG7KMKC_cjs.createHonoApp; }
+});
+Object.defineProperty(exports, "createRESTAPI", {
+  enumerable: true,
+  get: function () { return chunkUEG7KMKC_cjs.createRESTAPI; }
+});
+Object.defineProperty(exports, "evaluateAccess", {
+  enumerable: true,
+  get: function () { return chunkR3XIBBAW_cjs.evaluateAccess; }
+});
+Object.defineProperty(exports, "getWhereClause", {
+  enumerable: true,
+  get: function () { return chunkR3XIBBAW_cjs.getWhereClause; }
+});
+Object.defineProperty(exports, "mergeWhereClauses", {
+  enumerable: true,
+  get: function () { return chunkR3XIBBAW_cjs.mergeWhereClauses; }
+});
+Object.defineProperty(exports, "KyroPubSub", {
+  enumerable: true,
+  get: function () { return chunkDVD5P72E_cjs.KyroPubSub; }
+});
+Object.defineProperty(exports, "KyroWSServer", {
+  enumerable: true,
+  get: function () { return chunkDVD5P72E_cjs.KyroWSServer; }
+});
+Object.defineProperty(exports, "PubSub", {
+  enumerable: true,
+  get: function () { return chunkDVD5P72E_cjs.PubSub; }
+});
+Object.defineProperty(exports, "createWSServer", {
+  enumerable: true,
+  get: function () { return chunkDVD5P72E_cjs.createWSServer; }
+});
+Object.defineProperty(exports, "DrizzleAdapter", {
+  enumerable: true,
+  get: function () { return chunk3Q3FS5J4_cjs.DrizzleAdapter; }
+});
+Object.defineProperty(exports, "collectionToDrizzleSchema", {
+  enumerable: true,
+  get: function () { return chunk3Q3FS5J4_cjs.collectionToDrizzleSchema; }
+});
+Object.defineProperty(exports, "createDrizzleAdapter", {
+  enumerable: true,
+  get: function () { return chunk3Q3FS5J4_cjs.createDrizzleAdapter; }
+});
+Object.defineProperty(exports, "fieldToDrizzleType", {
+  enumerable: true,
+  get: function () { return chunk3Q3FS5J4_cjs.fieldToDrizzleType; }
+});
+Object.defineProperty(exports, "MongoDBAdapter", {
+  enumerable: true,
+  get: function () { return chunkHT6VE4NW_cjs.MongoDBAdapter; }
+});
+Object.defineProperty(exports, "createMongoDBAdapter", {
+  enumerable: true,
+  get: function () { return chunkHT6VE4NW_cjs.createMongoDBAdapter; }
+});
+Object.defineProperty(exports, "AbstractBaseAdapter", {
+  enumerable: true,
+  get: function () { return chunkRLTG4YZM_cjs.AbstractBaseAdapter; }
+});
+Object.defineProperty(exports, "z", {
+  enumerable: true,
+  get: function () { return zod.z; }
+});
+exports.ALL_FIELD_TYPES = ALL_FIELD_TYPES;
+exports.AnalyticsPlugin = AnalyticsPlugin;
+exports.Auth = Auth;
+exports.COMPLEX_FIELD_TYPES = COMPLEX_FIELD_TYPES;
+exports.CSSGenerator = CSSGenerator;
+exports.CommentsPlugin = CommentsPlugin;
+exports.ConfigValidationError = ConfigValidationError;
+exports.Kyro = Kyro;
+exports.KyroPlugin = KyroPlugin;
+exports.LAYOUT_FIELD_TYPES = LAYOUT_FIELD_TYPES;
+exports.LocalAdapter = LocalAdapter;
+exports.PRIMITIVE_FIELD_TYPES = PRIMITIVE_FIELD_TYPES;
+exports.PluginManager = PluginManager;
+exports.RELATIONAL_FIELD_TYPES = RELATIONAL_FIELD_TYPES;
+exports.Registry = Registry;
+exports.ReviewsPlugin = ReviewsPlugin;
+exports.SEOPLugin = SEOPLugin;
+exports.VersionManager = VersionManager;
+exports.WishlistPlugin = WishlistPlugin;
+exports.collectionToCreateZod = collectionToCreateZod;
+exports.collectionToUpdateZod = collectionToUpdateZod;
+exports.collectionToWhereZod = collectionToWhereZod;
+exports.collectionToZod = collectionToZod;
+exports.createAdminStyling = createAdminStyling;
+exports.createAuth = createAuth;
+exports.createKyro = createKyro;
+exports.createLocalAdapter = createLocalAdapter;
+exports.createRegistry = createRegistry;
+exports.createVersionManager = createVersionManager;
+exports.defaultDarkTheme = defaultDarkTheme;
+exports.defaultFieldStyling = defaultFieldStyling;
+exports.defaultLightTheme = defaultLightTheme;
+exports.ecommerce2026Theme = ecommerce2026Theme;
+exports.fieldToZod = fieldToZod;
+exports.generateCSSVariables = generateCSSVariables;
+exports.generateTailwindConfig = generateTailwindConfig;
+exports.getDefaultDraftPublishConfig = getDefaultDraftPublishConfig;
+exports.getRegistry = getRegistry;
+exports.globalToZod = globalToZod;
+exports.isArchived = isArchived;
+exports.isArrayField = isArrayField;
+exports.isBlocksField = isBlocksField;
+exports.isDraft = isDraft;
+exports.isGroupField = isGroupField;
+exports.isLayoutField = isLayoutField;
+exports.isNumberField = isNumberField;
+exports.isPublished = isPublished;
+exports.isRelationshipField = isRelationshipField;
+exports.isRichTextField = isRichTextField;
+exports.isSelectField = isSelectField;
+exports.isTextField = isTextField;
+exports.isUploadField = isUploadField;
+exports.presetPlugins = presetPlugins;
+exports.resetRegistry = resetRegistry;
+exports.runFieldHooks = runFieldHooks;
+exports.runHooks = runHooks;
+exports.validateCollection = validateCollection;
+exports.validateConfig = validateConfig;
+exports.validateFields = validateFields;
+exports.validateGlobal = validateGlobal;
+//# sourceMappingURL=index.cjs.map
+//# sourceMappingURL=index.cjs.map