@elytracms/next 0.0.1 → 0.0.2

package/dist/index.js

@@ -1,2573 +1,19 @@
-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
-  };
-}
+import { ComponentRegistry } from '@elytracms/component-registry';
+export { defineComponent } from '@elytracms/component-registry';
+import { basePrimitives, getImplementation, renderCompositionInLayout, renderComposition, ImageManifest, serializeListingQuery, RenderErrorBoundary, collectReferencedAssetIds, collectReferencedRelations, collectReferencedListings, normalizeImageSource } from '@elytracms/runtime-renderer';
+import { isValidElement } from 'react';
+import { jsx, Fragment } from 'react/jsx-runtime';
+import { cacheTags, isSectionSourceId, parseCmsSourceQueryConfig, listQueryOfCmsConfig, isDocumentHistory, resolvedAsset, createContentClient, createContentContext } from '@elytracms/content';
+import { documentKey, splitPath, hierarchyMount, composePath } from '@elytracms/cms-core';
+export { documentSchema, localeConfigSchema, redirectRecordSchema, routeRecordSchema } from '@elytracms/cms-core';
+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 { z } from 'zod';
+export { z } from 'zod';
+import NextImage from 'next/image';
+export { PROJECT_GRAPH_SCHEMA_VERSION, parseProjectGraph } from '@elytracms/project-graph';
 
 // src/components.ts
 function defineHostComponents(components = [], options = {}) {
@@ -2601,7 +47,7 @@ function pathFromToken(token) {
   if (!token.startsWith("/")) return void 0;
   return token.slice(1).split("/").map(unescapeRefToken);
 }
-var isPlainObject2 = (value) => typeof value === "object" && value !== null && !Array.isArray(value);
+var isPlainObject = (value) => typeof value === "object" && value !== null && !Array.isArray(value);
 function resolvePayloadToken(payload, token) {
   const path = pathFromToken(token);
   if (path === void 0) return void 0;
@@ -2614,7 +60,7 @@ function resolvePayloadToken(payload, token) {
       current = current[index];
       continue;
     }
-    if (isPlainObject2(current)) {
+    if (isPlainObject(current)) {
       if (!Object.prototype.hasOwnProperty.call(current, segment)) return void 0;
       current = current[segment];
       continue;
@@ -2715,996 +161,6 @@ function compositionNodesOf(document) {
 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({
@@ -3715,8 +171,6 @@ function mergeCacheTags(first, ...rest) {
     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);
@@ -3758,8 +212,6 @@ function materializeSourcePayloads(input) {
   }
   return { payloads, tags };
 }
-
-// src/snapshot.ts
 var DEFAULT_LOCALES = { default: "en", locales: ["en"] };
 function patternKey(pattern) {
   return "/" + splitPath(pattern).join("/");
@@ -3866,8 +318,6 @@ async function createContentSnapshot(adapter, projectId, options = {}) {
     assetUrl: (asset) => adapter.blobs.url(asset.storageKey)
   });
 }
-
-// src/route-core.ts
 function pathFromSlug(slug) {
   return "/" + (slug ?? []).join("/");
 }
@@ -4069,7 +519,7 @@ async function loadCachedEntry(cache, keyParts, baselineTags, load) {
 }
 
 // src/metadata.ts
-function str2(value) {
+function str(value) {
   return typeof value === "string" && value.length > 0 ? value : null;
 }
 function looksLikeUrl(value) {
@@ -4082,13 +532,13 @@ function resolveOgImage(value, assets) {
 }
 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 seoTitle = str(doc?.["seoTitle"]);
+  const seoDescription = str(doc?.["seoDescription"]);
+  const seoOgTitle = str(doc?.["seoOgTitle"]);
+  const seoOgImage = resolveOgImage(str(doc?.["seoOgImage"]), assets);
   const seoNoindex = doc?.["seoNoindex"] === true;
-  const seoCanonical = str2(doc?.["seoCanonical"]);
-  const docTitle = str2(doc?.["name"]) ?? str2(doc?.["title"]);
+  const seoCanonical = str(doc?.["seoCanonical"]);
+  const docTitle = str(doc?.["name"]) ?? str(doc?.["title"]);
   const title = seoTitle ?? docTitle;
   const metadata = {};
   if (title !== null) metadata.title = title;
@@ -4179,8 +629,6 @@ function createCanvasRoute(options) {
   };
   return { Page, generateMetadata };
 }
-
-// src/sitemap.ts
 function paramNamesOf(pattern) {
   return splitPath(pattern).filter((segment) => segment.startsWith(":")).map((segment) => segment.slice(1));
 }
@@ -4479,6 +927,6 @@ function createPreviewDisableRoute() {
 }
 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 };
+export { CanvasRenderer, ElytraImage, PACKAGE, REVALIDATE_SIGNATURE_HEADER, canvasPageMetadata, canvasSitemapEntries, collectBindingSourceIds, collectionCacheTag, createAssetImageLoader, createBindingResolver, createCanvasRoute, createCanvasSitemap, createContentSnapshot, createPreviewDisableRoute, createPreviewRoute, createRevalidateRoute, createStaticContentSource, defaultBindingPayloads, defineHostComponents, docCacheTag, evaluatePreviewRequest, evaluateRevalidateRequest, isSourcePayloadError, loadCachedEntry, materializeSourcePayloads, mergeCacheTags, mergeRouteRecords, nextCacheTags, nextImagePrimitive, pathFromSlug, projectSweepTag, resolveCanvasPage, resolvePayloadToken, revalidatePayloadSchema, routeCacheTag, safeRedirectTarget, scopeCacheTag, signRevalidateBody, sourcePayloadError, splitLocalePath };
 //# sourceMappingURL=index.js.map
 //# sourceMappingURL=index.js.map