@vexcms/core 0.0.1

package/dist/index.js

@@ -0,0 +1,3158 @@
+// src/types/media.ts
+var LOCKED_MEDIA_FIELDS = [
+  "storageId",
+  "filename",
+  "mimeType",
+  "size"
+];
+var OVERRIDABLE_MEDIA_FIELDS = [
+  "url",
+  "alt",
+  "width",
+  "height"
+];
+function getDefaultMediaFields() {
+  return {
+    storageId: {
+      type: "text",
+      required: true,
+      defaultValue: "",
+      label: "Storage ID",
+      admin: { hidden: true }
+    },
+    filename: {
+      type: "text",
+      required: true,
+      defaultValue: "",
+      label: "Filename",
+      admin: { readOnly: true }
+    },
+    mimeType: {
+      type: "text",
+      required: true,
+      defaultValue: "",
+      label: "MIME Type",
+      index: "by_mimeType",
+      admin: { readOnly: true }
+    },
+    size: {
+      type: "number",
+      required: true,
+      defaultValue: 0,
+      label: "File Size (bytes)",
+      admin: { readOnly: true }
+    },
+    url: {
+      type: "text",
+      required: true,
+      defaultValue: "",
+      label: "URL",
+      admin: { readOnly: true }
+    },
+    alt: { type: "text", label: "Alt Text" },
+    width: { type: "number", label: "Width (px)" },
+    height: { type: "number", label: "Height (px)" }
+  };
+}
+
+// src/errors/index.ts
+var VexError = class extends Error {
+  constructor(message) {
+    super(`[vex] ${message}`);
+    this.name = "VexError";
+  }
+};
+var VexSlugConflictError = class extends VexError {
+  constructor(slug, existingSource, existingLocation, newSource, newLocation) {
+    super(
+      `Duplicate table slug "${slug}":
+  - ${existingSource}: ${existingLocation}
+  - ${newSource}: ${newLocation}
+Rename one of these to resolve the conflict.`
+    );
+    this.slug = slug;
+    this.existingSource = existingSource;
+    this.existingLocation = existingLocation;
+    this.newSource = newSource;
+    this.newLocation = newLocation;
+    this.name = "VexSlugConflictError";
+  }
+};
+var VexFieldValidationError = class extends VexError {
+  constructor(collectionSlug, fieldName, detail) {
+    super(`Field "${fieldName}" in collection "${collectionSlug}": ${detail}`);
+    this.collectionSlug = collectionSlug;
+    this.fieldName = fieldName;
+    this.detail = detail;
+    this.name = "VexFieldValidationError";
+  }
+};
+var VexAuthConfigError = class extends VexError {
+  constructor(detail) {
+    super(`Auth configuration error: ${detail}`);
+    this.name = "VexAuthConfigError";
+  }
+};
+var VexMediaConfigError = class extends VexError {
+  constructor(detail) {
+    super(`Media configuration error: ${detail}`);
+    this.name = "VexMediaConfigError";
+  }
+};
+var VexAccessConfigError = class extends VexError {
+  constructor(detail) {
+    super(`Access configuration error: ${detail}`);
+    this.name = "VexAccessConfigError";
+  }
+};
+var VexAccessError = class extends VexError {
+  constructor(resource, action, field) {
+    const target = field ? `field "${field}" on resource "${resource}"` : `resource "${resource}"`;
+    super(`Access denied: ${action} on ${target}`);
+    this.resource = resource;
+    this.action = action;
+    this.field = field;
+    this.name = "VexAccessError";
+  }
+};
+var VexBlockValidationError = class extends VexError {
+  constructor(blockSlug, detail) {
+    super(`Block "${blockSlug}": ${detail}`);
+    this.blockSlug = blockSlug;
+    this.detail = detail;
+    this.name = "VexBlockValidationError";
+  }
+};
+
+// src/config/defineConfig.ts
+var BASE_VEX_CONFIG = {
+  basePath: "/admin",
+  globals: [],
+  collections: [],
+  admin: {
+    meta: {
+      titleSuffix: "| Admin",
+      favicon: "/favicon.ico"
+    },
+    user: "users",
+    sidebar: {
+      hideGlobals: false
+    }
+  },
+  schema: {
+    outputPath: "/convex/vex.schema.ts",
+    typesOutputPath: "/convex/vex.types.ts",
+    autoMigrate: true,
+    autoRemove: false
+  }
+};
+function resolveMediaCollection(props) {
+  const defaults = getDefaultMediaFields();
+  if (props.mediaCollection.fields) {
+    for (const [fieldName, field] of Object.entries(props.mediaCollection.fields)) {
+      if (LOCKED_MEDIA_FIELDS.includes(fieldName)) {
+        if (process.env.NODE_ENV !== "production") {
+          console.warn(
+            `[vex] Media collection "${props.mediaCollection.slug}": field "${fieldName}" is a system field and cannot be overridden`
+          );
+        }
+        continue;
+      }
+      defaults[fieldName] = field;
+    }
+  }
+  const adminConfig = {
+    ...props.mediaCollection.admin,
+    useAsTitle: props.mediaCollection.admin?.useAsTitle ?? "filename"
+  };
+  return {
+    slug: props.mediaCollection.slug,
+    fields: defaults,
+    tableName: props.mediaCollection.tableName,
+    labels: props.mediaCollection.labels,
+    admin: adminConfig
+  };
+}
+function defineConfig(vexConfig) {
+  const { media: mediaInput, ...restInput } = vexConfig;
+  const config = {
+    ...BASE_VEX_CONFIG,
+    ...restInput,
+    admin: {
+      ...BASE_VEX_CONFIG.admin,
+      ...vexConfig.admin,
+      meta: {
+        ...BASE_VEX_CONFIG.admin.meta,
+        ...vexConfig.admin?.meta
+      },
+      sidebar: {
+        ...BASE_VEX_CONFIG.admin.sidebar,
+        ...vexConfig.admin?.sidebar
+      },
+      livePreview: vexConfig.admin?.livePreview
+    },
+    schema: {
+      ...BASE_VEX_CONFIG.schema,
+      ...vexConfig.schema
+    },
+    access: vexConfig.access
+  };
+  if (mediaInput) {
+    if (mediaInput.collections.length === 0) {
+      config.media = void 0;
+    } else if (!mediaInput.storageAdapter) {
+      throw new VexMediaConfigError(
+        "media.storageAdapter is required when media.collections is non-empty"
+      );
+    } else {
+      config.media = {
+        collections: mediaInput.collections.map(
+          (mc) => resolveMediaCollection({ mediaCollection: mc })
+        ),
+        storageAdapter: mediaInput.storageAdapter
+      };
+    }
+  } else {
+    config.media = void 0;
+  }
+  if (process.env.NODE_ENV !== "production") {
+    for (const collection of config.collections) {
+      if (!/^[a-z][a-z0-9_]*$/.test(collection.slug)) {
+        console.warn(
+          `[vex] Collection slug "${collection.slug}" should be lowercase alphanumeric with underscores, starting with a letter`
+        );
+      }
+      if (collection.slug.startsWith("vex_")) {
+        console.warn(
+          `[vex] Collection slug "${collection.slug}" uses reserved prefix "vex_"`
+        );
+      }
+      if (Object.keys(collection.fields).length === 0) {
+        console.warn(`[vex] Collection "${collection.slug}" has no fields defined`);
+      }
+    }
+    for (const global of config.globals) {
+      if (!/^[a-z][a-z0-9_]*$/.test(global.slug)) {
+        console.warn(
+          `[vex] Global slug "${global.slug}" should be lowercase alphanumeric with underscores, starting with a letter`
+        );
+      }
+      if (global.slug.startsWith("vex_")) {
+        console.warn(`[vex] Global slug "${global.slug}" uses reserved prefix "vex_"`);
+      }
+      if (Object.keys(global.fields).length === 0) {
+        console.warn(`[vex] Global "${global.slug}" has no fields defined`);
+      }
+    }
+    const slugs = config.collections.concat(config.globals).map((c) => c.slug);
+    const duplicates = slugs.filter((slug, i) => slugs.indexOf(slug) !== i);
+    if (duplicates.length > 0) {
+      console.warn(
+        `[vex] Duplicate collection slugs detected: ${duplicates.join(", ")}`
+      );
+    }
+  }
+  return config;
+}
+
+// src/config/defineCollection.ts
+function defineCollection(props) {
+  const { auth: _auth, ...rest } = props;
+  return rest;
+}
+function defineMediaCollection(props) {
+  return props;
+}
+
+// src/access/defineAccess.ts
+function defineAccess(props) {
+  if (props.orgCollection && !props.userOrgField) {
+    throw new VexAccessConfigError("orgCollection requires userOrgField");
+  }
+  if (props.userOrgField && !props.orgCollection) {
+    throw new VexAccessConfigError("userOrgField requires orgCollection");
+  }
+  const adminRoles = props.adminRoles ?? props.roles;
+  if (process.env.NODE_ENV !== "production") {
+    if (!props.userCollection?.slug) {
+      console.warn("[vex] defineAccess: userCollection must have a slug");
+    }
+    if (props.orgCollection && !props.orgCollection.slug) {
+      console.warn("[vex] defineAccess: orgCollection must have a slug");
+    }
+    if (props.resources) {
+      const resourceSlugs = new Set(
+        props.resources.map((r) => r.slug)
+      );
+      for (const role of Object.keys(props.permissions)) {
+        const rolePerms = props.permissions[role];
+        if (!rolePerms) continue;
+        for (const slug of Object.keys(rolePerms)) {
+          if (!resourceSlugs.has(slug)) {
+            console.warn(
+              `[vex] defineAccess: permission resource "${slug}" not found in resources`
+            );
+          }
+        }
+      }
+    }
+    const rolesSet = new Set(props.roles);
+    for (const role of Object.keys(props.permissions)) {
+      if (!rolesSet.has(role)) {
+        console.warn(
+          `[vex] defineAccess: permission role "${role}" not in roles array`
+        );
+      }
+    }
+    if (props.adminRoles) {
+      const rolesSetForAdmin = new Set(props.roles);
+      for (const adminRole of props.adminRoles) {
+        if (!rolesSetForAdmin.has(adminRole)) {
+          console.warn(
+            `[vex] defineAccess: adminRole "${adminRole}" not found in roles array`
+          );
+        }
+      }
+    }
+    if (props.userOrgField && props.userCollection?.fields) {
+      if (!(props.userOrgField in props.userCollection.fields)) {
+        console.warn(
+          `[vex] defineAccess: userOrgField "${props.userOrgField}" not found in user collection fields`
+        );
+      }
+    }
+  }
+  return {
+    roles: props.roles,
+    adminRoles,
+    userCollection: props.userCollection.slug,
+    orgCollection: props.orgCollection?.slug,
+    userOrgField: props.userOrgField,
+    permissions: props.permissions
+  };
+}
+
+// src/access/hasPermission.ts
+function resolvePermissionCheck(props) {
+  if (props.check === void 0) {
+    if (props.fields === void 0) return true;
+    return Object.fromEntries(props.fields.map((k) => [k, true]));
+  }
+  let resolved;
+  if (typeof props.check === "function") {
+    const callbackProps = props.organization !== void 0 ? { data: props.data, user: props.user, organization: props.organization } : { data: props.data, user: props.user };
+    resolved = props.check(callbackProps);
+  } else {
+    resolved = props.check;
+  }
+  if (resolved === void 0) {
+    if (props.fields === void 0) return false;
+    return Object.fromEntries(props.fields.map((k) => [k, false]));
+  }
+  if (typeof resolved === "boolean") {
+    if (props.fields === void 0) return resolved;
+    return Object.fromEntries(props.fields.map((k) => [k, resolved]));
+  }
+  if (props.fields === void 0) {
+    if (resolved.mode === "allow") return resolved.fields.length > 0;
+    if (resolved.mode === "deny") return resolved.fields.length === 0;
+    return true;
+  }
+  if (resolved.mode === "allow") {
+    const allowSet = new Set(resolved.fields);
+    return Object.fromEntries(
+      props.fields.map((k) => [k, allowSet.has(k)])
+    );
+  }
+  const denySet = new Set(resolved.fields);
+  return Object.fromEntries(
+    props.fields.map((k) => [k, !denySet.has(k)])
+  );
+}
+function mergeRolePermissions(props) {
+  if (props.results.length === 0) {
+    if (props.fields === void 0) return true;
+    return Object.fromEntries(props.fields.map((k) => [k, true]));
+  }
+  if (props.fields === void 0) {
+    return props.results.some((r) => r === true);
+  }
+  return Object.fromEntries(
+    props.fields.map((k) => [
+      k,
+      props.results.some(
+        (r) => typeof r === "boolean" ? r : r[k] === true
+      )
+    ])
+  );
+}
+function hasPermission(props) {
+  if (props.access === void 0) {
+    if (props.fields === void 0) return true;
+    return Object.fromEntries(props.fields.map((k) => [k, true]));
+  }
+  if (props.userRoles.length === 0) {
+    if (props.throwOnDenied) {
+      throw new VexAccessError(props.resource, props.action);
+    }
+    if (props.fields === void 0) return false;
+    return Object.fromEntries(props.fields.map((k) => [k, false]));
+  }
+  const knownRolesSet = new Set(props.access.roles);
+  const knownRoles = props.userRoles.filter((r) => knownRolesSet.has(r));
+  if (knownRoles.length === 0) {
+    if (props.throwOnDenied) {
+      throw new VexAccessError(props.resource, props.action);
+    }
+    if (props.fields === void 0) return false;
+    return Object.fromEntries(props.fields.map((k) => [k, false]));
+  }
+  const results = [];
+  const data = props.data ?? {};
+  for (const role of knownRoles) {
+    const rolePerms = props.access.permissions[role];
+    if (rolePerms === void 0) {
+      continue;
+    }
+    const resourcePerms = rolePerms[props.resource];
+    if (resourcePerms === void 0) {
+      results.push(true);
+      continue;
+    }
+    if (typeof resourcePerms === "boolean") {
+      results.push(resourcePerms);
+      continue;
+    }
+    const actionCheck = resourcePerms[props.action];
+    results.push(
+      resolvePermissionCheck({
+        check: actionCheck,
+        fields: props.fields,
+        data,
+        user: props.user,
+        organization: props.organization
+      })
+    );
+  }
+  const merged = mergeRolePermissions({
+    results,
+    fields: props.fields
+  });
+  if (props.throwOnDenied) {
+    if (typeof merged === "boolean") {
+      if (!merged) {
+        throw new VexAccessError(props.resource, props.action);
+      }
+    } else {
+      const deniedField = Object.entries(merged).find(([, v2]) => v2 === false);
+      if (deniedField) {
+        throw new VexAccessError(props.resource, props.action, deniedField[0]);
+      }
+    }
+  }
+  return merged;
+}
+
+// src/config/sanitizeConfig.ts
+function sanitizeConfigForClient(config) {
+  const { media, ...rest } = config;
+  return {
+    ...rest,
+    collections: rest.collections.map((collection) => {
+      if (!collection.admin?.livePreview) return collection;
+      if (typeof collection.admin.livePreview.url === "string") return collection;
+      return {
+        ...collection,
+        admin: {
+          ...collection.admin,
+          livePreview: {
+            ...collection.admin.livePreview,
+            url: null
+          }
+        }
+      };
+    }),
+    media: media ? { collections: media.collections } : void 0
+  };
+}
+function extractLivePreviewConfigs(config) {
+  const result = {};
+  for (const collection of config.collections) {
+    if (collection.admin?.livePreview && typeof collection.admin.livePreview.url === "function") {
+      result[collection.slug] = { url: collection.admin.livePreview.url };
+    }
+  }
+  return result;
+}
+
+// src/config/isMediaCollection.ts
+function isMediaCollection(props) {
+  if (!props.config.media?.collections) return false;
+  return props.config.media.collections.some(
+    (mc) => mc.slug === props.collection.slug
+  );
+}
+
+// src/config/findCollectionBySlug.ts
+function getAllCollections(props) {
+  const { config, excludeGlobals = false } = props;
+  const result = [];
+  for (const c of config.collections) {
+    result.push({ slug: c.slug, fields: c.fields, kind: "collection" });
+  }
+  if (config.media?.collections) {
+    for (const c of config.media.collections) {
+      result.push({ slug: c.slug, fields: c.fields, kind: "media" });
+    }
+  }
+  if (!excludeGlobals) {
+    for (const g of config.globals) {
+      result.push({ slug: g.slug, fields: g.fields, kind: "global" });
+    }
+  }
+  return result;
+}
+function findCollectionBySlug(props) {
+  return getAllCollections(props).find((c) => c.slug === props.slug) ?? null;
+}
+
+// src/fields/checkbox/config.ts
+function checkbox(options) {
+  return {
+    type: "checkbox",
+    ...options?.required && options?.defaultValue === void 0 ? { defaultValue: false } : {},
+    ...options
+  };
+}
+
+// src/utils.ts
+var MINOR_WORDS = /* @__PURE__ */ new Set([
+  "a",
+  "an",
+  "and",
+  "as",
+  // "at",
+  "but",
+  "by",
+  "for",
+  "if",
+  "in",
+  "nor",
+  "of",
+  "on",
+  "or",
+  "so",
+  "the",
+  "to",
+  "up",
+  "yet"
+]);
+function toTitleCase(input) {
+  const words = input.replace(/([a-z])([A-Z])/g, "$1 $2").replace(/[_-]+/g, " ").trim().split(/\s+/);
+  return words.map((word, i) => {
+    const lower = word.toLowerCase();
+    if (i > 0 && MINOR_WORDS.has(lower)) return lower;
+    return lower.charAt(0).toUpperCase() + lower.slice(1);
+  }).join(" ");
+}
+
+// src/fields/checkbox/columnDef.ts
+function checkboxColumnDef(props) {
+  return {
+    accessorKey: props.fieldKey,
+    header: props.field.label ?? toTitleCase(props.fieldKey),
+    meta: { align: props.field.admin?.cellAlignment ?? "left" }
+  };
+}
+
+// src/valueTypes/processAdminOptions.ts
+function processFieldValueTypeOptions(props) {
+  if (!props.field.required) {
+    return `v.optional(${props.valueType})`;
+  }
+  if (!props.skipDefaultValidation) {
+    if (props.field.defaultValue === void 0) {
+      throw new VexFieldValidationError(
+        props.collectionSlug,
+        props.fieldName,
+        "No defaultValue Provided"
+      );
+    }
+    if (!(typeof props.field.defaultValue === props.expectedType)) {
+      throw new VexFieldValidationError(
+        props.collectionSlug,
+        props.fieldName,
+        `Invalid defaultValue Provided. Expected: ${props.expectedType}, Received: ${typeof props.field.defaultValue}`
+      );
+    }
+  }
+  return props.valueType;
+}
+
+// src/fields/constants.ts
+var TEXT_VALUETYPE = "v.string()";
+var NUMBER_VALUETYPE = "v.number()";
+var CHECKBOX_VALUETYPE = "v.boolean()";
+var DATE_VALUETYPE = "v.number()";
+var IMAGEURL_VALUETYPE = "v.string()";
+var JSON_VALUETYPE = "v.any()";
+var RICHTEXT_VALUETYPE = "v.any()";
+
+// src/fields/checkbox/schemaValueType.ts
+function checkboxToValueTypeString(props) {
+  return processFieldValueTypeOptions({
+    field: props.field,
+    collectionSlug: props.collectionSlug,
+    fieldName: props.fieldName,
+    expectedType: "boolean",
+    valueType: CHECKBOX_VALUETYPE
+  });
+}
+
+// src/fields/number/config.ts
+function number(options) {
+  return {
+    type: "number",
+    ...options?.required && options?.defaultValue === void 0 ? { defaultValue: 0 } : {},
+    ...options
+  };
+}
+
+// src/fields/number/columnDef.ts
+function numberColumnDef(props) {
+  return {
+    accessorKey: props.fieldKey,
+    header: props.field.label ?? toTitleCase(props.fieldKey),
+    meta: { align: props.field.admin?.cellAlignment ?? "right" }
+  };
+}
+
+// src/fields/number/schemaValueType.ts
+function numberToValueTypeString(props) {
+  return processFieldValueTypeOptions({
+    field: props.field,
+    collectionSlug: props.collectionSlug,
+    fieldName: props.fieldName,
+    expectedType: "number",
+    valueType: NUMBER_VALUETYPE
+  });
+}
+
+// src/fields/select/config.ts
+function select(options) {
+  return { type: "select", ...options };
+}
+
+// src/fields/select/columnDef.tsx
+import { jsx } from "react/jsx-runtime";
+var DEFAULT_BADGE_COLORS = [
+  "#3b82f6",
+  // blue
+  "#22c55e",
+  // green
+  "#a855f7",
+  // purple
+  "#f59e0b",
+  // amber
+  "#f43f5e",
+  // rose
+  "#06b6d4",
+  // cyan
+  "#6366f1",
+  // indigo
+  "#14b8a6",
+  // teal
+  "#f97316",
+  // orange
+  "#d946ef"
+  // fuchsia
+];
+function selectColumnDef(props) {
+  const optionMap = new Map(
+    props.field.options.map((opt, i) => [
+      opt.value,
+      {
+        label: opt.label,
+        color: opt.badgeColor ?? DEFAULT_BADGE_COLORS[i % DEFAULT_BADGE_COLORS.length]
+      }
+    ])
+  );
+  return {
+    accessorKey: props.fieldKey,
+    header: (props.field.hasMany ? props.field.labels?.singular : props.field.label) ?? toTitleCase(props.fieldKey),
+    meta: {
+      align: props.field.admin?.cellAlignment ?? "left",
+      noTruncate: true
+    },
+    cell: (info) => {
+      const raw = info.getValue();
+      const values = Array.isArray(raw) ? raw : raw != null ? [String(raw)] : [];
+      if (values.length === 0) return null;
+      return /* @__PURE__ */ jsx("div", { className: "flex flex-wrap gap-1 max-w-[240px] max-h-[60px] overflow-auto", children: values.map((v2) => {
+        const opt = optionMap.get(v2);
+        return /* @__PURE__ */ jsx(
+          "span",
+          {
+            className: "inline-flex items-center rounded-full px-2 py-0.5 text-xs font-medium text-white shrink-0",
+            style: { backgroundColor: opt?.color },
+            children: opt?.label ?? v2
+          },
+          v2
+        );
+      }) });
+    }
+  };
+}
+
+// src/fields/select/schemaValueType.ts
+function selectToValueTypeString(props) {
+  const literals = props.field.options.map((o) => `v.literal("${o.value}")`).join(",");
+  if (props.field.hasMany) {
+    return processFieldValueTypeOptions({
+      field: props.field,
+      collectionSlug: props.collectionSlug,
+      fieldName: props.fieldName,
+      expectedType: "object",
+      valueType: props.field.options.length === 1 ? `v.array(${literals})` : `v.array(v.union(${literals}))`,
+      skipDefaultValidation: true
+    });
+  }
+  return processFieldValueTypeOptions({
+    field: props.field,
+    collectionSlug: props.collectionSlug,
+    fieldName: props.fieldName,
+    expectedType: "string",
+    valueType: `v.union(${literals})`
+  });
+}
+
+// src/fields/text/config.ts
+function text(options) {
+  return {
+    type: "text",
+    ...options?.required && options?.defaultValue === void 0 ? { defaultValue: "" } : {},
+    ...options
+  };
+}
+
+// src/fields/text/columnDef.tsx
+function textColumnDef(props) {
+  return {
+    accessorKey: props.fieldKey,
+    header: props.field.label ?? toTitleCase(props.fieldKey),
+    meta: { align: props.field.admin?.cellAlignment ?? "left" }
+  };
+}
+
+// src/fields/text/schemaValueType.ts
+function textToValueTypeString(props) {
+  return processFieldValueTypeOptions({
+    field: props.field,
+    collectionSlug: props.collectionSlug,
+    fieldName: props.fieldName,
+    expectedType: "string",
+    valueType: TEXT_VALUETYPE
+  });
+}
+
+// src/fields/date/config.ts
+function date(options) {
+  return {
+    type: "date",
+    ...options?.required && options?.defaultValue === void 0 ? { defaultValue: 0 } : {},
+    ...options
+  };
+}
+
+// src/fields/date/columnDef.ts
+function dateColumnDef(props) {
+  return {
+    accessorKey: props.fieldKey,
+    header: props.field.label ?? toTitleCase(props.fieldKey),
+    meta: {
+      align: props.field.admin?.cellAlignment ?? "left"
+    },
+    cell: (info) => {
+      const value = info.getValue();
+      if (value == null) return "";
+      return new Date(value).toLocaleDateString();
+    }
+  };
+}
+
+// src/fields/date/schemaValueType.ts
+function dateToValueTypeString(props) {
+  return processFieldValueTypeOptions({
+    field: props.field,
+    collectionSlug: props.collectionSlug,
+    fieldName: props.fieldName,
+    expectedType: "number",
+    valueType: DATE_VALUETYPE
+  });
+}
+
+// src/fields/imageUrl/config.ts
+function imageUrl(options) {
+  return {
+    type: "imageUrl",
+    ...options?.required && options?.defaultValue === void 0 ? { defaultValue: "" } : {},
+    ...options
+  };
+}
+
+// src/fields/imageUrl/columnDef.tsx
+import { jsx as jsx2 } from "react/jsx-runtime";
+function imageUrlColumnDef(props) {
+  return {
+    accessorKey: props.fieldKey,
+    header: props.field.label ?? toTitleCase(props.fieldKey),
+    meta: { align: props.field.admin?.cellAlignment ?? "center" },
+    cell: (info) => {
+      const value = info.getValue();
+      if (!value || typeof value !== "string") return "";
+      const size = props.field.width ?? 28;
+      const height = props.field.height ?? size;
+      return /* @__PURE__ */ jsx2(
+        "img",
+        {
+          src: value,
+          alt: "",
+          width: size,
+          height,
+          className: "rounded-full object-cover bg-muted",
+          style: { width: size, height },
+          loading: "lazy",
+          referrerPolicy: "no-referrer",
+          onError: (e) => {
+            e.currentTarget.style.display = "none";
+          }
+        }
+      );
+    }
+  };
+}
+
+// src/fields/imageUrl/schemaValueType.ts
+function imageUrlToValueTypeString(props) {
+  return processFieldValueTypeOptions({
+    field: props.field,
+    collectionSlug: props.collectionSlug,
+    fieldName: props.fieldName,
+    expectedType: "string",
+    valueType: IMAGEURL_VALUETYPE
+  });
+}
+
+// src/fields/relationship/config.ts
+function relationship(options) {
+  return { type: "relationship", ...options };
+}
+
+// src/fields/relationship/columnDef.ts
+function relationshipColumnDef(props) {
+  return {
+    accessorKey: props.fieldKey,
+    header: (props.field.hasMany ? props.field.labels?.singular : props.field.label) ?? toTitleCase(props.fieldKey),
+    meta: { type: "relationship", to: props.field.to, align: props.field.admin?.cellAlignment ?? "left" },
+    cell: (info) => {
+      const value = info.getValue();
+      if (value == null) return "";
+      if (Array.isArray(value)) return `${value.length} item${value.length === 1 ? "" : "s"}`;
+      return String(value);
+    }
+  };
+}
+
+// src/fields/relationship/schemaValueType.ts
+function relationshipToValueTypeString(props) {
+  const idType = `v.id("${props.field.to}")`;
+  const baseValueType = props.field.hasMany ? `v.array(${idType})` : idType;
+  return processFieldValueTypeOptions({
+    field: props.field,
+    collectionSlug: props.collectionSlug,
+    fieldName: props.fieldName,
+    expectedType: "string",
+    valueType: baseValueType,
+    skipDefaultValidation: true
+  });
+}
+
+// src/fields/json/config.ts
+function json(options) {
+  return {
+    type: "json",
+    ...options
+  };
+}
+
+// src/fields/json/columnDef.ts
+function jsonColumnDef(props) {
+  return {
+    accessorKey: props.fieldKey,
+    header: props.field.label ?? toTitleCase(props.fieldKey),
+    meta: { align: props.field.admin?.cellAlignment ?? "left" },
+    cell: (info) => {
+      const value = info.getValue();
+      if (value == null) return "";
+      const str = JSON.stringify(value);
+      return str.length > 50 ? str.slice(0, 50) + "..." : str;
+    }
+  };
+}
+
+// src/fields/json/schemaValueType.ts
+function jsonToValueTypeString(props) {
+  return processFieldValueTypeOptions({
+    field: props.field,
+    collectionSlug: props.collectionSlug,
+    fieldName: props.fieldName,
+    expectedType: "object",
+    valueType: JSON_VALUETYPE,
+    skipDefaultValidation: true
+  });
+}
+
+// src/fields/richtext/config.ts
+function richtext(options) {
+  return {
+    type: "richtext",
+    ...options
+  };
+}
+
+// src/fields/richtext/schemaValueType.ts
+function richtextToValueTypeString(props) {
+  return processFieldValueTypeOptions({
+    field: props.field,
+    collectionSlug: props.collectionSlug,
+    fieldName: props.fieldName,
+    expectedType: "object",
+    valueType: RICHTEXT_VALUETYPE,
+    skipDefaultValidation: true
+  });
+}
+
+// src/fields/richtext/columnDef.ts
+function richtextColumnDef(props) {
+  return {
+    accessorKey: props.fieldKey,
+    header: props.field.label ?? toTitleCase(props.fieldKey),
+    meta: { align: props.field.admin?.cellAlignment ?? "left" },
+    cell: (info) => {
+      const value = info.getValue();
+      if (value == null) return "";
+      if (Array.isArray(value) && value.length === 0) return "";
+      return "Rich text";
+    }
+  };
+}
+
+// src/fields/media/config.ts
+function upload(options) {
+  return { type: "upload", ...options };
+}
+
+// src/fields/media/schemaValueType.ts
+function uploadToValueTypeString(props) {
+  const idType = `v.id("${props.field.to}")`;
+  const baseValueType = props.field.hasMany ? `v.array(${idType})` : idType;
+  return processFieldValueTypeOptions({
+    field: props.field,
+    collectionSlug: props.collectionSlug,
+    fieldName: props.fieldName,
+    expectedType: "string",
+    valueType: baseValueType,
+    skipDefaultValidation: true
+  });
+}
+
+// src/fields/array/config.ts
+function array(options) {
+  return { type: "array", ...options };
+}
+
+// src/fields/array/columnDef.ts
+function arrayColumnDef(props) {
+  return {
+    accessorKey: props.fieldKey,
+    header: props.field.label ?? toTitleCase(props.fieldKey),
+    meta: { align: props.field.admin?.cellAlignment ?? "left" },
+    cell: (info) => {
+      const value = info.getValue();
+      if (!Array.isArray(value) || value.length === 0) return "no items";
+      if (value.length === 1) return "1 item";
+      return `${value.length} items`;
+    }
+  };
+}
+
+// src/fields/array/schemaValueType.ts
+function arrayToValueTypeString(props) {
+  const innerValueType = props.resolveInnerField({
+    field: props.field.field,
+    collectionSlug: props.collectionSlug,
+    fieldName: `${props.fieldName}[]`
+  });
+  const unwrapped = innerValueType.replace(/^v\.optional\((.+)\)$/, "$1");
+  const arrayType = `v.array(${unwrapped})`;
+  return processFieldValueTypeOptions({
+    field: props.field,
+    collectionSlug: props.collectionSlug,
+    fieldName: props.fieldName,
+    expectedType: "object",
+    valueType: arrayType,
+    skipDefaultValidation: true
+  });
+}
+
+// src/fields/blocks/config.ts
+function blocks(props) {
+  const seen = /* @__PURE__ */ new Set();
+  for (const block of props.blocks) {
+    if (seen.has(block.slug)) {
+      throw new VexBlockValidationError(
+        block.slug,
+        `Duplicate block slug "${block.slug}" in blocks field. Each block in a blocks() field must have a unique slug.`
+      );
+    }
+    seen.add(block.slug);
+  }
+  return {
+    type: "blocks",
+    blocks: props.blocks,
+    labels: props.labels,
+    min: props.min,
+    max: props.max,
+    label: props.label,
+    description: props.description,
+    required: props.required,
+    admin: props.admin
+  };
+}
+
+// src/fields/blocks/schemaValueType.ts
+function blocksToValueTypeString(props) {
+  const visited = props.visitedBlockSlugs ?? /* @__PURE__ */ new Set();
+  if (props.field.blocks.length === 0) {
+    return processFieldValueTypeOptions({
+      field: props.field,
+      collectionSlug: props.collectionSlug,
+      fieldName: props.fieldName,
+      expectedType: "object",
+      valueType: "v.array(v.any())",
+      skipDefaultValidation: true
+    });
+  }
+  const objectTypes = [];
+  for (const block of props.field.blocks) {
+    if (visited.has(block.slug)) {
+      throw new VexBlockValidationError(
+        block.slug,
+        `Circular block reference detected: block "${block.slug}" references itself (directly or through a cycle).`
+      );
+    }
+    const blockVisited = new Set(visited);
+    blockVisited.add(block.slug);
+    const fieldEntries = [
+      `blockType: v.literal("${block.slug}")`,
+      `blockName: v.optional(v.string())`,
+      `_key: v.string()`
+    ];
+    for (const [fieldName, field] of Object.entries(block.fields)) {
+      const valueType = props.resolveInnerField({
+        field,
+        collectionSlug: props.collectionSlug,
+        fieldName: `${props.fieldName}.${block.slug}.${fieldName}`,
+        visitedBlockSlugs: blockVisited
+      });
+      fieldEntries.push(`${fieldName}: ${valueType}`);
+    }
+    objectTypes.push(`v.object({${fieldEntries.join(", ")}})`);
+  }
+  const innerType = objectTypes.length === 1 ? objectTypes[0] : `v.union(${objectTypes.join(", ")})`;
+  const arrayType = `v.array(${innerType})`;
+  return processFieldValueTypeOptions({
+    field: props.field,
+    collectionSlug: props.collectionSlug,
+    fieldName: props.fieldName,
+    expectedType: "object",
+    valueType: arrayType,
+    skipDefaultValidation: true
+  });
+}
+
+// src/fields/blocks/columnDef.ts
+function blocksColumnDef(props) {
+  const singular = props.field.labels?.singular ?? "block";
+  const plural = props.field.labels?.plural ?? "blocks";
+  return {
+    accessorKey: props.fieldKey,
+    header: props.field.label ?? toTitleCase(props.fieldKey),
+    meta: { align: props.field.admin?.cellAlignment ?? "left" },
+    cell: (info) => {
+      const value = info.getValue();
+      if (!Array.isArray(value) || value.length === 0) return `no ${plural}`;
+      if (value.length === 1) return `1 ${singular}`;
+      return `${value.length} ${plural}`;
+    }
+  };
+}
+
+// src/valueTypes/extract.ts
+function fieldToValueType(props) {
+  const { field, collectionSlug, fieldName } = props;
+  switch (field.type) {
+    case "text":
+      return textToValueTypeString({ field, collectionSlug, fieldName });
+    case "number":
+      return numberToValueTypeString({ field, collectionSlug, fieldName });
+    case "checkbox":
+      return checkboxToValueTypeString({ field, collectionSlug, fieldName });
+    case "select":
+      return selectToValueTypeString({ field, collectionSlug, fieldName });
+    case "date":
+      return dateToValueTypeString({ field, collectionSlug, fieldName });
+    case "imageUrl":
+      return imageUrlToValueTypeString({ field, collectionSlug, fieldName });
+    case "relationship":
+      return relationshipToValueTypeString({ field, collectionSlug, fieldName });
+    case "upload":
+      return uploadToValueTypeString({ field, collectionSlug, fieldName });
+    case "json":
+      return jsonToValueTypeString({ field, collectionSlug, fieldName });
+    case "richtext":
+      return richtextToValueTypeString({ field, collectionSlug, fieldName });
+    case "array":
+      return arrayToValueTypeString({
+        field,
+        collectionSlug,
+        fieldName,
+        resolveInnerField: fieldToValueType
+      });
+    case "blocks":
+      return blocksToValueTypeString({
+        field,
+        collectionSlug,
+        fieldName,
+        resolveInnerField: (innerProps) => fieldToValueType({
+          field: innerProps.field,
+          collectionSlug: innerProps.collectionSlug,
+          fieldName: innerProps.fieldName,
+          visitedBlockSlugs: innerProps.visitedBlockSlugs
+        }),
+        visitedBlockSlugs: props.visitedBlockSlugs
+      });
+    case "ui":
+      throw new VexFieldValidationError(
+        collectionSlug,
+        fieldName,
+        `UI field "${fieldName}" on collection "${collectionSlug}" has no database representation and should not be included in schema generation.`
+      );
+    default:
+      throw new VexFieldValidationError(
+        collectionSlug,
+        fieldName,
+        `Unknown Field Type: ${field.type}`
+      );
+  }
+}
+
+// src/valueTypes/indexes.ts
+function collectIndexes(props) {
+  const { collection } = props;
+  const fieldIndexes = /* @__PURE__ */ new Map();
+  for (const [fieldKey, field] of Object.entries(collection.fields)) {
+    const indexName = field.index;
+    if (indexName) {
+      if (fieldIndexes.has(indexName)) {
+        throw new VexFieldValidationError(
+          collection.slug,
+          fieldKey,
+          `Duplicate Indexes detected: ${indexName}`
+        );
+      }
+      fieldIndexes.set(indexName, { name: indexName, fields: [fieldKey] });
+    }
+  }
+  collection.indexes?.forEach((index) => {
+    fieldIndexes.set(index.name, { name: index.name, fields: index.fields });
+  });
+  const useAsTitle = collection.admin?.useAsTitle;
+  if (useAsTitle && useAsTitle !== "_id") {
+    const autoName = `by_${useAsTitle}`;
+    if (!fieldIndexes.has(autoName)) {
+      fieldIndexes.set(autoName, { name: autoName, fields: [useAsTitle] });
+    }
+  }
+  return Array.from(fieldIndexes.values());
+}
+
+// src/valueTypes/searchIndexes.ts
+function collectSearchIndexes(props) {
+  const { collection } = props;
+  const searchIndexes = /* @__PURE__ */ new Map();
+  for (const [fieldKey, field] of Object.entries(collection.fields)) {
+    const searchIndex = field.searchIndex;
+    if (searchIndex && searchIndex.name) {
+      if (searchIndexes.has(searchIndex.name)) {
+        throw new VexFieldValidationError(
+          collection.slug,
+          fieldKey,
+          `Duplicate search index name: ${searchIndex.name}`
+        );
+      }
+      searchIndexes.set(searchIndex.name, {
+        name: searchIndex.name,
+        searchField: fieldKey,
+        filterFields: searchIndex.filterFields
+      });
+    }
+  }
+  collection.searchIndexes?.forEach((entry) => {
+    searchIndexes.set(entry.name, {
+      name: entry.name,
+      searchField: entry.searchField,
+      filterFields: entry.filterFields ?? []
+    });
+  });
+  const useAsTitle = collection.admin?.useAsTitle;
+  if (useAsTitle && useAsTitle !== "_id") {
+    const autoName = `search_${useAsTitle}`;
+    const alreadyCovered = Array.from(searchIndexes.values()).some(
+      (si) => si.searchField === useAsTitle
+    );
+    if (!alreadyCovered && !searchIndexes.has(autoName)) {
+      searchIndexes.set(autoName, {
+        name: autoName,
+        searchField: useAsTitle,
+        filterFields: []
+      });
+    }
+  }
+  return Array.from(searchIndexes.values());
+}
+
+// src/valueTypes/merge.ts
+function mergeAuthCollectionWithUserCollection(props) {
+  const { authCollection, userCollection } = props;
+  const fields = {};
+  const overlapping = [];
+  const authOnly = [];
+  const userOnly = [];
+  const authFields = authCollection.fields;
+  const userFields = userCollection.fields;
+  const authFieldKeys = Object.keys(authFields);
+  const userFieldKeys = Object.keys(userFields);
+  for (const fieldKey of authFieldKeys) {
+    if (userFieldKeys.includes(fieldKey)) {
+      overlapping.push(fieldKey);
+      const authField = authFields[fieldKey];
+      const userField = userFields[fieldKey];
+      fields[fieldKey] = {
+        ...userField,
+        required: authField.required,
+        ...authField.defaultValue !== void 0 && { defaultValue: authField.defaultValue }
+      };
+    } else {
+      authOnly.push(fieldKey);
+      fields[fieldKey] = authFields[fieldKey];
+    }
+  }
+  for (const fieldKey of userFieldKeys) {
+    if (authFieldKeys.includes(fieldKey)) continue;
+    userOnly.push(fieldKey);
+    fields[fieldKey] = userFields[fieldKey];
+  }
+  const indexes = [];
+  const indexNames = /* @__PURE__ */ new Set();
+  for (const idx of authCollection.indexes ?? []) {
+    indexes.push({ name: idx.name, fields: idx.fields });
+    indexNames.add(idx.name);
+  }
+  for (const idx of userCollection.indexes ?? []) {
+    if (!indexNames.has(idx.name)) {
+      indexes.push({ name: idx.name, fields: idx.fields });
+      indexNames.add(idx.name);
+    }
+  }
+  const searchIndexes = (userCollection.searchIndexes ?? []).map((si) => ({
+    name: si.name,
+    searchField: si.searchField,
+    filterFields: si.filterFields ?? []
+  }));
+  return { fields, indexes, searchIndexes, overlapping, authOnly, userOnly };
+}
+
+// src/valueTypes/slugs.ts
+var SLUG_SOURCES = {
+  userCollection: "user-collection",
+  userGlobal: "user-global",
+  authTable: "auth-table",
+  mediaCollection: "media-collection",
+  system: "system"
+};
+var SlugRegistry = class {
+  registrations = /* @__PURE__ */ new Map();
+  /**
+   * Register a slug with its source.
+   * Throws VexSlugConflictError immediately if the slug is already registered,
+   * UNLESS an auth table slug overlaps with a user collection slug — this is
+   * expected behavior indicating the user wants to customize that auth table's
+   * admin UI. In that case, the user collection's registration takes precedence
+   * (it was registered first as "user-collection") and the auth table is
+   * silently skipped in the registry. The merge happens during schema generation.
+   *
+   * @param props.slug - The table slug to register
+   * @param props.source - Where this slug comes from (e.g., "user-collection", "auth-table")
+   * @param props.location - Human-readable location for error messages (e.g., `collection "posts"`)
+   *
+   * Edge cases:
+   * - Auth table slug matches user collection slug: NOT a conflict — skip
+   *   registration (user collection already registered, merge happens later)
+   * - System table prefixed with "vex_" should not conflict with user tables
+   *   because defineCollection already warns about "vex_" prefix
+   */
+  register(props) {
+    const existing = this.registrations.get(props.slug);
+    if (existing) {
+      if (existing.source === "user-collection" && props.source === "auth-table" || existing.source === "auth-table" && props.source === "user-collection") {
+        if (props.source === "user-collection") {
+          this.registrations.set(props.slug, {
+            slug: props.slug,
+            source: props.source,
+            location: props.location
+          });
+        }
+        return;
+      }
+      throw new VexSlugConflictError(
+        props.slug,
+        existing.source,
+        existing.location,
+        props.source,
+        props.location
+      );
+    }
+    this.registrations.set(props.slug, {
+      slug: props.slug,
+      source: props.source,
+      location: props.location
+    });
+  }
+  /**
+   * Get all registered slugs.
+   */
+  getAll() {
+    return [...this.registrations.values()];
+  }
+};
+function buildSlugRegistry(props) {
+  const registry = new SlugRegistry();
+  for (const collection of props.config.collections) {
+    registry.register({
+      slug: collection.slug,
+      source: SLUG_SOURCES.userCollection,
+      location: `Collection ${collection.slug}`
+    });
+  }
+  if (props.config.media) {
+    for (const collection of props.config.media.collections) {
+      registry.register({
+        slug: collection.slug,
+        source: SLUG_SOURCES.mediaCollection,
+        location: `Media Collection ${collection.slug}`
+      });
+    }
+  }
+  for (const global of props.config.globals) {
+    registry.register({
+      slug: global.slug,
+      source: SLUG_SOURCES.userGlobal,
+      location: `Global ${global.slug}`
+    });
+  }
+  for (const collection of props.config.auth.collections) {
+    registry.register({
+      slug: collection.slug,
+      source: SLUG_SOURCES.authTable,
+      location: `Auth Table ${collection.slug}`
+    });
+  }
+  return registry;
+}
+
+// src/valueTypes/generate.ts
+function generateVexSchema(props) {
+  const config = props.config;
+  buildSlugRegistry({ config });
+  const authCollectionMap = new Map(
+    config.auth.collections.map((c) => [c.slug, c])
+  );
+  const mergedAuthSlugs = /* @__PURE__ */ new Set();
+  const lines = [
+    "// \u26A0\uFE0F AUTO-GENERATED BY VEX CMS \u2014 DO NOT EDIT \u26A0\uFE0F",
+    "",
+    'import { defineTable } from "convex/server";',
+    'import { v } from "convex/values";'
+  ];
+  if (config.collections.length > 0) {
+    lines.push("", "/**", " * USER COLLECTIONS", " **/");
+  }
+  for (const collection of config.collections) {
+    const authCollection = authCollectionMap.get(collection.slug);
+    const fields = [];
+    const indexes = collectIndexes({ collection });
+    const searchIndexes = collectSearchIndexes({
+      collection
+    });
+    if (authCollection) {
+      mergedAuthSlugs.add(authCollection.slug);
+      const merged = mergeAuthCollectionWithUserCollection({
+        authCollection,
+        userCollection: collection
+      });
+      for (const [name, field] of Object.entries(merged.fields)) {
+        if (field.type === "ui") continue;
+        fields.push({
+          name,
+          valueType: fieldToValueType({
+            field,
+            collectionSlug: collection.slug,
+            fieldName: name
+          })
+        });
+      }
+      for (const index of merged.indexes) {
+        if (indexes.find((ui2) => ui2.name === index.name)) continue;
+        indexes.push(index);
+      }
+      for (const si of merged.searchIndexes) {
+        if (searchIndexes.find((existing) => existing.name === si.name))
+          continue;
+        searchIndexes.push(si);
+      }
+    } else {
+      for (const [fieldName, field] of Object.entries(
+        collection.fields
+      )) {
+        if (field.type === "ui") continue;
+        fields.push({
+          name: fieldName,
+          valueType: fieldToValueType({
+            fieldName,
+            field,
+            collectionSlug: collection.slug
+          })
+        });
+      }
+    }
+    lines.push(
+      "",
+      `export const ${collection.tableName ?? collection.slug} = defineTable({`
+    );
+    for (const f of fields) {
+      lines.push(`  ${f.name}: ${f.valueType},`);
+    }
+    lines.push(`  vex_status: v.optional(v.union(v.literal("draft"), v.literal("published"))),`);
+    if (collection.versions?.drafts) {
+      lines.push(`  vex_version: v.optional(v.number()),`);
+      lines.push(`  vex_publishedAt: v.optional(v.number()),`);
+    }
+    lines.push("})");
+    for (const i of indexes) {
+      const fieldList = i.fields.map((f) => `"${f}"`).join(", ");
+      lines.push(`  .index("${i.name}", [${fieldList}])`);
+    }
+    for (const si of searchIndexes) {
+      const filterList = si.filterFields.length > 0 ? `, filterFields: [${si.filterFields.map((f) => `"${f}"`).join(", ")}]` : "";
+      lines.push(
+        `  .searchIndex("${si.name}", { searchField: "${si.searchField}"${filterList} })`
+      );
+    }
+  }
+  if (config.media && config.media.collections.length > 0) {
+    lines.push("", "/**", " * MEDIA COLLECTIONS", " **/");
+    for (const mediaCollection of config.media.collections) {
+      const fields = [];
+      const indexes = collectIndexes({ collection: mediaCollection });
+      const searchIndexes = collectSearchIndexes({
+        collection: mediaCollection
+      });
+      for (const [fieldName, field] of Object.entries(
+        mediaCollection.fields
+      )) {
+        if (field.type === "ui") continue;
+        if (fieldName === "storageId") {
+          fields.push({
+            name: fieldName,
+            valueType: config.media.storageAdapter.storageIdValueType
+          });
+        } else {
+          fields.push({
+            name: fieldName,
+            valueType: fieldToValueType({
+              fieldName,
+              field,
+              collectionSlug: mediaCollection.slug
+            })
+          });
+        }
+      }
+      lines.push(
+        "",
+        `export const ${mediaCollection.tableName ?? mediaCollection.slug} = defineTable({`
+      );
+      for (const f of fields) {
+        lines.push(`  ${f.name}: ${f.valueType},`);
+      }
+      lines.push("})");
+      for (const i of indexes) {
+        const fieldList = i.fields.map((f) => `"${f}"`).join(", ");
+        lines.push(`  .index("${i.name}", [${fieldList}])`);
+      }
+      for (const si of searchIndexes) {
+        const filterList = si.filterFields.length > 0 ? `, filterFields: [${si.filterFields.map((f) => `"${f}"`).join(", ")}]` : "";
+        lines.push(
+          `  .searchIndex("${si.name}", { searchField: "${si.searchField}"${filterList} })`
+        );
+      }
+    }
+  }
+  const unmergedAuthCollections = config.auth.collections.filter(
+    (c) => !mergedAuthSlugs.has(c.slug)
+  );
+  if (unmergedAuthCollections.length > 0) {
+    lines.push("", "/**", " * AUTH TABLES", " **/");
+  }
+  for (const authCollection of unmergedAuthCollections) {
+    const indexes = collectIndexes({
+      collection: authCollection
+    });
+    lines.push(
+      "",
+      `export const ${authCollection.tableName ?? authCollection.slug} = defineTable({`
+    );
+    for (const [name, field] of Object.entries(authCollection.fields)) {
+      lines.push(
+        `  ${name}: ${fieldToValueType({
+          field,
+          collectionSlug: authCollection.slug,
+          fieldName: name
+        })},`
+      );
+    }
+    lines.push("})");
+    for (const i of indexes) {
+      const fieldList = i.fields.map((f) => `"${f}"`).join(", ");
+      lines.push(`  .index("${i.name}", [${fieldList}])`);
+    }
+  }
+  for (const global of config.globals) {
+    const fields = [];
+    const indexes = collectIndexes({ collection: global });
+    for (const [fieldName, field] of Object.entries(global.fields)) {
+      fields.push({
+        name: fieldName,
+        valueType: fieldToValueType({
+          fieldName,
+          field,
+          collectionSlug: global.slug
+        })
+      });
+    }
+    lines.push(
+      "",
+      `export const ${global.tableName ?? global.slug} = defineTable({`
+    );
+    for (const f of fields) {
+      lines.push(`  ${f.name}: ${f.valueType},`);
+    }
+    lines.push("})");
+    for (const i of indexes) {
+      const fieldList = i.fields.map((f) => `"${f}"`).join(", ");
+      lines.push(`  .index("${i.name}", [${fieldList}])`);
+    }
+  }
+  {
+    lines.push("", "/**", " * VEX SYSTEM TABLES", " **/");
+    lines.push("");
+    lines.push("export const vex_versions = defineTable({");
+    lines.push("  collection: v.string(),");
+    lines.push("  documentId: v.string(),");
+    lines.push("  version: v.number(),");
+    lines.push(`  status: v.union(v.literal("draft"), v.literal("published"), v.literal("autosave"), v.literal("previewSnapshot")),`);
+    lines.push("  snapshot: v.any(),");
+    lines.push("  createdAt: v.number(),");
+    lines.push("  createdBy: v.optional(v.string()),");
+    lines.push("  isAutosave: v.boolean(),");
+    lines.push("  restoredFrom: v.optional(v.number()),");
+    lines.push("})");
+    lines.push(`  .index("by_document", ["collection", "documentId"])`);
+    lines.push(`  .index("by_document_version", ["collection", "documentId", "version"])`);
+    lines.push(`  .index("by_document_latest", ["collection", "documentId", "createdAt"])`);
+    lines.push(`  .index("by_document_status", ["collection", "documentId", "status"])`);
+    lines.push(`  .index("by_autosave", ["collection", "documentId", "isAutosave"])`);
+  }
+  return lines.join("\n") + "\n";
+}
+
+// src/schema/extendTable.ts
+import { defineTable } from "convex/server";
+function extendTable(props) {
+  const { validator } = props.table;
+  let extended = defineTable({
+    ...validator.fields,
+    ...props.additionalFields
+  });
+  for (const idx of props.table[" indexes"]()) {
+    extended = extended.index(
+      idx.indexDescriptor,
+      idx.fields
+    );
+  }
+  const source = props.table;
+  for (const idx of source.searchIndexes ?? []) {
+    extended = extended.searchIndex(idx.indexDescriptor, {
+      searchField: idx.searchField,
+      filterFields: idx.filterFields
+    });
+  }
+  for (const idx of source.vectorIndexes ?? []) {
+    extended = extended.vectorIndex(idx.indexDescriptor, {
+      vectorField: idx.vectorField,
+      dimensions: idx.dimensions,
+      filterFields: idx.filterFields
+    });
+  }
+  return extended;
+}
+
+// src/fields/media/columnDef.ts
+function uploadColumnDef(props) {
+  return {
+    accessorKey: props.fieldKey,
+    header: (props.field.hasMany ? props.field.labels?.singular : props.field.label) ?? toTitleCase(props.fieldKey),
+    meta: {
+      type: "upload",
+      to: props.field.to,
+      noTruncate: true
+    },
+    cell: (info) => {
+      const value = info.getValue();
+      if (!value || typeof value !== "string") return "";
+      return value;
+    }
+  };
+}
+
+// src/columns/generateColumns.ts
+function generateColumns(props) {
+  const { collection, auth } = props;
+  const columns = [];
+  const useAsTitle = collection.admin?.useAsTitle;
+  const defaultColumns = collection.admin?.defaultColumns;
+  const fields = collection.fields;
+  const authFields = {};
+  if (auth) {
+    const authCollection = auth.collections.find(
+      (c) => c.slug === collection.slug
+    );
+    if (authCollection) {
+      for (const [k, v2] of Object.entries(authCollection.fields)) {
+        authFields[k] = v2;
+      }
+    }
+  }
+  if (defaultColumns) {
+    for (const fieldKey of defaultColumns) {
+      if (fieldKey === "_id") {
+        columns.push({ accessorKey: "_id", header: "ID" });
+        continue;
+      }
+      const field = fields[fieldKey] ?? authFields[fieldKey];
+      if (!field) {
+        columns.push({ accessorKey: fieldKey, header: toTitleCase(fieldKey) });
+        continue;
+      }
+      if (field.admin?.hidden) continue;
+      if (field.type === "ui") continue;
+      const col = buildColumnDef(fieldKey, field);
+      if (useAsTitle && fieldKey === useAsTitle) {
+        col.meta = { ...col.meta, isTitle: true };
+      }
+      if (field.admin?.components?.Cell) {
+        col.meta = {
+          ...col.meta,
+          customCell: field.admin.components.Cell,
+          fieldDef: field
+        };
+      }
+      columns.push(col);
+    }
+  } else {
+    columns.push({ accessorKey: "_id", header: "ID" });
+    const allFieldKeys = new Set(Object.keys(fields));
+    for (const k of Object.keys(authFields)) {
+      allFieldKeys.add(k);
+    }
+    for (const fieldKey of allFieldKeys) {
+      const field = fields[fieldKey] ?? authFields[fieldKey];
+      if (field.admin?.hidden) continue;
+      if (field.type === "ui") continue;
+      const col = buildColumnDef(fieldKey, field);
+      if (useAsTitle && fieldKey === useAsTitle) {
+        col.meta = { ...col.meta, isTitle: true };
+      }
+      if (field.admin?.components?.Cell) {
+        col.meta = {
+          ...col.meta,
+          customCell: field.admin.components.Cell,
+          fieldDef: field
+        };
+      }
+      columns.push(col);
+    }
+  }
+  return columns;
+}
+function buildColumnDef(fieldKey, field) {
+  switch (field.type) {
+    case "text":
+      return textColumnDef({ fieldKey, field });
+    case "number":
+      return numberColumnDef({ fieldKey, field });
+    case "checkbox":
+      return checkboxColumnDef({ fieldKey, field });
+    case "select":
+      return selectColumnDef({ fieldKey, field });
+    case "date":
+      return dateColumnDef({ fieldKey, field });
+    case "imageUrl":
+      return imageUrlColumnDef({ fieldKey, field });
+    case "relationship":
+      return relationshipColumnDef({ fieldKey, field });
+    case "json":
+      return jsonColumnDef({ fieldKey, field });
+    case "richtext":
+      return richtextColumnDef({ fieldKey, field });
+    case "array":
+      return arrayColumnDef({ fieldKey, field });
+    case "upload":
+      return uploadColumnDef({ fieldKey, field });
+    case "blocks":
+      return blocksColumnDef({ fieldKey, field });
+    default:
+      return {
+        accessorKey: fieldKey,
+        header: toTitleCase(fieldKey)
+      };
+  }
+}
+
+// src/formSchema/generateFormSchema.ts
+import { z } from "zod";
+function generateFormSchema(props) {
+  const shape = {};
+  for (const [fieldName, field] of Object.entries(props.fields)) {
+    if (field.admin?.hidden) continue;
+    if (field.type === "ui") continue;
+    let validator = fieldMetaToZod({ field });
+    if (!field.required) {
+      validator = validator.optional();
+    }
+    shape[fieldName] = validator;
+  }
+  return z.object(shape);
+}
+function fieldMetaToZod(props) {
+  switch (props.field.type) {
+    case "text": {
+      let schema = z.string();
+      if (props.field.minLength != null) schema = schema.min(props.field.minLength);
+      if (props.field.maxLength != null) schema = schema.max(props.field.maxLength);
+      return schema;
+    }
+    case "number": {
+      let schema = z.number();
+      if (props.field.min != null) schema = schema.min(props.field.min);
+      if (props.field.max != null) schema = schema.max(props.field.max);
+      return schema;
+    }
+    case "checkbox":
+      return z.boolean();
+    case "select": {
+      const values = props.field.options.map((o) => o.value);
+      if (values.length === 0) return z.string();
+      const enumSchema = z.enum(values);
+      if (props.field.hasMany) {
+        return z.array(enumSchema);
+      }
+      return enumSchema;
+    }
+    case "date":
+      return z.number();
+    case "imageUrl":
+      return z.string().url().or(z.literal(""));
+    case "relationship": {
+      if (props.field.hasMany) {
+        return z.array(z.string());
+      }
+      return z.string();
+    }
+    case "upload": {
+      if (props.field.hasMany) {
+        return z.array(z.string());
+      }
+      return z.string();
+    }
+    case "json":
+      return z.any();
+    case "richtext":
+      return z.any();
+    case "array": {
+      let schema = z.array(fieldMetaToZod({ field: props.field.field }));
+      if (props.field.min != null) schema = schema.min(props.field.min);
+      if (props.field.max != null) schema = schema.max(props.field.max);
+      return schema;
+    }
+    case "blocks": {
+      const blockSchemas = props.field.blocks.map((blockDef) => {
+        const shape = {
+          blockType: z.literal(blockDef.slug),
+          blockName: z.string().optional(),
+          _key: z.string()
+        };
+        for (const [fieldName, field] of Object.entries(blockDef.fields)) {
+          let validator = fieldMetaToZod({ field });
+          if (!field.required) {
+            validator = validator.optional();
+          }
+          shape[fieldName] = validator;
+        }
+        return z.object(shape);
+      });
+      if (blockSchemas.length === 0) {
+        let schema2 = z.array(z.any());
+        if (props.field.min != null) schema2 = schema2.min(props.field.min);
+        if (props.field.max != null) schema2 = schema2.max(props.field.max);
+        return schema2;
+      }
+      const union = blockSchemas.length === 1 ? blockSchemas[0] : z.discriminatedUnion(
+        "blockType",
+        blockSchemas
+      );
+      let schema = z.array(union);
+      if (props.field.min != null) schema = schema.min(props.field.min);
+      if (props.field.max != null) schema = schema.max(props.field.max);
+      return schema;
+    }
+    default:
+      return z.any();
+  }
+}
+
+// src/formSchema/generateFormDefaultValues.ts
+function getFormDefaultValue(props) {
+  switch (props.field.type) {
+    case "text":
+      return props.field.defaultValue ?? "";
+    case "number":
+      return props.field.defaultValue ?? 0;
+    case "checkbox":
+      return props.field.defaultValue ?? false;
+    case "select":
+      if (props.field.hasMany) {
+        return props.field.defaultValue ? [props.field.defaultValue] : [];
+      }
+      return props.field.defaultValue ?? "";
+    case "date":
+      return props.field.defaultValue ?? 0;
+    case "imageUrl":
+      return props.field.defaultValue ?? "";
+    case "relationship":
+      return props.field.hasMany ? [] : "";
+    case "upload":
+      return props.field.hasMany ? [] : "";
+    case "json":
+      return {};
+    case "richtext":
+      return [];
+    case "array":
+      return [];
+    case "blocks":
+      return [];
+    case "ui":
+      return void 0;
+    default:
+      return void 0;
+  }
+}
+function generateFormDefaultValues(props) {
+  const result = {};
+  for (const [fieldName, field] of Object.entries(props.fields)) {
+    if (field.admin?.hidden) continue;
+    if (field.type === "ui") continue;
+    result[fieldName] = getFormDefaultValue({ field });
+  }
+  return result;
+}
+
+// src/fields/ui/config.ts
+function ui(props) {
+  return {
+    type: "ui",
+    label: props.label,
+    description: props.description,
+    admin: props.admin
+  };
+}
+
+// src/types/fields.ts
+var RESERVED_BLOCK_FIELD_NAMES = ["blockType", "blockName", "_key"];
+
+// src/blocks/defineBlock.ts
+function defineBlock(props) {
+  if (!props.slug || !/^[a-zA-Z][a-zA-Z0-9_-]*$/.test(props.slug)) {
+    throw new VexBlockValidationError(
+      props.slug || "(empty)",
+      `Invalid block slug "${props.slug}". Slugs must start with a letter and contain only letters, numbers, hyphens, and underscores.`
+    );
+  }
+  for (const fieldName of Object.keys(props.fields)) {
+    if (RESERVED_BLOCK_FIELD_NAMES.includes(fieldName)) {
+      throw new VexBlockValidationError(
+        props.slug,
+        `Field name "${fieldName}" is reserved in block definitions. Reserved names: ${RESERVED_BLOCK_FIELD_NAMES.join(", ")}`
+      );
+    }
+  }
+  return {
+    slug: props.slug,
+    label: props.label,
+    fields: props.fields,
+    admin: props.admin,
+    interfaceName: props.interfaceName
+  };
+}
+
+// src/typeGen/slugToInterfaceName.ts
+function slugToInterfaceName(props) {
+  return props.slug.replace(/[-_]+/g, " ").replace(/([a-z])([A-Z])/g, "$1 $2").split(/\s+/).filter(Boolean).map((seg) => seg.charAt(0).toUpperCase() + seg.slice(1).toLowerCase()).join("");
+}
+
+// src/typeGen/fieldToTypeString.ts
+function fieldToTypeString(props) {
+  switch (props.field.type) {
+    case "text":
+      return "string";
+    case "number":
+      return "number";
+    case "checkbox":
+      return "boolean";
+    case "date":
+      return "number";
+    case "imageUrl":
+      return "string";
+    case "json":
+      return "Record<string, unknown>";
+    case "richtext":
+      return "any";
+    case "ui":
+      return "never";
+    case "select": {
+      const values = props.field.options.map((o) => o.value);
+      if (values.length === 0) return "string";
+      const union = values.map((v2) => `'${v2}'`).join(" | ");
+      if (props.field.hasMany) {
+        return `(${union})[]`;
+      }
+      return union;
+    }
+    case "relationship": {
+      const idType = `Id<'${props.field.to}'>`;
+      return props.field.hasMany ? `${idType}[]` : idType;
+    }
+    case "upload": {
+      const idType = `Id<'${props.field.to}'>`;
+      return props.field.hasMany ? `${idType}[]` : idType;
+    }
+    case "array": {
+      const inner = fieldToTypeString({
+        field: props.field.field,
+        blockInterfaceNames: props.blockInterfaceNames
+      });
+      const needsParens = inner.includes("|");
+      return needsParens ? `(${inner})[]` : `${inner}[]`;
+    }
+    case "blocks": {
+      const names = props.field.blocks.map((b) => {
+        if (props.blockInterfaceNames?.has(b.slug)) {
+          return props.blockInterfaceNames.get(b.slug);
+        }
+        return b.interfaceName ?? slugToInterfaceName({ slug: b.slug });
+      });
+      if (names.length === 0) return "unknown[]";
+      if (names.length === 1) return `${names[0]}[]`;
+      return `(${names.join(" | ")})[]`;
+    }
+    default:
+      return "unknown";
+  }
+}
+
+// src/typeGen/generateVexTypes.ts
+function generateVexTypes(props) {
+  const config = props.config;
+  const parts = [];
+  const blocksBySlug = /* @__PURE__ */ new Map();
+  const blockInterfaceNames = /* @__PURE__ */ new Map();
+  function collectBlocks(fields) {
+    for (const field of Object.values(fields)) {
+      if (field.type === "blocks") {
+        for (const block of field.blocks) {
+          if (!blocksBySlug.has(block.slug)) {
+            blocksBySlug.set(block.slug, block);
+            collectBlocks(block.fields);
+          }
+        }
+      }
+    }
+  }
+  for (const col of config.collections) {
+    collectBlocks(col.fields);
+  }
+  if (config.media?.collections) {
+    for (const col of config.media.collections) {
+      collectBlocks(col.fields);
+    }
+  }
+  for (const g of config.globals) {
+    collectBlocks(g.fields);
+  }
+  for (const [slug, block] of blocksBySlug) {
+    blockInterfaceNames.set(
+      slug,
+      block.interfaceName ?? slugToInterfaceName({ slug })
+    );
+  }
+  const allNames = /* @__PURE__ */ new Map();
+  function registerName(name, source) {
+    if (allNames.has(name)) {
+      throw new VexError(
+        `Duplicate interface name "${name}" \u2014 used by ${allNames.get(name)} and ${source}. Set a unique \`interfaceName\` on one of them.`
+      );
+    }
+    allNames.set(name, source);
+  }
+  const collectionNames = /* @__PURE__ */ new Map();
+  for (const col of config.collections) {
+    const name = col.interfaceName ?? slugToInterfaceName({ slug: col.slug });
+    registerName(name, `collection "${col.slug}"`);
+    collectionNames.set(col.slug, name);
+  }
+  if (config.media?.collections) {
+    for (const col of config.media.collections) {
+      const name = col.interfaceName ?? slugToInterfaceName({ slug: col.slug });
+      registerName(name, `media collection "${col.slug}"`);
+      collectionNames.set(col.slug, name);
+    }
+  }
+  const authCollectionMap = new Map(
+    config.auth.collections.map((c) => [c.slug, c])
+  );
+  const userCollectionSlugs = new Set(config.collections.map((c) => c.slug));
+  const mediaSlugs = new Set(
+    (config.media?.collections ?? []).map((c) => c.slug)
+  );
+  for (const authCol of config.auth.collections) {
+    if (!userCollectionSlugs.has(authCol.slug) && !mediaSlugs.has(authCol.slug)) {
+      const name = authCol.interfaceName ?? slugToInterfaceName({ slug: authCol.slug });
+      registerName(name, `auth collection "${authCol.slug}"`);
+      collectionNames.set(authCol.slug, name);
+    }
+  }
+  const globalNames = /* @__PURE__ */ new Map();
+  for (const g of config.globals) {
+    const name = g.interfaceName ?? slugToInterfaceName({ slug: g.slug });
+    registerName(name, `global "${g.slug}"`);
+    globalNames.set(g.slug, name);
+  }
+  for (const [slug, name] of blockInterfaceNames) {
+    registerName(name, `block "${slug}"`);
+  }
+  let needsIdImport = false;
+  function checkForIdFields(fields) {
+    for (const field of Object.values(fields)) {
+      if (field.type === "relationship" || field.type === "upload") {
+        needsIdImport = true;
+      }
+    }
+  }
+  for (const col of config.collections) {
+    checkForIdFields(col.fields);
+  }
+  if (config.media?.collections) {
+    for (const col of config.media.collections) {
+      checkForIdFields(col.fields);
+    }
+  }
+  for (const g of config.globals) {
+    checkForIdFields(g.fields);
+  }
+  for (const block of blocksBySlug.values()) {
+    checkForIdFields(block.fields);
+  }
+  if (config.collections.length > 0 || (config.media?.collections?.length ?? 0) > 0 || config.globals.length > 0) {
+    needsIdImport = true;
+  }
+  parts.push("// \u26A0\uFE0F AUTO-GENERATED BY VEX CMS \u2014 DO NOT EDIT \u26A0\uFE0F");
+  parts.push("");
+  if (needsIdImport) {
+    parts.push("import type { Id } from './_generated/dataModel';");
+    parts.push("");
+  }
+  const sortedBlockSlugs = [...blocksBySlug.keys()].sort();
+  for (const slug of sortedBlockSlugs) {
+    const block = blocksBySlug.get(slug);
+    const name = blockInterfaceNames.get(slug);
+    parts.push(generateBlockInterface({ block, name, blockInterfaceNames }));
+    parts.push("");
+  }
+  for (const col of config.collections) {
+    const name = collectionNames.get(col.slug);
+    const authCol = authCollectionMap.get(col.slug);
+    let fields;
+    if (authCol) {
+      const merged = mergeAuthCollectionWithUserCollection({
+        authCollection: authCol,
+        userCollection: col
+      });
+      fields = merged.fields;
+    } else {
+      fields = col.fields;
+    }
+    const isVersioned = !!col.versions?.drafts;
+    parts.push(
+      generateCollectionInterface({
+        name,
+        slug: col.slug,
+        fields,
+        isVersioned,
+        blockInterfaceNames
+      })
+    );
+    parts.push("");
+  }
+  for (const authCol of config.auth.collections) {
+    if (userCollectionSlugs.has(authCol.slug) || mediaSlugs.has(authCol.slug)) continue;
+    const name = collectionNames.get(authCol.slug);
+    parts.push(
+      generateCollectionInterface({
+        name,
+        slug: authCol.slug,
+        fields: authCol.fields,
+        isVersioned: false,
+        blockInterfaceNames
+      })
+    );
+    parts.push("");
+  }
+  if (config.media?.collections) {
+    for (const col of config.media.collections) {
+      const name = collectionNames.get(col.slug);
+      parts.push(
+        generateMediaCollectionInterface({
+          name,
+          slug: col.slug,
+          userFields: col.fields,
+          blockInterfaceNames
+        })
+      );
+      parts.push("");
+    }
+  }
+  for (const g of config.globals) {
+    const name = globalNames.get(g.slug);
+    parts.push(
+      generateGlobalInterface({
+        name,
+        slug: g.slug,
+        fields: g.fields,
+        blockInterfaceNames
+      })
+    );
+    parts.push("");
+  }
+  if (collectionNames.size > 0) {
+    const entries = [...collectionNames.entries()].sort(([a], [b]) => a.localeCompare(b)).map(([slug, name]) => `  ${slug}: ${name};`).join("\n");
+    parts.push(`export interface VexCollectionTypes {
+${entries}
+}`);
+    parts.push("");
+  }
+  if (globalNames.size > 0) {
+    const entries = [...globalNames.entries()].sort(([a], [b]) => a.localeCompare(b)).map(([slug, name]) => `  ${slug}: ${name};`).join("\n");
+    parts.push(`export interface VexGlobalTypes {
+${entries}
+}`);
+    parts.push("");
+  }
+  return parts.join("\n");
+}
+function generateBlockInterface(props) {
+  const lines = [];
+  lines.push(`export interface ${props.name} {`);
+  lines.push(`  blockType: '${props.block.slug}';`);
+  lines.push(`  blockName?: string;`);
+  lines.push(`  _key: string;`);
+  for (const [fieldName, field] of Object.entries(props.block.fields)) {
+    const f = field;
+    if (f.type === "ui") continue;
+    const label = f.label;
+    if (label) lines.push(`  /** ${label} */`);
+    const optional = f.required ? "" : "?";
+    const typeStr = fieldToTypeString({
+      field: f,
+      blockInterfaceNames: props.blockInterfaceNames
+    });
+    lines.push(`  ${fieldName}${optional}: ${typeStr};`);
+  }
+  lines.push("}");
+  return lines.join("\n");
+}
+function generateCollectionInterface(props) {
+  const lines = [];
+  lines.push(`export interface ${props.name} {`);
+  lines.push(`  _id: Id<'${props.slug}'>;`);
+  lines.push(`  _creationTime: number;`);
+  if (props.isVersioned) {
+    lines.push(`  vex_status?: 'draft' | 'published';`);
+    lines.push(`  vex_version?: number;`);
+    lines.push(`  vex_publishedAt?: number;`);
+  }
+  for (const [fieldName, field] of Object.entries(props.fields)) {
+    const f = field;
+    if (f.type === "ui") continue;
+    const label = f.label;
+    if (label) lines.push(`  /** ${label} */`);
+    const optional = f.required ? "" : "?";
+    const typeStr = fieldToTypeString({
+      field: f,
+      blockInterfaceNames: props.blockInterfaceNames
+    });
+    lines.push(`  ${fieldName}${optional}: ${typeStr};`);
+  }
+  lines.push("}");
+  return lines.join("\n");
+}
+function generateMediaCollectionInterface(props) {
+  const lines = [];
+  lines.push(`export interface ${props.name} {`);
+  lines.push(`  _id: Id<'${props.slug}'>;`);
+  lines.push(`  _creationTime: number;`);
+  lines.push(`  storageId: string;`);
+  lines.push(`  filename: string;`);
+  lines.push(`  mimeType: string;`);
+  lines.push(`  size: number;`);
+  lines.push(`  url?: string;`);
+  lines.push(`  width?: number;`);
+  lines.push(`  height?: number;`);
+  const lockedSet = /* @__PURE__ */ new Set([...LOCKED_MEDIA_FIELDS, ...OVERRIDABLE_MEDIA_FIELDS]);
+  for (const [fieldName, field] of Object.entries(props.userFields)) {
+    if (lockedSet.has(fieldName)) continue;
+    const f = field;
+    if (f.type === "ui") continue;
+    const label = f.label;
+    if (label) lines.push(`  /** ${label} */`);
+    const optional = f.required ? "" : "?";
+    const typeStr = fieldToTypeString({
+      field: f,
+      blockInterfaceNames: props.blockInterfaceNames
+    });
+    lines.push(`  ${fieldName}${optional}: ${typeStr};`);
+  }
+  lines.push("}");
+  return lines.join("\n");
+}
+function generateGlobalInterface(props) {
+  const lines = [];
+  lines.push(`export interface ${props.name} {`);
+  lines.push(`  _id: Id<'vex_globals'>;`);
+  lines.push(`  _creationTime: number;`);
+  lines.push(`  vexGlobalSlug: '${props.slug}';`);
+  for (const [fieldName, field] of Object.entries(props.fields)) {
+    const f = field;
+    if (f.type === "ui") continue;
+    const label = f.label;
+    if (label) lines.push(`  /** ${label} */`);
+    const optional = f.required ? "" : "?";
+    const typeStr = fieldToTypeString({
+      field: f,
+      blockInterfaceNames: props.blockInterfaceNames
+    });
+    lines.push(`  ${fieldName}${optional}: ${typeStr};`);
+  }
+  lines.push("}");
+  return lines.join("\n");
+}
+
+// src/versioning/constants.ts
+var VERSION_SYSTEM_FIELDS = [
+  "vex_status",
+  "vex_version",
+  "vex_publishedAt"
+];
+var ALL_SYSTEM_FIELDS = /* @__PURE__ */ new Set([
+  "_id",
+  "_creationTime",
+  ...VERSION_SYSTEM_FIELDS
+]);
+var DEFAULT_MAX_VERSIONS_PER_DOC = 100;
+var DEFAULT_AUTOSAVE_INTERVAL = 2e3;
+
+// src/versioning/extractUserFields.ts
+function extractUserFields(props) {
+  const result = {};
+  for (const [key, value] of Object.entries(props.document)) {
+    if (!ALL_SYSTEM_FIELDS.has(key)) {
+      result[key] = value;
+    }
+  }
+  return result;
+}
+
+// src/livePreview/resolvePreviewURL.ts
+function resolvePreviewURL(props) {
+  if (typeof props.config.url === "string") {
+    return props.config.url;
+  }
+  try {
+    const result = props.config.url(props.doc);
+    if (!result) {
+      throw new Error(
+        `Live preview URL resolved to empty string for document ${props.doc._id}`
+      );
+    }
+    return result;
+  } catch (error) {
+    if (props.fallbackURL !== void 0) {
+      return props.fallbackURL;
+    }
+    throw error;
+  }
+}
+
+// src/livePreview/shouldReloadURL.ts
+function shouldReloadURL(props) {
+  if (props.config.reloadOnFields === void 0) {
+    return true;
+  }
+  if (props.config.reloadOnFields.length === 0) {
+    return false;
+  }
+  return props.changedFields.some(
+    (field) => props.config.reloadOnFields.includes(field)
+  );
+}
+
+// src/livePreview/constants.ts
+var DEFAULT_BREAKPOINTS = [
+  { label: "Mobile", width: 375, height: 667, icon: "smartphone" },
+  { label: "Tablet", width: 768, height: 1024, icon: "tablet" },
+  { label: "Laptop", width: 1280, height: 800, icon: "laptop" },
+  { label: "Desktop", width: 1920, height: 1080, icon: "monitor" }
+];
+var PREVIEW_SNAPSHOT_DEBOUNCE_MS = 500;
+
+// src/convex/previewSnapshot.ts
+async function upsertPreviewSnapshot(props) {
+  const existing = await props.ctx.db.query("vex_versions").withIndex(
+    "by_document_status",
+    (q) => q.eq("collection", props.collection).eq("documentId", props.documentId).eq("status", "previewSnapshot")
+  ).first();
+  if (existing) {
+    await props.ctx.db.patch(existing._id, {
+      snapshot: props.snapshot,
+      createdAt: Date.now()
+    });
+  } else {
+    await props.ctx.db.insert("vex_versions", {
+      collection: props.collection,
+      documentId: props.documentId,
+      version: 0,
+      status: "previewSnapshot",
+      snapshot: props.snapshot,
+      createdAt: Date.now(),
+      createdBy: void 0,
+      isAutosave: false,
+      restoredFrom: void 0
+    });
+  }
+}
+async function deletePreviewSnapshot(props) {
+  const entries = await props.ctx.db.query("vex_versions").withIndex(
+    "by_document_status",
+    (q) => q.eq("collection", props.collection).eq("documentId", props.documentId).eq("status", "previewSnapshot")
+  ).collect();
+  for (const entry of entries) {
+    await props.ctx.db.delete(entry._id);
+  }
+}
+async function getPreviewSnapshot(props) {
+  const entry = await props.ctx.db.query("vex_versions").withIndex(
+    "by_document_status",
+    (q) => q.eq("collection", props.collection).eq("documentId", props.documentId).eq("status", "previewSnapshot")
+  ).first();
+  if (!entry) return null;
+  return entry.snapshot;
+}
+
+// src/convex/vexQuery.ts
+import {
+  queryGeneric
+} from "convex/server";
+import { v } from "convex/values";
+function vexQuery(props) {
+  const mergedArgs = {
+    ...props.args,
+    _vexDrafts: v.optional(v.union(v.literal("snapshot"), v.boolean()))
+  };
+  return queryGeneric({
+    args: mergedArgs,
+    handler: async (ctx, args) => {
+      const { _vexDrafts, ...userArgs } = args;
+      const drafts = _vexDrafts !== void 0 ? _vexDrafts : "snapshot";
+      const vexCtx = Object.assign(Object.create(Object.getPrototypeOf(ctx)), ctx, {
+        drafts
+      });
+      return props.handler(vexCtx, userArgs);
+    }
+  });
+}
+
+// src/convex/model/collections.ts
+import { ConvexError } from "convex/values";
+async function resolveStorageUrl(ctx, doc) {
+  if (doc?.storageId && (!doc.url || doc.url === "")) {
+    const url = await ctx.storage.getUrl(doc.storageId);
+    if (url) return { ...doc, url };
+  }
+  return doc;
+}
+async function listDocuments(props) {
+  const { args, ctx } = props;
+  const q = args.order === "desc" ? ctx.db.query(args.collectionSlug).order("desc") : ctx.db.query(args.collectionSlug);
+  const result = await q.paginate(args.paginationOpts);
+  const resolvedPage = await Promise.all(
+    result.page.map((doc) => resolveStorageUrl(ctx, doc))
+  );
+  return { ...result, page: resolvedPage };
+}
+async function getDocument(props) {
+  const doc = await props.ctx.db.get(props.args.documentId);
+  if (!doc) return null;
+  const resolved = await resolveStorageUrl(props.ctx, doc);
+  if (props.args.preview) {
+    const snapshot = await getPreviewSnapshot({
+      ctx: props.ctx,
+      collection: props.args.collectionSlug,
+      documentId: props.args.documentId
+    });
+    if (snapshot) {
+      return { ...resolved, ...snapshot };
+    }
+  }
+  return resolved;
+}
+async function updateDocument(props) {
+  const f = { ...props.args.fields };
+  if (f.storageId && f.url === "") {
+    const url = await props.ctx.storage.getUrl(f.storageId);
+    if (url) f.url = url;
+  }
+  const schema = generateFormSchema({
+    fields: props.args.collectionFields
+  }).partial();
+  const result = schema.safeParse(f);
+  if (!result.success) {
+    throw new ConvexError({
+      message: "Validation failed",
+      errors: result.error.flatten()
+    });
+  }
+  await props.ctx.db.patch(props.args.documentId, result.data);
+  return props.args.documentId;
+}
+async function createDocument(props) {
+  if (props.args.kind === "global") {
+    const existing = await props.ctx.db.query(props.args.collectionSlug).first();
+    if (existing) {
+      throw new ConvexError(
+        `Global "${props.args.collectionSlug}" already exists. Globals can only have one document.`
+      );
+    }
+  }
+  const schema = generateFormSchema({
+    fields: props.args.collectionFields
+  });
+  const result = schema.safeParse(props.args.fields);
+  if (!result.success) {
+    throw new ConvexError({
+      message: "Validation failed",
+      errors: result.error.flatten()
+    });
+  }
+  const id = await props.ctx.db.insert(props.args.collectionSlug, result.data);
+  return id;
+}
+async function deleteDocument(props) {
+  if (props.args.kind === "global") {
+    const existing = await props.ctx.db.get(props.args.documentId);
+    if (!existing) {
+      throw new ConvexError(
+        `Global "${props.args.collectionSlug}" document not found. Cannot delete a non-existent global.`
+      );
+    }
+  }
+  await props.ctx.db.delete(props.args.documentId);
+}
+async function searchDocuments(props) {
+  const { args, ctx } = props;
+  const docs = await ctx.db.query(args.collectionSlug).withSearchIndex(args.searchIndexName, (q) => q.search(args.searchField, args.query)).take(50);
+  return Promise.all(docs.map((doc) => resolveStorageUrl(ctx, doc)));
+}
+
+// src/valueTypes/generateCollectionQueries.ts
+var GENERATED_HEADER = "// \u26A0\uFE0F AUTO-GENERATED BY VEX CMS \u2014 DO NOT EDIT \u26A0\uFE0F";
+function generateCollectionQueries(props) {
+  const { config, imports } = props;
+  const result = {};
+  const slugs = [];
+  for (const collection of config.collections) {
+    const { apiFile, modelFile } = generateCollectionPair({
+      collection,
+      isMedia: false,
+      imports
+    });
+    result[`api/${collection.slug}.ts`] = apiFile;
+    result[`model/api/${collection.slug}.ts`] = modelFile;
+    slugs.push(collection.slug);
+  }
+  if (config.media?.collections) {
+    for (const collection of config.media.collections) {
+      const { apiFile, modelFile } = generateCollectionPair({
+        collection,
+        isMedia: true,
+        imports
+      });
+      result[`api/${collection.slug}.ts`] = apiFile;
+      result[`model/api/${collection.slug}.ts`] = modelFile;
+      slugs.push(collection.slug);
+    }
+  }
+  if (config.auth?.collections) {
+    for (const collection of config.auth.collections) {
+      if (!collection.generateApi) continue;
+      if (slugs.includes(collection.slug)) continue;
+      const { apiFile, modelFile } = generateCollectionPair({
+        collection,
+        isMedia: false,
+        imports
+      });
+      result[`api/${collection.slug}.ts`] = apiFile;
+      result[`model/api/${collection.slug}.ts`] = modelFile;
+      slugs.push(collection.slug);
+    }
+  }
+  result["api/index.ts"] = generateIndexFile({ slugs });
+  return result;
+}
+function generateCollectionPair(props) {
+  const { collection, isMedia, imports } = props;
+  const slug = collection.slug;
+  const tableName = collection.tableName ?? collection.slug;
+  const firstSearchIndex = collection.searchIndexes?.[0] ?? null;
+  const modelFile = generateModelFile({ slug, tableName, isMedia, firstSearchIndex, imports });
+  const apiFile = generateApiFile({ slug, tableName, isMedia, firstSearchIndex, imports });
+  return { apiFile, modelFile };
+}
+function generateModelFile(props) {
+  const { tableName, isMedia, firstSearchIndex, imports } = props;
+  const parts = [];
+  const coreImports = ["getPreviewSnapshot"];
+  if (!isMedia) {
+    coreImports.push("generateFormSchema");
+  }
+  const coreTypeImports = ["CollectionKind"];
+  if (!isMedia) {
+    coreTypeImports.push("VexField");
+  }
+  const coreTypeImportLine = coreTypeImports.length > 0 ? `
+import type { ${coreTypeImports.join(", ")} } from "@vexcms/core"` : "";
+  const convexTypeImports = isMedia ? "" : `
+import type { WithoutSystemFields } from "convex/server"`;
+  parts.push(`${GENERATED_HEADER}
+import type { Doc, Id } from "${imports.generatedDirFromModel}/dataModel"
+import type { QueryCtx, MutationCtx } from "${imports.generatedDirFromModel}/server"${convexTypeImports}
+import { ConvexError } from "convex/values"
+import { ${coreImports.join(", ")} } from "@vexcms/core"${coreTypeImportLine}`);
+  parts.push(buildModelGetDocument({ tableName }));
+  parts.push(buildModelListDocuments({ tableName }));
+  if (!isMedia) {
+    parts.push(buildModelCreateDocument({ tableName }));
+  }
+  if (!isMedia) {
+    parts.push(buildModelUpdateDocument({ tableName }));
+  }
+  parts.push(buildModelDeleteDocument({ tableName }));
+  if (firstSearchIndex) {
+    parts.push(buildModelSearchDocuments({
+      tableName,
+      searchIndexName: firstSearchIndex.name,
+      searchField: firstSearchIndex.searchField
+    }));
+  }
+  return parts.join("\n\n") + "\n";
+}
+function buildModelGetDocument(props) {
+  const { tableName } = props;
+  return `export async function getDocument(props: {
+  ctx: QueryCtx
+  documentId: Id<"${tableName}">
+  preview?: boolean
+}): Promise<Doc<"${tableName}"> | null> {
+  const doc = await props.ctx.db.get(props.documentId)
+  if (!doc) return null
+
+  if (props.preview) {
+    const snapshot = await getPreviewSnapshot({
+      ctx: props.ctx,
+      collection: "${tableName}",
+      documentId: props.documentId,
+    })
+    if (snapshot) {
+      return { ...doc, ...snapshot } as Doc<"${tableName}">
+    }
+  }
+
+  return doc
+}`;
+}
+function buildModelListDocuments(props) {
+  const { tableName } = props;
+  return `export async function listDocuments(props: {
+  ctx: QueryCtx
+  paginationOpts: { numItems: number; cursor: string | null }
+  order?: "asc" | "desc"
+}) {
+  const q = props.order === "desc"
+    ? props.ctx.db.query("${tableName}").order("desc")
+    : props.ctx.db.query("${tableName}")
+  return await q.paginate(props.paginationOpts)
+}`;
+}
+function buildModelCreateDocument(props) {
+  const { tableName } = props;
+  return `export async function createDocument(props: {
+  collectionFields: Record<string, VexField>
+  ctx: MutationCtx
+  fields: unknown
+  kind: CollectionKind
+}): Promise<Id<"${tableName}">> {
+  if (props.kind === "global") {
+    const existing = await props.ctx.db.query("${tableName}").first()
+    if (existing) {
+      throw new ConvexError(\`Global "${tableName}" already exists. Globals can only have one document.\`)
+    }
+  }
+
+  const schema = generateFormSchema({ fields: props.collectionFields })
+  const parsed = schema.safeParse(props.fields)
+  if (!parsed.success) {
+    throw new ConvexError({ message: "Validation failed", errors: parsed.error.flatten() })
+  }
+
+  const data = { ...parsed.data }
+  data.vex_status ??= "published"
+  return await props.ctx.db.insert("${tableName}", data as WithoutSystemFields<Doc<"${tableName}">>)
+}`;
+}
+function buildModelUpdateDocument(props) {
+  const { tableName } = props;
+  return `export async function updateDocument(props: {
+  collectionFields: Record<string, VexField>
+  ctx: MutationCtx
+  documentId: Id<"${tableName}">
+  fields: unknown
+}): Promise<Id<"${tableName}">> {
+  const schema = generateFormSchema({ fields: props.collectionFields }).partial()
+  const parsed = schema.safeParse(props.fields)
+  if (!parsed.success) {
+    throw new ConvexError({ message: "Validation failed", errors: parsed.error.flatten() })
+  }
+
+  await props.ctx.db.patch(props.documentId, parsed.data as Partial<Doc<"${tableName}">>)
+  return props.documentId
+}`;
+}
+function buildModelDeleteDocument(props) {
+  const { tableName } = props;
+  return `export async function deleteDocument(props: {
+  ctx: MutationCtx
+  documentId: Id<"${tableName}">
+  kind: CollectionKind
+}): Promise<void> {
+  if (props.kind === "global") {
+    const existing = await props.ctx.db.get(props.documentId)
+    if (!existing) {
+      throw new ConvexError(\`Global "${tableName}" document not found. Cannot delete a non-existent global.\`)
+    }
+  }
+
+  await props.ctx.db.delete(props.documentId)
+}`;
+}
+function buildModelSearchDocuments(props) {
+  const { tableName, searchIndexName, searchField } = props;
+  return `export async function searchDocuments(props: {
+  ctx: QueryCtx
+  query: string
+}): Promise<Doc<"${tableName}">[]> {
+  return await props.ctx.db.query("${tableName}")
+    .withSearchIndex("${searchIndexName}", (q) => q.search("${searchField}", props.query))
+    .take(50)
+}`;
+}
+function generateApiFile(props) {
+  const { slug, tableName, isMedia, firstSearchIndex, imports } = props;
+  const parts = [];
+  const modelFns = [
+    "getDocument",
+    "listDocuments",
+    ...isMedia ? [] : ["createDocument", "updateDocument"],
+    "deleteDocument",
+    ...firstSearchIndex ? ["searchDocuments"] : []
+  ];
+  parts.push(`${GENERATED_HEADER}
+import { v } from "convex/values"
+import { paginationOptsValidator } from "convex/server"
+import { ConvexError } from "convex/values"
+import { query, mutation } from "${imports.generatedDirFromApi}/server"
+import type { QueryCtx, MutationCtx } from "${imports.generatedDirFromApi}/server"
+import { hasPermission, findCollectionBySlug } from "@vexcms/core"
+import { getUser } from "${imports.authFromApi}"
+import vexConfig from "${imports.vexConfigFromApi}"
+import { ${modelFns.join(", ")} } from "../model/api/${slug}"`);
+  parts.push(`const SLUG = "${slug}" as const
+
+async function requireAuth(ctx: QueryCtx | MutationCtx) {
+  const auth = await getUser(ctx)
+  if (!auth) throw new ConvexError("Not authenticated")
+  return auth
+}`);
+  parts.push(buildApiGetDocument({ tableName }));
+  parts.push(buildApiListDocuments({ tableName }));
+  if (!isMedia) {
+    parts.push(buildApiCreateDocument({ slug, tableName }));
+  }
+  if (!isMedia) {
+    parts.push(buildApiUpdateDocument({ slug, tableName }));
+  }
+  parts.push(buildApiDeleteDocument({ tableName }));
+  if (firstSearchIndex) {
+    parts.push(buildApiSearchDocuments());
+  }
+  return parts.join("\n\n") + "\n";
+}
+function buildApiGetDocument(props) {
+  const { tableName } = props;
+  return `export const get = query({
+  args: {
+    id: v.id("${tableName}"),
+    _vexDrafts: v.optional(v.union(v.literal("snapshot"), v.boolean())),
+  },
+  handler: async (ctx, args) => {
+    const preview = (args._vexDrafts ?? "snapshot") === "snapshot"
+    const doc = await getDocument({
+      ctx,
+      documentId: args.id,
+      preview,
+    })
+    if (!doc) return null
+    const auth = await getUser(ctx)
+    if (auth) {
+      const allowed = hasPermission({
+        access: vexConfig.access,
+        user: auth.user,
+        userRoles: auth.roles,
+        resource: SLUG,
+        action: "read",
+        data: doc,
+      })
+      if (!allowed) return null
+    }
+    return doc
+  },
+})`;
+}
+function buildApiListDocuments(_props) {
+  return `export const list = query({
+  args: {
+    paginationOpts: paginationOptsValidator,
+    order: v.optional(v.union(v.literal("asc"), v.literal("desc"))),
+  },
+  handler: async (ctx, args) => {
+    const result = await listDocuments({
+      ctx,
+      paginationOpts: args.paginationOpts,
+      order: args.order,
+    })
+    const auth = await getUser(ctx)
+    if (!auth) return result
+    const filteredPage = result.page.filter((doc) =>
+      hasPermission({
+        access: vexConfig.access,
+        user: auth.user,
+        userRoles: auth.roles,
+        resource: SLUG,
+        action: "read",
+        data: doc,
+      }) === true,
+    )
+    return { ...result, page: filteredPage }
+  },
+})`;
+}
+function buildApiCreateDocument(_props) {
+  return `export const create = mutation({
+  args: { fields: v.any() },
+  handler: async (ctx, args) => {
+    const { user, roles } = await requireAuth(ctx)
+    hasPermission({
+      access: vexConfig.access,
+      user,
+      userRoles: roles,
+      resource: SLUG,
+      action: "create",
+      throwOnDenied: true,
+    })
+    const collection = findCollectionBySlug({ slug: SLUG, config: vexConfig })
+    if (!collection) throw new ConvexError(\`Collection "\${SLUG}" not found in vex config\`)
+    return createDocument({
+      collectionFields: collection.fields,
+      ctx,
+      fields: args.fields as unknown,
+      kind: "collection",
+    })
+  },
+})`;
+}
+function buildApiUpdateDocument(props) {
+  const { tableName } = props;
+  return `export const update = mutation({
+  args: { id: v.id("${tableName}"), fields: v.any() },
+  handler: async (ctx, args) => {
+    const { user, roles } = await requireAuth(ctx)
+    hasPermission({
+      access: vexConfig.access,
+      user,
+      userRoles: roles,
+      resource: SLUG,
+      action: "update",
+      throwOnDenied: true,
+    })
+    const collection = findCollectionBySlug({ slug: SLUG, config: vexConfig })
+    if (!collection) throw new ConvexError(\`Collection "\${SLUG}" not found in vex config\`)
+    return updateDocument({
+      collectionFields: collection.fields,
+      ctx,
+      documentId: args.id,
+      fields: args.fields,
+    })
+  },
+})`;
+}
+function buildApiDeleteDocument(props) {
+  const { tableName } = props;
+  return `export const remove = mutation({
+  args: { id: v.id("${tableName}") },
+  handler: async (ctx, args) => {
+    const { user, roles } = await requireAuth(ctx)
+    hasPermission({
+      access: vexConfig.access,
+      user,
+      userRoles: roles,
+      resource: SLUG,
+      action: "delete",
+      throwOnDenied: true,
+    })
+    await deleteDocument({
+      ctx,
+      documentId: args.id,
+      kind: "collection",
+    })
+  },
+})`;
+}
+function buildApiSearchDocuments() {
+  return `export const search = query({
+  args: { query: v.string() },
+  handler: async (ctx, args) => {
+    const results = await searchDocuments({
+      ctx,
+      query: args.query,
+    })
+    const auth = await getUser(ctx)
+    if (!auth) return results
+    return results.filter((doc) =>
+      hasPermission({
+        access: vexConfig.access,
+        user: auth.user,
+        userRoles: auth.roles,
+        resource: SLUG,
+        action: "read",
+        data: doc,
+      }) === true,
+    )
+  },
+})`;
+}
+function generateIndexFile(props) {
+  const sorted = [...props.slugs].sort();
+  if (sorted.length === 0) {
+    return GENERATED_HEADER + "\n";
+  }
+  const exports = sorted.map((slug) => `export * as ${slug} from "./${slug}"`).join("\n");
+  return `${GENERATED_HEADER}
+${exports}
+`;
+}
+
+// src/migrations/diffSchema.ts
+function parseTables(schema) {
+  const tables = /* @__PURE__ */ new Map();
+  if (!schema.trim()) return tables;
+  const tableRegex = /export\s+const\s+(\w+)\s*=\s*defineTable\(\{([\s\S]*?)\}\)/g;
+  let match;
+  while ((match = tableRegex.exec(schema)) !== null) {
+    const name = match[1];
+    const body = match[2];
+    const fields = /* @__PURE__ */ new Map();
+    const fieldRegex = /^\s+(\w+):\s+(v\..+?),?\s*$/gm;
+    let fieldMatch;
+    while ((fieldMatch = fieldRegex.exec(body)) !== null) {
+      const fieldName = fieldMatch[1];
+      const valueType = fieldMatch[2].replace(/,\s*$/, "");
+      const isOptional = valueType.startsWith("v.optional(");
+      fields.set(fieldName, { valueType, isOptional });
+    }
+    tables.set(name, { name, fields });
+  }
+  return tables;
+}
+function diffSchema(oldSchema, newSchema) {
+  const oldTables = parseTables(oldSchema);
+  const newTables = parseTables(newSchema);
+  const addedRequired = [];
+  const addedOptional = [];
+  const newRequired = [];
+  const removedFields = [];
+  for (const [tableName, newTable] of newTables) {
+    const oldTable = oldTables.get(tableName);
+    for (const [fieldName, newField] of newTable.fields) {
+      const info = {
+        table: tableName,
+        field: fieldName,
+        valueType: newField.valueType,
+        isOptional: newField.isOptional
+      };
+      if (!oldTable) {
+        if (newField.isOptional) {
+          addedOptional.push(info);
+        } else {
+          addedRequired.push(info);
+        }
+      } else {
+        const oldField = oldTable.fields.get(fieldName);
+        if (!oldField) {
+          if (newField.isOptional) {
+            addedOptional.push(info);
+          } else {
+            addedRequired.push(info);
+          }
+        } else if (oldField.isOptional && !newField.isOptional) {
+          newRequired.push(info);
+        }
+      }
+    }
+  }
+  for (const [tableName, oldTable] of oldTables) {
+    const newTable = newTables.get(tableName);
+    if (!newTable) continue;
+    for (const [fieldName, oldField] of oldTable.fields) {
+      if (!newTable.fields.has(fieldName)) {
+        removedFields.push({
+          table: tableName,
+          field: fieldName,
+          valueType: oldField.valueType,
+          wasOptional: oldField.isOptional
+        });
+      }
+    }
+  }
+  return {
+    addedRequired,
+    addedOptional,
+    newRequired,
+    removedFields,
+    needsMigration: [...addedRequired, ...addedOptional, ...newRequired]
+  };
+}
+function makeFieldsOptional(schema, fields) {
+  let result = schema;
+  for (const field of fields) {
+    if (field.isOptional) continue;
+    const escaped = field.field.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+    const pattern = new RegExp(
+      `(\\s+${escaped}:\\s+)(${field.valueType.replace(/[.*+?^${}()|[\]\\]/g, "\\$&")})(,?)`
+    );
+    result = result.replace(pattern, `$1v.optional($2)$3`);
+  }
+  return result;
+}
+function addRemovedFieldsAsOptional(schema, fields) {
+  let result = schema;
+  const byTable = /* @__PURE__ */ new Map();
+  for (const f of fields) {
+    const list = byTable.get(f.table) ?? [];
+    list.push(f);
+    byTable.set(f.table, list);
+  }
+  for (const [tableName, tableFields] of byTable) {
+    const tablePattern = new RegExp(
+      `(export\\s+const\\s+${tableName}\\s*=\\s*defineTable\\(\\{[\\s\\S]*?)(\\}\\))`
+    );
+    const tableMatch = result.match(tablePattern);
+    if (!tableMatch) continue;
+    const extraLines = tableFields.map((f) => {
+      const optionalType = f.wasOptional ? f.valueType : `v.optional(${f.valueType})`;
+      return `  ${f.field}: ${optionalType},`;
+    });
+    result = result.replace(
+      tablePattern,
+      `$1${extraLines.join("\n")}
+$2`
+    );
+  }
+  return result;
+}
+
+// src/migrations/planMigration.ts
+function planMigration(props) {
+  const { diff, config } = props;
+  if (diff.needsMigration.length === 0) return [];
+  const tableFieldsMap = /* @__PURE__ */ new Map();
+  for (const collection of config.collections) {
+    tableFieldsMap.set(collection.slug, collection.fields);
+  }
+  for (const global of config.globals) {
+    tableFieldsMap.set(global.slug, global.fields);
+  }
+  const ops = [];
+  for (const fieldInfo of diff.needsMigration) {
+    const collectionFields = tableFieldsMap.get(fieldInfo.table);
+    if (!collectionFields) {
+      continue;
+    }
+    const field = collectionFields[fieldInfo.field];
+    if (!field) {
+      continue;
+    }
+    if (!field.required) {
+      continue;
+    }
+    const defaultValue = field.defaultValue;
+    if (defaultValue === void 0) {
+      continue;
+    }
+    ops.push({
+      table: fieldInfo.table,
+      field: fieldInfo.field,
+      defaultValue
+    });
+  }
+  return ops;
+}
+export {
+  ALL_SYSTEM_FIELDS,
+  DEFAULT_AUTOSAVE_INTERVAL,
+  DEFAULT_BREAKPOINTS,
+  DEFAULT_MAX_VERSIONS_PER_DOC,
+  GENERATED_HEADER,
+  LOCKED_MEDIA_FIELDS,
+  OVERRIDABLE_MEDIA_FIELDS,
+  PREVIEW_SNAPSHOT_DEBOUNCE_MS,
+  VERSION_SYSTEM_FIELDS,
+  VexAccessConfigError,
+  VexAccessError,
+  VexAuthConfigError,
+  VexBlockValidationError,
+  VexError,
+  VexFieldValidationError,
+  VexMediaConfigError,
+  VexSlugConflictError,
+  addRemovedFieldsAsOptional,
+  array,
+  blocks,
+  checkbox,
+  createDocument,
+  date,
+  defineAccess,
+  defineBlock,
+  defineCollection,
+  defineConfig,
+  defineMediaCollection,
+  deleteDocument,
+  deletePreviewSnapshot,
+  diffSchema,
+  extendTable,
+  extractLivePreviewConfigs,
+  extractUserFields,
+  fieldMetaToZod,
+  findCollectionBySlug,
+  generateCollectionQueries,
+  generateColumns,
+  generateFormDefaultValues,
+  generateFormSchema,
+  generateIndexFile,
+  generateVexSchema,
+  generateVexTypes,
+  getAllCollections,
+  getDocument,
+  getPreviewSnapshot,
+  hasPermission,
+  imageUrl,
+  isMediaCollection,
+  json,
+  listDocuments,
+  makeFieldsOptional,
+  mergeAuthCollectionWithUserCollection,
+  number,
+  planMigration,
+  relationship,
+  resolvePreviewURL,
+  richtext,
+  sanitizeConfigForClient,
+  searchDocuments,
+  select,
+  shouldReloadURL,
+  slugToInterfaceName,
+  text,
+  toTitleCase,
+  ui,
+  updateDocument,
+  upload,
+  upsertPreviewSnapshot,
+  vexQuery
+};
+//# sourceMappingURL=index.js.map