@elytracms/next 0.0.1 → 0.0.2

package/dist/index.d.ts

@@ -1,677 +1,21 @@
 import { ComponentType, ReactNode } from 'react';
+import { ComponentRegistry, ComponentIssue, ComponentManifest } from '@elytracms/component-registry';
+export { ComponentManifest, PropField, SlotSpec, defineComponent } from '@elytracms/component-registry';
+import { ComponentImplementations, ResolveBinding, RelationTarget } from '@elytracms/runtime-renderer';
+export { ComponentImplementations, RenderAsset } from '@elytracms/runtime-renderer';
+import { ResolvePageResult, ResolvedAsset, Perspective, ContentClient, CacheTags, ContentDocumentSource } from '@elytracms/content';
+export { Perspective } from '@elytracms/content';
+import { ProjectGraph, ComponentNode } from '@elytracms/project-graph';
+export { ComponentNode, PROJECT_GRAPH_SCHEMA_VERSION, ProjectGraph, parseProjectGraph } from '@elytracms/project-graph';
+import { LocaleConfig, Locale, RouteRecord, RedirectRecord, CollectionDef } from '@elytracms/cms-core';
+export { CmsDocument, CollectionDef, FieldDef, Locale, LocaleConfig, RedirectRecord, RouteRecord, documentSchema, localeConfigSchema, redirectRecordSchema, routeRecordSchema } from '@elytracms/cms-core';
+import { AssetRecord, PersistenceAdapter } from '@elytracms/persistence';
+export { AssetRecord } from '@elytracms/persistence';
+import { Metadata, MetadataRoute } from 'next';
 import { z } from 'zod';
 export { z } from 'zod';
-import { Metadata, MetadataRoute } from 'next';
 import { ImageLoader } from 'next/image';
 
-/**
- * A structured CMS validation issue. Same conventions as
- * `@elytracms/project-graph`'s `ValidationIssue`: a path locating the offending
- * data, optional document/collection identity, and free-form metadata.
- */
-declare const cmsValidationIssueSchema: z.ZodObject<{
-    code: z.ZodEnum<{
-        "duplicate-collection": "duplicate-collection";
-        "duplicate-field": "duplicate-field";
-        "unknown-collection": "unknown-collection";
-        "invalid-collection-config": "invalid-collection-config";
-        "invalid-field-config": "invalid-field-config";
-        "missing-required-field": "missing-required-field";
-        "invalid-field-value": "invalid-field-value";
-        "unknown-relation-target": "unknown-relation-target";
-        "unpublished-relation-target": "unpublished-relation-target";
-        "cardinality-violation": "cardinality-violation";
-        "unknown-asset": "unknown-asset";
-        "duplicate-document": "duplicate-document";
-        "unknown-locale": "unknown-locale";
-        "missing-localized-value": "missing-localized-value";
-        "route-conflict": "route-conflict";
-        "redirect-loop": "redirect-loop";
-        "unknown-route-target": "unknown-route-target";
-        "hierarchy-cycle": "hierarchy-cycle";
-        "unknown-version": "unknown-version";
-    }>;
-    severity: z.ZodEnum<{
-        error: "error";
-        warning: "warning";
-    }>;
-    message: z.ZodString;
-    path: z.ZodArray<z.ZodUnion<readonly [z.ZodString, z.ZodNumber]>>;
-    collectionId: z.ZodOptional<z.ZodString>;
-    documentId: z.ZodOptional<z.ZodString>;
-    meta: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
-}, z.core.$strip>;
-type CmsValidationIssue = z.infer<typeof cmsValidationIssueSchema>;
-type CmsPath = ReadonlyArray<string | number>;
-
-/** How many related documents a relation field points at. */
-declare const cardinalitySchema: z.ZodEnum<{
-    one: "one";
-    many: "many";
-}>;
-type Cardinality = z.infer<typeof cardinalitySchema>;
-/** A single allowed option for a `select` field. */
-declare const selectOptionSchema: z.ZodObject<{
-    value: z.ZodString;
-    label: z.ZodOptional<z.ZodString>;
-}, z.core.$strip>;
-type SelectOption = z.infer<typeof selectOptionSchema>;
-/** A schema of just the shared base attributes — the source for {@link BaseFieldDef}. */
-declare const baseFieldObjectSchema: z.ZodObject<{
-    name: z.ZodString;
-    localized: z.ZodOptional<z.ZodBoolean>;
-    filterable: z.ZodOptional<z.ZodBoolean>;
-    context: z.ZodOptional<z.ZodEnum<{
-        document: "document";
-        prop: "prop";
-        both: "both";
-    }>>;
-    default: z.ZodOptional<z.ZodUnknown>;
-    form: z.ZodOptional<z.ZodObject<{
-        label: z.ZodOptional<z.ZodString>;
-        description: z.ZodOptional<z.ZodString>;
-        placeholder: z.ZodOptional<z.ZodString>;
-        group: z.ZodOptional<z.ZodString>;
-        tab: z.ZodOptional<z.ZodString>;
-        order: z.ZodOptional<z.ZodNumber>;
-        readOnly: z.ZodOptional<z.ZodBoolean>;
-        hidden: z.ZodOptional<z.ZodBoolean>;
-        control: z.ZodOptional<z.ZodEnum<{
-            input: "input";
-            textarea: "textarea";
-            color: "color";
-            json: "json";
-        }>>;
-        inlineEditable: z.ZodOptional<z.ZodBoolean>;
-    }, z.core.$strip>>;
-    validation: z.ZodOptional<z.ZodObject<{
-        required: z.ZodOptional<z.ZodBoolean>;
-        min: z.ZodOptional<z.ZodNumber>;
-        max: z.ZodOptional<z.ZodNumber>;
-        pattern: z.ZodOptional<z.ZodString>;
-        unique: z.ZodOptional<z.ZodBoolean>;
-    }, z.core.$strip>>;
-}, z.core.$strip>;
-/** Attributes every field-def carries, derived from {@link baseFieldShape}. */
-type BaseFieldDef = z.infer<typeof baseFieldObjectSchema>;
-/**
- * A field definition (the shape {@link fieldDefSchema} parses to). Written
- * explicitly rather than via `z.infer` because the `object` variant is recursive
- * — its `fields` reference `FieldDef` itself — and TypeScript cannot infer a
- * self-referential `z.infer`. The schema below is annotated with this type and the
- * two are kept in lock-step (`object-field.test.ts` round-trips against drift).
- *
- * A discriminated union on `type` so relation/asset/select/object carry exactly
- * the extra config they need and nothing more.
- */
-type FieldDef = (BaseFieldDef & {
-    type: 'text';
-}) | (BaseFieldDef & {
-    type: 'number';
-}) | (BaseFieldDef & {
-    type: 'boolean';
-}) | (BaseFieldDef & {
-    type: 'date';
-}) | (BaseFieldDef & {
-    type: 'select';
-    options: SelectOption[];
-    multiple?: boolean;
-}) | (BaseFieldDef & {
-    type: 'richText';
-    allow?: string[];
-}) | (BaseFieldDef & {
-    type: 'relation';
-    target: string;
-    cardinality: Cardinality;
-    populate?: boolean;
-    strict?: boolean;
-}) | (BaseFieldDef & {
-    type: 'asset';
-    cardinality: Cardinality;
-    accept?: string[];
-}) | (BaseFieldDef & {
-    type: 'blocks';
-    allow?: string[];
-    cardinality: Cardinality;
-}) | (BaseFieldDef & {
-    type: 'object';
-    fields: FieldDef[];
-    cardinality: Cardinality;
-});
-
-/**
- * A collection definition: an id, a kind, an ordered list of fields, and
- * optional form metadata. The field whose value identifies a document for
- * routing/display defaults to `title` when present (see `titleFieldOf`).
- */
-declare const collectionDefSchema: z.ZodObject<{
-    id: z.ZodString;
-    kind: z.ZodDefault<z.ZodEnum<{
-        asset: "asset";
-        document: "document";
-    }>>;
-    fields: z.ZodDefault<z.ZodArray<z.ZodType<FieldDef, unknown, z.core.$ZodTypeInternals<FieldDef, unknown>>>>;
-    form: z.ZodOptional<z.ZodObject<{
-        label: z.ZodOptional<z.ZodString>;
-        labelSingular: z.ZodOptional<z.ZodString>;
-        description: z.ZodOptional<z.ZodString>;
-        groups: z.ZodOptional<z.ZodArray<z.ZodString>>;
-        tabs: z.ZodOptional<z.ZodArray<z.ZodString>>;
-    }, z.core.$strip>>;
-    localized: z.ZodOptional<z.ZodBoolean>;
-    titleField: z.ZodOptional<z.ZodString>;
-    singleton: z.ZodOptional<z.ZodBoolean>;
-}, z.core.$strip>;
-type CollectionDef = z.infer<typeof collectionDefSchema>;
-
-/**
- * A locale code (BCP-47-ish, e.g. `en`, `en-US`, `de`). Kept as a plain
- * non-empty string so unusual locales still parse; validity against a project's
- * declared locale set is checked semantically (EC-018).
- */
-declare const localeSchema: z.ZodString;
-type Locale = z.infer<typeof localeSchema>;
-/**
- * A document identity (EC-017): the stable pointer to a piece of content. A
- * document belongs to exactly one collection and has a stable id. For localized
- * content the *identity* is collection+id; a specific localized variant is
- * addressed by additionally carrying a locale (see `LocaleAwareDocumentRef`).
- */
-declare const documentRefSchema: z.ZodObject<{
-    collection: z.ZodString;
-    id: z.ZodString;
-}, z.core.$strip>;
-type DocumentRef = z.infer<typeof documentRefSchema>;
-/**
- * A stored document (EC-016/017/018). The live row is the continuous DRAFT
- * (the Sanity model, EC-224). Holds:
- * - identity (`collection` + `id`),
- * - non-localized field values in `values`,
- * - per-locale field values in `localized` (only for localized fields).
- *
- * Publish-ness is NOT a field here: a document is published when an append-only
- * version is pinned via the record's `publishedVersion` pointer (EC-224). The
- * delivery `published` perspective serves that pinned snapshot; this live row
- * is always the working draft.
- */
-declare const documentSchema: z.ZodObject<{
-    collection: z.ZodString;
-    id: z.ZodString;
-    values: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
-    localized: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodRecord<z.ZodString, z.ZodUnknown>>>;
-    defaultLocale: z.ZodOptional<z.ZodString>;
-}, z.core.$strip>;
-type CmsDocument = z.infer<typeof documentSchema>;
-
-/**
- * Locale configuration for a project (EC-018): the set of supported locales and
- * the default used for fallback. Provider-neutral.
- */
-declare const localeConfigSchema: z.ZodObject<{
-    default: z.ZodString;
-    locales: z.ZodArray<z.ZodString>;
-}, z.core.$strip>;
-type LocaleConfig = z.infer<typeof localeConfigSchema>;
-
-/** A JSON-serializable value. The project graph contains only these — never functions or runtime handles. */
-type JsonValue = string | number | boolean | null | JsonValue[] | {
-    [key: string]: JsonValue;
-};
-
-/** A pointer from the graph into a data source via a stable path token. */
-declare const bindingReferenceSchema: z.ZodObject<{
-    sourceId: z.ZodString;
-    token: z.ZodString;
-    mode: z.ZodEnum<{
-        object: "object";
-        value: "value";
-        spread: "spread";
-        repeaterItem: "repeaterItem";
-        condition: "condition";
-    }>;
-}, z.core.$strip>;
-type BindingReference = z.infer<typeof bindingReferenceSchema>;
-/** Gates whether a node renders. The left operand is resolved from a binding. */
-declare const conditionSchema: z.ZodObject<{
-    source: z.ZodObject<{
-        sourceId: z.ZodString;
-        token: z.ZodString;
-        mode: z.ZodEnum<{
-            object: "object";
-            value: "value";
-            spread: "spread";
-            repeaterItem: "repeaterItem";
-            condition: "condition";
-        }>;
-    }, z.core.$strip>;
-    operator: z.ZodEnum<{
-        truthy: "truthy";
-        exists: "exists";
-        eq: "eq";
-        neq: "neq";
-        gt: "gt";
-        gte: "gte";
-        lt: "lt";
-        lte: "lte";
-    }>;
-    value: z.ZodOptional<z.ZodType<JsonValue, unknown, z.core.$ZodTypeInternals<JsonValue, unknown>>>;
-}, z.core.$strip>;
-type Condition = z.infer<typeof conditionSchema>;
-
-/** A prop value is either a static JSON value or a binding into a data source. */
-declare const propValueSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
-    kind: z.ZodLiteral<"static">;
-    value: z.ZodType<JsonValue, unknown, z.core.$ZodTypeInternals<JsonValue, unknown>>;
-}, z.core.$strip>, z.ZodObject<{
-    kind: z.ZodLiteral<"binding">;
-    binding: z.ZodObject<{
-        sourceId: z.ZodString;
-        token: z.ZodString;
-        mode: z.ZodEnum<{
-            object: "object";
-            value: "value";
-            spread: "spread";
-            repeaterItem: "repeaterItem";
-            condition: "condition";
-        }>;
-    }, z.core.$strip>;
-}, z.core.$strip>], "kind">;
-type PropValue = z.infer<typeof propValueSchema>;
-/**
- * An instance of a registered component. Recursive via `slots`: each named slot
- * holds an ordered list of child nodes. The reserved slot `children` is the default
- * insertion point.
- */
-interface ComponentNode {
-    id: string;
-    /** Namespaced registered component id (validated semantically, not at parse time). */
-    componentId: string;
-    props?: Record<string, PropValue>;
-    slots?: Record<string, ComponentNode[]>;
-    condition?: Condition;
-}
-
-/**
- * Schema version 2 (EC-187): the graph is LAYOUTS-ONLY. Version 1 carried a
- * `pages` array (page-as-graph-node); v2 removes it — a page is now a document
- * in the `page` collection whose `body` composition renders into a layout via
- * `renderCompositionInLayout`. A deployment NOT reseeded to v2 serves a null
- * graph, so the host degrades to its visible fallback rather than crashing.
- */
-declare const PROJECT_GRAPH_SCHEMA_VERSION = 2;
-/**
- * The canonical project graph — LAYOUTS-ONLY (EC-187). The single source of
- * truth for the dev-frame layout scaffolding; page content lives in the `page`
- * collection.
- */
-declare const projectGraphSchema: z.ZodObject<{
-    id: z.ZodString;
-    schemaVersion: z.ZodNumber;
-    metadata: z.ZodOptional<z.ZodObject<{
-        name: z.ZodOptional<z.ZodString>;
-    }, z.core.$strip>>;
-    settingsRef: z.ZodOptional<z.ZodString>;
-    layouts: z.ZodDefault<z.ZodArray<z.ZodObject<{
-        id: z.ZodString;
-        name: z.ZodString;
-        root: z.ZodType<ComponentNode, unknown, z.core.$ZodTypeInternals<ComponentNode, unknown>>;
-    }, z.core.$strip>>>;
-}, z.core.$strip>;
-type ProjectGraph = z.infer<typeof projectGraphSchema>;
-
-/** A structured validation issue carrying a JSON path into the graph. */
-declare const validationIssueSchema: z.ZodObject<{
-    code: z.ZodEnum<{
-        "route-conflict": "route-conflict";
-        "invalid-component-name": "invalid-component-name";
-        "unknown-component": "unknown-component";
-        "duplicate-node-id": "duplicate-node-id";
-        "unknown-prop": "unknown-prop";
-        "invalid-prop": "invalid-prop";
-        "binding-not-allowed": "binding-not-allowed";
-        "unresolved-binding": "unresolved-binding";
-        "missing-required-slot": "missing-required-slot";
-        "unknown-slot": "unknown-slot";
-        "forbidden-component": "forbidden-component";
-        "server-only-component": "server-only-component";
-        "unknown-layout": "unknown-layout";
-        "invalid-container-direction": "invalid-container-direction";
-        "invalid-container-alignment": "invalid-container-alignment";
-        "invalid-container-gap": "invalid-container-gap";
-        "invalid-container-columns": "invalid-container-columns";
-        "invalid-container-responsive": "invalid-container-responsive";
-    }>;
-    severity: z.ZodEnum<{
-        error: "error";
-        warning: "warning";
-    }>;
-    message: z.ZodString;
-    path: z.ZodArray<z.ZodUnion<readonly [z.ZodString, z.ZodNumber]>>;
-    nodeId: z.ZodOptional<z.ZodString>;
-    meta: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodType<JsonValue, unknown, z.core.$ZodTypeInternals<JsonValue, unknown>>>>;
-}, z.core.$strip>;
-type ValidationIssue = z.infer<typeof validationIssueSchema>;
-
-/**
- * Structural views of a component manifest, supplied by the registry. The graph
- * package depends only on these shapes (not on `@elytracms/component-registry`) so it
- * stays free of cycles. The registry's Manifest satisfies these structurally.
- */
-interface PropView {
-    /** Whether this prop accepts a binding. Defaults to allowed when omitted. */
-    bindable?: boolean;
-    /** Optional static-value validator (typically backed by the manifest's Zod schema). */
-    validate?: (value: unknown) => boolean;
-}
-interface SlotView {
-    name: string;
-    required?: boolean;
-    /**
-     * Allowed child component ids (EC-186). Omit to allow any registered
-     * component; when present, a child whose `componentId` is not listed is a
-     * `forbidden-component` error. Mirrors the registry's `SlotSpec.allow`.
-     */
-    allow?: readonly string[];
-}
-interface ManifestView {
-    id: string;
-    props?: Record<string, PropView>;
-    slots?: SlotView[];
-    /**
-     * Canvas-eligibility (EC-191). `false` marks a server-only / RSC component that
-     * is NOT client-renderable, so it may not appear in an editor composition (the
-     * canvas is client-rendered). Omitted/true = canvas-eligible. Only enforced when
-     * `requireCanvasEligible` is set (i.e. validating a composition value, not a
-     * dev-authored page/layout frame).
-     */
-    clientRenderable?: boolean;
-}
-interface ComponentLookup {
-    has(componentId: string): boolean;
-    get(componentId: string): ManifestView | undefined;
-}
-
-type ParseResult = {
-    ok: true;
-    graph: ProjectGraph;
-} | {
-    ok: false;
-    error: z.ZodError;
-};
-/** Parse a project graph from a JSON string or already-parsed value. Never throws on invalid input. */
-declare function parseProjectGraph(input: string | unknown): ParseResult;
-
-/**
- * A route record (EC-019, reshaped by EC-187). A path pattern may contain
- * dynamic segments written `:name` (e.g. `/blog/:slug`). A route maps a concrete
- * URL to a **render target = a collection + document** via its `document` ref
- * — `/` → `{ collection: 'page', id: 'home' }`, `/blog/:slug` →
- * `{ collection: 'post', id: ':slug' }`. The catch-all dispatches on the
- * resolved document's collection. There is no `templateId`/`pageId` anymore:
- * page content is a `page`-collection document, not a graph page.
- */
-declare const routeRecordSchema: z.ZodObject<{
-    id: z.ZodString;
-    pattern: z.ZodString;
-    locale: z.ZodOptional<z.ZodString>;
-    document: z.ZodOptional<z.ZodObject<{
-        collection: z.ZodString;
-        id: z.ZodString;
-    }, z.core.$strip>>;
-}, z.core.$strip>;
-type RouteRecord = z.infer<typeof routeRecordSchema>;
-/** A redirect record (EC-019/020). */
-declare const redirectRecordSchema: z.ZodObject<{
-    id: z.ZodString;
-    from: z.ZodString;
-    to: z.ZodString;
-    permanent: z.ZodDefault<z.ZodBoolean>;
-}, z.core.$strip>;
-type RedirectRecord = z.infer<typeof redirectRecordSchema>;
-/** Result of `resolveUrl` (EC-019). */
-type ResolveStatus = 'ok' | 'redirect' | 'notFound';
-
-/**
- * A snapshot of a document at a point in time (EC-021 version history). Stores a
- * full copy of the document's stored state plus bookkeeping. Snapshots are
- * immutable records of prior states.
- */
-declare const documentVersionSchema: z.ZodObject<{
-    version: z.ZodNumber;
-    snapshot: z.ZodObject<{
-        collection: z.ZodString;
-        id: z.ZodString;
-        values: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
-        localized: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodRecord<z.ZodString, z.ZodUnknown>>>;
-        defaultLocale: z.ZodOptional<z.ZodString>;
-    }, z.core.$strip>;
-    createdAt: z.ZodNumber;
-    label: z.ZodOptional<z.ZodString>;
-}, z.core.$strip>;
-type DocumentVersion = z.infer<typeof documentVersionSchema>;
-/**
- * Draft/published primitives + version history for a single document (EC-021).
- *
- * Holds the live `draft` state, the last `published` state (if any), and an
- * ordered history of recorded versions. All mutations return new states or
- * append history; nothing is silently dropped, and retrieving an unknown
- * version yields a structured issue rather than throwing.
- */
-interface DocumentHistory {
-    /** The current working draft. */
-    readonly draft: CmsDocument;
-    /** The last published snapshot, if the document has ever been published. */
-    readonly published: CmsDocument | undefined;
-    /** Recorded versions, oldest first. */
-    readonly versions: readonly DocumentVersion[];
-}
-
-/** Distributive `Omit` that preserves a discriminated union (one variant per member). */
-type DistributiveOmit<T, K extends PropertyKey> = T extends unknown ? Omit<T, K> : never;
-/**
- * A component prop is a **field-def** (EC-190 "props as fields", AD-12): the SAME
- * vocabulary the CMS uses for document fields (`@elytracms/cms-core` `FieldDef`) —
- * text/number/boolean/select/date/relation/asset/richText/blocks — minus the
- * `name` (the record key on `ComponentManifest.props` IS the prop name). One
- * schema vocabulary, one inspector/form engine, recursively: a prop of type
- * `blocks` carries a nested composition. Authoring metadata (label, default,
- * inline-editing, control hint) lives on the field-def's `form` and `default`.
- * Use `context: 'prop'` (or `'both'`); document-only attributes (`filterable`,
- * `unique`) are flagged by cms-core's `assertPropFieldDef`, never silently honoured.
- */
-type PropField = DistributiveOmit<FieldDef, 'name'>;
-/** A named child insertion point. */
-interface SlotSpec {
-    name: string;
-    label?: string;
-    required?: boolean;
-    /** Restrict which component ids may be inserted (omit to allow any). */
-    allow?: string[];
-}
-/** A deterministic preview fixture for a component state. */
-interface ComponentFixture {
-    name: string;
-    props?: Record<string, JsonValue>;
-    /** Named slots rendered with literal child component ids for preview. */
-    slotChildren?: Record<string, string[]>;
-}
-/** Declares that a component iterates a list prop over an item slot (e.g. Repeater). */
-interface IterateSpec {
-    itemsProp: string;
-    itemSlot: string;
-}
-/**
- * Declares that a component renders a composition FIELD VALUE (EC-188, AD-12): the
- * `valueProp` carries a stored composition (one `ComponentNode` root or an ordered
- * list — a `blocks` field's value), which the renderer renders as the component's
- * children via `renderComposition`, with the live `RenderContext`. The mirror of
- * `IterateSpec`: a manifest opts a host component into rendering a composition tree
- * wherever it is placed (e.g. a post template's body), so the same renderer/export
- * pipeline that renders pages renders block fields too.
- */
-interface CompositionSpec {
-    valueProp: string;
-}
-/**
- * Declares that a component renders a LISTING — a live, query-resolved set of
- * documents (EC-255, un-parks AD-9 "this section repeats over a collection,
- * filtered, sorted"). The `prop` receives the matching documents (delivery-shaped),
- * injected by the host exactly like a composition's children — NOT a static
- * relation pick the editor maintains by hand. The filter binds the listed
- * collection's `field` to the ref a SIBLING authored prop (`fromProp`) carries:
- * a ProductGrid picks one `category`, and the listing lists `product` where its
- * `categories` (a `many` relation) contains that pick. `sort`/`limit` are the
- * closed AD-3 query envelope. The mirror of {@link CompositionSpec} for a
- * query-resolved prop — so the same renderer/export pipeline that renders pages
- * renders dynamic grids, and adding/removing a member re-renders them.
- */
-interface ListingSpec {
-    /** Prop the resolved documents are injected as (read by the implementation). */
-    prop: string;
-    /** Collection to list (e.g. `product`). */
-    collection: string;
-    /**
-     * The membership filter: the listed collection's `field` must contain the ref
-     * the sibling authored prop `fromProp` holds (a relation pick, reduced to its
-     * target id). Closed to a single equality/contains term — the AD-3 vocabulary.
-     */
-    filter: {
-        field: string;
-        fromProp: string;
-    };
-    /** Optional single-field sort (ties break by id, like every list — EC-143). */
-    sort?: {
-        field: string;
-        direction?: 'asc' | 'desc';
-    };
-    /** Optional page-size cap. */
-    limit?: number;
-}
-/** The typed manifest each editable component declares (brief §7.2). */
-interface ComponentManifest {
-    /** Namespaced id, e.g. `base.primitives.Stack` or `project.MarketingHero`. */
-    id: string;
-    /** Source namespace: `base.primitives` for platform primitives, `project` for project code. */
-    namespace: string;
-    title?: string;
-    description?: string;
-    category?: string;
-    /** Editable props as field-defs (EC-190), keyed by prop name. */
-    props: Record<string, PropField>;
-    slots: SlotSpec[];
-    /** Design-token usage hints (e.g. `['color.surface', 'space.gap']`). */
-    designTokens?: string[];
-    fixtures?: ComponentFixture[];
-    iterate?: IterateSpec;
-    /** Marks the component as a composition host: `valueProp` holds a block-field tree (EC-188). */
-    composition?: CompositionSpec;
-    /** Marks the component as a listing host: `prop` receives a live query's documents (EC-255). */
-    listing?: ListingSpec;
-    /**
-     * Canvas-eligibility (EC-191). Editors place components on a **client-rendered**
-     * canvas, so a placeable component must be client-renderable (isomorphic React).
-     * Defaults to eligible; set `clientRenderable: false` for a server-only / RSC
-     * component — it stays usable in dev frames (`page.tsx` / `layout.tsx`) but the
-     * blocks panel won't offer it and a composition that contains it is invalid.
-     */
-    clientRenderable?: boolean;
-}
-/** Identity helper that infers nothing but documents intent at call sites. */
-declare function defineComponent(manifest: ComponentManifest): ComponentManifest;
-
-/** Structured issues surfaced by the registry itself (distinct from graph issues). */
-interface ComponentIssue {
-    code: 'duplicate-id' | 'invalid-namespace' | 'invalid-id';
-    componentId: string;
-    message: string;
-}
-
-interface ListFilter {
-    namespace?: string;
-    category?: string;
-    /** Case-insensitive substring match over id / title / category. */
-    query?: string;
-}
-/**
- * The component registry serves the Builder, renderer, AI tools, export pipeline, and
- * CLI. It distinguishes platform primitives from project components, supports lookup,
- * filtering, required lookups, and reports duplicate ids as structured issues.
- */
-declare class ComponentRegistry {
-    private readonly byId;
-    private readonly viewCache;
-    readonly issues: ComponentIssue[];
-    constructor(manifests?: Iterable<ComponentManifest>);
-    register(manifest: ComponentManifest): void;
-    has(id: string): boolean;
-    getManifest(id: string): ComponentManifest | undefined;
-    /** Required lookup — throws when the component is not registered. */
-    require(id: string): ComponentManifest;
-    list(filter?: ListFilter): ComponentManifest[];
-    /** Platform primitives (`base.primitives.*`). */
-    primitives(): ComponentManifest[];
-    /** Project-level components (everything not under `base.primitives.*`). */
-    projectComponents(): ComponentManifest[];
-    get size(): number;
-    /** A `ComponentLookup` view for the project-graph validator. */
-    get lookup(): ComponentLookup;
-}
-
-/**
- * A single repeater item scope. When set, `repeaterItem`-mode bindings resolve against
- * `item` rather than the root data source (brief §4.6 — uniform binding model).
- */
-interface ItemContext {
-    item: unknown;
-    index: number;
-}
-/**
- * Resolves a binding to a runtime value. INJECTED by the host (builder preview, export
- * runtime, tests) so the renderer never imports `@elytracms/data-binding`. When an
- * `ItemContext` is active, it is passed through so `repeaterItem` bindings resolve
- * relative to the current item.
- */
-type ResolveBinding = (ref: BindingReference, item?: ItemContext) => unknown;
-/**
- * A resolved asset, ready to hand to an image implementation (EC-195). The
- * delivery-shaped subset of `@elytracms/content`'s `ResolvedAsset` the renderer
- * needs — kept minimal so the renderer takes no dependency on the content or
- * persistence packages. `width`/`height` are intrinsic dimensions (so the host
- * can reserve space and `next/image` can size variants); `null` when unknown.
- */
-interface RenderAsset {
-    url: string;
-    width: number | null;
-    height: number | null;
-    alt: string | null;
-    /**
-     * Normalized focal point `{ x, y }` in 0–1 (EC-230) → CSS `object-position` so
-     * an art-directed image keeps its subject in frame when cropped; `null` when
-     * none. Kept as a plain pair so the renderer stays free of content/persistence.
-     */
-    focalPoint: {
-        x: number;
-        y: number;
-    } | null;
-}
-/**
- * A relation target populated to delivery shape (EC-254): identity plus the
- * target document's resolved fields (relations inside stay `{ id, collection }`
- * stubs at depth-1; assets inside resolve to objects). Opaque to the renderer —
- * the host's content layer produces it, the component implementation reads its
- * fields. The minimal structural face is `{ id, collection }`.
- */
-type RelationTarget = {
-    id: string;
-    collection: string;
-} & Record<string, unknown>;
-/**
- * Maps namespaced component ids to their React implementations. Implementations receive
- * resolved props plus rendered slot children: the default slot `children` maps to React
- * `children`, and every other named slot is passed as a prop named after the slot.
- */
-type ComponentImplementations = Record<string, ComponentType<Record<string, unknown>>> | Map<string, ComponentType<Record<string, unknown>>>;
-
 /**
  * One host-repo component: the manifest the builder edits against plus the
  * real React implementation that renders it (vision AD-2 — project components
@@ -710,884 +54,6 @@ interface DefineHostComponentsOptions {
  */
 declare function defineHostComponents(components?: readonly HostComponent[], options?: DefineHostComponentsOptions): HostComponents;
 
-/**
- * Which side of the draft/published split a delivery request reads from
- * (EC-021, vision AD-4). `published` never exposes draft content; `draft` is
- * the editor/preview view.
- */
-declare const perspectiveSchema: z.ZodEnum<{
-    draft: "draft";
-    published: "published";
-}>;
-type Perspective = z.infer<typeof perspectiveSchema>;
-/**
- * Ambient request context (vision AD-4): locale and perspective are set once
- * per request and threaded through every resolution function — never per-call
- * ceremony. The locale config travels along so EC-018 fallback needs no extra
- * arguments either.
- */
-interface ContentContext {
-    /** The locale requested for this delivery (EC-018 fallback applies). */
-    readonly locale: Locale;
-    /** Draft or published perspective (EC-021). */
-    readonly perspective: Perspective;
-    /** The project's locale configuration (default + supported set). */
-    readonly locales: LocaleConfig;
-}
-
-/**
- * What delivery resolution accepts as a document source: either a bare stored
- * row (`CmsDocument`, always a working draft — EC-224 retired the `state` flag)
- * or the full draft/published history (`DocumentHistory`, EC-021) whose
- * `published` field carries the pinned snapshot. Lookups hand these in;
- * resolution stays pure — no fetching at this layer.
- */
-type ContentDocumentSource = CmsDocument | DocumentHistory;
-
-/**
- * A report entry for one field whose value was served from a different locale
- * than the one requested (EC-018 default-locale fallback). Paths are rooted at
- * the resolved document, e.g. `['title']` or `['author', 'bio']` for a field
- * inside a populated relation.
- */
-interface FieldLocaleFallback {
-    path: CmsPath;
-    /** The field name (last path segment, repeated for convenience). */
-    field: string;
-    /** The locale the request asked for. */
-    requestedLocale: Locale;
-    /** The locale the value was actually read from. */
-    sourceLocale: Locale;
-}
-
-/**
- * Which backend a persistence adapter is talking to, and whether it's reachable.
- * Lets the Studio surface degraded/offline states without leaking provider types.
- */
-declare const backendKindSchema: z.ZodEnum<{
-    convex: "convex";
-    "in-memory": "in-memory";
-}>;
-type BackendKind = z.infer<typeof backendKindSchema>;
-interface BackendStatus {
-    backend: BackendKind;
-    available: boolean;
-    detail?: string;
-}
-
-/**
- * An immutable record of one saved graph state (brief §7.1, §10). Each save
- * appends a revision; the highest revision is the latest. The graph is stored
- * serialized so reload is provably lossless (serialize → parse round-trip).
- */
-declare const graphRevisionRecordSchema: z.ZodObject<{
-    id: z.ZodString;
-    projectId: z.ZodString;
-    revision: z.ZodNumber;
-    serializedGraph: z.ZodString;
-    schemaVersion: z.ZodNumber;
-    createdAt: z.ZodString;
-    label: z.ZodOptional<z.ZodString>;
-    message: z.ZodOptional<z.ZodString>;
-}, z.core.$strip>;
-type GraphRevisionRecord = z.infer<typeof graphRevisionRecordSchema>;
-/** A revision paired with its parsed graph. */
-interface LoadedGraph {
-    graph: ProjectGraph;
-    revision: GraphRevisionRecord;
-}
-interface SaveGraphOptions {
-    label?: string;
-    message?: string;
-}
-/**
- * Persists project graphs and their revision history (brief §7.1, §10).
- * Provider-neutral: an in-memory and a Convex implementation both satisfy it.
- */
-interface GraphRepository {
-    /** Append a new revision for the project's graph and return it. */
-    saveGraph(projectId: string, graph: ProjectGraph, options?: SaveGraphOptions): Promise<GraphRevisionRecord>;
-    /** Load the latest graph + revision. Throws `RecordNotFoundError` if none. */
-    getLatest(projectId: string): Promise<LoadedGraph>;
-    /** Load a specific revision. Throws `RecordNotFoundError` if absent. */
-    getRevision(projectId: string, revision: number): Promise<LoadedGraph>;
-    /** All revisions for a project, newest first. */
-    listRevisions(projectId: string): Promise<GraphRevisionRecord[]>;
-    /** Whether any graph revision exists for the project. */
-    hasGraph(projectId: string): Promise<boolean>;
-}
-
-/** The persisted CMS schema for a project: its collection definitions (brief §7.4, §10). */
-declare const cmsSchemaRecordSchema: z.ZodObject<{
-    createdAt: z.ZodString;
-    updatedAt: z.ZodString;
-    projectId: z.ZodString;
-    collections: z.ZodArray<z.ZodObject<{
-        id: z.ZodString;
-        kind: z.ZodDefault<z.ZodEnum<{
-            asset: "asset";
-            document: "document";
-        }>>;
-        fields: z.ZodDefault<z.ZodArray<z.ZodType<FieldDef, unknown, z.core.$ZodTypeInternals<FieldDef, unknown>>>>;
-        form: z.ZodOptional<z.ZodObject<{
-            label: z.ZodOptional<z.ZodString>;
-            labelSingular: z.ZodOptional<z.ZodString>;
-            description: z.ZodOptional<z.ZodString>;
-            groups: z.ZodOptional<z.ZodArray<z.ZodString>>;
-            tabs: z.ZodOptional<z.ZodArray<z.ZodString>>;
-        }, z.core.$strip>>;
-        localized: z.ZodOptional<z.ZodBoolean>;
-        titleField: z.ZodOptional<z.ZodString>;
-        singleton: z.ZodOptional<z.ZodBoolean>;
-    }, z.core.$strip>>;
-}, z.core.$strip>;
-type CmsSchemaRecord = z.infer<typeof cmsSchemaRecordSchema>;
-/**
- * A persisted CMS document. The stored `document` is the continuous working
- * **draft** (every edit updates it); `publishedVersion` pins which recorded
- * version is currently live (the Sanity draft/published model, EC-224). Absent
- * `publishedVersion` means the document has never been published / is unpublished.
- * Localized variants ride along on the `CmsDocument` itself.
- */
-declare const cmsDocumentRecordSchema: z.ZodObject<{
-    createdAt: z.ZodString;
-    updatedAt: z.ZodString;
-    projectId: z.ZodString;
-    document: z.ZodObject<{
-        collection: z.ZodString;
-        id: z.ZodString;
-        values: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
-        localized: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodRecord<z.ZodString, z.ZodUnknown>>>;
-        defaultLocale: z.ZodOptional<z.ZodString>;
-    }, z.core.$strip>;
-    publishedVersion: z.ZodOptional<z.ZodNumber>;
-}, z.core.$strip>;
-type CmsDocumentRecord = z.infer<typeof cmsDocumentRecordSchema>;
-/**
- * An immutable snapshot of a document at one recorded version (EC-224). Append-only,
- * mirroring {@link GraphRevisionRecord} but document-scoped: one row per version,
- * keyed by (projectId, collection, docId, version). Created on publish (the promoted
- * draft) and by an explicit pre-restore snapshot, never on a plain draft edit.
- */
-declare const documentVersionRecordSchema: z.ZodObject<{
-    projectId: z.ZodString;
-    collection: z.ZodString;
-    docId: z.ZodString;
-    version: z.ZodNumber;
-    snapshot: z.ZodObject<{
-        collection: z.ZodString;
-        id: z.ZodString;
-        values: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
-        localized: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodRecord<z.ZodString, z.ZodUnknown>>>;
-        defaultLocale: z.ZodOptional<z.ZodString>;
-    }, z.core.$strip>;
-    createdAt: z.ZodString;
-    label: z.ZodOptional<z.ZodString>;
-}, z.core.$strip>;
-type DocumentVersionRecord = z.infer<typeof documentVersionRecordSchema>;
-interface SaveDocumentVersionOptions {
-    label?: string;
-}
-/**
- * Persists CMS collection schemas and documents (brief §7.4, §10). Localized
- * variants and draft/published state ride along on the `CmsDocument` itself.
- */
-interface CmsRepository {
-    /** Persist (replace) the project's collection schema; validates structural shape. */
-    saveSchema(projectId: string, collections: readonly CollectionDef[]): Promise<CmsSchemaRecord>;
-    getSchema(projectId: string): Promise<CmsSchemaRecord>;
-    findSchema(projectId: string): Promise<CmsSchemaRecord | undefined>;
-    /** Insert or update a document (keyed by collection + id). */
-    upsertDocument(projectId: string, document: CmsDocument): Promise<CmsDocumentRecord>;
-    getDocument(projectId: string, ref: DocumentRef): Promise<CmsDocumentRecord>;
-    findDocument(projectId: string, ref: DocumentRef): Promise<CmsDocumentRecord | undefined>;
-    /** All documents for a project, optionally filtered to one collection. */
-    listDocuments(projectId: string, collection?: string): Promise<CmsDocumentRecord[]>;
-    deleteDocument(projectId: string, ref: DocumentRef): Promise<void>;
-    /**
-     * Append a snapshot of a document as a new monotonic version (EC-224). Used by
-     * publish (the promoted draft) and the pre-restore snapshot so a rollback is
-     * itself undoable. The (collection, docId) is derived from the snapshot.
-     */
-    saveDocumentVersion(projectId: string, snapshot: CmsDocument, options?: SaveDocumentVersionOptions): Promise<DocumentVersionRecord>;
-    /** All recorded versions for a document, newest first. Empty when none. */
-    listDocumentVersions(projectId: string, ref: DocumentRef): Promise<DocumentVersionRecord[]>;
-    /**
-     * Every recorded version across all documents in a project (EC-224). Backs the
-     * delivery feeders, which reconstruct each document's `DocumentHistory` from
-     * one bulk fetch rather than a per-document query. Order is deterministic
-     * (by document key, then version ascending).
-     */
-    listAllDocumentVersions(projectId: string): Promise<DocumentVersionRecord[]>;
-    /** A specific recorded version. Throws `RecordNotFoundError` if absent. */
-    getDocumentVersion(projectId: string, ref: DocumentRef, version: number): Promise<DocumentVersionRecord>;
-    /**
-     * Pin an existing recorded version live (EC-224 publish). Throws
-     * `RecordNotFoundError` if the document or the version is unknown.
-     */
-    publishDocumentVersion(projectId: string, ref: DocumentRef, version: number): Promise<CmsDocumentRecord>;
-    /**
-     * Clear the live pin (EC-224 unpublish). Throws `PersistenceValidationError`
-     * if the document is not currently published.
-     */
-    unpublishDocument(projectId: string, ref: DocumentRef): Promise<CmsDocumentRecord>;
-}
-
-/**
- * Persisted asset metadata (brief §7.4, §8.6, §10). The bytes themselves live in
- * a {@link BlobStorageAdapter}; this record is the queryable metadata that CMS
- * `asset` fields point at by id.
- */
-declare const assetRecordSchema: z.ZodObject<{
-    createdAt: z.ZodString;
-    updatedAt: z.ZodString;
-    id: z.ZodString;
-    projectId: z.ZodString;
-    filename: z.ZodString;
-    contentType: z.ZodString;
-    byteSize: z.ZodNumber;
-    width: z.ZodOptional<z.ZodNumber>;
-    height: z.ZodOptional<z.ZodNumber>;
-    alt: z.ZodOptional<z.ZodString>;
-    title: z.ZodOptional<z.ZodString>;
-    storageKey: z.ZodString;
-    url: z.ZodOptional<z.ZodString>;
-    focalPoint: z.ZodOptional<z.ZodObject<{
-        x: z.ZodNumber;
-        y: z.ZodNumber;
-    }, z.core.$strip>>;
-}, z.core.$strip>;
-type AssetRecord = z.infer<typeof assetRecordSchema>;
-interface NewAssetInput {
-    id?: string;
-    filename: string;
-    contentType: string;
-    byteSize: number;
-    width?: number;
-    height?: number;
-    alt?: string;
-    /** Editable display title (EC-152 asset library metadata). */
-    title?: string;
-    /** Defaults to a key derived from the asset id. */
-    storageKey?: string;
-    /** Resolvable serve URL for the stored bytes (EC-151). */
-    url?: string;
-    /** Normalized image focal point `{ x, y }` in 0–1 (EC-230). */
-    focalPoint?: {
-        x: number;
-        y: number;
-    };
-}
-/**
- * Storage boundary for asset *bytes* (brief §8.6). Project-owned and swappable
- * (Convex file storage, S3, etc.); the in-memory implementation backs tests and
- * local inspection. Metadata stays in the {@link AssetRepository}.
- */
-interface BlobStorageAdapter {
-    put(key: string, data: Uint8Array, contentType?: string): Promise<void>;
-    get(key: string): Promise<Uint8Array | undefined>;
-    /** A resolvable locator for the blob (e.g. a CDN/file URL). */
-    url(key: string): string;
-    has(key: string): Promise<boolean>;
-    delete(key: string): Promise<void>;
-    /**
-     * Store bytes under a backend-assigned key and return it (EC-151). Backends
-     * like Convex file storage mint their own ids, so callers cannot choose the
-     * key up front the way {@link put} assumes. Optional; in-memory implements it
-     * deterministically.
-     */
-    store?(data: Uint8Array, contentType?: string): Promise<string>;
-    /**
-     * Mint a short-lived URL the client can POST bytes to directly (EC-151,
-     * Convex `storage.generateUploadUrl()`). Optional — backends without
-     * client-direct uploads omit it and callers fall back to {@link store}/{@link put}.
-     */
-    createUploadUrl?(): Promise<string>;
-    /**
-     * Resolve the serve URL for a stored blob asynchronously (EC-151, Convex
-     * `storage.getUrl()`). Returns `undefined` when the blob does not exist.
-     * Optional; backends with synchronous stable URLs can rely on {@link url}.
-     */
-    resolveUrl?(key: string): Promise<string | undefined>;
-}
-/** Persists asset metadata records (brief §7.4, §8.6, §10). */
-interface AssetRepository {
-    upsertAsset(projectId: string, input: NewAssetInput): Promise<AssetRecord>;
-    getAsset(projectId: string, id: string): Promise<AssetRecord>;
-    findAsset(projectId: string, id: string): Promise<AssetRecord | undefined>;
-    listAssets(projectId: string): Promise<AssetRecord[]>;
-    removeAsset(projectId: string, id: string): Promise<void>;
-    /** Resolve persisted metadata for the asset ids referenced by CMS fields. */
-    resolveMany(projectId: string, ids: readonly string[]): Promise<Map<string, AssetRecord>>;
-}
-
-/**
- * Publishing state (brief §10). Single-environment (EC-179, vision AD-8): a
- * deployment IS one environment, so there is exactly ONE publishing-state
- * record per project. A `published` record pins the graph revision that is
- * live. Moving a release between environments is a deployment/code-pipeline
- * concern, not an in-deployment dimension — see `env-is-deployment-boundary`.
- */
-declare const publishingStateRecordSchema: z.ZodObject<{
-    createdAt: z.ZodString;
-    updatedAt: z.ZodString;
-    projectId: z.ZodString;
-    status: z.ZodEnum<{
-        draft: "draft";
-        published: "published";
-    }>;
-    publishedRevisionId: z.ZodOptional<z.ZodString>;
-    publishedRevision: z.ZodOptional<z.ZodNumber>;
-    publishedAt: z.ZodOptional<z.ZodString>;
-}, z.core.$strip>;
-type PublishingStateRecord = z.infer<typeof publishingStateRecordSchema>;
-interface PublishInput {
-    revisionId: string;
-    revision: number;
-}
-/**
- * Persists and transitions publishing state (brief §10). Transitions are
- * validated: publishing requires a revision; unpublishing requires a
- * currently-published deployment.
- */
-interface PublishingRepository {
-    getState(projectId: string): Promise<PublishingStateRecord>;
-    findState(projectId: string): Promise<PublishingStateRecord | undefined>;
-    /** Publish a graph revision. */
-    publish(projectId: string, input: PublishInput): Promise<PublishingStateRecord>;
-    /** Revert to draft (must currently be published). */
-    unpublish(projectId: string): Promise<PublishingStateRecord>;
-}
-
-/**
- * Reference-index substrate (EC-155, vision AD-6 / pillar 3.6).
- *
- * On every write the operations layer extracts *outbound* references — relation
- * fields, rich-text link marks and inline refs, page-graph bindings and
- * component usage, asset usages — into this index, for draft and published
- * variants separately. One index powers many features: "used by" panels, safe
- * unpublish (the queryable answer to Sanity's hidden-draft-reference failure),
- * component/asset where-used, and broken-link audits (UX lands in Milestone B).
- *
- * Records are **derived data**: they carry no timestamps and are deterministic
- * functions of the indexed content, so backfill is idempotent and two runs over
- * the same data are byte-for-byte identical.
- */
-/** Which content variant an entry was extracted from (the Sanity failure-case axis). */
-declare const referenceVariantSchema: z.ZodEnum<{
-    draft: "draft";
-    published: "published";
-}>;
-type ReferenceVariant = z.infer<typeof referenceVariantSchema>;
-/**
- * What kind of entity *holds* the reference. Documents are keyed by their
- * `documentKey` (`collection:id`); pages/layouts by their graph ids.
- */
-declare const referenceSourceTypeSchema: z.ZodEnum<{
-    document: "document";
-    page: "page";
-    layout: "layout";
-}>;
-type ReferenceSourceType = z.infer<typeof referenceSourceTypeSchema>;
-declare const referenceSourceSchema: z.ZodObject<{
-    type: z.ZodEnum<{
-        document: "document";
-        page: "page";
-        layout: "layout";
-    }>;
-    id: z.ZodString;
-}, z.core.$strip>;
-type ReferenceSource = z.infer<typeof referenceSourceSchema>;
-declare const referenceTargetSchema: z.ZodObject<{
-    type: z.ZodEnum<{
-        asset: "asset";
-        document: "document";
-        component: "component";
-    }>;
-    id: z.ZodString;
-}, z.core.$strip>;
-type ReferenceTarget = z.infer<typeof referenceTargetSchema>;
-/**
- * One outbound reference found *inside* a source, before it is attributed to
- * that source: the exact field/node path, the target, and which structure
- * produced it. `path` is a `/`-joined token path into the stored value, e.g.
- * `values/author`, `localized/en/body/doc/content/0/marks/0`,
- * `root/slots/children/2/props/items/binding`.
- */
-declare const outboundReferenceSchema: z.ZodObject<{
-    path: z.ZodString;
-    target: z.ZodObject<{
-        type: z.ZodEnum<{
-            asset: "asset";
-            document: "document";
-            component: "component";
-        }>;
-        id: z.ZodString;
-    }, z.core.$strip>;
-    kind: z.ZodEnum<{
-        "relation-field": "relation-field";
-        "asset-field": "asset-field";
-        "rich-text-link": "rich-text-link";
-        "rich-text-node": "rich-text-node";
-        "component-usage": "component-usage";
-        "prop-binding": "prop-binding";
-        "condition-binding": "condition-binding";
-    }>;
-}, z.core.$strip>;
-type OutboundReference = z.infer<typeof outboundReferenceSchema>;
-/** An outbound reference attributed to its holding source entity. */
-declare const referenceEntrySchema: z.ZodObject<{
-    path: z.ZodString;
-    target: z.ZodObject<{
-        type: z.ZodEnum<{
-            asset: "asset";
-            document: "document";
-            component: "component";
-        }>;
-        id: z.ZodString;
-    }, z.core.$strip>;
-    kind: z.ZodEnum<{
-        "relation-field": "relation-field";
-        "asset-field": "asset-field";
-        "rich-text-link": "rich-text-link";
-        "rich-text-node": "rich-text-node";
-        "component-usage": "component-usage";
-        "prop-binding": "prop-binding";
-        "condition-binding": "condition-binding";
-    }>;
-    source: z.ZodObject<{
-        type: z.ZodEnum<{
-            document: "document";
-            page: "page";
-            layout: "layout";
-        }>;
-        id: z.ZodString;
-    }, z.core.$strip>;
-}, z.core.$strip>;
-type ReferenceEntry = z.infer<typeof referenceEntrySchema>;
-/** The persisted index record: entry + project + variant. Derived, timestamp-free. */
-declare const referenceEntryRecordSchema: z.ZodObject<{
-    path: z.ZodString;
-    target: z.ZodObject<{
-        type: z.ZodEnum<{
-            asset: "asset";
-            document: "document";
-            component: "component";
-        }>;
-        id: z.ZodString;
-    }, z.core.$strip>;
-    kind: z.ZodEnum<{
-        "relation-field": "relation-field";
-        "asset-field": "asset-field";
-        "rich-text-link": "rich-text-link";
-        "rich-text-node": "rich-text-node";
-        "component-usage": "component-usage";
-        "prop-binding": "prop-binding";
-        "condition-binding": "condition-binding";
-    }>;
-    source: z.ZodObject<{
-        type: z.ZodEnum<{
-            document: "document";
-            page: "page";
-            layout: "layout";
-        }>;
-        id: z.ZodString;
-    }, z.core.$strip>;
-    projectId: z.ZodString;
-    variant: z.ZodEnum<{
-        draft: "draft";
-        published: "published";
-    }>;
-}, z.core.$strip>;
-type ReferenceEntryRecord = z.infer<typeof referenceEntryRecordSchema>;
-interface ReferenceLookupOptions {
-    /** Restrict the lookup to one variant; omit for both (draft + published). */
-    variant?: ReferenceVariant;
-}
-/**
- * Persists the reference index (EC-155). Writes are **replace-all-for-source**:
- * saving an entity recomputes every outbound reference it holds and replaces the
- * previous set atomically, so edits/deletes/unpublishes can never leave stale
- * entries behind. Lookups work in both directions with field/node-path
- * granularity and are variant-aware.
- */
-interface ReferenceIndexRepository {
-    /**
-     * Replace all entries held by `source` in `variant` with the given outbound
-     * references. An empty list removes the source's entries entirely.
-     */
-    replaceForSource(projectId: string, variant: ReferenceVariant, source: ReferenceSource, references: readonly OutboundReference[]): Promise<ReferenceEntryRecord[]>;
-    /**
-     * Replace all entries held by sources of the given types in `variant` (the
-     * graph recompute path: one revision yields entries across many pages/layouts,
-     * and pages removed from the graph must drop their entries too).
-     */
-    replaceForSourceTypes(projectId: string, variant: ReferenceVariant, sourceTypes: readonly ReferenceSourceType[], entries: readonly ReferenceEntry[]): Promise<ReferenceEntryRecord[]>;
-    /** Remove all entries held by `source` (in one variant, or both when omitted). */
-    removeForSource(projectId: string, source: ReferenceSource, variant?: ReferenceVariant): Promise<void>;
-    /** Outbound: what does `source` reference? */
-    outbound(projectId: string, source: ReferenceSource, options?: ReferenceLookupOptions): Promise<ReferenceEntryRecord[]>;
-    /** Inbound: what references `target`? (The "used by" / safe-unpublish direction.) */
-    inbound(projectId: string, target: ReferenceTarget, options?: ReferenceLookupOptions): Promise<ReferenceEntryRecord[]>;
-    /** Every entry of a project (optionally one variant), deterministically ordered. */
-    listEntries(projectId: string, variant?: ReferenceVariant): Promise<ReferenceEntryRecord[]>;
-    /** Drop the whole index of a project (backfill starts from a clean slate). */
-    clearProject(projectId: string): Promise<void>;
-}
-
-/**
- * Per-project membership records (EC-150, vision AD-7). The role model is
- * deliberately minimal for v1 — three roles, project-scoped, no field-level
- * permissions. Workspace-level grants (who may create projects, default
- * memberships) land with EC-154; everything here stays project-scoped.
- *
- * Roles:
- * - `viewer`  — read-only: queries succeed, every command is denied.
- * - `editor`  — edits and publishes content, but cannot administer the project
- *               (lifecycle, settings, members, CLI tokens).
- * - `admin`   — everything within the project.
- *
- * Enforcement lives at the operations chokepoint
- * (`@elytracms/operations` `createRoleAuthorization`) and server-side in the
- * Convex functions (`apps/builder/convex/guard.ts`); this module only defines
- * the storage contract.
- */
-declare const projectRoleSchema: z.ZodEnum<{
-    admin: "admin";
-    editor: "editor";
-    viewer: "viewer";
-}>;
-type ProjectRole = z.infer<typeof projectRoleSchema>;
-declare const projectMemberRecordSchema: z.ZodObject<{
-    projectId: z.ZodString;
-    userId: z.ZodString;
-    role: z.ZodEnum<{
-        admin: "admin";
-        editor: "editor";
-        viewer: "viewer";
-    }>;
-    createdAt: z.ZodString;
-    updatedAt: z.ZodString;
-}, z.core.$strip>;
-type ProjectMemberRecord = z.infer<typeof projectMemberRecordSchema>;
-/**
- * Membership storage boundary. Mirrors the other repository contracts: the
- * in-memory implementation below and the Convex-backed implementation in
- * `apps/builder` both satisfy it.
- */
-interface MembersRepository {
-    /** Upsert a membership (add a member or change their role). */
-    setMember(projectId: string, userId: string, role: ProjectRole): Promise<ProjectMemberRecord>;
-    /** Look up one membership; `undefined` when the user is not a member. */
-    findMember(projectId: string, userId: string): Promise<ProjectMemberRecord | undefined>;
-    /** All members of a project, ordered by userId for determinism. */
-    listMembers(projectId: string): Promise<ProjectMemberRecord[]>;
-    /** All memberships of a user across projects, ordered by projectId. */
-    listMembershipsForUser(userId: string): Promise<ProjectMemberRecord[]>;
-    /** Remove a membership. Throws `RecordNotFoundError` when absent. */
-    removeMember(projectId: string, userId: string): Promise<void>;
-}
-
-/**
- * Revocable per-project CLI tokens (EC-150). The EC-147 push CLI authenticates
- * with `Authorization: Bearer <token>`; the builder stores only a SHA-256 hash
- * of the token (`tokenHash`) — the plaintext is shown exactly once at issuance
- * and never persisted. Verification (`verifyCliToken` in `@elytracms/operations`)
- * hashes the presented token and looks it up here; revoked tokens stay stored
- * (with `revokedAt`) so revocation is auditable and ids stay stable.
- */
-declare const cliTokenRecordSchema: z.ZodObject<{
-    id: z.ZodString;
-    label: z.ZodString;
-    tokenHash: z.ZodString;
-    createdAt: z.ZodString;
-    revokedAt: z.ZodOptional<z.ZodString>;
-}, z.core.$strip>;
-type CliTokenRecord = z.infer<typeof cliTokenRecordSchema>;
-interface NewCliTokenInput {
-    label: string;
-    tokenHash: string;
-}
-/**
- * Token storage boundary. The in-memory implementation below and the
- * Convex-backed implementation in `apps/builder` both satisfy it.
- */
-interface CliTokenRepository {
-    /** Persist a freshly issued token (hash only). */
-    createToken(input: NewCliTokenInput): Promise<CliTokenRecord>;
-    /** All tokens of this deployment (revoked included), ordered by id. */
-    listTokens(): Promise<CliTokenRecord[]>;
-    /** Mark a token revoked (idempotent). Throws `RecordNotFoundError` when absent. */
-    revokeToken(tokenId: string): Promise<CliTokenRecord>;
-    /** Look a token up by its hash — the verification path. */
-    findByHash(tokenHash: string): Promise<CliTokenRecord | undefined>;
-}
-
-/**
- * Inputs to the backend validation service (brief §4.11, §10). Any subset may be
- * provided; only supplied domains are validated.
- */
-interface BackendValidationInput {
-    graph?: ProjectGraph;
-    /** Registry lookup for component/prop/slot checks against the graph. */
-    components?: ComponentLookup;
-    /** Known data-source ids for binding resolution. */
-    knownSourceIds?: ReadonlySet<string>;
-    collections?: readonly CollectionDef[];
-    routes?: readonly RouteRecord[];
-    redirects?: readonly RedirectRecord[];
-    defaultLocale?: string;
-}
-/** Structured, typed validation results returned to clients (brief §4.11). */
-interface BackendValidationResult {
-    ok: boolean;
-    /** Graph + binding + component issues (from `@elytracms/project-graph`). */
-    graphIssues: ValidationIssue[];
-    /** Collection/field schema issues (from `@elytracms/cms-core`). */
-    schemaIssues: CmsValidationIssue[];
-    /** Route conflict + redirect loop issues (from `@elytracms/cms-core`). */
-    routeIssues: CmsValidationIssue[];
-    /** Count of error-severity issues across all domains. */
-    errorCount: number;
-}
-
-/**
- * The aggregate persistence boundary (brief §4.10, §10). Core packages depend on
- * this interface — never on Convex directly. A Convex-backed implementation and
- * the in-memory implementation below both satisfy it, so the Studio, seeds, and
- * tests are provider-agnostic.
- */
-interface PersistenceAdapter {
-    readonly graphs: GraphRepository;
-    readonly cms: CmsRepository;
-    readonly assets: AssetRepository;
-    readonly publishing: PublishingRepository;
-    /** Reference index — outbound/inbound reference entries per variant (EC-155, AD-6). */
-    readonly references: ReferenceIndexRepository;
-    /** Per-project membership roles — admin/editor/viewer (EC-150, AD-7). */
-    readonly members: MembersRepository;
-    /** Revocable per-project CLI sync tokens, stored hashed (EC-150). */
-    readonly cliTokens: CliTokenRepository;
-    /** Blob storage boundary for asset bytes. */
-    readonly blobs: BlobStorageAdapter;
-    /** Backend identity + reachability, for degraded-state UI. */
-    status(): Promise<BackendStatus>;
-    /** Server-side validation service (brief §4.11, EC-047). */
-    validate(input: BackendValidationInput): BackendValidationResult;
-}
-
-/**
- * The delivery shape of an asset (vision AD-4): a directly usable object, not
- * an id. Optional metadata that the stored record lacks is `null` (never
- * `undefined`) so resolved documents stay JSON-stable.
- */
-interface ResolvedAsset {
-    /** The asset id the field stored (kept for cache keys and re-lookup). */
-    id: string;
-    /** Resolvable URL for the asset bytes (EC-044 blob storage locator). */
-    url: string;
-    width: number | null;
-    height: number | null;
-    alt: string | null;
-    mimeType: string;
-    /**
-     * Normalized image focal point `{ x, y }` in 0–1 (EC-230), or `null`. Threaded
-     * to the image primitive's CSS `object-position` so a migrated hotspot keeps
-     * the subject in frame when a layout crops the image (`object-fit: cover`).
-     */
-    focalPoint: {
-        x: number;
-        y: number;
-    } | null;
-}
-
-/**
- * A document in delivery shape: identity plus resolved field values, flat —
- * `post.title`, `post.author.name`, `post.cover.url`. The precise per-collection
- * shape is what `generateDeliveryTypes` emits (EC-142 codegen).
- */
-type ResolvedDocument = {
-    id: string;
-    collection: string;
-} & Record<string, unknown>;
-/**
- * The minimal structural face of any delivery-shaped document — what the typed
- * accessors (EC-143) constrain their per-collection generics against. The
- * generated interfaces from `generateDeliveryTypes` (e.g. `Post`) satisfy this
- * where they cannot satisfy `ResolvedDocument`'s index signature.
- */
-interface DeliveryDocument {
-    id: string;
-    collection: string;
-}
-/**
- * Structured information about *how* a document was resolved — most notably
- * which fields served their value via EC-018 locale fallback.
- */
-interface ResolutionInfo {
-    locale: Locale;
-    perspective: Perspective;
-    localeFallbacks: FieldLocaleFallback[];
-}
-
-/** A scalar a filter can compare against (relation/asset filters use the id). */
-type FilterScalar = string | number | boolean;
-/** One field's filter: every present operator must hold (AND). */
-interface FilterCondition {
-    eq?: FilterScalar;
-    gt?: FilterScalar;
-    gte?: FilterScalar;
-    in?: readonly FilterScalar[];
-    lt?: FilterScalar;
-    lte?: FilterScalar;
-}
-/**
- * The `where` input: field name → condition. A bare scalar is shorthand for
- * `{ eq: value }`. Generated per-collection types (`PostWhere`) narrow the
- * keys to the fields declared `filterable` in the schema.
- */
-type WhereInput = Readonly<Record<string, FilterScalar | FilterCondition | undefined>>;
-type SortDirection = 'asc' | 'desc';
-/** Single-field sort; ties always break by document id ascending. */
-interface SortInput {
-    field: string;
-    direction?: SortDirection;
-}
-/** The full `listDocuments` query envelope (vision AD-3, rung 3). */
-interface ListDocumentsQuery<TWhere extends WhereInput = WhereInput> {
-    where?: TWhere;
-    sort?: SortInput;
-    limit?: number;
-    cursor?: string;
-}
-/**
- * Codes for structured accessor query errors (EC-143). These describe *caller*
- * mistakes (bad filter, bad cursor), as opposed to `CmsValidationIssue`s which
- * describe content/schema problems. Accessors never throw — invalid queries
- * come back as an error result carrying these.
- */
-type ContentQueryErrorCode = 'unknown-collection' | 'list-not-supported' | 'non-filterable-field' | 'invalid-filter' | 'invalid-sort' | 'invalid-limit' | 'invalid-cursor';
-interface ContentQueryError {
-    code: ContentQueryErrorCode;
-    message: string;
-    /** Path into the query input, e.g. ['where', 'title'] or ['sort', 'field']. */
-    path: CmsPath;
-    meta?: Record<string, unknown>;
-}
-
-/**
- * Cache-tag metadata carried by every accessor result (EC-143, vision AD-5):
- * fetch-time tagging of what was *actually returned*, so EC-146 can map each
- * entry to a `revalidateTag` call. Deterministic by construction — every list
- * is sorted and deduplicated.
- */
-interface CacheTags {
-    /**
-     * Identities of every document whose content is present in the result —
-     * the returned documents themselves plus their depth-1 populated relation
-     * targets. Entries are `documentKey` strings (`collection:id`), sorted.
-     */
-    docs: string[];
-    /**
-     * Collections the accessor read from (the coarse membership tags of AD-5:
-     * create/delete/publish in a collection sweeps them). Sorted.
-     */
-    collections: string[];
-    /**
-     * Normalized URL paths the accessor touched (`resolvePage` only): the
-     * requested path, plus every hop of a redirect chain — editing any hop
-     * changes the result. Sorted.
-     */
-    routes: string[];
-    /**
-     * Asset ids the result *baked* its delivery shape from (EC-227): the page's
-     * page-scoped `ResolvedAsset` set (url/dimensions/alt) + its `seoOgImage`.
-     * Editing the asset record (alt/dimensions/re-upload) must drop the page that
-     * baked it — without this dimension the only invalidation triggers are
-     * unrelated (doc/collection/project), so an asset-only edit serves stale
-     * until one of those fires. Sorted.
-     */
-    assets: string[];
-    /** The locale the result was resolved for. */
-    locale: Locale;
-}
-
-/**
- * The closed-form v1 query surface (EC-143, vision AD-3): `resolvePage`,
- * `getDocument`, `listDocuments` — no query language. Every result is
- * delivery-shaped (EC-142) and carries deterministic `CacheTags` for EC-146.
- *
- * Pure and synchronous like the rest of the package: the client reads through
- * a `ContentLookup`; EC-144/EC-145 bind it to Convex/Next later. The ambient
- * `{ locale, perspective }` context is taken once at creation — never per-call
- * ceremony (per-call `locale` overrides exist for route-level needs only).
- */
-interface ResolvePageResult {
-    /** Route resolution status (EC-019 parity): ok | redirect | notFound. */
-    status: ResolveStatus;
-    /** The matched route record, when status is `ok`. */
-    route: RouteRecord | null;
-    /** Extracted dynamic params, e.g. `{ slug: 'hello-world' }`. */
-    dynamicParams: Record<string, string>;
-    /** True when route matching fell back to the default locale (EC-018). */
-    localeFallback: boolean;
-    /** Terminal redirect target + permanence, when status is `redirect`. */
-    redirect: {
-        target: string;
-        permanent: boolean;
-    } | null;
-    /**
-     * The document this URL resolves to, delivery-shaped (EC-142, EC-187). A
-     * `page`-collection document (its `body` composition renders into a layout)
-     * or a content-collection document (rendered by a dev route component). SEO
-     * for a page is read from this document's flat `seo*` fields — there is no
-     * separate page-graph `seo` block anymore.
-     */
-    document: ResolvedDocument | null;
-    issues: CmsValidationIssue[];
-    tags: CacheTags;
-}
-interface GetDocumentResult<TDoc extends DeliveryDocument = ResolvedDocument> {
-    /**
-     * The delivery-shaped document, or `null` when not found / not visible in
-     * the context perspective (correct behavior, not an error — see EC-142).
-     */
-    document: TDoc | null;
-    info: ResolutionInfo | null;
-    issues: CmsValidationIssue[];
-    tags: CacheTags;
-}
-type ListDocumentsResult<TDoc extends DeliveryDocument = ResolvedDocument> = {
-    ok: true;
-    documents: TDoc[];
-    /** Cursor for the next page, `null` when this page exhausts the list. */
-    nextCursor: string | null;
-    issues: CmsValidationIssue[];
-    tags: CacheTags;
-} | {
-    /** The query itself was invalid (never thrown — structured errors). */
-    ok: false;
-    errors: ContentQueryError[];
-    tags: CacheTags;
-};
-interface ContentClient {
-    readonly context: ContentContext;
-    /** Structural route issues from construction (conflicts, redirect loops). */
-    readonly routerIssues: readonly CmsValidationIssue[];
-    resolvePage(url: string, locale?: Locale): ResolvePageResult;
-    getDocument<TDoc extends DeliveryDocument = ResolvedDocument>(collection: string, idOrSlug: string, locale?: Locale): GetDocumentResult<TDoc>;
-    listDocuments<TDoc extends DeliveryDocument = ResolvedDocument, TWhere extends WhereInput = WhereInput>(collection: string, query?: ListDocumentsQuery<TWhere>): ListDocumentsResult<TDoc>;
-    /**
-     * Populate a relation reference to depth-1 delivery shape (EC-254), or `null`
-     * when the target is missing or not visible in the active perspective. A
-     * renderer host wires this as `RenderContext.resolveRelation` to populate the
-     * COMPOSITION-NODE relation props of the nodes inside a page's `blocks` field
-     * (e.g. a ProductGrid block's picked `product`s) — which `resolvePage` leaves
-     * raw, since document resolution does not descend into a composition value.
-     */
-    resolveRelation(ref: DocumentRef): ResolvedDocument | null;
-}
-
 /**
  * Binding payloads for the embedded runtime (EC-144): one payload value per
  * binding `sourceId`. The catch-all route helper provides `document` (the
@@ -2613,4 +1079,4 @@ declare function createPreviewDisableRoute(): PreviewRouteHandlers;
  */
 declare const PACKAGE = "@elytracms/next";
 
-export { type AssetImageLoaderOptions, type AssetRecord, type BindingPayloads, type CacheWrapper, type CacheWrapperOptions, type CachedEntry, type CanvasCacheOptions, type CanvasContentRequest, type CanvasDataSource, type CanvasPageOutcome, type CanvasPayloadContext, type CanvasPayloadsFactory, CanvasRenderer, type CanvasRendererProps, type CanvasRequestInfo, type CanvasRoute, type CanvasRouteOptions, type CanvasRouteProps, type CanvasSitemapOptions, type CanvasSitemapResult, type CmsDocument, type CollectionDef, type ComponentImplementations, type ComponentManifest, type ComponentNode, type ContentSnapshot, type ContentSnapshotOptions, type ContentSource, type CreateCanvasSitemapOptions, type DefineHostComponentsOptions, ElytraImage, type ElytraImageAsset, type ElytraImageProps, type FieldDef, type HostComponent, type HostComponents, type Locale, type LocaleConfig, type MaterializeSourcePayloadsInput, type MaterializedSourcePayloads, PACKAGE, PROJECT_GRAPH_SCHEMA_VERSION, type Perspective, type PreviewEvaluation, type PreviewRouteHandlers, type PreviewRouteOptions, type ProjectGraph, type PropField, REVALIDATE_SIGNATURE_HEADER, type RedirectRecord, type RenderAsset, type ResolveCanvasPageOptions, type RevalidateEvaluation, type RevalidatePayload, type RevalidateRouteHandlers, type RevalidateRouteOptions, type RouteRecord, type SitemapParamsProvider, type SitemapRouteContext, type SitemapSkippedRoute, type SlotSpec, type SourcePayloadError, type StaticContentData, 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 { type AssetImageLoaderOptions, type BindingPayloads, type CacheWrapper, type CacheWrapperOptions, type CachedEntry, type CanvasCacheOptions, type CanvasContentRequest, type CanvasDataSource, type CanvasPageOutcome, type CanvasPayloadContext, type CanvasPayloadsFactory, CanvasRenderer, type CanvasRendererProps, type CanvasRequestInfo, type CanvasRoute, type CanvasRouteOptions, type CanvasRouteProps, type CanvasSitemapOptions, type CanvasSitemapResult, type ContentSnapshot, type ContentSnapshotOptions, type ContentSource, type CreateCanvasSitemapOptions, type DefineHostComponentsOptions, ElytraImage, type ElytraImageAsset, type ElytraImageProps, type HostComponent, type HostComponents, type MaterializeSourcePayloadsInput, type MaterializedSourcePayloads, PACKAGE, type PreviewEvaluation, type PreviewRouteHandlers, type PreviewRouteOptions, REVALIDATE_SIGNATURE_HEADER, type ResolveCanvasPageOptions, type RevalidateEvaluation, type RevalidatePayload, type RevalidateRouteHandlers, type RevalidateRouteOptions, type SitemapParamsProvider, type SitemapRouteContext, type SitemapSkippedRoute, type SourcePayloadError, type StaticContentData, 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 };