@nextbridgehq/payload-block-builder 0.1.8 → 0.2.0

package/dist/index.js

@@ -74,6 +74,17 @@ var BlockDefinitionVersions = {
     update: () => false,
     delete: authenticated
   },
+  hooks: {
+    beforeValidate: [
+      ({ data }) => {
+        if (data?.blockDefinition && data?.versionNumber) {
+          const bd = typeof data.blockDefinition === "object" && data.blockDefinition !== null ? data.blockDefinition.id : data.blockDefinition;
+          data.versionIdString = `${bd}_${data.versionNumber}`;
+        }
+        return data;
+      }
+    ]
+  },
   fields: [
     {
       name: "blockDefinition",
@@ -110,6 +121,12 @@ var BlockDefinitionVersions = {
       type: "textarea",
       required: false,
       admin: { description: "Notes on what changed in this version." }
+    },
+    {
+      name: "versionIdString",
+      type: "text",
+      unique: true,
+      admin: { hidden: true }
     }
   ]
 };
@@ -136,13 +153,26 @@ function dbLayoutField(fieldName = "dbLayout", tabLabel = "DB Layout") {
                 type: "relationship",
                 relationTo: "block-definitions",
                 required: true,
-                admin: { description: "Which block type to use.", width: "50%" }
+                admin: {
+                  description: "Which block type to use.",
+                  width: "50%",
+                  components: {
+                    afterInput: ["@nextbridgehq/payload-block-builder/client#BlockVersionSync"]
+                  }
+                }
               },
               {
                 name: "blockVersion",
                 type: "relationship",
                 relationTo: "block-definition-versions",
                 required: true,
+                filterOptions: ({ siblingData }) => {
+                  const def = siblingData?.blockDefinition;
+                  if (!def) return false;
+                  const defId = def && typeof def === "object" ? def.id : def;
+                  if (!defId) return false;
+                  return { blockDefinition: { equals: defId } };
+                },
                 admin: { description: "Which schema version to use.", width: "50%" }
               }
             ]
@@ -194,51 +224,117 @@ function dbLayoutField(fieldName = "dbLayout", tabLabel = "DB Layout") {
 function indent(n) {
   return "  ".repeat(n);
 }
-function escStr(s) {
-  return s.replace(/\\/g, "\\\\").replace(/'/g, "\\'");
+function safeStr(s) {
+  return JSON.stringify(s);
+}
+function listToCode(items, body, depth) {
+  if (items.length === 0) return "[]";
+  const pad = indent(depth);
+  const innerPad = indent(depth + 1);
+  const entries = items.map((item) => `${innerPad}{
+${body(item)}
+${innerPad}}`).join(",\n");
+  return `[
+${entries}
+${pad}]`;
+}
+var UNNAMED_TYPES = /* @__PURE__ */ new Set(["row", "tabs", "collapsible"]);
+var NO_LABEL_TYPES = /* @__PURE__ */ new Set(["row"]);
+var NO_LOCALIZED_TYPES = /* @__PURE__ */ new Set(["row", "tabs", "collapsible"]);
+var NO_ADMIN_DESCRIPTION_TYPES = /* @__PURE__ */ new Set(["row", "tabs"]);
+var FIELDS_CONTAINER_TYPES = /* @__PURE__ */ new Set([
+  "array",
+  "group",
+  "row",
+  "collapsible"
+]);
+var PAYLOAD_TYPE = {
+  richtext: "richText",
+  image: "upload",
+  file: "upload",
+  multiselect: "select",
+  url: "text",
+  color: "text"
+};
+var UPLOAD_TYPES = /* @__PURE__ */ new Set(["image", "file"]);
+var DEFAULT_UPLOAD_COLLECTION = "media";
+function payloadType(type) {
+  return PAYLOAD_TYPE[type] ?? type;
 }
 function fieldToCode(field, depth = 1) {
   const pad = indent(depth);
   const innerPad = indent(depth + 1);
   const lines = [];
-  lines.push(`${pad}name: '${escStr(field.name)}'`);
-  lines.push(`${pad}type: '${field.type}'`);
-  if (field.label) lines.push(`${pad}label: '${escStr(field.label)}'`);
+  if (!UNNAMED_TYPES.has(field.type)) {
+    lines.push(`${pad}name: ${safeStr(field.name)}`);
+  }
+  lines.push(`${pad}type: '${payloadType(field.type)}'`);
+  if (field.label && !NO_LABEL_TYPES.has(field.type)) {
+    lines.push(`${pad}label: ${safeStr(field.label)}`);
+  }
   if (field.required) lines.push(`${pad}required: true`);
   if (field.unique) lines.push(`${pad}unique: true`);
-  if (field.localized) lines.push(`${pad}localized: true`);
+  if (field.localized && !NO_LOCALIZED_TYPES.has(field.type)) {
+    lines.push(`${pad}localized: true`);
+  }
   if (field.defaultValue !== void 0) {
-    const val = typeof field.defaultValue === "string" ? `'${escStr(String(field.defaultValue))}'` : field.defaultValue;
+    const val = typeof field.defaultValue === "string" ? safeStr(String(field.defaultValue)) : field.defaultValue;
     lines.push(`${pad}defaultValue: ${val}`);
   }
-  if (field.type === "richText") {
+  if (field.type === "richtext") {
     lines.push(`${pad}editor: lexicalEditor({})`);
   }
   if (field.options && field.options.length > 0) {
-    const opts = field.options.map((o) => `{ label: '${escStr(o.label)}', value: '${escStr(o.value)}' }`).join(`, `);
+    const opts = field.options.map((o) => `{ label: ${safeStr(o.label)}, value: ${safeStr(o.value)} }`).join(`, `);
     lines.push(`${pad}options: [${opts}]`);
   }
-  if (field.relationTo) {
-    lines.push(`${pad}relationTo: '${escStr(field.relationTo)}'`);
+  if (UPLOAD_TYPES.has(field.type)) {
+    lines.push(
+      `${pad}relationTo: ${safeStr(field.collection || DEFAULT_UPLOAD_COLLECTION)}`
+    );
+  } else if (field.collection) {
+    lines.push(`${pad}relationTo: ${safeStr(field.collection)}`);
   }
-  if (field.hasMany !== void 0) {
+  if (field.type === "multiselect") {
+    lines.push(`${pad}hasMany: true`);
+  } else if (field.hasMany !== void 0) {
     lines.push(`${pad}hasMany: ${field.hasMany}`);
   }
   if (field.minRows !== void 0) lines.push(`${pad}minRows: ${field.minRows}`);
   if (field.maxRows !== void 0) lines.push(`${pad}maxRows: ${field.maxRows}`);
-  if (field.fields && field.fields.length > 0) {
-    const nested = field.fields.map((f) => `${innerPad}{
-${fieldToCode(f, depth + 2)}
-${innerPad}}`).join(",\n");
-    lines.push(`${pad}fields: [
-${nested}
-${innerPad}]`);
+  const children = field.fields ?? [];
+  if (children.length > 0 || FIELDS_CONTAINER_TYPES.has(field.type)) {
+    lines.push(
+      `${pad}fields: ${listToCode(children, (f) => fieldToCode(f, depth + 2), depth)}`
+    );
+  }
+  if (field.type === "blocks") {
+    lines.push(`${pad}blocks: []`);
+  }
+  if (field.type === "tabs") {
+    const tabsCode = (field.tabs ?? []).map((tab) => {
+      const tabPad = indent(depth + 2);
+      const tabLines = [];
+      if (tab.name) tabLines.push(`${tabPad}name: ${safeStr(tab.name)}`);
+      tabLines.push(`${tabPad}label: ${safeStr(tab.label)}`);
+      tabLines.push(
+        `${tabPad}fields: ${listToCode(tab.fields ?? [], (f) => fieldToCode(f, depth + 4), depth + 2)}`
+      );
+      return `${innerPad}{
+${tabLines.join(",\n")}
+${innerPad}}`;
+    }).join(",\n");
+    lines.push(
+      `${pad}tabs: ${(field.tabs ?? []).length > 0 ? `[
+${tabsCode}
+${pad}]` : "[]"}`
+    );
   }
   const adminParts = [];
-  if (field.admin?.description)
-    adminParts.push(`description: '${escStr(field.admin.description)}'`);
+  if (field.admin?.description && !NO_ADMIN_DESCRIPTION_TYPES.has(field.type))
+    adminParts.push(`description: ${safeStr(field.admin.description)}`);
   if (field.admin?.placeholder)
-    adminParts.push(`placeholder: '${escStr(field.admin.placeholder)}'`);
+    adminParts.push(`placeholder: ${safeStr(field.admin.placeholder)}`);
   if (field.admin?.readOnly) adminParts.push(`readOnly: true`);
   if (field.admin?.hidden) adminParts.push(`hidden: true`);
   if (adminParts.length > 0) {
@@ -252,22 +348,22 @@ function generateBlockCode(block) {
   if (hasRichText) {
     imports.push(`import { lexicalEditor } from '@payloadcms/richtext-lexical'`);
   }
-  const fieldsCode = block.fields.map((f) => `  {
-${fieldToCode(f, 2)}
-  }`).join(",\n");
+  const fieldsCode = block.fields.map((f) => `    {
+${fieldToCode(f, 3)}
+    }`).join(",\n");
   const labelsCode = block.labels ? `
   labels: {
-    singular: '${escStr(block.labels.singular ?? block.slug)}',
-    plural: '${escStr(block.labels.plural ?? block.slug + "s")}',
+    singular: ${safeStr(block.labels.singular ?? block.slug)},
+    plural: ${safeStr(block.labels.plural ?? block.slug + "s")},
   },` : "";
   const interfaceLine = block.interfaceName ? `
-  interfaceName: '${escStr(block.interfaceName)}',` : "";
+  interfaceName: ${safeStr(block.interfaceName)},` : "";
   const exportName = block.interfaceName ?? toCamelCase(block.slug);
   return [
     imports.join("\n"),
     "",
     `export const ${exportName}: Block = {`,
-    `  slug: '${escStr(block.slug)}',${interfaceLine}${labelsCode}`,
+    `  slug: ${safeStr(block.slug)},${interfaceLine}${labelsCode}`,
     `  fields: [`,
     fieldsCode,
     `  ],`,
@@ -276,15 +372,102 @@ ${fieldToCode(f, 2)}
   ].join("\n");
 }
 function containsRichText(fields) {
-  return fields.some(
-    (f) => f.type === "richText" || (f.fields ? containsRichText(f.fields) : false)
-  );
+  return fields.some((f) => {
+    if (f.type === "richtext") return true;
+    if (f.fields && containsRichText(f.fields)) return true;
+    if (f.tabs?.some((tab) => containsRichText(tab.fields ?? []))) return true;
+    return false;
+  });
 }
 function toCamelCase(slug) {
   return slug.split(/[-_]/).map(
     (part, i) => i === 0 ? part : part.charAt(0).toUpperCase() + part.slice(1)
   ).join("");
 }
+function toPascalCase(slug) {
+  return slug.split(/[-_]/).map((part) => part.charAt(0).toUpperCase() + part.slice(1)).join("");
+}
+function getTsType(field) {
+  switch (field.type) {
+    case "number":
+      return "number";
+    case "checkbox":
+      return "boolean";
+    case "text":
+    case "textarea":
+    case "email":
+    case "url":
+    case "color":
+    case "select":
+    case "date":
+      return "string";
+    case "multiselect":
+      return "string[]";
+    case "group":
+      return field.fields ? objectType(flattenProps(field.fields)) : "any";
+    case "array":
+      if (field.fields) {
+        const inner = flattenProps(field.fields).map((p) => `${p.name}: ${p.type}`).join("; ");
+        return `Array<{ id: string; ${inner} }>`;
+      }
+      return "any[]";
+    default:
+      return "any";
+  }
+}
+function objectType(props) {
+  return props.length > 0 ? `{ ${props.map((p) => `${p.name}: ${p.type}`).join("; ")} }` : "Record<string, unknown>";
+}
+function flattenProps(fields) {
+  const out = [];
+  for (const f of fields) {
+    if (f.type === "row" || f.type === "collapsible") {
+      out.push(...flattenProps(f.fields ?? []));
+    } else if (f.type === "tabs") {
+      for (const tab of f.tabs ?? []) {
+        if (tab.name) {
+          out.push({ name: tab.name, type: objectType(flattenProps(tab.fields ?? [])) });
+        } else {
+          out.push(...flattenProps(tab.fields ?? []));
+        }
+      }
+    } else {
+      out.push({ name: f.name, type: getTsType(f) });
+    }
+  }
+  return out;
+}
+function generateReactComponent(block) {
+  const componentName = block.interfaceName ?? toPascalCase(block.slug);
+  const propsName = `${componentName}Props`;
+  const propList = flattenProps(block.fields);
+  const propsCode = propList.map((p) => `  ${p.name}: ${p.type}`).join("\n");
+  const fieldsJsx = propList.map((p) => `      <div className="field-${p.name}">
+        {/* ${p.name} */}
+        {String(props.${p.name})}
+      </div>`).join("\n");
+  const code = [
+    `import React from 'react'`,
+    ``,
+    `export type ${propsName} = {`,
+    propsCode,
+    `}`,
+    ``,
+    `export function ${componentName}(props: ${propsName}) {`,
+    `  return (`,
+    `    <div className="${block.slug}">`,
+    fieldsJsx,
+    `    </div>`,
+    `  )`,
+    `}`,
+    ``
+  ].join("\n");
+  return {
+    filename: `${componentName}.tsx`,
+    code,
+    language: "typescript"
+  };
+}
 function generateBlockOutput(block) {
   return {
     filename: `${block.slug}.ts`,
@@ -292,8 +475,10 @@ function generateBlockOutput(block) {
     language: "typescript"
   };
 }
-function generateAllBlocks(blocks) {
-  return blocks.map(generateBlockOutput);
+function generateAllBlocks(blocks, options = {}) {
+  return blocks.flatMap(
+    (block) => options.react ? [generateBlockOutput(block), generateReactComponent(block)] : [generateBlockOutput(block)]
+  );
 }
 function generateIndexFile(blocks) {
   const exportName = (b) => b.interfaceName ?? toCamelCase(b.slug);
@@ -310,185 +495,29 @@ function generateIndexFile(blocks) {
   return { filename: "index.ts", code, language: "typescript" };
 }
 
-// src/endpoints/generate.ts
-var generateEndpoint = async (req) => {
-  if (!req.user) {
-    return Response.json({ error: "Unauthorized" }, { status: 401 });
-  }
-  let blocks;
-  try {
-    if (!req.json) return Response.json({ error: "No JSON parser available" }, { status: 500 });
-    const body = await req.json();
-    blocks = body.blocks ?? [];
-  } catch {
-    return Response.json({ error: "Invalid JSON body" }, { status: 400 });
-  }
-  const blockOutputs = generateAllBlocks(blocks);
-  const indexOutput = generateIndexFile(blocks);
-  const fileMap = {};
-  for (const out of blockOutputs) {
-    fileMap[out.filename] = out.code;
-  }
-  fileMap[indexOutput.filename] = indexOutput.code;
-  return Response.json({ files: fileMap });
-};
-
-// src/block-builder/lib/schemaToBuilderBlock.ts
-import { v4 as uuidv4 } from "uuid";
-var REVERSE_TYPE_MAP = {
-  richtext: "richText",
-  image: "upload",
-  file: "upload",
-  // file and image both map to upload in the builder
-  multiselect: "select",
-  // builder has no multiselect — nearest equivalent
-  url: "text",
-  // builder has no url field — falls back to text
-  color: "text"
-  // builder has no color field — falls back to text
-};
-var VALID_BUILDER_TYPES = /* @__PURE__ */ new Set([
-  "text",
-  "textarea",
-  "number",
-  "email",
-  "checkbox",
-  "select",
-  "radio",
-  "date",
-  "richText",
-  "upload",
-  "relationship",
-  "array",
-  "group",
-  "tabs",
-  "row",
-  "collapsible",
-  "json",
-  "code",
-  "point",
-  "ui"
-]);
-function fieldToBuilderField(raw) {
-  const rawType = String(raw.type ?? "text");
-  const mappedType = REVERSE_TYPE_MAP[rawType] ?? rawType;
-  const isKnown = VALID_BUILDER_TYPES.has(mappedType);
-  if (!isKnown) {
-    console.warn(`[block-builder] Unknown field type "${rawType}" \u2014 rendering as "text". Add a mapping in REVERSE_TYPE_MAP.`);
-  }
-  const fieldType = isKnown ? mappedType : "text";
-  const field = {
-    id: uuidv4(),
-    type: fieldType,
-    name: String(raw.name ?? "field"),
-    label: raw.label ? String(raw.label) : void 0,
-    required: Boolean(raw.required)
-  };
-  if (raw.options && Array.isArray(raw.options)) {
-    field.options = raw.options.map(
-      (o) => typeof o === "string" ? { label: o, value: o } : { label: String(o.label), value: String(o.value) }
-    );
-  }
-  if (raw.hasMany !== void 0) field.hasMany = Boolean(raw.hasMany);
-  if (raw.collection) field.relationTo = String(raw.collection);
-  if (raw.relationTo) {
-    field.relationTo = String(raw.relationTo);
-  }
-  if (raw.minRows !== void 0) field.minRows = Number(raw.minRows);
-  if (raw.maxRows !== void 0) field.maxRows = Number(raw.maxRows);
-  if (raw.fields && Array.isArray(raw.fields)) {
-    field.fields = raw.fields.map(fieldToBuilderField);
-  }
-  if (raw.admin && typeof raw.admin === "object") {
-    const a = raw.admin;
-    field.admin = {
-      description: a.description ? String(a.description) : void 0,
-      placeholder: a.placeholder ? String(a.placeholder) : void 0,
-      readOnly: Boolean(a.readOnly),
-      hidden: Boolean(a.hidden)
-    };
-  }
-  return field;
-}
-function slugToInterfaceName(slug) {
-  return slug.split(/[-_]/).map((part) => part.charAt(0).toUpperCase() + part.slice(1)).join("");
-}
-function schemaToBuilderBlock(slug, _name, labels, schemaFields) {
-  return {
-    id: uuidv4(),
-    slug,
-    interfaceName: slugToInterfaceName(slug),
-    labels,
-    fields: schemaFields.map(fieldToBuilderField)
+// src/endpoints/guard.ts
+var BUILDER_HEADER = "X-Block-Builder";
+var BUILDER_HEADER_LOWER = BUILDER_HEADER.toLowerCase();
+var BUILDER_HEADER_VALUE = "1";
+function withBuilderGuard(handler) {
+  return async (req) => {
+    if (!req.user) {
+      return Response.json({ error: "Unauthorized" }, { status: 401 });
+    }
+    if (req.headers.get(BUILDER_HEADER_LOWER) !== BUILDER_HEADER_VALUE) {
+      return Response.json(
+        {
+          error: `Missing or invalid "${BUILDER_HEADER}" header. Internal Block Builder endpoints require "${BUILDER_HEADER}: ${BUILDER_HEADER_VALUE}".`
+        },
+        { status: 403 }
+      );
+    }
+    return handler(req);
   };
 }
 
-// src/endpoints/load.ts
-var loadEndpoint = async (req) => {
-  if (!req.user) {
-    return Response.json({ error: "Unauthorized" }, { status: 401 });
-  }
-  const slug = req.routeParams?.slug;
-  if (!slug) {
-    return Response.json({ error: "Slug is required" }, { status: 400 });
-  }
-  const requestedVersionId = req.url ? new URL(req.url).searchParams.get("versionId") : null;
-  const result = await req.payload.find({
-    collection: "block-definitions",
-    where: { slug: { equals: slug } },
-    depth: 2,
-    limit: 1
-  });
-  const def = result.docs[0];
-  if (!def) {
-    return Response.json({ error: `Block definition "${slug}" not found` }, { status: 404 });
-  }
-  const name = def.name ?? slug;
-  const currentVersionId = def.currentVersion && typeof def.currentVersion === "object" ? String(def.currentVersion.id) : typeof def.currentVersion === "string" || typeof def.currentVersion === "number" ? String(def.currentVersion) : null;
-  let version = null;
-  if (requestedVersionId) {
-    try {
-      const v = await req.payload.findByID({
-        collection: "block-definition-versions",
-        id: requestedVersionId,
-        depth: 0
-      });
-      version = v;
-    } catch {
-      return Response.json({ error: `Version "${requestedVersionId}" not found` }, { status: 404 });
-    }
-  } else if (def.currentVersion && typeof def.currentVersion === "object") {
-    version = def.currentVersion;
-  } else {
-    const latestResult = await req.payload.find({
-      collection: "block-definition-versions",
-      where: { blockDefinition: { equals: def.id } },
-      sort: "-versionNumber",
-      depth: 0,
-      limit: 1
-    });
-    version = latestResult.docs[0] ?? null;
-  }
-  if (!version) {
-    const block2 = schemaToBuilderBlock(slug, name, {}, []);
-    return Response.json({ block: block2, versionId: null, versionNumber: null, isCurrent: true });
-  }
-  const versionId = String(version.id);
-  const schema = version.schema;
-  const schemaFields = schema ? Array.isArray(schema) ? schema : schema.fields ?? [] : [];
-  const labels = version.labels ?? {};
-  const versionNumber = version.versionNumber;
-  const block = schemaToBuilderBlock(slug, name, labels, schemaFields);
-  return Response.json({
-    block,
-    versionId,
-    versionNumber: versionNumber ?? null,
-    isCurrent: versionId === currentVersionId
-  });
-};
-
-// src/builder/normalizer.ts
-var KNOWN_TYPES = /* @__PURE__ */ new Set([
+// src/validation/schemaValidator.ts
+var VALID_FIELD_TYPES = /* @__PURE__ */ new Set([
   "text",
   "textarea",
   "richtext",
@@ -506,230 +535,64 @@ var KNOWN_TYPES = /* @__PURE__ */ new Set([
   "group",
   "relationship",
   "json",
-  "blocks"
+  "blocks",
+  "row",
+  "tabs",
+  "collapsible"
 ]);
-function normaliseOption(opt) {
-  if (typeof opt === "string") {
-    return { label: opt, value: opt.toLowerCase().replace(/\s+/g, "-") };
-  }
-  if (opt && typeof opt === "object") {
-    const o = opt;
-    const value = String(o.value ?? o.label ?? "").toLowerCase().replace(/\s+/g, "-");
-    const label = String(o.label ?? o.value ?? value);
-    return { label, value };
+var CONTAINER_TYPES = /* @__PURE__ */ new Set(["array", "group", "row", "collapsible"]);
+var UNNAMED_TYPES2 = /* @__PURE__ */ new Set(["row", "tabs", "collapsible"]);
+var LEAF_NAME_RE = /^[a-zA-Z][a-zA-Z0-9_]*$/;
+var VALID_CONDITION_OPERATORS = /* @__PURE__ */ new Set([
+  "equals",
+  "not_equals",
+  "contains",
+  "not_contains",
+  "greater_than",
+  "less_than",
+  "in",
+  "not_in",
+  "exists",
+  "empty"
+]);
+function validateConditions(conditions, path, errors) {
+  if (!Array.isArray(conditions)) {
+    errors.push(`${path}: "conditions" must be an array.`);
+    return;
   }
-  return { label: String(opt), value: String(opt) };
+  ;
+  conditions.forEach((cond, i) => {
+    const cp = `${path}[${i}]`;
+    if (!cond || typeof cond !== "object") {
+      errors.push(`${cp}: condition must be an object.`);
+      return;
+    }
+    const c = cond;
+    if (typeof c.field !== "string" || !c.field.trim()) {
+      errors.push(`${cp}: "field" must be a non-empty string.`);
+    }
+    if (typeof c.operator !== "string" || !VALID_CONDITION_OPERATORS.has(c.operator)) {
+      errors.push(
+        `${cp}: "operator" must be one of: ${[...VALID_CONDITION_OPERATORS].join(", ")}.`
+      );
+    }
+  });
 }
-function normaliseConditions(raw) {
-  if (!Array.isArray(raw)) return void 0;
-  const result = [];
-  for (const item of raw) {
-    if (item && typeof item === "object" && !Array.isArray(item)) {
-      const c = item;
-      if (typeof c.field === "string" && typeof c.operator === "string") {
-        result.push({ field: c.field, operator: c.operator, value: c.value });
-      }
-    }
-  }
-  return result.length > 0 ? result : void 0;
-}
-function normaliseValidation(raw) {
-  if (!raw || typeof raw !== "object" || Array.isArray(raw)) return void 0;
-  const v = raw;
-  const out = {};
-  if (typeof v.required === "boolean") out.required = v.required;
-  if (typeof v.minLength === "number") out.minLength = v.minLength;
-  if (typeof v.maxLength === "number") out.maxLength = v.maxLength;
-  if (typeof v.regex === "string") out.regex = v.regex;
-  if (typeof v.min === "number") out.min = v.min;
-  if (typeof v.max === "number") out.max = v.max;
-  if (typeof v.step === "number") out.step = v.step;
-  if (typeof v.integerOnly === "boolean") out.integerOnly = v.integerOnly;
-  if (typeof v.minRows === "number") out.minRows = v.minRows;
-  if (typeof v.maxRows === "number") out.maxRows = v.maxRows;
-  if (typeof v.uniqueItems === "boolean") out.uniqueItems = v.uniqueItems;
-  if (Array.isArray(v.allowedMimeTypes)) out.allowedMimeTypes = v.allowedMimeTypes;
-  if (typeof v.maxFileSize === "number") out.maxFileSize = v.maxFileSize;
-  if (typeof v.maxSelections === "number") out.maxSelections = v.maxSelections;
-  return Object.keys(out).length > 0 ? out : void 0;
-}
-function normaliseUI(raw) {
-  if (!raw || typeof raw !== "object" || Array.isArray(raw)) return void 0;
-  const u = raw;
-  const out = {};
-  if (typeof u.tab === "string") out.tab = u.tab;
-  if (typeof u.section === "string") out.section = u.section;
-  if (["full", "half", "third", "quarter"].includes(u.width)) {
-    out.width = u.width;
-  }
-  if (typeof u.collapsed === "boolean") out.collapsed = u.collapsed;
-  if (typeof u.order === "number") out.order = u.order;
-  return Object.keys(out).length > 0 ? out : void 0;
-}
-function normaliseField(raw) {
-  const type = raw.type ?? "text";
-  const resolvedType = KNOWN_TYPES.has(type) ? type : "text";
-  const base = {
-    name: String(raw.name ?? "").trim(),
-    type: resolvedType
-  };
-  if (raw.label) base.label = String(raw.label);
-  if (raw.required !== void 0) base.required = Boolean(raw.required);
-  if (raw.admin && typeof raw.admin === "object") base.admin = raw.admin;
-  const conditions = normaliseConditions(raw.conditions);
-  if (conditions) base.conditions = conditions;
-  if (raw.conditionMode === "AND" || raw.conditionMode === "OR") {
-    base.conditionMode = raw.conditionMode;
-  }
-  const validation = normaliseValidation(raw.validation);
-  if (validation) base.validation = validation;
-  const ui = normaliseUI(raw.ui);
-  if (ui) base.ui = ui;
-  switch (resolvedType) {
-    case "text":
-    case "textarea": {
-      if (raw.minLength !== void 0) base.minLength = Number(raw.minLength);
-      if (raw.maxLength !== void 0) base.maxLength = Number(raw.maxLength);
-      if (raw.defaultValue !== void 0) base.defaultValue = raw.defaultValue;
-      break;
-    }
-    case "number": {
-      if (raw.min !== void 0) base.min = Number(raw.min);
-      if (raw.max !== void 0) base.max = Number(raw.max);
-      if (raw.defaultValue !== void 0) base.defaultValue = raw.defaultValue;
-      break;
-    }
-    case "checkbox": {
-      if (raw.defaultValue !== void 0) base.defaultValue = Boolean(raw.defaultValue);
-      break;
-    }
-    case "select":
-    case "multiselect": {
-      const rawOpts = Array.isArray(raw.options) ? raw.options : [];
-      base.options = rawOpts.map(normaliseOption);
-      if (raw.defaultValue !== void 0) base.defaultValue = raw.defaultValue;
-      break;
-    }
-    case "date": {
-      if (raw.timeFormat !== void 0) base.timeFormat = Boolean(raw.timeFormat);
-      break;
-    }
-    case "array": {
-      const subFields = Array.isArray(raw.fields) ? raw.fields.map(normaliseField) : [];
-      base.fields = subFields;
-      if (raw.minRows !== void 0) base.minRows = Number(raw.minRows);
-      if (raw.maxRows !== void 0) base.maxRows = Number(raw.maxRows);
-      break;
-    }
-    case "group": {
-      const subFields = Array.isArray(raw.fields) ? raw.fields.map(normaliseField) : [];
-      base.fields = subFields;
-      break;
-    }
-    case "relationship": {
-      if (raw.collection) base.collection = String(raw.collection);
-      if (raw.hasMany !== void 0) base.hasMany = Boolean(raw.hasMany);
-      break;
-    }
-    case "file": {
-      if (Array.isArray(raw.allowedMimeTypes)) base.allowedMimeTypes = raw.allowedMimeTypes;
-      break;
-    }
-    case "blocks": {
-      if (Array.isArray(raw.allowedBlocks)) {
-        base.allowedBlocks = raw.allowedBlocks.map(String).filter(Boolean);
-      }
-      if (raw.minBlocks !== void 0) base.minBlocks = Number(raw.minBlocks);
-      if (raw.maxBlocks !== void 0) base.maxBlocks = Number(raw.maxBlocks);
-      break;
-    }
-  }
-  return base;
-}
-function normaliseSchema(raw) {
-  const fields = Array.isArray(raw.fields) ? raw.fields.map(normaliseField) : [];
-  const schema = { fields };
-  if (raw.layout === "sidebar" || raw.layout === "tabs") {
-    schema.layout = raw.layout;
-  } else {
-    schema.layout = "default";
-  }
-  return schema;
-}
-
-// src/validation/schemaValidator.ts
-var VALID_FIELD_TYPES = /* @__PURE__ */ new Set([
-  "text",
-  "textarea",
-  "richtext",
-  "number",
-  "checkbox",
-  "select",
-  "multiselect",
-  "date",
-  "image",
-  "file",
-  "url",
-  "email",
-  "color",
-  "array",
-  "group",
-  "relationship",
-  "json",
-  "blocks"
-]);
-var CONTAINER_TYPES = /* @__PURE__ */ new Set(["array", "group"]);
-var LEAF_NAME_RE = /^[a-zA-Z][a-zA-Z0-9_]*$/;
-var VALID_CONDITION_OPERATORS = /* @__PURE__ */ new Set([
-  "equals",
-  "not_equals",
-  "contains",
-  "not_contains",
-  "greater_than",
-  "less_than",
-  "in",
-  "not_in",
-  "exists",
-  "empty"
-]);
-function validateConditions(conditions, path, errors) {
-  if (!Array.isArray(conditions)) {
-    errors.push(`${path}: "conditions" must be an array.`);
-    return;
-  }
-  ;
-  conditions.forEach((cond, i) => {
-    const cp = `${path}[${i}]`;
-    if (!cond || typeof cond !== "object") {
-      errors.push(`${cp}: condition must be an object.`);
-      return;
-    }
-    const c = cond;
-    if (typeof c.field !== "string" || !c.field.trim()) {
-      errors.push(`${cp}: "field" must be a non-empty string.`);
-    }
-    if (typeof c.operator !== "string" || !VALID_CONDITION_OPERATORS.has(c.operator)) {
-      errors.push(
-        `${cp}: "operator" must be one of: ${[...VALID_CONDITION_OPERATORS].join(", ")}.`
-      );
-    }
-  });
-}
-function validateValidationRules(v, path, errors) {
-  const numericProps = [
-    "minLength",
-    "maxLength",
-    "min",
-    "max",
-    "step",
-    "minRows",
-    "maxRows",
-    "maxFileSize",
-    "maxSelections"
-  ];
-  for (const prop of numericProps) {
-    if (v[prop] !== void 0 && typeof v[prop] !== "number") {
-      errors.push(`${path}.${prop}: must be a number.`);
+function validateValidationRules(v, path, errors) {
+  const numericProps = [
+    "minLength",
+    "maxLength",
+    "min",
+    "max",
+    "step",
+    "minRows",
+    "maxRows",
+    "maxFileSize",
+    "maxSelections"
+  ];
+  for (const prop of numericProps) {
+    if (v[prop] !== void 0 && typeof v[prop] !== "number") {
+      errors.push(`${path}.${prop}: must be a number.`);
     }
   }
   if (typeof v.minLength === "number" && typeof v.maxLength === "number" && v.minLength > v.maxLength) {
@@ -762,7 +625,7 @@ function validateValidationRules(v, path, errors) {
     errors.push(`${path}.allowedMimeTypes: must be an array of strings.`);
   }
 }
-function validateField(field, path, errors, warnings) {
+function validateField(field, path, errors, warnings, reserved = [], names = /* @__PURE__ */ new Set()) {
   if (!field || typeof field !== "object" || Array.isArray(field)) {
     errors.push(`${path}: must be a non-array object.`);
     return;
@@ -873,7 +736,16 @@ function validateField(field, path, errors, warnings) {
     if (!Array.isArray(f.fields) || f.fields.length === 0) {
       errors.push(`${path}: "${type}" fields must have a non-empty "fields" array.`);
     } else {
-      validateFields(f.fields, `${path}.fields`, errors, warnings);
+      validateFields(
+        f.fields,
+        `${path}.fields`,
+        errors,
+        warnings,
+        childReservedNames(type, reserved),
+        // A `row` or `collapsible` stores its children in the surrounding
+        // object, so they share its namespace; `array` and `group` open one.
+        FLATTENING_TYPES.has(type) ? names : /* @__PURE__ */ new Set()
+      );
     }
     if (type === "array") {
       if (f.minRows !== void 0 && typeof f.minRows !== "number") {
@@ -907,18 +779,63 @@ function validateField(field, path, errors, warnings) {
       errors.push(`${path}: "minBlocks" (${f.minBlocks}) must be <= "maxBlocks" (${f.maxBlocks}).`);
     }
   }
+  if (type === "tabs") {
+    if (!Array.isArray(f.tabs) || f.tabs.length === 0) {
+      errors.push(`${path}: "tabs" fields must have a non-empty "tabs" array.`);
+    } else {
+      ;
+      f.tabs.forEach((tab, i) => {
+        const tabPath = `${path}.tabs[${i}]`;
+        if (!tab || typeof tab !== "object") {
+          errors.push(`${tabPath}: must be an object.`);
+          return;
+        }
+        const t = tab;
+        if (typeof t.label !== "string" || !t.label.trim()) {
+          errors.push(`${tabPath}: "label" is required.`);
+        }
+        if (!Array.isArray(t.fields) || t.fields.length === 0) {
+          errors.push(`${tabPath}: "fields" must be a non-empty array.`);
+        } else {
+          const named = typeof t.name === "string" && t.name.trim().length > 0;
+          if (named) claimName(String(t.name).trim(), tabPath, errors, reserved, names);
+          validateFields(
+            t.fields,
+            `${tabPath}.fields`,
+            errors,
+            warnings,
+            named ? [] : reserved,
+            named ? /* @__PURE__ */ new Set() : names
+          );
+        }
+      });
+    }
+  }
+}
+var BLOCK_RESERVED_NAMES = ["id", "createdAt", "updatedAt", "blockType", "blockName"];
+var ARRAY_ROW_RESERVED_NAMES = ["id"];
+function childReservedNames(type, reserved) {
+  if (FLATTENING_TYPES.has(type)) return reserved;
+  if (type === "array") return ARRAY_ROW_RESERVED_NAMES;
+  return [];
+}
+var FLATTENING_TYPES = /* @__PURE__ */ new Set(["row", "collapsible"]);
+function claimName(name, path, errors, reserved, names) {
+  if (names.has(name)) {
+    errors.push(`${path}: duplicate field name "${name}".`);
+  }
+  if (reserved.includes(name)) {
+    errors.push(`${path}: field name "${name}" is a reserved word in Payload CMS.`);
+  }
+  names.add(name);
 }
-function validateFields(fields, path, errors, warnings) {
-  const names = /* @__PURE__ */ new Set();
+function validateFields(fields, path, errors, warnings, reserved = [], names = /* @__PURE__ */ new Set()) {
   fields.forEach((field, index) => {
     const fieldPath = `${path}[${index}]`;
-    validateField(field, fieldPath, errors, warnings);
+    validateField(field, fieldPath, errors, warnings, reserved, names);
     const f = field;
-    if (typeof f.name === "string" && f.name) {
-      if (names.has(f.name)) {
-        errors.push(`${path}: duplicate field name "${f.name}".`);
-      }
-      names.add(f.name);
+    if (typeof f.name === "string" && f.name && !UNNAMED_TYPES2.has(f.type)) {
+      claimName(f.name, path, errors, reserved, names);
     }
   });
 }
@@ -938,7 +855,7 @@ function validateBlockSchema(schema) {
   } else if (s.fields.length === 0) {
     warnings.push("Schema has no fields defined.");
   } else {
-    validateFields(s.fields, "schema.fields", errors, warnings);
+    validateFields(s.fields, "schema.fields", errors, warnings, BLOCK_RESERVED_NAMES);
   }
   if (s.layout !== void 0 && !["default", "sidebar", "tabs"].includes(s.layout)) {
     errors.push(`schema.layout must be one of: "default", "sidebar", "tabs".`);
@@ -946,49 +863,467 @@ function validateBlockSchema(schema) {
   return { valid: errors.length === 0, errors, warnings };
 }
 
-// src/builder/saveSchema.ts
-async function saveSchemaLocally(payload, request) {
-  const { blockSlug, name, description, category, schema: rawSchema, changelog } = request;
-  const schema = normaliseSchema(rawSchema);
-  if (!schema.fields?.length) {
-    return {
-      success: false,
-      definitionId: "",
-      versionId: "",
-      versionNumber: 0,
-      errors: [`Block "${blockSlug}" schema has no fields. Schemas must be imported from a server-safe module (not a "use client" file).`],
-      warnings: []
-    };
+// src/endpoints/generate.ts
+var SLUG_RE = /^[A-Za-z][A-Za-z0-9]*(?:[-_][A-Za-z0-9]+)*$/;
+var IDENTIFIER_RE = /^[A-Za-z_$][A-Za-z0-9_$]*$/;
+var generateEndpoint = withBuilderGuard(async (req) => {
+  let blocks;
+  let react = false;
+  try {
+    if (!req.json) return Response.json({ error: "No JSON parser available" }, { status: 500 });
+    const body = await req.json();
+    const raw = body.blocks ?? [];
+    if (!Array.isArray(raw)) {
+      return Response.json({ error: '"blocks" must be an array.' }, { status: 400 });
+    }
+    blocks = raw;
+    react = body.react === true;
+  } catch {
+    return Response.json({ error: "Invalid JSON body" }, { status: 400 });
   }
-  const validation = validateBlockSchema(schema);
-  if (!validation.valid) {
-    return {
-      success: false,
-      definitionId: "",
-      versionId: "",
-      versionNumber: 0,
-      errors: validation.errors,
-      warnings: validation.warnings
-    };
+  const errors = [];
+  blocks.forEach((block, i) => {
+    const label = block?.slug ? `"${block.slug}"` : `at index ${i}`;
+    if (typeof block?.slug !== "string" || !SLUG_RE.test(block.slug)) {
+      errors.push(
+        `Block ${label}: "slug" must start with a letter and contain only letters, digits, and single "-" or "_" separators.`
+      );
+    }
+    if (block?.interfaceName !== void 0 && (typeof block.interfaceName !== "string" || !IDENTIFIER_RE.test(block.interfaceName))) {
+      errors.push(`Block ${label}: "interfaceName" must be a valid TypeScript identifier.`);
+    }
+    const result = validateBlockSchema({ fields: block?.fields ?? [] });
+    result.errors.forEach((e) => errors.push(`Block ${label}: ${e}`));
+  });
+  if (errors.length > 0) {
+    return Response.json({ error: "Invalid block schema", errors }, { status: 400 });
   }
-  try {
-    let definitionId;
-    const existing = await payload.find({
-      collection: "block-definitions",
-      where: { slug: { equals: blockSlug } },
-      limit: 1
-    });
-    if (existing.docs.length > 0) {
-      definitionId = existing.docs[0].id;
-      const updates = {};
-      if (description !== void 0) updates.description = description;
-      if (category !== void 0) updates.category = category;
-      if (name !== void 0) updates.name = name;
-      if (Object.keys(updates).length > 0) {
-        await payload.update({
-          collection: "block-definitions",
-          id: definitionId,
-          // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  const blockOutputs = generateAllBlocks(blocks, { react });
+  const indexOutput = generateIndexFile(blocks);
+  const fileMap = {};
+  for (const out of blockOutputs) {
+    fileMap[out.filename] = out.code;
+  }
+  fileMap[indexOutput.filename] = indexOutput.code;
+  return Response.json({ files: fileMap });
+});
+
+// src/utils/uuid.ts
+function uuidv4() {
+  const c = globalThis.crypto;
+  if (typeof c?.randomUUID === "function") {
+    return c.randomUUID();
+  }
+  if (typeof c?.getRandomValues === "function") {
+    const bytes = c.getRandomValues(new Uint8Array(16));
+    bytes[6] = bytes[6] & 15 | 64;
+    bytes[8] = bytes[8] & 63 | 128;
+    const hex = Array.from(bytes, (b) => b.toString(16).padStart(2, "0")).join("");
+    return `${hex.slice(0, 8)}-${hex.slice(8, 12)}-${hex.slice(12, 16)}-${hex.slice(16, 20)}-${hex.slice(20)}`;
+  }
+  throw new Error(
+    "No cryptographic random source available. `crypto.randomUUID` requires a secure context (HTTPS or localhost)."
+  );
+}
+
+// src/utils/resolveId.ts
+function resolveId(value) {
+  if (value === null || value === void 0) return null;
+  if (typeof value === "string") return value;
+  if (typeof value === "number") return String(value);
+  if (typeof value === "object" && "id" in value) {
+    const id = value.id;
+    if (typeof id === "string") return id;
+    if (typeof id === "number") return String(id);
+  }
+  return null;
+}
+
+// src/endpoints/load.ts
+function assignFieldIds(fields) {
+  if (!Array.isArray(fields)) return [];
+  return fields.map((field) => {
+    const f = { ...field, id: uuidv4() };
+    if (Array.isArray(f.fields)) f.fields = assignFieldIds(f.fields);
+    if (Array.isArray(f.tabs)) {
+      f.tabs = f.tabs.map((tab) => ({ ...tab, fields: assignFieldIds(tab.fields) }));
+    }
+    return f;
+  });
+}
+var loadEndpoint = withBuilderGuard(async (req) => {
+  const slug = req.routeParams?.slug;
+  if (!slug) {
+    return Response.json({ error: "Slug is required" }, { status: 400 });
+  }
+  const requestedVersionId = req.url ? new URL(req.url).searchParams.get("versionId") : null;
+  const result = await req.payload.find({
+    collection: "block-definitions",
+    where: { slug: { equals: slug } },
+    depth: 2,
+    limit: 1
+  });
+  const def = result.docs[0];
+  if (!def) {
+    return Response.json({ error: `Block definition "${slug}" not found` }, { status: 404 });
+  }
+  const currentVersionId = resolveId(def.currentVersion);
+  let version = null;
+  if (requestedVersionId) {
+    try {
+      const v = await req.payload.findByID({
+        collection: "block-definition-versions",
+        id: requestedVersionId,
+        depth: 0
+      });
+      version = v;
+    } catch (err) {
+      if (err instanceof Error && err.name === "NotFound") {
+        return Response.json({ error: `Version "${requestedVersionId}" not found` }, { status: 404 });
+      }
+      return Response.json({ error: `Failed to load version "${requestedVersionId}"` }, { status: 500 });
+    }
+  } else if (def.currentVersion && typeof def.currentVersion === "object") {
+    version = def.currentVersion;
+  } else {
+    const latestResult = await req.payload.find({
+      collection: "block-definition-versions",
+      where: { blockDefinition: { equals: def.id } },
+      sort: "-versionNumber",
+      depth: 0,
+      limit: 1
+    });
+    version = latestResult.docs[0] ?? null;
+  }
+  function slugToInterfaceName(s) {
+    return s.split(/[-_]/).map((p) => p.charAt(0).toUpperCase() + p.slice(1)).join("");
+  }
+  if (!version) {
+    const block2 = { id: uuidv4(), slug, interfaceName: slugToInterfaceName(slug), labels: {}, fields: [] };
+    return Response.json({ block: block2, versionId: null, versionNumber: null, isCurrent: true });
+  }
+  const versionId = String(version.id);
+  const schema = version.schema;
+  const schemaFields = schema ? Array.isArray(schema) ? schema : schema.fields ?? [] : [];
+  const labels = version.labels ?? {};
+  const versionNumber = version.versionNumber;
+  const block = {
+    id: uuidv4(),
+    slug,
+    interfaceName: slugToInterfaceName(slug),
+    labels,
+    fields: assignFieldIds(schemaFields)
+  };
+  return Response.json({
+    block,
+    versionId,
+    versionNumber: versionNumber ?? null,
+    isCurrent: versionId === currentVersionId
+  });
+});
+
+// src/builder/normalizer.ts
+var KNOWN_TYPES = /* @__PURE__ */ new Set([
+  "text",
+  "textarea",
+  "richtext",
+  "number",
+  "checkbox",
+  "select",
+  "multiselect",
+  "date",
+  "image",
+  "file",
+  "url",
+  "email",
+  "color",
+  "array",
+  "group",
+  "relationship",
+  "json",
+  "blocks",
+  "row",
+  "tabs",
+  "collapsible"
+]);
+function normaliseOption(opt) {
+  if (typeof opt === "string") {
+    return { label: opt, value: opt.toLowerCase().replace(/\s+/g, "-") };
+  }
+  if (opt && typeof opt === "object") {
+    const o = opt;
+    const value = String(o.value ?? o.label ?? "").toLowerCase().replace(/\s+/g, "-");
+    const label = String(o.label ?? o.value ?? value);
+    return { label, value };
+  }
+  return { label: String(opt), value: String(opt) };
+}
+function normaliseConditions(raw) {
+  if (!Array.isArray(raw)) return void 0;
+  const result = [];
+  for (const item of raw) {
+    if (item && typeof item === "object" && !Array.isArray(item)) {
+      const c = item;
+      if (typeof c.field === "string" && typeof c.operator === "string") {
+        result.push({ field: c.field, operator: c.operator, value: c.value });
+      }
+    }
+  }
+  return result.length > 0 ? result : void 0;
+}
+function normaliseValidation(raw) {
+  if (!raw || typeof raw !== "object" || Array.isArray(raw)) return void 0;
+  const v = raw;
+  const out = {};
+  if (typeof v.required === "boolean") out.required = v.required;
+  if (typeof v.minLength === "number") out.minLength = v.minLength;
+  if (typeof v.maxLength === "number") out.maxLength = v.maxLength;
+  if (typeof v.regex === "string") out.regex = v.regex;
+  if (typeof v.min === "number") out.min = v.min;
+  if (typeof v.max === "number") out.max = v.max;
+  if (typeof v.step === "number") out.step = v.step;
+  if (typeof v.integerOnly === "boolean") out.integerOnly = v.integerOnly;
+  if (typeof v.minRows === "number") out.minRows = v.minRows;
+  if (typeof v.maxRows === "number") out.maxRows = v.maxRows;
+  if (typeof v.uniqueItems === "boolean") out.uniqueItems = v.uniqueItems;
+  if (Array.isArray(v.allowedMimeTypes)) out.allowedMimeTypes = v.allowedMimeTypes;
+  if (typeof v.maxFileSize === "number") out.maxFileSize = v.maxFileSize;
+  if (typeof v.maxSelections === "number") out.maxSelections = v.maxSelections;
+  return Object.keys(out).length > 0 ? out : void 0;
+}
+function normaliseUI(raw) {
+  if (!raw || typeof raw !== "object" || Array.isArray(raw)) return void 0;
+  const u = raw;
+  const out = {};
+  if (typeof u.tab === "string") out.tab = u.tab;
+  if (typeof u.section === "string") out.section = u.section;
+  if (["full", "half", "third", "quarter"].includes(u.width)) {
+    out.width = u.width;
+  }
+  if (typeof u.collapsed === "boolean") out.collapsed = u.collapsed;
+  if (typeof u.order === "number") out.order = u.order;
+  return Object.keys(out).length > 0 ? out : void 0;
+}
+function normaliseField(raw) {
+  const type = raw.type ?? "text";
+  const resolvedType = KNOWN_TYPES.has(type) ? type : "text";
+  const base = {
+    name: String(raw.name ?? "").trim(),
+    type: resolvedType
+  };
+  if (raw.label) base.label = String(raw.label);
+  if (raw.required !== void 0) base.required = Boolean(raw.required);
+  if (raw.unique !== void 0) base.unique = Boolean(raw.unique);
+  if (raw.localized !== void 0) base.localized = Boolean(raw.localized);
+  if (raw.admin && typeof raw.admin === "object") base.admin = raw.admin;
+  const conditions = normaliseConditions(raw.conditions);
+  if (conditions) base.conditions = conditions;
+  if (raw.conditionMode === "AND" || raw.conditionMode === "OR") {
+    base.conditionMode = raw.conditionMode;
+  }
+  const validation = normaliseValidation(raw.validation);
+  if (validation) base.validation = validation;
+  const ui = normaliseUI(raw.ui);
+  if (ui) base.ui = ui;
+  switch (resolvedType) {
+    case "text":
+    case "textarea": {
+      if (raw.minLength !== void 0) base.minLength = Number(raw.minLength);
+      if (raw.maxLength !== void 0) base.maxLength = Number(raw.maxLength);
+      if (raw.defaultValue !== void 0) base.defaultValue = raw.defaultValue;
+      break;
+    }
+    case "number": {
+      if (raw.min !== void 0) base.min = Number(raw.min);
+      if (raw.max !== void 0) base.max = Number(raw.max);
+      if (raw.defaultValue !== void 0 && raw.defaultValue !== "") {
+        const n = Number(raw.defaultValue);
+        if (!Number.isNaN(n)) base.defaultValue = n;
+      }
+      break;
+    }
+    case "checkbox": {
+      if (raw.defaultValue !== void 0) {
+        base.defaultValue = typeof raw.defaultValue === "string" ? raw.defaultValue.toLowerCase() === "true" : Boolean(raw.defaultValue);
+      }
+      break;
+    }
+    case "select":
+    case "multiselect": {
+      const rawOpts = Array.isArray(raw.options) ? raw.options : [];
+      base.options = rawOpts.map(normaliseOption);
+      if (raw.defaultValue !== void 0) base.defaultValue = raw.defaultValue;
+      break;
+    }
+    case "date": {
+      if (raw.timeFormat !== void 0) base.timeFormat = Boolean(raw.timeFormat);
+      if (raw.defaultValue !== void 0) base.defaultValue = raw.defaultValue;
+      break;
+    }
+    // The config panel offers a Default Value input for all of these, and the
+    // emitter writes one out, so the normaliser has to carry it through.
+    case "richtext":
+    case "email":
+    case "url":
+    case "color": {
+      if (raw.defaultValue !== void 0) base.defaultValue = raw.defaultValue;
+      break;
+    }
+    case "array": {
+      const subFields = Array.isArray(raw.fields) ? raw.fields.map(normaliseField) : [];
+      base.fields = subFields;
+      if (raw.minRows !== void 0) base.minRows = Number(raw.minRows);
+      if (raw.maxRows !== void 0) base.maxRows = Number(raw.maxRows);
+      break;
+    }
+    case "group": {
+      const subFields = Array.isArray(raw.fields) ? raw.fields.map(normaliseField) : [];
+      base.fields = subFields;
+      break;
+    }
+    case "relationship": {
+      if (raw.collection) base.collection = String(raw.collection);
+      if (raw.hasMany !== void 0) base.hasMany = Boolean(raw.hasMany);
+      break;
+    }
+    // Both upload types carry the target collection through to `relationTo`.
+    case "image": {
+      if (raw.collection) base.collection = String(raw.collection);
+      break;
+    }
+    case "file": {
+      if (Array.isArray(raw.allowedMimeTypes)) base.allowedMimeTypes = raw.allowedMimeTypes;
+      if (raw.collection) base.collection = String(raw.collection);
+      break;
+    }
+    case "blocks": {
+      if (Array.isArray(raw.allowedBlocks)) {
+        base.allowedBlocks = raw.allowedBlocks.map(String).filter(Boolean);
+      }
+      if (raw.minBlocks !== void 0) base.minBlocks = Number(raw.minBlocks);
+      if (raw.maxBlocks !== void 0) base.maxBlocks = Number(raw.maxBlocks);
+      break;
+    }
+    case "row":
+    case "collapsible": {
+      const subFields = Array.isArray(raw.fields) ? raw.fields.map(normaliseField) : [];
+      base.fields = subFields;
+      if (resolvedType === "collapsible") {
+        base.label = String(raw.label ?? "Collapsible Section");
+      }
+      break;
+    }
+    case "tabs": {
+      const rawTabs = Array.isArray(raw.tabs) ? raw.tabs : [];
+      base.tabs = rawTabs.map((t) => {
+        const tab = t;
+        return {
+          id: tab.id ? String(tab.id) : void 0,
+          name: tab.name ? String(tab.name) : void 0,
+          label: String(tab.label ?? "Tab"),
+          description: tab.description ? String(tab.description) : void 0,
+          fields: Array.isArray(tab.fields) ? tab.fields.map(normaliseField) : []
+        };
+      });
+      break;
+    }
+  }
+  return base;
+}
+function normaliseSchema(raw) {
+  const fields = Array.isArray(raw.fields) ? raw.fields.map(normaliseField) : [];
+  const schema = { fields };
+  if (raw.layout === "sidebar" || raw.layout === "tabs") {
+    schema.layout = raw.layout;
+  } else {
+    schema.layout = "default";
+  }
+  return schema;
+}
+
+// src/utils/isUniqueConstraintViolation.ts
+function isUniqueConstraintViolation(err) {
+  for (const candidate of unwrap(err)) {
+    if (!candidate || typeof candidate !== "object") continue;
+    const e = candidate;
+    const code = typeof e.code === "string" || typeof e.code === "number" ? String(e.code) : "";
+    if (code === "23505") return true;
+    if (code === "11000" || code === "11001") return true;
+    if (code === "ER_DUP_ENTRY") return true;
+    if (code.startsWith("SQLITE_CONSTRAINT")) return true;
+    if (e.errno === 1062) return true;
+    if (e.name === "MongoServerError" && code === "11000") return true;
+    const message = typeof e.message === "string" ? e.message.toLowerCase() : "";
+    if (message.includes("duplicate key") || message.includes("unique constraint") || message.includes("duplicate entry")) {
+      return true;
+    }
+  }
+  return false;
+}
+function unwrap(err) {
+  const seen = [];
+  let current = err;
+  for (let depth = 0; depth < 5 && current; depth++) {
+    if (seen.includes(current)) break;
+    seen.push(current);
+    const next = current;
+    current = next.cause ?? next.originalError;
+  }
+  return seen;
+}
+
+// src/builder/saveSchema.ts
+async function saveSchemaLocally(payload, request) {
+  const { blockSlug, name, description, category, schema: rawSchema, changelog } = request;
+  if (!/^[a-z0-9-]+$/.test(blockSlug)) {
+    return {
+      success: false,
+      definitionId: "",
+      versionId: "",
+      versionNumber: 0,
+      errors: [`Invalid block slug "${blockSlug}". Use only lowercase letters, numbers, and hyphens.`],
+      warnings: []
+    };
+  }
+  const schema = normaliseSchema(rawSchema);
+  if (!schema.fields?.length) {
+    return {
+      success: false,
+      definitionId: "",
+      versionId: "",
+      versionNumber: 0,
+      errors: [`Block "${blockSlug}" schema has no fields. Schemas must be imported from a server-safe module (not a "use client" file).`],
+      warnings: []
+    };
+  }
+  const validation = validateBlockSchema(schema);
+  if (!validation.valid) {
+    return {
+      success: false,
+      definitionId: "",
+      versionId: "",
+      versionNumber: 0,
+      errors: validation.errors,
+      warnings: validation.warnings
+    };
+  }
+  try {
+    let definitionId;
+    const existing = await payload.find({
+      collection: "block-definitions",
+      where: { slug: { equals: blockSlug } },
+      limit: 1
+    });
+    if (existing.docs.length > 0) {
+      definitionId = existing.docs[0].id;
+      const updates = {};
+      if (description !== void 0) updates.description = description;
+      if (category !== void 0) updates.category = category;
+      if (name !== void 0) updates.name = name;
+      if (Object.keys(updates).length > 0) {
+        await payload.update({
+          collection: "block-definitions",
+          id: definitionId,
           data: updates
         });
       }
@@ -1003,34 +1338,71 @@ async function saveSchemaLocally(payload, request) {
           warnings: validation.warnings
         };
       }
-      const created = await payload.create({
-        collection: "block-definitions",
-        // eslint-disable-next-line @typescript-eslint/no-explicit-any
-        data: {
-          slug: blockSlug,
-          name,
-          description
-        }
-      });
-      definitionId = created.id;
+      try {
+        const created = await payload.create({
+          collection: "block-definitions",
+          data: {
+            slug: blockSlug,
+            name,
+            description
+          }
+        });
+        definitionId = created.id;
+      } catch (err) {
+        if (!isUniqueConstraintViolation(err)) throw err;
+        const raced = await payload.find({
+          collection: "block-definitions",
+          where: { slug: { equals: blockSlug } },
+          limit: 1
+        });
+        if (raced.docs.length === 0) throw err;
+        definitionId = raced.docs[0].id;
+      }
     }
-    const existingVersions = await payload.find({
+    const latestVersionRes = await payload.find({
       collection: "block-definition-versions",
       where: { blockDefinition: { equals: definitionId } },
-      limit: 0
+      limit: 1,
+      sort: "-versionNumber"
     });
-    const versionNumber = existingVersions.totalDocs + 1;
-    const version = await payload.create({
-      collection: "block-definition-versions",
-      // eslint-disable-next-line @typescript-eslint/no-explicit-any
-      data: {
-        blockDefinition: definitionId,
-        versionNumber,
-        label: `v${versionNumber}`,
-        schema,
-        changelog: changelog ?? "Created via Block Builder"
+    let nextVersionNumber = latestVersionRes.docs.length > 0 ? latestVersionRes.docs[0].versionNumber + 1 : 1;
+    let version = null;
+    let attempts = 0;
+    const MAX_ATTEMPTS = 5;
+    while (attempts < MAX_ATTEMPTS) {
+      attempts++;
+      try {
+        version = await payload.create({
+          collection: "block-definition-versions",
+          data: {
+            blockDefinition: definitionId,
+            versionNumber: nextVersionNumber,
+            label: `v${nextVersionNumber}`,
+            schema,
+            changelog: changelog ?? "Created via Block Builder"
+          }
+        });
+        break;
+      } catch (err) {
+        if (!isUniqueConstraintViolation(err)) throw err;
+        if (attempts >= MAX_ATTEMPTS) {
+          throw new Error(
+            `Failed to create version after ${MAX_ATTEMPTS} attempts due to concurrency conflicts.`
+          );
+        }
+        const latest = await payload.find({
+          collection: "block-definition-versions",
+          where: { blockDefinition: { equals: definitionId } },
+          limit: 1,
+          sort: "-versionNumber"
+        });
+        const observed = latest.docs.length > 0 ? latest.docs[0].versionNumber : nextVersionNumber;
+        nextVersionNumber = Math.max(observed + 1, nextVersionNumber + 1);
       }
-    });
+    }
+    if (!version) {
+      throw new Error("Failed to create version.");
+    }
     await payload.update({
       collection: "block-definitions",
       id: definitionId,
@@ -1057,10 +1429,7 @@ async function saveSchemaLocally(payload, request) {
 }
 
 // src/endpoints/save.ts
-var saveEndpoint = async (req) => {
-  if (!req.user) {
-    return Response.json({ error: "Unauthorized" }, { status: 401 });
-  }
+var saveEndpoint = withBuilderGuard(async (req) => {
   let body;
   try {
     if (!req.json) return Response.json({ error: "No JSON parser available" }, { status: 500 });
@@ -1073,13 +1442,10 @@ var saveEndpoint = async (req) => {
   }
   const result = await saveSchemaLocally(req.payload, body);
   return Response.json(result, { status: result.success ? 200 : 422 });
-};
+});
 
 // src/endpoints/versions.ts
-var versionsEndpoint = async (req) => {
-  if (!req.user) {
-    return Response.json({ error: "Unauthorized" }, { status: 401 });
-  }
+var versionsEndpoint = withBuilderGuard(async (req) => {
   const slug = req.routeParams?.slug;
   if (!slug) {
     return Response.json({ error: "Slug is required" }, { status: 400 });
@@ -1094,7 +1460,7 @@ var versionsEndpoint = async (req) => {
   if (!def) {
     return Response.json({ error: `Block definition "${slug}" not found` }, { status: 404 });
   }
-  const currentVersionId = def.currentVersion && typeof def.currentVersion === "object" ? String(def.currentVersion.id) : typeof def.currentVersion === "string" || typeof def.currentVersion === "number" ? String(def.currentVersion) : null;
+  const currentVersionId = resolveId(def.currentVersion);
   const versionsResult = await req.payload.find({
     collection: "block-definition-versions",
     where: { blockDefinition: { equals: def.id } },
@@ -1114,7 +1480,7 @@ var versionsEndpoint = async (req) => {
     };
   });
   return Response.json({ versions });
-};
+});
 
 // src/plugin.ts
 var dynamicBlocksPlugin = (options = {}) => {