@elytracms/next 0.0.1

package/dist/index.js

@@ -0,0 +1,4484 @@
+import { z } from 'zod';
+export { z } from 'zod';
+import { createContext, createElement, Fragment as Fragment$1, Component, isValidElement } from 'react';
+import { jsx, Fragment, jsxs } from 'react/jsx-runtime';
+import { revalidateTag, unstable_cache } from 'next/cache';
+import { draftMode } from 'next/headers';
+import { redirect, notFound, permanentRedirect } from 'next/navigation';
+import { createHmac, timingSafeEqual } from 'crypto';
+import NextImage from 'next/image';
+
+// ../cms-core/src/issues.ts
+var cmsIssueCodeSchema = z.enum([
+  // collections & fields (EC-016)
+  "duplicate-collection",
+  "duplicate-field",
+  "unknown-collection",
+  "invalid-collection-config",
+  "invalid-field-config",
+  "missing-required-field",
+  "invalid-field-value",
+  // relations & assets (EC-017)
+  "unknown-relation-target",
+  // broken published references after a weak unpublish (EC-173)
+  "unpublished-relation-target",
+  "cardinality-violation",
+  "unknown-asset",
+  "duplicate-document",
+  // localization (EC-018)
+  "unknown-locale",
+  "missing-localized-value",
+  // routes / redirects / resolution (EC-019, EC-020)
+  "route-conflict",
+  "redirect-loop",
+  "unknown-route-target",
+  // page hierarchy (EC-218): a parent chain that loops
+  "hierarchy-cycle",
+  // versions (EC-021)
+  "unknown-version"
+]);
+var cmsIssueSeveritySchema = z.enum(["error", "warning"]);
+z.object({
+  code: cmsIssueCodeSchema,
+  severity: cmsIssueSeveritySchema,
+  message: z.string(),
+  /** Path into the CMS data, e.g. ['collections', 'post', 'fields', 'author']. */
+  path: z.array(z.union([z.string(), z.number()])),
+  /** The offending collection id, when applicable. */
+  collectionId: z.string().optional(),
+  /** The offending document id, when applicable. */
+  documentId: z.string().optional(),
+  meta: z.record(z.string(), z.unknown()).optional()
+});
+function cmsIssue(init) {
+  return {
+    code: init.code,
+    severity: init.severity ?? "error",
+    message: init.message,
+    path: [...init.path],
+    ...init.collectionId ? { collectionId: init.collectionId } : {},
+    ...init.documentId ? { documentId: init.documentId } : {},
+    ...init.meta ? { meta: init.meta } : {}
+  };
+}
+z.enum([
+  "text",
+  "number",
+  "boolean",
+  "date",
+  "select",
+  "richText",
+  "relation",
+  "asset",
+  // Composition field (EC-186, AD-12): the value is a constrained tree of
+  // registry components (a canvas), not a scalar. The vocabulary is code.
+  "blocks",
+  // Object / repeater field (EC-253): a nested group of field-defs — a single
+  // object (`cardinality: 'one'`) or an ordered array of them (`'many'`). The
+  // missing array-of-objects primitive real sites lean on (menus, forms, galleries).
+  "object"
+]);
+var cardinalitySchema = z.enum(["one", "many"]);
+var fieldContextSchema = z.enum(["document", "prop", "both"]);
+var fieldControlSchema = z.enum(["input", "textarea", "color", "json"]);
+var fieldFormMetaSchema = z.object({
+  /** Human label shown in the editor; falls back to the field name when omitted. */
+  label: z.string().optional(),
+  /** Helper/description text shown under the field. */
+  description: z.string().optional(),
+  /** Placeholder for text-like inputs. */
+  placeholder: z.string().optional(),
+  /** Grouping section the field belongs to (a fieldset). */
+  group: z.string().optional(),
+  /** Tab the field belongs to (for tabbed editors). */
+  tab: z.string().optional(),
+  /** Sort order within its group/tab; lower comes first. */
+  order: z.number().optional(),
+  /** When true the editor renders the field read-only. */
+  readOnly: z.boolean().optional(),
+  /** When true the editor hides the field (still validated/stored). */
+  hidden: z.boolean().optional(),
+  /** Preferred input control when the field type maps to several (EC-190). */
+  control: fieldControlSchema.optional(),
+  /**
+   * When true the editor edits this value inline on the canvas (EC-158) rather
+   * than as a form row — used for text-like component props rendered as visible
+   * content. The single home for inline-editing across documents and props.
+   */
+  inlineEditable: z.boolean().optional()
+});
+var fieldValidationSchema = z.object({
+  /** When true a value must be present (and non-empty for strings/arrays). */
+  required: z.boolean().optional(),
+  /** Minimum string length / array length / numeric value (type-dependent). */
+  min: z.number().optional(),
+  /** Maximum string length / array length / numeric value (type-dependent). */
+  max: z.number().optional(),
+  /** RegExp source string a text value must match. */
+  pattern: z.string().optional(),
+  /** Value must be unique across the collection's documents. */
+  unique: z.boolean().optional()
+});
+var selectOptionSchema = z.object({
+  value: z.string(),
+  label: z.string().optional()
+});
+var baseFieldShape = {
+  /** Stable field name (the key in a document's values; survives label changes). */
+  name: z.string().min(1),
+  /** When true the field stores a separate value per locale (EC-018). */
+  localized: z.boolean().optional(),
+  /**
+   * Marks the field as filterable/sortable for the closed-form list accessors
+   * (EC-143, vision AD-3). `listDocuments` filters and sorts are permitted only
+   * on declared fields — this keeps backend indexes honest and stops filter
+   * vocabulary creep. Never affects stored values or validation.
+   */
+  filterable: z.boolean().optional(),
+  /**
+   * Where this field-def is valid (EC-190): a CMS document field, a component
+   * prop, or both. Defaults to `document` when omitted (back-compat — every
+   * existing collection field-def stays a document field). Document-only
+   * attributes (`filterable`, `validation.unique`) declared on a `context:'prop'`
+   * field are a structured issue (`assertPropFieldDef`), never silent.
+   */
+  context: fieldContextSchema.optional(),
+  /**
+   * Default value applied when none is set (EC-190). On a component prop this is
+   * the renderer's static fallback (EC-015); on a document field it seeds new
+   * documents — the per-field starter-content mechanism (no template entity
+   * needed). Never affects whether a value is *stored*, only what fills a gap.
+   */
+  default: z.unknown().optional(),
+  form: fieldFormMetaSchema.optional(),
+  validation: fieldValidationSchema.optional()
+};
+z.object(baseFieldShape);
+var fieldDefSchema = z.discriminatedUnion("type", [
+  z.object({ ...baseFieldShape, type: z.literal("text") }),
+  z.object({ ...baseFieldShape, type: z.literal("number") }),
+  z.object({ ...baseFieldShape, type: z.literal("boolean") }),
+  z.object({ ...baseFieldShape, type: z.literal("date") }),
+  z.object({
+    ...baseFieldShape,
+    type: z.literal("select"),
+    options: z.array(selectOptionSchema).min(1),
+    /** Allow selecting multiple options (stored as an array). */
+    multiple: z.boolean().optional()
+  }),
+  z.object({
+    ...baseFieldShape,
+    type: z.literal("richText"),
+    /**
+     * Embeddable composition vocabulary (EC-189, AD-12): component ids editors
+     * may embed as `componentEmbed` blocks inside the prose — the SAME `allow`
+     * mechanism a `blocks` field uses, applied to rich-text embeds. Each embed
+     * holds a single `ComponentNode` validated against this list by
+     * `validateCompositionValue` (`@elytracms/project-graph`). Omit to allow any
+     * registered component; deeper nesting is governed by each component's slot
+     * `allow`. The leash is code.
+     */
+    allow: z.array(z.string().min(1)).optional()
+  }),
+  z.object({
+    ...baseFieldShape,
+    type: z.literal("relation"),
+    /** Id of the collection this relation points at. */
+    target: z.string().min(1),
+    cardinality: cardinalitySchema,
+    /**
+     * Delivery-shape population declaration (EC-142). Defaults to populated:
+     * delivery resolution expands the relation to a depth-1 populated reference.
+     * Set to `false` to opt out and receive reference stubs
+     * (`{ id, collection }`) instead. Never affects stored values.
+     */
+    populate: z.boolean().optional(),
+    /**
+     * Strict referential integrity (EC-173). References are **weak by
+     * default**: unpublishing/deleting a referenced target is allowed and the
+     * reference degrades to an explicit validation issue plus a delivery
+     * fallback. `strict: true` is the deliberate opt-in that inverts this for
+     * one field: while any document references a target through this field,
+     * deleting the target is blocked — and while a *published* document does,
+     * unpublishing it is blocked too (enforced in `@elytracms/operations`).
+     */
+    strict: z.boolean().optional()
+  }),
+  z.object({
+    ...baseFieldShape,
+    type: z.literal("asset"),
+    cardinality: cardinalitySchema.default("one"),
+    /** Restrict to specific asset kinds (e.g. 'image', 'file'); empty = any. */
+    accept: z.array(z.string()).optional()
+  }),
+  z.object({
+    ...baseFieldShape,
+    type: z.literal("blocks"),
+    /**
+     * The composition vocabulary (EC-186, AD-12): allowed component ids editors
+     * may place as TOP-LEVEL blocks. Omit to allow any registered component;
+     * deeper nesting is governed by each component's slot `allow`. The value
+     * (a `ComponentNode` tree) is validated against this by
+     * `validateCompositionValue` (`@elytracms/project-graph`). The leash is code.
+     */
+    allow: z.array(z.string().min(1)).optional(),
+    /** `one` = a single root component; `many` = an ordered list (default). */
+    cardinality: cardinalitySchema.default("many")
+  }),
+  z.object({
+    ...baseFieldShape,
+    type: z.literal("object"),
+    /**
+     * The nested field-defs. Recursive via `z.lazy` (a subfield may itself be an
+     * `object`), so Konditorei's nested menu, the form builder's groups→fields,
+     * and multi-entry settings model faithfully. Subfields carry their own `name`
+     * (they are object keys), so this is the full `FieldDef`, not the prop shape.
+     */
+    fields: z.lazy(() => z.array(fieldDefSchema)),
+    /** `one` = a single nested object; `many` = an ordered array (the repeater). */
+    cardinality: cardinalitySchema.default("one")
+  })
+]);
+var collectionKindSchema = z.enum(["document", "asset"]);
+var collectionFormMetaSchema = z.object({
+  /** Plural human label, e.g. "Blog Posts". */
+  label: z.string().optional(),
+  /** Singular human label, e.g. "Blog Post". */
+  labelSingular: z.string().optional(),
+  description: z.string().optional(),
+  /** Declared ordering of form groups (fieldsets). */
+  groups: z.array(z.string()).optional(),
+  /** Declared ordering of form tabs. */
+  tabs: z.array(z.string()).optional()
+});
+z.object({
+  id: z.string().min(1),
+  kind: collectionKindSchema.default("document"),
+  fields: z.array(fieldDefSchema).default([]),
+  form: collectionFormMetaSchema.optional(),
+  /** When true, documents in this collection support localized variants (EC-018). */
+  localized: z.boolean().optional(),
+  /** Name of the field used as the document's display title (defaults to `title`). */
+  titleField: z.string().optional(),
+  /**
+   * When true, this collection holds exactly ONE fixed document — Settings,
+   * Menus, Footer, Homepage SEO… (EC-217). The studio skips the list view and
+   * opens the detail editor directly on the single document. Pure authoring
+   * sugar: internally identical to a `document` collection, so the engine,
+   * delivery, and validation paths are unchanged. Meaningless on an `asset`
+   * collection (flagged as `invalid-collection-config`).
+   */
+  singleton: z.boolean().optional()
+});
+function fieldOf(collection, name) {
+  return collection.fields.find((f) => f.name === name);
+}
+var localeSchema = z.string().min(1);
+var documentRefSchema = z.object({
+  collection: z.string().min(1),
+  id: z.string().min(1)
+});
+documentRefSchema.extend({
+  locale: localeSchema
+});
+function documentKey(ref) {
+  return `${ref.collection}:${ref.id}`;
+}
+z.enum(["draft", "published"]);
+var documentSchema = z.object({
+  collection: z.string().min(1),
+  id: z.string().min(1),
+  /** Non-localized field values shared across locales. */
+  values: z.record(z.string(), z.unknown()).default({}),
+  /** Per-locale overrides for localized fields: `{ [locale]: { [field]: value } }`. */
+  localized: z.record(localeSchema, z.record(z.string(), z.unknown())).optional(),
+  /** The default locale this document was authored in (EC-018 fallback source). */
+  defaultLocale: localeSchema.optional()
+});
+function refOf(doc) {
+  return { collection: doc.collection, id: doc.id };
+}
+var localeConfigSchema = z.object({
+  default: z.string().min(1),
+  locales: z.array(z.string().min(1)).min(1)
+});
+function isKnownLocale(config, locale) {
+  return config.locales.includes(locale);
+}
+function isFieldLocalized(collection, fieldName) {
+  return fieldOf(collection, fieldName)?.localized === true;
+}
+function documentDefaultLocale(doc, config) {
+  return doc.defaultLocale ?? config.default;
+}
+function resolveField(collection, doc, fieldName, locale, config) {
+  if (!isFieldLocalized(collection, fieldName)) {
+    return { value: doc.values[fieldName], sourceLocale: locale, fellBack: false };
+  }
+  const requested = doc.localized?.[locale];
+  if (requested && fieldName in requested) {
+    return { value: requested[fieldName], sourceLocale: locale, fellBack: false };
+  }
+  const fallbackLocale = documentDefaultLocale(doc, config);
+  if (fallbackLocale !== locale) {
+    const fallback = doc.localized?.[fallbackLocale];
+    if (fallback && fieldName in fallback) {
+      return { value: fallback[fieldName], sourceLocale: fallbackLocale, fellBack: true };
+    }
+  }
+  if (fieldName in doc.values) {
+    return { value: doc.values[fieldName], sourceLocale: fallbackLocale, fellBack: true };
+  }
+  return { value: void 0, sourceLocale: fallbackLocale, fellBack: fallbackLocale !== locale };
+}
+function validateLocale(config, locale, path = ["locale"]) {
+  if (isKnownLocale(config, locale)) return [];
+  return [
+    cmsIssue({
+      code: "unknown-locale",
+      message: `Locale "${locale}" is not in the configured locale set.`,
+      path,
+      meta: { locale, configured: config.locales }
+    })
+  ];
+}
+var routeRecordSchema = z.object({
+  id: z.string().min(1),
+  /** Path pattern, leading slash, with optional `:param` segments. */
+  pattern: z.string().min(1),
+  /** Locale this route serves (EC-018). Omitted = locale-agnostic. */
+  locale: localeSchema.optional(),
+  /**
+   * The document this route resolves to: a `page`-collection document (whose
+   * `body` composition renders into a layout), or a content-collection document
+   * (rendered by a dev route component). The `id` may be a `:param` placeholder
+   * materialized from the matched URL (EC-166).
+   */
+  document: z.object({ collection: z.string().min(1), id: z.string().min(1) }).optional()
+});
+var redirectRecordSchema = z.object({
+  id: z.string().min(1),
+  from: z.string().min(1),
+  to: z.string().min(1),
+  /** 301 permanent (default) or 302 temporary. */
+  permanent: z.boolean().default(true)
+});
+function splitPath(path) {
+  const [pathname] = path.split(/[?#]/, 1);
+  return (pathname ?? "").split("/").filter((s) => s.length > 0);
+}
+function compilePattern(pattern) {
+  return splitPath(pattern).map(
+    (seg) => seg.startsWith(":") ? { kind: "param", name: seg.slice(1) } : { kind: "static", value: seg }
+  );
+}
+function matchSegments(segments, urlSegments) {
+  if (segments.length !== urlSegments.length) return void 0;
+  const params = {};
+  for (let i = 0; i < segments.length; i++) {
+    const seg = segments[i];
+    const value = urlSegments[i];
+    if (seg === void 0 || value === void 0) return void 0;
+    if (seg.kind === "static") {
+      if (seg.value !== value) return void 0;
+    } else {
+      params[seg.name] = decodeURIComponent(value);
+    }
+  }
+  return params;
+}
+function specificity(segments) {
+  return segments.map((s) => s.kind === "static" ? "S" : "P").join("");
+}
+function normalizePath(path) {
+  const [pathname] = path.split(/[?#]/, 1);
+  const segs = splitPath(pathname ?? "");
+  return "/" + segs.join("/");
+}
+function createRouter(routes, redirects = [], options = {}) {
+  const issues = [];
+  const compiled = routes.map((route) => ({
+    route,
+    segments: compilePattern(route.pattern)
+  }));
+  const conflictKey = (c) => {
+    const locale = c.route.locale ?? "*";
+    const sig = c.segments.map((s) => s.kind === "static" ? `s:${s.value}` : "p").join("/");
+    return `${locale}|${sig}`;
+  };
+  const byKey = /* @__PURE__ */ new Map();
+  for (const c of compiled) {
+    const key = conflictKey(c);
+    const existing = byKey.get(key);
+    if (existing) {
+      issues.push(
+        cmsIssue({
+          code: "route-conflict",
+          message: `Routes "${existing.route.id}" and "${c.route.id}" both match the same URLs (pattern "${c.route.pattern}").`,
+          path: ["routes", c.route.id],
+          meta: { conflictsWith: existing.route.id, pattern: c.route.pattern }
+        })
+      );
+    } else {
+      byKey.set(key, c);
+    }
+  }
+  const redirectMap = /* @__PURE__ */ new Map();
+  for (const r of redirects) {
+    redirectMap.set(normalizePath(r.from), r);
+  }
+  const followRedirects = (from) => {
+    const chain = [];
+    const seen = /* @__PURE__ */ new Set();
+    let current = normalizePath(from);
+    let permanent = true;
+    chain.push(current);
+    while (true) {
+      const hop = redirectMap.get(current);
+      if (!hop) {
+        return { target: current, chain, loop: false, permanent };
+      }
+      if (!hop.permanent) permanent = false;
+      const next = normalizePath(hop.to);
+      if (seen.has(next) || next === current) {
+        chain.push(next);
+        return { target: next, chain, loop: true, permanent };
+      }
+      seen.add(current);
+      current = next;
+      chain.push(current);
+    }
+  };
+  const loopReported = /* @__PURE__ */ new Set();
+  for (const r of redirects) {
+    const res = followRedirects(r.from);
+    if (res.loop && !loopReported.has(res.target)) {
+      loopReported.add(res.target);
+      issues.push(
+        cmsIssue({
+          code: "redirect-loop",
+          message: `Redirect chain starting at "${r.from}" loops (\u2026${res.chain.slice(-3).join(" -> ")}).`,
+          path: ["redirects", r.id],
+          meta: { chain: res.chain }
+        })
+      );
+    }
+  }
+  const orderedMatches = (urlSegments, locale) => {
+    const matches = [];
+    for (const c of compiled) {
+      if (locale !== void 0 && c.route.locale !== void 0 && c.route.locale !== locale) {
+        continue;
+      }
+      const params = matchSegments(c.segments, urlSegments);
+      if (params) matches.push({ compiled: c, params });
+    }
+    matches.sort((a, b) => specificity(a.compiled.segments).localeCompare(specificity(b.compiled.segments)) * -1);
+    return matches;
+  };
+  const resolveUrl = (url, locale) => {
+    const path = normalizePath(url);
+    if (redirectMap.has(path)) {
+      const res = followRedirects(path);
+      return {
+        status: "redirect",
+        redirectTarget: res.target,
+        permanent: res.permanent,
+        dynamicParams: {},
+        fallback: false
+      };
+    }
+    const urlSegments = splitPath(path);
+    let fallback = false;
+    let matches = orderedMatches(urlSegments, locale);
+    if (matches.length === 0 && locale && options.defaultLocale && locale !== options.defaultLocale) {
+      const fallbackMatches = orderedMatches(urlSegments, options.defaultLocale);
+      if (fallbackMatches.length > 0) {
+        matches = fallbackMatches;
+        fallback = true;
+      }
+    }
+    if (matches.length === 0 && locale === void 0) {
+      matches = orderedMatches(urlSegments, void 0);
+    }
+    const best = matches[0];
+    if (!best) {
+      return { status: "notFound", dynamicParams: {}, fallback };
+    }
+    const route = best.compiled.route;
+    return {
+      status: "ok",
+      route,
+      ...route.document ? { documentRef: route.document } : {},
+      dynamicParams: best.params,
+      fallback
+    };
+  };
+  return { issues, resolveUrl, followRedirects };
+}
+
+// ../cms-core/src/hierarchy.ts
+var DEFAULT_PARENT_FIELD = "parent";
+var DEFAULT_SLUG_FIELD = "slug";
+function hierarchyFields(config = {}) {
+  return {
+    parentField: config.parentField ?? DEFAULT_PARENT_FIELD,
+    slugField: config.slugField ?? DEFAULT_SLUG_FIELD
+  };
+}
+function parentRelationField(collection, config = {}) {
+  const { parentField } = hierarchyFields(config);
+  const field = collection.fields.find((f) => f.name === parentField);
+  if (field && field.type === "relation" && field.target === collection.id && field.cardinality === "one") {
+    return field;
+  }
+  return void 0;
+}
+function isHierarchical(collection, config = {}) {
+  return parentRelationField(collection, config) !== void 0;
+}
+function readParentId(doc, parentField) {
+  const value = doc.values[parentField];
+  if (value == null) return void 0;
+  if (typeof value === "string") return value.length > 0 ? value : void 0;
+  if (typeof value === "object" && "id" in value) {
+    const id = value.id;
+    return typeof id === "string" && id.length > 0 ? id : void 0;
+  }
+  return void 0;
+}
+function readSlug(doc, slugField) {
+  const value = doc.values[slugField];
+  return typeof value === "string" && value.length > 0 ? value : void 0;
+}
+function composePath(doc, getById, config = {}) {
+  const { parentField, slugField } = hierarchyFields(config);
+  const segments = [];
+  const seen = /* @__PURE__ */ new Set([doc.id]);
+  let cycle = false;
+  let missingSlug = false;
+  let danglingParent = false;
+  let current = doc;
+  while (current) {
+    const slug = readSlug(current, slugField);
+    if (slug === void 0) missingSlug = true;
+    else segments.unshift(slug);
+    const parentId = readParentId(current, parentField);
+    if (parentId === void 0) break;
+    const parent = getById(parentId);
+    if (!parent) {
+      danglingParent = true;
+      break;
+    }
+    if (seen.has(parent.id)) {
+      cycle = true;
+      break;
+    }
+    seen.add(parent.id);
+    current = parent;
+  }
+  return { segments, ok: !cycle && !missingSlug && !danglingParent, cycle, missingSlug, danglingParent };
+}
+function isHierarchyTemplate(route) {
+  if (!route.document) return false;
+  const segments = splitPath(route.pattern);
+  const last = segments[segments.length - 1];
+  return last !== void 0 && last.startsWith(":") && last.endsWith("*");
+}
+function hierarchyMount(route) {
+  if (!isHierarchyTemplate(route) || !route.document) return void 0;
+  const prefix = splitPath(route.pattern).slice(0, -1);
+  if (prefix.some((segment) => segment.startsWith(":"))) return void 0;
+  return {
+    collection: route.document.collection,
+    prefix,
+    ...route.locale ? { locale: route.locale } : {}
+  };
+}
+function resolveByPath(segments, docs, config = {}) {
+  if (segments.length === 0) return void 0;
+  const byId = new Map(docs.map((d) => [d.id, d]));
+  const getById = (id) => byId.get(id);
+  const target = segments.join("/");
+  let match;
+  for (const doc of docs) {
+    const composed = composePath(doc, getById, config);
+    if (!composed.ok) continue;
+    if (composed.segments.join("/") === target && (!match || doc.id < match.id)) {
+      match = doc;
+    }
+  }
+  return match;
+}
+
+// ../cms-core/src/validate-document.ts
+function isEmpty(value) {
+  if (value === void 0 || value === null) return true;
+  if (typeof value === "string") return value.length === 0;
+  if (Array.isArray(value)) return value.length === 0;
+  if (isPlainObject(value)) return Object.keys(value).length === 0;
+  return false;
+}
+function isPlainObject(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function checkScalarType(field, value) {
+  switch (field.type) {
+    case "text":
+      return typeof value === "string" ? null : "expects a string";
+    case "richText":
+      return typeof value === "string" || typeof value === "object" && value !== null ? null : "expects rich-text content (a string or a rich-text value)";
+    case "number":
+      return typeof value === "number" && !Number.isNaN(value) ? null : "expects a number";
+    case "boolean":
+      return typeof value === "boolean" ? null : "expects a boolean";
+    case "date":
+      if (typeof value === "string") {
+        return Number.isNaN(Date.parse(value)) ? "expects a valid date string" : null;
+      }
+      return typeof value === "number" ? null : "expects a date (ISO string or epoch number)";
+    case "select": {
+      const allowed = new Set(field.options.map((o) => o.value));
+      const values = field.multiple ? Array.isArray(value) ? value : [value] : [value];
+      for (const v of values) {
+        if (typeof v !== "string" || !allowed.has(v)) {
+          return `has value "${String(v)}" not among its options`;
+        }
+      }
+      return null;
+    }
+    case "object":
+      if (field.cardinality === "many") {
+        return Array.isArray(value) && value.every((item) => isPlainObject(item)) ? null : "expects a list of objects";
+      }
+      return isPlainObject(value) ? null : "expects an object";
+    case "relation":
+    case "asset":
+    case "blocks":
+      return null;
+    default: {
+      return null;
+    }
+  }
+}
+function checkConstraints(field, value) {
+  const out = [];
+  const rules = field.validation;
+  if (!rules) return out;
+  if (typeof value === "string") {
+    if (rules.min !== void 0 && value.length < rules.min) out.push(`is shorter than min length ${rules.min}`);
+    if (rules.max !== void 0 && value.length > rules.max) out.push(`is longer than max length ${rules.max}`);
+    if (rules.pattern !== void 0) {
+      let re;
+      try {
+        re = new RegExp(rules.pattern);
+      } catch {
+        re = void 0;
+      }
+      if (re && !re.test(value)) out.push(`does not match pattern ${rules.pattern}`);
+    }
+  } else if (typeof value === "number") {
+    if (rules.min !== void 0 && value < rules.min) out.push(`is less than min ${rules.min}`);
+    if (rules.max !== void 0 && value > rules.max) out.push(`is greater than max ${rules.max}`);
+  } else if (Array.isArray(value)) {
+    if (rules.min !== void 0 && value.length < rules.min) out.push(`has fewer than ${rules.min} items`);
+    if (rules.max !== void 0 && value.length > rules.max) out.push(`has more than ${rules.max} items`);
+  }
+  return out;
+}
+function fieldValueValidator(field) {
+  return (value) => {
+    if (isEmpty(value)) return true;
+    return checkScalarType(field, value) === null && checkConstraints(field, value).length === 0;
+  };
+}
+z.object({
+  /** Monotonic version number, starting at 1. */
+  version: z.number().int().positive(),
+  /** Full document snapshot at this version. */
+  snapshot: documentSchema,
+  /** When the snapshot was recorded (epoch ms). */
+  createdAt: z.number().int().nonnegative(),
+  /** Optional label, e.g. "published" or an author note. */
+  label: z.string().optional()
+});
+
+// ../cms-core/src/fixtures.ts
+var assetCollection = {
+  id: "asset",
+  kind: "asset",
+  titleField: "filename",
+  fields: [
+    { name: "filename", type: "text", validation: { required: true } },
+    { name: "alt", type: "text", localized: true },
+    { name: "url", type: "text", validation: { required: true } }
+  ]
+};
+var authorCollection = {
+  id: "author",
+  kind: "document",
+  titleField: "name",
+  fields: [
+    { name: "name", type: "text", validation: { required: true } },
+    { name: "bio", type: "richText" }
+  ]
+};
+var postCollection = {
+  id: "post",
+  kind: "document",
+  localized: true,
+  titleField: "title",
+  form: {
+    label: "Posts",
+    labelSingular: "Post",
+    groups: ["content", "meta"],
+    tabs: ["main", "seo"]
+  },
+  fields: [
+    {
+      name: "title",
+      type: "text",
+      localized: true,
+      validation: { required: true, min: 1, max: 120 },
+      form: { label: "Title", group: "content", tab: "main", order: 1 }
+    },
+    {
+      name: "slug",
+      type: "text",
+      validation: { required: true, pattern: "^[a-z0-9-]+$", unique: true },
+      form: { label: "Slug", group: "content", tab: "main", order: 2 }
+    },
+    {
+      name: "body",
+      type: "richText",
+      localized: true,
+      form: { label: "Body", group: "content", tab: "main", order: 3 }
+    },
+    {
+      name: "views",
+      type: "number",
+      validation: { min: 0 },
+      form: { label: "Views", group: "meta", tab: "main" }
+    },
+    {
+      name: "featured",
+      type: "boolean",
+      form: { label: "Featured", group: "meta", tab: "main" }
+    },
+    {
+      name: "publishedAt",
+      type: "date",
+      form: { label: "Published at", group: "meta", tab: "main" }
+    },
+    {
+      name: "status",
+      type: "select",
+      options: [
+        { value: "news", label: "News" },
+        { value: "guide", label: "Guide" }
+      ],
+      form: { label: "Status", group: "meta", tab: "main" }
+    },
+    {
+      name: "author",
+      type: "relation",
+      target: "author",
+      cardinality: "one",
+      validation: { required: true },
+      form: { label: "Author", group: "meta", tab: "main" }
+    },
+    {
+      name: "related",
+      type: "relation",
+      target: "post",
+      cardinality: "many",
+      form: { label: "Related posts", group: "meta", tab: "main" }
+    },
+    {
+      name: "cover",
+      type: "asset",
+      cardinality: "one",
+      accept: ["image"],
+      form: { label: "Cover image", group: "content", tab: "main" }
+    }
+  ]
+};
+var pageCollection = {
+  id: "page",
+  kind: "document",
+  titleField: "name",
+  form: {
+    label: "Pages",
+    labelSingular: "Page",
+    tabs: ["main", "canvas", "seo"]
+  },
+  fields: [
+    {
+      name: "name",
+      type: "text",
+      validation: { required: true },
+      form: { tab: "main" }
+    },
+    {
+      name: "body",
+      type: "blocks",
+      allow: [
+        "base.primitives.Heading",
+        "base.primitives.Text",
+        "base.primitives.Image",
+        "base.primitives.Button",
+        "base.primitives.Stack",
+        "project.MarketingHero",
+        "project.FeatureCard",
+        "project.PricingCallout"
+      ],
+      cardinality: "many",
+      form: { label: "Canvas", tab: "canvas" }
+    },
+    { name: "layoutId", type: "text", form: { tab: "main" } },
+    { name: "seoTitle", type: "text", form: { tab: "seo" } },
+    { name: "seoDescription", type: "text", form: { tab: "seo" } },
+    { name: "seoCanonical", type: "text", form: { tab: "seo" } },
+    { name: "seoOgTitle", type: "text", form: { tab: "seo" } },
+    { name: "seoOgImage", type: "text", form: { tab: "seo" } },
+    { name: "seoNoindex", type: "boolean", form: { tab: "seo" } }
+  ]
+};
+var sampleCollections = [
+  assetCollection,
+  authorCollection,
+  postCollection,
+  pageCollection
+];
+var sampleFilterableFields = {
+  author: ["name"],
+  post: ["slug", "views", "featured", "publishedAt", "status", "author"]
+};
+function withSampleFilterable(collection) {
+  const filterable = new Set(sampleFilterableFields[collection.id] ?? []);
+  if (filterable.size === 0) return collection;
+  return {
+    ...collection,
+    fields: collection.fields.map(
+      (field) => filterable.has(field.name) ? { ...field, filterable: true } : field
+    )
+  };
+}
+sampleCollections.map(withSampleFilterable);
+var coverAsset = {
+  collection: "asset",
+  id: "asset-cover",
+  values: { filename: "cover.png", url: "https://cdn/cover.png" },
+  localized: { en: { alt: "A cover" }, de: { alt: "Ein Titelbild" } },
+  defaultLocale: "en"
+};
+var libraryCoverAsset = {
+  collection: "asset",
+  id: "asset_cover",
+  values: { filename: "cover.jpg", url: "https://cdn/cover.jpg" },
+  localized: { en: { alt: "Cover image" }, de: { alt: "Titelbild" } },
+  defaultLocale: "en"
+};
+var authorAda = {
+  collection: "author",
+  id: "author-ada",
+  values: { name: "Ada Lovelace", bio: "Pioneer." }
+};
+var validPost = {
+  collection: "post",
+  id: "post-hello",
+  values: {
+    slug: "hello-world",
+    views: 10,
+    featured: true,
+    publishedAt: "2026-01-02T00:00:00.000Z",
+    status: "news",
+    author: { collection: "author", id: "author-ada" },
+    related: [],
+    cover: "asset-cover"
+  },
+  localized: {
+    en: { title: "Hello World", body: "<p>Hi</p>" },
+    de: { title: "Hallo Welt", body: "<p>Hallo</p>" }
+  },
+  defaultLocale: "en"
+};
+var partiallyLocalizedPost = {
+  collection: "post",
+  id: "post-fallback",
+  values: {
+    slug: "fallback",
+    author: { collection: "author", id: "author-ada" }
+  },
+  localized: {
+    en: { title: "Only English", body: "<p>en</p>" }
+    // no `de` variant — `de` requests must fall back to `en`
+  },
+  defaultLocale: "en"
+};
+var samplePageHome = {
+  collection: "page",
+  id: "home",
+  values: {
+    name: "Home",
+    layoutId: "layout.main",
+    seoTitle: "Welcome to Elytra",
+    seoDescription: "A code-first website builder.",
+    body: [
+      {
+        id: "p-home-heading",
+        componentId: "base.primitives.Heading",
+        props: {
+          level: { kind: "static", value: 1 },
+          text: { kind: "static", value: "Welcome to Elytra" }
+        }
+      },
+      {
+        id: "p-home-intro",
+        componentId: "base.primitives.Text",
+        props: { value: { kind: "static", value: "A code-first website builder." } }
+      }
+    ]
+  },
+  defaultLocale: "en"
+};
+var sampleDocuments = [
+  coverAsset,
+  authorAda,
+  validPost,
+  partiallyLocalizedPost,
+  libraryCoverAsset,
+  samplePageHome
+];
+sampleDocuments.map(
+  (doc) => documentKey(refOf(doc))
+);
+
+// ../component-registry/src/manifest.ts
+function defineComponent(manifest) {
+  return manifest;
+}
+function manifestPropField(manifest, name) {
+  const field = manifest.props[name];
+  return field ? { ...field, name } : void 0;
+}
+function manifestSlots(manifest) {
+  const compositionValueProp = manifest.composition?.valueProp;
+  const fromBlocksProps = [];
+  for (const [name, field] of Object.entries(manifest.props)) {
+    if (field.type !== "blocks") continue;
+    if (name === compositionValueProp) continue;
+    fromBlocksProps.push({
+      name,
+      ...field.form?.label ? { label: field.form.label } : {},
+      ...field.validation?.required ? { required: true } : {},
+      ...field.allow ? { allow: field.allow } : {}
+    });
+  }
+  return fromBlocksProps.length === 0 ? manifest.slots : [...manifest.slots, ...fromBlocksProps];
+}
+function propValueValidator(manifest, name) {
+  const field = manifestPropField(manifest, name);
+  return field ? fieldValueValidator(field) : void 0;
+}
+function namespaceOf(id) {
+  if (id.startsWith("base.primitives.")) return "base.primitives";
+  const first = id.split(".")[0];
+  return first ?? "";
+}
+function isPrimitive(id) {
+  return id.startsWith("base.primitives.");
+}
+function toManifestView(manifest) {
+  const props = {};
+  for (const [name, field] of Object.entries(manifest.props)) {
+    props[name] = {
+      // EC-190: props are static; the binding path retires in slice 5. Until then
+      // every prop reports bindable so the graph validator's binding branch stays
+      // inert (no false `binding-not-allowed`). `validate` is the field-def value
+      // validator — the SAME check the CMS uses for a document field value.
+      bindable: true,
+      validate: fieldValueValidator({ ...field})
+    };
+  }
+  return {
+    id: manifest.id,
+    props,
+    // EC-191: carry canvas-eligibility so `validateCompositionValue` can reject a
+    // server-only component placed in a composition.
+    ...manifest.clientRenderable === false ? { clientRenderable: false } : {},
+    // EC-186: carry the slot's placement vocabulary (`allow`) through to the
+    // graph validator so it can enforce `forbidden-component` — previously
+    // dropped here, leaving slot `allow` declared-but-unenforced. EC-190:
+    // `manifestSlots` folds in `blocks`-type props as slots, so a blocks prop's
+    // `allow` leash is enforced through the same path.
+    slots: manifestSlots(manifest).map((s) => ({
+      name: s.name,
+      required: s.required,
+      ...s.allow ? { allow: s.allow } : {}
+    }))
+  };
+}
+var jsonValueSchema = z.lazy(
+  () => z.union([
+    z.string(),
+    z.number(),
+    z.boolean(),
+    z.null(),
+    z.array(jsonValueSchema),
+    z.record(z.string(), jsonValueSchema)
+  ])
+);
+var idSchema = z.string().min(1);
+var COMPONENT_ID_PATTERN = /^(base\.primitives|project)\.[A-Za-z][A-Za-z0-9]*(\.[A-Za-z][A-Za-z0-9]*)*$/;
+function isValidComponentId(componentId) {
+  return COMPONENT_ID_PATTERN.test(componentId);
+}
+var DEFAULT_SLOT = "children";
+var OUTLET_SLOT = "outlet";
+var bindingModeSchema = z.enum(["value", "object", "spread", "repeaterItem", "condition"]);
+var bindingReferenceSchema = z.object({
+  /** Id of a data source (REST / CMS query / Convex query). */
+  sourceId: idSchema,
+  /** Stable path token (JSON Pointer / JSONPath) that survives UI label changes. */
+  token: z.string().min(1),
+  mode: bindingModeSchema
+});
+var conditionOperatorSchema = z.enum([
+  "truthy",
+  "exists",
+  "eq",
+  "neq",
+  "gt",
+  "gte",
+  "lt",
+  "lte"
+]);
+var conditionSchema = z.object({
+  source: bindingReferenceSchema,
+  operator: conditionOperatorSchema,
+  /** Right-hand comparison value for binary operators (omitted for truthy/exists). */
+  value: jsonValueSchema.optional()
+});
+var propValueSchema = z.discriminatedUnion("kind", [
+  z.object({ kind: z.literal("static"), value: jsonValueSchema }),
+  z.object({ kind: z.literal("binding"), binding: bindingReferenceSchema })
+]);
+var componentNodeSchema = z.lazy(
+  () => z.object({
+    id: idSchema,
+    componentId: idSchema,
+    props: z.record(z.string(), propValueSchema).optional(),
+    slots: z.record(z.string(), z.array(componentNodeSchema)).optional(),
+    condition: conditionSchema.optional()
+  })
+);
+var layoutSchema = z.object({
+  id: idSchema,
+  name: z.string().min(1),
+  root: componentNodeSchema
+});
+var PROJECT_GRAPH_SCHEMA_VERSION = 2;
+var projectGraphSchema = z.object({
+  id: idSchema,
+  schemaVersion: z.number().int().nonnegative(),
+  metadata: z.object({ name: z.string().optional() }).optional(),
+  /** Link to project settings owned by studio-core. */
+  settingsRef: idSchema.optional(),
+  layouts: z.array(layoutSchema).default([])
+});
+var STACK_COMPONENT_ID = "base.primitives.Stack";
+var GRID_COMPONENT_ID = "base.primitives.Grid";
+var SPACING_TOKEN_NAMES = ["px", "1", "2", "3", "4", "6", "8"];
+var spacingTokenNameSchema = z.enum(SPACING_TOKEN_NAMES);
+var SPACING_TOKEN_CSS = {
+  px: "1px",
+  "1": "0.25rem",
+  "2": "0.5rem",
+  "3": "0.75rem",
+  "4": "1rem",
+  "6": "1.5rem",
+  "8": "2rem"
+};
+function isSpacingTokenName(value) {
+  return typeof value === "string" && SPACING_TOKEN_NAMES.includes(value);
+}
+function spacingTokenCss(name) {
+  return isSpacingTokenName(name) ? SPACING_TOKEN_CSS[name] : void 0;
+}
+z.boolean();
+var STACK_DIRECTIONS = ["vertical", "horizontal"];
+z.enum(STACK_DIRECTIONS);
+var CONTAINER_ALIGNMENTS = ["start", "center", "end", "stretch"];
+z.enum(CONTAINER_ALIGNMENTS);
+var GRID_MIN_COLUMNS = 1;
+var GRID_MAX_COLUMNS = 12;
+z.number().int().min(GRID_MIN_COLUMNS).max(GRID_MAX_COLUMNS);
+z.union([
+  spacingTokenNameSchema,
+  z.number().int().nonnegative()
+]);
+function staticProps(values) {
+  const entries = Object.entries(values).filter(([, v]) => v !== void 0);
+  if (entries.length === 0) return void 0;
+  return Object.fromEntries(
+    entries.map(([name, value]) => [name, { kind: "static", value }])
+  );
+}
+function stackContainerNode(id, options, children) {
+  const props = staticProps({
+    direction: options.direction,
+    gap: options.gap,
+    align: options.align
+  });
+  return {
+    id,
+    componentId: STACK_COMPONENT_ID,
+    ...props ? { props } : {},
+    slots: { [DEFAULT_SLOT]: children }
+  };
+}
+function gridContainerNode(id, options, children) {
+  const props = staticProps({
+    columns: options.columns,
+    gap: options.gap,
+    align: options.align,
+    stackOnMobile: options.stackOnMobile
+  });
+  return {
+    id,
+    componentId: GRID_COMPONENT_ID,
+    ...props ? { props } : {},
+    slots: { [DEFAULT_SLOT]: children }
+  };
+}
+var issueCodeSchema = z.enum([
+  "invalid-component-name",
+  "unknown-component",
+  "duplicate-node-id",
+  "unknown-prop",
+  "invalid-prop",
+  "binding-not-allowed",
+  "unresolved-binding",
+  "missing-required-slot",
+  "unknown-slot",
+  // Placement constraints (EC-186): a component appears where its slot's `allow`
+  // vocabulary — or a composition field's `allow` — forbids it.
+  "forbidden-component",
+  // Canvas-eligibility (EC-191): a server-only (RSC / non-client-renderable)
+  // component was placed in an editor composition, which is client-rendered.
+  // Such components belong in dev frames (page.tsx / layout.tsx), not the canvas.
+  "server-only-component",
+  "unknown-layout",
+  "route-conflict",
+  // Layout containers (EC-161): malformed Stack/Grid canonical props.
+  "invalid-container-direction",
+  "invalid-container-alignment",
+  "invalid-container-gap",
+  "invalid-container-columns",
+  // Responsive defaults (EC-163): malformed Grid stack-on-mobile override.
+  "invalid-container-responsive"
+]);
+var issueSeveritySchema = z.enum(["error", "warning"]);
+z.object({
+  code: issueCodeSchema,
+  severity: issueSeveritySchema,
+  message: z.string(),
+  /** JSON path into the graph, e.g. ['pages', 0, 'root', 'slots', 'children', 1]. */
+  path: z.array(z.union([z.string(), z.number()])),
+  /** The offending node id, when applicable. */
+  nodeId: idSchema.optional(),
+  meta: z.record(z.string(), jsonValueSchema).optional()
+});
+
+// ../project-graph/src/serialize.ts
+function parseProjectGraph(input) {
+  let json;
+  try {
+    json = typeof input === "string" ? JSON.parse(input) : input;
+  } catch {
+    json = void 0;
+  }
+  const result = projectGraphSchema.safeParse(json);
+  return result.success ? { ok: true, graph: result.data } : { ok: false, error: result.error };
+}
+var textNode = (id, value) => ({
+  id,
+  componentId: "base.primitives.Text",
+  props: { value: { kind: "static", value } }
+});
+function containerGraph(id, root) {
+  return {
+    id,
+    schemaVersion: PROJECT_GRAPH_SCHEMA_VERSION,
+    layouts: [{ id: `${id}.layout`, name: "Layout", root }]
+  };
+}
+containerGraph(
+  "proj-containers",
+  stackContainerNode("n-root", { direction: "vertical", gap: "4", align: "start" }, [
+    gridContainerNode("n-grid", { columns: 2, gap: "2", align: "stretch" }, [
+      textNode("n-cell-1", "Cell one"),
+      {
+        id: "n-cell-2",
+        componentId: "base.primitives.Heading",
+        props: { level: { kind: "static", value: 2 }, text: { kind: "static", value: "Cell two" } }
+      }
+    ]),
+    stackContainerNode("n-row", { direction: "horizontal", gap: "2", align: "center" }, [
+      textNode("n-row-a", "Left"),
+      textNode("n-row-b", "Right")
+    ])
+  ])
+);
+containerGraph(
+  "proj-soup",
+  stackContainerNode("n-root", { gap: "4" }, [
+    stackContainerNode("n-wrap-1", { gap: "2" }, [
+      stackContainerNode("n-wrap-2", {}, [
+        gridContainerNode("n-wrap-3", { columns: 2 }, [textNode("n-deep", "Deeply wrapped")])
+      ])
+    ]),
+    gridContainerNode("n-empty-grid", { columns: 3, gap: "2" }, []),
+    textNode("n-plain", "Plain sibling")
+  ])
+);
+
+// ../component-registry/src/registry.ts
+var ComponentRegistry = class {
+  byId = /* @__PURE__ */ new Map();
+  viewCache = /* @__PURE__ */ new Map();
+  issues = [];
+  constructor(manifests = []) {
+    for (const manifest of manifests) this.register(manifest);
+  }
+  register(manifest) {
+    if (!isValidComponentId(manifest.id)) {
+      this.issues.push({
+        code: "invalid-id",
+        componentId: manifest.id,
+        message: `Component id "${manifest.id}" is not namespaced under base.primitives.* or project.*.`
+      });
+    }
+    if (this.byId.has(manifest.id)) {
+      this.issues.push({
+        code: "duplicate-id",
+        componentId: manifest.id,
+        message: `Duplicate component id "${manifest.id}" \u2014 keeping the first registration.`
+      });
+      return;
+    }
+    this.byId.set(manifest.id, manifest);
+  }
+  has(id) {
+    return this.byId.has(id);
+  }
+  getManifest(id) {
+    return this.byId.get(id);
+  }
+  /** Required lookup — throws when the component is not registered. */
+  require(id) {
+    const manifest = this.byId.get(id);
+    if (!manifest) throw new Error(`Unknown component "${id}".`);
+    return manifest;
+  }
+  list(filter = {}) {
+    const q = filter.query?.toLowerCase();
+    return [...this.byId.values()].filter((m) => {
+      if (filter.namespace && namespaceOf(m.id) !== filter.namespace) return false;
+      if (filter.category && m.category !== filter.category) return false;
+      if (q) {
+        const hay = `${m.id} ${m.title ?? ""} ${m.category ?? ""}`.toLowerCase();
+        if (!hay.includes(q)) return false;
+      }
+      return true;
+    });
+  }
+  /** Platform primitives (`base.primitives.*`). */
+  primitives() {
+    return this.list().filter((m) => isPrimitive(m.id));
+  }
+  /** Project-level components (everything not under `base.primitives.*`). */
+  projectComponents() {
+    return this.list().filter((m) => !isPrimitive(m.id));
+  }
+  get size() {
+    return this.byId.size;
+  }
+  /** A `ComponentLookup` view for the project-graph validator. */
+  get lookup() {
+    return {
+      has: (id) => this.byId.has(id),
+      get: (id) => {
+        if (!this.byId.has(id)) return void 0;
+        let view = this.viewCache.get(id);
+        if (!view) {
+          view = toManifestView(this.byId.get(id));
+          this.viewCache.set(id, view);
+        }
+        return view;
+      }
+    };
+  }
+};
+
+// ../runtime-renderer/src/context.ts
+function getImplementation(implementations, id) {
+  if (implementations instanceof Map) return implementations.get(id);
+  return implementations[id];
+}
+
+// ../runtime-renderer/src/condition.ts
+function evaluateCondition(condition, resolveBinding, item) {
+  let left;
+  try {
+    left = resolveBinding(condition.source, item);
+  } catch {
+    return false;
+  }
+  switch (condition.operator) {
+    case "truthy":
+      return Boolean(left);
+    case "exists":
+      return left !== void 0 && left !== null;
+    case "eq":
+      return left === condition.value;
+    case "neq":
+      return left !== condition.value;
+    case "gt":
+      return compare(left, condition.value, (a, b) => a > b);
+    case "gte":
+      return compare(left, condition.value, (a, b) => a >= b);
+    case "lt":
+      return compare(left, condition.value, (a, b) => a < b);
+    case "lte":
+      return compare(left, condition.value, (a, b) => a <= b);
+    default: {
+      const _never = condition.operator;
+      return Boolean(_never);
+    }
+  }
+}
+function compare(left, right, op) {
+  if (typeof left !== "number" || typeof right !== "number") return false;
+  return op(left, right);
+}
+var ContentClientContext = createContext(null);
+function ContentClientProvider({
+  client,
+  children
+}) {
+  return createElement(ContentClientContext.Provider, { value: client }, children);
+}
+function MissingComponentFallback(props) {
+  return /* @__PURE__ */ jsx(
+    "div",
+    {
+      "data-ec-fallback": "missing-component",
+      "data-ec-node-id": props.nodeId,
+      "data-ec-component-id": props.componentId,
+      children: `Missing component "${props.componentId}" (node ${props.nodeId})`
+    }
+  );
+}
+function MissingSlotPlaceholder(props) {
+  return /* @__PURE__ */ jsx("div", { "data-ec-fallback": "missing-slot", "data-ec-node-id": props.nodeId, "data-ec-slot": props.slot, children: `Missing required slot "${props.slot}" (node ${props.nodeId})` });
+}
+function RenderErrorFallback(props) {
+  return /* @__PURE__ */ jsx("div", { "data-ec-fallback": "render-error", "data-ec-node-id": props.nodeId, children: props.message ? `Render error in node ${props.nodeId}: ${props.message}` : `Render error in node ${props.nodeId}` });
+}
+var RenderErrorBoundary = class extends Component {
+  constructor(props) {
+    super(props);
+    this.state = { error: null };
+  }
+  static getDerivedStateFromError(error) {
+    return { error };
+  }
+  componentDidCatch(_error, _info) {
+  }
+  render() {
+    if (this.state.error) {
+      return /* @__PURE__ */ jsx(RenderErrorFallback, { nodeId: this.props.nodeId, message: this.state.error.message });
+    }
+    return this.props.children;
+  }
+};
+function renderNode(node, ctx) {
+  if (node.condition && !evaluateCondition(node.condition, ctx.resolveBinding, ctx.item)) {
+    return null;
+  }
+  const manifest = ctx.registry.getManifest(node.componentId);
+  const implementation = getImplementation(ctx.implementations, node.componentId);
+  if (!manifest || !implementation) {
+    return decorate(
+      ctx,
+      node,
+      /* @__PURE__ */ jsx(MissingComponentFallback, { nodeId: node.id, componentId: node.componentId })
+    );
+  }
+  let resolved;
+  try {
+    resolved = resolveRender(node, manifest, ctx);
+  } catch (error) {
+    return decorate(ctx, node, /* @__PURE__ */ jsx(RenderErrorFallback, { nodeId: node.id, message: messageOf(error) }));
+  }
+  const element = createElement(
+    implementation,
+    { ...resolved.props, ...resolved.slotProps, key: node.id },
+    resolved.children
+  );
+  return decorate(
+    ctx,
+    node,
+    /* @__PURE__ */ jsx(RenderErrorBoundary, { nodeId: node.id, children: element }, node.id)
+  );
+}
+function decorate(ctx, node, rendered) {
+  return ctx.decorateNode ? ctx.decorateNode(node, rendered) : rendered;
+}
+function createEmbedRenderer(ctx) {
+  return (node) => renderComposition(node, ctx);
+}
+function manifestConsumesEmbeds(manifest) {
+  return Object.values(manifest.props).some((field) => field.type === "richText");
+}
+function createBlocksRenderer(ctx) {
+  return (value) => renderComposition(value, ctx);
+}
+function manifestConsumesRelations(manifest) {
+  return Object.values(manifest.props).some((field) => field.type === "relation");
+}
+function relationRefOf(value) {
+  if (!value || typeof value !== "object" || Array.isArray(value)) return null;
+  const { collection, id } = value;
+  return typeof collection === "string" && collection !== "" && typeof id === "string" && id !== "" ? { collection, id } : null;
+}
+function relationKey(ref) {
+  return `${ref.collection}:${ref.id}`;
+}
+function nodeRelationKeys(node, manifest) {
+  const keys = [];
+  for (const [name, value] of Object.entries(node.props ?? {})) {
+    if (value.kind !== "static") continue;
+    const spec = manifest.props[name];
+    if (spec?.type !== "relation") continue;
+    const refs = spec.cardinality === "many" ? Array.isArray(value.value) ? value.value : [] : [value.value];
+    for (const raw of refs) {
+      const ref = relationRefOf(raw);
+      if (ref) keys.push(relationKey(ref));
+    }
+  }
+  return keys;
+}
+function resolveRelationProp(cardinality, value, ctx) {
+  const resolveOne = (raw) => {
+    const ref = relationRefOf(raw);
+    if (!ref) return null;
+    if (ctx.transcludePath?.includes(relationKey(ref))) return null;
+    return ctx.resolveRelation?.(ref) ?? null;
+  };
+  if (cardinality === "many") {
+    const refs = Array.isArray(value) ? value : [];
+    const out = [];
+    for (const raw of refs) {
+      const target = resolveOne(raw);
+      if (target) out.push(target);
+    }
+    return out;
+  }
+  return resolveOne(value) ?? void 0;
+}
+function withContent(ctx, rendered) {
+  if (ctx.content)
+    return /* @__PURE__ */ jsx(ContentClientProvider, { client: ctx.content, children: rendered });
+  return rendered;
+}
+function resolveRender(node, manifest, ctx) {
+  const props = resolveProps(node, manifest, ctx);
+  if (manifestConsumesEmbeds(manifest)) props.renderEmbed = createEmbedRenderer(ctx);
+  if (manifestConsumesRelations(manifest)) {
+    props.renderBlocks = createBlocksRenderer({
+      ...ctx,
+      transcludePath: [...ctx.transcludePath ?? [], ...nodeRelationKeys(node, manifest)]
+    });
+  }
+  if (manifest.listing) {
+    const query = listingQueryOf(node, manifest.listing);
+    props[manifest.listing.prop] = query && ctx.resolveListing?.(query) || [];
+  }
+  if (manifest.iterate) {
+    return resolveRepeater(node, manifest, manifest.iterate, props, ctx);
+  }
+  if (manifest.composition) {
+    return resolveComposition(manifest.composition, props, ctx);
+  }
+  const { children, slotProps } = renderSlots(node, manifest, ctx);
+  return { props, slotProps, children };
+}
+function resolveComposition(spec, props, ctx) {
+  return { props, slotProps: {}, children: renderComposition(props[spec.valueProp], ctx) };
+}
+function resolveProps(node, manifest, ctx) {
+  const out = {};
+  const entries = Object.entries(node.props ?? {});
+  const isSpread = (value) => value.kind === "binding" && value.binding.mode === "spread";
+  for (const [name, value] of entries)
+    if (isSpread(value)) resolveProp(name, value, manifest, ctx, out);
+  for (const [name, value] of entries)
+    if (!isSpread(value)) resolveProp(name, value, manifest, ctx, out);
+  return out;
+}
+function isUrlLike(value) {
+  return /^(https?:)?\/\//.test(value) || value.startsWith("/") || value.startsWith("data:") || value.startsWith("blob:");
+}
+function collectReferencedAssetIds(node, registry, into = /* @__PURE__ */ new Set()) {
+  const manifest = registry.getManifest(node.componentId);
+  if (manifest) {
+    for (const [name, value] of Object.entries(node.props ?? {})) {
+      if (value.kind !== "static") continue;
+      const spec = manifest.props[name];
+      if (spec?.type === "asset") {
+        const raw = value.value;
+        if (typeof raw === "string" && raw !== "" && !isUrlLike(raw)) into.add(raw);
+      } else if (spec?.type === "object") {
+        collectObjectPropAssetIds(spec.fields, spec.cardinality, value.value, into);
+      }
+    }
+  }
+  for (const children of Object.values(node.slots ?? {})) {
+    for (const child of children) collectReferencedAssetIds(child, registry, into);
+  }
+  return into;
+}
+function collectReferencedRelations(nodes, registry, resolveRelation, into = {}, refKeys) {
+  for (const node of nodes) {
+    const manifest = registry.getManifest(node.componentId);
+    if (manifest) {
+      for (const [name, value] of Object.entries(node.props ?? {})) {
+        if (value.kind !== "static") continue;
+        const spec = manifest.props[name];
+        if (spec?.type === "relation") {
+          const refs = spec.cardinality === "many" ? Array.isArray(value.value) ? value.value : [] : [value.value];
+          for (const raw of refs) {
+            const ref = relationRefOf(raw);
+            if (!ref) continue;
+            const key = relationKey(ref);
+            refKeys?.add(key);
+            if (key in into) continue;
+            const target = resolveRelation(ref);
+            if (!target) continue;
+            into[key] = target;
+            for (const fieldValue of Object.values(target)) {
+              const childNodes = compositionRoots(fieldValue);
+              if (childNodes.length > 0) {
+                collectReferencedRelations(childNodes, registry, resolveRelation, into, refKeys);
+              }
+            }
+          }
+        } else if (spec?.type === "object" && value.value != null) {
+          collectObjectPropRelations(
+            spec.fields,
+            spec.cardinality,
+            value.value,
+            resolveRelation,
+            into,
+            refKeys
+          );
+        }
+      }
+      if (manifest.composition) {
+        const composed = node.props?.[manifest.composition.valueProp];
+        if (composed?.kind === "static") {
+          collectReferencedRelations(
+            compositionRoots(composed.value),
+            registry,
+            resolveRelation,
+            into,
+            refKeys
+          );
+        }
+      }
+    }
+    for (const children of Object.values(node.slots ?? {})) {
+      collectReferencedRelations(children, registry, resolveRelation, into, refKeys);
+    }
+  }
+  return into;
+}
+function listingQueryOf(node, spec) {
+  const pick = node.props?.[spec.filter.fromProp];
+  if (!pick || pick.kind !== "static") return null;
+  const ref = relationRefOf(pick.value);
+  const id = ref ? ref.id : typeof pick.value === "string" && pick.value !== "" ? pick.value : null;
+  if (id === null) return null;
+  const query = { collection: spec.collection, where: { [spec.filter.field]: id } };
+  if (spec.sort) query.sort = spec.sort;
+  if (spec.limit !== void 0) query.limit = spec.limit;
+  return query;
+}
+function serializeListingQuery(query) {
+  const where = {};
+  for (const key of Object.keys(query.where).sort()) {
+    const value = query.where[key];
+    if (value !== void 0) where[key] = value;
+  }
+  return JSON.stringify({
+    collection: query.collection,
+    where,
+    sort: query.sort ? { field: query.sort.field, direction: query.sort.direction ?? "asc" } : null,
+    limit: query.limit ?? null
+  });
+}
+function collectReferencedListings(nodes, registry, runListing, resolveRelation, into = {}, visitedRelations = /* @__PURE__ */ new Set()) {
+  for (const node of nodes) {
+    const manifest = registry.getManifest(node.componentId);
+    if (manifest?.listing) {
+      const query = listingQueryOf(node, manifest.listing);
+      if (query) {
+        const key = serializeListingQuery(query);
+        if (!(key in into)) into[key] = runListing(query);
+      }
+    }
+    if (manifest) {
+      for (const [name, value] of Object.entries(node.props ?? {})) {
+        if (value.kind !== "static") continue;
+        const spec = manifest.props[name];
+        if (spec?.type !== "relation") continue;
+        const refs = spec.cardinality === "many" ? Array.isArray(value.value) ? value.value : [] : [value.value];
+        for (const raw of refs) {
+          const ref = relationRefOf(raw);
+          if (!ref) continue;
+          const relKey = relationKey(ref);
+          if (visitedRelations.has(relKey)) continue;
+          visitedRelations.add(relKey);
+          const target = resolveRelation(ref);
+          if (!target) continue;
+          for (const fieldValue of Object.values(target)) {
+            const childNodes = compositionRoots(fieldValue);
+            if (childNodes.length > 0) {
+              collectReferencedListings(
+                childNodes,
+                registry,
+                runListing,
+                resolveRelation,
+                into,
+                visitedRelations
+              );
+            }
+          }
+        }
+      }
+    }
+    if (manifest?.composition) {
+      const composed = node.props?.[manifest.composition.valueProp];
+      if (composed?.kind === "static") {
+        collectReferencedListings(
+          compositionRoots(composed.value),
+          registry,
+          runListing,
+          resolveRelation,
+          into,
+          visitedRelations
+        );
+      }
+    }
+    for (const children of Object.values(node.slots ?? {})) {
+      collectReferencedListings(children, registry, runListing, resolveRelation, into, visitedRelations);
+    }
+  }
+  return into;
+}
+function collectObjectPropAssetIds(fields, cardinality, value, into) {
+  const items = cardinality === "many" ? Array.isArray(value) ? value : [] : [value];
+  for (const item of items) {
+    if (!item || typeof item !== "object" || Array.isArray(item)) continue;
+    const record = item;
+    for (const sub of fields) {
+      const sv = record[sub.name];
+      if (sub.type === "asset" && typeof sv === "string" && sv !== "" && !isUrlLike(sv)) into.add(sv);
+      else if (sub.type === "object" && sv != null)
+        collectObjectPropAssetIds(sub.fields, sub.cardinality, sv, into);
+    }
+  }
+}
+function collectObjectPropRelations(fields, cardinality, value, resolveRelation, into, refKeys) {
+  const items = cardinality === "many" ? Array.isArray(value) ? value : [] : [value];
+  for (const item of items) {
+    if (!item || typeof item !== "object" || Array.isArray(item)) continue;
+    const record = item;
+    for (const sub of fields) {
+      const sv = record[sub.name];
+      if (sub.type === "relation" && sv != null) {
+        const refs = sub.cardinality === "many" ? Array.isArray(sv) ? sv : [] : [sv];
+        for (const raw of refs) {
+          const ref = relationRefOf(raw);
+          if (!ref) continue;
+          const key = relationKey(ref);
+          refKeys?.add(key);
+          if (key in into) continue;
+          const target = resolveRelation(ref);
+          if (target) into[key] = target;
+        }
+      } else if (sub.type === "object" && sv != null) {
+        collectObjectPropRelations(sub.fields, sub.cardinality, sv, resolveRelation, into, refKeys);
+      }
+    }
+  }
+}
+function resolveObjectProps(fields, cardinality, value, ctx) {
+  const items = cardinality === "many" ? Array.isArray(value) ? value : [] : [value];
+  const resolvedItems = items.map((item) => {
+    if (!item || typeof item !== "object" || Array.isArray(item)) return item;
+    const next = { ...item };
+    for (const sub of fields) {
+      const sv = next[sub.name];
+      if (sub.type === "asset" && typeof sv === "string") {
+        if (sv === "" || isUrlLike(sv)) continue;
+        const resolved = ctx.resolveAsset?.(sv);
+        if (resolved) next[sub.name] = resolved;
+        else delete next[sub.name];
+      } else if (sub.type === "relation" && sv != null) {
+        if (!ctx.resolveRelation) continue;
+        const resolved = resolveRelationProp(sub.cardinality, sv, ctx);
+        if (resolved !== void 0) next[sub.name] = resolved;
+        else delete next[sub.name];
+      } else if (sub.type === "object" && sv != null) {
+        next[sub.name] = resolveObjectProps(sub.fields, sub.cardinality, sv, ctx);
+      }
+    }
+    return next;
+  });
+  return cardinality === "many" ? resolvedItems : resolvedItems[0];
+}
+function resolveProp(name, value, manifest, ctx, out) {
+  const spec = manifest.props[name];
+  if (value.kind === "static") {
+    const validate = propValueValidator(manifest, name);
+    if (validate && !validate(value.value)) {
+      if (spec?.default !== void 0) out[name] = spec.default;
+      return;
+    }
+    if (spec?.type === "asset" && typeof value.value === "string") {
+      const raw = value.value;
+      if (raw === "" || isUrlLike(raw)) {
+        out[name] = raw;
+        return;
+      }
+      const resolved2 = ctx.resolveAsset?.(raw);
+      if (resolved2) out[name] = resolved2;
+      return;
+    }
+    if (spec?.type === "object" && value.value != null) {
+      out[name] = resolveObjectProps(spec.fields, spec.cardinality, value.value, ctx);
+      return;
+    }
+    if (spec?.type === "relation") {
+      if (!ctx.resolveRelation) {
+        out[name] = value.value;
+        return;
+      }
+      const resolved2 = resolveRelationProp(spec.cardinality, value.value, ctx);
+      if (resolved2 !== void 0) out[name] = resolved2;
+      return;
+    }
+    out[name] = value.value;
+    return;
+  }
+  const resolved = ctx.resolveBinding(value.binding, ctx.item);
+  if (value.binding.mode === "spread") {
+    if (resolved && typeof resolved === "object" && !Array.isArray(resolved)) {
+      Object.assign(out, resolved);
+    }
+    return;
+  }
+  out[name] = resolved;
+}
+function renderSlots(node, manifest, ctx) {
+  const slots = node.slots ?? {};
+  const slotProps = {};
+  let children = renderSlotChildren(slots[DEFAULT_SLOT], ctx);
+  const declaredSlots = manifestSlots(manifest);
+  for (const slotSpec of declaredSlots) {
+    if (slotSpec.name === DEFAULT_SLOT) continue;
+    const nodes = slots[slotSpec.name];
+    if ((!nodes || nodes.length === 0) && slotSpec.required) {
+      slotProps[slotSpec.name] = /* @__PURE__ */ jsx(MissingSlotPlaceholder, { nodeId: node.id, slot: slotSpec.name });
+      continue;
+    }
+    slotProps[slotSpec.name] = renderSlotChildren(nodes, ctx);
+  }
+  const declared = new Set(declaredSlots.map((s) => s.name));
+  for (const [name, nodes] of Object.entries(slots)) {
+    if (name === DEFAULT_SLOT || declared.has(name)) continue;
+    slotProps[name] = renderSlotChildren(nodes, ctx);
+  }
+  const defaultSpec = declaredSlots.find((s) => s.name === DEFAULT_SLOT);
+  const defaultNodes = slots[DEFAULT_SLOT];
+  if (defaultSpec?.required && (!defaultNodes || defaultNodes.length === 0)) {
+    children = /* @__PURE__ */ jsx(MissingSlotPlaceholder, { nodeId: node.id, slot: DEFAULT_SLOT });
+  }
+  return { children, slotProps };
+}
+function renderSlotChildren(nodes, ctx) {
+  if (!nodes || nodes.length === 0) return null;
+  return /* @__PURE__ */ jsx(Fragment$1, { children: nodes.map((child) => /* @__PURE__ */ jsx(Fragment$1, { children: renderNode(child, ctx) }, child.id)) });
+}
+function resolveRepeater(node, manifest, iterate, props, ctx) {
+  const itemsValue = props[iterate.itemsProp];
+  const items = Array.isArray(itemsValue) ? itemsValue : [];
+  const template = node.slots?.[iterate.itemSlot];
+  const slotSpec = manifest.slots.find((s) => s.name === iterate.itemSlot);
+  if ((!template || template.length === 0) && slotSpec?.required) {
+    return {
+      props,
+      slotProps: {},
+      children: /* @__PURE__ */ jsx(MissingSlotPlaceholder, { nodeId: node.id, slot: iterate.itemSlot })
+    };
+  }
+  const rendered = items.map((item, index) => {
+    const itemCtx = { ...ctx, item: { item, index } };
+    return /* @__PURE__ */ jsx(Fragment$1, { children: (template ?? []).map((child) => (
+      // Keyed per template node for the same reason as renderSlotChildren.
+      /* @__PURE__ */ jsx(Fragment$1, { children: renderNode(child, itemCtx) }, child.id)
+    )) }, index);
+  });
+  return { props, slotProps: {}, children: /* @__PURE__ */ jsx(Fragment$1, { children: rendered }) };
+}
+function renderComposition(value, ctx) {
+  const roots = compositionRoots(value);
+  if (roots.length === 0) return null;
+  return withContent(
+    ctx,
+    /* @__PURE__ */ jsx(Fragment$1, { children: roots.map((root) => /* @__PURE__ */ jsx(Fragment$1, { children: renderNode(root, ctx) }, root.id)) })
+  );
+}
+function compositionRoots(value) {
+  if (Array.isArray(value)) return value.filter(isComponentNode);
+  if (isComponentNode(value)) return [value];
+  return [];
+}
+function isComponentNode(value) {
+  return typeof value === "object" && value !== null && typeof value.id === "string" && typeof value.componentId === "string";
+}
+function renderCompositionInLayout(graph, layoutId, value, ctx) {
+  const layout = layoutId ? graph.layouts.find((l) => l.id === layoutId) : void 0;
+  if (!layout) return withContent(ctx, renderComposition(value, ctx));
+  const root = injectNodesIntoOutlet(layout.root, compositionRoots(value));
+  return withContent(ctx, renderNode(root, ctx));
+}
+function injectNodesIntoOutlet(root, nodes) {
+  return {
+    ...root,
+    slots: {
+      ...root.slots ?? {},
+      [OUTLET_SLOT]: nodes
+    }
+  };
+}
+function messageOf(error) {
+  return error instanceof Error ? error.message : String(error);
+}
+var richTextAttrsSchema = z.record(z.string(), jsonValueSchema);
+var richTextMarkSchema = z.object({
+  type: z.string().min(1),
+  attrs: richTextAttrsSchema.optional()
+});
+var richTextNodeSchema = z.lazy(
+  () => z.object({
+    type: z.string().min(1),
+    attrs: richTextAttrsSchema.optional(),
+    content: z.array(richTextNodeSchema).optional(),
+    marks: z.array(richTextMarkSchema).optional(),
+    text: z.string().optional()
+  })
+);
+var richTextDocSchema = z.object({
+  type: z.literal("doc"),
+  content: z.array(richTextNodeSchema).default([])
+});
+var richTextValueSchema = z.object({
+  /** Schema version this value was written under. */
+  version: z.number().int().nonnegative(),
+  doc: richTextDocSchema
+});
+function parseRichTextValue(input) {
+  let json;
+  try {
+    json = typeof input === "string" ? JSON.parse(input) : input;
+  } catch {
+    json = void 0;
+  }
+  const result = richTextValueSchema.safeParse(json);
+  return result.success ? { ok: true, value: result.data } : { ok: false, error: result.error };
+}
+
+// ../rich-text/src/embed.ts
+var COMPONENT_EMBED_NODE_TYPE = "componentEmbed";
+function isComponentEmbedNode(node) {
+  return node.type === COMPONENT_EMBED_NODE_TYPE;
+}
+function embeddedComponentNode(node) {
+  if (!isComponentEmbedNode(node)) return void 0;
+  const raw = node.attrs?.node;
+  const parsed = componentNodeSchema.safeParse(raw);
+  return parsed.success ? parsed.data : void 0;
+}
+
+// ../rich-text/src/registry.tsx
+function createRichTextRegistry(definitions = []) {
+  const byType = /* @__PURE__ */ new Map();
+  for (const def of definitions) {
+    byType.set(def.type, def);
+  }
+  return {
+    has: (type) => byType.has(type),
+    get: (type) => byType.get(type),
+    isInline: (type) => byType.get(type)?.group === "inline"
+  };
+}
+var emptyRichTextRegistry = createRichTextRegistry();
+function attrString(value) {
+  return typeof value === "string" ? value : void 0;
+}
+function attrNumber(value) {
+  return typeof value === "number" ? value : void 0;
+}
+function applyMarks(content, marks, key) {
+  if (!marks || marks.length === 0) return content;
+  return marks.reduce((acc, mark, i) => {
+    const markKey = `${key}-m${i}`;
+    switch (mark.type) {
+      case "bold":
+        return createElement("strong", { key: markKey }, acc);
+      case "italic":
+        return createElement("em", { key: markKey }, acc);
+      case "code":
+        return createElement("code", { key: markKey }, acc);
+      case "strike":
+        return createElement("s", { key: markKey }, acc);
+      case "underline":
+        return createElement("u", { key: markKey }, acc);
+      case "link": {
+        const href = attrString(mark.attrs?.href) ?? "#";
+        const target = attrString(mark.attrs?.target);
+        const rel = target === "_blank" ? "noopener noreferrer" : attrString(mark.attrs?.rel);
+        return createElement("a", { key: markKey, href, ...target ? { target } : {}, ...rel ? { rel } : {} }, acc);
+      }
+      default:
+        return createElement("span", { key: markKey, "data-unknown-mark": mark.type }, acc);
+    }
+  }, content);
+}
+function invalidEmbedFallback(key) {
+  return createElement(
+    "div",
+    { key, "data-invalid-embed": "", className: "rich-text-invalid-embed", role: "note" },
+    "Invalid embedded component."
+  );
+}
+function renderChildren(nodes, ctx, path) {
+  if (!nodes) return [];
+  return nodes.map((child, i) => renderNode2(child, ctx, [...path, i]));
+}
+function unknownFallback(node, key) {
+  return createElement(
+    "div",
+    { key, "data-unknown-node": node.type, className: "rich-text-unknown", role: "note" },
+    `Unknown content block: ${node.type}`
+  );
+}
+function renderNode2(node, ctx, path) {
+  const key = `n-${path.join("-")}`;
+  if (node.type === "text") {
+    return applyMarks(node.text ?? "", node.marks, key);
+  }
+  switch (node.type) {
+    case "paragraph":
+      return createElement("p", { key }, ...renderChildren(node.content, ctx, path));
+    case "heading": {
+      const level = attrNumber(node.attrs?.level);
+      const clamped = level && level >= 1 && level <= 6 ? level : 1;
+      return createElement(`h${clamped}`, { key }, ...renderChildren(node.content, ctx, path));
+    }
+    case "bulletList":
+      return createElement("ul", { key }, ...renderChildren(node.content, ctx, path));
+    case "orderedList":
+      return createElement("ol", { key }, ...renderChildren(node.content, ctx, path));
+    case "listItem":
+      return createElement("li", { key }, ...renderChildren(node.content, ctx, path));
+    case "blockquote":
+      return createElement("blockquote", { key }, ...renderChildren(node.content, ctx, path));
+    case "codeBlock": {
+      const language = attrString(node.attrs?.language);
+      return createElement(
+        "pre",
+        { key },
+        createElement(
+          "code",
+          language ? { className: `language-${language}` } : {},
+          ...renderChildren(node.content, ctx, path)
+        )
+      );
+    }
+    case "hardBreak":
+      return createElement("br", { key });
+    case "horizontalRule":
+      return createElement("hr", { key });
+    case "image": {
+      const src = attrString(node.attrs?.src) ?? "";
+      const alt = attrString(node.attrs?.alt) ?? "";
+      const title = attrString(node.attrs?.title);
+      return createElement("img", { key, src, alt, ...title ? { title } : {} });
+    }
+    case "embed": {
+      const src = attrString(node.attrs?.src) ?? "";
+      const title = attrString(node.attrs?.title) ?? "Embedded content";
+      return createElement("iframe", {
+        key,
+        src,
+        title,
+        loading: "lazy",
+        "data-embed-provider": attrString(node.attrs?.provider) ?? void 0
+      });
+    }
+    case COMPONENT_EMBED_NODE_TYPE: {
+      const embedded = embeddedComponentNode(node);
+      if (!embedded) {
+        ctx.onIssue?.({
+          code: "invalid-embed",
+          message: "Component embed is missing a valid embedded component node.",
+          nodeType: node.type,
+          path
+        });
+        return invalidEmbedFallback(key);
+      }
+      if (!ctx.renderEmbed) return invalidEmbedFallback(key);
+      return createElement(Fragment$1, { key }, ctx.renderEmbed(embedded));
+    }
+    default: {
+      const def = ctx.registry.get(node.type);
+      if (def) {
+        const children = node.content && node.content.length > 0 ? renderChildren(node.content, ctx, path) : void 0;
+        const element = def.render({ node, children });
+        return element ? createElement(Fragment$1, { key }, element) : null;
+      }
+      ctx.onIssue?.({
+        code: "unknown-node",
+        message: `No renderer registered for rich-text node type "${node.type}".`,
+        nodeType: node.type,
+        path
+      });
+      return unknownFallback(node, key);
+    }
+  }
+}
+function renderRichTextDoc(doc, options = {}) {
+  const ctx = {
+    registry: options.registry ?? emptyRichTextRegistry,
+    renderEmbed: options.renderEmbed,
+    onIssue: options.onIssue
+  };
+  const children = renderChildren(doc.content, ctx, []);
+  return createElement(
+    "div",
+    { className: options.className ? `rich-text ${options.className}` : "rich-text" },
+    ...children
+  );
+}
+function renderRichTextValue(value, options = {}) {
+  return renderRichTextDoc(value.doc, options);
+}
+function str(value) {
+  return typeof value === "string" ? value : "";
+}
+var calloutBlock = {
+  type: "callout",
+  group: "block",
+  render: ({ node, children }) => createElement(
+    "aside",
+    { className: "callout", "data-tone": str(node.attrs?.tone) || "info", role: "note" },
+    children
+  )
+};
+var mentionInline = {
+  type: "mention",
+  group: "inline",
+  render: ({ node }) => createElement(
+    "span",
+    { className: "mention", "data-mention-id": str(node.attrs?.id) },
+    `@${str(node.attrs?.label)}`
+  )
+};
+var sampleRichTextRegistry = createRichTextRegistry([
+  calloutBlock,
+  mentionInline
+]);
+var richTextPrimitiveRegistry = sampleRichTextRegistry;
+function asJson(value) {
+  return value;
+}
+var RICH_TEXT_DEFAULT_VALUE = {
+  version: 1,
+  doc: {
+    type: "doc",
+    content: [
+      {
+        type: "paragraph",
+        content: [{ type: "text", text: "Rich text. Select to format, double-click to edit." }]
+      }
+    ]
+  }
+};
+var RICH_TEXT_FIXTURE_VALUE = {
+  version: 1,
+  doc: {
+    type: "doc",
+    content: [
+      { type: "heading", attrs: { level: 3 }, content: [{ type: "text", text: "Rich text block" }] },
+      {
+        type: "paragraph",
+        content: [
+          { type: "text", text: "Formatted " },
+          { type: "text", text: "bold", marks: [{ type: "bold" }] },
+          { type: "text", text: " and " },
+          { type: "text", text: "italic", marks: [{ type: "italic" }] },
+          { type: "text", text: " copy with a " },
+          { type: "text", text: "link", marks: [{ type: "link", attrs: { href: "https://example.com" } }] },
+          { type: "text", text: "." }
+        ]
+      },
+      {
+        type: "callout",
+        attrs: { tone: "info" },
+        content: [{ type: "text", text: "A custom block, rendered by the project registry." }]
+      }
+    ]
+  }
+};
+function RichText(props) {
+  const renderEmbed = typeof props.renderEmbed === "function" ? props.renderEmbed : void 0;
+  const parsed = parseRichTextValue(props.content ?? RICH_TEXT_DEFAULT_VALUE);
+  if (!parsed.ok) {
+    return /* @__PURE__ */ jsx("div", { "data-ec-primitive": "RichText", className: "rich-text-invalid", role: "note", children: "Invalid rich-text content." });
+  }
+  return /* @__PURE__ */ jsx("div", { "data-ec-primitive": "RichText", children: renderRichTextValue(parsed.value, { registry: richTextPrimitiveRegistry, renderEmbed }) });
+}
+var RichTextManifest = defineComponent({
+  id: "base.primitives.RichText",
+  namespace: "base.primitives",
+  title: "Rich Text",
+  category: "content",
+  description: "Formatted long-form content stored in the rich-text format.",
+  props: {
+    content: {
+      // The structured @elytracms/rich-text storage value (EC-159); validated by
+      // the renderer's parse guard rather than a scalar string check.
+      type: "richText",
+      context: "prop",
+      default: asJson(RICH_TEXT_DEFAULT_VALUE),
+      // Rich-text content prop, editable in place on the canvas (EC-159).
+      form: { label: "Content", inlineEditable: true }
+    }
+  },
+  slots: [],
+  fixtures: [
+    { name: "Default" },
+    { name: "Formatted", props: { content: asJson(RICH_TEXT_FIXTURE_VALUE) } }
+  ]
+});
+function asString(value, fallback = "") {
+  return typeof value === "string" ? value : fallback;
+}
+function gapCss(value) {
+  if (typeof value === "string") return spacingTokenCss(value);
+  if (typeof value === "number" && Number.isFinite(value) && value > 0) return `${value * 4}px`;
+  return void 0;
+}
+var ALIGN_ITEMS = {
+  start: "flex-start",
+  center: "center",
+  end: "flex-end",
+  stretch: "stretch"
+};
+function alignItemsCss(value) {
+  if (value === "start" || value === "center" || value === "end") return ALIGN_ITEMS[value];
+  return void 0;
+}
+var SPACING_OPTIONS = SPACING_TOKEN_NAMES.map((name) => ({ label: name, value: name }));
+var ALIGN_OPTIONS = CONTAINER_ALIGNMENTS.map((name) => ({ label: name, value: name }));
+function Container(props) {
+  return /* @__PURE__ */ jsxs("div", { "data-ec-primitive": "Container", children: [
+    props.children,
+    props.outlet
+  ] });
+}
+var ContainerManifest = defineComponent({
+  id: "base.primitives.Container",
+  namespace: "base.primitives",
+  title: "Container",
+  category: "layout",
+  props: {},
+  // The outlet is filled by page injection, so it is not authored-required.
+  slots: [{ name: "children" }, { name: "outlet" }]
+});
+function Stack(props) {
+  const style = {
+    display: "flex",
+    flexDirection: props.direction === "horizontal" ? "row" : "column"
+  };
+  const gap = gapCss(props.gap);
+  if (gap !== void 0) style.gap = gap;
+  const alignItems = alignItemsCss(props.align);
+  if (alignItems !== void 0) style.alignItems = alignItems;
+  return /* @__PURE__ */ jsx("div", { "data-ec-primitive": "Stack", style, children: props.children });
+}
+var StackManifest = defineComponent({
+  id: "base.primitives.Stack",
+  namespace: "base.primitives",
+  title: "Stack",
+  category: "layout",
+  props: {
+    direction: {
+      type: "select",
+      context: "prop",
+      default: "vertical",
+      options: [
+        { value: "vertical", label: "Vertical" },
+        { value: "horizontal", label: "Horizontal" }
+      ],
+      form: { label: "Direction" }
+    },
+    gap: {
+      // A design-token spacing step name (EC-161); legacy numeric gaps still render.
+      type: "select",
+      context: "prop",
+      default: "4",
+      options: SPACING_OPTIONS,
+      form: { label: "Gap" }
+    },
+    align: {
+      type: "select",
+      context: "prop",
+      default: "stretch",
+      options: ALIGN_OPTIONS,
+      form: { label: "Align" }
+    }
+  },
+  slots: [{ name: "children" }],
+  designTokens: ["space.gap"]
+});
+function asColumns(value) {
+  if (typeof value !== "number" || !Number.isFinite(value)) return GRID_MIN_COLUMNS;
+  return Math.min(Math.max(GRID_MIN_COLUMNS, Math.floor(value)), GRID_MAX_COLUMNS);
+}
+var GRID_MOBILE_BREAKPOINT_PX = 640;
+var GRID_STACK_CSS = `@media (max-width: ${GRID_MOBILE_BREAKPOINT_PX}px){[data-ec-grid-stack]{grid-template-columns:minmax(0,1fr) !important}}`;
+function Grid(props) {
+  const style = {
+    display: "grid",
+    gridTemplateColumns: `repeat(${asColumns(props.columns)}, minmax(0, 1fr))`
+  };
+  const gap = gapCss(props.gap);
+  if (gap !== void 0) style.gap = gap;
+  const alignItems = alignItemsCss(props.align);
+  if (alignItems !== void 0) style.alignItems = alignItems;
+  const stacksOnMobile = props.stackOnMobile !== false;
+  return /* @__PURE__ */ jsxs(
+    "div",
+    {
+      "data-ec-primitive": "Grid",
+      ...stacksOnMobile ? { "data-ec-grid-stack": "" } : {},
+      style,
+      children: [
+        stacksOnMobile ? /* @__PURE__ */ jsx("style", { children: GRID_STACK_CSS }) : null,
+        props.children
+      ]
+    }
+  );
+}
+var GridManifest = defineComponent({
+  id: "base.primitives.Grid",
+  namespace: "base.primitives",
+  title: "Grid",
+  category: "layout",
+  props: {
+    columns: {
+      type: "number",
+      context: "prop",
+      default: 2,
+      validation: { min: GRID_MIN_COLUMNS, max: GRID_MAX_COLUMNS },
+      form: { label: "Columns" }
+    },
+    gap: {
+      type: "select",
+      context: "prop",
+      default: "4",
+      options: SPACING_OPTIONS,
+      form: { label: "Gap" }
+    },
+    align: {
+      type: "select",
+      context: "prop",
+      default: "stretch",
+      options: ALIGN_OPTIONS,
+      form: { label: "Align" }
+    },
+    stackOnMobile: {
+      // Responsive default (EC-163): stacking is on unless explicitly opted out.
+      type: "boolean",
+      context: "prop",
+      default: true,
+      form: { label: "Stack on phones" }
+    }
+  },
+  slots: [{ name: "children" }],
+  designTokens: ["space.gap"]
+});
+function Text(props) {
+  return /* @__PURE__ */ jsx("p", { "data-ec-primitive": "Text", children: asString(props.value) });
+}
+var TextManifest = defineComponent({
+  id: "base.primitives.Text",
+  namespace: "base.primitives",
+  title: "Text",
+  category: "content",
+  props: {
+    value: {
+      type: "text",
+      context: "prop",
+      default: "",
+      // Plain-text content prop, editable in place on the canvas (EC-158).
+      form: { label: "Text", control: "textarea", inlineEditable: true }
+    }
+  },
+  slots: []
+});
+function Heading(props) {
+  const level = typeof props.level === "number" && props.level >= 1 && props.level <= 6 ? props.level : 2;
+  const tag = `h${level}`;
+  return createElement(tag, { "data-ec-primitive": "Heading" }, asString(props.text));
+}
+var HeadingManifest = defineComponent({
+  id: "base.primitives.Heading",
+  namespace: "base.primitives",
+  title: "Heading",
+  category: "content",
+  props: {
+    text: {
+      type: "text",
+      context: "prop",
+      default: "",
+      // Plain-text content prop, editable in place on the canvas (EC-158).
+      form: { label: "Text", inlineEditable: true }
+    },
+    level: {
+      // A numeric heading level 1–6 (the impl clamps out-of-range to 2).
+      type: "number",
+      context: "prop",
+      default: 2,
+      validation: { min: 1, max: 6 },
+      form: { label: "Level" }
+    }
+  },
+  slots: []
+});
+function asPositiveInt(value) {
+  return typeof value === "number" && Number.isInteger(value) && value > 0 ? value : void 0;
+}
+function asFocalPoint(value) {
+  if (value && typeof value === "object" && !Array.isArray(value)) {
+    const point = value;
+    if (typeof point.x === "number" && typeof point.y === "number") {
+      return { x: point.x, y: point.y };
+    }
+  }
+  return null;
+}
+function normalizeImageSource(props) {
+  const src = props.src;
+  const asset = src && typeof src === "object" && !Array.isArray(src) ? src : null;
+  const url = asset ? asString(asset.url) : asString(src);
+  const width = asPositiveInt(props.width) ?? (asset ? asPositiveInt(asset.width) : void 0);
+  const height = asPositiveInt(props.height) ?? (asset ? asPositiveInt(asset.height) : void 0);
+  const alt = asString(props.alt) || (asset ? asString(asset.alt) : "");
+  const focalPoint = asset ? asFocalPoint(asset.focalPoint) : null;
+  return { url, width, height, alt, focalPoint };
+}
+function focalPointObjectPosition(focalPoint) {
+  return focalPoint ? `${focalPoint.x * 100}% ${focalPoint.y * 100}%` : void 0;
+}
+function Image(props) {
+  const { url, width, height, alt, focalPoint } = normalizeImageSource(props);
+  const objectPosition = focalPointObjectPosition(focalPoint);
+  if (url === "") {
+    return /* @__PURE__ */ jsx(
+      "span",
+      {
+        "data-ec-primitive": "Image",
+        "data-ec-image": "empty",
+        role: "img",
+        "aria-label": alt || "No image selected",
+        children: "No image selected"
+      }
+    );
+  }
+  return /* @__PURE__ */ jsx(
+    "img",
+    {
+      "data-ec-primitive": "Image",
+      src: url,
+      alt,
+      ...width !== void 0 ? { width } : {},
+      ...height !== void 0 ? { height } : {},
+      ...objectPosition ? { style: { objectPosition } } : {}
+    }
+  );
+}
+var ImageManifest = defineComponent({
+  id: "base.primitives.Image",
+  namespace: "base.primitives",
+  title: "Image",
+  category: "media",
+  props: {
+    // EC-195: `asset`-typed, so the editor picks an uploaded asset (the renderer
+    // resolves the id to a url + intrinsic dimensions at delivery) — a plain URL
+    // string still works (the resolver passes URL-like values through).
+    src: {
+      type: "asset",
+      cardinality: "one",
+      context: "prop",
+      default: "",
+      form: { label: "Image" }
+    },
+    alt: {
+      type: "text",
+      context: "prop",
+      default: "",
+      form: { label: "Alt text" }
+    },
+    width: {
+      type: "number",
+      context: "prop",
+      validation: { min: 1 },
+      form: { label: "Width" }
+    },
+    height: {
+      type: "number",
+      context: "prop",
+      validation: { min: 1 },
+      form: { label: "Height" }
+    },
+    // EC-195: above-the-fold images load eagerly (`next/image priority`) so the
+    // host can opt the hero image out of lazy-loading.
+    priority: {
+      type: "boolean",
+      context: "prop",
+      default: false,
+      form: { label: "Load eagerly (above the fold)" }
+    }
+  },
+  slots: []
+});
+function Button(props) {
+  const label = asString(props.label, "Button");
+  if (typeof props.href === "string" && props.href.length > 0) {
+    return /* @__PURE__ */ jsx("a", { "data-ec-primitive": "Button", href: props.href, role: "button", children: label });
+  }
+  return /* @__PURE__ */ jsx("button", { "data-ec-primitive": "Button", type: "button", children: label });
+}
+var ButtonManifest = defineComponent({
+  id: "base.primitives.Button",
+  namespace: "base.primitives",
+  title: "Button",
+  category: "content",
+  props: {
+    label: {
+      type: "text",
+      context: "prop",
+      default: "Button",
+      form: { label: "Label" }
+    },
+    href: {
+      type: "text",
+      context: "prop",
+      form: { label: "Link" }
+    }
+  },
+  slots: []
+});
+function Repeater(props) {
+  return /* @__PURE__ */ jsx("div", { "data-ec-primitive": "Repeater", children: props.children });
+}
+var RepeaterManifest = defineComponent({
+  id: "base.primitives.Repeater",
+  namespace: "base.primitives",
+  title: "Repeater",
+  category: "data",
+  // EC-190 DD7: iterate-over-a-source is a binding construct designed out of v1.
+  // The `items` value (an array) has no static field-def type; it rides node.props
+  // undeclared (passing through the renderer) until the binding/iteration removal in
+  // slice 5 decides Repeater's fate. No editable static prop is exposed meanwhile.
+  props: {},
+  slots: [{ name: "item", label: "Item template", required: true }],
+  iterate: { itemsProp: "items", itemSlot: "item" }
+});
+function Switch(props) {
+  const key = asString(props.case);
+  const selected = props[`case:${key}`] ?? props.fallback;
+  return /* @__PURE__ */ jsx("div", { "data-ec-primitive": "Switch", children: selected });
+}
+var SwitchManifest = defineComponent({
+  id: "base.primitives.Switch",
+  namespace: "base.primitives",
+  title: "Switch",
+  category: "data",
+  props: {
+    case: {
+      type: "text",
+      context: "prop",
+      default: "",
+      form: { label: "Case" }
+    }
+  },
+  // Named case slots are dynamic; `fallback` renders when no case matches.
+  slots: [{ name: "fallback", label: "Fallback" }]
+});
+var PRIMITIVES = [
+  { manifest: ContainerManifest, implementation: Container },
+  { manifest: StackManifest, implementation: Stack },
+  { manifest: GridManifest, implementation: Grid },
+  { manifest: TextManifest, implementation: Text },
+  { manifest: HeadingManifest, implementation: Heading },
+  // Rich-text content primitive (EC-159) — content prop is the stored
+  // `@elytracms/rich-text` value, flagged inline-editable.
+  { manifest: RichTextManifest, implementation: RichText },
+  { manifest: ImageManifest, implementation: Image },
+  { manifest: ButtonManifest, implementation: Button },
+  { manifest: RepeaterManifest, implementation: Repeater },
+  { manifest: SwitchManifest, implementation: Switch }
+];
+function basePrimitives() {
+  const implementations = {};
+  for (const { manifest, implementation } of PRIMITIVES) {
+    implementations[manifest.id] = implementation;
+  }
+  return {
+    manifests: PRIMITIVES.map((p) => p.manifest),
+    implementations
+  };
+}
+
+// src/components.ts
+function defineHostComponents(components = [], options = {}) {
+  const includeBase = options.includeBasePrimitives !== false;
+  const base = includeBase ? basePrimitives() : { manifests: [], implementations: {} };
+  const registry = new ComponentRegistry([...base.manifests, ...components.map((c) => c.manifest)]);
+  const implementations = {};
+  for (const manifest of base.manifests) {
+    const implementation = getImplementation(base.implementations, manifest.id);
+    if (implementation) implementations[manifest.id] = implementation;
+  }
+  for (const component of components) {
+    implementations[component.manifest.id] = component.implementation;
+  }
+  return { registry, implementations, issues: registry.issues };
+}
+
+// src/payloads.ts
+var SOURCE_PAYLOAD_ERROR_KEY = "__elytraSourcePayloadError";
+function sourcePayloadError(sourceId, messages) {
+  return { [SOURCE_PAYLOAD_ERROR_KEY]: true, sourceId, messages: [...messages] };
+}
+function isSourcePayloadError(value) {
+  return typeof value === "object" && value !== null && value[SOURCE_PAYLOAD_ERROR_KEY] === true && typeof value.sourceId === "string" && Array.isArray(value.messages);
+}
+function unescapeRefToken(token) {
+  return token.replace(/~1/g, "/").replace(/~0/g, "~");
+}
+function pathFromToken(token) {
+  if (token === "" || token === "/") return [];
+  if (!token.startsWith("/")) return void 0;
+  return token.slice(1).split("/").map(unescapeRefToken);
+}
+var isPlainObject2 = (value) => typeof value === "object" && value !== null && !Array.isArray(value);
+function resolvePayloadToken(payload, token) {
+  const path = pathFromToken(token);
+  if (path === void 0) return void 0;
+  let current = payload;
+  for (const segment of path) {
+    if (Array.isArray(current)) {
+      if (!/^(0|[1-9][0-9]*)$/.test(segment)) return void 0;
+      const index = Number(segment);
+      if (index >= current.length) return void 0;
+      current = current[index];
+      continue;
+    }
+    if (isPlainObject2(current)) {
+      if (!Object.prototype.hasOwnProperty.call(current, segment)) return void 0;
+      current = current[segment];
+      continue;
+    }
+    return void 0;
+  }
+  return current;
+}
+function createBindingResolver(payloads) {
+  return (ref, item) => {
+    if (ref.mode === "repeaterItem") {
+      return item === void 0 ? void 0 : resolvePayloadToken(item.item, ref.token);
+    }
+    if (!Object.prototype.hasOwnProperty.call(payloads, ref.sourceId)) return void 0;
+    const payload = payloads[ref.sourceId];
+    if (isSourcePayloadError(payload)) {
+      throw new Error(
+        `Source "${payload.sourceId}" query was rejected: ${payload.messages.join("; ")}`
+      );
+    }
+    return resolvePayloadToken(payload, ref.token);
+  };
+}
+function relationResolver(relations) {
+  return (ref) => relations[`${ref.collection}:${ref.id}`] ?? null;
+}
+function listingResolver(listings) {
+  return (query) => listings[serializeListingQuery(query)] ?? null;
+}
+function assetResolver(assets) {
+  const byId = new Map(assets.map((asset) => [asset.id, asset]));
+  return (id) => {
+    const asset = byId.get(id);
+    return asset ? {
+      url: asset.url,
+      width: asset.width,
+      height: asset.height,
+      alt: asset.alt,
+      focalPoint: asset.focalPoint
+    } : null;
+  };
+}
+function UnresolvedPageFallback(props) {
+  return /* @__PURE__ */ jsx("div", { "data-ec-fallback": "unresolved-page", "data-ec-status": props.status, children: `This URL did not resolve to a page (status: ${props.status}).` });
+}
+function MissingDocumentFallback() {
+  return /* @__PURE__ */ jsx("div", { "data-ec-fallback": "missing-document", children: `Route resolved but carried no page document to render.` });
+}
+function stripServerErrorBoundary(_node, rendered) {
+  if (isValidElement(rendered) && rendered.type === RenderErrorBoundary) {
+    return rendered.props.children ?? null;
+  }
+  return rendered;
+}
+function defaultBindingPayloads(result) {
+  return { document: result.document, params: result.dynamicParams };
+}
+async function CanvasRenderer(props) {
+  const { result, components } = props;
+  if (result.status !== "ok") {
+    return /* @__PURE__ */ jsx(UnresolvedPageFallback, { status: result.status });
+  }
+  const resolveBinding = props.resolveBinding ?? createBindingResolver(props.payloads ?? defaultBindingPayloads(result));
+  const ctx = {
+    registry: components.registry,
+    implementations: components.implementations,
+    resolveBinding,
+    resolveAsset: assetResolver(props.assets ?? []),
+    // EC-254: wire relation population only when the host baked the populated
+    // targets, so a host that did not opt in keeps the raw-ref passthrough.
+    ...props.relations ? { resolveRelation: relationResolver(props.relations) } : {},
+    // EC-255: wire the listing resolver only when the host baked the query results,
+    // so a host that did not opt in keeps listing props empty (the block's own state).
+    ...props.listings ? { resolveListing: listingResolver(props.listings) } : {},
+    decorateNode: stripServerErrorBoundary
+  };
+  const graph = props.graph ?? null;
+  const document = result.document;
+  if (document) {
+    const layoutId = typeof document["layoutId"] === "string" ? document["layoutId"] : void 0;
+    const composition = compositionOf(document);
+    if (graph) return /* @__PURE__ */ jsx(Fragment, { children: renderCompositionInLayout(graph, layoutId, composition, ctx) });
+    return /* @__PURE__ */ jsx(Fragment, { children: renderComposition(composition, ctx) });
+  }
+  return /* @__PURE__ */ jsx(MissingDocumentFallback, {});
+}
+function compositionOf(document) {
+  const body = document["body"];
+  if (Array.isArray(body) || isComponentNodeValue(body)) return body;
+  return document["content"];
+}
+function compositionNodesOf(document) {
+  if (!document) return [];
+  const composition = compositionOf(document);
+  const candidates = Array.isArray(composition) ? composition : [composition];
+  return candidates.filter((node) => isComponentNodeValue(node));
+}
+function isComponentNodeValue(value) {
+  return typeof value === "object" && value !== null && typeof value.id === "string" && typeof value.componentId === "string";
+}
+z.enum(["draft", "published"]);
+function createContentContext(init) {
+  return {
+    locale: init.locale,
+    perspective: init.perspective,
+    locales: init.locales
+  };
+}
+
+// ../content/src/perspective.ts
+function isDocumentHistory(source) {
+  return "draft" in source && "versions" in source;
+}
+function selectPerspective(context, source) {
+  if (isDocumentHistory(source)) {
+    if (context.perspective === "draft") return source.draft;
+    return source.published ?? null;
+  }
+  if (context.perspective === "draft") return source;
+  return null;
+}
+
+// ../content/src/locale.ts
+function resolveLocaleValues(context, collection, doc, basePath = []) {
+  const values = {};
+  const fallbacks = [];
+  for (const field of collection.fields) {
+    const resolved = resolveField(collection, doc, field.name, context.locale, context.locales);
+    if (resolved.value === void 0) continue;
+    values[field.name] = resolved.value;
+    if (resolved.fellBack) {
+      fallbacks.push({
+        path: [...basePath, field.name],
+        field: field.name,
+        requestedLocale: context.locale,
+        sourceLocale: resolved.sourceLocale
+      });
+    }
+  }
+  return { values, fallbacks };
+}
+
+// ../content/src/populate.ts
+function isPopulatedRelation(field) {
+  return field.populate !== false;
+}
+function relationStub(ref) {
+  return { id: ref.id, collection: ref.collection };
+}
+function parseRelationRef(value) {
+  const parsed = documentRefSchema.safeParse(value);
+  return parsed.success ? parsed.data : void 0;
+}
+
+// ../content/src/assets.ts
+function resolvedAsset(record, url) {
+  return {
+    id: record.id,
+    url,
+    width: record.width ?? null,
+    height: record.height ?? null,
+    alt: record.alt ?? null,
+    mimeType: record.contentType,
+    focalPoint: record.focalPoint ?? null
+  };
+}
+function resolveAssetValue(lookup, assetId, location) {
+  const record = lookup.asset(assetId);
+  if (!record) {
+    return {
+      asset: null,
+      issues: [
+        cmsIssue({
+          code: "unknown-asset",
+          message: `Asset "${assetId}" could not be resolved.`,
+          path: location.path,
+          ...location.collectionId ? { collectionId: location.collectionId } : {},
+          ...location.documentId ? { documentId: location.documentId } : {},
+          meta: { assetId }
+        })
+      ]
+    };
+  }
+  return { asset: resolvedAsset(record, lookup.assetUrl(record)), issues: [] };
+}
+
+// ../content/src/resolve.ts
+function invalidValueIssue(field, collection, documentId, path, expected) {
+  return cmsIssue({
+    code: "invalid-field-value",
+    message: `Field "${field.name}" on "${collection.id}" holds a value that is not ${expected}.`,
+    path,
+    collectionId: collection.id,
+    documentId,
+    meta: { field: field.name, expected }
+  });
+}
+function resolveRelationTarget(context, lookup, ref, populate, path, ownerCollectionId, ownerDocumentId, acc) {
+  if (!populate) return { ...relationStub(ref) };
+  const missing = (reason) => {
+    acc.issues.push(
+      cmsIssue({
+        code: "unknown-relation-target",
+        message: `Relation target "${ref.collection}:${ref.id}" could not be populated (${reason}).`,
+        path,
+        collectionId: ownerCollectionId,
+        documentId: ownerDocumentId,
+        meta: { targetCollection: ref.collection, targetId: ref.id, reason }
+      })
+    );
+    return { ...relationStub(ref) };
+  };
+  const targetCollection = lookup.collection(ref.collection);
+  if (!targetCollection) return missing("unknown collection");
+  const source = lookup.document(ref);
+  if (!source) return missing("document not found");
+  const visible = selectPerspective(context, source);
+  if (!visible) return missing(`not visible in ${context.perspective} perspective`);
+  const fields = resolveFields(context, lookup, targetCollection, visible, 1, path, acc);
+  return { id: ref.id, collection: ref.collection, ...fields };
+}
+function resolveRelationField(context, lookup, collection, doc, field, value, depth, path, acc) {
+  const populate = depth === 0 && isPopulatedRelation(field);
+  if (field.cardinality === "many") {
+    if (!Array.isArray(value)) {
+      acc.issues.push(invalidValueIssue(field, collection, doc.id, path, "an array of references"));
+      return void 0;
+    }
+    const out = [];
+    value.forEach((entry, index) => {
+      const ref2 = parseRelationRef(entry);
+      if (!ref2) {
+        acc.issues.push(
+          invalidValueIssue(
+            field,
+            collection,
+            doc.id,
+            [...path, index],
+            "a { collection, id } reference"
+          )
+        );
+        return;
+      }
+      out.push(
+        resolveRelationTarget(
+          context,
+          lookup,
+          ref2,
+          populate,
+          [...path, index],
+          collection.id,
+          doc.id,
+          acc
+        )
+      );
+    });
+    return out;
+  }
+  const ref = parseRelationRef(value);
+  if (!ref) {
+    acc.issues.push(
+      invalidValueIssue(field, collection, doc.id, path, "a { collection, id } reference")
+    );
+    return void 0;
+  }
+  return resolveRelationTarget(context, lookup, ref, populate, path, collection.id, doc.id, acc);
+}
+function resolveAssetField(lookup, collection, doc, field, value, path, acc) {
+  const resolveOne = (assetId, entryPath) => {
+    if (typeof assetId !== "string" || assetId.length === 0) {
+      acc.issues.push(invalidValueIssue(field, collection, doc.id, entryPath, "an asset id string"));
+      return null;
+    }
+    const resolution = resolveAssetValue(lookup, assetId, {
+      path: entryPath,
+      collectionId: collection.id,
+      documentId: doc.id
+    });
+    acc.issues.push(...resolution.issues);
+    return resolution.asset;
+  };
+  if (field.cardinality === "many") {
+    if (!Array.isArray(value)) {
+      acc.issues.push(invalidValueIssue(field, collection, doc.id, path, "an array of asset ids"));
+      return void 0;
+    }
+    return value.map((entry, index) => resolveOne(entry, [...path, index])).filter((asset) => asset !== null);
+  }
+  return resolveOne(value, path);
+}
+function resolveObjectField(context, lookup, collection, doc, field, value, depth, path, acc) {
+  const resolveItem = (item, itemPath) => {
+    if (typeof item !== "object" || item === null || Array.isArray(item)) {
+      acc.issues.push(invalidValueIssue(field, collection, doc.id, itemPath, "an object"));
+      return null;
+    }
+    const record = item;
+    const out = {};
+    for (const sub of field.fields) {
+      const subValue = record[sub.name];
+      if (subValue === void 0) continue;
+      const resolved = resolveFieldValue(
+        context,
+        lookup,
+        collection,
+        doc,
+        sub,
+        subValue,
+        depth,
+        [...itemPath, sub.name],
+        acc
+      );
+      if (resolved !== void 0) out[sub.name] = resolved;
+    }
+    return out;
+  };
+  if (field.cardinality === "many") {
+    if (!Array.isArray(value)) {
+      acc.issues.push(invalidValueIssue(field, collection, doc.id, path, "an array of objects"));
+      return void 0;
+    }
+    return value.map((item, index) => resolveItem(item, [...path, index])).filter((item) => item !== null);
+  }
+  return resolveItem(value, path) ?? void 0;
+}
+function resolveFieldValue(context, lookup, collection, doc, field, value, depth, path, acc) {
+  switch (field.type) {
+    case "relation":
+      return resolveRelationField(context, lookup, collection, doc, field, value, depth, path, acc);
+    case "asset":
+      return resolveAssetField(lookup, collection, doc, field, value, path, acc);
+    case "object":
+      return resolveObjectField(context, lookup, collection, doc, field, value, depth, path, acc);
+    default:
+      return value;
+  }
+}
+function resolveFields(context, lookup, collection, doc, depth, basePath, acc) {
+  const localeResolution = resolveLocaleValues(context, collection, doc, basePath);
+  acc.fallbacks.push(...localeResolution.fallbacks);
+  const out = {};
+  for (const field of collection.fields) {
+    const value = localeResolution.values[field.name];
+    if (value === void 0) continue;
+    const resolved = resolveFieldValue(
+      context,
+      lookup,
+      collection,
+      doc,
+      field,
+      value,
+      depth,
+      [...basePath, field.name],
+      acc
+    );
+    if (resolved !== void 0) out[field.name] = resolved;
+  }
+  return out;
+}
+function resolveDocument(context, lookup, source) {
+  const acc = {
+    fallbacks: [],
+    issues: [...validateLocale(context.locales, context.locale)]
+  };
+  const info = () => ({
+    locale: context.locale,
+    perspective: context.perspective,
+    localeFallbacks: acc.fallbacks
+  });
+  const doc = selectPerspective(context, source);
+  if (!doc) return { document: null, info: info(), issues: acc.issues };
+  const collection = lookup.collection(doc.collection);
+  if (!collection) {
+    acc.issues.push(
+      cmsIssue({
+        code: "unknown-collection",
+        message: `Document "${doc.id}" belongs to unknown collection "${doc.collection}".`,
+        path: ["collection"],
+        collectionId: doc.collection,
+        documentId: doc.id
+      })
+    );
+    return { document: null, info: info(), issues: acc.issues };
+  }
+  const fields = resolveFields(context, lookup, collection, doc, 0, [], acc);
+  return {
+    document: { id: doc.id, collection: doc.collection, ...fields },
+    info: info(),
+    issues: acc.issues
+  };
+}
+function populateRelationRef(context, lookup, ref) {
+  const acc = { fallbacks: [], issues: [] };
+  const miss = (reason) => {
+    acc.issues.push(
+      cmsIssue({
+        code: "unknown-relation-target",
+        message: `Relation target "${ref.collection}:${ref.id}" could not be populated (${reason}).`,
+        path: [ref.collection, ref.id],
+        collectionId: ref.collection,
+        documentId: ref.id,
+        meta: { targetCollection: ref.collection, targetId: ref.id, reason }
+      })
+    );
+    return { document: null, issues: acc.issues };
+  };
+  const targetCollection = lookup.collection(ref.collection);
+  if (!targetCollection) return miss("unknown collection");
+  const source = lookup.document(ref);
+  if (!source) return miss("document not found");
+  const visible = selectPerspective(context, source);
+  if (!visible) return miss(`not visible in ${context.perspective} perspective`);
+  const fields = resolveFields(context, lookup, targetCollection, visible, 1, [], acc);
+  return {
+    document: { id: ref.id, collection: ref.collection, ...fields },
+    issues: acc.issues
+  };
+}
+
+// ../content/src/query.ts
+var FILTER_OPERATORS = ["eq", "gt", "gte", "in", "lt", "lte"];
+function queryError(code, message, path, meta) {
+  return { code, message, path, ...meta ? { meta } : {} };
+}
+function isFilterScalar(value) {
+  return typeof value === "string" || typeof value === "number" || typeof value === "boolean";
+}
+function isOperator(key) {
+  return FILTER_OPERATORS.includes(key);
+}
+function normalizeWhere(where) {
+  const entries = [];
+  for (const field of Object.keys(where).sort()) {
+    const raw = where[field];
+    if (raw === void 0) continue;
+    if (isFilterScalar(raw)) {
+      entries.push({ field, condition: { eq: raw } });
+      continue;
+    }
+    const condition = {};
+    for (const op of FILTER_OPERATORS) {
+      const value = raw[op];
+      if (value === void 0) continue;
+      condition[op] = value;
+    }
+    entries.push({ field, condition });
+  }
+  return entries;
+}
+function fieldByName(collection, name) {
+  return collection.fields.find((f) => f.name === name);
+}
+function validateWhere(collection, where) {
+  const errors = [];
+  for (const field of Object.keys(where).sort()) {
+    const raw = where[field];
+    if (raw === void 0) continue;
+    const path = ["where", field];
+    const def = fieldByName(collection, field);
+    if (!def || def.filterable !== true) {
+      errors.push(
+        queryError(
+          "non-filterable-field",
+          def ? `Field "${field}" on "${collection.id}" is not declared filterable.` : `Field "${field}" does not exist on "${collection.id}".`,
+          path,
+          { collection: collection.id, field }
+        )
+      );
+      continue;
+    }
+    if (isFilterScalar(raw)) continue;
+    if (raw === null || typeof raw !== "object" || Array.isArray(raw)) {
+      errors.push(
+        queryError(
+          "invalid-filter",
+          `Filter for "${field}" must be a scalar or an operator object.`,
+          path
+        )
+      );
+      continue;
+    }
+    const keys = Object.keys(raw).sort();
+    if (keys.length === 0) {
+      errors.push(queryError("invalid-filter", `Filter for "${field}" has no operators.`, path));
+      continue;
+    }
+    for (const key of keys) {
+      const value = raw[key];
+      if (value === void 0) continue;
+      const opPath = ["where", field, key];
+      if (!isOperator(key)) {
+        errors.push(
+          queryError(
+            "invalid-filter",
+            `Unknown filter operator "${key}" on "${field}" \u2014 the vocabulary is exactly ${FILTER_OPERATORS.join(", ")}.`,
+            opPath,
+            { operator: key }
+          )
+        );
+        continue;
+      }
+      if (key === "in") {
+        if (!Array.isArray(value) || !value.every(isFilterScalar)) {
+          errors.push(
+            queryError(
+              "invalid-filter",
+              `Operator "in" on "${field}" requires an array of scalars.`,
+              opPath
+            )
+          );
+        }
+        continue;
+      }
+      if (!isFilterScalar(value)) {
+        errors.push(
+          queryError(
+            "invalid-filter",
+            `Operator "${key}" on "${field}" requires a scalar value.`,
+            opPath
+          )
+        );
+      }
+    }
+  }
+  return errors;
+}
+function validateSort(collection, sort) {
+  const def = fieldByName(collection, sort.field);
+  if (!def || def.filterable !== true) {
+    return [
+      queryError(
+        "invalid-sort",
+        def ? `Sort field "${sort.field}" on "${collection.id}" is not declared filterable.` : `Sort field "${sort.field}" does not exist on "${collection.id}".`,
+        ["sort", "field"],
+        { collection: collection.id, field: sort.field }
+      )
+    ];
+  }
+  if (sort.direction !== void 0 && sort.direction !== "asc" && sort.direction !== "desc") {
+    return [
+      queryError("invalid-sort", `Sort direction must be "asc" or "desc".`, ["sort", "direction"])
+    ];
+  }
+  return [];
+}
+function validateLimit(limit) {
+  if (!Number.isInteger(limit) || limit < 1) {
+    return [queryError("invalid-limit", "Limit must be a positive integer.", ["limit"])];
+  }
+  return [];
+}
+function filterScalarOf(value) {
+  if (isFilterScalar(value)) return value;
+  if (value !== null && typeof value === "object" && !Array.isArray(value) && typeof value.id === "string") {
+    return value.id;
+  }
+  return null;
+}
+function compares(value, bound) {
+  if (value === null) return null;
+  if (typeof value === "number" && typeof bound === "number") {
+    return value < bound ? -1 : value > bound ? 1 : 0;
+  }
+  if (typeof value === "string" && typeof bound === "string") {
+    return value < bound ? -1 : value > bound ? 1 : 0;
+  }
+  return null;
+}
+function matchesFieldValue(value, condition) {
+  if (Array.isArray(value)) {
+    return value.some((element) => matchesCondition(filterScalarOf(element), condition));
+  }
+  return matchesCondition(filterScalarOf(value), condition);
+}
+function matchesCondition(value, condition) {
+  for (const op of FILTER_OPERATORS) {
+    const bound = condition[op];
+    if (bound === void 0) continue;
+    switch (op) {
+      case "eq":
+        if (value !== bound) return false;
+        break;
+      case "in":
+        if (value === null || !bound.includes(value)) return false;
+        break;
+      case "lt":
+      case "lte":
+      case "gt":
+      case "gte": {
+        const cmp = compares(value, bound);
+        if (cmp === null) return false;
+        if (op === "lt" && !(cmp < 0)) return false;
+        if (op === "lte" && !(cmp <= 0)) return false;
+        if (op === "gt" && !(cmp > 0)) return false;
+        if (op === "gte" && !(cmp >= 0)) return false;
+        break;
+      }
+    }
+  }
+  return true;
+}
+function compareSortValues(a, b) {
+  const rank = (v) => typeof v === "number" ? 0 : typeof v === "string" ? 1 : typeof v === "boolean" ? 2 : 3;
+  const ra = rank(a);
+  const rb = rank(b);
+  if (ra !== rb) return ra - rb;
+  if (typeof a === "number" && typeof b === "number") return a < b ? -1 : a > b ? 1 : 0;
+  if (typeof a === "string" && typeof b === "string") return a < b ? -1 : a > b ? 1 : 0;
+  if (typeof a === "boolean" && typeof b === "boolean") return a === b ? 0 : a ? 1 : -1;
+  return 0;
+}
+function compareListEntries(a, b, direction) {
+  const byValue = compareSortValues(a.sortValue, b.sortValue);
+  const directed = direction === "desc" ? -byValue : byValue;
+  if (directed !== 0) return directed;
+  return a.id < b.id ? -1 : a.id > b.id ? 1 : 0;
+}
+var LIST_CURSOR_PREFIX = "ec1.";
+var cursorPayloadSchema = z.object({
+  v: z.literal(1),
+  f: z.string().nullable(),
+  d: z.enum(["asc", "desc"]),
+  s: z.union([z.string(), z.number(), z.boolean(), z.null()]),
+  i: z.string().min(1)
+});
+var BASE64URL = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789-_";
+function toBase64Url(bytes) {
+  let out = "";
+  for (let i = 0; i < bytes.length; i += 3) {
+    const a = bytes[i] ?? 0;
+    const b = bytes[i + 1];
+    const c = bytes[i + 2];
+    out += BASE64URL[a >> 2];
+    out += BASE64URL[(a & 3) << 4 | (b ?? 0) >> 4];
+    if (b !== void 0) out += BASE64URL[(b & 15) << 2 | (c ?? 0) >> 6];
+    if (c !== void 0) out += BASE64URL[c & 63];
+  }
+  return out;
+}
+function fromBase64Url(text) {
+  const values = [];
+  for (const char of text) {
+    const value = BASE64URL.indexOf(char);
+    if (value === -1) return null;
+    values.push(value);
+  }
+  if (values.length % 4 === 1) return null;
+  const bytes = [];
+  for (let i = 0; i < values.length; i += 4) {
+    const [a, b, c, d] = [values[i], values[i + 1], values[i + 2], values[i + 3]];
+    if (a === void 0 || b === void 0) break;
+    bytes.push(a << 2 | b >> 4);
+    if (c !== void 0) bytes.push((b & 15) << 4 | c >> 2);
+    if (d !== void 0) bytes.push(((c ?? 0) & 3) << 6 | d);
+  }
+  return new Uint8Array(bytes);
+}
+function encodeListCursor(cursor) {
+  const payload = JSON.stringify({
+    v: 1,
+    f: cursor.sortField,
+    d: cursor.direction,
+    s: cursor.sortValue,
+    i: cursor.id
+  });
+  return LIST_CURSOR_PREFIX + toBase64Url(new TextEncoder().encode(payload));
+}
+function decodeListCursor(text) {
+  if (!text.startsWith(LIST_CURSOR_PREFIX)) return null;
+  const bytes = fromBase64Url(text.slice(LIST_CURSOR_PREFIX.length));
+  if (!bytes) return null;
+  let parsed;
+  try {
+    parsed = JSON.parse(new TextDecoder().decode(bytes));
+  } catch {
+    return null;
+  }
+  const payload = cursorPayloadSchema.safeParse(parsed);
+  if (!payload.success) return null;
+  return {
+    sortField: payload.data.f,
+    direction: payload.data.d,
+    sortValue: payload.data.s,
+    id: payload.data.i
+  };
+}
+
+// ../content/src/tags.ts
+function sortedUnique(values) {
+  return [...new Set(values)].sort();
+}
+function cacheTags(init) {
+  return {
+    docs: sortedUnique(init.docs ?? []),
+    collections: sortedUnique(init.collections ?? []),
+    routes: sortedUnique(init.routes ?? []),
+    assets: sortedUnique(init.assets ?? []),
+    locale: init.locale
+  };
+}
+function documentCacheKeys(collection, document) {
+  const keys = [documentKey({ collection: document.collection, id: document.id })];
+  for (const field of collection.fields) {
+    if (field.type !== "relation") continue;
+    const value = document[field.name];
+    const entries = Array.isArray(value) ? value : [value];
+    for (const entry of entries) {
+      if (entry !== null && typeof entry === "object" && typeof entry.id === "string" && typeof entry.collection === "string") {
+        const ref = entry;
+        keys.push(documentKey({ collection: ref.collection, id: ref.id }));
+      }
+    }
+  }
+  return keys;
+}
+
+// ../content/src/client.ts
+function withLocale(context, locale) {
+  return locale === void 0 || locale === context.locale ? context : { ...context, locale };
+}
+function normalizePath2(url) {
+  return "/" + splitPath(url).join("/");
+}
+function materializeRouteDocumentRef(ref, params) {
+  if (!ref.id.startsWith(":")) return { ok: true, ref };
+  const param = ref.id.slice(1);
+  const value = params[param];
+  if (value === void 0 || value.length === 0) return { ok: false, missingParam: param };
+  return { ok: true, ref: { collection: ref.collection, id: value } };
+}
+function mountParamName(route) {
+  const last = splitPath(route.pattern).at(-1) ?? "";
+  return last.replace(/^:/, "").replace(/\*$/, "");
+}
+function createContentClient(init) {
+  const { lookup, context } = init;
+  const allRoutes = init.routes ?? [];
+  const mounts = allRoutes.map((route) => {
+    const mount = hierarchyMount(route);
+    return mount ? { mount, route } : void 0;
+  }).filter((m) => m !== void 0);
+  const router = createRouter(
+    allRoutes.filter((route) => !isHierarchyTemplate(route)),
+    init.redirects ?? [],
+    { defaultLocale: context.locales.default }
+  );
+  const resolveBoundDocument = (ctx, ref, issues, docKeys, collections) => {
+    collections.push(ref.collection);
+    const collection = lookup.collection(ref.collection);
+    const source = lookup.document(ref) ?? (collection ? findBySlug(ctx, collection, ref.id) : void 0);
+    if (!source) {
+      issues.push(
+        cmsIssue({
+          code: "unknown-route-target",
+          message: `Route-bound document "${ref.collection}:${ref.id}" was not found.`,
+          path: ["document"],
+          collectionId: ref.collection,
+          documentId: ref.id
+        })
+      );
+      return null;
+    }
+    const result = resolveDocument(ctx, lookup, source);
+    issues.push(...result.issues);
+    if (result.document && collection) {
+      docKeys.push(...documentCacheKeys(collection, result.document));
+    }
+    return result.document;
+  };
+  const resolvePage = (url, locale) => {
+    const ctx = withLocale(context, locale);
+    const path = normalizePath2(url);
+    const resolution = router.resolveUrl(path, ctx.locale);
+    const issues = [];
+    const docKeys = [];
+    const collections = [];
+    const routePaths = [path];
+    if (resolution.status === "redirect") {
+      const chain = router.followRedirects(path);
+      routePaths.push(...chain.chain);
+      return {
+        status: "redirect",
+        route: null,
+        dynamicParams: {},
+        localeFallback: false,
+        redirect: {
+          target: resolution.redirectTarget ?? chain.target,
+          permanent: resolution.permanent ?? chain.permanent
+        },
+        document: null,
+        issues,
+        tags: cacheTags({ routes: routePaths, locale: ctx.locale })
+      };
+    }
+    if (resolution.status === "notFound") {
+      const urlSegments = splitPath(path);
+      for (const { mount, route: route2 } of mounts) {
+        if (mount.locale !== void 0 && mount.locale !== ctx.locale) continue;
+        if (urlSegments.length <= mount.prefix.length) continue;
+        if (!mount.prefix.every((seg, i) => urlSegments[i] === seg)) continue;
+        const collection = lookup.collection(mount.collection);
+        if (!collection || !isHierarchical(collection)) continue;
+        const rest = urlSegments.slice(mount.prefix.length);
+        const source = findByComposedPath(ctx, mount.collection, rest);
+        if (!source) continue;
+        collections.push(mount.collection);
+        const result = resolveDocument(ctx, lookup, source);
+        issues.push(...result.issues);
+        if (!result.document) continue;
+        docKeys.push(...documentCacheKeys(collection, result.document));
+        return {
+          status: "ok",
+          route: route2,
+          dynamicParams: { [mountParamName(route2)]: rest.join("/") },
+          localeFallback: false,
+          redirect: null,
+          document: result.document,
+          issues,
+          tags: cacheTags({ docs: docKeys, collections, routes: routePaths, locale: ctx.locale })
+        };
+      }
+      return {
+        status: "notFound",
+        route: null,
+        dynamicParams: {},
+        localeFallback: resolution.fallback,
+        redirect: null,
+        document: null,
+        issues,
+        tags: cacheTags({ routes: routePaths, locale: ctx.locale })
+      };
+    }
+    const route = resolution.route ?? null;
+    let document = null;
+    let documentMissing = false;
+    if (resolution.documentRef) {
+      const materialized = materializeRouteDocumentRef(
+        resolution.documentRef,
+        resolution.dynamicParams
+      );
+      if (materialized.ok) {
+        document = resolveBoundDocument(ctx, materialized.ref, issues, docKeys, collections);
+        documentMissing = document === null;
+      } else {
+        documentMissing = true;
+        collections.push(resolution.documentRef.collection);
+        issues.push(
+          cmsIssue({
+            code: "unknown-route-target",
+            message: `Route "${route?.id ?? path}" binds its document to URL parameter ":${materialized.missingParam}", which pattern "${route?.pattern ?? path}" does not capture.`,
+            path: ["routes", route?.id ?? path, "document"],
+            collectionId: resolution.documentRef.collection,
+            meta: { param: materialized.missingParam, pattern: route?.pattern }
+          })
+        );
+      }
+    }
+    if (documentMissing) {
+      return {
+        status: "notFound",
+        route: null,
+        dynamicParams: resolution.dynamicParams,
+        localeFallback: resolution.fallback,
+        redirect: null,
+        document: null,
+        issues,
+        tags: cacheTags({ docs: docKeys, collections, routes: routePaths, locale: ctx.locale })
+      };
+    }
+    return {
+      status: "ok",
+      route,
+      dynamicParams: resolution.dynamicParams,
+      localeFallback: resolution.fallback,
+      redirect: null,
+      document,
+      issues,
+      tags: cacheTags({ docs: docKeys, collections, routes: routePaths, locale: ctx.locale })
+    };
+  };
+  const findBySlug = (ctx, collection, slug) => {
+    if (!lookup.documents) return void 0;
+    if (!collection.fields.some((f) => f.name === "slug")) return void 0;
+    const matches = [];
+    for (const source of lookup.documents(collection.id)) {
+      const row = selectPerspective(ctx, source);
+      if (!row) continue;
+      const value = resolveField(collection, row, "slug", ctx.locale, ctx.locales).value;
+      if (value === slug) matches.push({ id: row.id, source });
+    }
+    matches.sort((a, b) => a.id < b.id ? -1 : a.id > b.id ? 1 : 0);
+    return matches[0]?.source;
+  };
+  const findByComposedPath = (ctx, collectionId, segments) => {
+    if (!lookup.documents) return void 0;
+    const rows = [];
+    const sourceById = /* @__PURE__ */ new Map();
+    for (const source of lookup.documents(collectionId)) {
+      const row = selectPerspective(ctx, source);
+      if (!row) continue;
+      rows.push(row);
+      sourceById.set(row.id, source);
+    }
+    const matched = resolveByPath(segments, rows);
+    return matched ? sourceById.get(matched.id) : void 0;
+  };
+  const getDocument = (collectionId, idOrSlug, locale) => {
+    const ctx = withLocale(context, locale);
+    const baseTags = { collections: [collectionId], locale: ctx.locale };
+    const collection = lookup.collection(collectionId);
+    if (!collection) {
+      return {
+        document: null,
+        info: null,
+        issues: [
+          cmsIssue({
+            code: "unknown-collection",
+            message: `Collection "${collectionId}" is not defined.`,
+            path: ["collection"],
+            collectionId
+          })
+        ],
+        tags: cacheTags(baseTags)
+      };
+    }
+    const source = lookup.document({ collection: collectionId, id: idOrSlug }) ?? findBySlug(ctx, collection, idOrSlug);
+    if (!source) {
+      return { document: null, info: null, issues: [], tags: cacheTags(baseTags) };
+    }
+    const result = resolveDocument(ctx, lookup, source);
+    const docKeys = result.document ? documentCacheKeys(collection, result.document) : [];
+    return {
+      // The generated per-collection delivery type (EC-142 codegen) is the
+      // static face of what resolveDocument produces for this collection.
+      document: result.document,
+      info: result.info,
+      issues: result.issues,
+      tags: cacheTags({ ...baseTags, docs: docKeys })
+    };
+  };
+  const listDocuments = (collectionId, query = {}) => {
+    const ctx = context;
+    const errorTags = cacheTags({ collections: [collectionId], locale: ctx.locale });
+    const errors = [];
+    const collection = lookup.collection(collectionId);
+    if (!collection) {
+      errors.push(
+        queryError("unknown-collection", `Collection "${collectionId}" is not defined.`, [
+          "collection"
+        ])
+      );
+      return { ok: false, errors, tags: errorTags };
+    }
+    if (!lookup.documents) {
+      errors.push(
+        queryError(
+          "list-not-supported",
+          "This content lookup does not provide a `documents` capability.",
+          []
+        )
+      );
+      return { ok: false, errors, tags: errorTags };
+    }
+    if (query.where) errors.push(...validateWhere(collection, query.where));
+    if (query.sort) errors.push(...validateSort(collection, query.sort));
+    if (query.limit !== void 0) errors.push(...validateLimit(query.limit));
+    const sortField = query.sort?.field ?? null;
+    const direction = query.sort?.direction ?? "asc";
+    let after = null;
+    if (query.cursor !== void 0) {
+      const decoded = decodeListCursor(query.cursor);
+      if (!decoded || decoded.sortField !== sortField || decoded.direction !== direction) {
+        errors.push(
+          queryError(
+            "invalid-cursor",
+            decoded ? "Cursor was minted under a different sort and cannot be reused." : "Cursor is malformed.",
+            ["cursor"]
+          )
+        );
+      } else {
+        after = { sortValue: decoded.sortValue, id: decoded.id };
+      }
+    }
+    if (errors.length > 0) return { ok: false, errors, tags: errorTags };
+    const where = normalizeWhere(query.where ?? {});
+    const entries = [];
+    for (const source of lookup.documents(collectionId)) {
+      const row = selectPerspective(ctx, source);
+      if (!row || row.collection !== collectionId) continue;
+      const values = resolveLocaleValues(ctx, collection, row).values;
+      const matches = where.every(
+        (entry) => matchesFieldValue(values[entry.field], entry.condition)
+      );
+      if (!matches) continue;
+      entries.push({
+        source,
+        id: row.id,
+        sortValue: sortField === null ? row.id : filterScalarOf(values[sortField])
+      });
+    }
+    entries.sort(
+      (a, b) => compareListEntries(
+        { id: a.id, sortValue: a.sortValue },
+        { id: b.id, sortValue: b.sortValue },
+        direction
+      )
+    );
+    const afterPosition = after;
+    const fromIndex = afterPosition ? entries.findIndex(
+      (entry) => compareListEntries(
+        { id: entry.id, sortValue: entry.sortValue },
+        afterPosition,
+        direction
+      ) > 0
+    ) : 0;
+    const start = fromIndex === -1 ? entries.length : fromIndex;
+    const end = query.limit !== void 0 ? start + query.limit : entries.length;
+    const pageEntries = entries.slice(start, end);
+    const hasMore = end < entries.length;
+    const documents = [];
+    const issues = [];
+    const docKeys = [];
+    for (const entry of pageEntries) {
+      const result = resolveDocument(ctx, lookup, entry.source);
+      issues.push(...result.issues);
+      if (result.document) {
+        documents.push(result.document);
+        docKeys.push(...documentCacheKeys(collection, result.document));
+      }
+    }
+    const last = pageEntries[pageEntries.length - 1];
+    const nextCursor = hasMore && last ? encodeListCursor({ sortField, direction, sortValue: last.sortValue, id: last.id }) : null;
+    return {
+      ok: true,
+      // The generated per-collection delivery type (EC-142 codegen) is the
+      // static face of what resolveDocument produces for this collection.
+      documents,
+      nextCursor,
+      issues,
+      tags: cacheTags({
+        docs: docKeys,
+        collections: [collectionId],
+        locale: ctx.locale
+      })
+    };
+  };
+  const resolveRelation = (ref) => populateRelationRef(context, lookup, ref).document;
+  return {
+    context,
+    routerIssues: router.issues,
+    resolvePage,
+    getDocument,
+    listDocuments,
+    resolveRelation
+  };
+}
+
+// ../content/src/binding-sources.ts
+var SECTION_SOURCE_PREFIX = "cms.section.";
+function isSectionSourceId(sourceId) {
+  return sourceId.startsWith(SECTION_SOURCE_PREFIX);
+}
+var isPlainObject3 = (value) => typeof value === "object" && value !== null && !Array.isArray(value);
+function parseCmsSourceQueryConfig(value) {
+  if (!isPlainObject3(value)) return void 0;
+  const collectionId = value.collectionId;
+  if (typeof collectionId !== "string" || collectionId.length === 0) return void 0;
+  const config = { collectionId };
+  if (typeof value.documentId === "string") config.documentId = value.documentId;
+  if (isPlainObject3(value.filter)) config.filter = value.filter;
+  if (typeof value.limit === "number") config.limit = value.limit;
+  const sort = value.sort;
+  if (isPlainObject3(sort) && typeof sort.field === "string") {
+    const direction = sort.direction;
+    config.sort = {
+      field: sort.field,
+      ...direction === "asc" || direction === "desc" ? { direction } : {}
+    };
+  }
+  return config;
+}
+function listQueryOfCmsConfig(config) {
+  return {
+    ...config.filter !== void 0 && Object.keys(config.filter).length > 0 ? { where: config.filter } : {},
+    ...config.sort !== void 0 ? { sort: config.sort } : {},
+    ...config.limit !== void 0 ? { limit: config.limit } : {}
+  };
+}
+
+// src/source.ts
+function mergeCacheTags(first, ...rest) {
+  const all = [first, ...rest];
+  return cacheTags({
+    docs: all.flatMap((t) => t.docs),
+    collections: all.flatMap((t) => t.collections),
+    routes: all.flatMap((t) => t.routes),
+    assets: all.flatMap((t) => t.assets),
+    locale: first.locale
+  });
+}
+
+// src/source-payloads.ts
+function collectBindingSourceIds(node, into = /* @__PURE__ */ new Set()) {
+  for (const value of Object.values(node.props ?? {})) {
+    if (value.kind === "binding") into.add(value.binding.sourceId);
+  }
+  if (node.condition) into.add(node.condition.source.sourceId);
+  for (const children of Object.values(node.slots ?? {})) {
+    for (const child of children) collectBindingSourceIds(child, into);
+  }
+  return into;
+}
+function materializeSourcePayloads(input) {
+  const { client, result, graph, sources } = input;
+  const payloads = {};
+  const tags = [];
+  if (result.status !== "ok") return { payloads, tags };
+  const referenced = /* @__PURE__ */ new Set();
+  const layoutId = result.document?.["layoutId"];
+  if (graph && typeof layoutId === "string") {
+    const layout = graph.layouts.find((candidate) => candidate.id === layoutId);
+    if (layout) collectBindingSourceIds(layout.root, referenced);
+  }
+  const byId = new Map(sources.map((source) => [source.id, source]));
+  for (const sourceId of [...referenced].sort()) {
+    if (!isSectionSourceId(sourceId)) continue;
+    const definition = byId.get(sourceId);
+    if (!definition || definition.kind !== "cms") continue;
+    const config = parseCmsSourceQueryConfig(definition.config);
+    if (!config || config.documentId !== void 0) continue;
+    const list = client.listDocuments(config.collectionId, listQueryOfCmsConfig(config));
+    tags.push(list.tags);
+    if (list.ok) {
+      payloads[sourceId] = list.documents;
+    } else {
+      payloads[sourceId] = sourcePayloadError(
+        sourceId,
+        list.errors.map((error) => error.message)
+      );
+    }
+  }
+  return { payloads, tags };
+}
+
+// src/snapshot.ts
+var DEFAULT_LOCALES = { default: "en", locales: ["en"] };
+function patternKey(pattern) {
+  return "/" + splitPath(pattern).join("/");
+}
+function mergeRouteRecords(stored, fallback) {
+  const agnostic = /* @__PURE__ */ new Set();
+  const localized = /* @__PURE__ */ new Set();
+  for (const route of stored) {
+    if (route.locale === void 0) agnostic.add(patternKey(route.pattern));
+    else localized.add(`${route.locale}|${patternKey(route.pattern)}`);
+  }
+  const covered = (route) => {
+    const key = patternKey(route.pattern);
+    if (agnostic.has(key)) return true;
+    return route.locale !== void 0 && localized.has(`${route.locale}|${key}`);
+  };
+  return [...stored, ...fallback.filter((route) => !covered(route))];
+}
+function createStaticContentSource(data) {
+  const locales = data.locales ?? DEFAULT_LOCALES;
+  const routes = data.routes ?? [];
+  const redirects = data.redirects ?? [];
+  const draftGraph = data.graphs?.draft ?? null;
+  const publishedGraph = data.graphs?.published ?? null;
+  const assetUrl = data.assetUrl ?? ((asset) => `asset://unresolved/${asset.storageKey}`);
+  const collections = /* @__PURE__ */ new Map();
+  for (const collection of data.collections ?? []) collections.set(collection.id, collection);
+  const documents = /* @__PURE__ */ new Map();
+  const byCollection = /* @__PURE__ */ new Map();
+  for (const source of data.documents ?? []) {
+    const doc = isDocumentHistory(source) ? source.draft : source;
+    documents.set(documentKey(doc), source);
+    const list = byCollection.get(doc.collection) ?? [];
+    list.push(source);
+    byCollection.set(doc.collection, list);
+  }
+  const assets = /* @__PURE__ */ new Map();
+  for (const record of data.assets ?? []) assets.set(record.id, record);
+  const graphFor = (perspective) => perspective === "draft" ? draftGraph : publishedGraph;
+  const lookupFor = (_perspective) => ({
+    collection: (id) => collections.get(id),
+    document: (ref) => documents.get(documentKey(ref)),
+    documents: (collectionId) => byCollection.get(collectionId) ?? [],
+    asset: (id) => assets.get(id),
+    assetUrl: (asset) => asset.url ?? assetUrl(asset)
+  });
+  const client = (init) => createContentClient({
+    lookup: lookupFor(init.perspective),
+    context: createContentContext({
+      locale: init.locale ?? locales.default,
+      perspective: init.perspective,
+      locales
+    }),
+    routes,
+    redirects
+  });
+  return {
+    projectId: data.projectId,
+    locales,
+    client,
+    graph: graphFor,
+    routes,
+    // EC-195: the delivery-shaped assets, so the renderer can resolve an
+    // `asset`-typed Image prop (an asset id) to a usable url + intrinsic
+    // dimensions. Baked into the (serializable) render outcome by the route
+    // helper, so a cached page keeps its images during a backend outage.
+    assets: () => [...assets.values()].map((record) => resolvedAsset(record, record.url ?? assetUrl(record))),
+    ...data.sources ? { sources: data.sources } : {}
+  };
+}
+async function createContentSnapshot(adapter, projectId, options = {}) {
+  const schema = await adapter.cms.findSchema(projectId);
+  const documentRecords = await adapter.cms.listDocuments(projectId);
+  const versionRecords = await adapter.cms.listAllDocumentVersions(projectId);
+  const assetRecords = await adapter.assets.listAssets(projectId);
+  const versionsByKey = /* @__PURE__ */ new Map();
+  for (const record of versionRecords) {
+    const key = `${record.collection}:${record.docId}`;
+    let byVersion = versionsByKey.get(key);
+    if (!byVersion) {
+      byVersion = /* @__PURE__ */ new Map();
+      versionsByKey.set(key, byVersion);
+    }
+    byVersion.set(record.version, record.snapshot);
+  }
+  const documents = documentRecords.map((record) => {
+    if (record.publishedVersion === void 0) return record.document;
+    const published = versionsByKey.get(`${record.document.collection}:${record.document.id}`)?.get(record.publishedVersion);
+    return { draft: record.document, published, versions: [] };
+  });
+  const draftGraph = await adapter.graphs.hasGraph(projectId) ? (await adapter.graphs.getLatest(projectId)).graph : null;
+  const publishState = await adapter.publishing.findState(projectId);
+  const publishedGraph = publishState?.status === "published" && publishState.publishedRevision !== void 0 ? (await adapter.graphs.getRevision(projectId, publishState.publishedRevision)).graph : null;
+  return createStaticContentSource({
+    projectId,
+    ...options.locales ? { locales: options.locales } : {},
+    ...options.routes ? { routes: options.routes } : {},
+    ...options.redirects ? { redirects: options.redirects } : {},
+    ...options.sources ? { sources: options.sources } : {},
+    ...schema ? { collections: schema.collections } : {},
+    documents,
+    assets: assetRecords,
+    graphs: { draft: draftGraph, published: publishedGraph },
+    assetUrl: (asset) => adapter.blobs.url(asset.storageKey)
+  });
+}
+
+// src/route-core.ts
+function pathFromSlug(slug) {
+  return "/" + (slug ?? []).join("/");
+}
+function splitLocalePath(url, locales) {
+  const segments = splitPath(url);
+  const first = segments[0];
+  if (first !== void 0 && first !== locales.default && locales.locales.includes(first)) {
+    return { locale: first, path: "/" + segments.slice(1).join("/") };
+  }
+  return { locale: locales.default, path: "/" + segments.join("/") };
+}
+function scopeAssetsToPage(allAssets, registry, result, graph) {
+  if (allAssets.length === 0) return allAssets;
+  const ids = /* @__PURE__ */ new Set();
+  for (const node of compositionNodesOf(result.document)) {
+    collectReferencedAssetIds(node, registry, ids);
+  }
+  const layoutId = result.document?.["layoutId"];
+  if (graph && typeof layoutId === "string") {
+    const layout = graph.layouts.find((candidate) => candidate.id === layoutId);
+    if (layout) collectReferencedAssetIds(layout.root, registry, ids);
+  }
+  const ogImage = result.document?.["seoOgImage"];
+  if (typeof ogImage === "string") ids.add(ogImage);
+  return ids.size === 0 ? [] : allAssets.filter((asset) => ids.has(asset.id));
+}
+function pageCompositionNodes(result, graph) {
+  const nodes = [...compositionNodesOf(result.document)];
+  const layoutId = result.document?.["layoutId"];
+  if (graph && typeof layoutId === "string") {
+    const layout = graph.layouts.find((candidate) => candidate.id === layoutId);
+    if (layout) nodes.push(layout.root);
+  }
+  return nodes;
+}
+function populatePageRelations(result, graph, client, registry) {
+  if (!registry) return { relations: {}, docKeys: [] };
+  const refKeys = /* @__PURE__ */ new Set();
+  const relations = collectReferencedRelations(
+    pageCompositionNodes(result, graph),
+    registry,
+    (ref) => client.resolveRelation(ref),
+    {},
+    refKeys
+  );
+  return { relations, docKeys: [...refKeys] };
+}
+function populatePageListings(result, graph, client, registry) {
+  if (!registry) return { listings: {}, tags: [] };
+  const tags = [];
+  const listings = collectReferencedListings(
+    pageCompositionNodes(result, graph),
+    registry,
+    (query) => {
+      const listed = client.listDocuments(query.collection, {
+        where: query.where,
+        ...query.sort ? { sort: query.sort } : {},
+        ...query.limit !== void 0 ? { limit: query.limit } : {}
+      });
+      tags.push(listed.tags);
+      return listed.ok ? listed.documents : [];
+    },
+    // EC-255: reach listings nested inside transcluded reusable content (the same
+    // depth-1 populate the relation bake uses), so a grid inside a reusable bakes —
+    // and its membership tag is folded in — instead of rendering empty on the host.
+    (ref) => client.resolveRelation(ref)
+  );
+  return { listings, tags };
+}
+async function resolveCanvasPage(source, url, perspective, options = {}) {
+  const { locale, path } = splitLocalePath(url, source.locales);
+  const client = source.client({ perspective, locale });
+  const result = client.resolvePage(path);
+  if (result.status === "redirect" && result.redirect) {
+    return {
+      kind: "redirect",
+      target: result.redirect.target,
+      permanent: result.redirect.permanent,
+      tags: result.tags
+    };
+  }
+  if (result.status !== "ok") {
+    return { kind: "not-found", tags: result.tags };
+  }
+  const graph = source.graph(perspective);
+  const extraTags = [];
+  let payloads = defaultBindingPayloads(result);
+  const materialized = materializeSourcePayloads({
+    client,
+    result,
+    graph,
+    sources: source.sources ?? []
+  });
+  payloads = { ...payloads, ...materialized.payloads };
+  extraTags.push(...materialized.tags);
+  if (options.payloads) {
+    const custom = await options.payloads({
+      client,
+      result,
+      perspective,
+      path,
+      params: result.dynamicParams,
+      addTags: (tags) => extraTags.push(tags)
+    });
+    payloads = { ...payloads, ...custom };
+  }
+  const allAssets = source.assets?.() ?? [];
+  const bakedAssets = options.registry ? scopeAssetsToPage(allAssets, options.registry, result, graph) : allAssets;
+  const assetTags = cacheTags({
+    assets: bakedAssets.map((asset) => asset.id),
+    locale: result.tags.locale
+  });
+  const { relations, docKeys: relationDocKeys } = populatePageRelations(
+    result,
+    graph,
+    client,
+    options.registry
+  );
+  const relationTags = cacheTags({ docs: relationDocKeys, locale: result.tags.locale });
+  const { listings, tags: listingTags } = populatePageListings(
+    result,
+    graph,
+    client,
+    options.registry
+  );
+  return {
+    kind: "render",
+    result,
+    graph,
+    payloads,
+    assets: bakedAssets,
+    relations,
+    listings,
+    tags: mergeCacheTags(result.tags, ...extraTags, ...listingTags, assetTags, relationTags)
+  };
+}
+
+// src/cache.ts
+function scopeCacheTag(tag, scope) {
+  return scope === void 0 || scope.length === 0 ? tag : `p:${scope}:${tag}`;
+}
+function docCacheTag(docKey, scope) {
+  return scopeCacheTag(`doc:${docKey}`, scope);
+}
+function collectionCacheTag(collection, locale, scope) {
+  return scopeCacheTag(`collection:${collection}:${locale}`, scope);
+}
+function routeCacheTag(pattern, locale, scope) {
+  return scopeCacheTag(`route:${pattern}:${locale}`, scope);
+}
+function assetCacheTag(assetId, scope) {
+  return scopeCacheTag(`asset:${assetId}`, scope);
+}
+function projectSweepTag(scope) {
+  return scopeCacheTag("project", scope);
+}
+function nextCacheTags(tags, scope) {
+  const all = /* @__PURE__ */ new Set();
+  all.add(projectSweepTag(scope));
+  for (const docKey of tags.docs) all.add(docCacheTag(docKey, scope));
+  for (const collection of tags.collections) {
+    all.add(collectionCacheTag(collection, tags.locale, scope));
+  }
+  for (const route of tags.routes) all.add(routeCacheTag(route, tags.locale, scope));
+  for (const assetId of tags.assets) all.add(assetCacheTag(assetId, scope));
+  return [...all].sort();
+}
+var CacheDiscoveryBail = class extends Error {
+  constructor() {
+    super("elytra cache discovery bail (never user-visible)");
+    this.name = "CacheDiscoveryBail";
+  }
+};
+function passthrough(impl) {
+  return async () => impl();
+}
+async function loadCachedEntry(cache, keyParts, baselineTags, load) {
+  let fresh;
+  const probe = cache(
+    passthrough(async () => {
+      fresh = await load();
+      throw new CacheDiscoveryBail();
+    }),
+    keyParts,
+    { tags: [...baselineTags], revalidate: false }
+  );
+  try {
+    return await probe();
+  } catch (error) {
+    if (!(error instanceof CacheDiscoveryBail)) throw error;
+  }
+  const entry = fresh;
+  const write = cache(
+    passthrough(async () => entry),
+    keyParts,
+    { tags: entry.tags, revalidate: false }
+  );
+  return write();
+}
+
+// src/metadata.ts
+function str2(value) {
+  return typeof value === "string" && value.length > 0 ? value : null;
+}
+function looksLikeUrl(value) {
+  return /^(https?:)?\/\//.test(value) || value.startsWith("/");
+}
+function resolveOgImage(value, assets) {
+  if (value === null) return null;
+  if (looksLikeUrl(value)) return value;
+  return assets.find((asset) => asset.id === value)?.url ?? null;
+}
+function canvasPageMetadata(result, assets = []) {
+  const doc = result.document;
+  const seoTitle = str2(doc?.["seoTitle"]);
+  const seoDescription = str2(doc?.["seoDescription"]);
+  const seoOgTitle = str2(doc?.["seoOgTitle"]);
+  const seoOgImage = resolveOgImage(str2(doc?.["seoOgImage"]), assets);
+  const seoNoindex = doc?.["seoNoindex"] === true;
+  const seoCanonical = str2(doc?.["seoCanonical"]);
+  const docTitle = str2(doc?.["name"]) ?? str2(doc?.["title"]);
+  const title = seoTitle ?? docTitle;
+  const metadata = {};
+  if (title !== null) metadata.title = title;
+  if (seoDescription) metadata.description = seoDescription;
+  const ogTitle = seoOgTitle ?? title;
+  if (ogTitle !== null || seoDescription || seoOgImage) {
+    metadata.openGraph = {
+      ...ogTitle !== null ? { title: ogTitle } : {},
+      ...seoDescription ? { description: seoDescription } : {},
+      ...seoOgImage ? { images: [{ url: seoOgImage }] } : {}
+    };
+  }
+  if (seoNoindex) metadata.robots = { index: false };
+  if (seoCanonical) metadata.alternates = { canonical: seoCanonical };
+  return metadata;
+}
+function defaultMetadata(result, assets) {
+  return canvasPageMetadata(result, assets);
+}
+async function requestPerspective() {
+  const { isEnabled } = await draftMode();
+  return isEnabled ? "draft" : "published";
+}
+var nextCacheWrapper = (cb, keyParts, options) => unstable_cache(cb, keyParts, { tags: options.tags, revalidate: options.revalidate });
+function createCanvasRoute(options) {
+  const loadOutcome = async (url, perspective) => {
+    const resolveFresh = async () => {
+      const source = await options.loadContent({ perspective });
+      return resolveCanvasPage(source, url, perspective, {
+        ...options.payloads ? { payloads: options.payloads } : {},
+        // EC-205: page-scope the baked assets to what the page actually uses.
+        registry: options.components.registry
+      });
+    };
+    const devBypass = process.env.NODE_ENV === "development";
+    if (!options.cache || perspective !== "published" || devBypass) return resolveFresh();
+    const scope = options.cache.scope;
+    const entry = await loadCachedEntry(
+      nextCacheWrapper,
+      ["elytra-route", scope ?? "", url],
+      [projectSweepTag(scope)],
+      async () => {
+        const outcome = await resolveFresh();
+        return { value: outcome, tags: nextCacheTags(outcome.tags, scope) };
+      }
+    );
+    return entry.value;
+  };
+  const Page = async (props) => {
+    const { slug } = await props.params;
+    const url = pathFromSlug(slug);
+    const perspective = await requestPerspective();
+    const outcome = await loadOutcome(url, perspective);
+    options.onTags?.(outcome.tags, { url, perspective });
+    switch (outcome.kind) {
+      case "redirect":
+        return outcome.permanent ? permanentRedirect(outcome.target) : redirect(outcome.target);
+      case "not-found":
+        return notFound();
+      case "render":
+        return /* @__PURE__ */ jsx(
+          CanvasRenderer,
+          {
+            result: outcome.result,
+            graph: outcome.graph,
+            components: options.components,
+            payloads: outcome.payloads,
+            assets: outcome.assets,
+            relations: outcome.relations,
+            listings: outcome.listings
+          }
+        );
+    }
+  };
+  const generateMetadata = async (props) => {
+    const { slug } = await props.params;
+    const url = pathFromSlug(slug);
+    const perspective = await requestPerspective();
+    if (options.cache && perspective === "published") {
+      const outcome2 = await loadOutcome(url, perspective);
+      if (outcome2.kind !== "render") return {};
+      return options.metadata ? options.metadata(outcome2.result, { url, perspective }) : defaultMetadata(outcome2.result, outcome2.assets);
+    }
+    const source = await options.loadContent({ perspective });
+    const outcome = await resolveCanvasPage(source, url, perspective);
+    if (outcome.kind !== "render") return {};
+    return options.metadata ? options.metadata(outcome.result, { url, perspective }) : defaultMetadata(outcome.result, outcome.assets);
+  };
+  return { Page, generateMetadata };
+}
+
+// src/sitemap.ts
+function paramNamesOf(pattern) {
+  return splitPath(pattern).filter((segment) => segment.startsWith(":")).map((segment) => segment.slice(1));
+}
+function fillPattern(pattern, params) {
+  const segments = [];
+  for (const segment of splitPath(pattern)) {
+    if (!segment.startsWith(":")) {
+      segments.push(segment);
+      continue;
+    }
+    const value = params[segment.slice(1)];
+    if (value === void 0 || value.length === 0) return null;
+    segments.push(encodeURIComponent(value));
+  }
+  return "/" + segments.join("/");
+}
+function absoluteUrl(baseUrl, locale, defaultLocale, path) {
+  const origin = baseUrl.replace(/\/+$/, "");
+  if (locale === defaultLocale) return origin + path;
+  return origin + (path === "/" ? `/${locale}` : `/${locale}${path}`);
+}
+function canvasSitemapEntries(source, options) {
+  const routes = options.routes ?? source.routes ?? [];
+  const locales = source.locales;
+  const skipped = [];
+  const skip = (route, reason) => {
+    if (!skipped.some((s) => s.routeId === route.id && s.reason === reason)) {
+      skipped.push({ routeId: route.id, pattern: route.pattern, reason });
+    }
+  };
+  const clients = /* @__PURE__ */ new Map();
+  const clientFor = (locale) => {
+    let client = clients.get(locale);
+    if (!client) {
+      client = source.client({ perspective: "published", locale });
+      clients.set(locale, client);
+    }
+    return client;
+  };
+  const byPath = /* @__PURE__ */ new Map();
+  for (const route of routes) {
+    const paramNames = paramNamesOf(route.pattern);
+    const mount = hierarchyMount(route);
+    const routeLocales = route.locale ? [route.locale] : locales.locales;
+    for (const locale of routeLocales) {
+      const client = clientFor(locale);
+      let paths;
+      if (mount) {
+        const listed = client.listDocuments(mount.collection);
+        if (!listed.ok) {
+          skip(route, `hierarchy collection "${mount.collection}" could not be listed`);
+          continue;
+        }
+        const rows = listed.documents.map((doc) => ({
+          collection: mount.collection,
+          id: doc.id,
+          values: { slug: doc["slug"], parent: doc["parent"] }
+        }));
+        const byId = new Map(rows.map((row) => [row.id, row]));
+        paths = [];
+        for (const row of rows) {
+          if (typeof row.values["slug"] !== "string" || row.values["slug"] === "") continue;
+          const composed = composePath(row, (id) => byId.get(id));
+          if (!composed.ok) continue;
+          paths.push("/" + [...mount.prefix, ...composed.segments].join("/"));
+        }
+      } else if (paramNames.length === 0) {
+        paths = [route.pattern];
+      } else {
+        const paramSets = options.params?.({ route, locale, client });
+        if (paramSets == null) {
+          skip(route, "dynamic route not enumerated (no params provider entry)");
+          continue;
+        }
+        paths = [];
+        for (const paramSet of paramSets) {
+          const path = fillPattern(route.pattern, paramSet);
+          if (path === null) {
+            skip(route, `params entry missing one of :${paramNames.join(", :")}`);
+            continue;
+          }
+          paths.push(path);
+        }
+      }
+      for (const path of paths) {
+        const result = client.resolvePage(path, locale);
+        if (result.status !== "ok") continue;
+        if (result.document?.["seoNoindex"] === true) continue;
+        const perLocale = byPath.get(path) ?? /* @__PURE__ */ new Map();
+        perLocale.set(locale, absoluteUrl(options.baseUrl, locale, locales.default, path));
+        byPath.set(path, perLocale);
+      }
+    }
+  }
+  const entries = [];
+  for (const perLocale of byPath.values()) {
+    const languages = Object.fromEntries(perLocale);
+    for (const url of perLocale.values()) {
+      entries.push({
+        url,
+        ...perLocale.size > 1 ? { alternates: { languages } } : {}
+      });
+    }
+  }
+  entries.sort((a, b) => a.url < b.url ? -1 : a.url > b.url ? 1 : 0);
+  return { entries, skipped };
+}
+function createCanvasSitemap(options) {
+  return async () => {
+    const source = await options.loadContent({ perspective: "published" });
+    return canvasSitemapEntries(source, options).entries;
+  };
+}
+var REVALIDATE_SIGNATURE_HEADER = "x-elytra-signature";
+var revalidatePayloadSchema = z.object({
+  projectId: z.string().min(1),
+  /** The operation that fired, e.g. `documents.setState`, `publishing.publish`. */
+  event: z.string().min(1),
+  /** Fully-formatted Next tag strings (already scoped) — revalidated verbatim. */
+  tags: z.array(z.string().min(1)),
+  /** ISO timestamp of emission. Informational in v1 (no replay window). */
+  timestamp: z.string().min(1)
+});
+function signRevalidateBody(rawBody, secret) {
+  return `sha256=${createHmac("sha256", secret).update(rawBody, "utf8").digest("hex")}`;
+}
+var SIGNATURE_PREFIX = "sha256=";
+var HEX_PATTERN = /^[0-9a-f]+$/;
+function evaluateRevalidateRequest(rawBody, signature, secret) {
+  if (secret === void 0 || secret.length === 0) {
+    return { ok: false, status: 401, message: "Revalidation webhook is not configured." };
+  }
+  if (signature === null || signature === void 0 || !signature.startsWith(SIGNATURE_PREFIX)) {
+    return { ok: false, status: 401, message: "Missing or malformed webhook signature." };
+  }
+  const providedHex = signature.slice(SIGNATURE_PREFIX.length).toLowerCase();
+  const expectedHex = createHmac("sha256", secret).update(rawBody, "utf8").digest("hex");
+  if (providedHex.length !== expectedHex.length || !HEX_PATTERN.test(providedHex) || !timingSafeEqual(Buffer.from(providedHex, "hex"), Buffer.from(expectedHex, "hex"))) {
+    return { ok: false, status: 401, message: "Invalid webhook signature." };
+  }
+  let parsed;
+  try {
+    parsed = JSON.parse(rawBody);
+  } catch {
+    return { ok: false, status: 400, message: "Webhook body is not valid JSON." };
+  }
+  const payload = revalidatePayloadSchema.safeParse(parsed);
+  if (!payload.success) {
+    return { ok: false, status: 400, message: "Webhook payload has an invalid shape." };
+  }
+  return { ok: true, payload: payload.data };
+}
+function corsHeaders(allowOrigin) {
+  if (allowOrigin === void 0 || allowOrigin.length === 0) return {};
+  return {
+    "access-control-allow-origin": allowOrigin,
+    "access-control-allow-methods": "POST, OPTIONS",
+    "access-control-allow-headers": `content-type, ${REVALIDATE_SIGNATURE_HEADER}`
+  };
+}
+function createRevalidateRoute(options) {
+  const cors = corsHeaders(options.allowOrigin);
+  return {
+    async POST(request) {
+      const rawBody = await request.text();
+      const signature = request.headers.get(REVALIDATE_SIGNATURE_HEADER);
+      const evaluation = evaluateRevalidateRequest(rawBody, signature, options.secret);
+      if (!evaluation.ok) {
+        return Response.json(
+          { error: evaluation.message },
+          { status: evaluation.status, headers: cors }
+        );
+      }
+      for (const tag of evaluation.payload.tags) revalidateTag(tag, "max");
+      return Response.json({ revalidated: evaluation.payload.tags }, { headers: cors });
+    },
+    async OPTIONS() {
+      return new Response(null, { status: 204, headers: cors });
+    }
+  };
+}
+function ElytraImage(props) {
+  const { asset, sizes, priority, quality, className, loader } = props;
+  if (!asset || asset.url.length === 0) return null;
+  const alt = asset.alt ?? "";
+  const objectPosition = asset.focalPoint ? `${asset.focalPoint.x * 100}% ${asset.focalPoint.y * 100}%` : void 0;
+  if (asset.width === null || asset.height === null) {
+    return /* @__PURE__ */ jsx(
+      "img",
+      {
+        "data-ec-image": "fallback",
+        src: asset.url,
+        alt,
+        className,
+        ...objectPosition ? { style: { objectPosition } } : {}
+      }
+    );
+  }
+  return /* @__PURE__ */ jsx(
+    NextImage,
+    {
+      "data-ec-image": "next",
+      src: asset.url,
+      alt,
+      width: asset.width,
+      height: asset.height,
+      ...sizes !== void 0 ? { sizes } : {},
+      ...priority !== void 0 ? { priority } : {},
+      ...quality !== void 0 ? { quality } : {},
+      ...className !== void 0 ? { className } : {},
+      ...loader !== void 0 ? { loader } : {},
+      ...objectPosition ? { style: { objectPosition } } : {}
+    }
+  );
+}
+function createAssetImageLoader(options = {}) {
+  const widthParam = options.widthParam ?? "w";
+  const qualityParam = options.qualityParam ?? "q";
+  const defaultQuality = options.defaultQuality ?? 75;
+  return ({ src, width, quality }) => {
+    const separator = src.includes("?") ? "&" : "?";
+    return `${src}${separator}${widthParam}=${width}&${qualityParam}=${quality ?? defaultQuality}`;
+  };
+}
+function NextImagePrimitive(props) {
+  const { url, width, height, alt, focalPoint } = normalizeImageSource(props);
+  if (url.length === 0) return null;
+  return /* @__PURE__ */ jsx(
+    ElytraImage,
+    {
+      asset: { url, width: width ?? null, height: height ?? null, alt, focalPoint },
+      ...props.priority === true ? { priority: true } : {}
+    }
+  );
+}
+function nextImagePrimitive() {
+  return {
+    manifest: ImageManifest,
+    implementation: NextImagePrimitive
+  };
+}
+
+// src/preview-core.ts
+function safeRedirectTarget(value, fallback = "/") {
+  if (value === null || value === void 0 || value === "") return fallback;
+  if (!value.startsWith("/") || value.startsWith("//")) return null;
+  return value;
+}
+function evaluatePreviewRequest(requestUrl, expectedToken) {
+  if (expectedToken === void 0 || expectedToken.length === 0) {
+    return { ok: false, status: 401, message: "Draft preview is not configured." };
+  }
+  let url;
+  try {
+    url = typeof requestUrl === "string" ? new URL(requestUrl, "http://localhost") : requestUrl;
+  } catch {
+    return { ok: false, status: 400, message: "Malformed preview request URL." };
+  }
+  const token = url.searchParams.get("token");
+  if (token !== expectedToken) {
+    return { ok: false, status: 401, message: "Invalid preview token." };
+  }
+  const redirectTo = safeRedirectTarget(url.searchParams.get("redirect"));
+  if (redirectTo === null) {
+    return { ok: false, status: 400, message: "Preview redirect target must be a same-site path." };
+  }
+  return { ok: true, redirectTo };
+}
+function createPreviewRoute(options) {
+  return {
+    async GET(request) {
+      const evaluation = evaluatePreviewRequest(request.url, options.token);
+      if (!evaluation.ok) {
+        return new Response(evaluation.message, { status: evaluation.status });
+      }
+      const draft = await draftMode();
+      draft.enable();
+      redirect(evaluation.redirectTo);
+    }
+  };
+}
+function createPreviewDisableRoute() {
+  return {
+    async GET(request) {
+      const draft = await draftMode();
+      draft.disable();
+      let target = "/";
+      try {
+        target = safeRedirectTarget(new URL(request.url).searchParams.get("redirect"));
+      } catch {
+        target = "/";
+      }
+      redirect(target ?? "/");
+    }
+  };
+}
+var PACKAGE = "@elytracms/next";
+
+export { CanvasRenderer, ElytraImage, PACKAGE, PROJECT_GRAPH_SCHEMA_VERSION, REVALIDATE_SIGNATURE_HEADER, canvasPageMetadata, canvasSitemapEntries, collectBindingSourceIds, collectionCacheTag, createAssetImageLoader, createBindingResolver, createCanvasRoute, createCanvasSitemap, createContentSnapshot, createPreviewDisableRoute, createPreviewRoute, createRevalidateRoute, createStaticContentSource, defaultBindingPayloads, defineComponent, defineHostComponents, docCacheTag, documentSchema, evaluatePreviewRequest, evaluateRevalidateRequest, isSourcePayloadError, loadCachedEntry, localeConfigSchema, materializeSourcePayloads, mergeCacheTags, mergeRouteRecords, nextCacheTags, nextImagePrimitive, parseProjectGraph, pathFromSlug, projectSweepTag, redirectRecordSchema, resolveCanvasPage, resolvePayloadToken, revalidatePayloadSchema, routeCacheTag, routeRecordSchema, safeRedirectTarget, scopeCacheTag, signRevalidateBody, sourcePayloadError, splitLocalePath };
+//# sourceMappingURL=index.js.map
+//# sourceMappingURL=index.js.map