@riverbankcms/sdk 0.2.0 → 0.3.0

package/dist/cli/index.js

@@ -3,13 +3,4844 @@
 
 var commander = require('commander');
 var zod = require('zod');
-var blocks = require('@riverbankcms/blocks');
-require('@riverbankcms/blocks/system/data');
 var jiti = require('jiti');
 var path = require('path');
 var fs = require('fs');
 
 var _documentCurrentScript = typeof document !== 'undefined' ? document.currentScript : null;
+// ../blocks/src/system/manifest/augmentManifest.ts
+function augmentManifest(manifest) {
+  let augmentedFields = manifest.fields ?? [];
+  const variantField = createVariantField(manifest);
+  if (variantField) {
+    augmentedFields = [variantField, ...augmentedFields];
+  }
+  return {
+    ...manifest,
+    fields: augmentedFields
+  };
+}
+function createVariantField(manifest) {
+  if (!manifest.variants || Object.keys(manifest.variants).length <= 1) {
+    return null;
+  }
+  const variantKeys = Object.keys(manifest.variants);
+  const field = {
+    id: "variant",
+    type: "select",
+    label: "Variant",
+    description: "Choose a layout variant for this block",
+    required: false,
+    defaultValue: manifest.defaultVariant ?? variantKeys[0],
+    options: variantKeys.map((key) => ({
+      value: key,
+      label: formatVariantLabel(key)
+    })),
+    multiple: false
+  };
+  return field;
+}
+function formatVariantLabel(variantKey) {
+  return variantKey.replace(/([A-Z])/g, " $1").replace(/_/g, " ").trim().split(" ").map((word) => word.charAt(0).toUpperCase() + word.slice(1).toLowerCase()).join(" ");
+}
+
+// ../blocks/src/system/manifest/registry.ts
+var REGISTRY_SYMBOL = Symbol.for("@riverbankcms/blocks/manifest-registry");
+var globalScope = globalThis;
+if (!globalScope[REGISTRY_SYMBOL]) {
+  globalScope[REGISTRY_SYMBOL] = /* @__PURE__ */ new Map();
+}
+var manifestStore = globalScope[REGISTRY_SYMBOL];
+function registerManifest(manifest) {
+  manifestStore.set(manifest.name, manifest);
+  return manifest;
+}
+var transformStepSchema = zod.z.object({
+  id: zod.z.string().min(1, "Transform requires an identifier"),
+  options: zod.z.record(zod.z.string(), zod.z.unknown()).optional()
+});
+var bindingPathSchema = zod.z.string().min(1, "Binding path is required").regex(/[A-Za-z0-9_\.$\[\]/-]+/, "Binding path contains invalid characters");
+var bindingSchema = zod.z.object({
+  from: bindingPathSchema,
+  fallback: zod.z.unknown().optional(),
+  transforms: transformStepSchema.array().default([]),
+  pick: zod.z.enum(["value", "collection", "context"]).default("value")
+});
+var repeatSchema = zod.z.object({
+  collection: bindingSchema,
+  itemName: zod.z.string().min(1).default("item"),
+  indexName: zod.z.string().min(1).default("index"),
+  limit: zod.z.number().int().positive().optional(),
+  sortBy: zod.z.object({
+    path: bindingPathSchema,
+    direction: zod.z.enum(["asc", "desc"]).default("asc")
+  }).optional()
+});
+var conditionSchema = zod.z.object({
+  when: bindingSchema,
+  equals: zod.z.unknown().optional(),
+  not: zod.z.boolean().default(false)
+});
+var dataScopeSchema = zod.z.object({
+  name: zod.z.string().min(1),
+  from: bindingSchema
+});
+var nodePropsSchema = zod.z.record(zod.z.string(), zod.z.unknown()).default({});
+var nodeSchema = zod.z.object({
+  type: zod.z.string().min(1, "Node type is required"),
+  key: zod.z.string().optional(),
+  props: nodePropsSchema.optional(),
+  children: zod.z.lazy(() => nodeSchema.array().default([])).optional(),
+  $bind: bindingSchema.optional(),
+  $repeat: repeatSchema.optional(),
+  $when: conditionSchema.optional(),
+  $scopes: dataScopeSchema.array().optional()
+});
+nodeSchema.array().or(nodeSchema);
+var NodeSchema = nodeSchema;
+
+// ../blocks/src/system/node/typeBasedLayout.ts
+function typeBasedLayout(itemTypesMap, options) {
+  const itemName = options?.itemName ?? "item";
+  const result = Object.entries(itemTypesMap).map(([typeId, layout]) => {
+    const node = Array.isArray(layout) && layout.length === 1 ? layout[0] : layout;
+    return {
+      ...node,
+      $when: {
+        when: { from: `${itemName}._type` },
+        equals: typeId
+      }
+    };
+  });
+  return result;
+}
+
+// ../blocks/src/system/manifest/schema.ts
+var visibilityLevels = ["admin", "designer", "author"];
+var uiSchema = zod.z.object({
+  widget: zod.z.string().optional(),
+  flattenInRepeater: zod.z.boolean().optional(),
+  hidden: zod.z.boolean().optional(),
+  hideLabel: zod.z.boolean().optional(),
+  hideDescription: zod.z.boolean().optional(),
+  showCharCount: zod.z.union([zod.z.number().int().positive(), zod.z.object({ max: zod.z.number().int().positive() })]).optional(),
+  showSlugPreview: zod.z.boolean().optional(),
+  variant: zod.z.enum(["full", "inline", "limited", "media"]).optional(),
+  richTextVariant: zod.z.enum(["full", "inline", "limited", "media"]).optional(),
+  // Optional input hints for validators/widgets
+  inputType: zod.z.enum(["text", "email", "tel", "number"]).optional(),
+  min: zod.z.number().optional(),
+  max: zod.z.number().optional(),
+  step: zod.z.number().optional(),
+  pattern: zod.z.string().optional(),
+  placeholder: zod.z.string().optional(),
+  visibleWhen: zod.z.object({
+    field: zod.z.string().min(1),
+    equals: zod.z.any().optional(),
+    notEquals: zod.z.any().optional(),
+    oneOf: zod.z.array(zod.z.any()).optional(),
+    notIn: zod.z.array(zod.z.any()).optional()
+  }).optional(),
+  // Modal configuration for modal and group fields
+  modalConfig: zod.z.object({
+    buttonLabel: zod.z.string().optional(),
+    description: zod.z.string().optional(),
+    buttonVariant: zod.z.enum(["default", "outline"]).optional(),
+    showCustomizedIndicator: zod.z.boolean().optional(),
+    maxWidth: zod.z.string().optional()
+  }).optional(),
+  // Background field configuration
+  allowedTypes: zod.z.array(zod.z.enum(["color", "gradient", "image"])).optional(),
+  // Tab group configuration
+  fullWidth: zod.z.boolean().optional(),
+  // Field layout configuration
+  row: zod.z.string().optional(),
+  colSpan: zod.z.number().int().min(1).max(4).optional(),
+  // Group layout configuration
+  layout: zod.z.enum(["stack", "grid"]).optional(),
+  columns: zod.z.number().int().min(2).max(4).optional(),
+  // Entry picker configuration
+  contentTypeField: zod.z.string().optional()
+}).partial();
+var baseFieldSchema = zod.z.object({
+  id: zod.z.string().min(1, "Field id is required"),
+  label: zod.z.string().min(1, "Field label is required"),
+  description: zod.z.string().optional(),
+  visibleRoles: zod.z.array(zod.z.enum(visibilityLevels)).optional(),
+  defaultValue: zod.z.any().optional(),
+  required: zod.z.boolean().default(false),
+  ui: uiSchema.optional()
+});
+var textFieldSchema = baseFieldSchema.extend({
+  type: zod.z.literal("text"),
+  multiline: zod.z.boolean().default(false),
+  maxLength: zod.z.number().int().positive().optional()
+});
+var richTextFieldSchema = baseFieldSchema.extend({
+  type: zod.z.literal("richText"),
+  format: zod.z.enum(["markdown", "html"]).default("markdown")
+});
+var mediaFieldSchema = baseFieldSchema.extend({
+  type: zod.z.literal("media"),
+  mediaKinds: zod.z.array(zod.z.enum(["image", "video"])).default(["image"]),
+  aspectRatio: zod.z.string().optional()
+});
+var booleanFieldSchema = baseFieldSchema.extend({
+  type: zod.z.literal("boolean")
+});
+var dateFieldSchema = baseFieldSchema.extend({
+  type: zod.z.literal("date")
+});
+var timeFieldSchema = baseFieldSchema.extend({
+  type: zod.z.literal("time")
+});
+var dateTimeFieldSchema = baseFieldSchema.extend({
+  type: zod.z.literal("datetime")
+});
+var slugFieldSchema = baseFieldSchema.extend({
+  type: zod.z.literal("slug"),
+  sourceFieldId: zod.z.string().min(1).optional(),
+  statusFieldId: zod.z.string().min(1).optional(),
+  maxLength: zod.z.number().int().positive().optional()
+});
+var urlFieldSchema = baseFieldSchema.extend({
+  type: zod.z.literal("url"),
+  allowRelative: zod.z.boolean().default(false)
+});
+var linkFieldSchema = baseFieldSchema.extend({
+  type: zod.z.literal("link")
+});
+var selectFieldSchema = baseFieldSchema.extend({
+  type: zod.z.literal("select"),
+  options: zod.z.array(zod.z.object({
+    value: zod.z.string(),
+    label: zod.z.string()
+  })).min(1),
+  multiple: zod.z.boolean().default(false)
+});
+var referenceFieldSchema = baseFieldSchema.extend({
+  type: zod.z.literal("reference"),
+  referenceKind: zod.z.string().min(1),
+  allowManualEntry: zod.z.boolean().default(false)
+});
+var itemTypeSchema = zod.z.object({
+  label: zod.z.string().min(1),
+  icon: zod.z.string().optional(),
+  fields: zod.z.lazy(() => getFieldSchemaInternal().array().min(1, "Item type requires at least one field"))
+});
+var repeaterFieldSchema = baseFieldSchema.extend({
+  type: zod.z.literal("repeater"),
+  itemLabel: zod.z.string().default("Item"),
+  itemLabelSource: zod.z.string().optional(),
+  minItems: zod.z.number().int().min(0).default(0),
+  maxItems: zod.z.number().int().positive().optional(),
+  // Monomorphic mode
+  schema: zod.z.object({
+    fields: zod.z.lazy(() => getFieldSchemaInternal().array().min(1, "Repeater requires at least one field"))
+  }).optional(),
+  // Polymorphic mode
+  polymorphic: zod.z.boolean().optional(),
+  itemTypes: zod.z.record(zod.z.string(), itemTypeSchema).optional(),
+  allowConversion: zod.z.boolean().default(true)
+}).refine(
+  (data) => {
+    const hasSchema = data.schema !== void 0;
+    const hasPolymorphic = data.polymorphic === true && data.itemTypes !== void 0;
+    return hasSchema !== hasPolymorphic;
+  },
+  {
+    message: "Repeater must have either 'schema' (monomorphic) or 'polymorphic: true' with 'itemTypes' (polymorphic)"
+  }
+);
+var groupFieldSchema = baseFieldSchema.extend({
+  type: zod.z.literal("group"),
+  schema: zod.z.object({
+    fields: zod.z.lazy(() => getFieldSchemaInternal().array().min(1, "Group requires at least one field"))
+  })
+});
+var modalFieldSchema = baseFieldSchema.extend({
+  type: zod.z.literal("modal"),
+  schema: zod.z.object({
+    fields: zod.z.lazy(() => getFieldSchemaInternal().array().min(1, "Modal requires at least one field"))
+  })
+});
+var numberFieldSchema = baseFieldSchema.extend({
+  type: zod.z.literal("number"),
+  min: zod.z.number().optional(),
+  max: zod.z.number().optional(),
+  step: zod.z.number().optional()
+});
+var tabDefinitionSchema = zod.z.object({
+  id: zod.z.string().min(1),
+  label: zod.z.string().min(1),
+  icon: zod.z.string().optional(),
+  description: zod.z.string().optional(),
+  fields: zod.z.lazy(() => getFieldSchemaInternal().array()),
+  /** SDK section option that controls tab visibility based on site config */
+  sdkSectionOption: zod.z.enum(["backgroundColor", "backgroundGradient", "backgroundImage"]).optional()
+});
+var tabGroupFieldSchema = baseFieldSchema.extend({
+  type: zod.z.literal("tabGroup"),
+  tabs: zod.z.array(tabDefinitionSchema).min(1, "TabGroup requires at least one tab"),
+  activeTabField: zod.z.string().optional()
+});
+var presetOptionSchema = zod.z.object({
+  value: zod.z.string(),
+  label: zod.z.string()
+});
+var presetOrCustomFieldSchema = baseFieldSchema.extend({
+  type: zod.z.literal("presetOrCustom"),
+  presets: zod.z.array(presetOptionSchema).min(1, "PresetOrCustom requires at least one preset"),
+  customInput: zod.z.object({
+    placeholder: zod.z.string().optional(),
+    pattern: zod.z.string().optional(),
+    helpText: zod.z.string().optional()
+  }).optional()
+});
+var contentTypeSelectFieldSchema = baseFieldSchema.extend({
+  type: zod.z.literal("contentTypeSelect"),
+  /** Filter: all, routable (hasPages=true), nonRoutable (hasPages=false) */
+  filter: zod.z.enum(["all", "routable", "nonRoutable"]).default("all")
+});
+var entryPickerFieldSchema = baseFieldSchema.extend({
+  type: zod.z.literal("entryPicker")
+});
+var _fieldSchemaInternal = null;
+function getFieldSchemaInternal() {
+  if (_fieldSchemaInternal) {
+    return _fieldSchemaInternal;
+  }
+  _fieldSchemaInternal = zod.z.discriminatedUnion("type", [
+    textFieldSchema,
+    richTextFieldSchema,
+    mediaFieldSchema,
+    booleanFieldSchema,
+    numberFieldSchema,
+    dateFieldSchema,
+    timeFieldSchema,
+    dateTimeFieldSchema,
+    slugFieldSchema,
+    urlFieldSchema,
+    linkFieldSchema,
+    selectFieldSchema,
+    referenceFieldSchema,
+    repeaterFieldSchema,
+    groupFieldSchema,
+    modalFieldSchema,
+    tabGroupFieldSchema,
+    presetOrCustomFieldSchema,
+    contentTypeSelectFieldSchema,
+    entryPickerFieldSchema
+  ]);
+  return _fieldSchemaInternal;
+}
+var fieldSchema = new Proxy({}, {
+  get(_, prop) {
+    const schema = getFieldSchemaInternal();
+    const value = schema[prop];
+    return typeof value === "function" ? value.bind(schema) : value;
+  },
+  // Forward has checks to the real schema
+  has(_, prop) {
+    return prop in getFieldSchemaInternal();
+  }
+});
+var slotSchema = zod.z.object({
+  id: zod.z.string().min(1),
+  label: zod.z.string().min(1),
+  allowedKinds: zod.z.array(zod.z.string()).default([]),
+  min: zod.z.number().int().min(0).default(0),
+  max: zod.z.number().int().positive().optional(),
+  help: zod.z.string().optional(),
+  visibleRoles: zod.z.array(zod.z.enum(visibilityLevels)).optional()
+});
+var typographyTokens = ["display", "heading", "subheading", "body", "caption"];
+var colorTokens = ["background", "surface", "foreground", "accent", "muted"];
+var spacingTokens = ["none", "xs", "sm", "md", "lg", "xl"];
+var radiusTokens = ["none", "sm", "md", "lg", "full"];
+var styleTokenSchema = zod.z.object({
+  background: zod.z.enum(colorTokens).optional(),
+  foreground: zod.z.enum(colorTokens).optional(),
+  border: zod.z.enum(colorTokens).optional(),
+  typography: zod.z.enum(typographyTokens).optional(),
+  spacing: zod.z.enum(spacingTokens).optional(),
+  radius: zod.z.enum(radiusTokens).optional()
+});
+var behaviourSchema = zod.z.object({
+  supportsThemeSwitching: zod.z.boolean().default(true),
+  inlineEditing: zod.z.boolean().default(false),
+  animation: zod.z.boolean().default(false),
+  // Hide from block picker palettes (e.g., header/footer system blocks)
+  paletteHidden: zod.z.boolean().default(false)
+});
+var blockCategoryEnum = zod.z.enum(["marketing", "content", "blog", "media", "layout", "interactive"]);
+zod.z.object({
+  name: zod.z.string().min(1),
+  version: zod.z.string().min(1),
+  title: zod.z.string().min(1),
+  titleSource: zod.z.string().optional(),
+  description: zod.z.string().optional(),
+  component: zod.z.string().min(1),
+  fields: fieldSchema.array().default([]),
+  slots: slotSchema.array().default([]),
+  styleTokens: styleTokenSchema.optional(),
+  behaviours: behaviourSchema.optional(),
+  layout: NodeSchema.optional(),
+  // Block variants system
+  variants: zod.z.record(zod.z.string(), NodeSchema).optional(),
+  defaultVariant: zod.z.string().optional(),
+  // Discovery metadata
+  category: blockCategoryEnum.optional(),
+  contentTypes: zod.z.array(zod.z.string()).optional(),
+  tags: zod.z.array(zod.z.string()).optional(),
+  icon: zod.z.string().optional()
+});
+
+// ../blocks/src/utils/env.ts
+function isDevEnvironment() {
+  try {
+    if (typeof process !== "undefined" && process.env?.NODE_ENV !== void 0) {
+      return process.env.NODE_ENV !== "production";
+    }
+    return true;
+  } catch {
+    return true;
+  }
+}
+
+// ../blocks/src/system/node/types.ts
+var RESERVED_KEYS = [
+  "children",
+  "key",
+  "$bind",
+  "$when",
+  "$repeat",
+  "$scopes"
+];
+function findReservedKeysInProps(props2) {
+  if (!props2) return [];
+  return RESERVED_KEYS.filter((key) => key in props2);
+}
+function validateProps(props2, context = "node builder") {
+  const reserved = findReservedKeysInProps(props2);
+  if (reserved.length === 0) return;
+  const message = `[blocks:${context}] Reserved keys found in props: ${reserved.join(", ")}. These should be passed as separate parameters or modifiers, not in props. For example, 'children' should be the 3rd parameter to el(), not in the props object.`;
+  if (isDevEnvironment()) {
+    throw new TypeError(message);
+  } else {
+    console.error(message);
+  }
+}
+
+// ../blocks/src/system/node/builder.ts
+function normalizeChildren(children) {
+  if (!children) return void 0;
+  const flat = children.flat().filter(Boolean);
+  return flat.length > 0 ? flat : void 0;
+}
+function el(type, props2, children, ...mods) {
+  validateProps(props2, `el('${type}', ...)`);
+  const node = {
+    type,
+    ...props2 && Object.keys(props2).length > 0 ? { props: props2 } : {},
+    ...children && children.length ? { children: normalizeChildren(children) } : {}
+  };
+  if (mods && mods.length > 0) {
+    const validMods = mods.filter((mod) => typeof mod === "function");
+    if (validMods.length > 0) {
+      const modified = validMods.reduce((acc, fn) => fn(acc), node);
+      return devValidate(modified);
+    }
+  }
+  return devValidate(node);
+}
+var section = (props2, children, ...mods) => el("section", props2, children, ...mods);
+var headerSection = (props2, children, ...mods) => el("headerSection", props2, children, ...mods);
+var stack = (props2, children, ...mods) => el("stack", props2, children, ...mods);
+var inline = (props2, children, ...mods) => el("inline", props2, children, ...mods);
+var accordion = (props2, children, ...mods) => el("accordion", props2, children, ...mods);
+var accordionItem = (props2, children, ...mods) => el("accordionItem", props2, children, ...mods);
+var carousel = (props2, children, ...mods) => el("carousel", props2, children, ...mods);
+var text = (props2, ...mods) => el("text", props2, void 0, ...mods);
+var richText = (props2, ...mods) => el("richText", props2, void 0, ...mods);
+var media = (props2, ...mods) => el("media", props2, void 0, ...mods);
+var button = (props2, children, ...mods) => el("button", props2, children, ...mods);
+var link = (props2, children, ...mods) => el("link", props2, children, ...mods);
+var form = (props2, children, ...mods) => el("form", props2, children, ...mods);
+var bookingForm = (props2, children, ...mods) => el("booking-form", props2, children, ...mods);
+var eventRegistration = (props2, children, ...mods) => el("event-registration", props2, children, ...mods);
+function bind(from, options) {
+  return (node) => ({
+    ...node,
+    $bind: {
+      from,
+      ...options?.fallback !== void 0 ? { fallback: options.fallback } : {},
+      ...options?.transforms ? { transforms: options.transforms } : {},
+      ...options?.pick ? { pick: options.pick } : {}
+    }
+  });
+}
+function when(path, options) {
+  return (node) => ({
+    ...node,
+    $when: {
+      when: { from: path },
+      ...options?.equals !== void 0 ? { equals: options.equals } : {},
+      ...options?.not ? { not: true } : {}
+    }
+  });
+}
+function repeat(collectionPath, itemName = "item", options) {
+  return (node) => ({
+    ...node,
+    $repeat: {
+      collection: { from: collectionPath, pick: "collection" },
+      itemName,
+      ...options?.indexName ? { indexName: options.indexName } : {},
+      ...options?.limit ? { limit: options.limit } : {},
+      ...options?.sortBy ? { sortBy: { path: options.sortBy.path, direction: options.sortBy.direction ?? "asc" } } : {}
+    }
+  });
+}
+function props(extra) {
+  validateProps(extra, "props() modifier");
+  return (node) => ({
+    ...node,
+    props: { ...node.props ?? {}, ...extra }
+  });
+}
+function accordionList({
+  collection,
+  itemName = "item",
+  indexName,
+  accordionProps = null,
+  itemProps = null,
+  triggerFrom,
+  contentFrom,
+  valueFrom
+}, ...mods) {
+  const resolvedIndexName = indexName;
+  const resolvedValuePath = valueFrom === null ? null : valueFrom ?? resolvedIndexName;
+  const baseItemProps = {
+    ...itemProps ?? {},
+    trigger: { $bind: { from: triggerFrom } }
+  };
+  {
+    baseItemProps.content = { $bind: { from: contentFrom } };
+  }
+  if (resolvedValuePath) {
+    baseItemProps.value = { $bind: { from: resolvedValuePath } };
+  }
+  return accordion(
+    accordionProps ?? void 0,
+    [
+      accordionItem(
+        baseItemProps,
+        void 0,
+        repeat(collection, itemName, { indexName: resolvedIndexName })
+      )
+    ],
+    ...mods
+  );
+}
+function devValidate(node) {
+  try {
+    if (isDevEnvironment()) {
+      const res = NodeSchema.safeParse(node);
+      if (!res.success) {
+        console.warn("[blocks:builder] Invalid node produced by builder", res.error.format());
+      }
+    }
+  } catch {
+  }
+  return node;
+}
+
+// ../blocks/src/system/node/fragments/backgroundLayer.ts
+function backgroundLayer(path, options = {}) {
+  const {
+    styleClassName = "absolute inset-0 -z-10 h-full w-full pointer-events-none",
+    imageClassName
+  } = options;
+  const styleLayer = el("div", {
+    className: { $bind: { from: path, transforms: [{ id: "background.resolveClass", options: { baseClass: styleClassName } }] } },
+    style: { $bind: { from: path, transforms: [{ id: "background.resolveStyle" }] } }
+  });
+  const imageLayer = createBackgroundImageNode(path, imageClassName);
+  return [styleLayer, imageLayer];
+}
+function createBackgroundImageNode(path, baseClassName = "absolute -z-10") {
+  const imagePath = `${path}.image`;
+  return media(
+    {
+      className: {
+        $bind: {
+          from: path,
+          transforms: [{
+            id: "background.resolveImageClassName",
+            options: { baseClass: `background-image ${baseClassName}` }
+          }]
+        }
+      },
+      style: {
+        $bind: {
+          from: path,
+          transforms: [{ id: "background.resolveImageStyle" }]
+        }
+      }
+    },
+    when(imagePath),
+    bind(imagePath)
+  );
+}
+
+// ../blocks/src/theme/utils/colorStyles.ts
+var COLOR_VAR_PREFIX = "--tb-";
+function parseToken(source) {
+  if (source.startsWith("raw:")) {
+    return { token: source, raw: source.slice(4) };
+  }
+  if (source.includes("/")) {
+    const [token, opacity] = source.split("/");
+    const alpha = Number(opacity) / 100;
+    if (!Number.isNaN(alpha)) {
+      return { token, alpha };
+    }
+    return { token: source };
+  }
+  return { token: source };
+}
+function rgbColorValue(token) {
+  const { token: baseToken, alpha, raw } = parseToken(token);
+  if (raw) {
+    return raw;
+  }
+  const cssVar = `${COLOR_VAR_PREFIX}${baseToken}`;
+  if (alpha === void 0) {
+    return `rgb(var(${cssVar}))`;
+  }
+  return `rgba(var(${cssVar}), ${alpha})`;
+}
+function backgroundColorStyle(token) {
+  return { backgroundColor: rgbColorValue(token) };
+}
+function textColorStyle(token) {
+  return { color: rgbColorValue(token) };
+}
+function borderColorStyle(token) {
+  return { borderColor: rgbColorValue(token) };
+}
+function mergeStyles(...styles) {
+  const merged = styles.filter(Boolean).reduce((acc, style) => Object.assign(acc, style), {});
+  return Object.keys(merged).length ? merged : void 0;
+}
+
+// ../blocks/src/system/node/fragments/headingGroup.ts
+function headingGroup(opts) {
+  const {
+    eyebrowPath,
+    titlePath,
+    containerClass = "text-center",
+    className,
+    eyebrowClass = "heading-eyebrow text-sm font-semibold tracking-wide",
+    titleClass = "heading-title text-3xl font-semibold sm:text-4xl",
+    eyebrowStyle = textColorStyle("neutral-500"),
+    titleStyle = textColorStyle("neutral-900")
+  } = opts;
+  const finalContainerClass = className ? `${containerClass} ${className}` : containerClass;
+  return stack({ gap: "sm", className: finalContainerClass }, [
+    eyebrowPath ? text({ as: "p", className: eyebrowClass, style: eyebrowStyle }, when(eyebrowPath), bind(eyebrowPath)) : null,
+    text({ as: "h2", className: titleClass, style: titleStyle }, bind(titlePath))
+  ]);
+}
+
+// ../blocks/src/system/node/fragments/sectionContainer.ts
+function sectionContainer(children, opts) {
+  const gap = opts?.gap ?? "md";
+  const align = opts?.align;
+  const bindFrom = opts?.bindFrom ?? "_containerStyles";
+  const additionalClasses = opts?.className ?? "";
+  return stack(
+    {
+      gap,
+      className: {
+        $bind: {
+          from: bindFrom,
+          transforms: [
+            {
+              id: "containerStyles.resolveClassName",
+              options: { baseClass: additionalClasses }
+            }
+          ],
+          fallback: additionalClasses ? `container mx-auto ${additionalClasses}` : "container mx-auto"
+        }
+      },
+      ...align ? { align } : {}
+    },
+    children
+  );
+}
+
+// ../blocks/src/system/spacing.ts
+var DEFAULT_SECTION_SPACING = "medium";
+
+// ../blocks/src/system/node/fragments/styledSection.ts
+function styledSection(config) {
+  const {
+    children,
+    baseClass = "px-6",
+    spacing = DEFAULT_SECTION_SPACING,
+    background = "background/base",
+    bindFrom = "_sectionStyles",
+    imageClassName = "absolute -z-10"
+  } = config;
+  const backgroundNodes = backgroundLayer(`${bindFrom}.background`, {
+    imageClassName
+  });
+  const childrenArray = Array.isArray(children) ? children : [children];
+  return section(
+    {
+      background,
+      className: {
+        $bind: {
+          from: bindFrom,
+          transforms: [
+            {
+              id: "sectionStyles.resolveClassName",
+              options: { baseClass, defaultSpacing: spacing }
+            }
+          ]
+          // No fallback needed - transform handles all cases via defaultSpacing
+        }
+      },
+      allowOverflow: {
+        $bind: {
+          from: `${bindFrom}.background.overflow`,
+          fallback: false
+        }
+      }
+    },
+    [
+      ...backgroundNodes,
+      ...childrenArray
+    ]
+  );
+}
+
+// ../blocks/src/system/node/fragments/ctaButton.ts
+function ctaButton(opts) {
+  const base = opts?.basePath ?? "cta";
+  const linkPath = opts?.linkPath ?? `${base}.link`;
+  const labelPath = opts?.labelPath ?? `${base}.label`;
+  const variantPath = opts?.variantPath ?? `${base}.variant`;
+  const iconLeftPath = opts?.iconLeftPath ?? `${base}.iconLeft`;
+  const iconRightPath = opts?.iconRightPath ?? `${base}.iconRight`;
+  const whenPath = opts?.whenPath ?? labelPath;
+  const leftIcon = media({ className: "mr-2 h-4 w-4 inline-block" }, when(iconLeftPath), bind(iconLeftPath));
+  const rightIcon = media({ className: "ml-2 h-4 w-4 inline-block" }, when(iconRightPath), bind(iconRightPath));
+  const label = text({ as: "span" }, bind(labelPath));
+  const classNameObj = {
+    $bind: {
+      from: variantPath,
+      fallback: "primary"
+    },
+    $prepend: "button-"
+  };
+  if (opts?.className) {
+    classNameObj.$append = ` ${opts.className}`;
+  }
+  const node = button(
+    {
+      className: classNameObj,
+      href: { $bind: { from: linkPath, transforms: [{ id: "links.resolve" }], fallback: "#" } }
+    },
+    [leftIcon, label, rightIcon]
+  );
+  if (opts?.repeatFrom) {
+    return button(
+      node.props ?? {},
+      node.children,
+      repeat(opts.repeatFrom.collectionPath, opts.repeatFrom.itemName ?? base)
+    );
+  }
+  return button(node.props ?? {}, node.children, when(whenPath));
+}
+
+// ../blocks/src/system/node/fragments/ctaRow.ts
+function ctaRow(opts) {
+  const collectionPath = opts?.collectionPath ?? "content.ctas";
+  const item = opts?.itemName ?? "cta";
+  const gap = opts?.gap ?? "sm";
+  const justify = opts?.justify ?? "center";
+  const containerClassName = ["cta-row flex-wrap", opts?.containerClassName].filter(Boolean).join(" ");
+  return inline(
+    { gap, justify, className: containerClassName },
+    [
+      ctaButton({ basePath: item, repeatFrom: { collectionPath, itemName: item } })
+    ],
+    when(collectionPath)
+  );
+}
+
+// ../blocks/src/system/node/fragments/navRow.ts
+function navRow(opts) {
+  const collectionPath = opts?.collectionPath ?? "menu.items";
+  const itemName = opts?.itemName ?? "navItem";
+  const gap = opts?.gap ?? "md";
+  const align = opts?.align ?? "end";
+  const className = ["items-center flex-wrap", opts?.className].filter(Boolean).join(" ").trim();
+  const linkClassName = opts?.linkClassName ?? "header-nav-link inline-flex items-center px-4 py-2 text-sm font-medium transition-theme-standard";
+  const links = link(
+    {
+      className: linkClassName,
+      href: { $bind: { from: `${itemName}.link`, transforms: [{ id: "links.resolve" }], fallback: "#" } },
+      target: { $bind: { from: `${itemName}.target` } },
+      rel: { $bind: { from: `${itemName}.rel` } },
+      "data-active": { $bind: { from: `${itemName}.active` } }
+    },
+    [text({ as: "span" }, bind(`${itemName}.label`))],
+    repeat(collectionPath, itemName)
+  );
+  return inline(
+    { gap, align, className },
+    [links],
+    when(collectionPath)
+  );
+}
+var FRAGMENT_ID_PATTERN = /^[a-z0-9](?:[a-z0-9._-]*[a-z0-9])?$/i;
+var FIELD_ID_PATTERN = /^[a-z][a-zA-Z0-9_-]*$/;
+var dataLoaderSchema = zod.z.object({
+  endpoint: zod.z.string().min(1, "Fragment data loader requires an endpoint"),
+  params: zod.z.record(zod.z.string(), zod.z.unknown()).default({}),
+  mode: zod.z.enum(["server", "client"]).default("server")
+});
+var fragmentDataSchema = zod.z.object({
+  key: zod.z.string().min(1, "Fragment data key is required"),
+  loader: dataLoaderSchema.optional()
+});
+var fragmentConfigSchema = zod.z.object({
+  id: zod.z.string().min(1, "Fragment id is required").regex(FRAGMENT_ID_PATTERN, "Fragment id must be alphanumeric with optional . _ - separators"),
+  title: zod.z.string().optional(),
+  description: zod.z.string().optional(),
+  category: zod.z.enum(["content", "media", "interactive", "layout"]).optional(),
+  icon: zod.z.string().optional(),
+  fields: fieldSchema.array().default([]),
+  layout: zod.z.union([NodeSchema, NodeSchema.array()]).transform((value) => Array.isArray(value) ? value : [value]),
+  data: fragmentDataSchema.optional()
+});
+var FragmentConfigError = class extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "FragmentConfigError";
+  }
+};
+function defineFragment(config) {
+  const parsed = fragmentConfigSchema.parse(config);
+  validateFieldDefinitions(parsed.fields, parsed.id);
+  return {
+    ...parsed,
+    fields: parsed.fields.map(cloneFieldDefinition),
+    layout: parsed.layout.map((node) => ({ ...node }))
+  };
+}
+function scopeFragmentFields(fragment, scope) {
+  const normalizedScope = scope.trim();
+  if (!normalizedScope) {
+    return fragment.fields.map(cloneFieldDefinition);
+  }
+  return fragment.fields.map((field) => prefixFieldId(field, normalizedScope));
+}
+function scopeFragmentLayout(fragment, scope) {
+  const normalizedScope = scope.trim();
+  return fragment.layout.map((node) => cloneAndScopeNode(node, normalizedScope));
+}
+function validateFieldDefinitions(fields4, fragmentId) {
+  const seen = /* @__PURE__ */ new Set();
+  for (const field of fields4) {
+    if (field.id.includes(".")) {
+      throw new FragmentConfigError(
+        `Field "${field.id}" in fragment "${fragmentId}" should not include dot notation; the builder scopes fields automatically.`
+      );
+    }
+    if (!FIELD_ID_PATTERN.test(field.id)) {
+      throw new FragmentConfigError(
+        `Field "${field.id}" in fragment "${fragmentId}" must start with a letter and contain only alphanumeric, "_", or "-".`
+      );
+    }
+    if (seen.has(field.id)) {
+      throw new FragmentConfigError(
+        `Duplicate field id "${field.id}" found in fragment "${fragmentId}". Field ids must be unique per fragment.`
+      );
+    }
+    seen.add(field.id);
+  }
+}
+function prefixFieldId(field, scope) {
+  const cloned = cloneFieldDefinition(field);
+  cloned.id = `${scope}.${field.id}`;
+  cloned.defaultValue = cloneUnknown(cloned.defaultValue);
+  cloned.visibleRoles = cloned.visibleRoles ? [...cloned.visibleRoles] : void 0;
+  cloned.ui = cloneUnknown(cloned.ui);
+  return cloned;
+}
+function cloneFieldDefinition(field) {
+  switch (field.type) {
+    case "repeater":
+      if (field.polymorphic && field.itemTypes) {
+        return {
+          ...field,
+          polymorphic: true,
+          itemTypes: Object.fromEntries(
+            Object.entries(field.itemTypes).map(([key, itemType]) => [
+              key,
+              {
+                ...itemType,
+                fields: itemType.fields.map(cloneFieldDefinition)
+              }
+            ])
+          )
+        };
+      } else if (field.schema) {
+        return {
+          ...field,
+          schema: {
+            fields: field.schema.fields.map(cloneFieldDefinition)
+          }
+        };
+      }
+      return { ...field };
+    case "group":
+      return {
+        ...field,
+        schema: {
+          fields: field.schema.fields.map(cloneFieldDefinition)
+        }
+      };
+    default:
+      return { ...field };
+  }
+}
+function cloneUnknown(value) {
+  if (value == null || typeof value !== "object") {
+    return value;
+  }
+  if (Array.isArray(value)) {
+    return value.map((entry) => cloneUnknown(entry));
+  }
+  return { ...value };
+}
+function cloneAndScopeNode(node, scope) {
+  const cloned = {
+    ...node
+  };
+  if (node.children) {
+    cloned.children = node.children.map((child) => cloneAndScopeNode(child, scope));
+  }
+  if (node.props) {
+    cloned.props = scopePropBindings(node.props, scope);
+  }
+  if (node.$bind) {
+    cloned.$bind = scopeBinding(node.$bind, scope);
+  }
+  if (node.$repeat) {
+    cloned.$repeat = scopeRepeat(node.$repeat, scope);
+  }
+  if (node.$when) {
+    cloned.$when = scopeCondition(node.$when, scope);
+  }
+  if (node.$scopes) {
+    cloned.$scopes = node.$scopes.map((entry) => ({
+      name: entry.name,
+      from: scopeBinding(entry.from, scope)
+    }));
+  }
+  return cloned;
+}
+function scopeBinding(binding, scope) {
+  const cloned = {
+    ...binding,
+    transforms: binding.transforms?.map(
+      (step) => ({ ...step })
+    ) ?? []
+  };
+  cloned.from = scopeContentPath(binding.from, scope);
+  return cloned;
+}
+function scopeRepeat(repeat2, scope) {
+  const cloned = {
+    ...repeat2,
+    collection: scopeBinding(repeat2.collection, scope)
+  };
+  if (repeat2.sortBy) {
+    cloned.sortBy = {
+      ...repeat2.sortBy,
+      path: scopeContentPath(repeat2.sortBy.path, scope)
+    };
+  }
+  return cloned;
+}
+function scopeCondition(condition, scope) {
+  return {
+    ...condition,
+    when: scopeBinding(condition.when, scope)
+  };
+}
+function scopePropBindings(input, scope) {
+  const result = {};
+  for (const [key, value] of Object.entries(input)) {
+    result[key] = scopePropValue(value, scope);
+  }
+  return result;
+}
+function scopePropValue(value, scope) {
+  if (Array.isArray(value)) {
+    return value.map((entry) => scopePropValue(entry, scope));
+  }
+  if (value && typeof value === "object") {
+    if ("$bind" in value) {
+      const bindingConfig = value.$bind;
+      return {
+        $bind: scopeBinding(bindingConfig, scope)
+      };
+    }
+    const result = {};
+    for (const [key, entry] of Object.entries(value)) {
+      result[key] = scopePropValue(entry, scope);
+    }
+    return result;
+  }
+  return value;
+}
+function scopeContentPath(path, scope) {
+  if (!scope || scope.length === 0) {
+    return path;
+  }
+  if (path === "content") {
+    return `content.${scope}`;
+  }
+  if (path.startsWith("content.")) {
+    const remainder = path.slice("content.".length);
+    return remainder.length > 0 ? `content.${scope}.${remainder}` : `content.${scope}`;
+  }
+  if (path.startsWith("content[")) {
+    return path.replace(/^content/, `content.${scope}`);
+  }
+  if (path.startsWith("$root.")) {
+    return path;
+  }
+  if (path.includes(".")) {
+    return path;
+  }
+  return `content.${scope}.${path}`;
+}
+
+// ../blocks/src/system/fragments/builder.ts
+var FragmentCompositionError = class extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "FragmentCompositionError";
+  }
+};
+var DOT_SCOPE_REGEX = /^[A-Za-z0-9_.-]*$/;
+function materializeFragment(config) {
+  const scope = normalizeScope(config.scope);
+  const fields4 = scopeFragmentFields(config.fragment, scope);
+  const layout = scopeFragmentLayout(config.fragment, scope);
+  const fieldPriority = config.fieldPriority ?? 0;
+  let data;
+  if (config.fragment.data) {
+    const key = config.dataKey ?? config.fragment.data.key;
+    if (!key || typeof key !== "string") {
+      throw new FragmentCompositionError(
+        `Fragment "${config.fragment.id}" requires a data key to compose.`
+      );
+    }
+    data = {
+      key,
+      loader: config.fragment.data.loader ? { ...config.fragment.data.loader } : void 0
+    };
+  }
+  return {
+    fragment: config.fragment,
+    scope,
+    fields: fields4,
+    layout,
+    data,
+    fieldPriority
+  };
+}
+function composeFragments(instances) {
+  const fieldEntries = [];
+  const layouts = [];
+  const dataEntries = [];
+  const scopes = [];
+  const seenFieldIds = /* @__PURE__ */ new Set();
+  let fieldOrder = 0;
+  for (const instance of instances) {
+    const materialized = materializeFragment(instance);
+    for (const field of materialized.fields) {
+      if (seenFieldIds.has(field.id)) {
+        throw new FragmentCompositionError(
+          `Duplicate field id "${field.id}" when composing fragments.`
+        );
+      }
+      seenFieldIds.add(field.id);
+      fieldEntries.push({
+        id: field.id,
+        field,
+        priority: materialized.fieldPriority,
+        order: fieldOrder++
+      });
+    }
+    scopes.push(materialized.scope);
+    layouts.push(...materialized.layout);
+    if (materialized.data) {
+      if (dataEntries.find((entry) => entry.key === materialized.data?.key)) {
+        throw new FragmentCompositionError(
+          `Duplicate fragment data key "${materialized.data.key}" detected.`
+        );
+      }
+      dataEntries.push(materialized.data);
+    }
+  }
+  return {
+    fields: fieldEntries.sort((a, b) => {
+      if (a.priority !== b.priority) {
+        return a.priority - b.priority;
+      }
+      return a.order - b.order;
+    }).map((entry) => entry.field),
+    layout: layouts,
+    data: dataEntries,
+    scopes
+  };
+}
+function normalizeScope(scope) {
+  if (!scope) return "";
+  const trimmed = scope.trim();
+  if (!DOT_SCOPE_REGEX.test(trimmed)) {
+    throw new FragmentCompositionError(
+      `Fragment scope "${scope}" contains invalid characters. Use alphanumeric, ".", "-", or "_".`
+    );
+  }
+  return trimmed;
+}
+function buildFragmentDataLoaders(composition2) {
+  const loaders = {};
+  for (const entry of composition2.data) {
+    if (!entry?.loader) continue;
+    loaders[entry.key] = {
+      endpoint: entry.loader.endpoint,
+      params: { ...entry.loader.params ?? {} },
+      mode: entry.loader.mode ?? "server"
+    };
+  }
+  return loaders;
+}
+
+// ../blocks/src/system/fragments/library/bodyCopy.ts
+var bodyCopyFragment = defineFragment({
+  id: "bodyCopy",
+  title: "Body Copy",
+  description: "Heading, rich text body, and alignment controls.",
+  fields: [
+    {
+      id: "heading",
+      type: "text",
+      label: "Heading",
+      description: "Optional heading displayed above the body copy."
+    },
+    {
+      id: "body",
+      type: "richText",
+      label: "Body",
+      required: true
+    },
+    {
+      id: "alignment",
+      type: "select",
+      label: "Text alignment",
+      required: false,
+      defaultValue: "left",
+      options: [
+        { value: "left", label: "Left" },
+        { value: "center", label: "Center" }
+      ]
+    }
+  ],
+  layout: stack(
+    {
+      gap: "md",
+      className: "mx-auto max-w-3xl",
+      align: {
+        $bind: {
+          from: "content.alignment",
+          transforms: [{ id: "ui.stackAlignFromAlignment" }],
+          fallback: "start"
+        }
+      }
+    },
+    [
+      text(
+        {
+          as: "h2",
+          className: {
+            $bind: {
+              from: "content.alignment",
+              transforms: [
+                {
+                  id: "ui.headingClassFromAlignment",
+                  options: {
+                    base: "text-3xl font-semibold sm:text-4xl"
+                  }
+                }
+              ],
+              fallback: "text-3xl font-semibold sm:text-4xl"
+            }
+          },
+          style: textColorStyle("neutral-900")
+        },
+        when("content.heading"),
+        bind("content.heading")
+      ),
+      richText(
+        {
+          className: {
+            $bind: {
+              from: "content.alignment",
+              transforms: [
+                {
+                  id: "ui.bodyClassFromAlignment",
+                  options: {
+                    base: "prose prose-lg max-w-none sm:prose-xl"
+                  }
+                }
+              ],
+              fallback: "prose prose-lg max-w-none sm:prose-xl"
+            },
+            style: textColorStyle("neutral-600")
+          }
+        },
+        bind("content.body")
+      )
+    ]
+  )
+});
+
+// ../blocks/src/system/fragments/library/heroCopy.ts
+var heroCopyFragment = defineFragment({
+  id: "heroCopy",
+  title: "Hero Copy",
+  description: "Eyebrow, headline, and subheadline copy for hero layouts.",
+  fields: [
+    {
+      id: "eyebrow",
+      type: "text",
+      label: "Eyebrow",
+      description: "Optional short line above the headline",
+      visibleRoles: ["designer", "admin"]
+    },
+    {
+      id: "headline",
+      type: "text",
+      label: "Headline",
+      required: true,
+      maxLength: 120
+    },
+    {
+      id: "subheadline",
+      type: "text",
+      label: "Subheadline",
+      multiline: true,
+      maxLength: 280
+    }
+  ],
+  layout: [
+    text(
+      {
+        as: "p",
+        className: "hero-eyebrow text-sm font-semibold tracking-wide",
+        style: textColorStyle("neutral-500")
+      },
+      when("content.eyebrow"),
+      bind("content.eyebrow")
+    ),
+    text(
+      {
+        as: "h1",
+        className: "hero-headline text-4xl font-semibold sm:text-5xl md:text-6xl",
+        style: textColorStyle("neutral-900")
+      },
+      bind("content.headline")
+    ),
+    text(
+      {
+        as: "p",
+        className: "hero-subheadline text-lg sm:text-xl",
+        style: textColorStyle("neutral-600")
+      },
+      when("content.subheadline"),
+      bind("content.subheadline")
+    )
+  ]
+});
+
+// ../blocks/src/system/fields/button.ts
+function createButtonGroup(options = {}) {
+  const {
+    variants = [
+      { value: "primary", label: "Primary" },
+      { value: "secondary", label: "Secondary" },
+      { value: "outline", label: "Outline" }
+    ],
+    showGroupLabel = false,
+    groupId = "button",
+    groupLabel = "Button",
+    flattenInRepeater = true
+  } = options;
+  const mainFields = [
+    {
+      id: "label",
+      type: "text",
+      label: "Label",
+      required: true,
+      multiline: false,
+      maxLength: 40,
+      ui: { row: "primary" }
+    },
+    {
+      id: "variant",
+      type: "select",
+      label: "Style",
+      options: variants,
+      required: false,
+      multiple: false,
+      ui: { row: "primary" }
+    },
+    {
+      id: "link",
+      type: "link",
+      label: "Link",
+      required: true,
+      ui: { colSpan: 2 }
+    }
+  ];
+  const iconsGroup = {
+    id: "icons",
+    type: "group",
+    label: "Icons",
+    required: false,
+    ui: { preset: "disclosure", colSpan: 2 },
+    schema: {
+      fields: [
+        { id: "iconLeft", type: "media", label: "Left icon", required: false, mediaKinds: ["image"] },
+        { id: "iconRight", type: "media", label: "Right icon", required: false, mediaKinds: ["image"] }
+      ]
+    }
+  };
+  return {
+    id: groupId,
+    type: "group",
+    label: groupLabel,
+    ui: { layout: "grid", columns: 2, flattenInRepeater, hideLabel: !showGroupLabel },
+    schema: { fields: [...mainFields, iconsGroup] },
+    required: false
+  };
+}
+
+// ../blocks/src/system/fields/ctas.ts
+function createCtasRepeater(options = {}) {
+  const {
+    id = "ctas",
+    label = "Calls to action",
+    itemLabel = "CTA",
+    minItems = 0,
+    maxItems
+  } = options;
+  return {
+    id,
+    type: "repeater",
+    label,
+    itemLabel,
+    itemLabelSource: "label",
+    minItems,
+    maxItems,
+    schema: {
+      fields: [createButtonGroup({ showGroupLabel: false, flattenInRepeater: true })]
+    }
+  };
+}
+
+// ../blocks/src/system/fragments/library/ctaRow.ts
+var ctaRowFragment = defineFragment({
+  id: "ctaRow",
+  title: "CTA Row",
+  description: "Repeatable calls to action rendered inline.",
+  fields: [createCtasRepeater({ label: "Calls to action", itemLabel: "CTA", maxItems: 3 })],
+  layout: [
+    ctaRow({ collectionPath: "content.ctas", itemName: "cta", justify: "center" })
+  ]
+});
+
+// ../blocks/src/system/fragments/library/ctaCopy.ts
+var ctaCopyFragment = defineFragment({
+  id: "ctaCopy",
+  title: "CTA Copy",
+  description: "Eyebrow, title, and supporting rich text for CTA layouts.",
+  fields: [
+    {
+      id: "eyebrow",
+      type: "text",
+      label: "Eyebrow",
+      description: "Optional short line above the title",
+      visibleRoles: ["designer", "admin"]
+    },
+    {
+      id: "title",
+      type: "text",
+      label: "Title",
+      required: true,
+      maxLength: 120
+    },
+    {
+      id: "content",
+      type: "richText",
+      label: "Copy",
+      description: "Short paragraph of supporting copy."
+    }
+  ],
+  layout: [
+    headingGroup({ eyebrowPath: "content.eyebrow", titlePath: "content.title", className: "cta-heading" }),
+    richText(
+      {
+        className: "cta-content prose prose-lg mx-auto max-w-none sm:prose-xl",
+        style: textColorStyle("neutral-700")
+      },
+      when("content.content"),
+      bind("content.content")
+    )
+  ]
+});
+
+// ../blocks/src/system/fragments/library/testimonialsHeading.ts
+var testimonialsHeadingFragment = defineFragment({
+  id: "testimonialsHeading",
+  title: "Testimonials Heading",
+  description: "Heading and subheading copy for testimonials section.",
+  fields: [
+    {
+      id: "heading",
+      type: "text",
+      label: "Heading",
+      description: "Optional block heading displayed above the testimonials."
+    },
+    {
+      id: "subheading",
+      type: "text",
+      label: "Description",
+      multiline: true,
+      description: "Optional supporting copy shown below the heading."
+    }
+  ],
+  layout: [
+    stack(
+      { gap: "md", className: "mx-auto max-w-2xl text-center" },
+      [
+        text(
+          { as: "h2", className: "text-3xl font-semibold sm:text-4xl", style: textColorStyle("neutral-900") },
+          when("content.heading"),
+          bind("content.heading")
+        ),
+        text(
+          { as: "p", className: "text-lg sm:text-xl", style: textColorStyle("neutral-600") },
+          when("content.subheading"),
+          bind("content.subheading")
+        )
+      ]
+    )
+  ]
+});
+
+// ../blocks/src/system/fragments/library/testimonialsCarousel.ts
+var testimonialsCarouselFragment = defineFragment({
+  id: "testimonialsCarousel",
+  title: "Testimonials Carousel",
+  description: "Carousel layout for testimonial cards with data loader configuration.",
+  fields: [
+    {
+      id: "slidesToShow",
+      type: "select",
+      label: "Testimonials per view",
+      defaultValue: "1",
+      options: [
+        { value: "1", label: "One at a time" },
+        { value: "2", label: "Two at a time" },
+        { value: "3", label: "Three at a time" }
+      ]
+    },
+    {
+      id: "transition",
+      type: "select",
+      label: "Transition",
+      defaultValue: "slide",
+      options: [
+        { value: "slide", label: "Slide" },
+        { value: "fade", label: "Fade" }
+      ]
+    },
+    {
+      id: "maxEntries",
+      type: "select",
+      label: "Testimonials to load",
+      defaultValue: "6",
+      options: [
+        { value: "3", label: "3 testimonials" },
+        { value: "6", label: "6 testimonials" },
+        { value: "9", label: "9 testimonials" }
+      ]
+    }
+  ],
+  layout: [
+    carousel(
+      {
+        className: "mt-12",
+        slidesToShow: { $bind: { from: "slidesToShow", fallback: 1 } },
+        transition: { $bind: { from: "transition", fallback: "slide" } },
+        showControls: true
+      },
+      [
+        stack(
+          {
+            gap: "lg",
+            className: "h-full justify-between rounded-2xl border p-8 shadow-sm",
+            style: mergeStyles(
+              borderColorStyle("neutral-200"),
+              backgroundColorStyle("surface")
+            )
+          },
+          [
+            richText(
+              {
+                className: "prose prose-lg max-w-none sm:prose-xl",
+                style: textColorStyle("neutral-700")
+              },
+              bind("testimonial.content.body"),
+              when("testimonial.content.body")
+            ),
+            inline(
+              { gap: "md", className: "mt-6 items-center" },
+              [
+                media(
+                  { className: "h-12 w-12 shrink-0 rounded-full object-cover" },
+                  bind("testimonial.content.headshot", { transforms: [{ id: "media.fromUrl" }] }),
+                  when("testimonial.content.headshot")
+                ),
+                stack(
+                  { gap: "xs" },
+                  [
+                    text(
+                      { as: "p", className: "font-semibold", style: textColorStyle("neutral-900") },
+                      bind("testimonial.content.name", { fallback: "Anonymous" })
+                    ),
+                    text(
+                      { as: "p", className: "text-sm", style: textColorStyle("neutral-500") },
+                      when("testimonial.content.jobTitle"),
+                      bind("testimonial.content.jobTitle")
+                    ),
+                    text(
+                      { as: "p", className: "text-sm", style: textColorStyle("neutral-500") },
+                      when("testimonial.content.company"),
+                      bind("testimonial.content.company")
+                    )
+                  ]
+                )
+              ]
+            )
+          ],
+          repeat("data.entries", "testimonial")
+        )
+      ]
+    )
+  ],
+  data: {
+    key: "entries",
+    loader: {
+      endpoint: "listPublishedEntries",
+      params: {
+        type: "testimonial",
+        siteId: { $bind: { from: "$root.siteId" } },
+        limit: { $bind: { from: "maxEntries", fallback: "6" } },
+        stage: { $bind: { from: "$root.previewStage", fallback: "published" } }
+      },
+      mode: "server"
+    }
+  }
+});
+
+// ../blocks/src/system/fragments/library/formCopy.ts
+var formCopyFragment = defineFragment({
+  id: "formCopy",
+  title: "Form Copy",
+  description: "Optional title and introduction content for form blocks.",
+  fields: [
+    {
+      id: "title",
+      type: "text",
+      label: "Title"
+    },
+    {
+      id: "intro",
+      type: "richText",
+      label: "Intro",
+      description: "Optional introduction above the form."
+    }
+  ],
+  layout: [
+    text(
+      {
+        as: "h2",
+        className: "text-2xl font-semibold",
+        style: textColorStyle("text")
+      },
+      when("content.title"),
+      bind("content.title")
+    ),
+    richText(
+      {
+        className: "text-base",
+        style: textColorStyle("text")
+      },
+      when("content.intro"),
+      bind("content.intro")
+    )
+  ]
+});
+
+// ../blocks/src/system/fragments/library/formEmbed.ts
+var formEmbedFragment = defineFragment({
+  id: "formEmbed",
+  title: "Form Embed",
+  description: "Embeds a saved form with configurable submit button copy.",
+  fields: [
+    {
+      id: "formId",
+      type: "reference",
+      label: "Form",
+      description: "Pick a saved form to render.",
+      required: true,
+      referenceKind: "form",
+      allowManualEntry: false
+    },
+    {
+      id: "submitLabel",
+      type: "text",
+      label: "Submit button label",
+      defaultValue: "Submit"
+    },
+    {
+      id: "successMessage",
+      type: "text",
+      label: "Success message",
+      description: "Shown after successful submit (handled by page or block)."
+    }
+  ],
+  layout: [
+    form(
+      {
+        submitLabel: { $bind: { from: "submitLabel" } },
+        successMessage: { $bind: { from: "successMessage" } }
+      },
+      [],
+      bind("data.form")
+    )
+  ],
+  data: {
+    key: "form",
+    loader: {
+      endpoint: "getPublicFormById",
+      params: {
+        formId: { $bind: { from: "formId" } }
+      },
+      mode: "server"
+    }
+  }
+});
+
+// ../blocks/src/system/fragments/library/footerBottomText.ts
+var footerBottomTextFragment = defineFragment({
+  id: "footerBottomText",
+  title: "Footer Bottom Text",
+  description: "Rich text content displayed at the bottom of the footer.",
+  fields: [
+    {
+      id: "bottomText",
+      type: "richText",
+      label: "Bottom text",
+      description: "Appears at the very bottom of the footer.",
+      ui: { variant: "limited" }
+    }
+  ],
+  layout: [
+    richText(
+      {
+        className: "prose prose-sm mx-auto max-w-3xl text-center",
+        style: textColorStyle("text/80")
+      },
+      when("bottomText"),
+      bind("bottomText")
+    )
+  ]
+});
+
+// ../blocks/src/system/fragments/library/footerLinkGroups.ts
+var footerLinkGroupsFragment = defineFragment({
+  id: "footerLinkGroups",
+  title: "Footer Link Groups",
+  description: "Repeating columns of grouped footer links.",
+  fields: [
+    {
+      id: "linkGroups",
+      type: "repeater",
+      label: "Link groups",
+      description: "Organize footer links into columns.",
+      schema: {
+        fields: [
+          {
+            id: "title",
+            type: "text",
+            label: "Group title"
+          },
+          {
+            id: "links",
+            type: "repeater",
+            label: "Links",
+            schema: {
+              fields: [
+                {
+                  id: "label",
+                  type: "text",
+                  label: "Label",
+                  required: true
+                },
+                {
+                  id: "link",
+                  type: "link",
+                  label: "Link",
+                  required: true
+                }
+              ]
+            }
+          }
+        ]
+      }
+    }
+  ],
+  layout: [
+    stack(
+      {
+        gap: "lg",
+        align: "start",
+        className: "grid gap-8 md:grid-cols-3"
+      },
+      [
+        stack(
+          { gap: "md", align: "start", className: "text-left" },
+          [
+            text(
+              {
+                as: "h3",
+                className: "text-xs font-semibold uppercase tracking-wide",
+                style: textColorStyle("text/70")
+              },
+              when("group.title"),
+              bind("group.title")
+            ),
+            stack(
+              { gap: "sm", align: "start", className: "space-y-2" },
+              [
+                link(
+                  {
+                    className: "block text-sm transition-theme hover:opacity-80",
+                    style: textColorStyle("text"),
+                    href: {
+                      $bind: {
+                        from: "entry.link",
+                        transforms: [{ id: "links.resolve" }],
+                        fallback: "#"
+                      }
+                    },
+                    target: { $bind: { from: "entry.target" } },
+                    rel: { $bind: { from: "entry.rel" } }
+                  },
+                  [text({ as: "span" }, bind("entry.label"))],
+                  repeat("group.links", "entry")
+                )
+              ]
+            )
+          ],
+          repeat("linkGroups", "group")
+          // Relative path
+        )
+      ],
+      when("linkGroups")
+      // Relative path
+    )
+  ]
+});
+
+// ../blocks/src/system/fragments/library/blogFeaturedPost.ts
+var blogFeaturedPostFragment = defineFragment({
+  id: "blogFeaturedPost",
+  title: "Featured Blog Post",
+  description: "Featured blog post card with title and preview content.",
+  fields: [
+    {
+      id: "title",
+      type: "text",
+      label: "Block title",
+      description: "Displayed above the featured blog post.",
+      defaultValue: "Latest post",
+      maxLength: 120
+    },
+    {
+      id: "postSlug",
+      type: "reference",
+      label: "Blog post",
+      description: "Pick the blog post to feature in this block.",
+      required: true,
+      referenceKind: "post",
+      allowManualEntry: false
+    }
+  ],
+  layout: [
+    sectionContainer(
+      [
+        stack({ gap: "sm", className: "md:w-1/3" }, [
+          text(
+            {
+              as: "h2",
+              className: "text-2xl font-semibold md:text-3xl",
+              style: textColorStyle("neutral-900")
+            },
+            bind("title", { fallback: "Latest post" })
+            // Relative path
+          )
+        ]),
+        stack({ gap: "md", className: "flex-1" }, [
+          stack({
+            gap: "md",
+            className: "rounded-2xl border bg-white p-6 shadow-sm",
+            style: borderColorStyle("neutral-200")
+          }, [
+            link(
+              {
+                className: "block overflow-hidden rounded-xl border",
+                style: borderColorStyle("neutral-100"),
+                href: { $bind: { from: "post.path" } }
+              },
+              [
+                media(
+                  { className: "h-56 w-full object-cover" },
+                  bind("post.image", { transforms: [{ id: "media.fromUrl" }] })
+                )
+              ],
+              when("post.image")
+            ),
+            stack({ gap: "sm" }, [
+              link(
+                {
+                  className: "block text-2xl font-semibold hover:opacity-80",
+                  style: textColorStyle("neutral-900"),
+                  href: { $bind: { from: "post.path" } }
+                },
+                [text({ as: "span" }, bind("post.title"))]
+              ),
+              text(
+                { as: "p", className: "text-sm", style: textColorStyle("neutral-500") },
+                when("post.publishedAt"),
+                bind("post.publishedAt", { transforms: [{ id: "date.formatShort" }] })
+              ),
+              text(
+                { as: "p", className: "text-base", style: textColorStyle("neutral-600") },
+                bind("post.excerpt", { fallback: "Select a blog post to display its preview." })
+              ),
+              link(
+                {
+                  className: "inline-flex items-center text-sm font-semibold hover:opacity-80",
+                  style: textColorStyle("primary"),
+                  href: { $bind: { from: "post.path" } }
+                },
+                [text({ as: "span" }, props({ value: "Read more \u2192" }))]
+              )
+            ])
+          ], when("post")),
+          stack(
+            {
+              gap: "sm",
+              className: "rounded-xl border border-dashed p-6 text-sm",
+              style: mergeStyles(
+                borderColorStyle("neutral-300"),
+                backgroundColorStyle("neutral-50"),
+                textColorStyle("neutral-500")
+              )
+            },
+            [text({ as: "p" }, props({ value: "Select a blog post to display its preview." }))],
+            when("post", { not: true })
+          )
+        ])
+      ],
+      { gap: "lg", className: "w-full md:flex-row md:items-start md:gap-10" }
+    )
+  ],
+  data: {
+    key: "post",
+    loader: {
+      endpoint: "getPublishedEntryPreview",
+      params: {
+        type: "post",
+        slug: { $bind: { from: "postSlug" } },
+        siteId: { $bind: { from: "$root.siteId" } }
+      },
+      mode: "server"
+    }
+  }
+});
+
+// ../blocks/src/system/fragments/library/blogListGrid.ts
+var grid = (props2, children, ...mods) => el("grid", props2 ?? void 0, children ?? void 0, ...mods);
+var blogListGridFragment = defineFragment({
+  id: "blogListGrid",
+  title: "Blog List Grid",
+  description: "Grid layout for displaying blog posts as cards with images.",
+  fields: [
+    {
+      id: "columns",
+      type: "select",
+      label: "Grid columns",
+      description: "Number of columns in the grid layout.",
+      defaultValue: "3",
+      options: [
+        { value: "2", label: "2 columns" },
+        { value: "3", label: "3 columns" },
+        { value: "4", label: "4 columns" }
+      ]
+    },
+    {
+      id: "showImages",
+      type: "boolean",
+      label: "Show images",
+      description: "Display featured images for each post.",
+      defaultValue: true
+    },
+    {
+      id: "showExcerpts",
+      type: "boolean",
+      label: "Show excerpts",
+      description: "Display post preview text.",
+      defaultValue: true
+    },
+    {
+      id: "showDates",
+      type: "boolean",
+      label: "Show dates",
+      description: "Display publish dates.",
+      defaultValue: true
+    }
+  ],
+  layout: [
+    // Grid container
+    grid(
+      {
+        className: "grid grid-cols-1 gap-8 md:grid-cols-2 lg:grid-cols-3"
+      },
+      [
+        // Individual post card
+        stack(
+          {
+            gap: "md",
+            className: "flex flex-col overflow-hidden rounded-xl border shadow-sm transition-shadow hover:shadow-md",
+            style: mergeStyles(
+              borderColorStyle("neutral-200"),
+              backgroundColorStyle("surface")
+            )
+          },
+          [
+            // Featured image
+            link(
+              {
+                className: "block overflow-hidden",
+                href: { $bind: { from: "post.path" } }
+              },
+              [
+                media(
+                  {
+                    className: "h-56 w-full object-cover transition-transform hover:scale-105"
+                  },
+                  bind("post.image", { transforms: [{ id: "media.fromUrl" }] })
+                )
+              ],
+              when("post.image"),
+              when("showImages")
+            ),
+            // Post content
+            stack({ gap: "sm", className: "flex-1 p-6" }, [
+              // Title
+              link(
+                {
+                  href: { $bind: { from: "post.path" } },
+                  className: "block text-xl font-semibold transition-colors hover:opacity-80",
+                  style: textColorStyle("neutral-900")
+                },
+                [text({ as: "h3" }, bind("post.title"))]
+              ),
+              // Date
+              text(
+                {
+                  as: "time",
+                  className: "text-sm",
+                  style: textColorStyle("neutral-500")
+                },
+                bind("post.publishedAt", { transforms: [{ id: "date.formatShort" }] }),
+                when("post.publishedAt"),
+                when("showDates")
+              ),
+              // Excerpt
+              text(
+                {
+                  as: "p",
+                  className: "mt-2 text-base line-clamp-3",
+                  style: textColorStyle("neutral-600")
+                },
+                bind("post.excerpt"),
+                when("post.excerpt"),
+                when("showExcerpts")
+              ),
+              // Read more button
+              button(
+                {
+                  href: { $bind: { from: "post.path" } },
+                  className: {
+                    $bind: { from: "readMoreVariant", fallback: "primary" },
+                    $prepend: "button-"
+                  }
+                },
+                [text({ as: "span" }, bind("readMoreText", { fallback: "Read more \u2192" }))]
+              )
+            ])
+          ],
+          repeat("data.posts", "post")
+        )
+      ]
+    )
+  ],
+  data: {
+    key: "posts",
+    loader: {
+      endpoint: "listPublishedEntries",
+      params: {
+        type: "post",
+        siteId: { $bind: { from: "$root.siteId" } },
+        limit: { $bind: { from: "postsPerPage", fallback: "12" } },
+        stage: { $bind: { from: "$root.previewStage", fallback: "published" } }
+      },
+      mode: "server"
+    }
+  }
+});
+
+// ../blocks/src/system/fragments/library/blogListStack.ts
+var blogListStackFragment = defineFragment({
+  id: "blogListStack",
+  title: "Blog List Stack",
+  description: "Vertical list layout for displaying blog posts with optional thumbnails.",
+  fields: [
+    {
+      id: "showImages",
+      type: "boolean",
+      label: "Show images",
+      description: "Display thumbnail images for each post.",
+      defaultValue: true
+    },
+    {
+      id: "showExcerpts",
+      type: "boolean",
+      label: "Show excerpts",
+      description: "Display post preview text.",
+      defaultValue: true
+    },
+    {
+      id: "showDates",
+      type: "boolean",
+      label: "Show dates",
+      description: "Display publish dates.",
+      defaultValue: true
+    }
+  ],
+  layout: [
+    // Vertical stack container
+    stack({ gap: "lg", className: "mx-auto max-w-3xl" }, [
+      // Individual post row
+      inline(
+        {
+          gap: "md",
+          className: "items-start border-b pb-6 last:border-b-0",
+          style: borderColorStyle("neutral-200")
+        },
+        [
+          // Optional thumbnail (left-aligned)
+          link(
+            {
+              href: { $bind: { from: "post.path" } },
+              className: "flex-shrink-0"
+            },
+            [
+              media(
+                {
+                  className: "h-24 w-24 rounded-lg object-cover transition-transform hover:scale-105"
+                },
+                bind("post.image", { transforms: [{ id: "media.fromUrl" }] })
+              )
+            ],
+            when("post.image"),
+            when("showImages")
+          ),
+          // Post content (grows to fill space)
+          stack({ gap: "sm", className: "flex-1 min-w-0" }, [
+            // Title
+            link(
+              {
+                href: { $bind: { from: "post.path" } },
+                className: "block text-xl font-semibold transition-colors hover:opacity-80",
+                style: textColorStyle("neutral-900")
+              },
+              [text({ as: "h3" }, bind("post.title"))]
+            ),
+            // Date
+            text(
+              {
+                as: "time",
+                className: "text-sm",
+                style: textColorStyle("neutral-500")
+              },
+              bind("post.publishedAt", { transforms: [{ id: "date.formatShort" }] }),
+              when("post.publishedAt"),
+              when("showDates")
+            ),
+            // Excerpt
+            text(
+              {
+                as: "p",
+                className: "text-sm line-clamp-2",
+                style: textColorStyle("neutral-600")
+              },
+              bind("post.excerpt"),
+              when("post.excerpt"),
+              when("showExcerpts")
+            ),
+            // Read more button
+            button(
+              {
+                href: { $bind: { from: "post.path" } },
+                className: {
+                  $bind: { from: "readMoreVariant", fallback: "primary" },
+                  $prepend: "button-"
+                }
+              },
+              [text({ as: "span" }, bind("readMoreText", { fallback: "Read more \u2192" }))]
+            )
+          ])
+        ],
+        repeat("data.posts", "post")
+      )
+    ])
+  ],
+  data: {
+    key: "posts",
+    loader: {
+      endpoint: "listPublishedEntries",
+      params: {
+        type: "post",
+        siteId: { $bind: { from: "$root.siteId" } },
+        limit: { $bind: { from: "postsPerPage", fallback: "12" } },
+        stage: { $bind: { from: "$root.previewStage", fallback: "published" } }
+      },
+      mode: "server"
+    }
+  }
+});
+
+// ../blocks/src/system/fragments/library/faqHeading.ts
+var faqHeadingFragment = defineFragment({
+  id: "faqHeading",
+  title: "FAQ Heading",
+  description: "Optional eyebrow, title, and description for FAQ sections.",
+  fields: [
+    {
+      id: "eyebrow",
+      type: "text",
+      label: "Eyebrow",
+      description: "Short label displayed above the title.",
+      visibleRoles: ["designer", "admin"],
+      maxLength: 60
+    },
+    {
+      id: "title",
+      type: "text",
+      label: "Title",
+      required: false,
+      maxLength: 120
+    },
+    {
+      id: "description",
+      type: "richText",
+      label: "Description",
+      required: false,
+      ui: { variant: "limited" }
+    }
+  ],
+  layout: stack(
+    {
+      gap: "sm",
+      className: "mx-auto max-w-3xl text-center mb-4"
+    },
+    [
+      text(
+        {
+          as: "p",
+          className: "faq-eyebrow text-sm font-semibold uppercase tracking-wide",
+          style: textColorStyle("primary")
+        },
+        when("content.eyebrow"),
+        bind("content.eyebrow")
+      ),
+      text(
+        {
+          as: "h2",
+          className: "faq-title text-3xl font-semibold sm:text-4xl",
+          style: textColorStyle("neutral-900")
+        },
+        when("content.title"),
+        bind("content.title")
+      ),
+      richText(
+        {
+          className: "faq-description prose mx-auto max-w-none text-base sm:text-lg",
+          style: textColorStyle("neutral-600")
+        },
+        when("content.description"),
+        bind("content.description")
+      )
+    ]
+  )
+});
+
+// ../blocks/src/system/fragments/library/faqAccordion.ts
+var faqAccordionFragment = defineFragment({
+  id: "faqAccordion",
+  title: "FAQ Accordion",
+  description: "Expandable list of question and answer pairs.",
+  fields: [
+    {
+      id: "items",
+      type: "repeater",
+      label: "FAQ items",
+      itemLabel: "FAQ item",
+      itemLabelSource: "question",
+      minItems: 1,
+      maxItems: 30,
+      schema: {
+        fields: [
+          {
+            id: "question",
+            type: "text",
+            label: "Question",
+            required: true,
+            maxLength: 160
+          },
+          {
+            id: "answer",
+            type: "richText",
+            label: "Answer",
+            required: true,
+            ui: { variant: "limited" }
+          }
+        ]
+      }
+    }
+  ],
+  layout: accordionList({
+    collection: "content.items",
+    itemName: "faqItem",
+    indexName: "faqIndex",
+    accordionProps: {
+      className: "accordion-root",
+      // CSS-first: all styling handled by theme CSS
+      type: "single",
+      collapsible: true
+    },
+    itemProps: {
+      className: "accordion-item",
+      iconStyle: { $bind: { from: "theme.accordions.icon.style" } }
+      // Pass icon style from theme
+    },
+    triggerFrom: "faqItem.question",
+    contentFrom: "faqItem.answer"
+  })
+});
+
+// ../blocks/src/system/fragments/library/card.ts
+var cardFragment = defineFragment({
+  id: "card",
+  title: "Card",
+  description: "Content card with optional media, title, body, and action buttons",
+  category: "content",
+  icon: "LayoutCard",
+  fields: [
+    {
+      id: "media",
+      type: "media",
+      label: "Featured media",
+      description: "Image or video displayed at top of card",
+      required: false,
+      mediaKinds: ["image", "video"]
+    },
+    {
+      id: "aspectRatio",
+      type: "select",
+      label: "Media aspect ratio",
+      defaultValue: "auto",
+      options: [
+        { value: "auto", label: "Auto" },
+        { value: "16/9", label: "16:9 (Landscape)" },
+        { value: "4/3", label: "4:3 (Standard)" },
+        { value: "1/1", label: "1:1 (Square)" },
+        { value: "3/4", label: "3:4 (Portrait)" }
+      ],
+      condition: {
+        field: "media",
+        operator: "isNotEmpty"
+      }
+    },
+    {
+      id: "title",
+      type: "text",
+      label: "Title",
+      required: true,
+      maxLength: 120
+    },
+    {
+      id: "body",
+      type: "richText",
+      label: "Body",
+      description: "Main card content",
+      format: "markdown"
+    },
+    createCtasRepeater({
+      id: "ctas",
+      label: "Action buttons",
+      itemLabel: "Button",
+      minItems: 0,
+      maxItems: 3
+    }),
+    {
+      id: "variant",
+      type: "select",
+      label: "Card variant",
+      description: "Choose a card style from your theme",
+      required: false,
+      defaultValue: "default",
+      options: [
+        { value: "default", label: "Default" },
+        { value: "variant1", label: "Variant 1" },
+        { value: "variant2", label: "Variant 2" }
+      ]
+    }
+  ],
+  layout: stack(
+    {
+      gap: "none",
+      className: {
+        $bind: {
+          from: "variant",
+          fallback: "default"
+        },
+        $prepend: "card-"
+      }
+    },
+    [
+      // Featured media at top (conditional) - full width, no padding
+      // CSS handles corner radius via .card-{variant} .card-media selector
+      media(
+        {
+          className: "card-media w-full h-auto object-cover",
+          style: {
+            aspectRatio: { $bind: { from: "aspectRatio" } }
+          }
+        },
+        when("media"),
+        bind("media")
+      ),
+      // Content wrapper with padding based on variant
+      // CSS handles padding via .card-{variant} .card-content selector
+      stack(
+        {
+          gap: "sm",
+          className: "card-content"
+        },
+        [
+          text(
+            {
+              as: "h3",
+              className: "card-title text-xl font-semibold"
+            },
+            bind("title")
+          ),
+          richText(
+            {
+              className: "card-body text-base",
+              style: textColorStyle("mutedText")
+            },
+            when("body"),
+            bind("body")
+          ),
+          // Action buttons at bottom (conditional)
+          ctaRow({
+            collectionPath: "ctas",
+            itemName: "cta",
+            gap: "sm",
+            justify: "start",
+            containerClassName: "mt-2"
+          })
+        ]
+      )
+    ]
+  )
+});
+
+// ../blocks/src/system/fragments/library/heading.ts
+var headingFragment = defineFragment({
+  id: "heading",
+  title: "Heading",
+  description: "Text heading",
+  category: "content",
+  icon: "Heading",
+  fields: [
+    {
+      id: "text",
+      type: "text",
+      label: "Heading text",
+      required: true,
+      maxLength: 200
+    },
+    {
+      id: "level",
+      type: "select",
+      label: "Heading level",
+      defaultValue: "h2",
+      options: [
+        { value: "h1", label: "H1 (Large)" },
+        { value: "h2", label: "H2 (Medium)" },
+        { value: "h3", label: "H3 (Small)" }
+      ]
+    }
+  ],
+  layout: text(
+    {
+      as: { $bind: { from: "level" } },
+      // Relative path - resolves to current scope
+      className: "fragment-heading font-bold"
+    },
+    bind("text")
+    // Relative path - resolves to current scope
+  )
+});
+
+// ../blocks/src/system/fragments/library/richText.ts
+var richTextFragment = defineFragment({
+  id: "richText",
+  title: "Rich Text",
+  description: "Formatted text with markdown",
+  category: "content",
+  icon: "FileText",
+  fields: [
+    {
+      id: "content",
+      type: "richText",
+      label: "Content",
+      required: true,
+      format: "markdown"
+    }
+  ],
+  layout: richText(
+    {
+      className: "fragment-richtext prose prose-neutral"
+    },
+    bind("content")
+    // Relative path - resolves to current scope
+  )
+});
+
+// ../blocks/src/system/fragments/utils/toRepeaterSchema.ts
+function fragmentsToRepeaterField(id, label, fragments, options = {}) {
+  return {
+    id,
+    type: "repeater",
+    label,
+    description: options.description,
+    polymorphic: true,
+    itemLabel: options.itemLabel ?? "Item",
+    itemLabelSource: "_type",
+    minItems: options.minItems ?? 0,
+    maxItems: options.maxItems,
+    allowConversion: options.allowConversion ?? true,
+    required: false,
+    itemTypes: Object.fromEntries(
+      Object.entries(fragments).map(([typeId, fragment]) => [
+        typeId,
+        {
+          label: fragment.title ?? typeId,
+          icon: fragment.icon,
+          fields: fragment.fields
+        }
+      ])
+    )
+  };
+}
+
+// ../blocks/src/system/fragments/library/image.ts
+var imageFragment = defineFragment({
+  id: "image",
+  title: "Image",
+  description: "Image with optional caption",
+  category: "content",
+  icon: "Image",
+  fields: [
+    {
+      id: "image",
+      type: "media",
+      label: "Image",
+      required: true,
+      mediaKinds: ["image"]
+    },
+    {
+      id: "caption",
+      type: "text",
+      label: "Caption",
+      required: false,
+      maxLength: 200
+    },
+    {
+      id: "aspectRatio",
+      type: "select",
+      label: "Aspect ratio",
+      defaultValue: "auto",
+      options: [
+        { value: "auto", label: "Auto" },
+        { value: "16/9", label: "16:9 (Landscape)" },
+        { value: "4/3", label: "4:3 (Standard)" },
+        { value: "1/1", label: "1:1 (Square)" },
+        { value: "3/4", label: "3:4 (Portrait)" }
+      ]
+    }
+  ],
+  layout: stack({ gap: "sm" }, [
+    media(
+      {
+        className: "fragment-image w-full h-auto object-cover",
+        style: {
+          aspectRatio: { $bind: { from: "aspectRatio" } }
+        }
+      },
+      bind("image")
+    ),
+    text(
+      {
+        as: "p",
+        className: "image-caption text-sm text-center",
+        style: textColorStyle("mutedText")
+      },
+      when("caption"),
+      bind("caption")
+    )
+  ])
+});
+
+// ../blocks/src/system/fragments/library/columnContent.ts
+var columnContentFragment = defineFragment({
+  id: "columnContent",
+  title: "Column",
+  description: "A single column with customizable content",
+  category: "layout",
+  icon: "RectangleVertical",
+  fields: [
+    fragmentsToRepeaterField(
+      "items",
+      "Column items",
+      {
+        image: imageFragment,
+        heading: headingFragment,
+        richText: richTextFragment
+      },
+      {
+        minItems: 0,
+        maxItems: 20,
+        itemLabel: "Item",
+        description: "Add content to this column"
+      }
+    )
+  ],
+  layout: stack(
+    { gap: "md", className: "h-full" },
+    [
+      {
+        type: "stack",
+        gap: "md",
+        children: typeBasedLayout(
+          {
+            image: imageFragment.layout,
+            heading: headingFragment.layout,
+            richText: richTextFragment.layout
+          },
+          { itemName: "item" }
+        ),
+        $repeat: {
+          collection: { from: "items" },
+          itemName: "item"
+        }
+      }
+    ]
+  )
+});
+
+// ../blocks/src/system/constants/background.ts
+var BACKGROUND_POSITION_PRESETS = [
+  { value: "center", label: "Center" },
+  { value: "top", label: "Top" },
+  { value: "top left", label: "Top Left" },
+  { value: "top right", label: "Top Right" },
+  { value: "bottom", label: "Bottom" },
+  { value: "bottom left", label: "Bottom Left" },
+  { value: "bottom right", label: "Bottom Right" },
+  { value: "left", label: "Left" },
+  { value: "right", label: "Right" },
+  // The following are valid keywords but are not included in the UI to reduce clutter.
+  // They are included here to ensure the transform logic can correctly identify them as presets.
+  { value: "top center", label: "Top Center" },
+  { value: "bottom center", label: "Bottom Center" },
+  { value: "left center", label: "Left Center" },
+  { value: "right center", label: "Right Center" },
+  { value: "left top", label: "Left Top" },
+  { value: "right top", label: "Right Top" },
+  { value: "left bottom", label: "Left Bottom" },
+  { value: "right bottom", label: "Right Bottom" }
+];
+BACKGROUND_POSITION_PRESETS.map((p) => p.value);
+
+// ../blocks/src/system/fields/background.ts
+function createBackgroundField(options = {}) {
+  const {
+    id = "background",
+    label = "Background",
+    allowColor = true,
+    allowGradient = true,
+    allowImage = true,
+    includeAdvanced = false
+  } = options;
+  const tabs = [];
+  if (allowColor) {
+    tabs.push({
+      id: "color",
+      label: "Color",
+      description: "Solid color background using theme tokens or custom colors",
+      sdkSectionOption: "backgroundColor",
+      fields: [
+        {
+          id: "color",
+          type: "text",
+          label: "Color",
+          description: "Select a background color from the available options.",
+          required: false,
+          multiline: false,
+          ui: {
+            // Use BackgroundColorWidget via widget override
+            widget: "backgroundColor"
+          }
+        }
+      ]
+    });
+  }
+  if (allowGradient) {
+    tabs.push({
+      id: "gradient",
+      label: "Gradient",
+      description: "CSS gradient background",
+      sdkSectionOption: "backgroundGradient",
+      fields: [
+        {
+          id: "gradient",
+          type: "text",
+          label: "Gradient",
+          description: "CSS gradient value (e.g., linear-gradient(to right, #ff0000, #00ff00)).",
+          required: false,
+          multiline: true,
+          ui: {
+            placeholder: "linear-gradient(to right, #ff0000, #00ff00)"
+          }
+        }
+      ]
+    });
+  }
+  if (allowImage) {
+    const imageFields = [
+      {
+        id: "image",
+        type: "media",
+        label: "Image",
+        description: "Background image file",
+        mediaKinds: ["image"],
+        required: false
+      }
+    ];
+    if (includeAdvanced) {
+      const objectFitField = {
+        id: "objectFit",
+        type: "select",
+        label: "Image Sizing",
+        description: "How the image should be sized and positioned.",
+        required: false,
+        multiple: false,
+        options: [
+          { value: "fill", label: "Fill (cover)" },
+          { value: "fit", label: "Fit (contain)" },
+          { value: "original", label: "Original size" },
+          { value: "custom", label: "Scale up" }
+        ]
+      };
+      const scaleField = {
+        id: "scale",
+        type: "presetOrCustom",
+        label: "Scale",
+        description: "Image scale amount.",
+        required: false,
+        ui: {
+          visibleWhen: {
+            field: "objectFit",
+            equals: "custom"
+          }
+        },
+        presets: [
+          { value: "125", label: "125%" },
+          { value: "150", label: "150%" },
+          { value: "175", label: "175%" },
+          { value: "200", label: "200%" }
+        ],
+        customInput: {
+          placeholder: "e.g., 800px, 50vw, 175%",
+          helpText: "Enter a custom size using %, px, vh, vw, rem, or em units"
+        }
+      };
+      const positionField = {
+        id: "position",
+        type: "presetOrCustom",
+        label: "Position",
+        description: 'Anchor point for the image. Relevant for "Fill" and "Custom size" options.',
+        required: false,
+        presets: [...BACKGROUND_POSITION_PRESETS],
+        customInput: {
+          placeholder: "e.g., 25% 75%, top 20px left 50px",
+          helpText: "Enter a custom CSS background-position value"
+        }
+      };
+      const opacityField = {
+        id: "opacity",
+        type: "number",
+        label: "Opacity",
+        description: "Image opacity (0-100).",
+        required: false,
+        ui: {
+          min: 0,
+          max: 100,
+          step: 5
+        }
+      };
+      imageFields.push(
+        objectFitField,
+        scaleField,
+        positionField,
+        opacityField
+      );
+    }
+    tabs.push({
+      id: "image",
+      label: "Image",
+      description: includeAdvanced ? "Background image with advanced controls" : "Background image",
+      sdkSectionOption: "backgroundImage",
+      fields: imageFields
+    });
+  }
+  return {
+    id,
+    type: "tabGroup",
+    label,
+    required: false,
+    tabs,
+    activeTabField: "type",
+    ui: {
+      hideLabel: false
+    }
+  };
+}
+
+// ../blocks/src/system/fields/boxStyles.ts
+function sectionStylesField(options = {}) {
+  const {
+    id = "_sectionStyles",
+    label = "Section styles",
+    includeBackground = true
+  } = options;
+  const fields4 = [];
+  if (includeBackground) {
+    fields4.push(
+      createBackgroundField({
+        id: "background",
+        label: "Background",
+        allowColor: true,
+        allowGradient: true,
+        allowImage: true,
+        includeAdvanced: true
+      })
+    );
+  }
+  fields4.push({
+    id: "spacing",
+    type: "select",
+    label: "Inner spacing",
+    description: "Vertical padding for the section.",
+    required: false,
+    multiple: false,
+    options: [
+      { value: "none", label: "None" },
+      { value: "compact", label: "Compact" },
+      { value: "cozy", label: "Cozy" },
+      { value: "medium", label: "Medium" },
+      { value: "comfortable", label: "Comfortable" },
+      { value: "spacious", label: "Spacious" }
+    ]
+  });
+  return {
+    id,
+    type: "modal",
+    label,
+    required: false,
+    schema: { fields: fields4 },
+    ui: {
+      modalConfig: {
+        buttonLabel: label,
+        description: "Configure background and spacing for this section.",
+        buttonVariant: "outline",
+        showCustomizedIndicator: true
+      }
+    }
+  };
+}
+
+// ../blocks/src/system/defineBlock.ts
+function createBlockManifest(config) {
+  const composition2 = config.fragments ? composeFragments(config.fragments) : { fields: []};
+  const allFields = [
+    ...composition2.fields,
+    ...config.additionalFields ?? []
+  ];
+  if (!config.skipSectionStyles) {
+    allFields.push(
+      sectionStylesField({
+        id: "_sectionStyles",
+        label: "Section styles"
+      })
+    );
+  }
+  const fields4 = fieldSchema.array().parse(allFields);
+  const layout = config.layout;
+  const variants = config.variants;
+  let behaviours = config.behaviours;
+  if (!behaviours && config.paletteHidden !== void 0) {
+    behaviours = {
+      supportsThemeSwitching: true,
+      inlineEditing: true,
+      animation: true,
+      paletteHidden: config.paletteHidden
+    };
+  }
+  const manifest = {
+    name: config.id,
+    version: "0.1.0",
+    title: config.title,
+    titleSource: config.titleSource,
+    description: config.description ?? "",
+    component: config.component ?? deriveComponentName(config.id),
+    fields: fields4,
+    slots: [],
+    // Always empty
+    styleTokens: config.styleTokens,
+    behaviours,
+    category: config.category,
+    contentTypes: config.contentTypes,
+    tags: config.tags ?? [],
+    icon: config.icon ?? "Box",
+    layout,
+    variants,
+    defaultVariant: config.defaultVariant
+  };
+  return augmentManifest(manifest);
+}
+function deriveComponentName(id) {
+  const base = id.replace(/^block\./, "");
+  const dotSeparated = base.replace(/([a-z])([A-Z])/g, "$1.$2").toLowerCase();
+  return `${dotSeparated}.default`;
+}
+
+// ../blocks/src/system/blocks/hero.ts
+var heroCopyAndCta = composeFragments([
+  { fragment: heroCopyFragment },
+  { fragment: ctaRowFragment }
+]);
+var heroContentNodes = heroCopyAndCta.layout;
+var classicLayout = styledSection({
+  children: sectionContainer(heroContentNodes, {
+    gap: "md",
+    className: "text-center"
+  })
+});
+var microLayout = styledSection({
+  children: sectionContainer(heroContentNodes, {
+    gap: "sm",
+    className: "text-center"
+  }),
+  spacing: "compact"
+});
+var splitLayoutBase = styledSection({
+  children: {
+    type: "grid",
+    cols: 1,
+    colsSm: 2,
+    gap: "lg",
+    className: "mx-auto max-w-7xl items-center",
+    children: [
+      {
+        type: "stack",
+        gap: "md",
+        className: "text-left",
+        children: heroContentNodes
+      }
+    ]
+  }
+});
+var splitLayout = splitLayoutBase;
+var splitReverseLayout = splitLayoutBase;
+var heroManifest = createBlockManifest({
+  id: "block.hero",
+  title: "Hero",
+  titleSource: "headline",
+  category: "layout",
+  fragments: [
+    { fragment: heroCopyFragment, fieldPriority: 0 },
+    { fragment: ctaRowFragment, fieldPriority: 2 }
+  ],
+  layout: classicLayout,
+  variants: {
+    classic: classicLayout,
+    micro: microLayout,
+    split: splitLayout,
+    splitReverse: splitReverseLayout
+  },
+  defaultVariant: "classic",
+  description: "Hero section with headline, subtitle, and repeatable CTAs.",
+  tags: ["header", "banner", "landing", "introduction", "welcome", "splash", "headline"],
+  icon: "Sparkles",
+  styleTokens: {
+    typography: "display",
+    spacing: "xl"
+  }
+});
+var heroBlockDefinition = {
+  manifest: heroManifest
+};
+
+// ../blocks/src/system/blocks/body-text.ts
+var bodyCopyComposition = composeFragments([{ fragment: bodyCopyFragment }]);
+var bodyTextManifest = createBlockManifest({
+  id: "block.bodyText",
+  title: "Body Text",
+  titleSource: "heading",
+  category: "content",
+  component: "body.text.basic",
+  fragments: [
+    { fragment: bodyCopyFragment, fieldPriority: 0 }
+  ],
+  layout: styledSection({
+    children: bodyCopyComposition.layout,
+    spacing: "medium"
+  }),
+  description: "Simple text block with optional heading and alignment controls.",
+  tags: ["text", "paragraph", "content", "copy", "article", "writing", "rich-text"],
+  icon: "Type",
+  styleTokens: {
+    spacing: "md"
+  }
+});
+var bodyTextBlockDefinition = {
+  manifest: bodyTextManifest
+};
+var composition = composeFragments([{ fragment: blogFeaturedPostFragment }]);
+var fields = fieldSchema.array().parse(composition.fields);
+var blogPostLayout = section(
+  { background: "background/base", className: "px-6 py-12" },
+  [...composition.layout]
+);
+var blogPostManifest = {
+  name: "block.blogPost",
+  version: "0.1.0",
+  title: "Blog post",
+  description: "Highlights a single blog post with title, image, and excerpt.",
+  component: "blog.post.highlight",
+  fields,
+  slots: [],
+  styleTokens: {
+    background: "surface",
+    typography: "body",
+    spacing: "md"
+  },
+  behaviours: {
+    supportsThemeSwitching: true,
+    inlineEditing: false,
+    animation: false,
+    paletteHidden: false
+  },
+  category: "blog",
+  contentTypes: ["post"],
+  tags: ["blog", "post", "featured", "highlight", "article", "single"],
+  icon: "FileText",
+  layout: blogPostLayout
+};
+var blogPostDataSchema = zod.z.object({
+  id: zod.z.string(),
+  title: zod.z.string(),
+  slug: zod.z.string(),
+  path: zod.z.string(),
+  excerpt: zod.z.string().nullable().optional(),
+  image: zod.z.object({
+    url: zod.z.string().optional().nullable(),
+    alt: zod.z.string().optional().nullable()
+  }).nullable().optional(),
+  publishedAt: zod.z.string().nullable().optional()
+});
+var blogPostBlockDefinition = {
+  manifest: blogPostManifest,
+  dataSchemas: { post: blogPostDataSchema.optional() },
+  dataLoaders: buildFragmentDataLoaders(composition)
+};
+
+// ../blocks/src/system/blocks/blog-placeholder.ts
+var grid2 = (props2, children, ...mods) => el("grid", props2 ?? void 0, children ?? void 0, ...mods);
+var blogPlaceholderLayout = section(
+  { background: "surface", className: "px-6 py-16 sm:py-20 md:py-24" },
+  // Semantic: comfortable + extra md padding
+  [
+    stack(
+      { gap: "sm", align: "center", className: "mx-auto max-w-3xl text-center" },
+      [
+        text(
+          { as: "p", className: "text-sm font-semibold uppercase tracking-wide", style: textColorStyle("mutedText") },
+          bind("content.eyebrow")
+        ),
+        text(
+          { as: "h2", className: "text-3xl font-semibold tracking-tight sm:text-4xl", style: textColorStyle("text") },
+          bind("content.heading")
+        ),
+        text(
+          { className: "text-base leading-relaxed", style: textColorStyle("mutedText") },
+          bind("content.description")
+        )
+      ]
+    ),
+    grid2(
+      { className: "mt-10 gap-6 sm:grid-cols-2 lg:grid-cols-3" },
+      [
+        stack(
+          {
+            gap: "sm",
+            className: "rounded-xl border p-6 text-left shadow-sm",
+            style: mergeStyles(borderColorStyle("border/60"), backgroundColorStyle("background"))
+          },
+          [
+            text(
+              { as: "h3", className: "text-lg font-semibold", style: textColorStyle("text") },
+              bind("item.title")
+            ),
+            text(
+              { className: "text-sm leading-relaxed", style: textColorStyle("mutedText") },
+              bind("item.summary")
+            )
+          ],
+          repeat("content.cards", "item", { limit: 6 })
+        )
+      ]
+    ),
+    stack(
+      { gap: "xs", align: "center", className: "mt-10 text-center" },
+      [
+        text({ className: "text-sm", style: textColorStyle("mutedText") }, bind("content.note"))
+      ]
+    )
+  ]
+);
+var blogPlaceholderManifest = createBlockManifest({
+  id: "block.blogPlaceholder",
+  title: "Blog placeholder",
+  category: "blog",
+  component: "blog.placeholder",
+  // Skip section styles - this block has custom layout with fixed styling
+  skipSectionStyles: true,
+  // Custom fields for blog placeholder content
+  additionalFields: [
+    fieldSchema.parse({
+      id: "eyebrow",
+      type: "text",
+      label: "Eyebrow",
+      description: "Short label displayed above the heading."
+    }),
+    fieldSchema.parse({
+      id: "heading",
+      type: "text",
+      label: "Heading",
+      required: true
+    }),
+    fieldSchema.parse({
+      id: "description",
+      type: "text",
+      label: "Description",
+      multiline: true
+    }),
+    fieldSchema.parse({
+      id: "cards",
+      type: "repeater",
+      label: "Placeholder cards",
+      itemLabel: "Placeholder",
+      schema: {
+        fields: [
+          { id: "title", type: "text", label: "Title", required: true },
+          { id: "summary", type: "text", label: "Summary", multiline: true, required: true }
+        ]
+      }
+    }),
+    fieldSchema.parse({
+      id: "note",
+      type: "text",
+      label: "Footer note",
+      description: "Optional helper text displayed below the cards."
+    })
+  ],
+  layout: blogPlaceholderLayout,
+  description: "Starter layout shown until real blog content replaces it.",
+  styleTokens: {
+    background: "surface",
+    spacing: "lg"
+  },
+  paletteHidden: true
+});
+var blogPlaceholderBlockDefinition = {
+  manifest: blogPlaceholderManifest
+};
+var gridComposition = composeFragments([{ fragment: blogListGridFragment }]);
+var stackComposition = composeFragments([{ fragment: blogListStackFragment }]);
+var fragmentFields = [...gridComposition.fields, ...stackComposition.fields];
+var uniqueFields = fragmentFields.filter(
+  (field, index, self) => index === self.findIndex((f) => f.id === field.id)
+);
+var blogListingLayout = section(
+  { background: "background/base", className: "px-6 py-12 sm:py-16 md:py-20" },
+  // Semantic: medium + extra md padding
+  [
+    // Grid layout (conditionally shown)
+    ...gridComposition.layout.map((node) => ({
+      ...node,
+      $when: {
+        when: { from: "content.layout" },
+        equals: "grid"
+      }
+    })),
+    // Stack layout (conditionally shown)
+    ...stackComposition.layout.map((node) => ({
+      ...node,
+      $when: {
+        when: { from: "content.layout" },
+        equals: "stack"
+      }
+    })),
+    // Empty state (shown when no posts)
+    stack(
+      {
+        gap: "sm",
+        className: "mx-auto max-w-3xl rounded-xl border border-dashed p-12 text-center",
+        style: mergeStyles(
+          borderColorStyle("neutral-300"),
+          backgroundColorStyle("neutral-50")
+        )
+      },
+      [
+        text(
+          { as: "p", className: "text-base", style: textColorStyle("neutral-500") },
+          bind("content.emptyMessage", { fallback: "No posts published yet." })
+        )
+      ],
+      when("data.posts", { not: true })
+    )
+  ]
+);
+var blogListingManifest = createBlockManifest({
+  id: "block.blogListing",
+  title: "Blog listing",
+  category: "blog",
+  component: "blog.listing",
+  // Skip section styles - this block has layout-specific fields instead
+  skipSectionStyles: true,
+  // Custom fields for blog listing configuration
+  additionalFields: [
+    fieldSchema.parse({
+      id: "layout",
+      type: "select",
+      label: "Layout",
+      description: "Choose how blog posts are displayed.",
+      defaultValue: "grid",
+      options: [
+        { value: "grid", label: "Grid (cards)" },
+        { value: "stack", label: "Stack (vertical list)" }
+      ]
+    }),
+    // Grid-specific column field (only visible when layout is grid)
+    ...gridComposition.fields.filter((f) => f.id === "columns").map((f) => ({
+      ...f,
+      ui: {
+        ...f.ui,
+        visibleWhen: { field: "layout", equals: "grid" }
+      }
+    })),
+    fieldSchema.parse({
+      id: "postsPerPage",
+      type: "select",
+      label: "Posts to display",
+      description: "Number of posts to show on this page.",
+      defaultValue: "12",
+      options: [
+        { value: "6", label: "6 posts" },
+        { value: "12", label: "12 posts" },
+        { value: "24", label: "24 posts" },
+        { value: "48", label: "48 posts" }
+      ]
+    }),
+    // Shared toggle fields from fragments (now unscoped)
+    ...uniqueFields.filter((f) => ["showImages", "showExcerpts", "showDates"].includes(f.id)),
+    fieldSchema.parse({
+      id: "readMoreText",
+      type: "text",
+      label: "Read more text",
+      description: "Text for the read more button/link.",
+      defaultValue: "Read more \u2192",
+      maxLength: 40
+    }),
+    fieldSchema.parse({
+      id: "readMoreVariant",
+      type: "select",
+      label: "Read more style",
+      description: "Visual style for the read more button.",
+      defaultValue: "link",
+      options: [
+        { value: "link", label: "Link (minimal)" },
+        { value: "primary", label: "Primary button" },
+        { value: "secondary", label: "Secondary button" },
+        { value: "outline", label: "Outline button" }
+      ]
+    }),
+    fieldSchema.parse({
+      id: "emptyMessage",
+      type: "text",
+      label: "Empty state message",
+      description: "Message shown when no posts are available.",
+      defaultValue: "No posts published yet.",
+      maxLength: 200
+    })
+  ],
+  layout: blogListingLayout,
+  description: "Display a collection of blog posts in grid or stack layout.",
+  contentTypes: ["post"],
+  tags: ["blog", "posts", "articles", "news", "archive", "listing", "feed", "index"],
+  icon: "Newspaper",
+  styleTokens: {
+    background: "surface",
+    spacing: "lg"
+  }
+});
+var blogPostListEntrySchema = zod.z.object({
+  id: zod.z.string(),
+  slug: zod.z.string(),
+  path: zod.z.string(),
+  title: zod.z.string(),
+  excerpt: zod.z.string().nullable().optional(),
+  publishedAt: zod.z.string().nullable().optional(),
+  updatedAt: zod.z.string(),
+  status: zod.z.string(),
+  image: zod.z.object({
+    url: zod.z.string(),
+    alt: zod.z.string().optional()
+  }).nullable().optional()
+});
+var blogListingBlockDefinition = {
+  manifest: blogListingManifest,
+  dataSchemas: {
+    posts: zod.z.array(blogPostListEntrySchema).optional()
+  },
+  dataLoaders: buildFragmentDataLoaders(gridComposition)
+  // Use grid composition for loader config (same for both)
+};
+
+// ../blocks/src/system/blocks/cta-full.ts
+var ctaComposition = composeFragments([
+  { fragment: ctaCopyFragment },
+  { fragment: ctaRowFragment }
+]);
+var ctaFullManifest = createBlockManifest({
+  id: "block.ctaFull",
+  title: "Full-width CTA",
+  category: "marketing",
+  fragments: [
+    { fragment: ctaCopyFragment, fieldPriority: 0 },
+    { fragment: ctaRowFragment, fieldPriority: 2 }
+  ],
+  layout: styledSection({
+    children: sectionContainer(ctaComposition.layout, {
+      gap: "md",
+      className: "relative text-center"
+    })
+  }),
+  description: "Centered call to action with optional background image.",
+  tags: ["cta", "call-to-action", "button", "conversion", "action", "sign-up", "get-started"],
+  icon: "Target"
+});
+var ctaFullBlockDefinition = {
+  manifest: ctaFullManifest
+};
+var formComposition = composeFragments([
+  { fragment: formCopyFragment },
+  { fragment: formEmbedFragment }
+]);
+var formLayout = section(
+  { background: "surface", className: "px-6 py-12" },
+  [sectionContainer(formComposition.layout, { gap: "lg" })]
+);
+var fields2 = fieldSchema.array().parse(formComposition.fields);
+var dataLoaders = buildFragmentDataLoaders(formComposition);
+var formManifest = {
+  name: "block.form",
+  version: "0.1.0",
+  title: "Form",
+  titleSource: "title",
+  description: "Renders a saved form definition with server-side submit.",
+  component: "form.block",
+  fields: fields2,
+  slots: [],
+  styleTokens: { background: "surface", typography: "body", spacing: "md" },
+  behaviours: { supportsThemeSwitching: true, inlineEditing: false, animation: false, paletteHidden: false },
+  category: "interactive",
+  tags: ["form", "contact", "input", "submit", "fields", "signup", "lead-capture"],
+  icon: "FormInput",
+  layout: formLayout
+};
+var formDataSchema = zod.z.object({
+  id: zod.z.string(),
+  siteId: zod.z.string(),
+  userId: zod.z.string(),
+  name: zod.z.string(),
+  slug: zod.z.string(),
+  schemaJson: zod.z.any(),
+  settingsJson: zod.z.any().optional(),
+  createdAt: zod.z.string(),
+  updatedAt: zod.z.string()
+});
+var formBlockDefinition = {
+  manifest: formManifest,
+  dataSchemas: { form: formDataSchema.optional() },
+  dataLoaders
+};
+
+// ../blocks/src/system/blocks/faq.ts
+var faqComposition = composeFragments([
+  { fragment: faqHeadingFragment, fieldPriority: 0 },
+  { fragment: faqAccordionFragment, fieldPriority: 1 }
+]);
+var faqManifest = createBlockManifest({
+  id: "block.faq",
+  title: "FAQ",
+  titleSource: "title",
+  category: "content",
+  fragments: [
+    { fragment: faqHeadingFragment, fieldPriority: 0 },
+    { fragment: faqAccordionFragment, fieldPriority: 1 }
+  ],
+  layout: styledSection({
+    children: sectionContainer(faqComposition.layout, {
+      gap: "xl",
+      className: "w-full"
+    })
+  }),
+  description: "Accordion of frequently asked questions and answers.",
+  tags: ["faq", "questions", "answers", "help", "support", "accordion", "q&a"],
+  icon: "HelpCircle"
+});
+var faqBlockDefinition = {
+  manifest: faqManifest
+};
+
+// ../blocks/src/system/transforms/typed.ts
+function tx(id, options) {
+  return { id, options };
+}
+function pipe(...steps) {
+  return steps;
+}
+function bindProp(from, opts) {
+  return {
+    $bind: {
+      from,
+      ...opts?.transforms ? { transforms: [...opts.transforms] } : {},
+      ...opts?.fallback !== void 0 ? { fallback: opts.fallback } : {},
+      ...opts?.pick ? { pick: opts.pick } : {}
+    }
+  };
+}
+
+// ../blocks/src/system/blocks/site-header.ts
+var logoRow = link(
+  { href: "/", className: "header-logo flex min-w-0 items-center gap-3 no-underline transition-opacity hover:opacity-80" },
+  [
+    media({ className: "h-10 w-auto transition-all duration-300 [.header-scrolled_&]:h-8" }, when("content.logo"), bind("content.logo")),
+    text({ as: "span", className: "header-logo-text truncate text-lg font-semibold" }, bind("site.title", { fallback: "Your Site" }))
+  ]
+);
+var centeredLogoRow = link(
+  { href: "/", className: "header-logo flex items-center justify-center gap-3 text-center no-underline transition-opacity hover:opacity-80" },
+  [
+    media({ className: "h-12 w-auto transition-all duration-300 [.header-scrolled_&]:h-10" }, when("content.logo"), bind("content.logo")),
+    text({ as: "span", className: "header-logo-text text-xl font-semibold" }, bind("site.title", { fallback: "Your Site" }))
+  ]
+);
+var createNavRow = (className, align = "end") => navRow({
+  className: `${className} header-nav-row`,
+  align,
+  linkClassName: "header-nav-link inline-flex items-center px-4 py-2 text-sm font-medium transition-theme-standard"
+});
+var headerCta = ctaButton({
+  basePath: "menu.ctaItem",
+  whenPath: "menu.ctaItem.label",
+  variantPath: "menu.ctaItem.variant",
+  linkPath: "menu.ctaItem.link",
+  className: "header-cta btn-sm hidden md:inline-flex ml-6"
+});
+var classicLayout2 = inline(
+  {
+    className: bindProp("$root.theme.header.maxWidth", {
+      transforms: pipe(tx("layout.maxWidthClass", { base: "flex w-full items-center gap-6 py-4" })),
+      fallback: "container mx-auto flex w-full items-center gap-6 px-6 py-4"
+    }),
+    align: "center"
+  },
+  [
+    logoRow,
+    createNavRow("ml-auto hidden md:flex gap-6"),
+    headerCta
+  ],
+  when("$root.theme.header.variant", { equals: "classic" })
+);
+var centeredLayout = stack(
+  {
+    gap: "md",
+    align: "center",
+    className: bindProp("$root.theme.header.maxWidth", {
+      transforms: pipe(tx("layout.maxWidthClass", { base: "flex w-full flex-col items-center gap-5 py-6 text-center" })),
+      fallback: "container mx-auto flex w-full flex-col items-center gap-5 px-6 py-6 text-center"
+    })
+  },
+  [
+    centeredLogoRow,
+    createNavRow("flex flex-wrap justify-center gap-x-6 gap-y-3", "center")
+  ],
+  when("$root.theme.header.variant", { equals: "centered" })
+);
+var transparentLayout = inline(
+  {
+    className: bindProp("$root.theme.header.maxWidth", {
+      transforms: pipe(tx("layout.maxWidthClass", { base: "flex w-full items-center gap-6 py-4" })),
+      fallback: "container mx-auto flex w-full items-center gap-6 px-6 py-4"
+    }),
+    align: "center"
+  },
+  [
+    logoRow,
+    createNavRow("ml-auto hidden md:flex gap-6"),
+    headerCta
+  ],
+  when("$root.theme.header.variant", { equals: "transparent" })
+);
+var floatingLayout = inline(
+  {
+    className: bindProp("$root.theme.header.maxWidth", {
+      transforms: pipe(tx("layout.maxWidthClass", { base: "header-floating-container absolute left-1/2 top-4 flex w-[calc(100%-2rem)] max-w-7xl -translate-x-1/2 items-center gap-6 px-6 py-3" })),
+      fallback: "header-floating-container absolute left-1/2 top-4 flex w-[calc(100%-2rem)] max-w-7xl -translate-x-1/2 items-center gap-6 px-6 py-3"
+    }),
+    align: "center"
+  },
+  [
+    logoRow,
+    createNavRow("ml-auto hidden md:flex gap-6"),
+    headerCta
+  ],
+  when("$root.theme.header.variant", { equals: "floating" })
+);
+var editorialLayout = stack(
+  {
+    gap: "md",
+    align: "center",
+    className: bindProp("$root.theme.header.maxWidth", {
+      transforms: pipe(tx("layout.maxWidthClass", { base: "flex w-full flex-col items-center gap-6 py-6 text-center" })),
+      fallback: "container mx-auto flex w-full flex-col items-center gap-6 px-6 py-6 text-center"
+    })
+  },
+  [
+    centeredLogoRow,
+    createNavRow("flex flex-wrap justify-center gap-x-8 gap-y-3", "center")
+  ],
+  when("$root.theme.header.variant", { equals: "editorial" })
+);
+var headerLayout = headerSection(
+  {
+    background: "background/base",
+    className: bindProp("$root.theme.header", {
+      transforms: pipe(tx("layout.headerRootClass")),
+      fallback: "header-root z-40 w-full border-b transition-theme backdrop-blur"
+    }),
+    style: bindProp("$root.theme.header", {
+      transforms: pipe(tx("layout.headerRootStyle")),
+      fallback: mergeStyles(
+        backgroundColorStyle("surface"),
+        textColorStyle("text"),
+        borderColorStyle("border")
+      )
+    })
+  },
+  [
+    classicLayout2,
+    centeredLayout,
+    transparentLayout,
+    floatingLayout,
+    editorialLayout
+  ],
+  props({
+    "data-site-header": "true"
+  })
+);
+var siteHeaderManifest = createBlockManifest({
+  id: "block.siteHeader",
+  title: "Site Header",
+  category: "layout",
+  component: "site.header.default",
+  // Skip section styles - this block uses theme-based styling
+  skipSectionStyles: true,
+  layout: headerLayout,
+  description: "Site-wide header with logo, navigation, and optional CTA.",
+  styleTokens: {
+    spacing: "sm"
+  },
+  paletteHidden: true
+});
+var siteHeaderBlockDefinition = {
+  manifest: siteHeaderManifest
+};
+
+// ../blocks/src/system/blocks/site-footer.ts
+composeFragments([
+  { fragment: footerLinkGroupsFragment, fieldPriority: 0 },
+  { fragment: footerBottomTextFragment, fieldPriority: 1 }
+]);
+var linkGroupsLayout = () => materializeFragment({ fragment: footerLinkGroupsFragment }).layout;
+var bottomTextLayout = () => materializeFragment({ fragment: footerBottomTextFragment }).layout;
+var simpleFooterLayout = stack(
+  {
+    gap: "md",
+    align: "center",
+    className: {
+      $bind: {
+        from: "$root.theme.footer.maxWidth",
+        transforms: [
+          {
+            id: "layout.maxWidthClass",
+            options: { base: "flex w-full flex-col items-center gap-4 py-10 text-center" }
+          }
+        ],
+        fallback: "container mx-auto flex w-full flex-col items-center gap-4 px-6 py-10 text-center"
+      }
+    }
+  },
+  [
+    navRow({ align: "center", className: "flex flex-wrap justify-center gap-x-6 gap-y-3" }),
+    ...bottomTextLayout()
+  ],
+  when("$root.theme.footer.variant", { equals: "simple" })
+);
+var columnsFooterLayout = stack(
+  {
+    gap: "xl",
+    align: "start",
+    className: {
+      $bind: {
+        from: "$root.theme.footer.maxWidth",
+        transforms: [
+          {
+            id: "layout.maxWidthClass",
+            options: { base: "flex w-full flex-col gap-10 py-12" }
+          }
+        ],
+        fallback: "container mx-auto flex w-full flex-col gap-10 px-6 py-12"
+      }
+    }
+  },
+  [
+    ...linkGroupsLayout(),
+    inline(
+      { className: "flex w-full flex-wrap items-center justify-between gap-4" },
+      [
+        text({ as: "span", className: "text-sm font-semibold", style: textColorStyle("text") }, bind("site.title", { fallback: "Your Site" })),
+        navRow({ className: "flex flex-wrap justify-end gap-x-6 gap-y-3", align: "end" })
+      ]
+    ),
+    ...bottomTextLayout()
+  ],
+  when("$root.theme.footer.variant", { equals: "columns" })
+);
+var footerLayout = section(
+  {
+    background: "background/base",
+    className: {
+      $bind: {
+        from: "$root.theme.footer",
+        transforms: [
+          {
+            id: "layout.footerRootClass"
+          }
+        ],
+        fallback: "w-full border-t transition-theme"
+      }
+    },
+    style: {
+      $bind: {
+        from: "$root.theme.footer",
+        transforms: [
+          {
+            id: "layout.footerRootStyle"
+          }
+        ],
+        fallback: mergeStyles(
+          backgroundColorStyle("surface"),
+          textColorStyle("text"),
+          borderColorStyle("border")
+        )
+      }
+    }
+  },
+  [
+    simpleFooterLayout,
+    columnsFooterLayout
+  ]
+);
+var siteFooterManifest = createBlockManifest({
+  id: "block.siteFooter",
+  title: "Site Footer",
+  category: "layout",
+  component: "site.footer.default",
+  // Use fragments for link groups and bottom text
+  fragments: [
+    { fragment: footerLinkGroupsFragment, fieldPriority: 0 },
+    { fragment: footerBottomTextFragment, fieldPriority: 1 }
+  ],
+  // Skip section styles - this block uses theme-based styling
+  skipSectionStyles: true,
+  layout: footerLayout,
+  description: "Site-wide footer with navigation links and optional columns.",
+  styleTokens: {
+    spacing: "md"
+  },
+  paletteHidden: true
+});
+var siteFooterBlockDefinition = {
+  manifest: siteFooterManifest
+};
+
+// ../blocks/src/system/blocks/testimonials.tsx
+var testimonialsBackgroundNodes = backgroundLayer("_sectionStyles.background", {
+  imageClassName: "absolute inset-0 -z-10 h-full w-full object-cover opacity-50"
+});
+var testimonialsContent = composeFragments([
+  { fragment: testimonialsHeadingFragment },
+  { fragment: testimonialsCarouselFragment }
+]);
+var testimonialsLayout = section(
+  { background: "background/base", className: "px-6 py-16 sm:py-20 md:py-24" },
+  // Semantic: comfortable + extra md padding
+  [
+    ...testimonialsBackgroundNodes,
+    sectionContainer(
+      [...testimonialsContent.layout],
+      { gap: "xl", className: "relative" }
+    )
+  ]
+);
+var fields3 = fieldSchema.array().parse([
+  ...testimonialsContent.fields.filter((field) => field.id === "heading" || field.id === "subheading"),
+  ...testimonialsContent.fields.filter(
+    (field) => field.id === "slidesToShow" || field.id === "transition" || field.id === "maxEntries"
+  ),
+  sectionStylesField({
+    id: "_sectionStyles",
+    label: "Section styles"
+  })
+]);
+var dataLoaders2 = buildFragmentDataLoaders(testimonialsContent);
+var testimonialsManifest = {
+  name: "block.testimonials",
+  version: "0.1.0",
+  title: "Testimonials",
+  description: "Carousel of customer testimonials with optional background styling.",
+  component: "testimonials.carousel",
+  fields: fields3,
+  slots: [],
+  styleTokens: {
+    background: "surface",
+    typography: "body",
+    spacing: "lg"
+  },
+  behaviours: {
+    supportsThemeSwitching: true,
+    inlineEditing: false,
+    animation: true,
+    paletteHidden: false
+  },
+  category: "marketing",
+  tags: ["testimonials", "reviews", "quotes", "feedback", "social-proof", "customers", "carousel"],
+  icon: "MessageSquareQuote",
+  layout: testimonialsLayout
+};
+var testimonialsBlockDefinition = {
+  manifest: testimonialsManifest,
+  dataLoaders: dataLoaders2
+};
+
+// ../blocks/src/system/blocks/columns.ts
+var columnsLayout = styledSection({
+  children: sectionContainer(
+    [
+      el(
+        "grid",
+        {
+          cols: {
+            $bind: {
+              from: "content.columns",
+              transforms: [{ id: "array.length" }]
+            }
+          },
+          gap: { $bind: { from: "content.gap" } }
+        },
+        [
+          {
+            type: "stack",
+            props: { gap: "md", className: "h-full" },
+            children: typeBasedLayout(
+              {
+                card: cardFragment.layout,
+                columnContent: columnContentFragment.layout
+              },
+              { itemName: "column" }
+            ),
+            $repeat: {
+              collection: { from: "content.columns" },
+              itemName: "column"
+            }
+          }
+        ]
+      )
+    ],
+    { gap: "md" }
+  ),
+  spacing: "medium"
+});
+var columnsManifest = createBlockManifest({
+  id: "block.columns",
+  title: "Columns",
+  category: "layout",
+  component: "columns",
+  // Custom fields for columns configuration
+  additionalFields: [
+    fieldSchema.parse({
+      id: "gap",
+      type: "select",
+      label: "Gap between columns",
+      defaultValue: "lg",
+      options: [
+        { value: "sm", label: "Small" },
+        { value: "md", label: "Medium" },
+        { value: "lg", label: "Large" }
+      ]
+    }),
+    fragmentsToRepeaterField(
+      "columns",
+      "Columns",
+      {
+        card: cardFragment,
+        columnContent: columnContentFragment
+      },
+      {
+        minItems: 0,
+        maxItems: 4,
+        itemLabel: "Column",
+        description: "Add or remove columns (up to 4)"
+      }
+    )
+  ],
+  layout: columnsLayout,
+  description: "Multi-column layout with customizable content per column",
+  tags: ["columns", "grid", "layout", "flexible", "multi-column"],
+  icon: "Columns",
+  styleTokens: {
+    spacing: "lg"
+  }
+});
+var columnsBlockDefinition = {
+  manifest: columnsManifest
+};
+var appointmentBookingManifest = {
+  name: "block.appointment-booking",
+  version: "2.0.0",
+  // Major version bump - breaking change from v1
+  title: "Appointment Booking",
+  titleSource: "heading",
+  description: "Multi-step appointment booking with customizable form fields",
+  component: "appointment-booking.block",
+  fields: [
+    {
+      id: "formId",
+      type: "reference",
+      label: "Booking Form",
+      description: "Select which booking form to use for collecting customer information",
+      required: true,
+      referenceKind: "bookingForm",
+      allowManualEntry: false
+    },
+    {
+      id: "heading",
+      type: "text",
+      label: "Heading",
+      description: "Main heading shown at the top of the booking flow",
+      required: false,
+      multiline: false,
+      defaultValue: "Book an Appointment"
+    },
+    {
+      id: "description",
+      type: "richText",
+      label: "Description",
+      description: "Optional description or instructions for users",
+      required: false,
+      format: "markdown"
+    }
+  ],
+  slots: [],
+  styleTokens: { background: "surface", typography: "body", spacing: "md" },
+  behaviours: { supportsThemeSwitching: true, inlineEditing: false, animation: false, paletteHidden: false },
+  category: "interactive",
+  tags: ["booking", "appointment", "calendar", "scheduling", "reservation"],
+  icon: "Calendar",
+  layout: [
+    styledSection({
+      children: sectionContainer([
+        // Optional heading
+        text(
+          { as: "h2", size: "2xl", weight: "bold" },
+          bind("content.heading"),
+          when("content.heading")
+        ),
+        // Optional description
+        richText(
+          {},
+          bind("content.description"),
+          when("content.description")
+        ),
+        // The booking form component - loads booking form by ID and renders multi-step flow
+        bookingForm({
+          siteId: { $bind: { from: "$root.siteId" } },
+          formId: { $bind: { from: "content.formId" } },
+          form: { $bind: { from: "data.form" } },
+          services: { $bind: { from: "data.services" } }
+        })
+      ], {
+        gap: "lg"
+      }),
+      spacing: "spacious"
+    })
+  ]
+};
+var availabilityDataSchema = zod.z.object({
+  slots: zod.z.array(zod.z.object({
+    startAt: zod.z.string(),
+    endAt: zod.z.string(),
+    resourceId: zod.z.string()
+  }))
+});
+var appointmentBookingBlockDefinition = {
+  manifest: appointmentBookingManifest,
+  dataSchemas: { availability: availabilityDataSchema.optional() },
+  dataLoaders: {
+    form: {
+      endpoint: "getPublicFormById",
+      params: {
+        formId: { $bind: { from: "content.formId" } }
+      },
+      mode: "server"
+    },
+    services: {
+      endpoint: "getPublicBookingServices",
+      params: {
+        siteId: { $bind: { from: "$root.siteId" } }
+      },
+      mode: "server"
+    }
+  }
+};
+var eventVenueSchema = zod.z.object({
+  id: zod.z.string(),
+  name: zod.z.string(),
+  address: zod.z.string().nullable()
+});
+var publicEventSchema = zod.z.object({
+  id: zod.z.string(),
+  seriesId: zod.z.string(),
+  title: zod.z.string(),
+  description: zod.z.string().nullable(),
+  slug: zod.z.string(),
+  startsAt: zod.z.string(),
+  endsAt: zod.z.string(),
+  capacity: zod.z.number().nullable(),
+  registeredCount: zod.z.number(),
+  availableSpots: zod.z.number().nullable(),
+  venue: eventVenueSchema.nullable()
+});
+var publicEventsArraySchema = zod.z.array(publicEventSchema);
+
+// ../blocks/src/system/blocks/events/shared/fields.ts
+var cardStylingFields = [
+  {
+    id: "cardVariant",
+    type: "select",
+    label: "Card style",
+    description: "Choose a card style from your theme",
+    required: false,
+    multiple: false,
+    defaultValue: "default",
+    options: [
+      { value: "default", label: "Default" },
+      { value: "variant1", label: "Variant 1" },
+      { value: "variant2", label: "Variant 2" }
+    ]
+  },
+  {
+    id: "buttonVariant",
+    type: "select",
+    label: "Button style",
+    description: "Choose a button style from your theme",
+    required: false,
+    multiple: false,
+    defaultValue: "primary",
+    options: [
+      { value: "primary", label: "Primary" },
+      { value: "secondary", label: "Secondary" },
+      { value: "outline", label: "Outline" },
+      { value: "link", label: "Link" }
+    ]
+  },
+  {
+    id: "buttonText",
+    type: "text",
+    label: "Button text",
+    description: "Text for the event action button",
+    required: false,
+    multiline: false,
+    defaultValue: "View event",
+    maxLength: 40
+  }
+];
+var eventDisplayFields = [
+  {
+    id: "showVenue",
+    type: "boolean",
+    label: "Show venue",
+    description: "Display venue name and address",
+    required: false,
+    defaultValue: true
+  },
+  {
+    id: "showCapacity",
+    type: "boolean",
+    label: "Show available spots",
+    description: "Display remaining capacity",
+    required: false,
+    defaultValue: true
+  }
+];
+var emptyStateField = {
+  id: "emptyMessage",
+  type: "text",
+  label: "Empty state message",
+  description: "Message when no upcoming events",
+  required: false,
+  multiline: false,
+  defaultValue: "No upcoming events scheduled.",
+  maxLength: 200
+};
+var sectionHeaderFields = (defaultHeading) => [
+  {
+    id: "heading",
+    type: "text",
+    label: "Heading",
+    description: "Main heading for the events section",
+    required: false,
+    multiline: false,
+    defaultValue: defaultHeading
+  },
+  {
+    id: "description",
+    type: "richText",
+    label: "Description",
+    description: "Optional introductory text",
+    required: false,
+    format: "markdown"
+  }
+];
+var layoutField = {
+  id: "layout",
+  type: "select",
+  label: "Layout",
+  description: "Choose how events are displayed",
+  required: false,
+  multiple: false,
+  defaultValue: "grid",
+  options: [
+    { value: "grid", label: "Grid (cards)" },
+    { value: "stack", label: "Stack (vertical list)" }
+  ]
+};
+var columnsField = (options = ["2", "3", "4"]) => ({
+  id: "columns",
+  type: "select",
+  label: "Columns",
+  description: "Number of columns in grid layout",
+  required: false,
+  multiple: false,
+  defaultValue: "3",
+  ui: {
+    visibleWhen: { field: "layout", equals: "grid" }
+  },
+  options: options.map((n) => ({ value: n, label: `${n} columns` }))
+});
+
+// ../blocks/src/system/blocks/event-registration.ts
+var eventRegistrationManifest = {
+  name: "block.event-registration",
+  version: "1.0.0",
+  title: "Event Registration",
+  titleSource: "heading",
+  description: "Multi-step event registration form",
+  component: "event-registration.block",
+  fields: [
+    {
+      id: "heading",
+      type: "text",
+      label: "Heading",
+      description: "Main heading for the registration form",
+      required: false,
+      multiline: false,
+      defaultValue: "Register for this event"
+    },
+    {
+      id: "description",
+      type: "richText",
+      label: "Description",
+      description: "Optional introductory text",
+      required: false,
+      format: "markdown"
+    },
+    {
+      id: "maxTickets",
+      type: "select",
+      label: "Max tickets per registration",
+      description: "Maximum tickets a person can register for",
+      required: false,
+      multiple: false,
+      defaultValue: "5",
+      options: [
+        { value: "1", label: "1 ticket" },
+        { value: "2", label: "2 tickets" },
+        { value: "3", label: "3 tickets" },
+        { value: "5", label: "5 tickets" },
+        { value: "10", label: "10 tickets" }
+      ]
+    },
+    {
+      id: "showVenue",
+      type: "boolean",
+      label: "Show venue",
+      description: "Display venue information",
+      required: false,
+      defaultValue: true
+    },
+    {
+      id: "showCapacity",
+      type: "boolean",
+      label: "Show available spots",
+      description: "Display remaining capacity",
+      required: false,
+      defaultValue: true
+    },
+    {
+      id: "successMessage",
+      type: "text",
+      label: "Success message",
+      description: "Message shown after successful registration",
+      required: false,
+      multiline: true,
+      defaultValue: "Thank you for registering! Check your email for confirmation details.",
+      maxLength: 500
+    },
+    {
+      id: "waitlistMessage",
+      type: "text",
+      label: "Waitlist message",
+      description: "Message when added to waitlist",
+      required: false,
+      multiline: true,
+      defaultValue: "You've been added to the waitlist. We'll notify you if a spot opens up.",
+      maxLength: 500
+    },
+    {
+      id: "buttonText",
+      type: "text",
+      label: "Submit button text",
+      description: "Text for the registration submit button",
+      required: false,
+      multiline: false,
+      defaultValue: "Complete Registration",
+      maxLength: 40
+    },
+    {
+      id: "buttonVariant",
+      type: "select",
+      label: "Button style",
+      description: "Choose a button style from your theme",
+      required: false,
+      multiple: false,
+      defaultValue: "primary",
+      options: [
+        { value: "primary", label: "Primary" },
+        { value: "secondary", label: "Secondary" },
+        { value: "outline", label: "Outline" }
+      ]
+    }
+  ],
+  slots: [],
+  styleTokens: { background: "surface", typography: "body", spacing: "md" },
+  behaviours: { supportsThemeSwitching: true, inlineEditing: false, animation: false, paletteHidden: false },
+  category: "interactive",
+  tags: ["events", "registration", "booking", "form", "signup"],
+  icon: "ClipboardList",
+  layout: [
+    styledSection({
+      spacing: "spacious",
+      children: sectionContainer([
+        // Optional heading
+        text(
+          { as: "h2", size: "2xl", weight: "bold" },
+          bind("content.heading"),
+          when("content.heading")
+        ),
+        // Optional description
+        richText(
+          {},
+          bind("content.description"),
+          when("content.description")
+        ),
+        // Event registration form component
+        eventRegistration({
+          // Site context for API calls
+          siteId: { $bind: { from: "$root.siteId" } },
+          // Pre-selected occurrence from route context (if available)
+          occurrenceContext: { $bind: { from: "$root.occurrenceContext" } },
+          // Event data from content entry context (if on event template)
+          contentEntry: { $bind: { from: "$root.contentEntry" } },
+          // Content configuration
+          maxTickets: { $bind: { from: "content.maxTickets", fallback: "5" } },
+          showVenue: { $bind: { from: "content.showVenue" } },
+          showCapacity: { $bind: { from: "content.showCapacity" } },
+          successMessage: { $bind: { from: "content.successMessage" } },
+          waitlistMessage: { $bind: { from: "content.waitlistMessage" } },
+          buttonText: { $bind: { from: "content.buttonText", fallback: "Complete Registration" } },
+          buttonVariant: { $bind: { from: "content.buttonVariant", fallback: "primary" } },
+          // Event data from loader
+          events: { $bind: { from: "data.events" } }
+        })
+      ], {
+        gap: "lg"
+      })
+    })
+  ]
+};
+var occurrenceContextSchema = zod.z.object({
+  /** Unique identifier for this occurrence */
+  id: zod.z.string(),
+  /** The event series this occurrence belongs to */
+  seriesId: zod.z.string(),
+  /** ISO 8601 datetime when the occurrence starts */
+  startsAt: zod.z.string(),
+  /** ISO 8601 datetime when the occurrence ends */
+  endsAt: zod.z.string(),
+  /** Override capacity for this specific occurrence (null = use series default) */
+  capacityOverride: zod.z.number().nullable().optional(),
+  /** Field-level overrides: { title?, description?, venueId?, etc. } */
+  overrides: zod.z.record(zod.z.string(), zod.z.unknown()).nullable().optional()
+}).nullable();
+var eventRegistrationBlockDefinition = {
+  manifest: eventRegistrationManifest,
+  dataSchemas: {
+    events: zod.z.array(publicEventSchema).optional(),
+    occurrenceContext: occurrenceContextSchema.optional()
+  },
+  dataLoaders: {
+    // Load events for occurrence selection
+    // This is needed when block is on a standalone page or event template without occurrence in URL
+    events: {
+      endpoint: "listPublicEvents",
+      params: {
+        siteId: { $bind: { from: "$root.siteId" } },
+        limit: "50",
+        // Get more events for selection
+        stage: { $bind: { from: "$root.previewStage", fallback: "published" } }
+      },
+      mode: "server"
+    }
+  }
+};
+
+// ../blocks/src/system/blocks/events/event-spotlight.ts
+var eventSpotlightManifest = {
+  name: "block.event-spotlight",
+  version: "1.0.0",
+  title: "Event Spotlight",
+  titleSource: "heading",
+  description: "Feature a few upcoming events on your homepage",
+  component: "event-spotlight.block",
+  fields: [
+    ...sectionHeaderFields("Upcoming Events"),
+    {
+      id: "maxEvents",
+      type: "select",
+      label: "Events to display",
+      description: "Number of events to show",
+      required: false,
+      multiple: false,
+      defaultValue: "3",
+      options: [
+        { value: "1", label: "1 event" },
+        { value: "2", label: "2 events" },
+        { value: "3", label: "3 events" },
+        { value: "4", label: "4 events" },
+        { value: "5", label: "5 events" },
+        { value: "6", label: "6 events" }
+      ]
+    },
+    layoutField,
+    columnsField(["2", "3"]),
+    ...cardStylingFields,
+    ...eventDisplayFields,
+    emptyStateField
+  ],
+  slots: [],
+  styleTokens: { background: "surface", typography: "body", spacing: "md" },
+  behaviours: { supportsThemeSwitching: true, inlineEditing: false, animation: false, paletteHidden: false },
+  category: "interactive",
+  tags: ["events", "featured", "homepage", "spotlight", "upcoming"],
+  icon: "Star",
+  layout: [
+    styledSection({
+      children: sectionContainer([
+        // Optional heading
+        text(
+          { as: "h2", size: "2xl", weight: "bold" },
+          bind("content.heading"),
+          when("content.heading")
+        ),
+        // Optional description
+        richText(
+          {},
+          bind("content.description"),
+          when("content.description")
+        ),
+        // Event spotlight component
+        el("event-spotlight", {
+          events: { $bind: { from: "data.events" } },
+          layout: { $bind: { from: "content.layout", fallback: "grid" } },
+          columns: { $bind: { from: "content.columns", fallback: "3" } },
+          cardVariant: { $bind: { from: "content.cardVariant", fallback: "default" } },
+          buttonVariant: { $bind: { from: "content.buttonVariant", fallback: "primary" } },
+          buttonText: { $bind: { from: "content.buttonText", fallback: "View event" } },
+          showVenue: { $bind: { from: "content.showVenue" } },
+          showCapacity: { $bind: { from: "content.showCapacity" } },
+          emptyMessage: { $bind: { from: "content.emptyMessage" } }
+        })
+      ], {
+        gap: "lg"
+      }),
+      spacing: "spacious"
+    })
+  ]
+};
+var eventSpotlightBlockDefinition = {
+  manifest: eventSpotlightManifest,
+  dataSchemas: {
+    events: publicEventsArraySchema.optional()
+  },
+  dataLoaders: {
+    events: {
+      endpoint: "listPublicEvents",
+      params: {
+        siteId: { $bind: { from: "$root.siteId" } },
+        limit: { $bind: { from: "content.maxEvents", fallback: "3" } },
+        stage: { $bind: { from: "$root.previewStage", fallback: "published" } }
+      },
+      mode: "server"
+    }
+  }
+};
+
+// ../blocks/src/system/blocks/events/event-listing.ts
+var eventListingManifest = {
+  name: "block.event-listing",
+  version: "1.0.0",
+  title: "Event Listing",
+  titleSource: "heading",
+  description: "Paginated list of all upcoming events",
+  component: "event-listing.block",
+  fields: [
+    ...sectionHeaderFields("All Events"),
+    layoutField,
+    columnsField(["2", "3", "4"]),
+    {
+      id: "eventsPerPage",
+      type: "select",
+      label: "Events per page",
+      description: "Number of events to load at a time",
+      required: false,
+      multiple: false,
+      defaultValue: "12",
+      options: [
+        { value: "6", label: "6 events" },
+        { value: "12", label: "12 events" },
+        { value: "24", label: "24 events" }
+      ]
+    },
+    {
+      id: "loadMoreText",
+      type: "text",
+      label: "Load more button text",
+      description: "Text for the pagination button",
+      required: false,
+      multiline: false,
+      defaultValue: "Load more events",
+      maxLength: 40
+    },
+    ...cardStylingFields,
+    ...eventDisplayFields,
+    emptyStateField
+  ],
+  slots: [],
+  styleTokens: { background: "surface", typography: "body", spacing: "md" },
+  behaviours: { supportsThemeSwitching: true, inlineEditing: false, animation: false, paletteHidden: false },
+  category: "interactive",
+  tags: ["events", "listing", "paginated", "archive", "all-events"],
+  icon: "List",
+  layout: [
+    styledSection({
+      children: sectionContainer([
+        // Optional heading
+        text(
+          { as: "h2", size: "2xl", weight: "bold" },
+          bind("content.heading"),
+          when("content.heading")
+        ),
+        // Optional description
+        richText(
+          {},
+          bind("content.description"),
+          when("content.description")
+        ),
+        // Event listing component with pagination
+        el("event-listing", {
+          events: { $bind: { from: "data.events" } },
+          siteId: { $bind: { from: "$root.siteId" } },
+          layout: { $bind: { from: "content.layout", fallback: "grid" } },
+          columns: { $bind: { from: "content.columns", fallback: "3" } },
+          eventsPerPage: { $bind: { from: "content.eventsPerPage", fallback: "12" } },
+          loadMoreText: { $bind: { from: "content.loadMoreText", fallback: "Load more events" } },
+          cardVariant: { $bind: { from: "content.cardVariant", fallback: "default" } },
+          buttonVariant: { $bind: { from: "content.buttonVariant", fallback: "primary" } },
+          buttonText: { $bind: { from: "content.buttonText", fallback: "View event" } },
+          showVenue: { $bind: { from: "content.showVenue" } },
+          showCapacity: { $bind: { from: "content.showCapacity" } },
+          emptyMessage: { $bind: { from: "content.emptyMessage" } }
+        })
+      ], {
+        gap: "lg"
+      }),
+      spacing: "spacious"
+    })
+  ]
+};
+var eventListingBlockDefinition = {
+  manifest: eventListingManifest,
+  dataSchemas: {
+    events: publicEventsArraySchema.optional()
+  },
+  dataLoaders: {
+    events: {
+      endpoint: "listPublicEvents",
+      params: {
+        siteId: { $bind: { from: "$root.siteId" } },
+        limit: { $bind: { from: "content.eventsPerPage", fallback: "12" } },
+        stage: { $bind: { from: "$root.previewStage", fallback: "published" } }
+      },
+      mode: "server"
+    }
+  }
+};
+
+// ../blocks/src/system/blocks/events/event-calendar.ts
+var eventCalendarManifest = {
+  name: "block.event-calendar",
+  version: "2.0.0",
+  title: "Event Calendar",
+  titleSource: "heading",
+  description: "Interactive calendar showing events by month or week",
+  component: "event-calendar.block",
+  fields: [
+    ...sectionHeaderFields("Event Calendar"),
+    {
+      id: "calendarView",
+      type: "select",
+      label: "Default view",
+      description: "Initial calendar view",
+      required: false,
+      multiple: false,
+      defaultValue: "month",
+      options: [
+        { value: "month", label: "Month" },
+        { value: "week", label: "Week" }
+      ]
+    },
+    {
+      id: "startOfWeek",
+      type: "select",
+      label: "Week starts on",
+      description: "First day of the week",
+      required: false,
+      multiple: false,
+      defaultValue: "monday",
+      options: [
+        { value: "sunday", label: "Sunday" },
+        { value: "monday", label: "Monday" }
+      ]
+    },
+    ...cardStylingFields.filter((f) => f.id === "buttonVariant"),
+    // Only button variant for calendar
+    emptyStateField
+  ],
+  slots: [],
+  styleTokens: { background: "surface", typography: "body", spacing: "md" },
+  behaviours: { supportsThemeSwitching: true, inlineEditing: false, animation: false, paletteHidden: false },
+  category: "interactive",
+  tags: ["events", "calendar", "month", "week", "schedule", "interactive"],
+  icon: "CalendarDays",
+  layout: [
+    styledSection({
+      children: sectionContainer([
+        // Optional heading
+        text(
+          { as: "h2", size: "2xl", weight: "bold" },
+          bind("content.heading"),
+          when("content.heading")
+        ),
+        // Optional description
+        richText(
+          {},
+          bind("content.description"),
+          when("content.description")
+        ),
+        // Event calendar grid component
+        el("event-calendar", {
+          events: { $bind: { from: "data.events" } },
+          siteId: { $bind: { from: "$root.siteId" } },
+          calendarView: { $bind: { from: "content.calendarView", fallback: "month" } },
+          startOfWeek: { $bind: { from: "content.startOfWeek", fallback: "monday" } },
+          buttonVariant: { $bind: { from: "content.buttonVariant", fallback: "primary" } },
+          emptyMessage: { $bind: { from: "content.emptyMessage" } }
+        })
+      ], {
+        gap: "lg"
+      }),
+      spacing: "spacious"
+    })
+  ]
+};
+var eventCalendarBlockDefinition = {
+  manifest: eventCalendarManifest,
+  dataSchemas: {
+    events: publicEventsArraySchema.optional()
+  },
+  dataLoaders: {
+    events: {
+      endpoint: "listPublicEvents",
+      params: {
+        siteId: { $bind: { from: "$root.siteId" } },
+        // Pre-fetch 3 months of events (server-side)
+        // The client will use the same API to fetch more as user navigates
+        limit: 100,
+        // High limit for calendar view
+        stage: { $bind: { from: "$root.previewStage", fallback: "published" } }
+      },
+      mode: "server"
+    }
+  }
+};
+var embedFields = [
+  // Section heading
+  fieldSchema.parse({
+    id: "heading",
+    type: "text",
+    label: "Heading",
+    description: "Optional section title displayed above the content.",
+    required: false,
+    maxLength: 120
+  }),
+  fieldSchema.parse({
+    id: "subheading",
+    type: "richText",
+    label: "Subheading",
+    description: "Optional section description below the heading.",
+    required: false,
+    format: "markdown",
+    ui: { variant: "limited" }
+  }),
+  // Content source
+  fieldSchema.parse({
+    id: "contentType",
+    type: "contentTypeSelect",
+    label: "Content type",
+    description: "Select the content type to embed.",
+    required: true,
+    filter: "all"
+  }),
+  fieldSchema.parse({
+    id: "mode",
+    type: "select",
+    label: "Selection mode",
+    description: "How to select which entries to display.",
+    required: true,
+    defaultValue: "query",
+    options: [
+      { value: "query", label: "Query (automatic)" },
+      { value: "manual", label: "Manual (pick entries)" }
+    ]
+  }),
+  // Query mode options
+  fieldSchema.parse({
+    id: "limit",
+    type: "select",
+    label: "Limit",
+    description: "Maximum number of entries to display.",
+    defaultValue: "10",
+    options: [
+      { value: "3", label: "3 entries" },
+      { value: "6", label: "6 entries" },
+      { value: "10", label: "10 entries" },
+      { value: "20", label: "20 entries" },
+      { value: "50", label: "50 entries" }
+    ],
+    ui: {
+      visibleWhen: { field: "mode", equals: "query" }
+    }
+  }),
+  fieldSchema.parse({
+    id: "orderBy",
+    type: "select",
+    label: "Order by",
+    description: "How to sort the entries.",
+    defaultValue: "order",
+    options: [
+      { value: "order", label: "Custom order field" },
+      { value: "newest", label: "Newest first" },
+      { value: "oldest", label: "Oldest first" },
+      { value: "title", label: "Title (A-Z)" }
+    ],
+    ui: {
+      visibleWhen: { field: "mode", equals: "query" }
+    }
+  }),
+  // Manual mode options - entry references
+  fieldSchema.parse({
+    id: "entries",
+    type: "repeater",
+    label: "Entries",
+    description: "Select specific entries to display.",
+    required: false,
+    itemLabel: "Entry",
+    minItems: 1,
+    maxItems: 20,
+    schema: {
+      fields: [
+        {
+          id: "entryId",
+          type: "entryPicker",
+          label: "Entry",
+          description: "Select a content entry to embed.",
+          required: true,
+          ui: {
+            contentTypeField: "contentType"
+          }
+        }
+      ]
+    },
+    ui: {
+      visibleWhen: { field: "mode", equals: "manual" }
+    }
+  }),
+  // Layout selection - SDK sites can provide custom options via blockFieldOptions
+  fieldSchema.parse({
+    id: "layout",
+    type: "select",
+    label: "Layout",
+    description: "Select a layout style for displaying the embedded content.",
+    defaultValue: "list",
+    options: [
+      { value: "list", label: "List" },
+      { value: "grid", label: "Grid" },
+      { value: "carousel", label: "Carousel" }
+    ],
+    ui: {
+      widget: "sdkSelect"
+      // Use SDK-aware widget for site-specific options
+    }
+  }),
+  // Empty state
+  fieldSchema.parse({
+    id: "emptyMessage",
+    type: "text",
+    label: "Empty state message",
+    description: "Message shown when no entries are available.",
+    defaultValue: "No entries found.",
+    maxLength: 200
+  })
+];
+var embedLayout = styledSection({
+  children: sectionContainer([
+    // Heading
+    text(
+      {
+        as: "h2",
+        className: "text-3xl font-bold",
+        style: textColorStyle("neutral-900")
+      },
+      bind("content.heading"),
+      when("content.heading")
+    ),
+    // Subheading
+    el(
+      "richText",
+      {
+        className: "mt-2 text-lg",
+        style: textColorStyle("neutral-600")
+      },
+      void 0,
+      bind("content.subheading"),
+      when("content.subheading")
+    ),
+    // Default entry rendering - a simple list
+    // Sites should override this with custom layouts via blockOverrides
+    // Outer stack provides gap between repeated entry cards
+    stack(
+      { gap: "md", className: "mt-8" },
+      [
+        // Entry card (repeated for each entry)
+        stack(
+          {
+            gap: "sm",
+            className: "rounded-lg border border-neutral-200 bg-white p-4 shadow-sm"
+          },
+          [
+            text(
+              {
+                as: "h3",
+                className: "text-lg font-semibold",
+                style: textColorStyle("neutral-900")
+              },
+              bind("entry.title")
+            ),
+            text(
+              {
+                as: "p",
+                className: "text-sm",
+                style: textColorStyle("neutral-500")
+              },
+              bind("entry.slug"),
+              when("entry.slug")
+            )
+          ],
+          repeat("data.entries", "entry")
+        )
+      ],
+      when("data.entries")
+    ),
+    // Empty state
+    stack(
+      {
+        gap: "sm",
+        className: "py-12 text-center"
+      },
+      [
+        text(
+          {
+            as: "p",
+            className: "text-base",
+            style: textColorStyle("neutral-400")
+          },
+          bind("content.emptyMessage", { fallback: "No entries found." })
+        )
+      ],
+      when("data.entries", { not: true })
+    )
+  ]),
+  spacing: "comfortable"
+});
+var embedManifest = createBlockManifest({
+  id: "block.embed",
+  title: "Embed Content",
+  category: "content",
+  titleSource: "heading",
+  additionalFields: embedFields,
+  layout: embedLayout,
+  description: "Embed content entries from any content type. Sites provide custom layouts via block overrides.",
+  tags: ["embed", "content", "dynamic", "collection", "entries", "listing"],
+  icon: "LayoutList",
+  styleTokens: {
+    spacing: "lg"
+  }
+});
+var embedEntrySchema = zod.z.object({
+  id: zod.z.string(),
+  title: zod.z.string(),
+  slug: zod.z.string().nullable().optional(),
+  content: zod.z.record(zod.z.string(), zod.z.unknown()).optional(),
+  publishedAt: zod.z.string().nullable().optional()
+});
+var embedBlockDefinition = {
+  manifest: embedManifest,
+  dataSchemas: {
+    entries: zod.z.array(embedEntrySchema).optional()
+  },
+  dataLoaders: {
+    entries: {
+      endpoint: "listPublishedEntries",
+      params: {
+        type: { $bind: { from: "contentType" } },
+        siteId: { $bind: { from: "$root.siteId" } },
+        limit: { $bind: { from: "limit", fallback: "10" } },
+        orderBy: { $bind: { from: "orderBy", fallback: "order" } },
+        stage: { $bind: { from: "$root.previewStage", fallback: "published" } },
+        // Manual mode entry IDs - loader should handle this
+        entryIds: { $bind: { from: "entries" } },
+        mode: { $bind: { from: "mode" } }
+      },
+      mode: "server"
+    }
+  }
+};
+
+// ../blocks/src/system/blocks/index.ts
+var systemBlockDefinitions = [
+  heroBlockDefinition,
+  bodyTextBlockDefinition,
+  blogPostBlockDefinition,
+  blogPlaceholderBlockDefinition,
+  blogListingBlockDefinition,
+  ctaFullBlockDefinition,
+  formBlockDefinition,
+  faqBlockDefinition,
+  siteHeaderBlockDefinition,
+  siteFooterBlockDefinition,
+  testimonialsBlockDefinition,
+  columnsBlockDefinition,
+  appointmentBookingBlockDefinition,
+  eventRegistrationBlockDefinition,
+  // Event display blocks (3 specialized blocks)
+  eventSpotlightBlockDefinition,
+  eventListingBlockDefinition,
+  eventCalendarBlockDefinition,
+  // Content embedding
+  embedBlockDefinition
+];
+var defaultsRegistered = false;
+function ensureSystemBlockDefinitionsRegistered() {
+  if (defaultsRegistered) {
+    return;
+  }
+  defaultsRegistered = true;
+  for (const definition of systemBlockDefinitions) {
+    registerBlockDefinition(definition);
+  }
+}
+
+// ../blocks/src/system/registry.ts
+var REGISTRY_SYMBOL2 = Symbol.for("@riverbankcms/blocks/system/definitions");
+var globalScope2 = globalThis;
+if (!globalScope2[REGISTRY_SYMBOL2]) {
+  globalScope2[REGISTRY_SYMBOL2] = /* @__PURE__ */ new Map();
+}
+var blockStore = globalScope2[REGISTRY_SYMBOL2];
+function ensureDefaults() {
+  ensureSystemBlockDefinitionsRegistered();
+}
+function registerBlockDefinition(definition) {
+  registerManifest(definition.manifest);
+  blockStore.set(definition.manifest.name, definition);
+  return definition;
+}
+function getBlockDefinition(name) {
+  ensureDefaults();
+  return blockStore.get(name);
+}
+
+// src/data/prefetchBlockData.ts
 var SUPPORTED_LOADER_ENDPOINTS = [
   "listPublishedEntries",
   "getPublishedEntryPreview",
@@ -96,7 +4927,7 @@ var blockFieldOptionsSchema = zod.z.record(
   )
 ).optional();
 var blockFieldExtensionSchema = zod.z.object({
-  fields: blocks.fieldSchema.array().min(1, "At least one field is required")
+  fields: fieldSchema.array().min(1, "At least one field is required")
 }).refine(
   (data) => {
     return data.fields.every((field) => {
@@ -118,7 +4949,7 @@ function validateFieldIdConflicts(blockFieldExtensions) {
   if (!blockFieldExtensions) return [];
   const conflicts = [];
   for (const [blockId, extension] of Object.entries(blockFieldExtensions)) {
-    const definition = blocks.getBlockDefinition(blockId);
+    const definition = getBlockDefinition(blockId);
     if (!definition) {
       conflicts.push({
         blockId,
@@ -128,9 +4959,9 @@ function validateFieldIdConflicts(blockFieldExtensions) {
       continue;
     }
     const existingFieldIds = /* @__PURE__ */ new Set();
-    const collectFieldIds = (fields) => {
-      if (!fields) return;
-      for (const field of fields) {
+    const collectFieldIds = (fields4) => {
+      if (!fields4) return;
+      for (const field of fields4) {
         existingFieldIds.add(field.id);
         if (field.type === "group" || field.type === "modal") {
           collectFieldIds(field.schema?.fields);
@@ -164,11 +4995,11 @@ var sdkCustomBlockSchema = zod.z.object({
   title: zod.z.string().min(1, "Title is required"),
   titleSource: zod.z.string().optional(),
   description: zod.z.string().optional(),
-  category: blocks.blockCategoryEnum,
+  category: blockCategoryEnum,
   icon: zod.z.string().optional(),
   tags: zod.z.array(zod.z.string()).optional(),
   // Reuse the exact field schema from @riverbankcms/blocks - all field types supported
-  fields: blocks.fieldSchema.array().min(1, "Custom blocks must have at least one field"),
+  fields: fieldSchema.array().min(1, "Custom blocks must have at least one field"),
   // Data loaders for CMS endpoints
   dataLoaders: sdkDataLoadersSchema
 }).refine(