@voltro/cms 0.85.0 → 0.87.0

package/dist/index.d.ts

@@ -1,17 +1,33 @@
+import { ApiWorkload } from '@voltro/protocol';
 import { DataStore } from '@voltro/database';
 import { Effect } from 'effect/Effect';
 import { Effect as Effect_2 } from 'effect';
+import { PluginHttpRouteByteStream } from '@voltro/protocol';
+import { PluginHttpRouteRequest } from '@voltro/protocol';
+import { PluginHttpRouteResult } from '@voltro/protocol';
+import { PluginHttpRouteStream } from '@voltro/protocol';
+import { PluginHttpRouteStreamRequest } from '@voltro/protocol';
+import { PublicApiDescriptor } from '@voltro/protocol/rest';
 import { ReactNode } from 'react';
+import { RestCache } from '@voltro/protocol/rest';
+import { RestCors } from '@voltro/protocol/rest';
+import { RestGuard } from '@voltro/protocol/rest';
+import { RestMethod } from '@voltro/protocol/rest';
+import { RestRateLimit } from '@voltro/protocol/rest';
+import { RestRouteContext } from '@voltro/protocol/rest';
+import { RestRouteDescriptor } from '@voltro/protocol/rest';
+import { RestRouteExample } from '@voltro/protocol/rest';
+import { RestRouteProjection } from '@voltro/protocol/rest';
 import { Row } from '@voltro/database';
 import { Schema as Schema_2 } from 'effect';
 import { TableLike } from '@voltro/database';
 import { YieldableError } from 'effect/Cause';
 
 /** Effect form of {@link addDomain}. */
-export declare const addDomain: (...args: Parameters<typeof addDomain_2>) => Effect<AddDomainResult, never, never>;
+export declare const addDomain: (...args: Parameters<typeof addDomain_2>) => Effect<AddDomainResult, SiteStateUnavailable, never>;
 
 /** Add a host to a site, pending until its TXT record is found. A host belongs to one site anywhere. */
-declare const addDomain_2: (tx: DataStore, site: string, input: string) => Promise<AddDomainResult>;
+declare const addDomain_2: (tx: DataStore, scope: CmsSiteScope, input: string) => Promise<AddDomainResult>;
 
 export declare type AddDomainResult = {
     readonly ok: true;
@@ -22,7 +38,7 @@ export declare type AddDomainResult = {
 };
 
 /** Effect form of {@link addRedirect}. */
-export declare const addRedirect: (...args: Parameters<typeof addRedirect_2>) => Effect<void, never, never>;
+export declare const addRedirect: (...args: Parameters<typeof addRedirect_2>) => Effect<void, ChangeFeedUnavailable, never>;
 
 /**
  * Point a former address at a document — an address from before an import, a
@@ -30,7 +46,7 @@ export declare const addRedirect: (...args: Parameters<typeof addRedirect_2>) =>
  * `fromPath` still wins over it (`cms.route` tries the tree first). In the
  * caller's transaction.
  */
-declare const addRedirect_2: (tx: DataStore, type: ContentType, scope: CmsScope, fromPath: string, documentId: string, tenantId?: unknown) => Promise<void>;
+declare const addRedirect_2: (tx: DataStore, type: ContentType, scope: CmsScope, fromPath: string, documentId: string, tenantId: unknown) => Promise<void>;
 
 /** Effect form of {@link addToCollection}. */
 export declare const addToCollection: (...args: Parameters<typeof addToCollection_2>) => Effect<boolean, never, never>;
@@ -223,7 +239,7 @@ export declare type AppliedSelection = {
 };
 
 /** Effect form of {@link applyBlueprint}. */
-export declare const applyBlueprint: (...args: Parameters<typeof applyBlueprint_2>) => Effect<BlueprintPlan, ContentValidationFailed | ContentNotFound | ContentIdConflict | RevisionMismatch | ReviewRequired | ReferenceUnavailable | BlueprintInvalid, never>;
+export declare const applyBlueprint: (...args: Parameters<typeof applyBlueprint_2>) => Effect<BlueprintPlan, ContentValidationFailed | ContentNotFound | ContentIdConflict | RevisionMismatch | ReviewRequired | ReferenceUnavailable | ChangeFeedUnavailable | BlueprintInvalid, never>;
 
 /**
  * Provision `blueprint` into `target`: every step the plan calls `create` is
@@ -300,7 +316,7 @@ export declare const approveReview: (...args: Parameters<typeof approveReview_2>
 declare const approveReview_2: (store: DataStore, type: ContentType, variantId: string, scope: CmsScope, options: DecideOptions) => Promise<Row>;
 
 /** Effect-native `archive` (see {@link saveDraftEffect}). */
-export declare const archive: (store: DataStore, type: ContentType, id: string, scope: CmsScope) => Effect_2.Effect<void, ContentNotFound>;
+export declare const archive: (store: DataStore, type: ContentType, id: string, scope: CmsScope) => Effect_2.Effect<void, ContentNotFound | ChangeFeedUnavailable | PublicRouteRegistryUnavailable>;
 
 /** Effect form of {@link assertApproved}. */
 export declare const assertApproved: (...args: Parameters<typeof assertApproved_2>) => Effect<void, ReviewRequired, never>;
@@ -321,6 +337,12 @@ export declare const assertReferencesAvailable: (...args: Parameters<typeof asse
  */
 declare const assertReferencesAvailable_2: (tx: DataStore, type: ContentType, variantId: string, values: Readonly<Record<string, unknown>>, scope: CmsScope, now?: Date) => Promise<void>;
 
+/** Declares the original-file field of a versioned asset document. It does
+ * not imply ingestion, creative approval, rights or public delivery fitness. */
+export declare interface AssetConfig {
+    readonly file: string;
+}
+
 /** The version a reader is shown: the same reader, the same version, every time. */
 export declare const assignVariant: (experimentId: string, readerId: string, share: number) => Variant;
 
@@ -397,6 +419,15 @@ export declare const bindExtensionSecret: (...args: Parameters<typeof bindExtens
  */
 declare const bindExtensionSecret_2: (tx: DataStore, extensionId: string, name: string, value: string | null) => Promise<SecretBinding>;
 
+export declare const bindSiteContent: (...args: Parameters<typeof bindSiteContent_2>) => Effect<SiteContentBinding, ChangeFeedUnavailable | SiteBindingUnavailable, never>;
+
+/** Create with expectedRevisionId:null, or replace the exact revision observed. Caller authorizes the binding and target type. */
+declare const bindSiteContent_2: (tx: DataStore, types: ReadonlyArray<ContentType>, scope: ChangeFeedScope, name: string, input: {
+    readonly expectedRevisionId: string | null;
+    readonly contentType: string;
+    readonly documentId: string;
+}) => Promise<SiteContentBinding>;
+
 /** Whether a block, or any text in it, holds a suggestion. */
 export declare const blockHasChanges: (block: RichBlock) => boolean;
 
@@ -497,6 +528,8 @@ export declare interface BlueprintTeam {
  * 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;
 
@@ -664,6 +697,21 @@ export declare interface ChangeEntry {
     readonly releaseId: string | null;
 }
 
+/** One independently resumable publication stream. Tenant must be explicit. */
+export declare interface ChangeFeedScope {
+    readonly tenantId: string;
+    readonly site: string;
+    readonly environment: 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>;
+
 export declare interface ChangeOrigin {
     /** The release applying this change. */
     readonly releaseId?: string;
@@ -686,6 +734,9 @@ export declare const CMS_AVAILABILITY_TABLE = "cms_availability";
 
 export declare const CMS_BULK_RUNS_TABLE = "cms_bulk_runs";
 
+/** Internal coordination, never an editor's inverse/redo operation. */
+export declare const CMS_CHANGE_HEADS_TABLE = "_voltro_cms_change_heads";
+
 export declare const CMS_CHANGES_TABLE = "cms_changes";
 
 export declare const CMS_COLLECTION_ITEMS_TABLE = "cms_collection_items";
@@ -704,6 +755,10 @@ export declare const CMS_DELIVERY_CHECKS_TABLE = "cms_delivery_checks";
 
 export declare const CMS_DRAFT_TEXTS_TABLE = "cms_draft_texts";
 
+export declare const CMS_ENVIRONMENT_ALIAS_REVISIONS_TABLE = "cms_environment_alias_revisions";
+
+export declare const CMS_ENVIRONMENT_ALIASES_TABLE = "cms_environment_aliases";
+
 export declare const CMS_EXPERIMENT_EVENTS_TABLE = "cms_experiment_events";
 
 export declare const CMS_EXPERIMENTS_TABLE = "cms_experiments";
@@ -731,7 +786,7 @@ export declare const CMS_QUALITY_EXCEPTIONS_TABLE = "cms_quality_exceptions";
 
 export declare const CMS_REDIRECTS_TABLE = "cms_redirects";
 
-/** The system table holding the reference edges of every published variant. */
+/** The system table holding scoped published, draft and revision edges. */
 export declare const CMS_REFERENCES_TABLE = "cms_references";
 
 export declare const CMS_RELEASE_ITEMS_TABLE = "cms_release_items";
@@ -749,8 +804,14 @@ export declare const CMS_SCOPE_COLUMNS: readonly ["site", "environment", "locale
 
 export declare const CMS_SEARCH_TABLE = "cms_search";
 
+export declare const CMS_SITE_BINDING_REVISIONS_TABLE = "cms_site_binding_revisions";
+
+export declare const CMS_SITE_BINDINGS_TABLE = "cms_site_bindings";
+
 export declare const CMS_SITE_DOMAINS_TABLE = "cms_site_domains";
 
+export declare const CMS_SITE_STATE_HEADS_TABLE = "_voltro_cms_site_state_heads";
+
 export declare const CMS_STEWARDSHIP_TABLE = "cms_stewardship";
 
 export declare const CMS_TEAM_INVITATIONS_TABLE = "cms_team_invitations";
@@ -828,6 +889,8 @@ export declare const cmsAvailabilityTable: TableLike;
 /** A bulk run as a durable record: what it does, the plan, and each item's result so far. */
 export declare const cmsBulkRunsTable: TableLike;
 
+export declare const cmsChangeHeadsTable: TableLike;
+
 export declare const cmsChangesTable: TableLike;
 
 export declare const cmsCollectionItemsTable: TableLike;
@@ -857,6 +920,10 @@ export declare const cmsDeliveryChecksTable: TableLike;
 /** One text field of one draft (a document in one language), as a CRDT text. */
 export declare const cmsDraftTextsTable: TableLike;
 
+export declare const cmsEnvironmentAliasesTable: TableLike;
+
+export declare const cmsEnvironmentAliasRevisionsTable: TableLike;
+
 export declare const cmsExperimentEventsTable: TableLike;
 
 export declare const cmsExperimentsTable: TableLike;
@@ -902,6 +969,34 @@ export declare const cmsPathsTable: TableLike;
  */
 export declare const cmsPreviewSharesTable: TableLike;
 
+export declare interface CmsPublicPresentations {
+    readonly consentPurposes: ReadonlyArray<SnapshotConsentPurpose>;
+    readonly presentations: ReadonlyArray<SnapshotPresentation>;
+}
+
+export declare interface CmsPublicPresentationTarget {
+    readonly host: string;
+    readonly path: string;
+    readonly presentation: SnapshotPresentation;
+}
+
+/** Use actual registered content types, approved site profiles and retained
+ * native discovery from the server application, never request-authored JSON. */
+export declare interface CmsPublicRouteDeclaration {
+    readonly types: ReadonlyArray<ContentType>;
+    readonly site: SiteDeliveryDefinition;
+    /** Explicit null admits only CMS locations, with no native routing/discovery. */
+    readonly code: SnapshotAppCodePin | null;
+    readonly routing: SnapshotRoutingDefinition | null;
+    readonly routeDiscovery: unknown;
+}
+
+export declare interface CmsPublicRouteInitialization {
+    readonly revision: number;
+}
+
+export declare const cmsPublicRouteTables: readonly [ TableLike, TableLike, TableLike, TableLike, TableLike, TableLike];
+
 /** One repeating live window per draft: its rule, and the occurrence armed last (-1: none yet). */
 export declare const cmsPublishSeriesTable: TableLike;
 
@@ -910,12 +1005,6 @@ export declare const cmsQualityExceptionsTable: TableLike;
 /** A former address and the document now answering it. */
 export declare const cmsRedirectsTable: TableLike;
 
-/**
- * One row per reference a published variant makes: the source (type,
- * document, variant, scope), where in its values the reference sits (`path`)
- * and the target document. Tenant-scoped. Register it in the app's
- * `databaseHandle` beside `cmsRevisionsTable`.
- */
 export declare const cmsReferencesTable: TableLike;
 
 /** One variant in a release: publish its pinned revision, or unpublish it. */
@@ -979,6 +1068,109 @@ export declare const cmsReviewsTable: TableLike;
  */
 export declare const cmsRevisionsTable: TableLike;
 
+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;
+}
+
+/** Dedicated organization API-key exchange. Mount only httpRoutes through the
+ * plugin HTTP seam and pass routes to OpenAPI; no generic idempotency cache or
+ * ambient Subject authorizes publisher decisions. */
+export declare const cmsRouteDispositionRest: (service: CmsRouteDispositions) => {
+    routes: {
+        guards: RestGuard[];
+        maxBodyBytes: number;
+        publicApiDescriptor?: PublicApiDescriptor;
+        method: RestMethod;
+        path: string;
+        input?: Schema_2.Codec<Record<string, unknown>, any, never, never>;
+        output: Schema_2.Codec<unknown, any, never, never>;
+        handler: (input: Record<string, unknown>, ctx: RestRouteContext) => unknown;
+        mapFailure?: (error: unknown, request: Pick< PluginHttpRouteRequest, "method" | "path" | "query">) => unknown;
+        summary?: string;
+        description?: string;
+        example?: RestRouteExample;
+        operationId?: string;
+        tags?: ReadonlyArray<string>;
+        projection?: RestRouteProjection;
+        deprecated?: string;
+        sunset?: string;
+        version?: `v${number}`;
+        cors?: RestCors;
+        credentials?: "bearer";
+        rateLimit?: RestRateLimit;
+        streaming?: boolean;
+        etag?: boolean;
+        cache?: RestCache;
+    }[];
+    httpRoutes: {
+        handle: (req: PluginHttpRouteRequest) => Promise<{
+            headers: {
+                'www-authenticate'?: string;
+                'cache-control': string;
+                pragma: string;
+                vary: string;
+            };
+            status: number;
+            body?: string | Uint8Array;
+            contentType?: string;
+            stream?: PluginHttpRouteStream;
+            cause?: unknown;
+            byteStream?: PluginHttpRouteByteStream;
+        }>;
+        workload?: ApiWorkload;
+        restContract?: RestRouteDescriptor<any, any>;
+        method: "*" | "GET" | "POST" | "PUT" | "PATCH" | "DELETE" | "HEAD" | "OPTIONS";
+        answersOtherMethods?: boolean | undefined;
+        path: string;
+        match?: "prefix" | "exact";
+        handleStream?: (req: PluginHttpRouteStreamRequest) => Promise< PluginHttpRouteResult>;
+        maxBodyBytes?: number;
+        originGuard?: "exempt";
+        cors?: RestCors;
+        credentials?: "bearer";
+    }[];
+};
+
+export declare interface CmsRouteDispositions {
+    readonly approve: (request: {
+        readonly apiKey: string;
+        readonly expectedRevision: number;
+        readonly definition: RouteDispositionDefinition;
+    }) => Effect_2.Effect<CmsRouteDispositionApproval, RouteDispositionUnavailable>;
+    readonly list: (request: {
+        readonly apiKey: string;
+        readonly expectedRevision?: number;
+        readonly after?: string;
+        readonly take?: number;
+    }) => Effect_2.Effect<CmsRouteDispositionPage, RouteDispositionUnavailable>;
+}
+
+export declare interface CmsRouteDispositionsOptions {
+    readonly store: DataStore;
+    readonly scope: ChangeFeedScope;
+    readonly approvalScope: string;
+    readonly readScope: string;
+    readonly now?: () => number;
+}
+
+/** Private approval state and history, never anonymous delivery projections. */
+export declare const cmsRouteDispositionTables: ReadonlyArray<TableLike>;
+
 /**
  * Where a content row lives besides its tenant: the site it belongs to, the
  * content environment (e.g. `production`, `staging`) and its locale. Three
@@ -995,8 +1187,19 @@ export declare interface CmsScope {
 
 export declare const cmsSearchTable: TableLike;
 
+export declare const cmsSiteBindingRevisionsTable: TableLike;
+
+export declare const cmsSiteBindingsTable: TableLike;
+
 export declare const cmsSiteDomainsTable: TableLike;
 
+export declare interface CmsSiteScope {
+    readonly tenantId: string;
+    readonly site: string;
+}
+
+export declare const cmsSiteStateHeadsTable: TableLike;
+
 export declare const cmsStewardshipTable: TableLike;
 
 /** Who is invited with which role. */
@@ -1072,6 +1275,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';
 }>;
@@ -1140,6 +1357,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>;
 
@@ -1399,6 +1621,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
@@ -1440,6 +1692,60 @@ export declare interface ContentQuery {
     }>;
 }
 
+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>;
+
 export declare type ContentStatus = (typeof CONTENT_STATUSES)[number];
 
 /** A registered content type. */
@@ -1448,6 +1754,8 @@ export declare interface ContentType {
     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
@@ -1457,6 +1765,12 @@ export 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';
@@ -1488,6 +1802,8 @@ export 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;
@@ -1505,6 +1821,12 @@ export 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,
@@ -1543,7 +1865,8 @@ export 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;
     /**
@@ -1704,7 +2027,7 @@ export declare type CopyDocumentResult = {
 };
 
 /** Effect form of {@link copyEnvironment}. */
-export declare const copyEnvironment: (...args: Parameters<typeof copyEnvironment_2>) => Effect<CopyEnvironmentResult, never, never>;
+export declare const copyEnvironment: (...args: Parameters<typeof copyEnvironment_2>) => Effect<CopyEnvironmentResult, PublicRouteRegistryUnavailable | ChangeFeedUnavailable, never>;
 
 /**
  * Fill `to` from `from`, within one site. Refused unless `to` holds no variant
@@ -1736,6 +2059,8 @@ export declare const copyOrigin: (...args: Parameters<typeof copyOrigin_2>) => E
 /** What a document was copied from, or null when it is an original. */
 declare const copyOrigin_2: (store: DataStore, documentId: string) => Promise<CopyOrigin | null>;
 
+export declare const copyRouteDispositionDefinition: (value: unknown) => RouteDispositionDefinition;
+
 /**
  * A standalone CMS client for build-time consumption (the blog
  * template's CMS mode), where there is no request handle. Same surface
@@ -1748,6 +2073,8 @@ export declare const createCmsClient: (config: {
     secret?: string;
 }) => CmsApi;
 
+export declare const createCmsRouteDispositions: (configured: CmsRouteDispositionsOptions) => CmsRouteDispositions;
+
 /** Effect form of {@link createCollection}. */
 export declare const createCollection: (...args: Parameters<typeof createCollection_2>) => Effect<Collection, never, never>;
 
@@ -1757,6 +2084,14 @@ declare const createCollection_2: (tx: DataStore, scope: Pick<CmsScope, "site" |
     readonly description?: string;
 }) => Promise<Collection>;
 
+export declare const createEnvironmentAlias: (...args: Parameters<typeof createEnvironmentAlias_2>) => Effect<EnvironmentAlias, EnvironmentAliasUnavailable, never>;
+
+/** Create a stable name pointing directly at a configured physical environment. */
+declare const createEnvironmentAlias_2: (tx: DataStore, scope: EnvironmentAliasScope, environments: ReadonlyArray<string>, input: {
+    readonly name: string;
+    readonly environment: string;
+}) => Promise<EnvironmentAlias>;
+
 /** Effect form of {@link createPortal}. */
 export declare const createPortal: (...args: Parameters<typeof createPortal_2>) => Effect<CreatePortalResult, never, never>;
 
@@ -2011,6 +2346,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;
+
 export declare const defineContentType: (spec: ContentTypeSpec) => ContentType;
 
 /**
@@ -2050,6 +2394,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;
+
 /** Effect form of {@link delegateStep}. */
 export declare const delegateStep: (...args: Parameters<typeof delegateStep_2>) => Effect<{
     readonly ok: true;
@@ -2330,6 +2681,40 @@ export declare const emptyRichDocument: () => RichDocument;
 /** The intent as a URL parameter value (`?select=…`). */
 export declare const encodeSelectionIntent: (intent: SelectionIntent) => string;
 
+export declare interface EnvironmentAlias {
+    readonly id: string;
+    readonly name: string;
+    readonly environment: string;
+    readonly revisionId: string;
+}
+
+export declare interface EnvironmentAliasRevision {
+    readonly id: string;
+    readonly aliasId: string;
+    readonly environment: string;
+    readonly previousRevisionId: string | null;
+    readonly action: 'created' | 'swapped' | 'rolledBack';
+    readonly sourceRevisionId: string | null;
+}
+
+export declare const environmentAliasRevision: (...args: Parameters<typeof environmentAliasRevision_2>) => Effect<EnvironmentAliasRevision, EnvironmentAliasUnavailable, never>;
+
+/** Read a revision of this alias only; previousRevisionId supports bounded history traversal. */
+declare const environmentAliasRevision_2: (store: DataStore, scope: EnvironmentAliasScope, name: string, revisionId: string) => Promise<EnvironmentAliasRevision>;
+
+export declare interface EnvironmentAliasScope {
+    readonly tenantId: string;
+    readonly site: 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>;
+
 export declare interface EnvironmentDifference {
     readonly contentType: string;
     /** Documents (with a variant) in `from` only, and in `to` only. */
@@ -2798,7 +3183,7 @@ export declare const glossaryProblems: (text: string, entries: ReadonlyArray<Glo
 }>;
 
 /** 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>;
 
 /** Which content the graph is read from. */
 export declare type GraphPerspective = 'published' | 'draft' | {
@@ -2922,6 +3307,23 @@ export declare interface InheritRule {
     readonly mask?: string;
 }
 
+/** Effect form of the explicit deployment upgrade. */
+export declare const initializeChangeFeed: (...args: Parameters<typeof initializeChangeFeed_2>) => Effect<number, ChangeFeedUnavailable, never>;
+
+/**
+ * One-time additive upgrade, IN THE CALLER'S TRANSACTION, with old writers
+ * stopped. Retains historical IDs/order. Never resequences an issued position.
+ * Bounded batches keep migration memory independent of the backlog size.
+ */
+declare const initializeChangeFeed_2: (tx: DataStore, scope: ChangeFeedScope) => Promise<number>;
+
+/** In the caller's transaction with cmsPublicRouteTables and ordinary CMS
+ * revision/change/path tables applied. Existing unknown history refuses;
+ * identical initialization is idempotent, configuration changes hold. */
+export declare const initializeCmsPublicRoutes: (tx: DataStore, scope: ChangeFeedScope, declaration: CmsPublicRouteDeclaration, options?: {
+    readonly now?: number;
+}) => Effect<CmsPublicRouteInitialization, PublicRouteRegistryUnavailable | ChangeFeedUnavailable | SiteStateUnavailable, never>;
+
 /** The minimal DOM a surface is read from (a browser element, or jsdom's). */
 export declare interface InlineDomNode {
     readonly nodeType: number;
@@ -3660,13 +4062,13 @@ export declare const previewToken: (type: string, id: string, options?: {
 }) => string;
 
 /** Effect form of {@link primaryDomain}. */
-export declare const primaryDomain: (...args: Parameters<typeof primaryDomain_2>) => Effect<string | null, never, never>;
+export declare const primaryDomain: (...args: Parameters<typeof primaryDomain_2>) => Effect<string | null, SiteStateUnavailable, never>;
 
 /** The site's primary domain, or null. */
-declare const primaryDomain_2: (store: DataStore, site: string) => Promise<string | null>;
+declare const primaryDomain_2: (store: DataStore, scope: CmsSiteScope) => Promise<string | null>;
 
 /** Effect form of {@link promote}. */
-export declare const promote: (...args: Parameters<typeof promote_2>) => Effect<PromotionResult, ContentValidationFailed | ContentNotFound | ContentIdConflict | RevisionMismatch | ReleaseNotEditable | ReviewRequired | ReferenceUnavailable, never>;
+export declare const promote: (...args: Parameters<typeof promote_2>) => Effect<PromotionResult, PublicRouteRegistryUnavailable | ContentValidationFailed | ContentNotFound | ContentIdConflict | RevisionMismatch | ReleaseNotEditable | ReviewRequired | ReferenceUnavailable | ChangeFeedUnavailable, never>;
 
 /**
  * Promote the chosen documents from `pair.from` into `pair.to` as one release
@@ -3727,11 +4129,23 @@ declare const proposeCandidate_2: (tx: DataStore, type: ContentType, variantId:
     readonly reason: "notFound" | "empty";
 }>;
 
+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>;
+
 /** Effect-native `publish` (see {@link saveDraftEffect}). */
-export declare const publish: (store: DataStore, type: ContentType, id: string, scope: CmsScope, options?: PublishOptions) => Effect_2.Effect<Row, ContentNotFound | RevisionMismatch | ReviewRequired | ReferenceUnavailable | ContentValidationFailed>;
+export declare const publish: (store: DataStore, type: ContentType, id: string, scope: CmsScope, options?: PublishOptions) => Effect_2.Effect<Row, ContentNotFound | RevisionMismatch | ReviewRequired | ReferenceUnavailable | ContentValidationFailed | ChangeFeedUnavailable | PublicRouteRegistryUnavailable>;
 
 /** Effect form of {@link publishDue}. */
-export declare const publishDue: (...args: Parameters<typeof publishDue_2>) => Effect<readonly string[], never, never>;
+export declare const publishDue: (...args: Parameters<typeof publishDue_2>) => Effect<readonly string[], ContentValidationFailed | ChangeFeedUnavailable, never>;
 
 /**
  * Publish every draft of `type` whose scheduled `publishAt` has passed
@@ -3771,7 +4185,7 @@ export declare interface PublishOptions {
 }
 
 /** Effect form of {@link publishRelease}. */
-export declare const publishRelease: (...args: Parameters<typeof publishRelease_2>) => Effect<Readonly<Record<string, unknown>>, ContentNotFound | ReleaseNotEditable | ReviewRequired | ReferenceUnavailable, never>;
+export declare const publishRelease: (...args: Parameters<typeof publishRelease_2>) => Effect<Readonly<Record<string, unknown>>, PublicRouteRegistryUnavailable | ContentNotFound | ReleaseNotEditable | ReviewRequired | ReferenceUnavailable | ChangeFeedUnavailable, never>;
 
 declare const publishRelease_2: (tx: DataStore, types: ReadonlyArray<ContentType>, releaseId: string, now?: Date, options?: PublishReleaseOptions) => Promise<Row>;
 
@@ -3780,7 +4194,7 @@ export declare interface PublishReleaseOptions {
 }
 
 /** Effect-native `publishRevision` (see {@link saveDraftEffect}). */
-export declare const publishRevision: (tx: DataStore, type: ContentType, id: string, scope: CmsScope, revisionId: string, origin?: ChangeOrigin) => Effect_2.Effect<Row, ContentNotFound | RevisionMismatch | ReviewRequired | ReferenceUnavailable | ContentValidationFailed>;
+export declare const publishRevision: (tx: DataStore, type: ContentType, id: string, scope: CmsScope, revisionId: string, origin?: ChangeOrigin) => Effect_2.Effect<Row, ContentNotFound | RevisionMismatch | ReviewRequired | ReferenceUnavailable | ContentValidationFailed | ChangeFeedUnavailable | PublicRouteRegistryUnavailable>;
 
 /** A series as the editor shows it. */
 export declare interface PublishSeries {
@@ -3919,18 +4333,24 @@ declare const QuotaExceeded_base: Schema_2.Class<QuotaExceeded, Schema_2.TaggedS
     readonly used: Schema_2.Number;
 }>, YieldableError>;
 
+/** Effect form of the latest committed checkpoint. */
+export declare const readChangeCheckpoint: (...args: Parameters<typeof readChangeCheckpoint_2>) => Effect<string | null, ChangeFeedUnavailable, never>;
+
+/** Latest committed change ID; ordinary consumer reads do not take write locks. */
+declare const readChangeCheckpoint_2: (store: DataStore, place: ChangeFeedScope) => Promise<string | null>;
+
 /** Effect form of {@link readChanges}. */
 export declare const readChanges: (...args: Parameters<typeof readChanges_2>) => Effect<{
     readonly items: ReadonlyArray<ChangeEntry>;
     readonly next: string | null;
-}, never, never>;
+}, ChangeFeedUnavailable, never>;
 
 /**
  * The changes in a site and environment after `after`, oldest first. Keep
  * `next` and pass it as `after` next time; it stays put when nothing new has
  * settled, so polling with it never skips.
  */
-declare const readChanges_2: (store: DataStore, place: Pick<CmsScope, "site" | "environment">, options?: ReadChangesOptions) => Promise<{
+declare const readChanges_2: (store: DataStore, place: ChangeFeedScope, options?: ReadChangesOptions) => Promise<{
     readonly items: ReadonlyArray<ChangeEntry>;
     readonly next: string | null;
 }>;
@@ -3938,9 +4358,11 @@ declare const readChanges_2: (store: DataStore, place: Pick<CmsScope, "site" | "
 export declare interface ReadChangesOptions {
     /** The `next` of the previous read; omit to start at the beginning. */
     readonly after?: string;
+    /** Inclusive upper checkpoint from readChangeCheckpoint; later commits wait for the next scan. */
+    readonly through?: string;
     /** At most this many (default 100). */
     readonly limit?: number;
-    /** Leave out changes younger than this (default 2000 ms) — see the file header. */
+    /** Pause at the first change younger than this (default 2000 ms); 0 disables freshness waiting. */
     readonly settleMs?: number;
     /** Equality filters, e.g. the tenant for a reader that carries none. */
     readonly filter?: Readonly<Record<string, unknown>>;
@@ -3959,6 +4381,12 @@ export declare const readEditorMessage: (event: VisualMessageEvent, session: Vis
 /** The preview's message, or null for anything else (another origin, another session, another shape). */
 export declare const readPreviewMessage: (event: VisualMessageEvent, session: VisualSession) => PreviewMessage | null;
 
+/** Effect form of the bounded editorial history. */
+export declare const readRecentChanges: (...args: Parameters<typeof readRecentChanges_2>) => Effect<readonly ChangeEntry[], ChangeFeedUnavailable, never>;
+
+/** Bounded editorial history, newest committed position first, without freshness waiting. */
+declare const readRecentChanges_2: (store: DataStore, place: ChangeFeedScope, limit?: number) => Promise<ReadonlyArray<ChangeEntry>>;
+
 /**
  * What a reader gets at an address: the revision id it carries, `gone` when it
  * answers without content (404/410), or an HTTP status as text. The app
@@ -3975,6 +4403,16 @@ export declare const rebaseDraftTexts: (...args: Parameters<typeof rebaseDraftTe
 /** After a save: the texts belong to the new revision. In the caller's transaction. */
 declare const rebaseDraftTexts_2: (tx: DataStore, rows: ReadonlyArray<Row>, revisionId: string) => Promise<void>;
 
+/** Effect form of {@link rebuildReferenceIndex}. */
+export declare const rebuildReferenceIndex: (...args: Parameters<typeof rebuildReferenceIndex_2>) => Effect<void, never, never>;
+
+/**
+ * Rebuild draft/history edges after schema application for existing content or
+ * changed reference declarations. Run inside the caller's transaction, with
+ * the same tenant-scoped store used for content writes. Published edges stay.
+ */
+declare const rebuildReferenceIndex_2: (store: DataStore, types: ReadonlyArray<ContentType>, scope: Pick<CmsScope, "site" | "environment">) => Promise<void>;
+
 /** Effect form of {@link rebuildSearch}. */
 export declare const rebuildSearch: (...args: Parameters<typeof rebuildSearch_2>) => Effect<number, never, never>;
 
@@ -4000,6 +4438,27 @@ declare const recertify_2: (store: DataStore, type: ContentType, documentId: str
     readonly now?: Date;
 }) => Promise<Stewardship>;
 
+/** Effect form of the explicit archival-history repair. */
+export declare const reconcileArchivedPublications: (...args: Parameters<typeof reconcileArchivedPublications_2>) => Effect<number, ChangeFeedUnavailable, never>;
+
+/**
+ * Explicit deployment repair for archives created before archival emitted a
+ * take-down. Stop publication writers and use one caller-owned transaction,
+ * after initializeChangeFeed. Append missing take-downs at the current tail;
+ * never backdate events or rewrite previously issued identities/positions.
+ * Only change-feed types and archived published copies in this scope qualify.
+ */
+declare const reconcileArchivedPublications_2: (tx: DataStore, types: ReadonlyArray<ContentType>, scope: ChangeFeedScope) => Promise<number>;
+
+/** In the actual caller transaction. Existing exact initialization remains the
+ * fresh-scope API; use this explicit CAS only for an admitted existing scope.
+ * Changed declarations reserve their complete actual final graph atomically.
+ * Exact latest retries return the same revision, never another binding record. */
+export declare const reconfigureCmsPublicRoutes: (tx: DataStore, supplied: ChangeFeedScope, declaration: CmsPublicRouteDeclaration, options: {
+    readonly expectedRevision: number;
+    readonly now?: number;
+}) => Effect<CmsPublicRouteInitialization, PublicRouteRegistryUnavailable | ChangeFeedUnavailable | SiteStateUnavailable, never>;
+
 /** Effect form of {@link recordAiOperation}. */
 export declare const recordAiOperation: (...args: Parameters<typeof recordAiOperation_2>) => Effect<string, never, never>;
 
@@ -4007,9 +4466,9 @@ export declare const recordAiOperation: (...args: Parameters<typeof recordAiOper
 declare const recordAiOperation_2: (tx: DataStore, input: AiOperationInput) => Promise<string>;
 
 /** Effect form of {@link recordChange}. */
-export declare const recordChange: (...args: Parameters<typeof recordChange_2>) => Effect<void, never, never>;
+export declare const recordChange: (...args: Parameters<typeof recordChange_2>) => Effect<void, ChangeFeedUnavailable, never>;
 
-/** Append one change, in the caller's transaction. A type without `changeFeed` writes nothing. */
+/** Advance publication generation atomically; only opted-in types append a feed event. */
 declare const recordChange_2: (tx: DataStore, type: ContentType, row: Row, scope: CmsScope, action: "published" | "unpublished", origin?: ChangeOrigin) => Promise<void>;
 
 /** Effect form of {@link recordCutoverIssues}. */
@@ -4053,14 +4512,9 @@ export declare const recordMigrationRecords: (...args: Parameters<typeof recordM
 declare const recordMigrationRecords_2: (tx: DataStore, source: string, records: ReadonlyArray<MigrationRecord>, tenantId: string | null, now?: Date) => Promise<void>;
 
 /** Effect form of {@link recordPaths}. */
-export declare const recordPaths: (...args: Parameters<typeof recordPaths_2>) => Effect<void, never, never>;
+export declare const recordPaths: (...args: Parameters<typeof recordPaths_2>) => Effect<void, ChangeFeedUnavailable, never>;
 
-/**
- * Record the paths of a tree type's published documents in `scope` — or, for
- * a type with an `address` field, each document's address — turning every
- * changed one into a redirect. Runs after a publish or unpublish, in the
- * caller's transaction. A type with neither is left alone.
- */
+/** Standalone path maintenance shares the publication boundary; no content event is invented. */
 declare const recordPaths_2: (tx: DataStore, type: ContentType, scope: CmsScope, tenantId: unknown) => Promise<void>;
 
 /** Effect form of {@link recordPortalDownload}. */
@@ -4245,10 +4699,10 @@ export declare const removeDomain: (...args: Parameters<typeof removeDomain_2>)
 } | {
     readonly ok: false;
     readonly reason: "notFound" | "primary";
-}, never, never>;
+}, PublicRouteRegistryUnavailable | ChangeFeedUnavailable | SiteStateUnavailable, never>;
 
 /** Remove a domain. The primary one is removed only after another took its place. */
-declare const removeDomain_2: (tx: DataStore, domainId: string) => Promise<{
+declare const removeDomain_2: (tx: DataStore, scope: CmsSiteScope, domainId: string) => Promise<{
     readonly ok: true;
 } | {
     readonly ok: false;
@@ -4268,14 +4722,14 @@ export declare const removeGlossaryTerm: (...args: Parameters<typeof removeGloss
 declare const removeGlossaryTerm_2: (tx: DataStore, tenantId: string, entryId: string) => Promise<boolean>;
 
 /** Effect form of {@link removeRedirect}. */
-export declare const removeRedirect: (...args: Parameters<typeof removeRedirect_2>) => Effect<boolean, never, never>;
+export declare const removeRedirect: (...args: Parameters<typeof removeRedirect_2>) => Effect<boolean, ChangeFeedUnavailable, never>;
 
 /**
  * Remove the redirect from `fromPath` in `scope`. True when there was one. A
  * page that had the address and is no longer live still answers it as gone
  * (`goneAt`). In the caller's transaction.
  */
-declare const removeRedirect_2: (tx: DataStore, type: ContentType, scope: CmsScope, fromPath: string) => Promise<boolean>;
+declare const removeRedirect_2: (tx: DataStore, type: ContentType, scope: CmsScope, fromPath: string, tenantId: unknown) => Promise<boolean>;
 
 /** Effect form of {@link reopenStage}. */
 export declare const reopenStage: (...args: Parameters<typeof reopenStage_2>) => Effect<number, never, never>;
@@ -4389,6 +4843,14 @@ declare const requestReview_2: (store: DataStore, type: ContentType, variantId:
 /** 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;
+
 /** Effect form of {@link resolveCutoverIssue}. */
 export declare const resolveCutoverIssue: (...args: Parameters<typeof resolveCutoverIssue_2>) => Effect<ResolveIssueResult, never, never>;
 
@@ -4398,6 +4860,28 @@ declare const resolveCutoverIssue_2: (tx: DataStore, issueId: string, input: {
     readonly actorId: string;
 }, now?: Date) => Promise<ResolveIssueResult>;
 
+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>;
+}
+
 /** One published entry found by {@link CmsApi.resolve}, with where it came from. */
 export declare interface ResolvedEntry {
     /** The published row that answers the request. */
@@ -4440,6 +4924,11 @@ export declare type ResolvedPreviewShare = {
     readonly reason: 'unknown' | 'expired' | 'revoked';
 };
 
+export declare const resolveEnvironmentAlias: (...args: Parameters<typeof resolveEnvironmentAlias_2>) => Effect<EnvironmentAlias, EnvironmentAliasUnavailable, never>;
+
+/** Resolve once for a request; retain the returned physical target throughout it. */
+declare const resolveEnvironmentAlias_2: (store: DataStore, scope: EnvironmentAliasScope, environments: ReadonlyArray<string>, name: string) => Promise<EnvironmentAlias>;
+
 export declare type ResolveIssueResult = {
     readonly ok: true;
 } | {
@@ -4495,11 +4984,15 @@ export declare const resolvePreviewShare: (...args: Parameters<typeof resolvePre
  */
 declare const resolvePreviewShare_2: (store: DataStore, token: string, now?: Date) => Promise<ResolvedPreviewShare>;
 
+/** 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;
+
 /** Effect-native `restoreRevision` (see {@link saveDraftEffect}). */
 export declare const restoreRevision: (store: DataStore, type: ContentType, id: string, scope: CmsScope, revisionId: string) => Effect_2.Effect<Row, ContentValidationFailed | ContentNotFound>;
 
 /** Effect form of {@link retireDuplicate}. */
-export declare const retireDuplicate: (...args: Parameters<typeof retireDuplicate_2>) => Effect<RetireDuplicateResult, ContentNotFound, never>;
+export declare const retireDuplicate: (...args: Parameters<typeof retireDuplicate_2>) => Effect<RetireDuplicateResult, ContentNotFound | ChangeFeedUnavailable, never>;
 
 /**
  * Retire `copyId` in favour of `keepId` — both drafts of `type` in `scope`
@@ -4796,6 +5289,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 {
@@ -4826,6 +5324,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;
@@ -4870,18 +5373,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. */
@@ -4965,6 +5468,14 @@ export declare interface RichTextSurfaceProps {
     };
 }
 
+export declare const rollbackEnvironmentAlias: (...args: Parameters<typeof rollbackEnvironmentAlias_2>) => Effect<EnvironmentAlias, EnvironmentAliasUnavailable, never>;
+
+/** Restore a recorded target as a NEW revision, without undoing intervening history. */
+declare const rollbackEnvironmentAlias_2: (tx: DataStore, scope: EnvironmentAliasScope, environments: ReadonlyArray<string>, name: string, input: {
+    readonly expectedRevisionId: string;
+    readonly revisionId: string;
+}) => Promise<EnvironmentAlias>;
+
 /** Effect form of {@link rollbackExtension}. */
 export declare const rollbackExtension: (...args: Parameters<typeof rollbackExtension_2>) => Effect<ExtensionChange, never, never>;
 
@@ -4976,7 +5487,7 @@ export declare const rollbackExtension: (...args: Parameters<typeof rollbackExte
 declare const rollbackExtension_2: (tx: DataStore, extensionId: string) => Promise<ExtensionChange>;
 
 /** Effect form of {@link rollbackRelease}. */
-export declare const rollbackRelease: (...args: Parameters<typeof rollbackRelease_2>) => Effect<Readonly<Record<string, unknown>>, ContentNotFound | ReleaseNotEditable | ReviewRequired | ReferenceUnavailable, never>;
+export declare const rollbackRelease: (...args: Parameters<typeof rollbackRelease_2>) => Effect<Readonly<Record<string, unknown>>, PublicRouteRegistryUnavailable | ContentNotFound | ReleaseNotEditable | ReviewRequired | ReferenceUnavailable | ChangeFeedUnavailable, never>;
 
 /**
  * Roll a published release back: a NEW release that puts back what each of
@@ -4986,6 +5497,79 @@ export declare const rollbackRelease: (...args: Parameters<typeof rollbackReleas
  */
 declare const rollbackRelease_2: (tx: DataStore, types: ReadonlyArray<ContentType>, releaseId: string, now?: Date, options?: PublishReleaseOptions) => Promise<Row>;
 
+export declare const rollbackSiteContentBinding: (...args: Parameters<typeof rollbackSiteContentBinding_2>) => Effect<SiteContentBinding, ChangeFeedUnavailable | SiteBindingUnavailable, never>;
+
+/** Restore a prior target as a new revision; it must still be published in this scope. */
+declare const rollbackSiteContentBinding_2: (tx: DataStore, types: ReadonlyArray<ContentType>, scope: ChangeFeedScope, name: string, input: {
+    readonly expectedRevisionId: string;
+    readonly revisionId: string;
+}) => Promise<SiteContentBinding>;
+
+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>;
+
 /** A path found by {@link CmsApi.route}. */
 export declare interface RouteMatch {
     /** The node for the path's document, in the requested locale's tree. Its
@@ -5180,6 +5764,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. */
 export declare interface SearchConfig {
     /** The string field ranked first — usually the title. */
@@ -5284,6 +5874,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;
+}
+
 /** Effect form of {@link seriesOf}. */
 export declare const seriesOf: (...args: Parameters<typeof seriesOf_2>) => Effect<PublishSeries | null, ContentValidationFailed | ContentNotFound, never>;
 
@@ -5329,10 +5931,10 @@ export declare const setOwner: (...args: Parameters<typeof setOwner_2>) => Effec
 declare const setOwner_2: (store: DataStore, type: ContentType, documentId: string, place: Place_2, owner: string | null) => Promise<Stewardship>;
 
 /** Effect form of {@link setPrimaryDomain}. */
-export declare const setPrimaryDomain: (...args: Parameters<typeof setPrimaryDomain_2>) => Effect<SetPrimaryResult, never, never>;
+export declare const setPrimaryDomain: (...args: Parameters<typeof setPrimaryDomain_2>) => Effect<SetPrimaryResult, PublicRouteRegistryUnavailable | ChangeFeedUnavailable | SiteStateUnavailable, never>;
 
 /** Make a verified domain the site's primary one; the previous primary stays, as an alias. */
-declare const setPrimaryDomain_2: (tx: DataStore, domainId: string) => Promise<SetPrimaryResult>;
+declare const setPrimaryDomain_2: (tx: DataStore, scope: CmsSiteScope, domainId: string) => Promise<SetPrimaryResult>;
 
 export declare type SetPrimaryResult = {
     readonly ok: true;
@@ -5406,6 +6008,76 @@ export declare const sharedRichBlocks: (type: ContentType, values: Readonly<Reco
     readonly markup: string;
 }>;
 
+/** 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 SiteContentBinding {
+    readonly id: string;
+    readonly name: string;
+    readonly contentType: string;
+    readonly documentId: string;
+    readonly revisionId: string;
+}
+
+export declare const siteContentBinding: (...args: Parameters<typeof siteContentBinding_2>) => Effect<SiteContentBinding | null, SiteBindingUnavailable, never>;
+
+/** The explicit target, or null when no binding was authored. Never a newest-row fallback. */
+declare const siteContentBinding_2: (store: DataStore, scope: ChangeFeedScope, name: string) => Promise<SiteContentBinding | null>;
+
+export declare interface SiteContentBindingRevision {
+    readonly id: string;
+    readonly bindingId: string;
+    readonly contentType: string;
+    readonly documentId: string;
+    readonly previousRevisionId: string | null;
+    readonly sourceRevisionId: string | null;
+}
+
+export declare const siteContentBindingRevision: (...args: Parameters<typeof siteContentBindingRevision_2>) => Effect<SiteContentBindingRevision, SiteBindingUnavailable, never>;
+
+/** Read only a revision belonging to this named binding in this physical scope. */
+declare const siteContentBindingRevision_2: (store: DataStore, scope: ChangeFeedScope, name: string, revisionId: string) => Promise<SiteContentBindingRevision>;
+
+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 SiteDomain {
     readonly id: string;
     readonly site: string;
@@ -5421,10 +6093,10 @@ export declare interface SiteDomain {
 }
 
 /** Effect form of {@link siteDomains}. */
-export declare const siteDomains: (...args: Parameters<typeof siteDomains_2>) => Effect<readonly SiteDomain[], never, never>;
+export declare const siteDomains: (...args: Parameters<typeof siteDomains_2>) => Effect<readonly SiteDomain[], SiteStateUnavailable, never>;
 
 /** A site's domains: the primary first, then by host. */
-declare const siteDomains_2: (store: DataStore, site: string) => Promise<ReadonlyArray<SiteDomain>>;
+declare const siteDomains_2: (store: DataStore, scope: CmsSiteScope) => Promise<ReadonlyArray<SiteDomain>>;
 
 export declare interface SitemapUrl extends PageAlternate {
     readonly documentId: string;
@@ -5447,6 +6119,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
@@ -5454,6 +6134,35 @@ export declare const sitemapXml: (urls: ReadonlyArray<SitemapUrl>, href: (locale
  */
 export declare const slugify: (value: unknown) => string;
 
+/** Must come from the admitted build artifact/config, never a request claim. */
+declare interface SnapshotAppCodePin {
+    readonly commit: string;
+    readonly artifactDigest: string;
+    readonly configDigest: string;
+}
+
+declare type SnapshotConsentPurpose = Pick<ConsentPurpose, 'id' | 'version'>;
+
+declare interface SnapshotPresentation {
+    readonly version: 1;
+    readonly decided: boolean;
+    readonly granted: ReadonlyArray<SnapshotConsentPurpose>;
+}
+
+declare type SnapshotRouteClaim = {
+    readonly kind: 'cms';
+} | {
+    readonly kind: 'code';
+    readonly collision: 'reject' | 'cms' | 'code';
+    /** Opt this native page into public production documents and path sets. */
+    readonly public?: boolean;
+};
+
+declare interface SnapshotRoutingDefinition {
+    readonly pagesDirectory: string;
+    readonly claims: Readonly<Record<string, SnapshotRouteClaim>>;
+}
+
 /** The passage of `body` around the first word that starts with a query word. */
 export declare const snippetOf: (body: string, query: string) => SearchSnippet;
 
@@ -5614,6 +6323,14 @@ declare const suggestOnStep_2: (tx: DataStore, instanceId: string, stepId: strin
     readonly reason: StepRefusal;
 }>;
 
+export declare const swapEnvironmentAlias: (...args: Parameters<typeof swapEnvironmentAlias_2>) => Effect<EnvironmentAlias, EnvironmentAliasUnavailable, never>;
+
+/** Atomically swap from an observed revision. A stale editor must re-read before retrying. */
+declare const swapEnvironmentAlias_2: (tx: DataStore, scope: EnvironmentAliasScope, environments: ReadonlyArray<string>, name: string, input: {
+    readonly expectedRevisionId: string;
+    readonly environment: string;
+}) => Promise<EnvironmentAlias>;
+
 /** A type's taxonomy — see `ContentTypeSpec.taxonomy`. */
 export declare interface TaxonomyConfig {
     /** A declared `Schema.Array(Schema.String)` field. */
@@ -5917,10 +6634,10 @@ export declare const unique: () => FieldRefinement;
 export declare const unitsHash: (units: ReadonlyArray<TranslationUnit>) => string;
 
 /** Effect-native `unpublish` (see {@link saveDraftEffect}). */
-export declare const unpublish: (store: DataStore, type: ContentType, id: string, scope: CmsScope) => Effect_2.Effect<void, ContentNotFound>;
+export declare const unpublish: (store: DataStore, type: ContentType, id: string, scope: CmsScope) => Effect_2.Effect<void, ContentNotFound | ChangeFeedUnavailable | PublicRouteRegistryUnavailable>;
 
 /** Effect form of {@link unpublishDue}. */
-export declare const unpublishDue: (...args: Parameters<typeof unpublishDue_2>) => Effect<readonly string[], never, never>;
+export declare const unpublishDue: (...args: Parameters<typeof unpublishDue_2>) => Effect<readonly string[], ChangeFeedUnavailable, never>;
 
 /**
  * Take down every entry of `type` whose scheduled `unpublishAt` has passed.
@@ -5991,10 +6708,10 @@ export declare interface VariantResult {
 }
 
 /** Effect form of {@link verifyDomain}. */
-export declare const verifyDomain: (...args: Parameters<typeof verifyDomain_2>) => Effect<VerifyDomainResult, never, never>;
+export declare const verifyDomain: (...args: Parameters<typeof verifyDomain_2>) => Effect<VerifyDomainResult, PublicRouteRegistryUnavailable | ChangeFeedUnavailable | SiteStateUnavailable, never>;
 
 /** Look for the domain's TXT record; found, the domain is verified. A lookup that fails counts as missing. */
-declare const verifyDomain_2: (tx: DataStore, domainId: string, resolveTxt: TxtResolver, now?: Date) => Promise<VerifyDomainResult>;
+declare const verifyDomain_2: (tx: DataStore, scope: CmsSiteScope, domainId: string, resolveTxt: TxtResolver, now?: Date) => Promise<VerifyDomainResult>;
 
 export declare type VerifyDomainResult = {
     readonly ok: true;