@voltro/cms 0.83.1 → 0.85.0

package/dist/index.d.ts

@@ -5,6 +5,21 @@ import { ReactNode } from 'react';
 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>;
+
+/** 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>;
+
+export declare type AddDomainResult = {
+    readonly ok: true;
+    readonly domain: SiteDomain;
+} | {
+    readonly ok: false;
+    readonly reason: 'notAHost' | 'taken';
+};
 
 /** Effect form of {@link addRedirect}. */
 export declare const addRedirect: (...args: Parameters<typeof addRedirect_2>) => Effect<void, never, never>;
@@ -17,6 +32,15 @@ export declare const addRedirect: (...args: Parameters<typeof addRedirect_2>) =>
  */
 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>;
+
+/** Add a document to a collection (at the end); already in it, nothing changes. False when the collection is not the caller's. */
+declare const addToCollection_2: (tx: DataStore, collectionId: string, item: {
+    readonly contentType: string;
+    readonly documentId: string;
+}) => Promise<boolean>;
+
 /** Effect form of {@link addToRelease}. */
 export declare const addToRelease: (...args: Parameters<typeof addToRelease_2>) => Effect<Readonly<Record<string, unknown>>, ContentNotFound | ReleaseNotEditable, never>;
 
@@ -35,6 +59,37 @@ declare const addToRelease_2: (store: DataStore, releaseId: string, item: {
     readonly revisionId?: string;
 }) => Promise<Row>;
 
+/** Effect form of {@link adoptCandidate}. */
+export declare const adoptCandidate: (...args: Parameters<typeof adoptCandidate_2>) => Effect<AdoptCandidateResult, ContentValidationFailed | ContentNotFound | ContentIdConflict | RevisionMismatch, never>;
+
+/**
+ * Save the chosen units of an open candidate on top of the draft as it is
+ * now — a new draft revision, validated like any save — and record what was
+ * taken. The AI operation behind it is settled as applied.
+ */
+declare const adoptCandidate_2: (tx: DataStore, type: ContentType, candidateId: string, scope: CmsScope, input: {
+    readonly units: ReadonlyArray<string>;
+    readonly actorId: string;
+}, now?: Date) => Promise<AdoptCandidateResult>;
+
+export declare type AdoptCandidateResult = {
+    readonly ok: true;
+    readonly revisionId: string;
+    readonly status: 'adopted' | 'partial';
+} | {
+    readonly ok: false;
+    readonly reason: 'notFound' | 'closed' | 'noUnits' | 'unknownUnit';
+    readonly units?: ReadonlyArray<string>;
+};
+
+export declare interface AdoptionEntry {
+    readonly actorId: string;
+    /** Revisions they saved of migrated documents after the import. */
+    readonly revisions: number;
+    readonly documents: number;
+    readonly lastAt: Date | null;
+}
+
 /** Effect form of {@link adoptWinner}. */
 export declare const adoptWinner: (...args: Parameters<typeof adoptWinner_2>) => Effect<AdoptWinnerResult, ContentValidationFailed | ContentNotFound | ContentIdConflict | RevisionMismatch | ReleaseNotEditable, never>;
 
@@ -77,6 +132,22 @@ export declare const aiBudgetLeft: (...args: Parameters<typeof aiBudgetLeft_2>)
 /** What is left of the workspace's monthly budget: a number of tokens, or null (no limit). */
 declare const aiBudgetLeft_2: (store: DataStore, tenantId: string, now?: Date) => Promise<number | null>;
 
+export declare interface AiCandidate {
+    readonly id: string;
+    readonly contentType: string;
+    readonly variantId: string;
+    readonly baseRevisionId: string | null;
+    readonly operationId: string | null;
+    /** Set for a person's suggestion; null for a model's candidate. */
+    readonly suggestedBy: string | null;
+    readonly values: Readonly<Record<string, unknown>>;
+    readonly status: 'open' | 'adopted' | 'partial' | 'discarded';
+    readonly adoptedUnits: ReadonlyArray<string>;
+    readonly adoptedRevisionId: string | null;
+    readonly decidedBy: string | null;
+    readonly createdAt: Date;
+}
+
 export declare interface AiOperation {
     readonly id: string;
     readonly operation: string;
@@ -143,6 +214,14 @@ declare const aiTokensUsed_2: (store: DataStore, tenantId: string, since?: Date)
 /** A document's address in every language it has its own variant in. */
 export declare const alternatesOf: (trees: ReadonlyArray<LocalizedTree>, documentId: string) => ReadonlyArray<PageAlternate>;
 
+export declare type AppliedSelection = {
+    readonly ok: true;
+    readonly values: Readonly<Record<string, unknown>>;
+} | {
+    readonly ok: false;
+    readonly reason: 'otherIntent' | 'otherDocument' | 'revisionMoved' | 'targetGone';
+};
+
 /** Effect form of {@link applyBlueprint}. */
 export declare const applyBlueprint: (...args: Parameters<typeof applyBlueprint_2>) => Effect<BlueprintPlan, ContentValidationFailed | ContentNotFound | ContentIdConflict | RevisionMismatch | ReviewRequired | ReferenceUnavailable | BlueprintInvalid, never>;
 
@@ -176,6 +255,19 @@ declare const applyBlueprintTeam_2: (tx: DataStore, tenantId: string, team: Blue
  */
 export declare const applyDerivations: (type: Pick<ContentType, "fields" | "derivedFields"> & Partial<Pick<ContentType, "taxonomy">>, row: Readonly<Record<string, unknown>>) => Record<string, unknown>;
 
+/**
+ * The values with the answer applied where the intent said: a field takes the
+ * chosen document; a placed component's prop takes it; an image block takes it
+ * as its asset; a paragraph or a heading gets a link to it over the selected
+ * text. Refused for another intent, another document or form, a revision that
+ * moved on, or a block or component that is gone.
+ */
+export declare const applySelection: (values: Readonly<Record<string, unknown>>, intent: SelectionIntent, answer: SelectionAnswer, now: {
+    readonly documentId?: string | null;
+    readonly revisionId?: string | null;
+    readonly formId?: string;
+}) => AppliedSelection;
+
 /**
  * The source values with each unit's target in place — what a translation
  * draft saves. A unit without a target keeps the source text; an id that
@@ -183,9 +275,19 @@ export declare const applyDerivations: (type: Pick<ContentType, "fields" | "deri
  */
 export declare const applyTranslation: (fields: Readonly<Record<string, FieldSchema>>, source: Readonly<Record<string, unknown>>, units: ReadonlyArray<TranslationUnit>) => Record<string, unknown>;
 
-/** The values a reader of `variant` sees: version B's text over the published values. */
+/**
+ * The values a reader of `variant` sees: version B's text over the published
+ * values — a field, or one prop of one placed component (an instance no longer
+ * on the page is left alone).
+ */
 export declare const applyVariant: (values: Readonly<Record<string, unknown>>, experiment: Pick<Experiment, "overrides">, variant: Variant) => Readonly<Record<string, unknown>>;
 
+/** Effect form of {@link approvedByWorkflow}. */
+export declare const approvedByWorkflow: (...args: Parameters<typeof approvedByWorkflow_2>) => Effect<boolean, never, never>;
+
+/** The publish gate's question: did a workflow instance approve exactly this revision? */
+declare const approvedByWorkflow_2: (store: DataStore, type: ContentType, variantId: string, revisionId: string) => Promise<boolean>;
+
 /** Effect form of {@link approveReview}. */
 export declare const approveReview: (...args: Parameters<typeof approveReview_2>) => Effect<Readonly<Record<string, unknown>>, ContentNotFound | RevisionMismatch | ReviewStepRefused, never>;
 
@@ -205,7 +307,7 @@ export declare const assertApproved: (...args: Parameters<typeof assertApproved_
 
 /**
  * The publish gate: for a type that requires review, `revisionId` must carry
- * an approval. Called by `publishRevision` — so single publishes, releases,
+ * an approval — with a review workflow, an instance that approved it. Called by `publishRevision` — so single publishes, releases,
  * rollbacks and scheduled publishing all pass the same gate.
  */
 declare const assertApproved_2: (store: DataStore, type: ContentType, variantId: string, scope: CmsScope, revisionId: string) => Promise<void>;
@@ -222,6 +324,18 @@ declare const assertReferencesAvailable_2: (tx: DataStore, type: ContentType, va
 /** 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;
 
+/**
+ * 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`).
+ */
+export declare const attributeToRevisions: (timeline: ReadonlyArray<LiveStretch>, daily: ReadonlyArray<{
+    readonly day: string;
+    readonly value: number;
+}>) => {
+    readonly shares: ReadonlyArray<RevisionShare>;
+    readonly unattributed: number;
+};
+
 export declare interface Audience {
     readonly id: string;
     /** Raise it when the rule changes meaning; a variant records the version it was written for. */
@@ -256,6 +370,22 @@ export declare interface AvailabilityConfig {
     readonly until?: string;
     /** A boolean field: `true` withdraws the document at once. */
     readonly blocked?: string;
+    /** A date or datetime field: usable from this moment on. */
+    readonly from?: string;
+    /** A list-of-text field of territory codes (ISO 3166-1 alpha-2): usable only there. Empty: everywhere. */
+    readonly territories?: string;
+    /** A list-of-text field of channels (`web`, `app`, `print`, …): usable only on these. Empty: on every channel. */
+    readonly channels?: string;
+    /** A list-of-text field of purposes (`editorial`, `advertising`, …): usable only for these. Empty: for every purpose. */
+    readonly purposes?: string;
+}
+
+/** Where, on what and for what a document is about to be used; each is checked only when given. */
+export declare interface AvailabilityUse {
+    /** The reader's territory, ISO 3166-1 alpha-2 (`AT`). */
+    readonly territory?: string | null;
+    readonly channel?: string | null;
+    readonly purpose?: string | null;
 }
 
 /** Effect form of {@link bindExtensionSecret}. */
@@ -267,7 +397,17 @@ 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 type BlockReason = 'notFound' | 'reviewRequired' | 'incomplete' | 'referenceUnavailable' | 'notPublished' | 'unknownType' | 'invalid' | 'revisionMoved';
+/** Whether a block, or any text in it, holds a suggestion. */
+export declare const blockHasChanges: (block: RichBlock) => boolean;
+
+/**
+ * The markup a block is edited as: text blocks are one run, a list one line
+ * per item (two spaces of indent per level), a table one line per row with
+ * cells split by `|`; an image or a component has none.
+ */
+export declare const blockMarkup: (block: RichBlock) => string;
+
+export declare type BlockReason = 'notFound' | 'reviewRequired' | 'incomplete' | 'referenceUnavailable' | 'notPublished' | 'unknownType' | 'invalid' | 'revisionMoved' | 'releaseClosed';
 
 export declare interface Blueprint {
     readonly id: string;
@@ -375,6 +515,11 @@ export declare type BulkAction = {
     readonly kind: 'setField';
     readonly field: string;
     readonly value: unknown;
+}
+/** Put each item's current revision into one draft release (to publish at once). */
+| {
+    readonly kind: 'addToRelease';
+    readonly releaseId: string;
 };
 
 /** One locale variant (a draft id) of a document. */
@@ -391,12 +536,118 @@ export declare interface BulkResult extends BulkItem {
     readonly detail: ReadonlyArray<string>;
 }
 
+export declare interface BulkRunState {
+    readonly id: string;
+    readonly action: BulkAction;
+    readonly status: 'running' | 'done';
+    readonly total: number;
+    readonly results: ReadonlyArray<BulkResult>;
+}
+
+/** Effect form of {@link bulkRunState}. */
+export declare const bulkRunState: (...args: Parameters<typeof bulkRunState_2>) => Effect<BulkRunState | null, never, never>;
+
+/** Where a run stands, or null. */
+declare const bulkRunState_2: (store: DataStore, runId: string) => Promise<BulkRunState | null>;
+
+/** What a route's response depends on — declared once, read by every cache in front of it. */
+export declare interface CacheContract {
+    /** The route pattern (`/v1/site/page`), the purge selector's route class. */
+    readonly route: string;
+    readonly query?: ReadonlyArray<QueryParam>;
+    /** The language, from a bounded set — never the raw `Accept-Language`. */
+    readonly locale?: CacheDimension;
+    /** Declared audiences or experiment cohorts the output differs by. */
+    readonly audience?: CacheDimension;
+    /** The reader's consent decision class — only when the output really varies by it. */
+    readonly consent?: CacheDimension;
+    /** Cookies and headers that make a response private when present (a session, a preview token). */
+    readonly credentials?: ReadonlyArray<string>;
+    /** The most variants one route may fan out to. Default 64. */
+    readonly cardinalityBudget?: number;
+}
+
+/** A bounded request dimension: where it is read from, and its values. */
+export declare interface CacheDimension {
+    /** A request header (lowercase) or a cookie (`cookie:<name>`). */
+    readonly from: string;
+    readonly values: ReadonlyArray<string>;
+    /** Taken when the request names none, or one not in `values`. */
+    readonly fallback: string;
+}
+
+export declare type CacheIdentity = {
+    readonly cacheable: true;
+    /** The canonical identity — every dimension in a fixed order. */
+    readonly key: string;
+    /** A short, stable fingerprint of `key`. */
+    readonly fingerprint: string;
+    readonly vary: ReadonlyArray<string>;
+    /** What a purge of this response names: the route class and its tags. */
+    readonly purge: {
+        readonly route: string;
+        readonly tags: ReadonlyArray<string>;
+    };
+    readonly variants: number;
+    readonly explain: ReadonlyArray<ExplainLine>;
+} | {
+    readonly cacheable: false;
+    readonly reason: 'method' | 'credential' | 'path' | 'budget';
+    readonly detail: string;
+    /** A refused or private request is never stored by a shared cache. */
+    readonly cacheControl: 'private, no-store';
+    readonly explain: ReadonlyArray<ExplainLine>;
+};
+
+export declare interface CacheRequest {
+    readonly method: string;
+    readonly host: string;
+    /** The path as received, still encoded. */
+    readonly path: string;
+    /** The query string without `?`. */
+    readonly query: string;
+    readonly headers: Readonly<Record<string, string | undefined>>;
+}
+
 /** Effect form of {@link cancelSeries}. */
 export declare const cancelSeries: (...args: Parameters<typeof cancelSeries_2>) => Effect<boolean, ContentValidationFailed | ContentNotFound, never>;
 
 /** End a draft's series and clear what it armed. True when there was one. In the caller's transaction. */
 declare const cancelSeries_2: (tx: DataStore, type: ContentType, draftId: string) => Promise<boolean>;
 
+/** Effect form of {@link candidatesFor}. */
+export declare const candidatesFor: (...args: Parameters<typeof candidatesFor_2>) => Effect<readonly AiCandidate[], never, never>;
+
+/** A draft's candidates, newest first. */
+declare const candidatesFor_2: (store: DataStore, type: ContentType, variantId: string) => Promise<ReadonlyArray<AiCandidate>>;
+
+/** One unit of a candidate an editor adopts or leaves: a field, or one section of a components field. */
+export declare interface CandidateUnit {
+    /** `title`, or `sections[<instanceId>]` for a changed section, `sections+<n>` for an added one. */
+    readonly key: string;
+    readonly kind: 'field' | 'section' | 'addedSection';
+    readonly field: string;
+    readonly before: unknown;
+    readonly after: unknown;
+}
+
+/** The units in which `proposed` differs from `current`, field by field and section by section. */
+export declare const candidateUnits: (type: ContentType, current: Readonly<Record<string, unknown>>, proposed: Readonly<Record<string, unknown>>) => ReadonlyArray<CandidateUnit>;
+
+/** Who suggests the edit, and when; `id` names the change. */
+export declare type ChangeAuthor = Omit<RichChange, 'kind'>;
+
+/**
+ * The fields that changed between `before` and `after` other than through the
+ * texts typed in together (`keys`): a plain field with a shared text, a field
+ * derived from one, and a rich text whose change lies only in its shared blocks
+ * do not count.
+ */
+export declare const changedApartFromShared: (type: ContentType, before: Readonly<Record<string, unknown>>, after: Readonly<Record<string, unknown>>, keys: Iterable<string>) => ReadonlyArray<string>;
+
+/** What to do with one suggestion. */
+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>;
 
@@ -418,9 +669,14 @@ export declare interface ChangeOrigin {
     readonly releaseId?: string;
 }
 
+/** 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;
+
 /** Throws when a declaration cannot work: fields missing or of the wrong kind, a component the field does not allow. */
 export declare const checkTemplates: (name: string, fields: Readonly<Record<string, FieldSchema>>, config: TemplatesConfig) => void;
 
+export declare const CMS_AI_CANDIDATES_TABLE = "cms_ai_candidates";
+
 export declare const CMS_AI_OPERATIONS_TABLE = "cms_ai_operations";
 
 export declare const CMS_AI_SETTINGS_TABLE = "cms_ai_settings";
@@ -428,8 +684,24 @@ export declare const CMS_AI_SETTINGS_TABLE = "cms_ai_settings";
 /** The system table holding the availability of published documents. */
 export declare const CMS_AVAILABILITY_TABLE = "cms_availability";
 
+export declare const CMS_BULK_RUNS_TABLE = "cms_bulk_runs";
+
 export declare const CMS_CHANGES_TABLE = "cms_changes";
 
+export declare const CMS_COLLECTION_ITEMS_TABLE = "cms_collection_items";
+
+export declare const CMS_COLLECTION_PORTALS_TABLE = "cms_collection_portals";
+
+export declare const CMS_COLLECTIONS_TABLE = "cms_collections";
+
+export declare const CMS_COPIES_TABLE = "cms_copies";
+
+export declare const CMS_CUTOVER_DECISIONS_TABLE = "cms_cutover_decisions";
+
+export declare const CMS_CUTOVER_ISSUES_TABLE = "cms_cutover_issues";
+
+export declare const CMS_DELIVERY_CHECKS_TABLE = "cms_delivery_checks";
+
 export declare const CMS_DRAFT_TEXTS_TABLE = "cms_draft_texts";
 
 export declare const CMS_EXPERIMENT_EVENTS_TABLE = "cms_experiment_events";
@@ -444,6 +716,10 @@ export declare const CMS_EXTENSIONS_TABLE = "cms_extensions";
 
 export declare const CMS_GLOSSARY_TABLE = "cms_glossary";
 
+export declare const CMS_MIGRATION_RECORDS_TABLE = "cms_migration_records";
+
+export declare const CMS_MIGRATION_STAGES_TABLE = "cms_migration_stages";
+
 export declare const CMS_PATHS_TABLE = "cms_paths";
 
 /** The system table holding preview shares. */
@@ -473,12 +749,20 @@ export declare const CMS_SCOPE_COLUMNS: readonly ["site", "environment", "locale
 
 export declare const CMS_SEARCH_TABLE = "cms_search";
 
+export declare const CMS_SITE_DOMAINS_TABLE = "cms_site_domains";
+
 export declare const CMS_STEWARDSHIP_TABLE = "cms_stewardship";
 
 export declare const CMS_TEAM_INVITATIONS_TABLE = "cms_team_invitations";
 
 export declare const CMS_TEAM_TABLE = "cms_team";
 
+export declare const CMS_WORKFLOW_DECISIONS_TABLE = "cms_workflow_decisions";
+
+export declare const CMS_WORKFLOW_INSTANCES_TABLE = "cms_workflow_instances";
+
+export declare const cmsAiCandidatesTable: TableLike;
+
 /** One AI call on a document, and what became of it. */
 export declare const cmsAiOperationsTable: TableLike;
 
@@ -541,8 +825,17 @@ export declare interface CmsApi {
  */
 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 cmsChangesTable: TableLike;
 
+export declare const cmsCollectionItemsTable: TableLike;
+
+export declare const cmsCollectionPortalsTable: TableLike;
+
+export declare const cmsCollectionsTable: TableLike;
+
 /**
  * Build the `ctx.cms` surface over a request-scoped store, confined to one
  * `scope` (site, environment, locale). Attach the result to your
@@ -553,6 +846,14 @@ export declare const cmsContext: (store: DataStore, types: ReadonlyArray<Content
     readonly secret?: string;
 }) => CmsApi;
 
+export declare const cmsCopiesTable: TableLike;
+
+export declare const cmsCutoverDecisionsTable: TableLike;
+
+export declare const cmsCutoverIssuesTable: TableLike;
+
+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;
 
@@ -587,6 +888,10 @@ export declare const cmsExtensionsTable: TableLike;
 /** One entry per workspace, term (lower case) and target language. */
 export declare const cmsGlossaryTable: TableLike;
 
+export declare const cmsMigrationRecordsTable: TableLike;
+
+export declare const cmsMigrationStagesTable: TableLike;
+
 /** The address each published document of a tree type had at its last publish, per locale. */
 export declare const cmsPathsTable: TableLike;
 
@@ -690,6 +995,8 @@ export declare interface CmsScope {
 
 export declare const cmsSearchTable: TableLike;
 
+export declare const cmsSiteDomainsTable: TableLike;
+
 export declare const cmsStewardshipTable: TableLike;
 
 /** Who is invited with which role. */
@@ -709,6 +1016,10 @@ export declare interface CmsTree {
     readonly orphans: ReadonlyArray<string>;
 }
 
+export declare const cmsWorkflowDecisionsTable: TableLike;
+
+export declare const cmsWorkflowInstancesTable: TableLike;
+
 /** Everything the write pipeline can fail with on the typed channel. */
 export declare type CmsWriteError = ContentValidationFailed | ContentNotFound | ContentIdConflict | RevisionMismatch;
 
@@ -719,6 +1030,30 @@ export declare type CmsWriteError = ContentValidationFailed | ContentNotFound |
  */
 export declare const collaborativeFields: (type: ContentType) => ReadonlyArray<string>;
 
+export declare interface Collection {
+    readonly id: string;
+    readonly name: string;
+    readonly description: string | null;
+}
+
+export declare interface CollectionItem {
+    readonly contentType: string;
+    readonly documentId: string;
+    readonly position: number;
+}
+
+/** Effect form of {@link collectionItems}. */
+export declare const collectionItems: (...args: Parameters<typeof collectionItems_2>) => Effect<readonly CollectionItem[], never, never>;
+
+/** A collection's documents, in order. */
+declare const collectionItems_2: (store: DataStore, collectionId: string, crossTenant?: boolean) => Promise<ReadonlyArray<CollectionItem>>;
+
+/** Effect form of {@link collectionPortals}. */
+export declare const collectionPortals: (...args: Parameters<typeof collectionPortals_2>) => Effect<readonly Portal[], never, never>;
+
+/** A collection's portals, newest first. */
+declare const collectionPortals_2: (store: DataStore, collectionId: string) => Promise<ReadonlyArray<Portal>>;
+
 /** Effect form of {@link compareEnvironments}. */
 export declare const compareEnvironments: (...args: Parameters<typeof compareEnvironments_2>) => Effect<readonly EnvironmentDifference[], never, never>;
 
@@ -728,6 +1063,19 @@ declare const compareEnvironments_2: (store: DataStore, types: ReadonlyArray<Con
 /** Order of two `major.minor.patch` versions: negative, 0 or positive. */
 export declare const compareVersions: (a: string, b: string) => number;
 
+/**
+ * The identity of `request` under `contract` at publication `checkpoint` (a
+ * release or publication id), with the document tags its response depends on.
+ */
+export declare const compileCacheIdentity: (contract: CacheContract, request: CacheRequest, context: {
+    readonly checkpoint: string;
+    readonly tags?: ReadonlyArray<string>;
+}) => CacheIdentity;
+
+declare type ComponentBlock = Extract<RichBlock, {
+    readonly type: 'component';
+}>;
+
 /**
  * A component editors compose pages from (ADR-CMS-015): a stable `id`, a
  * display name and typed props. The frontend renders it; the CMS validates
@@ -739,10 +1087,29 @@ export declare interface ComponentDefinition {
     readonly displayName: string;
     readonly props: Readonly<Record<string, FieldSchema>>;
     readonly fingerprint: string;
+    /** What it is for, in an editor's words — searched by the picker. */
+    readonly description?: string;
+    /** The editorial jobs it serves (`'announce an event'`, `'collect leads'`) — the picker groups and searches by them. */
+    readonly jobs?: ReadonlyArray<string>;
+    /** Named presets an editor starts from (`dark`, `compact`): props that differ from empty. */
+    readonly variants?: Readonly<Record<string, Readonly<Record<string, unknown>>>>;
+    /** Example props — previews, galleries and tests render them; checked against `props` when a content type uses the component. */
+    readonly fixtures?: Readonly<Record<string, Readonly<Record<string, unknown>>>>;
+    /** Upgrades of instances saved against an earlier definition: its fingerprint → the props it becomes now. */
+    readonly migrations?: Readonly<Record<string, (props: Readonly<Record<string, unknown>>) => Readonly<Record<string, unknown>>>>;
     /** The consent purpose a reader must grant before this component's props reach them (`gateConsent`). */
     readonly consent?: string;
 }
 
+/** A component's fixtures and variants against its props: every violation, with the fixture or variant it is in. */
+export declare const componentExampleViolations: (definition: ComponentDefinition) => ReadonlyArray<FieldViolation>;
+
+/** The fingerprint a component with these props has — to key a migration from an earlier definition. */
+export declare const componentFingerprint: (spec: {
+    readonly id: string;
+    readonly props: Readonly<Record<string, FieldSchema | PipeableField>>;
+}) => string;
+
 /** One placed component in a `components` field, as stored. */
 export declare interface ComponentInstance {
     /** Stable across saves, reorders and translations of the same placement. */
@@ -753,9 +1120,29 @@ export declare interface ComponentInstance {
     readonly props: Readonly<Record<string, unknown>>;
 }
 
+/** Every component placed in the values, nested ones included. */
+export declare const componentsOf: (type: ContentType, values: Readonly<Record<string, unknown>>) => ReadonlyArray<ComponentUse>;
+
+/** A component placed in the document — a design-system node of the graph. */
+export declare interface ComponentUse {
+    readonly path: string;
+    readonly componentId: string;
+}
+
 /** A reader's choices: purpose id → the version they allowed. */
 export declare type ConsentChoices = Readonly<Record<string, number>>;
 
+/**
+ * The same decision as {@link gateConsent}, for the browser to enforce: a
+ * Content-Security-Policy whose `frame-src` lets in only this origin and the
+ * vendors the reader granted. Set it on the response (a web middleware) and
+ * an embed the reader refused cannot load even if one slipped into the page.
+ */
+export declare const consentContentSecurityPolicy: (purposes: ReadonlyArray<ConsentPurpose>, choices: ConsentChoices, base?: string) => string;
+
+/** 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>;
+
 /** Something a reader can allow or refuse. */
 export declare interface ConsentPurpose {
     readonly id: string;
@@ -763,6 +1150,8 @@ export declare interface ConsentPurpose {
     readonly version: number;
     readonly displayName: string;
     readonly description: string;
+    /** The third parties it lets in (none for a first-party purpose). */
+    readonly vendors?: ReadonlyArray<ConsentVendor>;
 }
 
 /** Effect form of {@link consentToUpgrade}. */
@@ -771,6 +1160,27 @@ export declare const consentToUpgrade: (...args: Parameters<typeof consentToUpgr
 /** Consent to what the waiting version adds, and move to it. */
 declare const consentToUpgrade_2: (tx: DataStore, extensionId: string, consent: ReadonlyArray<ExtensionCapability>) => Promise<ExtensionChange>;
 
+/**
+ * A third party a purpose lets in — kept apart from the purpose itself: who
+ * it is, where its content comes from (the origins a page may then load), what
+ * it stores on the reader's device, and what it does with the data.
+ */
+export declare interface ConsentVendor {
+    /** camelCase, unique within the purpose — what a reader-facing text is keyed by. */
+    readonly id: string;
+    readonly name: string;
+    /** `https://host` origins, exactly — the browser loads frames from them once the purpose is granted. */
+    readonly origins: ReadonlyArray<string>;
+    readonly storage: string;
+    readonly dataUse: string;
+}
+
+/** The `href` of a one-off contact: `mailto:` an address, `tel:` a number without its spacing. */
+export declare const contactLiteralHref: (channel: "email" | "phone", value: string) => string;
+
+/** Why `value` is not a usable one-off e-mail address or phone number, or null when it is. */
+export declare const contactLiteralProblem: (channel: "email" | "phone", value: string) => string | null;
+
 export declare const CONTENT_FORM_STRINGS: ContentFormStrings;
 
 /** The lifecycle states a content row moves through. */
@@ -829,6 +1239,11 @@ export declare interface ContentFormProps {
     readonly strings?: ContentFormStringsInput;
     /** How rich text's paragraphs and headings are edited — see `RichDocumentEditorProps.surface`. */
     readonly richTextSurface?: 'markup' | 'visual';
+    /**
+     * Where each field's value lives, for its widget's `target`; by default the
+     * field itself. A placed component's props form names its instance and prop.
+     */
+    readonly widgetTarget?: (name: string) => WidgetTarget;
 }
 
 export declare interface ContentFormStrings {
@@ -844,6 +1259,11 @@ export declare interface ContentFormStrings {
     readonly add: string;
     readonly addBlock: string;
     readonly addComponent: string;
+    /** The search above the component picker. */
+    readonly findComponent: string;
+    readonly noComponentFound: string;
+    /** The group of components that name no job. */
+    readonly otherComponents: string;
     readonly unknownComponent: (componentId: string) => string;
     readonly level: string;
     readonly numbered: string;
@@ -851,6 +1271,10 @@ export declare interface ContentFormStrings {
     readonly numberedAt: (depth: number) => string;
     readonly headerRow: string;
     readonly image: string;
+    /** The label of a download block's file. */
+    readonly file: string;
+    /** The label of the text a download block's link shows. */
+    readonly fileLabel: string;
     readonly caption: string;
     readonly text: string;
     readonly listItems: string;
@@ -866,6 +1290,27 @@ export declare interface ContentFormStrings {
     readonly bold: string;
     readonly italic: string;
     readonly underline: string;
+    /** A block's or a selection's named style (a rich-text profile's styles). */
+    readonly style: string;
+    readonly noStyle: string;
+    /** Which component a component block places. */
+    readonly component: string;
+    /** The contact inserter: a published contact point, or a one-off address or number. */
+    readonly contactKind: string;
+    readonly contactPoint: string;
+    readonly contactEmail: string;
+    readonly contactPhone: string;
+    readonly contactValue: string;
+    readonly contactText: string;
+    readonly insertContact: string;
+    /** Above a block holding suggested changes; it is edited again once they are decided. */
+    readonly suggestedChanges: string;
+    /** One suggestion: who made it, what it puts in and takes out. */
+    readonly changeBy: (by: string, inserted: string, deleted: string) => string;
+    readonly accept: string;
+    readonly reject: string;
+    readonly acceptLabel: (by: string) => string;
+    readonly rejectLabel: (by: string) => string;
 }
 
 /** The defaults with an app's words over them. */
@@ -921,13 +1366,11 @@ export declare interface ContentfulNode {
 export declare class ContentGone extends ContentGone_base {
 }
 
-declare const ContentGone_base: Schema_2.TaggedErrorClass<ContentGone, "ContentGone", {
-    readonly _tag: Schema_2.tag<"ContentGone">;
-} & {
-    contentType: typeof Schema_2.String;
+declare const ContentGone_base: Schema_2.Class<ContentGone, Schema_2.TaggedStruct<"ContentGone", {
+    readonly contentType: Schema_2.String;
     /** The address asked for. */
-    path: typeof Schema_2.String;
-}>;
+    readonly path: Schema_2.String;
+}>, YieldableError>;
 
 /** Effect form of {@link contentHealth}. */
 export declare const contentHealth: (...args: Parameters<typeof contentHealth_2>) => Effect<readonly HealthFinding[], never, never>;
@@ -951,12 +1394,10 @@ declare const contentHealth_2: (store: DataStore, types: ReadonlyArray<ContentTy
 export declare class ContentIdConflict extends ContentIdConflict_base {
 }
 
-declare const ContentIdConflict_base: Schema_2.TaggedErrorClass<ContentIdConflict, "ContentIdConflict", {
-    readonly _tag: Schema_2.tag<"ContentIdConflict">;
-} & {
-    contentType: typeof Schema_2.String;
-    id: typeof Schema_2.String;
-}>;
+declare const ContentIdConflict_base: Schema_2.Class<ContentIdConflict, Schema_2.TaggedStruct<"ContentIdConflict", {
+    readonly contentType: Schema_2.String;
+    readonly id: Schema_2.String;
+}>, YieldableError>;
 
 /**
  * Raised by `publish` / `unpublish` / `archive` when the row id doesn't
@@ -967,16 +1408,14 @@ declare const ContentIdConflict_base: Schema_2.TaggedErrorClass<ContentIdConflic
 export declare class ContentNotFound extends ContentNotFound_base {
 }
 
-declare const ContentNotFound_base: Schema_2.TaggedErrorClass<ContentNotFound, "ContentNotFound", {
-    readonly _tag: Schema_2.tag<"ContentNotFound">;
-} & {
-    contentType: typeof Schema_2.String;
-    id: typeof Schema_2.String;
+declare const ContentNotFound_base: Schema_2.Class<ContentNotFound, Schema_2.TaggedStruct<"ContentNotFound", {
+    readonly contentType: Schema_2.String;
+    readonly id: Schema_2.String;
     /** Which lifecycle table the id was looked up in (`revision`: the
      *  revision to publish is not one of this variant's; `share`: a preview
      *  share of the caller's). */
-    stage: Schema_2.Literal<["draft", "published", "revision", "share"]>;
-}>;
+    readonly stage: Schema_2.Literals<readonly ["draft", "published", "revision", "share"]>;
+}>, YieldableError>;
 
 /** A chainable read over one content type's published rows. */
 export declare interface ContentQuery {
@@ -1021,6 +1460,7 @@ export declare interface ContentType {
     /** Whether publishing needs an approved revision — see `ContentTypeSpec.review`. */
     readonly review?: {
         readonly required: boolean | 'workspace';
+        readonly workflow?: ReviewWorkflow;
     };
     /** When documents may be used — see `ContentTypeSpec.availability`. */
     readonly availability?: AvailabilityConfig;
@@ -1070,10 +1510,15 @@ export declare interface ContentTypeSpec {
      * (`approveReview`) — for every path that publishes: single, release,
      * rollback, schedule. Register `cmsReviewsTable` when set. `'workspace'`:
      * each workspace decides (team.ts `setReviewRequired`, or a blueprint's
-     * `team.reviewRequired`) — register `cmsTeamTable` too.
+     * `team.reviewRequired`) — register `cmsTeamTable` too. With `workflow`
+     * (`defineReviewWorkflow`), the approval is a workflow instance that
+     * approved the exact revision — every applicable step decided — instead of
+     * one approval; register `cmsWorkflowInstancesTable` and
+     * `cmsWorkflowDecisionsTable`.
      */
     readonly review?: {
         readonly required: boolean | 'workspace';
+        readonly workflow?: ReviewWorkflow;
     };
     /**
      * When this type's documents may be used (`until`: a date/datetime field,
@@ -1179,16 +1624,14 @@ declare const contentUsage_2: (store: DataStore, types: ReadonlyArray<ContentTyp
 export declare class ContentValidationFailed extends ContentValidationFailed_base {
 }
 
-declare const ContentValidationFailed_base: Schema_2.TaggedErrorClass<ContentValidationFailed, "ContentValidationFailed", {
-    readonly _tag: Schema_2.tag<"ContentValidationFailed">;
-} & {
-    contentType: typeof Schema_2.String;
-    violations: Schema_2.Array$<Schema_2.Struct<{
-        field: typeof Schema_2.String;
-        rule: typeof Schema_2.String;
-        message: typeof Schema_2.String;
+declare const ContentValidationFailed_base: Schema_2.Class<ContentValidationFailed, Schema_2.TaggedStruct<"ContentValidationFailed", {
+    readonly contentType: Schema_2.String;
+    readonly violations: Schema_2.$Array<Schema_2.Struct<{
+        readonly field: Schema_2.String;
+        readonly rule: Schema_2.String;
+        readonly message: Schema_2.String;
     }>>;
-}>;
+}>, YieldableError>;
 
 export declare type ContentValue = Record<string, unknown>;
 
@@ -1212,6 +1655,54 @@ export declare type ContentValue = Record<string, unknown>;
  */
 export declare const contentViolations: (type: Pick<ContentType, "name" | "fields"> & Partial<Pick<ContentType, "taxonomy">>, row: Readonly<Record<string, unknown>>) => ReadonlyArray<FieldViolation>;
 
+/** Effect form of {@link continueBulkRun}. */
+export declare const continueBulkRun: (...args: Parameters<typeof continueBulkRun_2>) => Effect<BulkRunState | null, never, never>;
+
+/**
+ * Do the next `limit` items of a run — each in its own transaction, its
+ * result saved before the next starts — and return where the run stands. A
+ * call after an interruption continues at the first item without a result,
+ * so no item runs twice. Hand it a store outside any transaction.
+ */
+declare const continueBulkRun_2: (store: DataStore, types: ReadonlyArray<ContentType>, runId: string, limit?: number, now?: Date) => Promise<BulkRunState | null>;
+
+/** How many variants the contract allows at most (query strings count as unbounded beyond the budget). */
+export declare const contractVariants: (contract: CacheContract) => number;
+
+/** Effect form of {@link copiesOf}. */
+export declare const copiesOf: (...args: Parameters<typeof copiesOf_2>) => Effect<readonly (CopyOrigin & {
+    readonly documentId: string;
+})[], never, never>;
+
+/** The independent copies made of a document, oldest first. */
+declare const copiesOf_2: (store: DataStore, sourceDocumentId: string) => Promise<ReadonlyArray<CopyOrigin & {
+    readonly documentId: string;
+}>>;
+
+/** Effect form of {@link copyDocument}. */
+export declare const copyDocument: (...args: Parameters<typeof copyDocument_2>) => Effect<CopyDocumentResult, ContentValidationFailed | ContentNotFound | ContentIdConflict | RevisionMismatch, never>;
+
+/**
+ * Copy a document's current draft into a new, independent document in the same
+ * place, in the caller's transaction. The copy is titled `title` — or the
+ * source's title with “(copy)”, numbered from the second copy — and records
+ * the source and the revision it was made from.
+ */
+declare const copyDocument_2: (tx: DataStore, type: ContentType, sourceDocumentId: string, scope: CmsScope, input?: {
+    readonly title?: string;
+    readonly actorId?: string | null;
+}, now?: Date) => Promise<CopyDocumentResult>;
+
+export declare type CopyDocumentResult = {
+    readonly ok: true;
+    readonly id: string;
+    readonly documentId: string;
+    readonly revisionId: string;
+} | {
+    readonly ok: false;
+    readonly reason: 'notFound';
+};
+
 /** Effect form of {@link copyEnvironment}. */
 export declare const copyEnvironment: (...args: Parameters<typeof copyEnvironment_2>) => Effect<CopyEnvironmentResult, never, never>;
 
@@ -1232,6 +1723,19 @@ export declare type CopyEnvironmentResult = {
     readonly variants: number;
 };
 
+export declare interface CopyOrigin {
+    readonly sourceDocumentId: string;
+    readonly sourceRevisionId: string | null;
+    readonly copiedBy: string | null;
+    readonly copiedAt: Date;
+}
+
+/** Effect form of {@link copyOrigin}. */
+export declare const copyOrigin: (...args: Parameters<typeof copyOrigin_2>) => Effect<CopyOrigin | null, never, never>;
+
+/** What a document was copied from, or null when it is an original. */
+declare const copyOrigin_2: (store: DataStore, documentId: string) => Promise<CopyOrigin | null>;
+
 /**
  * A standalone CMS client for build-time consumption (the blog
  * template's CMS mode), where there is no request handle. Same surface
@@ -1244,6 +1748,34 @@ export declare const createCmsClient: (config: {
     secret?: string;
 }) => CmsApi;
 
+/** Effect form of {@link createCollection}. */
+export declare const createCollection: (...args: Parameters<typeof createCollection_2>) => Effect<Collection, never, never>;
+
+/** Create an empty collection in the caller's site and environment. */
+declare const createCollection_2: (tx: DataStore, scope: Pick<CmsScope, "site" | "environment">, input: {
+    readonly name: string;
+    readonly description?: string;
+}) => Promise<Collection>;
+
+/** Effect form of {@link createPortal}. */
+export declare const createPortal: (...args: Parameters<typeof createPortal_2>) => Effect<CreatePortalResult, never, never>;
+
+/** A portal link to a collection: the token is returned once, only its hash is stored. */
+declare const createPortal_2: (tx: DataStore, collectionId: string, input: {
+    readonly expiresAt: Date;
+    readonly maxDownloads?: number | null;
+    readonly label?: string;
+}, now?: Date) => Promise<CreatePortalResult>;
+
+export declare type CreatePortalResult = {
+    readonly ok: true;
+    readonly id: string;
+    readonly token: string;
+} | {
+    readonly ok: false;
+    readonly reason: 'notFound' | 'badExpiry' | 'badLimit';
+};
+
 /** Effect form of {@link createPreviewShare}. */
 export declare const createPreviewShare: (...args: Parameters<typeof createPreviewShare_2>) => Effect<{
     readonly share: Row;
@@ -1281,6 +1813,111 @@ declare const createRelease_2: (store: DataStore, input: {
     readonly environment: string;
 }) => Promise<Row>;
 
+export declare interface CriterionResult extends CutoverCriterion {
+    /** The measured number; null when the measure is missing (which fails). */
+    readonly measured: number | null;
+    readonly pass: boolean;
+}
+
+/** Effect form of {@link cutoverAdoption}. */
+export declare const cutoverAdoption: (...args: Parameters<typeof cutoverAdoption_2>) => Effect<readonly AdoptionEntry[], never, never>;
+
+/**
+ * Who has worked on migrated content since it arrived, per person: the
+ * revisions saved after `since` (the import run), or — without it — after
+ * each document's first revision.
+ */
+declare const cutoverAdoption_2: (store: DataStore, documentIds: ReadonlyArray<string>, since?: Date) => Promise<ReadonlyArray<AdoptionEntry>>;
+
+/** One objective criterion: a named measure against a threshold. */
+export declare interface CutoverCriterion {
+    readonly id: string;
+    /** The measure it reads (a key of the measures handed to `evaluateCutover`). */
+    readonly measure: string;
+    readonly op: 'atMost' | 'atLeast';
+    readonly value: number;
+    /** What it means, in the team's words. */
+    readonly label: string;
+}
+
+export declare interface CutoverDecision {
+    readonly id: string;
+    readonly decision: 'go' | 'fallback';
+    readonly criteria: ReadonlyArray<CriterionResult>;
+    readonly note: string;
+    readonly plan: CutoverPlan | null;
+    readonly decidedBy: string;
+    readonly decidedAt: Date;
+}
+
+/** Effect form of {@link cutoverDecisions}. */
+export declare const cutoverDecisions: (...args: Parameters<typeof cutoverDecisions_2>) => Effect<readonly CutoverDecision[], never, never>;
+
+/** A source's decisions, newest first. */
+declare const cutoverDecisions_2: (store: DataStore, source: string) => Promise<ReadonlyArray<CutoverDecision>>;
+
+export declare interface CutoverIssue {
+    readonly id: string;
+    readonly key: string;
+    readonly kind: string;
+    readonly detail: string;
+    readonly resolution: string | null;
+    readonly resolvedBy: string | null;
+}
+
+/** Effect form of {@link cutoverIssues}. */
+export declare const cutoverIssues: (...args: Parameters<typeof cutoverIssues_2>) => Effect<readonly CutoverIssue[], never, never>;
+
+/** A source's issues, open ones first. */
+declare const cutoverIssues_2: (store: DataStore, source: string) => Promise<ReadonlyArray<CutoverIssue>>;
+
+/**
+ * What a `go` pins: from when the old system takes no more edits (the freeze
+ * — or, with `dualWrite`, until when both are written), where traffic goes,
+ * how many old addresses redirect, whether caches are purged at the switch,
+ * and until when a rollback to the old system stays possible.
+ */
+export declare interface CutoverPlan {
+    readonly freezeAt: Date;
+    readonly dualWrite?: boolean;
+    readonly routing: string;
+    readonly redirects: number;
+    readonly purgeCaches: boolean;
+    readonly rollbackUntil: Date;
+}
+
+/** Why a plan cannot stand, or null. */
+export declare const cutoverPlanProblem: (plan: CutoverPlan, now: Date) => string | null;
+
+/** Effect form of {@link decideCutover}. */
+export declare const decideCutover: (...args: Parameters<typeof decideCutover_2>) => Effect<DecideCutoverResult, never, never>;
+
+/**
+ * Record the decision with the criteria as they stand: `go` only when every
+ * criterion passes and with a plan that pins the switch; `fallback` (stay on
+ * the old system, or return to it) any time, with a note.
+ */
+declare const decideCutover_2: (tx: DataStore, input: {
+    readonly source: string;
+    readonly decision: "go" | "fallback";
+    readonly results: ReadonlyArray<CriterionResult>;
+    readonly note: string;
+    readonly actorId: string;
+    readonly tenantId: string | null;
+    /** Required for `go`. */
+    readonly plan?: CutoverPlan;
+}, now?: Date) => Promise<DecideCutoverResult>;
+
+export declare type DecideCutoverResult = {
+    readonly ok: true;
+    readonly id: string;
+} | {
+    readonly ok: false;
+    readonly reason: 'notReady' | 'noNote' | 'noPlan';
+    readonly failing?: ReadonlyArray<string>;
+    readonly problem?: string;
+};
+
 export declare type DecideExceptionResult = {
     readonly ok: true;
     readonly state: 'approved' | 'rejected' | 'withdrawn';
@@ -1312,31 +1949,147 @@ declare const decideQualityException_2: (tx: DataStore, exceptionId: string, inp
     readonly note?: string;
 }, now?: Date) => Promise<DecideExceptionResult>;
 
-/** Decode character references (`&amp;`, `&#8217;`, `&#x2014;`). */
-export declare const decodeEntities: (text: string) => string;
+/** Who decides, with the scopes they hold (effective scopes of the request). */
+export declare interface Decider {
+    readonly actorId: string;
+    readonly scopes: ReadonlySet<string>;
+}
 
-/** Define an audience; a rule with no condition would match everyone and is refused. */
-export declare const defineAudience: (audience: Audience) => Audience;
+/** Effect form of {@link decideStep}. */
+export declare const decideStep: (...args: Parameters<typeof decideStep_2>) => Effect<DecideStepResult, never, never>;
 
 /**
- * Check a blueprint and order its entries so every referenced entry comes
- * before the entries that reference it. Throws `BlueprintInvalid` for a key
- * used twice, a reference to no entry, or entries that reference each other
- * in a circle.
+ * Approve or request changes on one open step, as `decider`, in the caller's
+ * transaction. The draft must still show the instance's revision; the
+ * requester never decides; a delegated step is decided by its delegate alone.
+ * Approving the last applicable step approves the instance; asking for
+ * changes on any step sends it back.
  */
-export declare const defineBlueprint: (spec: Blueprint) => Blueprint;
+declare const decideStep_2: (tx: DataStore, instanceId: string, stepId: string, decider: Decider, input: {
+    readonly action: "approve" | "requestChanges";
+    readonly evidence?: string;
+    readonly note?: string;
+}, now?: Date) => Promise<DecideStepResult>;
+
+export declare type DecideStepResult = {
+    readonly ok: true;
+    readonly instanceStatus: WorkflowInstance['status'];
+} | {
+    readonly ok: false;
+    readonly reason: StepRefusal;
+};
+
+/** 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;
+
+/** Define an audience; a rule with no condition would match everyone and is refused. */
+export declare const defineAudience: (audience: Audience) => Audience;
+
+/**
+ * Check a blueprint and order its entries so every referenced entry comes
+ * before the entries that reference it. Throws `BlueprintInvalid` for a key
+ * used twice, a reference to no entry, or entries that reference each other
+ * in a circle.
+ */
+export declare const defineBlueprint: (spec: Blueprint) => Blueprint;
 
-/** Declare a component editors can place in a `Schema.Components` field. */
 export declare const defineComponent: (spec: {
     readonly id: string;
     readonly displayName: string;
     readonly props: Readonly<Record<string, FieldSchema | PipeableField>>;
     /** A consent purpose the reader must grant first — an embed that loads a third party. */
     readonly consent?: string;
+    /** What it is for, in an editor's words. */
+    readonly description?: string;
+    /** The editorial jobs it serves; the picker groups and searches by them. */
+    readonly jobs?: ReadonlyArray<string>;
+    readonly variants?: ComponentDefinition["variants"];
+    readonly fixtures?: ComponentDefinition["fixtures"];
+    readonly migrations?: ComponentDefinition["migrations"];
 }) => ComponentDefinition;
 
 export declare const defineContentType: (spec: ContentTypeSpec) => ContentType;
 
+/**
+ * Declare the design tokens components may name (`Schema.Token(tokens, 'tone')`).
+ * Group and token names are camelCase; the values are what an editor reads
+ * beside each name — the renderer owns the actual styles.
+ */
+export declare const defineDesignTokens: <T extends DesignTokens>(tokens: T) => T;
+
+/** Declare a metric; the fingerprint follows its meaning. */
+export declare const defineMetric: (spec: MetricSpec) => MetricDefinition;
+
+/** Declare a review workflow; throws for a duplicate step, an unknown or a cyclic `after`. */
+export declare const defineReviewWorkflow: (spec: ReviewWorkflow) => ReviewWorkflow;
+
+/**
+ * Declare what a rich-text field allows (`Schema.RichText({ profile })`):
+ * its blocks, heading levels and marks, named styles from one design-token
+ * group, the components that may sit between blocks, and how e-mail
+ * addresses and phone numbers are given — a published contact point of
+ * `contactPoints`, and/or a one-off checked on save (`contactLiterals`).
+ * Bump `version` when it changes: a saved document records `<name>@<version>`.
+ * Unset lists allow every built-in block, heading level and mark.
+ */
+export declare const defineRichTextProfile: (spec: {
+    readonly name: string;
+    readonly version: number;
+    readonly blocks?: ReadonlyArray<Exclude<RichBlockKind, "component">>;
+    readonly headings?: ReadonlyArray<2 | 3>;
+    readonly marks?: ReadonlyArray<RichMark>;
+    readonly styles?: {
+        readonly tokens: DesignTokens;
+        readonly group: string;
+    };
+    readonly components?: ReadonlyArray<ComponentDefinition>;
+    readonly contactPoints?: string;
+    readonly contactLiterals?: boolean;
+}) => RichTextProfile;
+
+/** Effect form of {@link delegateStep}. */
+export declare const delegateStep: (...args: Parameters<typeof delegateStep_2>) => Effect<{
+    readonly ok: true;
+} | {
+    readonly ok: false;
+    readonly reason: StepRefusal | "selfDelegation";
+}, never, never>;
+
+/** Hand an open step to a named person (someone allowed to decide it delegates); they decide it from then on. */
+declare const delegateStep_2: (tx: DataStore, instanceId: string, stepId: string, decider: Decider, to: string, now?: Date) => Promise<{
+    readonly ok: true;
+} | {
+    readonly ok: false;
+    readonly reason: StepRefusal | "selfDelegation";
+}>;
+
+export declare interface DeliveryCheck {
+    readonly id: string;
+    readonly contentType: string;
+    readonly documentId: string;
+    readonly locale: string;
+    readonly kind: 'publish' | 'unpublish';
+    readonly revisionId: string | null;
+    readonly url: string;
+    readonly status: 'pending' | 'observed' | 'stale';
+    readonly requestedAt: Date;
+    readonly observedAt: Date | null;
+    readonly lastSeen: string | null;
+    readonly attempts: number;
+}
+
+/** Effect form of {@link deliveryChecks}. */
+export declare const deliveryChecks: (...args: Parameters<typeof deliveryChecks_2>) => Effect<readonly DeliveryCheck[], never, never>;
+
+/** The newest checks, newest first — optionally of one document. */
+declare const deliveryChecks_2: (store: DataStore, options?: {
+    readonly documentId?: string;
+    readonly limit?: number;
+}) => Promise<ReadonlyArray<DeliveryCheck>>;
+
 /**
  * Mark a field computed-on-save from another field. The transform runs
  * before the row is written — `saveDraft` applies it (via
@@ -1365,6 +2118,9 @@ export declare const describeEdit: (fields: Readonly<Record<string, FieldSchema>
 
 export declare const describeFailure: (err: unknown) => string;
 
+/** A design system's tokens: group → token name → what it stands for (a value or a description). */
+export declare type DesignTokens = Readonly<Record<string, Readonly<Record<string, string>>>>;
+
 /** One run of a word diff: text both sides share, or text only one side has. */
 export declare interface DiffSegment {
     readonly op: 'same' | 'removed' | 'added';
@@ -1379,6 +2135,68 @@ export declare interface DiffSegment {
  */
 export declare const diffWords: (before: string, after: string) => ReadonlyArray<DiffSegment>;
 
+/** Effect form of {@link discardCandidate}. */
+export declare const discardCandidate: (...args: Parameters<typeof discardCandidate_2>) => Effect<boolean, never, never>;
+
+/** Leave an open candidate; its AI operation is settled as discarded. */
+declare const discardCandidate_2: (tx: DataStore, candidateId: string, actorId: string, now?: Date) => Promise<boolean>;
+
+export declare interface DocumentGraph {
+    /** False when the document has no content in this perspective. */
+    readonly found: boolean;
+    readonly perspective: 'published' | 'draft' | 'revision';
+    /** The revision the forward edges were read from. */
+    readonly revision: {
+        readonly id: string;
+        readonly number: number;
+    } | null;
+    /** What it points at. */
+    readonly references: ReadonlyArray<ReferenceOccurrence>;
+    /** The components it is built from. */
+    readonly components: ReadonlyArray<ComponentUse>;
+    /** What uses it: live content for `published` and a revision, drafts for `draft`. */
+    readonly usedBy: ReadonlyArray<GraphUse>;
+    /** Its address now, and the addresses that redirect to it. */
+    readonly routes: {
+        readonly path: string | null;
+        readonly formerPaths: ReadonlyArray<string>;
+    };
+    /** The releases that carry one of its variants. */
+    readonly releases: ReadonlyArray<{
+        readonly releaseId: string;
+        readonly name: string;
+        readonly status: string;
+        readonly action: string;
+        readonly revisionId: string | null;
+        readonly locale: string;
+    }>;
+}
+
+/** Effect form of {@link documentGraph}. */
+export declare const documentGraph: (...args: Parameters<typeof documentGraph_2>) => Effect<DocumentGraph, never, never>;
+
+/**
+ * The graph around one document in one place (site, environment, locale) and
+ * perspective. A revision perspective reads that revision's values — the
+ * document as it was then — and refuses a revision of another document.
+ */
+declare const documentGraph_2: (store: DataStore, types: ReadonlyArray<ContentType>, target: {
+    readonly type: ContentType;
+    readonly documentId: string;
+}, scope: CmsScope, perspective?: GraphPerspective) => Promise<DocumentGraph>;
+
+/** Whether any block of the document holds a suggestion. */
+export declare const documentHasChanges: (doc: RichDocument) => boolean;
+
+/** Effect form of {@link draftUses}. */
+export declare const draftUses: (...args: Parameters<typeof draftUses_2>) => Effect<readonly GraphUse[], never, never>;
+
+/** The drafts in a site and environment that reference `target`, with the paths and the revision each is in. */
+declare const draftUses_2: (store: DataStore, types: ReadonlyArray<ContentType>, target: {
+    readonly type: string;
+    readonly documentId: string;
+}, scope: Pick<CmsScope, "site" | "environment">) => Promise<ReadonlyArray<GraphUse>>;
+
 /** Effect form of {@link dropFromSearch}. */
 export declare const dropFromSearch: (...args: Parameters<typeof dropFromSearch_2>) => Effect<void, never, never>;
 
@@ -1408,6 +2226,33 @@ declare const duplicateGroups_2: (store: DataStore, type: ContentType, scope: Cm
     readonly titleField?: string;
 }) => Promise<ReadonlyArray<DuplicateGroup>>;
 
+/**
+ * The response headers that tell `provider` how to keep this answer: how long
+ * (`maxAge`, then `staleWhileRevalidate` served stale while it refetches), the
+ * `Vary` from the identity, and the purge tags in the header the provider
+ * reads (`Cache-Tag` comma-separated; Fastly's `Surrogate-Key` space-separated
+ * with its own `Surrogate-Control`). A request that is not shared-cacheable
+ * gets `private, no-store` and no tags.
+ */
+export declare const edgeHeaders: (provider: EdgeProvider, identity: CacheIdentity, lifetime: {
+    readonly maxAge: number;
+    readonly staleWhileRevalidate?: number;
+}) => Readonly<Record<string, string>>;
+
+/** A shared cache in front of the delivery API: your own (BYO) or a managed one. */
+export declare type EdgeProvider = 'cloudflare' | 'fastly' | 'generic';
+
+/**
+ * The requests that drop every cached answer carrying one of `tags`, and the
+ * answers at `urls` — none when there is nothing to purge or the target is
+ * unusable. Tags a header could not carry and addresses that are not absolute
+ * http(s) URLs are left out rather than sent.
+ */
+export declare const edgePurgeRequests: (provider: PurgeProvider, config: {
+    readonly target: string;
+    readonly token: string | null;
+}, tags: ReadonlyArray<string>, urls?: ReadonlyArray<string>) => ReadonlyArray<PurgeRequest>;
+
 /** What one change did, and a key that tells whether the next change continues it. */
 export declare interface EditDescription {
     readonly label: string;
@@ -1458,11 +2303,33 @@ export declare interface EditWords {
 /** The tools on for the last step of `chain`, and why each tool is as it is. */
 export declare const effectiveExposure: (input: ExposureInput) => ExposureResult;
 
+/** One inherited field of a page as the editor shows it: what it is, where it came from, and what the page may do. */
+export declare interface EffectiveInheritance extends Inherited {
+    readonly field: string;
+    readonly locked: boolean;
+    /** The mask field, when the field may be masked. */
+    readonly mask: string | null;
+    /** What it would be without the page's own value or mask — what "reset" brings back. */
+    readonly inherited: Inherited;
+}
+
+/**
+ * Every inherited field of `node` (the type's `tree.inherit`): its effective
+ * value with the document it came from and how, whether it is locked or may
+ * be masked, and what it would be after a reset. A draft not yet in the tree
+ * inherits through its parent — pass it as `node` and it is placed for the
+ * walk.
+ */
+export declare const effectiveInheritance: (inherit: Readonly<Record<string, InheritRule>>, tree: CmsTree, node: TreeNode) => ReadonlyArray<EffectiveInheritance>;
+
 export declare const EMPTY_EDIT_HISTORY: EditHistory;
 
 /** An empty document. */
 export declare const emptyRichDocument: () => RichDocument;
 
+/** The intent as a URL parameter value (`?select=…`). */
+export declare const encodeSelectionIntent: (intent: SelectionIntent) => string;
+
 export declare interface EnvironmentDifference {
     readonly contentType: string;
     /** Documents (with a variant) in `from` only, and in `to` only. */
@@ -1482,6 +2349,12 @@ export declare interface EnvironmentPair {
     readonly to: string;
 }
 
+/** Every criterion against the measures: each with its measured value, and whether all pass. */
+export declare const evaluateCutover: (criteria: ReadonlyArray<CutoverCriterion>, measures: Readonly<Record<string, number>>) => {
+    readonly results: ReadonlyArray<CriterionResult>;
+    readonly ready: boolean;
+};
+
 export declare type ExceptionState = 'requested' | 'approved' | 'rejected' | 'withdrawn' | 'expired';
 
 export declare interface Experiment {
@@ -1490,15 +2363,18 @@ export declare interface Experiment {
     readonly contentType: string;
     readonly documentId: string;
     readonly locale: string;
-    readonly status: 'running' | 'stopped';
+    readonly status: 'planned' | 'running' | 'stopped';
     readonly share: number;
     readonly overrides: Readonly<Record<string, string>>;
     readonly goal: string;
     /** Null for an experiment started before hypotheses were asked for. */
     readonly hypothesis: string | null;
     readonly guardrailMaxDrop: number | null;
-    readonly startedAt: Date;
+    /** Null while planned. */
+    readonly startedAt: Date | null;
     readonly stoppedAt: Date | null;
+    readonly startReleaseId: string | null;
+    readonly stopReason: 'manual' | 'replaced' | 'rolledBack' | null;
     /** Version A: the published revision it was started on (null before lineage was recorded). */
     readonly revisionId: string | null;
     readonly adoptedReleaseId: string | null;
@@ -1539,6 +2415,22 @@ export declare const experimentLineage: (...args: Parameters<typeof experimentLi
 /** Where every delivery of an experiment came from — revision, version, adoption. */
 declare const experimentLineage_2: (store: DataStore, experimentId: string) => Promise<ExperimentLineage | null>;
 
+/**
+ * Everything version B may override on a page with these values: its text
+ * fields, and each text prop of each component placed on it
+ * (`sections[<instanceId>].heading`).
+ */
+export declare const experimentOverrideKeys: (type: ContentType, values: Readonly<Record<string, unknown>>) => ReadonlyArray<string>;
+
+/**
+ * The release hook experiments need (pass it to `publishRelease`,
+ * `publishDueReleases` and `rollbackRelease` as `afterPublish`): a release
+ * going live starts the experiments planned on it — on the revision it just
+ * published, replacing one still running on that page — and a rollback stops
+ * the experiments the rolled-back release started.
+ */
+export declare const experimentReleaseHook: ReleaseHook;
+
 export declare interface ExperimentResults {
     readonly A: VariantResult;
     readonly B: VariantResult;
@@ -1561,6 +2453,28 @@ export declare const experimentResults: (...args: Parameters<typeof experimentRe
 /** Per version: readers, conversions and rate, the lift of B, and whether the difference is yet more than noise. */
 declare const experimentResults_2: (store: DataStore, experimentId: string) => Promise<ExperimentResults>;
 
+/** Effect form of {@link expiringAmong}. */
+export declare const expiringAmong: (...args: Parameters<typeof expiringAmong_2>) => Effect<readonly ExpiringRight[], never, never>;
+
+/** The published documents whose rights end within `days`, soonest first. */
+declare const expiringAmong_2: (store: DataStore, scope: Pick<CmsScope, "site" | "environment">, days: number, now?: Date) => Promise<ReadonlyArray<ExpiringRight>>;
+
+/** A document whose rights end soon, for a renewal reminder. */
+export declare interface ExpiringRight {
+    readonly contentType: string;
+    readonly documentId: string;
+    readonly until: Date;
+    readonly days: number;
+}
+
+/** Why a dimension is in the identity or not. */
+export declare interface ExplainLine {
+    readonly dimension: string;
+    readonly included: boolean;
+    readonly value: string | null;
+    readonly why: string;
+}
+
 export declare interface ExposureInput {
     readonly ceiling: ReadonlyArray<string>;
     readonly defaults: ReadonlyArray<string>;
@@ -1589,12 +2503,10 @@ export declare const EXTENSION_SLOTS: readonly ["dashboard", "sidebar", "fieldWi
 export declare class ExtensionAccessDenied extends ExtensionAccessDenied_base {
 }
 
-declare const ExtensionAccessDenied_base: Schema_2.TaggedErrorClass<ExtensionAccessDenied, "ExtensionAccessDenied", {
-    readonly _tag: Schema_2.tag<"ExtensionAccessDenied">;
-} & {
-    extensionId: typeof Schema_2.String;
-    capability: typeof Schema_2.String;
-}>;
+declare const ExtensionAccessDenied_base: Schema_2.Class<ExtensionAccessDenied, Schema_2.TaggedStruct<"ExtensionAccessDenied", {
+    readonly extensionId: Schema_2.String;
+    readonly capability: Schema_2.String;
+}>, YieldableError>;
 
 /**
  * What an extension may do; everything else is refused.
@@ -1641,31 +2553,31 @@ export declare interface ExtensionHost {
 
 /** A manifest on the wire — for a descriptor's input or output. */
 export declare const ExtensionManifestSchema: Schema_2.Struct<{
-    id: typeof Schema_2.String;
-    name: typeof Schema_2.String;
-    version: typeof Schema_2.String;
-    publisher: typeof Schema_2.String;
-    capabilities: Schema_2.Array$<typeof Schema_2.String>;
-    slots: Schema_2.Array$<typeof Schema_2.String>;
-    fields: Schema_2.optional<Schema_2.Array$<typeof Schema_2.String>>;
-    settings: Schema_2.optional<Schema_2.Array$<Schema_2.Union<[Schema_2.Struct<{
-        key: typeof Schema_2.String;
-        label: typeof Schema_2.String;
-        kind: Schema_2.Literal<["number"]>;
-        default: typeof Schema_2.Number;
-        min: Schema_2.optional<typeof Schema_2.Number>;
-        max: Schema_2.optional<typeof Schema_2.Number>;
+    readonly id: Schema_2.String;
+    readonly name: Schema_2.String;
+    readonly version: Schema_2.String;
+    readonly publisher: Schema_2.String;
+    readonly capabilities: Schema_2.$Array<Schema_2.String>;
+    readonly slots: Schema_2.$Array<Schema_2.String>;
+    readonly fields: Schema_2.optional<Schema_2.$Array<Schema_2.String>>;
+    readonly settings: Schema_2.optional<Schema_2.$Array<Schema_2.Union<readonly [Schema_2.Struct<{
+        readonly key: Schema_2.String;
+        readonly label: Schema_2.String;
+        readonly kind: Schema_2.Literal<"number">;
+        readonly default: Schema_2.Number;
+        readonly min: Schema_2.optional<Schema_2.Number>;
+        readonly max: Schema_2.optional<Schema_2.Number>;
     }>, Schema_2.Struct<{
-        key: typeof Schema_2.String;
-        label: typeof Schema_2.String;
-        kind: Schema_2.Literal<["boolean"]>;
-        default: typeof Schema_2.Boolean;
+        readonly key: Schema_2.String;
+        readonly label: Schema_2.String;
+        readonly kind: Schema_2.Literal<"boolean">;
+        readonly default: Schema_2.Boolean;
     }>, Schema_2.Struct<{
-        key: typeof Schema_2.String;
-        label: typeof Schema_2.String;
-        kind: Schema_2.Literal<["choice"]>;
-        default: typeof Schema_2.String;
-        options: Schema_2.Array$<typeof Schema_2.String>;
+        readonly key: Schema_2.String;
+        readonly label: Schema_2.String;
+        readonly kind: Schema_2.Literal<"choice">;
+        readonly default: Schema_2.String;
+        readonly options: Schema_2.$Array<Schema_2.String>;
     }>]>>>;
 }>;
 
@@ -1776,6 +2688,12 @@ export declare interface FieldSchema {
     readonly pattern?: string;
     /** Closed value set for `literal` fields → `<select>` + CHECK constraint. */
     readonly literals?: ReadonlyArray<string>;
+    /** What an editor reads for each literal (a token's value, an action's purpose). */
+    readonly literalLabels?: Readonly<Record<string, string>>;
+    /** Set by `Schema.Token`: the design-token group the value names. */
+    readonly token?: string;
+    /** Set by `Schema.Action`: the value names an action the renderer binds. */
+    readonly action?: true;
     /** A `number` field that takes fractions (a `real` column); without it a number is whole. */
     readonly fraction?: boolean;
     /**
@@ -1882,6 +2800,16 @@ 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>;
 
+/** Which content the graph is read from. */
+export declare type GraphPerspective = 'published' | 'draft' | {
+    readonly revisionId: string;
+};
+
+/** One use of the document in the graph's perspective. A draft use names the revision it is in. */
+export declare interface GraphUse extends ReferenceUse {
+    readonly revisionId: string | null;
+}
+
 /** Effect form of {@link hadAddress}. */
 export declare const hadAddress: (...args: Parameters<typeof hadAddress_2>) => Effect<boolean, never, never>;
 
@@ -1937,6 +2865,8 @@ export declare interface HtmlImportOptions {
     readonly resolveImage?: (src: string) => string | null;
     /** Block ids; defaults to a counter, so a test reads stable ids. */
     readonly newId?: () => string;
+    /** Keep `mailto:` and `tel:` links as one-off contacts (a field profile with `contactLiterals`); one that is not a usable address or number is reported. */
+    readonly contacts?: boolean;
 }
 
 export declare interface HtmlImportResult {
@@ -1952,12 +2882,22 @@ declare const indexForSearch_2: (tx: DataStore, type: ContentType, row: Row, sco
 
 /** Where an inherited value came from. */
 export declare interface Inherited {
-    /** The value; undefined when neither the page nor an ancestor sets it. */
+    /** The value; undefined when masked or when nothing in the tree sets it. */
     readonly value: unknown;
-    /** The document that set it: the page itself, an ancestor, or null for none. */
+    /** The document that decided it: the page itself, an ancestor, or null for none. */
     readonly from: string | null;
+    readonly how: InheritedHow;
 }
 
+/**
+ * How a page came by an inherited field:
+ *  - `own` — the page sets it;
+ *  - `ancestor` — the nearest ancestor that sets it;
+ *  - `masked` — the page or an ancestor masks it: nothing shows;
+ *  - `none` — nothing in the tree sets it (the app's site default applies).
+ */
+export declare type InheritedHow = 'own' | 'ancestor' | 'masked' | 'none';
+
 /**
  * The value of an inherited field for `node`: its own when set, else the
  * nearest ancestor's in `tree` (the same locale's variants the tree was built
@@ -1966,12 +2906,20 @@ export declare interface Inherited {
  */
 export declare const inheritedValue: (tree: CmsTree, node: TreeNode, field: string, options?: {
     readonly ancestorsOnly?: boolean;
+    readonly mask?: string;
 }) => Inherited;
 
 /** How one inherited field may be set. */
 export declare interface InheritRule {
     /** No page may set the field; saving one that does is refused (`locked`). */
     readonly locked?: boolean;
+    /**
+     * An optional Boolean field of the same type that MASKS this one: true on a
+     * page means it shows nothing here, on purpose — not "unset" (that
+     * inherits) and not an empty value. Pages below inherit the mask until one
+     * sets its own value or mask. A locked field cannot be masked.
+     */
+    readonly mask?: string;
 }
 
 /** The minimal DOM a surface is read from (a browser element, or jsdom's). */
@@ -1990,7 +2938,7 @@ export declare interface InlineDomNode {
  */
 export declare const inlineFromDom: (root: InlineDomNode) => ReadonlyArray<RichInline>;
 
-/** A run as the HTML a visual surface shows: `strong`, `em`, `u`, `a[data-target]`, escaped text. */
+/** A run as the HTML a visual surface shows: `strong`, `em`, `u`, `span[data-style]`, `a[data-target]`, `a[data-contact]`, escaped text. */
 export declare const inlineHtml: (content: ReadonlyArray<RichInline>) => string;
 
 /** Inline nodes back to the editor's markup (the inverse of `parseInlineMarkup`). */
@@ -2057,12 +3005,24 @@ export declare const isKnownZone: (zone: string) => boolean;
 /** Accept-Language → languages in order of preference (quality factors honoured). */
 export declare const languagesOf: (acceptLanguage: string | undefined) => ReadonlyArray<string>;
 
+/** Effect form of {@link latestWorkflow}. */
+export declare const latestWorkflow: (...args: Parameters<typeof latestWorkflow_2>) => Effect<WorkflowInstance | null, never, never>;
+
+/** The newest instance for a draft (any status), or null. */
+declare const latestWorkflow_2: (store: DataStore, type: ContentType, variantId: string, now?: Date) => Promise<WorkflowInstance | null>;
+
 /** How often a type's documents are checked again, declared on the type. */
 export declare interface LifecycleConfig {
     /** Days from a publish or a recertification to the next review. */
     readonly reviewEveryDays: number;
 }
 
+/** Effect form of {@link listCollections}. */
+export declare const listCollections: (...args: Parameters<typeof listCollections_2>) => Effect<readonly Collection[], never, never>;
+
+/** The caller's collections in a site and environment, by name. */
+declare const listCollections_2: (store: DataStore, scope: Pick<CmsScope, "site" | "environment">) => Promise<ReadonlyArray<Collection>>;
+
 /**
  * List-view configuration for the consuming editor/template: which
  * columns its list page shows and the default sort. Validated by
@@ -2142,6 +3102,15 @@ export declare const liveDraftTexts: (...args: Parameters<typeof liveDraftTexts_
 
 declare const liveDraftTexts_2: (store: DataStore, draft: Row) => Promise<LiveDraftTexts>;
 
+/** One stretch of time a revision was live (`to` null: still live). */
+export declare interface LiveStretch {
+    readonly revision: number;
+    readonly releaseId: string | null;
+    /** ISO timestamps. */
+    readonly from: string;
+    readonly to: string | null;
+}
+
 /** One language's published page tree. */
 export declare interface LocalizedTree {
     readonly locale: string;
@@ -2170,9 +3139,15 @@ export declare const MAX_LIST_LEVEL = 3;
 
 export declare const MAX_OCCURRENCES = 100;
 
+/** The longest a portal link may live. */
+export declare const MAX_PORTAL_DAYS = 90;
+
 /** The longest a preview link may live. */
 export declare const MAX_PREVIEW_SHARE_DAYS = 30;
 
+/** The longest a rollback window may stay open. */
+export declare const MAX_ROLLBACK_DAYS = 30;
+
 /** Cap a string field's length. Past `value` the editor renders a textarea. */
 export declare const maxLength: (value: number) => FieldRefinement;
 
@@ -2188,9 +3163,95 @@ export declare const mediaFields: (type: Pick<ContentType, "fields">) => Readonl
  */
 export declare type MediaResolver = (key: string) => Promise<string | null>;
 
-/** Adjacent text runs with the same marks become one; empty text runs go. */
+/** Adjacent text runs with the same marks and style become one; empty text runs go. */
 export declare const mergeInline: (content: ReadonlyArray<RichInline>) => ReadonlyArray<RichInline>;
 
+export declare interface MetricDefinition extends MetricSpec {
+    /** A digest of what the number means (not of its label or description). */
+    readonly fingerprint: string;
+}
+
+export declare type MetricDrill = 'document' | 'locale' | 'revision' | 'release';
+
+export declare type MetricFreshness = {
+    readonly kind: 'live';
+} | {
+    readonly kind: 'daily';
+} | {
+    readonly kind: 'interval';
+    readonly minutes: number;
+};
+
+export declare interface MetricSpec {
+    readonly id: string;
+    /** Raise it whenever the formula, scope, freshness, quality or drill changes. */
+    readonly version: number;
+    readonly label: string;
+    readonly description: string;
+    /** What is computed, in words a reviewer can check against the code. */
+    readonly formula: string;
+    readonly unit: MetricUnit;
+    /** What it is counted over — `site`, `environment`, `locale`, `document`, `day`… */
+    readonly scope: ReadonlyArray<string>;
+    readonly freshness: MetricFreshness;
+    /** Known limits of the number, e.g. `consent-only`, `utc-days`. */
+    readonly quality: ReadonlyArray<string>;
+    /** Where it drills down to. */
+    readonly drill: ReadonlyArray<MetricDrill>;
+}
+
+export declare type MetricUnit = 'count' | 'ratio' | 'percent' | 'seconds';
+
+/**
+ * The metrics whose meaning changed against a recorded set of
+ * `{ id, version, fingerprint }` without a new version — keep the set in a
+ * test, and this names every silent redefinition.
+ */
+export declare const metricVersionDrift: (metrics: ReadonlyArray<MetricDefinition>, recorded: ReadonlyArray<{
+    readonly id: string;
+    readonly version: number;
+    readonly fingerprint: string;
+}>) => ReadonlyArray<string>;
+
+/** The stages of a migration, in the order they pass. */
+export declare const MIGRATION_STAGES: readonly ["inventory", "mapping", "dryRun", "reconciliation", "delta", "cutover", "fallback", "uat"];
+
+export declare interface MigrationLedger {
+    /** Records per result. */
+    readonly counts: Readonly<Record<'created' | 'already' | 'skipped' | 'failed', number>>;
+    /** Records with a conflict or a loss. */
+    readonly withConflict: number;
+    readonly withLoss: number;
+    readonly records: ReadonlyArray<MigrationRecord & {
+        readonly recordedAt: Date;
+    }>;
+}
+
+/** Effect form of {@link migrationLedger}. */
+export declare const migrationLedger: (...args: Parameters<typeof migrationLedger_2>) => Effect<MigrationLedger, never, never>;
+
+/** The ledger of a source: counts, and the records (those with a conflict or loss first). */
+declare const migrationLedger_2: (store: DataStore, source: string, limit?: number) => Promise<MigrationLedger>;
+
+export declare interface MigrationRecord {
+    readonly sourceKey: string;
+    readonly sourceType: string;
+    readonly result: 'created' | 'already' | 'skipped' | 'failed';
+    readonly targetType?: string | null;
+    readonly targetDocumentId?: string | null;
+    readonly transformation?: string | null;
+    readonly conflict?: string | null;
+    readonly loss?: string | null;
+}
+
+export declare type MigrationStage = (typeof MIGRATION_STAGES)[number];
+
+/** Effect form of {@link migrationStages}. */
+export declare const migrationStages: (...args: Parameters<typeof migrationStages_2>) => Effect<readonly StageState[], never, never>;
+
+/** Every stage of a source's migration, in order — open where nothing is recorded yet. */
+declare const migrationStages_2: (store: DataStore, source: string) => Promise<ReadonlyArray<StageState>>;
+
 /** Readers per version before a result is called at all. */
 export declare const MIN_READERS = 100;
 
@@ -2216,13 +3277,16 @@ export declare const newCapabilities: (granted: ReadonlyArray<ExtensionCapabilit
 /** A nonce for one editing session (unguessable; 128 bits). */
 export declare const newVisualNonce: () => string;
 
+/** A host name as stored: lower-case, trimmed, without a trailing dot; null when it is no host name. */
+export declare const normalizeHost: (input: string) => string | null;
+
 /**
  * The canonical form of a stored value: a plain string becomes paragraphs (a
  * blank line starts a new one), a document keeps its blocks and gets an id on
  * every block that lacks one, anything else is returned as is for the
- * validator to reject.
+ * validator to reject. With a profile, the document records its id.
  */
-export declare const normalizeRichDocument: (value: unknown) => unknown;
+export declare const normalizeRichDocument: (value: unknown, profile?: RichTextProfile) => unknown;
 
 /** The vocabulary's terms for `input`, in first-seen order, and what it does not know. */
 export declare const normalizeTerms: (config: Pick<TaxonomyConfig, "terms">, input: ReadonlyArray<unknown>) => {
@@ -2257,6 +3321,22 @@ export declare const openDraftTexts: (...args: Parameters<typeof openDraftTexts_
  */
 declare const openDraftTexts_2: (tx: DataStore, type: ContentType, draftId: string) => Promise<ReadonlyArray<Row>>;
 
+/** An open step that fell due in a window — for a reminder to whoever decides it. */
+export declare interface OverdueStep {
+    readonly instance: WorkflowInstance;
+    readonly step: StepState;
+}
+
+/** Effect form of {@link overdueSteps}. */
+export declare const overdueSteps: (...args: Parameters<typeof overdueSteps_2>) => Effect<readonly OverdueStep[], never, never>;
+
+/**
+ * Open steps whose due time lies in `(since, now]` — each once, when a sweep
+ * runs over consecutive windows. The reminder is derived from the state; it
+ * changes nothing. Hand it a store over every tenant (a schedule's `app.store`).
+ */
+declare const overdueSteps_2: (store: DataStore, since: Date, now: Date) => Promise<ReadonlyArray<OverdueStep>>;
+
 /** Where a document lives in one language. */
 export declare interface PageAlternate {
     readonly locale: string;
@@ -2284,10 +3364,25 @@ export declare interface PageTemplate {
         readonly component: ComponentDefinition;
         readonly count: number;
     }>;
+    /** Other `Schema.Components` fields of the type (an aside), each with its own rules. */
+    readonly regions?: Readonly<Record<string, RegionRule>>;
+    /** The widths a component may take here: the values its `TemplatesConfig.width` prop may hold. */
+    readonly widths?: ReadonlyArray<{
+        readonly component: ComponentDefinition;
+        readonly allowed: ReadonlyArray<string>;
+    }>;
+    /** How deep components may sit inside each other's slots; 1 = no nesting. */
+    readonly maxDepth?: number;
 }
 
-/** Parse the editor's inline markup into inline nodes. Unclosed markers stay text. */
-export declare const parseInlineMarkup: (input: string) => ReadonlyArray<RichInline>;
+/** Parse the editor's inline markup into inline nodes. Unclosed markers stay text; `{name|…}` is a style only for a name in `styles`. */
+export declare const parseInlineMarkup: (input: string, styles?: ReadonlyArray<string>) => ReadonlyArray<RichInline>;
+
+/** An anchor from someone else's presence, or null when it is not one of the declared shapes. */
+export declare const parsePresenceAnchor: (value: unknown) => PresenceAnchor | null;
+
+/** An intent from a URL or a message, or null when it is not one of the declared shape. Untrusted input. */
+export declare const parseSelectionIntent: (value: unknown) => SelectionIntent | null;
 
 /** `sections.2` → `{ field: 'sections', index: 2 }`; `title` → `{ field: 'title' }`. */
 export declare const parseSourcePath: (path: string) => {
@@ -2298,14 +3393,75 @@ export declare const parseSourcePath: (path: string) => {
 /** Read an XLIFF 2.x file with one `<file>`: languages, notes and each unit's source and target. */
 export declare const parseXliff: (xml: string) => XliffExchange;
 
+/** Effect form of {@link passStage}. */
+export declare const passStage: (...args: Parameters<typeof passStage_2>) => Effect<PassStageResult, never, never>;
+
+/**
+ * Pass a stage's exit gate: only its owner, with a note; only after every
+ * earlier stage passed; and only when `gate` (the stage's objective check,
+ * when it has one) holds.
+ */
+declare const passStage_2: (tx: DataStore, source: string, stage: MigrationStage, input: {
+    readonly actorId: string;
+    readonly note: string;
+    readonly evidenceUri?: string;
+    readonly gate?: boolean;
+}, now?: Date) => Promise<PassStageResult>;
+
+export declare type PassStageResult = {
+    readonly ok: true;
+} | {
+    readonly ok: false;
+    readonly reason: 'noOwner' | 'notOwner' | 'noNote' | 'earlierOpen' | 'gateNotMet' | 'passed';
+    readonly stage?: MigrationStage;
+};
+
 /** Constrain a string field to a regex (source form, validated on save). */
 export declare const pattern: (re: RegExp) => FieldRefinement;
 
+/** One suggestion: who made it and when, the blocks it touches, and the text it puts in and takes out. */
+export declare interface PendingChange {
+    readonly id: string;
+    readonly by: string;
+    readonly at: string;
+    readonly blockIds: ReadonlyArray<string>;
+    readonly inserted: string;
+    readonly deleted: string;
+    /** Blocks it inserts or deletes whole (an image, a component, a paragraph). */
+    readonly blocks: number;
+}
+
+/** The suggestions in a document, in order of first appearance. */
+export declare const pendingChanges: (doc: RichDocument) => ReadonlyArray<PendingChange>;
+
 /** The first variant whose audience matches, or null for the original. Variants naming an unknown audience never match. */
 export declare const pickVariant: <V extends {
     readonly audience: string;
 }>(variants: ReadonlyArray<V>, audiences: ReadonlyArray<Audience>, signals: AudienceSignals) => V | null;
 
+/** One inherited field as a release pinned it. */
+export declare interface PinnedInheritance {
+    readonly how: InheritedHow;
+    /** The document that decided it (the page, an ancestor), null for none. */
+    readonly from: string | null;
+    readonly value: unknown;
+    /** A readable name for the value — a referenced document's title. */
+    readonly label?: string | null;
+    /** The revision of the referenced document that was live then, when the value is a reference. */
+    readonly revisionId?: string | null;
+}
+
+/** Effect form of {@link pinReleaseInheritance}. */
+export declare const pinReleaseInheritance: (...args: Parameters<typeof pinReleaseInheritance_2>) => Effect<boolean, never, never>;
+
+/**
+ * Record what a release's item inherited as it went live — run from an
+ * `afterPublish` hook, where the tree is the one the release just made. Kept
+ * on the item, so the release shows what its pages showed even after a
+ * header changes, and a rollback says what it returns to.
+ */
+declare const pinReleaseInheritance_2: (tx: DataStore, releaseId: string, variantId: string, inherited: Readonly<Record<string, PinnedInheritance>>) => Promise<boolean>;
+
 export declare interface PipeableField extends FieldSchema {
     readonly isOptional: boolean;
     pipe(...refinements: ReadonlyArray<FieldRefinement>): PipeableField;
@@ -2349,6 +3505,31 @@ export declare const planBulk: (...args: Parameters<typeof planBulk_2>) => Effec
 /** The dry run: what `action` would do to each item, changing nothing. */
 declare const planBulk_2: (store: DataStore, types: ReadonlyArray<ContentType>, place: Place, action: BulkAction, items: ReadonlyArray<BulkItem>) => Promise<ReadonlyArray<PlannedItem>>;
 
+/** Effect form of {@link planExperiment}. */
+export declare const planExperiment: (...args: Parameters<typeof planExperiment_2>) => Effect<PlanExperimentResult, never, never>;
+
+/**
+ * Plan an experiment that starts when `releaseId` goes live — the experiment
+ * is content state: it ships, and rolls back, with the release that carries
+ * its page. The release must still be a draft or scheduled and publish this
+ * page in this language; version B's keys are checked against the page's
+ * draft. Started by {@link experimentReleaseHook}. In the caller's transaction.
+ */
+declare const planExperiment_2: (tx: DataStore, type: ContentType, scope: CmsScope, input: StartExperimentInput & {
+    readonly releaseId: string;
+}) => Promise<PlanExperimentResult>;
+
+export declare type PlanExperimentResult = {
+    readonly ok: true;
+    readonly id: string;
+} | {
+    readonly ok: false;
+    readonly reason: Exclude<StartExperimentResult, {
+        ok: true;
+    }>['reason'] | 'releaseNotEditable' | 'notInRelease' | 'alreadyPlanned';
+    readonly fields?: ReadonlyArray<string>;
+};
+
 export declare interface PlannedItem extends BulkItem {
     readonly documentId: string | null;
     readonly title: string;
@@ -2367,6 +3548,76 @@ export declare const planPromotion: (...args: Parameters<typeof planPromotion_2>
 /** What promoting `from` into `to` would change, per document and language. */
 declare const planPromotion_2: (store: DataStore, types: ReadonlyArray<ContentType>, pair: EnvironmentPair) => Promise<ReadonlyArray<PromotionItem>>;
 
+/** Effect form of {@link planReferenceReplacement}. */
+export declare const planReferenceReplacement: (...args: Parameters<typeof planReferenceReplacement_2>) => Effect<ReplacementPlan, never, never>;
+
+/**
+ * The drafts that reference `from`, grouped per variant with every path —
+ * what replacing it with `to` (a document of the same type) would change.
+ */
+declare const planReferenceReplacement_2: (store: DataStore, types: ReadonlyArray<ContentType>, from: {
+    readonly type: string;
+    readonly documentId: string;
+}, to: {
+    readonly type: string;
+    readonly documentId: string;
+}, scope: Pick<CmsScope, "site" | "environment">) => Promise<ReplacementPlan>;
+
+export declare interface Portal {
+    readonly id: string;
+    readonly label: string | null;
+    readonly expiresAt: Date;
+    readonly revoked: boolean;
+    readonly maxDownloads: number | null;
+    readonly downloads: number;
+}
+
+export declare type PortalDownloadResult = {
+    readonly ok: true;
+    readonly contentType: string;
+    readonly tenantId: string | null;
+    readonly downloadsLeft: number | null;
+} | {
+    readonly ok: false;
+    readonly reason: 'unknown' | 'expired' | 'revoked' | 'notInCollection' | 'limitReached';
+};
+
+export declare type PresenceAnchor = {
+    readonly kind: 'view';
+    readonly view: string;
+} | {
+    readonly kind: 'field';
+    readonly field: string;
+} | {
+    readonly kind: 'component';
+    readonly field: string;
+    readonly instanceId: string;
+    readonly componentId: string;
+} | {
+    readonly kind: 'slot';
+    readonly field: string;
+    readonly instanceId: string;
+    readonly componentId: string;
+    readonly prop: string;
+} | {
+    readonly kind: 'selection';
+    readonly field: string;
+    readonly start: number;
+    readonly end: number;
+} | {
+    readonly kind: 'assetRegion';
+    readonly x: number;
+    readonly y: number;
+    readonly width: number;
+    readonly height: number;
+};
+
+/**
+ * The anchor of a focused control in a `ContentForm`: the field, or — inside
+ * a placed component — the component, or the prop (slot) within it.
+ */
+export declare const presenceAnchorOf: (target: unknown) => PresenceAnchor | null;
+
 /** A verified preview claim. */
 export declare interface PreviewClaim {
     readonly type: string;
@@ -2398,11 +3649,9 @@ export declare type PreviewMessage = {
 export declare class PreviewShareRejected extends PreviewShareRejected_base {
 }
 
-declare const PreviewShareRejected_base: Schema_2.TaggedErrorClass<PreviewShareRejected, "PreviewShareRejected", {
-    readonly _tag: Schema_2.tag<"PreviewShareRejected">;
-} & {
-    reason: Schema_2.Literal<["expiryInPast", "expiryTooFar"]>;
-}>;
+declare const PreviewShareRejected_base: Schema_2.Class<PreviewShareRejected, Schema_2.TaggedStruct<"PreviewShareRejected", {
+    readonly reason: Schema_2.Literals<readonly ["expiryInPast", "expiryTooFar"]>;
+}>, YieldableError>;
 
 /** Mint a signed preview token for a draft row. */
 export declare const previewToken: (type: string, id: string, options?: {
@@ -2410,6 +3659,12 @@ export declare const previewToken: (type: string, id: string, options?: {
     secret?: string;
 }) => string;
 
+/** Effect form of {@link primaryDomain}. */
+export declare const primaryDomain: (...args: Parameters<typeof primaryDomain_2>) => Effect<string | null, never, never>;
+
+/** The site's primary domain, or null. */
+declare const primaryDomain_2: (store: DataStore, site: string) => 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>;
 
@@ -2450,6 +3705,28 @@ export declare interface PromotionSelection {
 /** The hash an operation keeps of its prompt: enough to tell two prompts apart, nothing to read back. */
 export declare const promptHash: (prompt: string) => string;
 
+/** Effect form of {@link proposeCandidate}. */
+export declare const proposeCandidate: (...args: Parameters<typeof proposeCandidate_2>) => Effect<{
+    readonly ok: true;
+    readonly id: string;
+} | {
+    readonly ok: false;
+    readonly reason: "notFound" | "empty";
+}, never, never>;
+
+/** Keep a proposal for a draft — only the type's declared fields; the id of the candidate. */
+declare const proposeCandidate_2: (tx: DataStore, type: ContentType, variantId: string, scope: CmsScope, input: {
+    readonly values: Readonly<Record<string, unknown>>;
+    readonly operationId?: string | null;
+    readonly suggestedBy?: string | null;
+}) => Promise<{
+    readonly ok: true;
+    readonly id: string;
+} | {
+    readonly ok: false;
+    readonly reason: "notFound" | "empty";
+}>;
+
 /** 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>;
 
@@ -2483,7 +3760,7 @@ export declare const publishDueReleases: (...args: Parameters<typeof publishDueR
  * that went live. Hand it a store outside any transaction (a schedule's
  * `app.store`).
  */
-declare const publishDueReleases_2: (store: DataStore, types: ReadonlyArray<ContentType>, now?: Date) => Promise<ReadonlyArray<string>>;
+declare const publishDueReleases_2: (store: DataStore, types: ReadonlyArray<ContentType>, now?: Date, options?: PublishReleaseOptions) => Promise<ReadonlyArray<string>>;
 
 /** Options for {@link publish}. */
 export declare interface PublishOptions {
@@ -2496,13 +3773,11 @@ 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>;
 
-/**
- * Publish every entry of a release — in the CALLER'S transaction, so either
- * all of them go live or, when one fails, none does. Records what each variant
- * showed before (for rollback) and marks the release `published`. Throws
- * `ReleaseNotEditable` for a release that is already published or failed.
- */
-declare const publishRelease_2: (tx: DataStore, types: ReadonlyArray<ContentType>, releaseId: string, now?: Date) => Promise<Row>;
+declare const publishRelease_2: (tx: DataStore, types: ReadonlyArray<ContentType>, releaseId: string, now?: Date, options?: PublishReleaseOptions) => Promise<Row>;
+
+export declare interface PublishReleaseOptions {
+    readonly afterPublish?: ReadonlyArray<ReleaseHook>;
+}
 
 /** 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>;
@@ -2519,16 +3794,32 @@ export declare interface PublishSeries {
 
 /**
  * What stops these values from being published: every `requiredToPublish()`
- * field that is empty (absent, null, or a blank string). Browser-safe, so an
- * editor can say so before the publish is refused.
+ * field that is empty (absent, null, or a blank string), and every rich text
+ * that still holds suggested changes. Browser-safe, so an editor can say so
+ * before the publish is refused.
  */
 export declare const publishViolations: (type: Pick<ContentType, "fields">, values: Readonly<Record<string, unknown>>) => ReadonlyArray<FieldViolation>;
 
+export declare type PurgeProvider = 'cloudflare' | 'fastly' | 'webhook';
+
+export declare interface PurgeRequest {
+    readonly url: string;
+    readonly method: 'POST';
+    readonly headers: Readonly<Record<string, string>>;
+    readonly body?: string;
+}
+
 /** The purposes the components of `type` need, for a banner to ask about. */
 export declare const purposesUsedBy: (type: {
     readonly fields: Readonly<Record<string, FieldSchema>>;
 }) => ReadonlySet<string>;
 
+/** When and where a quality rule is checked; `scope` is null where no place is known (every pack then applies). */
+export declare interface QualityContext {
+    readonly now: Date;
+    readonly scope: CmsScope | null;
+}
+
 export declare interface QualityException {
     readonly id: string;
     readonly ruleId: string;
@@ -2552,10 +3843,16 @@ export declare interface QualityFinding {
     readonly field: string;
     readonly message: string;
     readonly blocking: boolean;
+    /** The policy pack the rule belongs to, if any. */
+    readonly pack: string | null;
 }
 
-/** What a type's rules find in these values — pure, for the editor as for the gate. */
-export declare const qualityFindings: (type: Pick<ContentType, "quality">, values: Readonly<Record<string, unknown>>) => ReadonlyArray<QualityFinding>;
+/**
+ * What a type's rules find in these values — pure, for the editor as for the
+ * gate. With `at`, only the packs of that place apply and checks see that
+ * moment; without, every rule is checked now.
+ */
+export declare const qualityFindings: (type: Pick<ContentType, "quality">, values: Readonly<Record<string, unknown>>, at?: QualityContext) => ReadonlyArray<QualityFinding>;
 
 /** One quality check of a type — see `ContentTypeSpec.quality`. */
 export declare interface QualityRule {
@@ -2567,8 +3864,16 @@ export declare interface QualityRule {
     readonly message: string;
     /** Whether publishing waits for a repair or an approved exception. Default true. */
     readonly blocking?: boolean;
-    /** True when the values have the finding. Pure. */
-    readonly check: (values: Readonly<Record<string, unknown>>) => boolean;
+    /**
+     * The policy pack it belongs to (`'EU claims'`, `'German market'`) — shown
+     * beside the finding. With `sites` / `locales` a pack applies only there;
+     * absent, everywhere.
+     */
+    readonly pack?: string;
+    readonly sites?: ReadonlyArray<string>;
+    readonly locales?: ReadonlyArray<string>;
+    /** True when the values have the finding. Pure; `at` says when and where (a claim's evidence may have run out). */
+    readonly check: (values: Readonly<Record<string, unknown>>, at: QualityContext) => boolean;
 }
 
 /** Effect form of {@link qualityViolations}. */
@@ -2581,6 +3886,25 @@ export declare const qualityViolations: (...args: Parameters<typeof qualityViola
  */
 declare const qualityViolations_2: (store: DataStore, type: ContentType, variantId: string, scope: CmsScope, values: Readonly<Record<string, unknown>>, now?: Date) => Promise<ReadonlyArray<FieldViolation>>;
 
+/** One allowed query parameter. */
+export declare type QueryParam = {
+    readonly name: string;
+    readonly type: 'string';
+    readonly maxLength?: number;
+    readonly default?: string;
+} | {
+    readonly name: string;
+    readonly type: 'int';
+    readonly min?: number;
+    readonly max?: number;
+    readonly default?: number;
+} | {
+    readonly name: string;
+    readonly type: 'enum';
+    readonly values: ReadonlyArray<string>;
+    readonly default?: string;
+};
+
 /**
  * Raised when a create would take a tenant past a limit its app set — more
  * documents, keys or environments than it may hold. Nothing was written;
@@ -2589,13 +3913,11 @@ declare const qualityViolations_2: (store: DataStore, type: ContentType, variant
 export declare class QuotaExceeded extends QuotaExceeded_base {
 }
 
-declare const QuotaExceeded_base: Schema_2.TaggedErrorClass<QuotaExceeded, "QuotaExceeded", {
-    readonly _tag: Schema_2.tag<"QuotaExceeded">;
-} & {
-    quota: typeof Schema_2.String;
-    limit: typeof Schema_2.Number;
-    used: typeof Schema_2.Number;
-}>;
+declare const QuotaExceeded_base: Schema_2.Class<QuotaExceeded, Schema_2.TaggedStruct<"QuotaExceeded", {
+    readonly quota: Schema_2.String;
+    readonly limit: Schema_2.Number;
+    readonly used: Schema_2.Number;
+}>, YieldableError>;
 
 /** Effect form of {@link readChanges}. */
 export declare const readChanges: (...args: Parameters<typeof readChanges_2>) => Effect<{
@@ -2637,6 +3959,16 @@ 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;
 
+/**
+ * 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
+ * supplies it — a plain `fetch` through the public front door. An address that
+ * shows more than its own entry (a page with the header and blocks it
+ * includes) answers every revision it shows: a check of an included document
+ * is observed there once its revision is among them.
+ */
+export declare type ReadRevision = (url: string) => Promise<string | ReadonlyArray<string>>;
+
 /** Effect form of {@link rebaseDraftTexts}. */
 export declare const rebaseDraftTexts: (...args: Parameters<typeof rebaseDraftTexts_2>) => Effect<void, ContentNotFound, never>;
 
@@ -2680,6 +4012,19 @@ export declare const recordChange: (...args: Parameters<typeof recordChange_2>)
 /** Append one change, in the caller's transaction. A type without `changeFeed` writes nothing. */
 declare const recordChange_2: (tx: DataStore, type: ContentType, row: Row, scope: CmsScope, action: "published" | "unpublished", origin?: ChangeOrigin) => Promise<void>;
 
+/** Effect form of {@link recordCutoverIssues}. */
+export declare const recordCutoverIssues: (...args: Parameters<typeof recordCutoverIssues_2>) => Effect<number, never, never>;
+
+/**
+ * Record what a run found: an issue not seen before opens; one seen again
+ * keeps its resolution (a closed issue stays closed). Returns how many are new.
+ */
+declare const recordCutoverIssues_2: (tx: DataStore, source: string, found: ReadonlyArray<{
+    readonly key: string;
+    readonly kind: string;
+    readonly detail: string;
+}>, tenantId: string | null) => Promise<number>;
+
 /**
  * Record a change: `before` is the form as it was. A change with the same key
  * within `mergeMs` of the last step continues it (typing is one step). The
@@ -2701,6 +4046,12 @@ export declare const recordExperimentEvent: (...args: Parameters<typeof recordEx
  */
 declare const recordExperimentEvent_2: (store: DataStore, experiment: Experiment, readerId: string, kind: "exposure" | "conversion", now?: Date) => Promise<boolean>;
 
+/** Effect form of {@link recordMigrationRecords}. */
+export declare const recordMigrationRecords: (...args: Parameters<typeof recordMigrationRecords_2>) => Effect<void, never, never>;
+
+/** Record what a run did with each source record; a record seen again is updated, not doubled. */
+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>;
 
@@ -2712,6 +4063,16 @@ export declare const recordPaths: (...args: Parameters<typeof recordPaths_2>) =>
  */
 declare const recordPaths_2: (tx: DataStore, type: ContentType, scope: CmsScope, tenantId: unknown) => Promise<void>;
 
+/** Effect form of {@link recordPortalDownload}. */
+export declare const recordPortalDownload: (...args: Parameters<typeof recordPortalDownload_2>) => Effect<PortalDownloadResult, never, never>;
+
+/**
+ * Count one download of a document through a portal. Refused once the cap is
+ * reached; the count is a conditional update on the value read, retried on a
+ * race, so two downloads at once never pass the cap.
+ */
+declare const recordPortalDownload_2: (store: DataStore, token: string, documentId: string, now?: Date) => Promise<PortalDownloadResult>;
+
 export declare type RecurrenceEvery = 'day' | 'week' | 'month';
 
 /** What is wrong with a rule, in words; empty when it can be scheduled. */
@@ -2763,18 +4124,16 @@ export declare const referencesOf: (type: ContentType, values: Readonly<Record<s
 export declare class ReferenceUnavailable extends ReferenceUnavailable_base {
 }
 
-declare const ReferenceUnavailable_base: Schema_2.TaggedErrorClass<ReferenceUnavailable, "ReferenceUnavailable", {
-    readonly _tag: Schema_2.tag<"ReferenceUnavailable">;
-} & {
-    contentType: typeof Schema_2.String;
-    id: typeof Schema_2.String;
-    targets: Schema_2.Array$<Schema_2.Struct<{
-        path: typeof Schema_2.String;
-        contentType: typeof Schema_2.String;
-        documentId: typeof Schema_2.String;
-        reason: Schema_2.Literal<["blocked", "expired"]>;
+declare const ReferenceUnavailable_base: Schema_2.Class<ReferenceUnavailable, Schema_2.TaggedStruct<"ReferenceUnavailable", {
+    readonly contentType: Schema_2.String;
+    readonly id: Schema_2.String;
+    readonly targets: Schema_2.$Array<Schema_2.Struct<{
+        readonly path: Schema_2.String;
+        readonly contentType: Schema_2.String;
+        readonly documentId: Schema_2.String;
+        readonly reason: Schema_2.Literals<readonly ["blocked", "expired", "notYet", "territory", "channel", "purpose"]>;
     }>>;
-}>;
+}>, YieldableError>;
 
 /** One live use of a document. */
 export declare interface ReferenceUse {
@@ -2785,6 +4144,15 @@ export declare interface ReferenceUse {
     readonly path: string;
 }
 
+/** The rules of one region of a template. */
+export declare interface RegionRule {
+    /** Only these components may be placed here (all the field allows, when unset). */
+    readonly allowed?: ReadonlyArray<ComponentDefinition>;
+    readonly required?: ReadonlyArray<ComponentDefinition>;
+    /** The most components the region may hold. */
+    readonly maxItems?: number;
+}
+
 /** Effect form of {@link regrantExtension}. */
 export declare const regrantExtension: (...args: Parameters<typeof regrantExtension_2>) => Effect<ExtensionChange, never, never>;
 
@@ -2794,6 +4162,62 @@ declare const regrantExtension_2: (tx: DataStore, extensionId: string, consent:
 /** The lifecycle of a release. */
 export declare const RELEASE_STATUSES: readonly ["draft", "scheduled", "published", "failed"];
 
+/**
+ * One address of a release's entry, and whether it shows what the release did.
+ * An entry has its own address and, when other pages include it (a header, a
+ * shared block), one per page a check was requested for.
+ */
+export declare interface ReleaseAddress {
+    readonly contentType: string;
+    readonly documentId: string;
+    readonly locale: string;
+    readonly action: 'publish' | 'unpublish';
+    /** `unchecked`: the entry has no public address to read (no check was requested). */
+    readonly status: 'observed' | 'pending' | 'stale' | 'unchecked';
+    readonly url: string | null;
+    readonly tookSeconds: number | null;
+    readonly lastSeen: string | null;
+}
+
+/** Whether a published release reached readers at every address of its entries. */
+export declare interface ReleaseCheckpoint {
+    readonly releaseId: string;
+    readonly status: string;
+    readonly publishedAt: Date | null;
+    readonly addresses: ReadonlyArray<ReleaseAddress>;
+    /** Addresses that answer as the release left them, of those that are read. */
+    readonly reached: number;
+    readonly checked: number;
+    /** Every read address answers as the release left it, and none is still pending. */
+    readonly complete: boolean;
+}
+
+/** Effect form of {@link releaseCheckpoint}. */
+export declare const releaseCheckpoint: (...args: Parameters<typeof releaseCheckpoint_2>) => Effect<ReleaseCheckpoint | null, never, never>;
+
+/**
+ * The release's checkpoint across addresses: for each entry, the newest
+ * delivery check of every address requested when the release went out — the
+ * publish answering with the revision the release pinned, the take-down no
+ * longer answering — read through the public address. The pages that include
+ * an entry count like its own address. A purge is not a checkpoint; an
+ * observed address is. Null for a release the caller cannot see.
+ */
+declare const releaseCheckpoint_2: (store: DataStore, releaseId: string) => Promise<ReleaseCheckpoint | null>;
+
+/**
+ * Publish every entry of a release — in the CALLER'S transaction, so either
+ * all of them go live or, when one fails, none does. Records what each variant
+ * showed before (for rollback) and marks the release `published`. Throws
+ * `ReleaseNotEditable` for a release that is already published or failed.
+ */
+/**
+ * Work that belongs to a release going live — an experiment it starts, one its
+ * rollback stops. Runs in the release's transaction after its items, so a hook
+ * that fails fails the release.
+ */
+export declare type ReleaseHook = (tx: DataStore, release: Row, now: Date) => Promise<void>;
+
 /**
  * Raised when a release is asked to change in a state that does not allow it:
  * adding to or scheduling a release that is no longer a draft, publishing one
@@ -2802,12 +4226,10 @@ export declare const RELEASE_STATUSES: readonly ["draft", "scheduled", "publishe
 export declare class ReleaseNotEditable extends ReleaseNotEditable_base {
 }
 
-declare const ReleaseNotEditable_base: Schema_2.TaggedErrorClass<ReleaseNotEditable, "ReleaseNotEditable", {
-    readonly _tag: Schema_2.tag<"ReleaseNotEditable">;
-} & {
-    id: typeof Schema_2.String;
-    status: typeof Schema_2.String;
-}>;
+declare const ReleaseNotEditable_base: Schema_2.Class<ReleaseNotEditable, Schema_2.TaggedStruct<"ReleaseNotEditable", {
+    readonly id: Schema_2.String;
+    readonly status: Schema_2.String;
+}>, YieldableError>;
 
 export declare type ReleaseStatus = (typeof RELEASE_STATUSES)[number];
 
@@ -2817,21 +4239,93 @@ export declare const releaseStatusOf: (...args: Parameters<typeof releaseStatusO
 /** A release's status (`draft`, `scheduled`, `published`, …), or null when there is none of that id. */
 declare const releaseStatusOf_2: (store: DataStore, releaseId: string) => Promise<string | null>;
 
+/** Effect form of {@link removeDomain}. */
+export declare const removeDomain: (...args: Parameters<typeof removeDomain_2>) => Effect<{
+    readonly ok: true;
+} | {
+    readonly ok: false;
+    readonly reason: "notFound" | "primary";
+}, never, never>;
+
+/** Remove a domain. The primary one is removed only after another took its place. */
+declare const removeDomain_2: (tx: DataStore, domainId: string) => Promise<{
+    readonly ok: true;
+} | {
+    readonly ok: false;
+    readonly reason: "notFound" | "primary";
+}>;
+
+/** Effect form of {@link removeFromCollection}. */
+export declare const removeFromCollection: (...args: Parameters<typeof removeFromCollection_2>) => Effect<boolean, never, never>;
+
+/** Take a document out of a collection. */
+declare const removeFromCollection_2: (tx: DataStore, collectionId: string, documentId: string) => Promise<boolean>;
+
 /** Effect form of {@link removeGlossaryTerm}. */
 export declare const removeGlossaryTerm: (...args: Parameters<typeof removeGlossaryTerm_2>) => Effect<boolean, never, never>;
 
-/** Remove an entry; false when there was none in this workspace. */
-declare const removeGlossaryTerm_2: (tx: DataStore, tenantId: string, entryId: string) => Promise<boolean>;
+/** Remove an entry; false when there was none in this workspace. */
+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>;
+
+/**
+ * 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>;
+
+/** Effect form of {@link reopenStage}. */
+export declare const reopenStage: (...args: Parameters<typeof reopenStage_2>) => Effect<number, never, never>;
+
+/**
+ * Reopen a stage and every stage after it — the fallback: a failure returns
+ * the migration to the last stage that is still proven.
+ */
+declare const reopenStage_2: (tx: DataStore, source: string, stage: MigrationStage) => Promise<number>;
+
+/** One draft a replacement would change. */
+export declare interface ReplacementItem {
+    readonly type: string;
+    readonly documentId: string;
+    readonly variantId: string;
+    readonly locale: string;
+    /** The revision the plan saw — an edit in between is not overwritten. */
+    readonly revisionId: string | null;
+    readonly paths: ReadonlyArray<string>;
+}
+
+export declare type ReplacementPlan = {
+    readonly ok: true;
+    readonly items: ReadonlyArray<ReplacementItem>;
+} | {
+    readonly ok: false;
+    readonly reason: 'sameDocument' | 'typeMismatch';
+};
+
+/** What replacing one item did. */
+export declare interface ReplacementResult extends ReplacementItem {
+    readonly outcome: 'done' | 'failed';
+    readonly reason: 'revisionMoved' | 'incomplete' | 'notFound' | 'pathGone' | 'failed' | null;
+    /** The new draft revision, when done. */
+    readonly newRevisionId: string | null;
+    /** For `incomplete`, the fields a rule refused; for `failed`, the error. */
+    readonly detail: ReadonlyArray<string>;
+}
 
-/** Effect form of {@link removeRedirect}. */
-export declare const removeRedirect: (...args: Parameters<typeof removeRedirect_2>) => Effect<boolean, never, never>;
+/** Effect form of {@link replaceReferences}. */
+export declare const replaceReferences: (...args: Parameters<typeof replaceReferences_2>) => Effect<readonly ReplacementResult[], never, 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.
+ * Point every planned draft at `to` instead: per item, a new draft revision
+ * against the revision the plan saw, each in its own transaction with its
+ * own result. Nothing is published — the changes go live like any edit. It
+ * opens those transactions itself, so call it outside one: from an action or
+ * a schedule, not inside a mutation.
  */
-declare const removeRedirect_2: (tx: DataStore, type: ContentType, scope: CmsScope, fromPath: string) => Promise<boolean>;
+declare const replaceReferences_2: (store: DataStore, types: ReadonlyArray<ContentType>, items: ReadonlyArray<ReplacementItem>, to: string, scope: Pick<CmsScope, "site" | "environment">) => Promise<ReadonlyArray<ReplacementResult>>;
 
 /**
  * Replace the text in `[start, end)` with `text` (a paste, a typed line
@@ -2846,6 +4340,24 @@ export declare const requestChanges: (...args: Parameters<typeof requestChanges_
 /** Send the revision in review back with a note. Same checks as approving, minus self-approval. */
 declare const requestChanges_2: (store: DataStore, type: ContentType, variantId: string, scope: CmsScope, options: Omit<DecideOptions, "allowSelfApproval">) => Promise<Row>;
 
+/** Effect form of {@link requestDeliveryCheck}. */
+export declare const requestDeliveryCheck: (...args: Parameters<typeof requestDeliveryCheck_2>) => Effect<string, never, never>;
+
+/**
+ * Record what a public address must show after this change, in the caller's
+ * transaction. An earlier pending check of the same document, language and
+ * address is closed as stale: the newer change is what counts now.
+ */
+declare const requestDeliveryCheck_2: (tx: DataStore, input: {
+    readonly contentType: string;
+    readonly documentId: string;
+    readonly locale: string;
+    readonly kind: "publish" | "unpublish";
+    readonly revisionId?: string | null;
+    readonly url: string;
+    readonly tenantId?: string | null;
+}, now?: Date) => Promise<string>;
+
 export declare type RequestExceptionResult = {
     readonly ok: true;
     readonly id: string;
@@ -2874,6 +4386,18 @@ declare const requestReview_2: (store: DataStore, type: ContentType, variantId:
     readonly note?: string;
 }) => Promise<Row>;
 
+/** The document with each suggestion accepted, rejected or kept, as `decide` says. */
+export declare const resolveChanges: (doc: RichDocument, decide: (change: RichChange) => ChangeDecision) => RichDocument;
+
+/** Effect form of {@link resolveCutoverIssue}. */
+export declare const resolveCutoverIssue: (...args: Parameters<typeof resolveCutoverIssue_2>) => Effect<ResolveIssueResult, never, never>;
+
+/** Close an issue with why it may stand (an item type deliberately not migrated, a file replaced by hand). */
+declare const resolveCutoverIssue_2: (tx: DataStore, issueId: string, input: {
+    readonly resolution: string;
+    readonly actorId: string;
+}, now?: Date) => Promise<ResolveIssueResult>;
+
 /** One published entry found by {@link CmsApi.resolve}, with where it came from. */
 export declare interface ResolvedEntry {
     /** The published row that answers the request. */
@@ -2887,6 +4411,18 @@ export declare interface ResolvedEntry {
     readonly fallback: boolean;
 }
 
+export declare type ResolvedPortal = {
+    readonly ok: true;
+    readonly portal: Portal;
+    readonly tenantId: string | null;
+    readonly collection: Collection;
+    readonly items: ReadonlyArray<CollectionItem>;
+    readonly downloadsLeft: number | null;
+} | {
+    readonly ok: false;
+    readonly reason: 'unknown' | 'expired' | 'revoked';
+};
+
 /** What a preview link shows. */
 export declare type ResolvedPreviewShare = {
     readonly ok: true;
@@ -2904,6 +4440,13 @@ export declare type ResolvedPreviewShare = {
     readonly reason: 'unknown' | 'expired' | 'revoked';
 };
 
+export declare type ResolveIssueResult = {
+    readonly ok: true;
+} | {
+    readonly ok: false;
+    readonly reason: 'notFound' | 'noReason' | 'alreadyResolved';
+};
+
 /** Effect form of {@link resolveMedia}. */
 export declare const resolveMedia: (...args: Parameters<typeof resolveMedia_2>) => Effect<Record<string, unknown>, never, never>;
 
@@ -2936,6 +4479,12 @@ export declare interface ResolveOptions {
     readonly fallback?: ReadonlyArray<string>;
 }
 
+/** Effect form of {@link resolvePortal}. */
+export declare const resolvePortal: (...args: Parameters<typeof resolvePortal_2>) => Effect<ResolvedPortal, never, never>;
+
+/** What a portal link shows. The token is the authorization: this read crosses tenants. */
+declare const resolvePortal_2: (store: DataStore, token: string, now?: Date) => Promise<ResolvedPortal>;
+
 /** Effect form of {@link resolvePreviewShare}. */
 export declare const resolvePreviewShare: (...args: Parameters<typeof resolvePreviewShare_2>) => Effect<ResolvedPreviewShare, ContentNotFound | PreviewShareRejected, never>;
 
@@ -3015,13 +4564,11 @@ declare const reviewLog_2: (store: DataStore, type: ContentType, variantId: stri
 export declare class ReviewRequired extends ReviewRequired_base {
 }
 
-declare const ReviewRequired_base: Schema_2.TaggedErrorClass<ReviewRequired, "ReviewRequired", {
-    readonly _tag: Schema_2.tag<"ReviewRequired">;
-} & {
-    contentType: typeof Schema_2.String;
-    id: typeof Schema_2.String;
-    revisionId: typeof Schema_2.String;
-}>;
+declare const ReviewRequired_base: Schema_2.Class<ReviewRequired, Schema_2.TaggedStruct<"ReviewRequired", {
+    readonly contentType: Schema_2.String;
+    readonly id: Schema_2.String;
+    readonly revisionId: Schema_2.String;
+}>, YieldableError>;
 
 /** Effect form of {@link reviewRequiredFor}. */
 export declare const reviewRequiredFor: (...args: Parameters<typeof reviewRequiredFor_2>) => Effect<boolean, never, never>;
@@ -3058,13 +4605,18 @@ declare const reviewStatus_2: (store: DataStore, type: ContentType, variantId: s
 export declare class ReviewStepRefused extends ReviewStepRefused_base {
 }
 
-declare const ReviewStepRefused_base: Schema_2.TaggedErrorClass<ReviewStepRefused, "ReviewStepRefused", {
-    readonly _tag: Schema_2.tag<"ReviewStepRefused">;
-} & {
-    contentType: typeof Schema_2.String;
-    id: typeof Schema_2.String;
-    reason: Schema_2.Literal<["notInReview", "selfApproval", "ambiguousOrder"]>;
-}>;
+declare const ReviewStepRefused_base: Schema_2.Class<ReviewStepRefused, Schema_2.TaggedStruct<"ReviewStepRefused", {
+    readonly contentType: Schema_2.String;
+    readonly id: Schema_2.String;
+    readonly reason: Schema_2.Literals<readonly ["notInReview", "selfApproval", "ambiguousOrder"]>;
+}>, YieldableError>;
+
+export declare interface ReviewWorkflow {
+    readonly id: string;
+    /** Raise it whenever the steps change: an instance keeps the version it started with. */
+    readonly version: number;
+    readonly steps: ReadonlyArray<WorkflowStep>;
+}
 
 /**
  * Raised by `publish` when the caller pinned a revision (`{ revisionId }`)
@@ -3074,14 +4626,54 @@ declare const ReviewStepRefused_base: Schema_2.TaggedErrorClass<ReviewStepRefuse
 export declare class RevisionMismatch extends RevisionMismatch_base {
 }
 
-declare const RevisionMismatch_base: Schema_2.TaggedErrorClass<RevisionMismatch, "RevisionMismatch", {
-    readonly _tag: Schema_2.tag<"RevisionMismatch">;
-} & {
-    contentType: typeof Schema_2.String;
-    id: typeof Schema_2.String;
-    expected: typeof Schema_2.String;
-    actual: typeof Schema_2.String;
-}>;
+declare const RevisionMismatch_base: Schema_2.Class<RevisionMismatch, Schema_2.TaggedStruct<"RevisionMismatch", {
+    readonly contentType: Schema_2.String;
+    readonly id: Schema_2.String;
+    readonly expected: Schema_2.String;
+    readonly actual: Schema_2.String;
+}>, YieldableError>;
+
+/** A value attributed to the revision live when it was counted. */
+export declare interface RevisionShare extends LiveStretch {
+    readonly value: number;
+    readonly days: number;
+}
+
+/** Effect form of {@link revisionsReferencing}. */
+export declare const revisionsReferencing: (...args: Parameters<typeof revisionsReferencing_2>) => Effect<readonly RevisionUse[], never, never>;
+
+/**
+ * Every saved revision, of any document in the site and environment, that
+ * referenced `target` — newest first. Answers "what pointed here, and since
+ * when", including uses since removed.
+ */
+declare const revisionsReferencing_2: (store: DataStore, types: ReadonlyArray<ContentType>, target: {
+    readonly type: string;
+    readonly documentId: string;
+}, scope: Pick<CmsScope, "site" | "environment">) => Promise<ReadonlyArray<RevisionUse>>;
+
+/** Effect form of {@link revisionTimeline}. */
+export declare const revisionTimeline: (...args: Parameters<typeof revisionTimeline_2>) => Effect<readonly LiveStretch[], never, never>;
+
+/**
+ * When each revision of one document was live in one place, from its
+ * changes: a publish opens a stretch (with the release that took it live), the
+ * next publish or a take-down closes it. For `attributeToRevisions` (metrics.ts).
+ */
+declare const revisionTimeline_2: (store: DataStore, target: {
+    readonly contentType: string;
+    readonly documentId: string;
+}, scope: CmsScope) => Promise<ReadonlyArray<LiveStretch>>;
+
+/** One saved revision that referenced a document — the history of its uses. */
+export declare interface RevisionUse {
+    readonly sourceType: string;
+    readonly sourceDocumentId: string;
+    readonly locale: string;
+    readonly revisionId: string;
+    readonly number: number;
+    readonly path: string;
+}
 
 /** Effect form of {@link revokeExtension}. */
 export declare const revokeExtension: (...args: Parameters<typeof revokeExtension_2>) => Effect<ExtensionChange, never, never>;
@@ -3089,25 +4681,39 @@ export declare const revokeExtension: (...args: Parameters<typeof revokeExtensio
 /** Take every capability away; the install and its data stay. */
 declare const revokeExtension_2: (tx: DataStore, extensionId: string) => Promise<ExtensionChange>;
 
+/** Effect form of {@link revokePortal}. */
+export declare const revokePortal: (...args: Parameters<typeof revokePortal_2>) => Effect<boolean, never, never>;
+
+/** Revoke a portal: the link stops working at once. */
+declare const revokePortal_2: (tx: DataStore, portalId: string, now?: Date) => Promise<boolean>;
+
 /** Effect form of {@link revokePreviewShare}. */
 export declare const revokePreviewShare: (...args: Parameters<typeof revokePreviewShare_2>) => Effect<void, ContentNotFound | PreviewShareRejected, never>;
 
 /** Revoke one of the caller's shares; the link stops working at once. */
 declare const revokePreviewShare_2: (store: DataStore, shareId: string, now?: Date) => Promise<void>;
 
-/** A top-level block. `id` is stable across edits, moves and translations. */
+/** A top-level block. `id` is stable across edits, moves and translations. `style`
+ *  names a token of the profile's style group; `change` marks a block suggested
+ *  for insertion or deletion. */
 export declare type RichBlock = {
     readonly id: string;
+    readonly change?: RichChange;
     readonly type: 'paragraph';
     readonly content: ReadonlyArray<RichInline>;
+    readonly style?: string;
 } | {
     readonly id: string;
+    readonly change?: RichChange;
     readonly type: 'heading';
     readonly level: 2 | 3;
     readonly content: ReadonlyArray<RichInline>;
+    readonly style?: string;
 } | {
     readonly id: string;
+    readonly change?: RichChange;
     readonly type: 'list';
+    readonly style?: string;
     readonly ordered: boolean;
     readonly items: ReadonlyArray<ReadonlyArray<RichInline>>;
     /** How deep each item sits (0 at the top, at most `MAX_LIST_LEVEL`), one per item; absent: all at the top.
@@ -3118,6 +4724,7 @@ export declare type RichBlock = {
     readonly sublists?: ReadonlyArray<ListKind>;
 } | {
     readonly id: string;
+    readonly change?: RichChange;
     readonly type: 'table';
     /** True when the first row holds the column headers. */
     readonly header: boolean;
@@ -3126,15 +4733,67 @@ export declare type RichBlock = {
 /** An image asset (by its documentId) with an optional caption. */
 | {
     readonly id: string;
+    readonly change?: RichChange;
     readonly type: 'image';
     readonly asset: string;
     readonly caption?: string;
+}
+/** A file to download — an asset (by its documentId) from the media library — and the text its link shows. */
+| {
+    readonly id: string;
+    readonly change?: RichChange;
+    readonly type: 'file';
+    readonly asset: string;
+    readonly label: string;
+}
+/** A component the profile allows, placed between blocks; `id` is its instance id. */
+| {
+    readonly id: string;
+    readonly change?: RichChange;
+    readonly type: 'component';
+    readonly componentId: string;
+    readonly props: Readonly<Record<string, unknown>>;
+    /** The definition's fingerprint when it was last saved. */
+    readonly fingerprint?: string;
+};
+
+/** A kind of block. */
+export declare type RichBlockKind = RichBlock['type'];
+
+/** The field and block a text key names, or null for a plain field's key. */
+export declare const richBlockOfKey: (key: string) => {
+    readonly field: string;
+    readonly blockId: string;
+} | null;
+
+/** The text key of one block of a rich text: `<field>#<blockId>`. */
+export declare const richBlockTextKey: (field: string, blockId: string) => string;
+
+/** A suggested change (track changes): text or a block someone proposes to insert
+ *  or delete, until it is accepted or rejected (trackChanges.ts). */
+export declare interface RichChange {
+    readonly id: string;
+    readonly kind: 'insert' | 'delete';
+    /** Who suggested it. */
+    readonly by: string;
+    /** When, as an ISO timestamp. */
+    readonly at: string;
+}
+
+/** How a contact is given: a published contact point (its documentId), or a one-off address or number. */
+export declare type RichContact = {
+    readonly target: string;
+} | {
+    readonly channel: 'email' | 'phone';
+    readonly value: string;
 };
 
 /** A rich document. */
 export declare interface RichDocument {
     readonly type: 'doc';
     readonly blocks: ReadonlyArray<RichBlock>;
+    /** The profile it was saved against (`article@2`). */
+    readonly profile?: string;
 }
 
 export declare const RichDocumentEditor: (props: RichDocumentEditorProps) => ReactNode;
@@ -3154,6 +4813,8 @@ export declare interface RichDocumentEditorProps extends WidgetProps {
      * tables keep their lines either way.
      */
     readonly surface?: 'markup' | 'visual';
+    /** Renders the props form of a component between the blocks (`ContentForm` passes its own, nested). */
+    readonly renderComponentProps?: (definition: ComponentDefinition, props: Readonly<Record<string, unknown>>, onChange: (props: Readonly<Record<string, unknown>>) => void) => ReactNode;
 }
 
 /** Translate a Contentful rich-text document, and say what could not be translated. */
@@ -3171,6 +4832,15 @@ export declare type RichDocumentPicker = (props: {
     readonly type: string;
     readonly value: string;
     readonly onChange: (documentId: string) => void;
+    /** Where the choice goes, for a picker that hands off to another tool (a selection intent): the field and, inside a rich text, the block. */
+    readonly target?: {
+        readonly field: string;
+        readonly blockId?: string;
+    };
+    /** What the choice is for — an image block's image, a download block's file, a link's target, a contact — when two pickers share a `type`. */
+    readonly role?: 'image' | 'file' | 'link' | 'contact';
+    /** The id of the element that names the choice (a link's "Link to"): a control the picker renders is labelled by it (`aria-labelledby`). */
+    readonly labelledBy?: string;
 }) => ReactNode;
 
 /** One problem with a rich document, at a path below the field. */
@@ -3180,7 +4850,7 @@ export declare interface RichDocumentProblem {
     readonly message: string;
 }
 
-/** Everything wrong with `value` as a rich document under `options`. */
+/** Everything wrong with `value` as a rich document under `options` (component props are checked by the caller). */
 export declare const richDocumentProblems: (path: string, value: unknown, options: RichTextOptions) => ReadonlyArray<RichDocumentProblem>;
 
 /** A document reference found in a rich document. */
@@ -3194,7 +4864,7 @@ export declare interface RichDocumentReference {
 export declare const richDocumentReferences: (path: string, doc: RichDocument, options: RichTextOptions) => ReadonlyArray<RichDocumentReference>;
 
 /** The document's blocks, in order. Renders nothing for a value that is not a rich document. */
-export declare const RichDocumentView: ({ document, hrefOf, renderImage }: RichDocumentViewProps) => ReactNode;
+export declare const RichDocumentView: ({ document, hrefOf, renderImage, contactHrefOf, renderComponent, fileHrefOf }: RichDocumentViewProps) => ReactNode;
 
 export declare interface RichDocumentViewProps {
     /** A stored `Schema.RichText()` value (a plain string renders as paragraphs). */
@@ -3206,19 +4876,37 @@ export declare interface RichDocumentViewProps {
         readonly asset: string;
         readonly caption?: string;
     }) => ReactNode;
-}
-
-/** A run of text inside a block. */
-export declare type RichInline = {
+    /** The `mailto:` / `tel:` address of a published contact point, or undefined when it is not live. */
+    readonly contactHrefOf?: (documentId: string) => string | undefined;
+    /** Render a component placed between the blocks; without it, components are left out. */
+    readonly renderComponent?: (block: ComponentBlock) => 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;
+}
+
+/** A run of text inside a block. `change` marks it as suggested. */
+export declare type RichInline = 
+/** `style` names a token of the profile's style group (`lead`, `note`). */
+    {
     readonly type: 'text';
     readonly text: string;
     readonly marks?: ReadonlyArray<RichMark>;
+    readonly style?: string;
+    readonly change?: RichChange;
 }
 /** A link to a document (by its documentId) — the site resolves its address. */
 | {
     readonly type: 'link';
     readonly target: string;
     readonly text: string;
+    readonly change?: RichChange;
+}
+/** An e-mail address or a phone number — the site makes it a `mailto:` / `tel:` link. */
+| {
+    readonly type: 'contact';
+    readonly text: string;
+    readonly contact: RichContact;
+    readonly change?: RichChange;
 };
 
 /** An inline mark. */
@@ -3226,12 +4914,39 @@ export declare type RichMark = 'bold' | 'italic' | 'underline';
 
 /**
  * Which resources a rich-text field may hold: `images` names the content type
- * an image block references (an asset type), `links` the type a link
- * references (a page type). Unset → that node is not allowed.
+ * an image block references (an asset type), `files` the type a download
+ * block references (an asset type), `links` the type a link references (a
+ * page type). Unset → that node is not allowed.
  */
 export declare interface RichTextOptions {
     readonly images?: string;
+    /** The asset type a download block references; unset → no downloads. */
+    readonly files?: string;
     readonly links?: string;
+    /** What this field allows beyond that; without one, every built-in block and mark, no styles, components or contacts. */
+    readonly profile?: RichTextProfile;
+}
+
+/** What a rich-text field allows (`defineRichTextProfile`). Versioned: a change bumps `version`. */
+export declare interface RichTextProfile {
+    readonly name: string;
+    readonly version: number;
+    /** `<name>@<version>` — what a saved document records. */
+    readonly id: string;
+    readonly blocks: ReadonlyArray<RichBlockKind>;
+    readonly headings: ReadonlyArray<2 | 3>;
+    readonly marks: ReadonlyArray<RichMark>;
+    /** Named styles of paragraphs, headings, lists and runs of text: one design-token group, name → meaning. */
+    readonly styles?: {
+        readonly group: string;
+        readonly tokens: Readonly<Record<string, string>>;
+    };
+    /** The components that may sit between the blocks. */
+    readonly components: ReadonlyArray<ComponentDefinition>;
+    /** The content type of the published contact points (e-mail, phone) a text may name. */
+    readonly contactPoints?: string;
+    /** Whether a text may hold a one-off e-mail address or phone number (checked on save). */
+    readonly contactLiterals: boolean;
 }
 
 export declare const RichTextSurface: (props: RichTextSurfaceProps) => ReactNode;
@@ -3269,7 +4984,7 @@ export declare const rollbackRelease: (...args: Parameters<typeof rollbackReleas
  * published in the caller's transaction. The rolled-back release is left as it
  * was. Returns the new release.
  */
-declare const rollbackRelease_2: (tx: DataStore, types: ReadonlyArray<ContentType>, releaseId: string, now?: Date) => Promise<Row>;
+declare const rollbackRelease_2: (tx: DataStore, types: ReadonlyArray<ContentType>, releaseId: string, now?: Date, options?: PublishReleaseOptions) => Promise<Row>;
 
 /** A path found by {@link CmsApi.route}. */
 export declare interface RouteMatch {
@@ -3286,6 +5001,9 @@ export declare interface RouteMatch {
     readonly via: 'path' | 'fallback' | 'redirect';
 }
 
+/** Whether a rule's pack applies in this site and language (every rule applies where no place is known). */
+export declare const ruleApplies: (rule: QualityRule, scope: CmsScope | null) => boolean;
+
 /** Effect form of {@link runBulk}. */
 export declare const runBulk: (...args: Parameters<typeof runBulk_2>) => Effect<readonly BulkResult[], ContentValidationFailed | ContentNotFound | ContentIdConflict | RevisionMismatch | ReviewRequired | ReferenceUnavailable, never>;
 
@@ -3297,6 +5015,20 @@ export declare const runBulk: (...args: Parameters<typeof runBulk_2>) => Effect<
  */
 declare const runBulk_2: (store: DataStore, types: ReadonlyArray<ContentType>, place: Place, action: BulkAction, plan: ReadonlyArray<PlannedItem>) => Promise<ReadonlyArray<BulkResult>>;
 
+/** Effect form of {@link runDeliveryChecks}. */
+export declare const runDeliveryChecks: (...args: Parameters<typeof runDeliveryChecks_2>) => Effect<readonly DeliveryCheck[], never, never>;
+
+/**
+ * Read every pending check's address once: observed when it answers as
+ * expected, stale once `staleAfterMs` passed since the change without that.
+ * Hand it a store outside any request (a schedule's `app.store`). Returns
+ * the checks it settled.
+ */
+declare const runDeliveryChecks_2: (store: DataStore, read: ReadRevision, now?: Date, options?: {
+    readonly staleAfterMs?: number;
+    readonly limit?: number;
+}) => Promise<ReadonlyArray<DeliveryCheck>>;
+
 /** Effect form of {@link runningExperiment}. */
 export declare const runningExperiment: (...args: Parameters<typeof runningExperiment_2>) => Effect<Experiment | null, never, never>;
 
@@ -3403,6 +5135,20 @@ export declare const Schema: {
     readonly unique: () => FieldRefinement;
     /** Closed value set → `<select>` widget + a CHECK constraint. */
     readonly Literal: (values_0: string, ...values: string[]) => PipeableField;
+    /**
+     * A design token of one group (`tone`, `space`) from the set the design
+     * system declares with `defineDesignTokens`: the editor picks a NAME, never
+     * a colour or a size, and the renderer maps the name to its style. Stored
+     * and checked like a literal.
+     */
+    readonly Token: (tokens: DesignTokens, group: string) => PipeableField;
+    /**
+     * An action a component performs, chosen from the ones its renderer
+     * implements (`{ follow: 'Go to the target page', share: 'Share this page' }`):
+     * the editor picks what happens, the developer owns how. Stored and checked
+     * like a literal; the labels are what the editor reads.
+     */
+    readonly Action: (actions: Readonly<Record<string, string>>) => PipeableField;
     /**
      * Rich text, stored as a `RichDocument` (see richDocument.ts): blocks with
      * stable ids — paragraph, heading, list, table, image — and inline text
@@ -3496,6 +5242,48 @@ export declare type SecretBinding = {
     readonly reason: 'notInstalled' | 'notAsked';
 };
 
+/** The answer of an intent: which resource was chosen. */
+export declare interface SelectionAnswer {
+    readonly intentId: string;
+    readonly documentId: string;
+    /** What the chosen resource is called — the link text when nothing was selected. */
+    readonly title?: string;
+}
+
+export declare interface SelectionIntent {
+    readonly id: string;
+    /** The content type to pick from (`asset`, `page`). */
+    readonly pick: string;
+    /** What kind of it is wanted, when the type holds several (`image`, `file`); the tool shows only those. */
+    readonly kind?: string;
+    readonly target: SelectionTarget;
+    /** The app-relative address to go back to. */
+    readonly returnTo: string;
+    /** What the picking tool shows about the target (`Planting guide — Text, image 3`). */
+    readonly label?: string;
+}
+
+/** Where a chosen resource goes. */
+export declare interface SelectionTarget {
+    /** The type being edited; the document and the revision the intent was made on — or, before the draft is saved, the open form (`formId`). */
+    readonly type: string;
+    readonly documentId?: string;
+    readonly revisionId?: string;
+    readonly formId?: string;
+    readonly locale?: string;
+    /** The field; with `blockId`, a block of that rich text (an image block's asset, or a link over `selection`). */
+    readonly field: string;
+    readonly blockId?: string;
+    /** With `prop`: a placed component of a components field, by its instance id, and the prop that takes the choice. */
+    readonly instanceId?: string;
+    readonly prop?: string;
+    /** For a link: the text it is made over, by character offset in the block's text. */
+    readonly selection?: {
+        readonly start: number;
+        readonly end: number;
+    };
+}
+
 /** Effect form of {@link seriesOf}. */
 export declare const seriesOf: (...args: Parameters<typeof seriesOf_2>) => Effect<PublishSeries | null, ContentValidationFailed | ContentNotFound, never>;
 
@@ -3540,12 +5328,41 @@ export declare const setOwner: (...args: Parameters<typeof setOwner_2>) => Effec
 /** Make `owner` (an account id) responsible for the document, or nobody (`null`). */
 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>;
+
+/** 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>;
+
+export declare type SetPrimaryResult = {
+    readonly ok: true;
+} | {
+    readonly ok: false;
+    readonly reason: 'notFound' | 'notVerified';
+};
+
 /** Effect form of {@link setReviewRequired}. */
 export declare const setReviewRequired: (...args: Parameters<typeof setReviewRequired_2>) => Effect<readonly string[], never, never>;
 
 /** Turn the workspace's review requirement for `typeName` on or off, in the caller's transaction. */
 declare const setReviewRequired_2: (tx: DataStore, tenantId: string, typeName: string, required: boolean) => Promise<ReadonlyArray<string>>;
 
+/** Effect form of {@link setStageOwner}. */
+export declare const setStageOwner: (...args: Parameters<typeof setStageOwner_2>) => Effect<{
+    readonly ok: true;
+} | {
+    readonly ok: false;
+    readonly reason: "passed";
+}, never, never>;
+
+/** Name who owns a stage. A passed stage keeps its owner. */
+declare const setStageOwner_2: (tx: DataStore, source: string, stage: MigrationStage, ownerId: string, tenantId: string | null) => Promise<{
+    readonly ok: true;
+} | {
+    readonly ok: false;
+    readonly reason: "passed";
+}>;
+
 export declare type SettingsChange = {
     readonly ok: true;
     readonly settings: Readonly<Record<string, ExtensionSettingValue>>;
@@ -3570,6 +5387,45 @@ export declare const settleAiOperation: (...args: Parameters<typeof settleAiOper
 /** What the person did with a proposal; false when it is not a pending proposal. */
 declare const settleAiOperation_2: (tx: DataStore, operationId: string, outcome: "applied" | "discarded") => Promise<boolean>;
 
+/**
+ * Whether an origin response may be stored by a shared cache: eligibility is
+ * checked again after the origin answered — a `Set-Cookie`, `private` or
+ * `no-store` keeps it out whatever the request looked like.
+ */
+export declare const sharedCacheable: (headers: Readonly<Record<string, string | undefined>>) => boolean;
+
+/**
+ * The blocks of a draft's rich texts typed in together, with their markup:
+ * every paragraph, heading, list and table that holds no suggestions (a block
+ * with suggestions is decided, not typed in).
+ */
+export declare const sharedRichBlocks: (type: ContentType, values: Readonly<Record<string, unknown>>) => ReadonlyArray<{
+    readonly key: string;
+    readonly field: string;
+    readonly block: RichBlock;
+    readonly markup: string;
+}>;
+
+export declare interface SiteDomain {
+    readonly id: string;
+    readonly site: string;
+    readonly host: string;
+    readonly status: 'pending' | 'verified';
+    readonly primary: boolean;
+    readonly verifiedAt: Date | null;
+    /** The TXT record that proves ownership. */
+    readonly record: {
+        readonly name: string;
+        readonly value: string;
+    };
+}
+
+/** Effect form of {@link siteDomains}. */
+export declare const siteDomains: (...args: Parameters<typeof siteDomains_2>) => Effect<readonly SiteDomain[], never, never>;
+
+/** A site's domains: the primary first, then by host. */
+declare const siteDomains_2: (store: DataStore, site: string) => Promise<ReadonlyArray<SiteDomain>>;
+
 export declare interface SitemapUrl extends PageAlternate {
     readonly documentId: string;
     /** ISO date of the variant's last change, when known. */
@@ -3609,6 +5465,32 @@ export declare const sourceAttributes: (path: string) => {
 /** The field path behind a clicked element of the preview, or null. */
 export declare const sourcePathOf: (target: unknown) => string | null;
 
+export declare interface StageState {
+    readonly stage: MigrationStage;
+    readonly ownerId: string | null;
+    readonly status: 'open' | 'passed';
+    readonly note: string | null;
+    readonly evidenceUri: string | null;
+    readonly passedBy: string | null;
+    readonly passedAt: Date | null;
+}
+
+/** A placed component saved against an earlier definition of it, with no migration to upgrade it. */
+export declare interface StaleComponent {
+    readonly path: string;
+    readonly componentId: string;
+    readonly fingerprint: string | null;
+}
+
+/** The instances in `values` (nested ones included) that a save would not upgrade — their definition changed and names no migration from them. */
+export declare const staleComponents: (type: Pick<ContentType, "fields">, values: Readonly<Record<string, unknown>>) => ReadonlyArray<StaleComponent>;
+
+/** Effect form of {@link startBulkRun}. */
+export declare const startBulkRun: (...args: Parameters<typeof startBulkRun_2>) => Effect<string, never, never>;
+
+/** Record a run of `plan`; nothing is executed yet. */
+declare const startBulkRun_2: (tx: DataStore, place: Place, action: BulkAction, plan: ReadonlyArray<PlannedItem>, actorId: string | null) => Promise<string>;
+
 /** Effect form of {@link startExperiment}. */
 export declare const startExperiment: (...args: Parameters<typeof startExperiment_2>) => Effect<StartExperimentResult, never, never>;
 
@@ -3648,6 +5530,46 @@ export declare const startStewardship: (...args: Parameters<typeof startStewards
  */
 declare const startStewardship_2: (tx: DataStore, type: ContentType, documentId: string, place: Place_2, tenantId: unknown, now?: Date) => Promise<void>;
 
+/** Effect form of {@link startWorkflow}. */
+export declare const startWorkflow: (...args: Parameters<typeof startWorkflow_2>) => Effect<{
+    readonly id: string;
+    readonly revisionId: string;
+}, ContentNotFound, never>;
+
+/** Start a review of the revision the draft shows now; an open instance of an earlier revision is superseded. */
+declare const startWorkflow_2: (tx: DataStore, type: ContentType, workflow: ReviewWorkflow, variantId: string, scope: CmsScope, options: {
+    readonly actorId: string;
+}, now?: Date) => Promise<{
+    readonly id: string;
+    readonly revisionId: string;
+}>;
+
+export declare type StepRefusal = 'notFound' | 'closed' | 'revisionMoved' | 'unknownStep' | 'notApplicable' | 'waiting' | 'decided' | 'selfApproval' | 'notAllowed' | 'noEvidence' | 'noNote';
+
+/** One step as it applied to the revision an instance is about — the review snapshot. */
+export declare interface StepSnapshot {
+    readonly id: string;
+    readonly label: string;
+    readonly approverScope: string;
+    readonly after: ReadonlyArray<string>;
+    readonly applies: boolean;
+    readonly slaHours: number | null;
+    readonly evidence: boolean;
+}
+
+export declare interface StepState extends StepSnapshot {
+    readonly status: StepStatus;
+    /** When the step opened (its predecessors approved, or the request), null while waiting. */
+    readonly openedAt: Date | null;
+    readonly dueAt: Date | null;
+    readonly overdue: boolean;
+    readonly delegateTo: string | null;
+    readonly decidedBy: string | null;
+    readonly evidenceGiven: string | null;
+}
+
+export declare type StepStatus = 'notApplicable' | 'waiting' | 'open' | 'approved' | 'changesRequested';
+
 export declare interface Stewardship {
     readonly owner: string | null;
     readonly reviewDue: Date | null;
@@ -3669,6 +5591,29 @@ export declare const stopExperiment: (...args: Parameters<typeof stopExperiment_
 /** Stop a running experiment; its counts stay. False when there is none of that id running. */
 declare const stopExperiment_2: (tx: DataStore, experimentId: string, now?: Date) => Promise<boolean>;
 
+/** Effect form of {@link suggestOnStep}. */
+export declare const suggestOnStep: (...args: Parameters<typeof suggestOnStep_2>) => Effect<{
+    readonly ok: true;
+} | {
+    readonly ok: false;
+    readonly reason: StepRefusal;
+}, never, never>;
+
+/**
+ * Record a suggested change on an open step — the change itself is a
+ * candidate the author adopts or leaves (`proposeCandidate` with
+ * `suggestedBy`). Whoever may decide the step may suggest; the step stays open.
+ */
+declare const suggestOnStep_2: (tx: DataStore, instanceId: string, stepId: string, decider: Decider, input: {
+    readonly candidateId: string;
+    readonly note?: string;
+}, now?: Date) => Promise<{
+    readonly ok: true;
+} | {
+    readonly ok: false;
+    readonly reason: StepRefusal;
+}>;
+
 /** A type's taxonomy — see `ContentTypeSpec.taxonomy`. */
 export declare interface TaxonomyConfig {
     /** A declared `Schema.Array(Schema.String)` field. */
@@ -3729,6 +5674,8 @@ export declare interface TemplatesConfig {
     readonly field: string;
     /** The `Schema.Components` field the rules apply to. */
     readonly components: string;
+    /** The component prop that holds a placement's width (`widths`); default `width`. */
+    readonly width?: string;
     readonly list: ReadonlyArray<PageTemplate>;
 }
 
@@ -3745,6 +5692,9 @@ export declare const templateViolations: (type: Typed, row: Readonly<Record<stri
 /** The entries whose term `text` (in the source language) contains. */
 export declare const termsIn: (text: string, entries: ReadonlyArray<GlossaryEntry>) => ReadonlyArray<GlossaryEntry>;
 
+/** The current selection inside a text surface, as character offsets into its text — what a selection intent's `selection` is made of; null when it is elsewhere. */
+export declare const textSelectionIn: (root: HTMLElement) => [number, number] | null;
+
 /**
  * Put `mark` on the text in `[start, end)`, or take it off when all of it
  * already carries it. Text runs are split at the edges; a link is left as it
@@ -3762,6 +5712,38 @@ export declare interface ToolExposure {
 /** An XLIFF 2.1 core document for one file. */
 export declare const toXliff: (exchange: XliffExchange) => string;
 
+/** `edited` (a copy of `base` someone changed) as suggestions inside `base`. */
+export declare const trackChanges: (base: RichDocument, edited: RichDocument, author: ChangeAuthor) => TrackedChanges;
+
+/** The document with the edit suggested, and the blocks it could not suggest over (they hold others' suggestions). */
+export declare interface TrackedChanges {
+    readonly document: RichDocument;
+    readonly conflicts: ReadonlyArray<string>;
+}
+
+/** One run with the edit from `base` to `edited` suggested: the changed middle as a deletion and an insertion. */
+export declare const trackInline: (base: ReadonlyArray<RichInline>, edited: ReadonlyArray<RichInline>, author: ChangeAuthor) => ReadonlyArray<RichInline>;
+
+/**
+ * What an exchange does not carry, so the export can say so instead of
+ * losing it silently:
+ *
+ * - `suggestedChange`: a block holds suggested changes (track changes). Its
+ *   text goes out as written, insertions and deletions alike, and a
+ *   translation coming back has no suggestion marks — decide them first.
+ * - `unknownComponent`: a component whose definition the field no longer
+ *   declares; its text is not exported and stays as it is.
+ */
+export declare interface TranslationLoss {
+    /** Where: `body/<blockId>`, `sections/<instanceId>`, or deeper inside a component. */
+    readonly id: string;
+    /** Suggested changes flattened into the text, or a component's text left out. */
+    readonly kind: 'suggestedChange' | 'unknownComponent';
+}
+
+/** What exporting these values as translation units leaves out or flattens, in field order. */
+export declare const translationLosses: (fields: Readonly<Record<string, FieldSchema>>, values: Readonly<Record<string, unknown>>, prefix?: string) => ReadonlyArray<TranslationLoss>;
+
 /** Where one language stands against the source. */
 export declare interface TranslationState {
     readonly locale: string;
@@ -3869,6 +5851,9 @@ export declare interface TreeOptions {
     readonly filter?: Readonly<Record<string, unknown>>;
 }
 
+/** Looks up a name's TXT records (`node:dns/promises` `resolveTxt`, joined per record). */
+export declare type TxtResolver = (name: string) => Promise<ReadonlyArray<string>>;
+
 declare type Typed = {
     readonly name: string;
     readonly fields: Readonly<Record<string, FieldSchema>>;
@@ -3894,10 +5879,10 @@ export declare const unavailableAmong: (...args: Parameters<typeof unavailableAm
  * A document without a record (a type without availability, not published
  * yet) is not listed.
  */
-declare const unavailableAmong_2: (store: DataStore, documentIds: ReadonlyArray<string>, scope: Pick<CmsScope, "site" | "environment">, now?: Date) => Promise<ReadonlyMap<string, UnavailableReason>>;
+declare const unavailableAmong_2: (store: DataStore, documentIds: ReadonlyArray<string>, scope: Pick<CmsScope, "site" | "environment">, now?: Date, use?: AvailabilityUse) => Promise<ReadonlyMap<string, UnavailableReason>>;
 
 /** Why a referenced document may not be used. */
-export declare type UnavailableReason = 'blocked' | 'expired';
+export declare type UnavailableReason = 'blocked' | 'expired' | 'notYet' | 'territory' | 'channel' | 'purpose';
 
 /** Undo the last step: the form to show, and the history after it; null when there is nothing to undo. */
 export declare const undoEdit: (history: EditHistory, current: Readonly<Record<string, unknown>>) => {
@@ -3906,6 +5891,12 @@ export declare const undoEdit: (history: EditHistory, current: Readonly<Record<s
     readonly label: string;
 } | null;
 
+/** Effect form of {@link unfinishedBulkRuns}. */
+export declare const unfinishedBulkRuns: (...args: Parameters<typeof unfinishedBulkRuns_2>) => Effect<readonly string[], never, never>;
+
+/** The runs still going, oldest first — for a schedule that continues them. */
+declare const unfinishedBulkRuns_2: (store: DataStore) => Promise<ReadonlyArray<string>>;
+
 /** Effect form of {@link uninstallExtension}. */
 export declare const uninstallExtension: (...args: Parameters<typeof uninstallExtension_2>) => Effect<ExtensionRemoval, never, never>;
 
@@ -3999,6 +5990,21 @@ export declare interface VariantResult {
     readonly rate: number;
 }
 
+/** Effect form of {@link verifyDomain}. */
+export declare const verifyDomain: (...args: Parameters<typeof verifyDomain_2>) => Effect<VerifyDomainResult, never, 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>;
+
+export declare type VerifyDomainResult = {
+    readonly ok: true;
+    readonly domain: SiteDomain;
+} | {
+    readonly ok: false;
+    readonly reason: 'notFound' | 'recordMissing';
+    readonly found?: ReadonlyArray<string>;
+};
+
 /**
  * Verify a preview token. Returns the `{ type, id }` claim on success,
  * `null` on any failure (malformed, signature mismatch, expired). Never
@@ -4053,8 +6059,23 @@ export declare interface WidgetProps {
     readonly field: FieldSchema;
     readonly value: unknown;
     readonly onChange: (value: unknown) => void;
+    /**
+     * Where the value lives: the field, and for a prop of a placed component
+     * its instance and prop — what a picker hands to a selection intent.
+     */
+    readonly target?: WidgetTarget;
+}
+
+/** Where a widget's value lives (a `SelectionTarget`'s `field`, `instanceId`, `prop`). */
+declare interface WidgetTarget {
+    readonly field: string;
+    readonly instanceId?: string;
+    readonly prop?: string;
 }
 
+/** A block with its text replaced by `text` in its markup (the inverse of `blockMarkup`); `styles` are the names `{name|…}` may use. */
+export declare const withBlockMarkup: (block: RichBlock, text: string, styles?: ReadonlyArray<string>) => RichBlock;
+
 /** Effect form of {@link withdrawInvitation}. */
 export declare const withdrawInvitation: (...args: Parameters<typeof withdrawInvitation_2>) => Effect<boolean, never, never>;
 
@@ -4069,6 +6090,77 @@ export declare interface WithheldInstance {
     readonly props: Readonly<Record<string, never>>;
 }
 
+/**
+ * The values with the reference at `path` (as `referencesOf` reports it)
+ * pointing at `to`: a reference field holds the id itself, a rich-text link
+ * its `target`, a rich-text image block its `asset`. Returns null when the
+ * path leads nowhere — the values changed since the path was read.
+ */
+export declare const withReferenceAt: (values: Readonly<Record<string, unknown>>, path: string, to: string) => Record<string, unknown> | null;
+
+/**
+ * The rich texts of `form` with each shared block's text taken from `texts`
+ * (key → merged markup). A block the editor changed in the form before its
+ * shared text reached them keeps the form's text while nobody typed into it or
+ * saved it since `seen` — those come back in `typedBefore`, for the save to
+ * write into their texts.
+ */
+export declare const withSharedBlocks: (type: ContentType, form: Readonly<Record<string, unknown>>, texts: ReadonlyMap<string, string>, context?: {
+    readonly current?: Readonly<Record<string, unknown>> | undefined;
+    readonly seen?: Readonly<Record<string, unknown>> | undefined;
+}) => {
+    readonly values: Readonly<Record<string, unknown>>;
+    readonly typedBefore: ReadonlyArray<{
+        readonly key: string;
+        readonly markup: string;
+    }>;
+};
+
+export declare interface WorkflowInstance {
+    readonly id: string;
+    readonly contentType: string;
+    readonly variantId: string;
+    readonly revisionId: string;
+    readonly workflowId: string;
+    readonly workflowVersion: number;
+    readonly status: 'open' | 'approved' | 'changesRequested' | 'superseded';
+    readonly requestedBy: string;
+    readonly requestedAt: Date;
+    readonly steps: ReadonlyArray<StepState>;
+    readonly decisions: ReadonlyArray<{
+        readonly stepId: string;
+        readonly action: string;
+        readonly actorId: string;
+        readonly delegateTo: string | null;
+        readonly candidateId: string | null;
+        readonly evidence: string | null;
+        readonly note: string | null;
+        readonly decidedAt: Date;
+    }>;
+}
+
+/** Effect form of {@link workflowState}. */
+export declare const workflowState: (...args: Parameters<typeof workflowState_2>) => Effect<WorkflowInstance | null, never, never>;
+
+/** One instance with its steps and decisions, or null. */
+declare const workflowState_2: (store: DataStore, instanceId: string, now?: Date) => Promise<WorkflowInstance | null>;
+
+export declare interface WorkflowStep {
+    /** camelCase, unique within the workflow. */
+    readonly id: string;
+    readonly label: string;
+    /** The scope a person needs to decide this step (a delegate decides without it). */
+    readonly approverScope: string;
+    /** Steps that must be approved before this one opens. */
+    readonly after?: ReadonlyArray<string>;
+    /** The step applies only when this holds for the revision's values. */
+    readonly when?: (values: Readonly<Record<string, unknown>>) => boolean;
+    /** Hours the step may stay open once it is open; later it is overdue. */
+    readonly slaHours?: number;
+    /** Approving needs evidence: a link or a note saying what was checked. */
+    readonly evidence?: boolean;
+}
+
 /** Effect form of {@link workspaceReviewTypes}. */
 export declare const workspaceReviewTypes: (...args: Parameters<typeof workspaceReviewTypes_2>) => Effect<readonly string[], never, never>;