@voltro/cms 0.86.0 → 0.87.0

package/dist/web.d.ts

@@ -3,6 +3,9 @@ import { Row } from '@voltro/database';
 import { Schema as Schema_2 } from 'effect';
 import { YieldableError } from 'effect/Cause';
 
+/** Validate against the captured policy, not a live purpose or a cookie version. */
+export declare const admitSnapshotPresentation: (purposes: ReadonlyArray<SnapshotConsentPurpose>, supplied: unknown) => SnapshotPresentation;
+
 /** A document's address in every language it has its own variant in. */
 export declare const alternatesOf: (trees: ReadonlyArray<LocalizedTree>, documentId: string) => ReadonlyArray<PageAlternate>;
 
@@ -44,6 +47,12 @@ export declare const applySelection: (values: Readonly<Record<string, unknown>>,
  */
 export declare const applyTranslation: (fields: Readonly<Record<string, FieldSchema>>, source: Readonly<Record<string, unknown>>, units: ReadonlyArray<TranslationUnit>) => Record<string, unknown>;
 
+/** Declares the original-file field of a versioned asset document. It does
+ * not imply ingestion, creative approval, rights or public delivery fitness. */
+declare interface AssetConfig {
+    readonly file: string;
+}
+
 /**
  * Attribute per-day values (`YYYY-MM-DD`, UTC) to the revision live at the end
  * of each day. A day when nothing was live is left out (`unattributed`).
@@ -114,6 +123,8 @@ export declare const blockMarkup: (block: RichBlock) => string;
  * Arrange one variant per document into a tree. `entries` holds at most one
  * entry per `documentId` (the first one wins). A node without a segment is
  * not routable and counts as an orphan, and so does everything below it.
+ * Equal positions use locale-independent JavaScript string order for segments
+ * and document IDs; process locale or ICU data must not reorder a snapshot.
  */
 export declare const buildTree: (entries: ReadonlyArray<TreeEntry>, config: TreeConfig) => CmsTree;
 
@@ -176,6 +187,10 @@ export declare interface CacheRequest {
     readonly headers: Readonly<Record<string, string | undefined>>;
 }
 
+/** Shared with signed static URL identities. No database, crypto, server
+ * module or request credentials may enter this URL-only normalization. */
+export declare const canonicalCmsPublicPath: (path: string) => string;
+
 /** Who suggests the edit, and when; `id` names the change. */
 export declare type ChangeAuthor = Omit<RichChange, 'kind'>;
 
@@ -185,6 +200,14 @@ export declare type ChangeDecision = 'accept' | 'reject' | 'keep';
 /** The declared fields whose values differ between `before` and `after`, in declaration order. */
 export declare const changedFields: (fields: Readonly<Record<string, unknown>>, before: Readonly<Record<string, unknown>>, after: Readonly<Record<string, unknown>>) => ReadonlyArray<string>;
 
+/** The feed cannot issue a safe cursor; migrate, repair scope, or perform full sync. */
+export declare class ChangeFeedUnavailable extends ChangeFeedUnavailable_base {
+}
+
+declare const ChangeFeedUnavailable_base: Schema_2.Class<ChangeFeedUnavailable, Schema_2.TaggedStruct<"ChangeFeedUnavailable", {
+    readonly reason: Schema_2.Literals<readonly ["scope", "cursor", "migration", "exhausted"]>;
+}>, YieldableError>;
+
 /** Throws for a vendor origin that is not exactly `https://host[:port]` — it would widen the policy. */
 export declare const checkConsentPurposes: (purposes: ReadonlyArray<ConsentPurpose>) => void;
 
@@ -206,6 +229,51 @@ export declare interface CmsExtensionManifest {
     readonly settings?: ReadonlyArray<ExtensionSetting>;
 }
 
+export declare interface CmsPublicBuildDocument {
+    readonly querySelectorAll: (selector: string) => ArrayLike<{
+        readonly getAttribute: (name: string) => string | null;
+    }>;
+}
+
+export declare interface CmsPublicBuildIdentity {
+    readonly version: 1;
+    readonly snapshotDigest: string;
+    readonly inputsId: string;
+    readonly executionId: string;
+}
+
+export declare interface CmsPublicBuildPage<T = unknown> {
+    readonly version: 1;
+    readonly build: CmsPublicBuildIdentity;
+    readonly path: string;
+    readonly page: T;
+}
+
+export declare class CmsPublicBuildUnavailable extends Error {
+    readonly reason: 'identity' | 'request' | 'changed' | 'not-found' | 'denied' | 'transport';
+    readonly _tag = "CmsPublicBuildUnavailable";
+    constructor(reason: 'identity' | 'request' | 'changed' | 'not-found' | 'denied' | 'transport');
+}
+
+export declare interface CmsRouteDispositionApproval extends CmsRouteDispositionRecord {
+    readonly count: number;
+}
+
+export declare interface CmsRouteDispositionPage {
+    readonly revision: number;
+    readonly count: number;
+    readonly entries: ReadonlyArray<CmsRouteDispositionRecord>;
+    readonly next: string | null;
+}
+
+export declare interface CmsRouteDispositionRecord {
+    readonly revision: number;
+    readonly revisionId: string;
+    readonly previousRevisionId: string | null;
+    readonly definition: RouteDispositionDefinition;
+    readonly approvedAt: number;
+}
+
 /**
  * Where a content row lives besides its tenant: the site it belongs to, the
  * content environment (e.g. `production`, `staging`) and its locale. Three
@@ -246,6 +314,20 @@ export declare const compileCacheIdentity: (contract: CacheContract, request: Ca
     readonly tags?: ReadonlyArray<string>;
 }) => CacheIdentity;
 
+export declare interface CompiledSiteDelivery<D extends SiteDeliveryDefinition = SiteDeliveryDefinition> {
+    readonly definition: D;
+    readonly contentLocales: readonly [ContentLocale<D>, ...ContentLocale<D>[]];
+    readonly defaultLocale: ContentLocale<D>;
+    readonly sourceLocale: ContentLocale<D>;
+    readonly fallback: Readonly<Record<ContentLocale<D>, ReadonlyArray<ContentLocale<D>>>>;
+    readonly prefixes: Readonly<Record<ContentLocale<D>, string>>;
+    readonly tags: Readonly<Record<ContentLocale<D>, string>>;
+    readonly directions: Readonly<Record<ContentLocale<D>, 'ltr' | 'rtl'>>;
+}
+
+/** Compile the one graph used by API and frontend; fallback is ordered depth-first, with each locale visited once. */
+export declare const compileSiteDelivery: <const D extends SiteDeliveryDefinition>(input: D) => CompiledSiteDelivery<D>;
+
 declare type ComponentBlock = Extract<RichBlock, {
     readonly type: 'component';
 }>;
@@ -305,6 +387,11 @@ export declare type ConsentChoices = Readonly<Record<string, number>>;
  */
 export declare const consentContentSecurityPolicy: (purposes: ReadonlyArray<ConsentPurpose>, choices: ConsentChoices, base?: string) => string;
 
+/** Every current purpose was either refused or allowed in its current version.
+ * A missing or superseded choice needs another decision without discarding
+ * still-valid grants for other purposes. */
+export declare const consentDecisionComplete: (purposes: ReadonlyArray<Pick<ConsentPurpose, "id" | "version">>, choices: ConsentChoices | undefined) => boolean;
+
 /** The origins of the vendors whose purpose the reader granted in its current version. */
 export declare const consentedOrigins: (purposes: ReadonlyArray<ConsentPurpose>, choices: ConsentChoices) => ReadonlyArray<string>;
 
@@ -536,6 +623,36 @@ declare const ContentIdConflict_base: Schema_2.Class<ContentIdConflict, Schema_2
     readonly id: Schema_2.String;
 }>, YieldableError>;
 
+declare type ContentLocale<D extends SiteDeliveryDefinition> = D['locales'][number]['contentLocale'];
+
+export declare interface ContentLocation {
+    /** Stable mapping identity. Changing a slug/path must not change this ID. */
+    readonly id: string;
+    readonly segments: ReadonlyArray<ContentLocationSegment>;
+}
+
+export declare interface ContentLocationContext {
+    /** Decoded absolute locale prefix, or the empty string for the root locale. */
+    readonly prefix: string;
+    /** Decoded path from buildTree, required only by a tree segment. */
+    readonly treePath?: string;
+}
+
+/** A decoded literal segment, one string field, or the complete content-tree path. */
+export declare type ContentLocationSegment = string | {
+    readonly field: string;
+} | {
+    readonly tree: true;
+};
+
+/** Invalid location mapping or missing/unsafe decoded path input. */
+export declare class ContentLocationUnavailable extends ContentLocationUnavailable_base {
+}
+
+declare const ContentLocationUnavailable_base: Schema_2.Class<ContentLocationUnavailable, Schema_2.TaggedStruct<"ContentLocationUnavailable", {
+    readonly reason: Schema_2.Literals<readonly ["definition", "field", "tree", "path", "bounds"]>;
+}>, YieldableError>;
+
 /**
  * Raised by `publish` / `unpublish` / `archive` when the row id doesn't
  * exist in the caller's scope. On a tenant-scoped request store this is
@@ -554,12 +671,68 @@ declare const ContentNotFound_base: Schema_2.Class<ContentNotFound, Schema_2.Tag
     readonly stage: Schema_2.Literals<readonly ["draft", "published", "revision", "share"]>;
 }>, YieldableError>;
 
+export declare interface ContentSeoDefaults {
+    readonly title?: string;
+    readonly description?: string;
+    readonly social?: {
+        readonly title?: string;
+        readonly description?: string;
+    };
+    readonly robots?: SeoRobotsPolicy;
+    readonly sitemap?: boolean;
+}
+
+export declare interface ContentSeoDefinition {
+    readonly version: 1;
+    readonly title: SeoTextMapping;
+    readonly description?: SeoTextMapping;
+    readonly social?: {
+        readonly title?: SeoTextMapping;
+        readonly description?: SeoTextMapping;
+        readonly image?: string;
+    };
+    /** Route addresses remain authoritative; no independent URL field mapping. */
+    readonly canonical?: 'route' | 'omit';
+    readonly robots?: SeoRobotsPolicy;
+    readonly sitemap?: boolean;
+    readonly structuredData?: {
+        readonly type: 'WebPage' | 'Article' | 'BlogPosting';
+        /** A field the rendered main content actually shows, not the SEO override. */
+        readonly title: string;
+        readonly description?: string;
+        readonly datePublished?: string;
+    };
+}
+
+export declare interface ContentSeoFinding {
+    readonly kind: 'missing' | 'invalid' | 'recommendation';
+    readonly target: string;
+    readonly field: string | null;
+    readonly rule: 'required' | 'text' | 'date' | 'recommendedMaxLength';
+}
+
+export declare interface ContentSeoScope {
+    readonly site: string;
+    readonly environment: string;
+    readonly locale: string;
+}
+
+/** Invalid editorial SEO declaration or projected input; browser-safe. */
+export declare class ContentSeoUnavailable extends ContentSeoUnavailable_base {
+}
+
+declare const ContentSeoUnavailable_base: Schema_2.Class<ContentSeoUnavailable, Schema_2.TaggedStruct<"ContentSeoUnavailable", {
+    readonly reason: Schema_2.Literals<readonly ["definition", "field", "defaults", "values", "scope"]>;
+}>, YieldableError>;
+
 /** A registered content type. */
 declare interface ContentType {
     readonly name: string;
     readonly displayName: string;
     readonly pluralName: string;
     readonly fields: Readonly<Record<string, FieldSchema>>;
+    /** Original-file field of a versioned asset document. */
+    readonly asset?: AssetConfig;
     readonly list?: ListConfig;
     readonly idPrefix?: string;
     /** Declared ISR revalidations fired by `revalidateContent` — see
@@ -569,6 +742,12 @@ declare interface ContentType {
     readonly tree?: TreeConfig;
     /** The field a document outside a tree is addressed by — see `ContentTypeSpec.address`. */
     readonly address?: string;
+    /** Serializable delivery paths with stable mapping IDs; no publish reservation implied. */
+    readonly locations?: ReadonlyArray<ContentLocation>;
+    /** Required/invalid mapped values block publication; length recommendations do not. */
+    readonly seo?: ContentSeoDefinition;
+    /** Explicit delivery definitions supplying locale-specific SEO defaults. Requires `seo`. */
+    readonly seoSites?: ReadonlyArray<SiteDeliveryDefinition>;
     /** Whether publishing needs an approved revision — see `ContentTypeSpec.review`. */
     readonly review?: {
         readonly required: boolean | 'workspace';
@@ -600,6 +779,8 @@ declare interface ContentTypeSpec {
     readonly displayName: string;
     readonly pluralName: string;
     readonly fields: Readonly<Record<string, FieldSchema | PipeableField>>;
+    /** Explicit asset identity; the original is a required Media field. */
+    readonly asset?: AssetConfig;
     readonly list?: ListConfig;
     /** Override the TypeID prefix for awkward plurals / long names. */
     readonly idPrefix?: string;
@@ -617,6 +798,12 @@ declare interface ContentTypeSpec {
      * page in a tree does. Read it with `redirectTarget(store, type, path, scope)`.
      */
     readonly address?: string;
+    /** Serializable delivery paths with stable mapping IDs; no publish reservation implied. */
+    readonly locations?: ReadonlyArray<ContentLocation>;
+    /** Required/invalid mapped values block publication; length recommendations do not. */
+    readonly seo?: ContentSeoDefinition;
+    /** Explicit delivery definitions supplying locale-specific SEO defaults. Requires `seo`. */
+    readonly seoSites?: ReadonlyArray<SiteDeliveryDefinition>;
     /**
      * `required: true` publishes only revisions another editor approved
      * (`approveReview`) — for every path that publishes: single, release,
@@ -655,7 +842,8 @@ declare interface ContentTypeSpec {
     /**
      * Append every publish and take-down of this type to the change feed
      * (`cms_changes`, read with `readChanges`), in the same transaction. Register
-     * `cmsChangesTable` when set.
+     * `cmsChangesTable` and `cmsChangeHeadsTable` for every publication writer;
+     * this flag controls event emission, not publication coordination.
      */
     readonly changeFeed?: boolean;
     /**
@@ -746,12 +934,27 @@ export declare const contentViolations: (type: Pick<ContentType, "name" | "field
 /** How many variants the contract allows at most (query strings count as unbounded beyond the budget). */
 export declare const contractVariants: (contract: CacheContract) => number;
 
+export declare const copyCmsPublicBuildIdentity: (value: unknown) => CmsPublicBuildIdentity;
+
+export declare const copyRouteDispositionDefinition: (value: unknown) => RouteDispositionDefinition;
+
+/** Detached version pins; the actual application retains its notice/vendor text. */
+export declare const copySnapshotConsentPurposes: (value: unknown) => ReadonlyArray<SnapshotConsentPurpose>;
+
+/** Detach a closed claim before asynchronous admission. This alone does not
+ * admit any purpose; use admitSnapshotPresentation against the captured policy. */
+export declare const copySnapshotPresentationValue: (supplied: unknown) => SnapshotPresentation;
+
+export declare const decodeCmsPublicBuildIdentity: (value: string) => CmsPublicBuildIdentity;
+
 /** Decode character references (`&amp;`, `&#8217;`, `&#x2014;`). */
 export declare const decodeEntities: (text: string) => string;
 
 /** The intent a `?select=…` value carries, or null. */
 export declare const decodeSelectionIntent: (value: string | null | undefined) => SelectionIntent | null;
 
+export declare const decodeSnapshotPresentation: (purposes: ReadonlyArray<SnapshotConsentPurpose>, selector: string) => SnapshotPresentation;
+
 /** Define an audience; a rule with no condition would match everyone and is refused. */
 export declare const defineAudience: (audience: Audience) => Audience;
 
@@ -770,6 +973,15 @@ export declare const defineComponent: (spec: {
     readonly migrations?: ComponentDefinition["migrations"];
 }) => ComponentDefinition;
 
+/** Validate and detach a bounded, JSON-only set of stable location mappings. */
+export declare const defineContentLocations: (input: ReadonlyArray<ContentLocation>) => ReadonlyArray<ContentLocation>;
+
+/** Detach a bounded JSON-only declaration; getters/functions/unknown keys refuse. */
+export declare const defineContentSeo: (input: ContentSeoDefinition) => ContentSeoDefinition;
+
+/** Locale-specific text and editorial policy defaults, not an access decision. */
+export declare const defineContentSeoDefaults: (input: ContentSeoDefaults) => ContentSeoDefaults;
+
 /**
  * Declare the design tokens components may name (`Schema.Token(tokens, 'tone')`).
  * Group and token names are camelCase; the values are what an editor reads
@@ -777,6 +989,10 @@ export declare const defineComponent: (spec: {
  */
 export declare const defineDesignTokens: <T extends DesignTokens>(tokens: T) => T;
 
+/** Validate actual callable bindings. Full schema compatibility is checked by
+ * the shared descriptor encoder when the app describes its snapshot inputs. */
+export declare const defineFrontendBindings: (input: FrontendBindings) => FrontendBindings;
+
 /** Declare a metric; the fingerprint follows its meaning. */
 export declare const defineMetric: (spec: MetricSpec) => MetricDefinition;
 
@@ -804,6 +1020,13 @@ export declare const defineRichTextProfile: (spec: {
     readonly contactLiterals?: boolean;
 }) => RichTextProfile;
 
+/**
+ * Copy and validate the explicit site delivery graph. This performs no tag
+ * inference, registry lookup, source migration or content writes. Authoring
+ * supplies approved profiles; the complete definition is pinned with app code.
+ */
+export declare const defineSiteDelivery: <const D extends SiteDeliveryDefinition>(input: D) => D;
+
 /**
  * Mark a field computed-on-save from another field. The transform runs
  * before the row is written — `saveDraft` applies it (via
@@ -951,9 +1174,24 @@ export declare const EMPTY_EDIT_HISTORY: EditHistory;
 /** An empty document. */
 export declare const emptyRichDocument: () => RichDocument;
 
+/** Fixed ASCII framing needs no HTML attribute escaping and contains no site
+ * credentials, actor, grant, personal consent or private input configuration. */
+export declare const encodeCmsPublicBuildIdentity: (value: CmsPublicBuildIdentity) => string;
+
 /** The intent as a URL parameter value (`?select=…`). */
 export declare const encodeSelectionIntent: (intent: SelectionIntent) => string;
 
+/** A public class selector; this is not a credential or a reader identifier. */
+export declare const encodeSnapshotPresentation: (purposes: ReadonlyArray<SnapshotConsentPurpose>, presentation: SnapshotPresentation) => string;
+
+/** An environment alias never falls back to a literal environment or stale target. */
+export declare class EnvironmentAliasUnavailable extends EnvironmentAliasUnavailable_base {
+}
+
+declare const EnvironmentAliasUnavailable_base: Schema_2.Class<EnvironmentAliasUnavailable, Schema_2.TaggedStruct<"EnvironmentAliasUnavailable", {
+    readonly reason: Schema_2.Literals<readonly ["scope", "name", "target", "missing", "conflict", "revision", "state"]>;
+}>, YieldableError>;
+
 /** Why a dimension is in the identity or not. */
 export declare interface ExplainLine {
     readonly dimension: string;
@@ -1155,6 +1393,71 @@ export declare interface FieldViolation {
  */
 export declare const formPartOf: (form: ParentNode, path: string) => Element | null;
 
+export declare type FrontendBindings = Readonly<Record<string, FrontendComponentBinding>>;
+
+export declare class FrontendBindingUnavailable extends FrontendBindingUnavailable_base {
+}
+
+declare const FrontendBindingUnavailable_base: Schema_2.Class<FrontendBindingUnavailable, Schema_2.TaggedStruct<"FrontendBindingUnavailable", {
+    readonly reason: Schema_2.Literals<readonly ["definition", "missing", "schema", "implementation", "context"]>;
+}>, YieldableError>;
+
+export declare interface FrontendComponentBinding {
+    readonly schema: ComponentDefinition;
+    readonly renderer: string;
+    readonly contexts: ReadonlyArray<FrontendOutputContext>;
+    readonly render: (props: Readonly<Record<string, unknown>>, context: FrontendOutputContext, resources: {
+        readonly media: FrontendMediaReader;
+        readonly source?: SnapshotComponentSource;
+    }) => unknown;
+    readonly empty: (input: FrontendStateInput) => unknown;
+    readonly loading: (input: FrontendStateInput) => unknown;
+    readonly error: (input: FrontendStateInput) => unknown;
+    readonly restricted?: (input: FrontendStateInput & {
+        readonly purpose: string;
+    }) => unknown;
+}
+
+export declare interface FrontendMedia extends FrontendMediaSelection, FrontendMediaFile {
+}
+
+export declare interface FrontendMediaFile {
+    readonly url: string;
+    readonly contentType: string;
+}
+
+export declare type FrontendMediaOutput = {
+    readonly kind: 'original';
+} | {
+    readonly kind: 'rendition';
+    readonly slot: string;
+};
+
+export declare type FrontendMediaReader = (path: ReadonlyArray<string | number>, output?: FrontendMediaOutput) => FrontendMediaFile | null;
+
+export declare interface FrontendMediaSelection {
+    readonly fieldPath: ReadonlyArray<string | number>;
+    readonly output: FrontendMediaOutput;
+}
+
+export declare interface FrontendOutputContext extends FrontendOutputSelection {
+    readonly localeId: string;
+    readonly contentLocale: string;
+    readonly languageTag: string;
+    readonly direction: 'ltr' | 'rtl';
+}
+
+export declare interface FrontendOutputSelection {
+    readonly channel: string;
+    readonly theme: string;
+}
+
+export declare interface FrontendStateInput {
+    readonly componentId: string;
+    readonly context: FrontendOutputContext;
+    readonly source?: SnapshotComponentSource;
+}
+
 /**
  * The values with every component that needs an ungranted purpose replaced
  * by a {@link WithheldInstance}. Values without such components come back
@@ -1165,7 +1468,7 @@ export declare const gateConsent: (type: {
 }, values: Readonly<Record<string, unknown>>, granted: ReadonlySet<string>) => Record<string, unknown>;
 
 /** The purposes whose current version the reader allowed. */
-export declare const grantedPurposes: (purposes: ReadonlyArray<ConsentPurpose>, choices: ConsentChoices) => ReadonlySet<string>;
+export declare const grantedPurposes: (purposes: ReadonlyArray<Pick<ConsentPurpose, "id" | "version">>, choices: ConsentChoices) => ReadonlySet<string>;
 
 /** Whether every character of text in `[start, end)` carries `mark` (links never do). */
 export declare const hasMark: (content: ReadonlyArray<RichInline>, start: number, end: number, mark: RichMark) => boolean;
@@ -1307,6 +1610,13 @@ export declare interface LiveStretch {
     readonly to: string | null;
 }
 
+/** This dedicated public data transport cannot fall back to a live delivery
+ * query after a pin mismatch, denial, missing captured path or network error. */
+export declare const loadCmsPublicBuildPage: <T>(identity: CmsPublicBuildIdentity, path: string, options?: {
+    readonly signal?: AbortSignal;
+    readonly fetch?: typeof globalThis.fetch;
+}) => Promise<CmsPublicBuildPage<T>>;
+
 /** One language's published page tree. */
 export declare interface LocalizedTree {
     readonly locale: string;
@@ -1590,6 +1900,18 @@ declare const PreviewShareRejected_base: Schema_2.Class<PreviewShareRejected, Sc
     readonly reason: Schema_2.Literals<readonly ["expiryInPast", "expiryTooFar"]>;
 }>, YieldableError>;
 
+export declare interface PublicRouteIdentity {
+    readonly url: string;
+    readonly routeId: string;
+}
+
+export declare class PublicRouteRegistryUnavailable extends PublicRouteRegistryUnavailable_base {
+}
+
+declare const PublicRouteRegistryUnavailable_base: Schema_2.Class<PublicRouteRegistryUnavailable, Schema_2.TaggedStruct<"PublicRouteRegistryUnavailable", {
+    readonly reason: Schema_2.Literals<readonly ["scope", "definition", "configuration", "history", "state", "revision", "conflict", "bounds", "location"]>;
+}>, YieldableError>;
+
 /**
  * What stops these values from being published: every `requiredToPublish()`
  * field that is empty (absent, null, or a blank string), and every rich text
@@ -1673,6 +1995,8 @@ declare const QuotaExceeded_base: Schema_2.Class<QuotaExceeded, Schema_2.TaggedS
     readonly used: Schema_2.Number;
 }>, YieldableError>;
 
+export declare const readCmsPublicBuildIdentity: (document?: CmsPublicBuildDocument | undefined) => CmsPublicBuildIdentity | null;
+
 /** The editor's message, or null for anything else. */
 export declare const readEditorMessage: (event: VisualMessageEvent, session: VisualSession) => EditorMessage | null;
 
@@ -1757,6 +2081,8 @@ declare const ReleaseNotEditable_base: Schema_2.Class<ReleaseNotEditable, Schema
     readonly status: Schema_2.String;
 }>, YieldableError>;
 
+export declare const renderSnapshotComponent: (data: SnapshotContentData, bindings: FrontendBindings, fieldPath: ReadonlyArray<string | number>, state?: "content" | "empty" | "loading" | "error") => unknown;
+
 /**
  * Replace the text in `[start, end)` with `text` (a paste, a typed line
  * break). It takes the marks of the first character it replaces, or — where
@@ -1767,6 +2093,40 @@ export declare const replaceText: (content: ReadonlyArray<RichInline>, start: nu
 /** The document with each suggestion accepted, rejected or kept, as `decide` says. */
 export declare const resolveChanges: (doc: RichDocument, decide: (change: RichChange) => ChangeDecision) => RichDocument;
 
+/** Resolve decoded inputs into one canonical absolute path; no host, query or live reads. */
+export declare const resolveContentLocation: (input: ContentLocation, values: Readonly<Record<string, unknown>>, context: ContentLocationContext) => string;
+
+/** Project only mapped fields. Findings must be judged before publication/output.
+ * Public visibility, runtime rights, robots.txt, URLs and resolved images are
+ * separate admission/rendering contracts; true here is never a public grant. */
+export declare const resolveContentSeo: (definition: ContentSeoDefinition, values: Readonly<Record<string, unknown>>, defaults?: ContentSeoDefaults) => ResolvedContentSeo;
+
+export declare interface ResolvedContentSeo {
+    readonly title: string | null;
+    readonly description: string | null;
+    readonly canonical: 'route' | 'omit';
+    readonly robots: SeoRobotsPolicy;
+    readonly sitemap: boolean;
+    readonly social: {
+        readonly title: string | null;
+        readonly description: string | null;
+        readonly imageKey: string | null;
+    };
+    /** Typed semantic values; a renderer adds the admitted URL, locale and media. */
+    readonly structuredData: {
+        readonly type: 'WebPage' | 'Article' | 'BlogPosting';
+        readonly title: string;
+        readonly description: string | null;
+        readonly datePublished: string | null;
+    } | null;
+    readonly sources: Readonly<Record<string, string | null>>;
+    readonly findings: ReadonlyArray<ContentSeoFinding>;
+}
+
+/** Project the variant's own language. Delivery fallback never supplies missing
+ * publication metadata. An undeclared scope refuses even if all fields are set. */
+export declare const resolveScopedContentSeo: (policy: ScopedContentSeo, values: Readonly<Record<string, unknown>>, scope: ContentSeoScope) => ResolvedContentSeo | null;
+
 /**
  * Raised when a revision of a content type that requires review is published
  * without an approval of exactly that revision.
@@ -1915,6 +2275,11 @@ export declare interface RichDocument {
     readonly profile?: string;
 }
 
+export declare interface RichDocumentBlockContext {
+    /** Position in the rendered document's blocks, including repeated assets. */
+    readonly index: number;
+}
+
 export declare const RichDocumentEditor: (props: RichDocumentEditorProps) => ReactNode;
 
 export declare interface RichDocumentEditorProps extends WidgetProps {
@@ -1945,6 +2310,11 @@ export declare const richDocumentFromContentful: (root: ContentfulNode | null |
  */
 export declare const richDocumentFromHtml: (html: string, options?: HtmlImportOptions) => HtmlImportResult;
 
+export declare interface RichDocumentInlineContext {
+    /** Exact reference scalar path relative to the document, including block/list/table positions. */
+    readonly fieldPath: ReadonlyArray<string | number>;
+}
+
 /** Renders a control that picks one document of `type`. */
 export declare type RichDocumentPicker = (props: {
     readonly id: string;
@@ -1979,6 +2349,18 @@ export declare interface RichDocumentReference {
     readonly targetDocumentId: string;
 }
 
+/** One direct rich-document reference, addressed at its actual scalar field. */
+export declare interface RichDocumentReferenceField {
+    readonly fieldPath: ReadonlyArray<string | number>;
+    readonly targetType: string;
+    readonly targetDocumentId: string;
+}
+
+/** Direct links, managed contacts and image/file assets in a valid document.
+ * Embedded component props use their own declared component schemas. Prefix
+ * segments are opaque; never recover these coordinates from display labels. */
+export declare const richDocumentReferenceFields: (prefix: ReadonlyArray<string | number>, doc: RichDocument, options: RichTextOptions) => ReadonlyArray<RichDocumentReferenceField>;
+
 /** Every image and link reference in a (valid) document, with its path. */
 export declare const richDocumentReferences: (path: string, doc: RichDocument, options: RichTextOptions) => ReadonlyArray<RichDocumentReference>;
 
@@ -1989,18 +2371,18 @@ export declare interface RichDocumentViewProps {
     /** A stored `Schema.RichText()` value (a plain string renders as paragraphs). */
     readonly document: unknown;
     /** The address of a linked document, or undefined when it has none (not live). */
-    readonly hrefOf?: (documentId: string) => string | undefined;
+    readonly hrefOf?: (documentId: string, context: RichDocumentInlineContext) => string | undefined;
     /** Render an image block; without it, images are left out. */
     readonly renderImage?: (block: {
         readonly asset: string;
         readonly caption?: string;
-    }) => ReactNode;
+    }, context: RichDocumentBlockContext) => ReactNode;
     /** The `mailto:` / `tel:` address of a published contact point, or undefined when it is not live. */
-    readonly contactHrefOf?: (documentId: string) => string | undefined;
+    readonly contactHrefOf?: (documentId: string, context: RichDocumentInlineContext) => string | undefined;
     /** Render a component placed between the blocks; without it, components are left out. */
-    readonly renderComponent?: (block: ComponentBlock) => ReactNode;
+    readonly renderComponent?: (block: ComponentBlock, context: RichDocumentBlockContext) => ReactNode;
     /** The address a download block's file is fetched from, or undefined when it is not live — then the download is left out, never a dead link. */
-    readonly fileHrefOf?: (asset: string) => string | undefined;
+    readonly fileHrefOf?: (asset: string, context: RichDocumentBlockContext) => string | undefined;
 }
 
 /** A run of text inside a block. `change` marks it as suggested. */
@@ -2084,6 +2466,71 @@ export declare interface RichTextSurfaceProps {
     };
 }
 
+export declare type RouteDispositionAction = {
+    readonly kind: 'redirect';
+    readonly status: 301 | 302;
+    readonly method: 'allow-post-to-get';
+    readonly target: PublicRouteIdentity;
+} | {
+    readonly kind: 'redirect';
+    readonly status: 307 | 308;
+    readonly method: 'preserve';
+    readonly target: PublicRouteIdentity;
+} | {
+    readonly kind: 'gone';
+    readonly status: 404 | 410;
+} | {
+    readonly kind: 'hold';
+};
+
+export declare interface RouteDispositionDefinition {
+    readonly version: 1;
+    readonly source: PublicRouteIdentity;
+    readonly action: RouteDispositionAction;
+    /** Inclusive lower and exclusive upper bound, UTC epoch milliseconds. */
+    readonly activeFrom: number | null;
+    readonly activeUntil: number | null;
+}
+
+export declare const RouteDispositionDefinitionSchema: Schema_2.Struct<{
+    readonly version: Schema_2.Literal<1>;
+    readonly source: Schema_2.Struct<{
+        readonly url: Schema_2.String;
+        readonly routeId: Schema_2.String;
+    }>;
+    readonly action: Schema_2.Union<readonly [Schema_2.Struct<{
+        readonly kind: Schema_2.Literal<"redirect">;
+        readonly status: Schema_2.Literals<readonly [301, 302]>;
+        readonly method: Schema_2.Literal<"allow-post-to-get">;
+        readonly target: Schema_2.Struct<{
+            readonly url: Schema_2.String;
+            readonly routeId: Schema_2.String;
+        }>;
+    }>, Schema_2.Struct<{
+        readonly kind: Schema_2.Literal<"redirect">;
+        readonly status: Schema_2.Literals<readonly [307, 308]>;
+        readonly method: Schema_2.Literal<"preserve">;
+        readonly target: Schema_2.Struct<{
+            readonly url: Schema_2.String;
+            readonly routeId: Schema_2.String;
+        }>;
+    }>, Schema_2.Struct<{
+        readonly kind: Schema_2.Literal<"gone">;
+        readonly status: Schema_2.Literals<readonly [404, 410]>;
+    }>, Schema_2.Struct<{
+        readonly kind: Schema_2.Literal<"hold">;
+    }>]>;
+    readonly activeFrom: Schema_2.NullOr<Schema_2.Int>;
+    readonly activeUntil: Schema_2.NullOr<Schema_2.Int>;
+}>;
+
+export declare class RouteDispositionUnavailable extends RouteDispositionUnavailable_base {
+}
+
+declare const RouteDispositionUnavailable_base: Schema_2.Class<RouteDispositionUnavailable, Schema_2.TaggedStruct<"RouteDispositionUnavailable", {
+    readonly reason: Schema_2.Literals<readonly ["input", "bounds", "scope", "state", "revision", "credential", "graph", "hold"]>;
+}>, YieldableError>;
+
 /**
  * The CMS field namespace. Scalars mirror the effect/Schema names the
  * docs use; the CMS-only constructors (RichText / Media / Reference /
@@ -2154,6 +2601,12 @@ export declare const Schema: {
     readonly Components: (definitions: ReadonlyArray<ComponentDefinition>) => PipeableField;
 };
 
+export declare interface ScopedContentSeo {
+    readonly seo?: ContentSeoDefinition;
+    /** The same site declarations used by delivery; no inferred site or language. */
+    readonly seoSites?: ReadonlyArray<SiteDeliveryDefinition>;
+}
+
 /** What makes a type findable. */
 declare interface SearchConfig {
     /** The string field ranked first — usually the title. */
@@ -2202,6 +2655,18 @@ export declare interface SelectionTarget {
     };
 }
 
+export declare interface SeoRobotsPolicy {
+    readonly index: boolean;
+    readonly follow: boolean;
+}
+
+export declare interface SeoTextMapping {
+    readonly fields: ReadonlyArray<string>;
+    readonly required?: boolean;
+    /** An editorial recommendation, never an invented search-engine limit. */
+    readonly recommendedMaxLength?: number;
+}
+
 /** What is wrong with values for a manifest's settings; empty when nothing is. Unknown keys are refused. */
 export declare const settingsProblems: (manifest: CmsExtensionManifest, values: Readonly<Record<string, unknown>>) => ReadonlyArray<string>;
 
@@ -2215,6 +2680,49 @@ export declare const settingsWithDefaults: (manifest: CmsExtensionManifest, stor
  */
 export declare const sharedCacheable: (headers: Readonly<Record<string, string | undefined>>) => boolean;
 
+/** A named site content binding cannot be resolved or changed as requested. */
+export declare class SiteBindingUnavailable extends SiteBindingUnavailable_base {
+}
+
+declare const SiteBindingUnavailable_base: Schema_2.Class<SiteBindingUnavailable, Schema_2.TaggedStruct<"SiteBindingUnavailable", {
+    readonly reason: Schema_2.Literals<readonly ["scope", "name", "target", "missing", "conflict", "revision", "state"]>;
+}>, YieldableError>;
+
+export declare interface SiteDeliveryDefinition {
+    readonly id: string;
+    readonly version: number;
+    readonly environments: ReadonlyArray<string>;
+    readonly defaultEnvironment: string;
+    readonly locales: ReadonlyArray<SiteDeliveryLocale>;
+    readonly defaultLocale: string;
+    readonly sourceLocale: string;
+    /** Named site-content bindings and their registered content type names. */
+    readonly bindings: Readonly<Record<string, string>>;
+    /** Editorial defaults keyed by stable locale identity, never request language guesses. */
+    readonly seo?: Readonly<Record<string, ContentSeoDefaults>>;
+}
+
+export declare interface SiteDeliveryLocale {
+    readonly id: string;
+    /** An explicitly approved language tag; this compiler never canonicalizes it. */
+    readonly tag: string;
+    /** Existing published/draft row partition. Renaming a tag does not rewrite it. */
+    readonly contentLocale: string;
+    readonly direction: 'ltr' | 'rtl';
+    readonly enabled: boolean;
+    readonly prefix: string;
+    /** Ordered fallback locale IDs, independent of translation source. */
+    readonly fallback: ReadonlyArray<string>;
+}
+
+/** The explicit site delivery definition is invalid; no implicit defaults are selected. */
+export declare class SiteDeliveryUnavailable extends SiteDeliveryUnavailable_base {
+}
+
+declare const SiteDeliveryUnavailable_base: Schema_2.Class<SiteDeliveryUnavailable, Schema_2.TaggedStruct<"SiteDeliveryUnavailable", {
+    readonly reason: Schema_2.Literals<readonly ["definition", "environment", "locale", "fallback", "prefix", "binding"]>;
+}>, YieldableError>;
+
 export declare interface SitemapUrl extends PageAlternate {
     readonly documentId: string;
     /** ISO date of the variant's last change, when known. */
@@ -2236,6 +2744,14 @@ export declare const sitemapUrls: (trees: ReadonlyArray<LocalizedTree>, include?
  */
 export declare const sitemapXml: (urls: ReadonlyArray<SitemapUrl>, href: (locale: string, path: string) => string, xDefault?: string) => string;
 
+/** The site configuration scope or stored coordination state is invalid. */
+export declare class SiteStateUnavailable extends SiteStateUnavailable_base {
+}
+
+declare const SiteStateUnavailable_base: Schema_2.Class<SiteStateUnavailable, Schema_2.TaggedStruct<"SiteStateUnavailable", {
+    readonly reason: Schema_2.Literals<readonly ["scope", "state"]>;
+}>, YieldableError>;
+
 /**
  * The canonical slug helper: lowercase, letters with accents folded to their
  * base letter (umlauts spelled out, `ß` as `ss`), hyphenate, strip every
@@ -2243,6 +2759,192 @@ export declare const sitemapXml: (urls: ReadonlyArray<SitemapUrl>, href: (locale
  */
 export declare const slugify: (value: unknown) => string;
 
+export declare interface SnapshotComponentSource {
+    readonly content: SnapshotContentIdentity;
+    readonly fieldPath: ReadonlyArray<string | number>;
+    /** The original placed instance, or rich block id; null when not projected. */
+    readonly instanceId: string | null;
+    /** Paths are relative to this component's props, never document ids. */
+    readonly link: (fieldPath: ReadonlyArray<string | number>) => string | null;
+    readonly reference: (fieldPath: ReadonlyArray<string | number>) => SnapshotContentData | null;
+}
+
+export declare type SnapshotConsentPurpose = Pick<ConsentPurpose, 'id' | 'version'>;
+
+export declare interface SnapshotContentData {
+    readonly content: SnapshotContentIdentity;
+    readonly context: FrontendOutputContext;
+    readonly sourceLocale: string;
+    readonly fallback: boolean;
+    readonly values: Readonly<Record<string, unknown>>;
+    readonly media: ReadonlyArray<FrontendMedia>;
+    readonly presentation: SnapshotPresentation;
+    readonly consentPurposes: ReadonlyArray<SnapshotConsentPurpose>;
+}
+
+export declare interface SnapshotContentIdentity {
+    readonly contentType: string;
+    readonly documentId: string;
+    readonly variantId: string;
+    readonly revisionId: string;
+    readonly revision: number;
+}
+
+/** Resolve a projected reference using the application's captured referenceRoutes. */
+export declare const snapshotLink: (data: SnapshotContentData, fieldPath: ReadonlyArray<string | number>) => string | null;
+
+/** Read only an already staged representation and record its actual source occurrence. */
+export declare const snapshotMedia: (data: SnapshotContentData, fieldPath: ReadonlyArray<string | number>, output?: FrontendMediaOutput) => FrontendMediaFile | null;
+
+export declare interface SnapshotPageData extends SnapshotContentData {
+    readonly version: 6;
+    readonly path: string;
+    readonly seo: SnapshotPageSeo;
+    readonly bindings: Readonly<Record<string, SnapshotContentData | null>>;
+}
+
+export declare const snapshotPageLoader: (context: {
+    readonly pathname: string;
+    readonly query?: <T>(tag: string, input: Record<string, unknown>) => Promise<T>;
+}) => Promise<SnapshotPageData>;
+
+/** Structural PageMeta: the native renderer owns HTML and JSON-LD escaping. */
+export declare const snapshotPageMeta: ({ loaderData }: {
+    readonly loaderData: {
+        readonly seo: SnapshotPageSeo;
+    };
+}) => {
+    tags: {
+        name?: string;
+        property?: string;
+        content: string;
+    }[];
+    links: {
+        rel: string;
+        hreflang: string;
+        href: string;
+    }[];
+    jsonLd: ({
+        datePublished?: string;
+        description?: string;
+        image?: string;
+        inLanguage: string;
+        url?: string;
+        name: string;
+        '@context': string;
+        '@type': "WebPage" | "Article" | "BlogPosting";
+    } | {
+        datePublished?: string;
+        description?: string;
+        image?: string;
+        inLanguage: string;
+        url?: string;
+        headline: string;
+        '@context': string;
+        '@type': "WebPage" | "Article" | "BlogPosting";
+    })[];
+    canonical?: string;
+    description?: string;
+    title?: string;
+};
+
+export declare interface SnapshotPageSeo {
+    readonly title: string | null;
+    readonly description: string | null;
+    readonly canonical: string | null;
+    readonly alternates: ReadonlyArray<{
+        readonly locale: string;
+        readonly href: string;
+    }>;
+    readonly xDefault: string | null;
+    readonly languageTag: string;
+    readonly robots: SeoRobotsPolicy;
+    readonly social: {
+        readonly title: string | null;
+        readonly description: string | null;
+        readonly image?: {
+            readonly url: string;
+            readonly contentType: string;
+        };
+    };
+    readonly structuredData: ResolvedContentSeo['structuredData'];
+}
+
+export declare interface SnapshotPresentation {
+    readonly version: 1;
+    readonly decided: boolean;
+    readonly granted: ReadonlyArray<SnapshotConsentPurpose>;
+}
+
+/** Cookie decoding belongs to the application. Retain the existing exact-version
+ * consent decision, ignoring inherited properties and unknown purpose names. */
+export declare const snapshotPresentationFromChoices: (purposes: ReadonlyArray<SnapshotConsentPurpose>, choices: ConsentChoices | undefined) => SnapshotPresentation;
+
+/** Complete finite public classes, including never-decided and explicit denial.
+ * Refuse a build that cannot retain all classes within its declared budget. */
+export declare const snapshotPresentations: (purposes: ReadonlyArray<SnapshotConsentPurpose>, maximum?: number) => ReadonlyArray<SnapshotPresentation>;
+
+export declare class SnapshotPresentationUnavailable extends SnapshotPresentationUnavailable_base {
+}
+
+declare const SnapshotPresentationUnavailable_base: Schema_2.Class<SnapshotPresentationUnavailable, Schema_2.TaggedStruct<"SnapshotPresentationUnavailable", {
+    readonly reason: Schema_2.Literals<readonly ["policy", "selection", "bounds"]>;
+}>, YieldableError>;
+
+export declare const snapshotReference: (data: SnapshotContentData, fieldPath: ReadonlyArray<string | number>) => SnapshotContentData | null;
+
+export declare const snapshotRichDocumentProps: (data: SnapshotContentData, fieldPath: ReadonlyArray<string | number>, options: {
+    readonly bindings: FrontendBindings;
+    /** Resolve the exact projected reference scalar path, including the source field prefix. */
+    readonly hrefOf?: (fieldPath: ReadonlyArray<string | number>) => string | null | undefined;
+    /** Resolve a managed contact occurrence through its independently admitted target. */
+    readonly contactHrefOf?: (fieldPath: ReadonlyArray<string | number>) => string | null | undefined;
+    readonly imageOutput?: FrontendMediaOutput;
+    readonly renderImage: (block: {
+        readonly asset: string;
+        readonly caption?: string;
+    }, file: FrontendMediaFile, context: SnapshotRichImageContext) => ReactNode;
+}) => RichDocumentViewProps;
+
+export declare interface SnapshotRichImageContext extends RichDocumentBlockContext {
+    /** Exact asset reference field, including the source document field prefix. */
+    readonly fieldPath: ReadonlyArray<string | number>;
+}
+
+export declare interface SnapshotTreeData {
+    readonly version: 1;
+    readonly contentType: string;
+    readonly localeId: string;
+    readonly requestedLocale: string;
+    readonly currentDocumentId: string | null;
+    readonly nodes: ReadonlyArray<SnapshotTreeNode>;
+    /** Root-first public ancestors of the current document, independent of includeField. */
+    readonly ancestors: ReadonlyArray<SnapshotTreeNode>;
+}
+
+export declare const snapshotTreeLoader: (context: {
+    readonly pathname: string;
+    readonly query?: <T>(tag: string, input: Record<string, unknown>) => Promise<T>;
+}, name: string) => Promise<SnapshotTreeData>;
+
+export declare interface SnapshotTreeNode {
+    readonly documentId: string;
+    readonly parent: string | null;
+    readonly depth: number;
+    readonly path: string;
+    readonly sourceLocale: string;
+    readonly fallback: boolean;
+    readonly values: Readonly<Record<string, unknown>>;
+}
+
+export declare interface SnapshotTreeSelection {
+    readonly contentType: string;
+    readonly mappingId: string;
+    readonly fields: ReadonlyArray<string>;
+    /** Include only true nodes whose ancestors also match this Boolean field. */
+    readonly includeField?: string;
+}
+
 /** Mark an element of the preview with the field path it renders. */
 export declare const sourceAttributes: (path: string) => {
     readonly "data-cms-source": string;