@elytracms/next 0.0.91 → 0.0.93

package/dist/index.d.ts

@@ -3,11 +3,10 @@ import { ComponentRegistry, ComponentManifest } from '@elytracms/core/component-
 export { ComponentManifest, PropField, SlotSpec, defineComponent } from '@elytracms/core/component-registry';
 import { ComponentImplementations, RelationTarget, DocumentBodyItem } from '@elytracms/core/runtime-renderer';
 export { ComponentImplementations, RenderAsset } from '@elytracms/core/runtime-renderer';
-import { HostComponentEntry } from '@elytracms/core/studio-core';
-import { ContentQueryError, ResolvePageResult, ResolvedAsset, Perspective, ContentClient, CacheTags, ContentDocumentSource, ResolvedDocument } from '@elytracms/core/content';
-export { Perspective } from '@elytracms/core/content';
-import { LocaleConfig, Locale, RouteRecord, CollectionDef, RedirectRecord, LocaleConfigInput } from '@elytracms/core/cms-core';
-export { CmsDocument, CollectionDef, FieldDef, Locale, LocaleConfig, LocaleConfigInput, LocaleRequest, LocaleStrategy, LocaleUrlPath, RedirectRecord, RouteRecord, documentSchema, fallbackHomeRoutes, localeConfigSchema, localeUrlPath, mergeRouteRecords, parseLocaleConfig, redirectRecordSchema, resolveLocale, routeRecordSchema, splitLocalePath, textDirection } from '@elytracms/core/cms-core';
+import { HostComponentEntry, ResolvedProject, WorkspaceProjectEntry } from '@elytracms/core/studio-core';
+import { ContentQueryError, ResolvePageResult, ResolvedAsset, ContentClient, CacheTags, ContentDocumentSource, ResolvedDocument } from '@elytracms/core/content';
+import { LocaleConfig, Perspective, Locale, RouteRecord, CollectionDef, RedirectRecord, LocaleConfigInput, CmsValidationIssue } from '@elytracms/core/cms-core';
+export { CmsDocument, CollectionDef, DRAFT_PERSPECTIVE, FieldDef, Locale, LocaleConfig, LocaleConfigInput, LocaleRequest, LocaleStrategy, LocaleUrlPath, Perspective, RedirectRecord, RouteRecord, documentSchema, localeConfigSchema, localeUrlPath, parseLocaleConfig, redirectRecordSchema, resolveLocale, routeRecordSchema, splitLocalePath, textDirection, variantOf } from '@elytracms/core/cms-core';
 import { AssetRecord, PersistenceAdapter } from '@elytracms/core/persistence';
 export { AssetRecord } from '@elytracms/core/persistence';
 import { Clock } from '@elytracms/core/determinism';
@@ -252,6 +251,15 @@ declare function mergeCacheTags(first: CacheTags, ...rest: readonly CacheTags[])
  * API — assembles the exact same `ContentSource` without faking an adapter.
  */
 interface ContentSnapshotOptions {
+    /**
+     * The project's collection definitions — **required** (EC-583). The snapshot's
+     * lookup resolves localized fields and a collection's declared `presentation`
+     * through them, and the persistence contract holds no schema any more (this used to
+     * read `adapter.cms.findSchema`, which in a seeded host was the engine sample's JSON
+     * projection unless the host re-saved its own). Hand it the config's collections —
+     * the same ones the studio and the seed read.
+     */
+    collections: readonly CollectionDef[];
     /** Route records served by `resolvePage` (EC-019). */
     routes?: readonly RouteRecord[];
     /** Redirect records served by `resolvePage` (EC-019/020). */
@@ -302,8 +310,13 @@ interface StaticContentData {
      * explicit unresolved-placeholder scheme (never a silent empty string).
      */
     assetUrl?: (asset: AssetRecord) => string;
+    /**
+     * EC-585 — the stored rows the host could not read (`parseDeliveredDocuments`), handed
+     * to every client of this source as its `sourceIssues` (and in the results they
+     * concern). A malformed row is not delivered, and never silently.
+     */
+    sourceIssues?: readonly CmsValidationIssue[];
 }
-
 /**
  * Assemble a `ContentSource` from plain prefetched data — the pure half of
  * {@link createContentSnapshot}, shared with hosts that fetched the data
@@ -471,28 +484,164 @@ interface ResolveCanvasPageOptions {
  */
 declare function resolveCanvasPage(source: ContentSource, url: string, perspective: Perspective, options?: ResolveCanvasPageOptions): Promise<CanvasPageOutcome>;
 
-interface CanvasCacheOptions {
-    /**
-     * Project scope prefix for every tag (`p:<scope>:…`) — must be the SAME scope
-     * the revalidate receiver derives its tags with (`createRevalidateRoute`'s
-     * `scope`; the delivery kit hands its one `contentScope` to both, EC-579).
-     */
-    scope?: string;
-    /**
-     * Which content world `loadContent` reads — the delivery kit passes its
-     * `contentMode` (`'live' | 'fallback' | 'empty'`), so entries written in one
-     * world can never be served in another (EC-543, see `canvasCacheKey`). A host
-     * driving this helper directly with a single world may omit it.
-     */
-    mode?: string;
+/**
+ * Cache-tag pipeline (EC-146, vision AD-5) — the pure half.
+ *
+ * This module defines (a) the **canonical Next.js tag string format** mapping
+ * the accessor-level `CacheTags` (EC-143) onto `cacheTag` / `revalidateTag` keys,
+ * (b) the **tag derivation for a revalidation event** ({@link revalidationTags},
+ * EC-579 — the receiver's half of the one emitter), and (c) the **pure half of a
+ * cached resolution**: its key ({@link canvasCacheKey}) and the `cacheTag` calls that
+ * declare its tags ({@link entryTagCalls}). No Next.js imports — everything here is
+ * unit-testable.
+ *
+ * **Caching is the host's (EC-620).** The engine's part is exactly three things: the
+ * tags on everything the accessors return, the invalidation signal (the Convex
+ * trigger's event → the kit receiver → `revalidateTag` for every derived tag), and a
+ * default in the scaffold. Whether a page caches, under which scope, for how long and
+ * with which Next flag is the host's: the kit holds no `'use cache'` scope and no
+ * `cacheLife`. The host's own `'use cache'` function declares a result's tags through
+ * the canvas route's `applyCacheTags` (`route.tsx`), which makes the
+ * {@link entryTagCalls} calls with the host's one scope.
+ *
+ * This is the ONE tag module: the entries are tagged here and the invalidations
+ * are derived here, from the same formatters and the same scope. Before EC-579 the
+ * format was mirrored twice more (the studio's browser dispatcher and an inline
+ * literal in the Convex emitter), and each emitter brought its own scope.
+ *
+ * ## Tag format
+ *
+ * - `doc:<collection>:<id>` — one per document whose content was actually in
+ *   the response (fetch-time tagging: includes depth-1 populated relation
+ *   targets, and documents inside filtered/dynamic lists *after* the filter
+ *   ran).
+ * - `collection:<name>:<locale>` — the coarse membership tag: every response
+ *   that read from a collection carries it, so create/delete/newly-matching
+ *   documents sweep cached lists without read-set tracking.
+ * - `route:<pattern>:<locale>` — the resolved URL path plus every hop of a
+ *   redirect chain.
+ * - `asset:<id>` — one per asset whose delivery shape the page *baked*
+ *   (page-scoped images + `seoOgImage`, EC-227); editing that asset record
+ *   (alt/dimensions/re-upload) drops exactly the pages that baked it. Not
+ *   locale-scoped — an asset record is locale-agnostic.
+ * - `project` — the whole-project sweep tag attached to **every** cached
+ *   entry; derived for the events whose effect no narrower tag names (a redirect
+ *   change, an asset edit — see {@link revalidationTags}).
+ *
+ * ## Project scope
+ *
+ * Every tag is prefixed `p:<projectId>:` when a scope is configured (e.g.
+ * `p:prj_aurora:doc:post:post-1`). The cost is a few bytes per tag and it
+ * keeps multi-project hosts (one Next app serving several builder projects)
+ * from cross-invalidating, so the prefix is **on whenever the host knows its
+ * project id** — decision: include it. Since EC-579 the scope has ONE owner: the
+ * host. The webhook carries an event, not tags, and the receiver derives the
+ * tags with the same scope its cache entries are written under (the delivery
+ * kit hands both the one `contentScope`), so emitter and host can no longer
+ * disagree about it.
+ */
+/** Apply the optional multi-project scope prefix to one tag. */
+declare function scopeCacheTag(tag: string, scope?: string): string;
+/**
+ * Tag for one document identity. `docKey` is the EC-143 `documentKey` string
+ * (`<collection>:<id>`), exactly as found in `CacheTags.docs`.
+ */
+declare function docCacheTag(docKey: string, scope?: string): string;
+/** The coarse membership tag of one collection in one locale. */
+declare function collectionCacheTag(collection: string, locale: string, scope?: string): string;
+/** Tag for one resolved route path (or redirect-chain hop) in one locale. */
+declare function routeCacheTag(pattern: string, locale: string, scope?: string): string;
+/**
+ * The whole-project sweep tag. Attached to every cached page entry; derived for
+ * the events no narrower tag covers ({@link revalidationTags}).
+ */
+declare function projectSweepTag(scope?: string): string;
+/**
+ * Map an accessor-level `CacheTags` (what one request actually read) onto the
+ * full, deterministic (sorted, deduplicated) set of Next tag strings for the
+ * cache entry — including the project sweep tag.
+ */
+declare function nextCacheTags(tags: CacheTags, scope?: string): string[];
+/** The receiver's own project — what its cached entries are tagged with. */
+interface RevalidationProject {
+    /** The tag scope of this host's cache entries (`p:<scope>:…`), if any. */
+    scope?: string | undefined;
+    /** Every locale this host serves — one `collection:` tag per locale. */
+    locales: readonly string[];
 }
+/**
+ * The tags one revalidation event invalidates on this host — sorted, deduplicated,
+ * scoped with the receiver's OWN scope, so the emitter never needs to know it.
+ *
+ * - `publish` / `unpublish` / `delete` → `doc:<collection>:<id>` (its detail page and
+ *   every cached list that contained it) + `collection:<collection>:<locale>` for
+ *   EVERY locale this host serves (list membership may have changed, and a URL
+ *   cached as not-found for a document that now exists carries it too). **No
+ *   sweep** — a publish drops exactly the entries that read the document or its
+ *   collection (EC-515);
+ * - `redirects` → the sweep (routing can change any URL; see the `redirects` trigger
+ *   in the studio's `convex/triggers.ts` for why a targeted `route:` tag is wrong);
+ * - `asset` → `asset:<id>` + the sweep (a page reading the asset through a document
+ *   asset FIELD carries no `asset:` tag — EC-566 D16, EC-589);
+ * - `probe` → nothing (the doctor's no-op ping).
+ *
+ * Why the precise tags are enough (EC-515 option D, kept by EC-620): a cached
+ * resolution declares its tags with `cacheTag` from INSIDE the cache function that
+ * loaded it (the host's, through `applyCacheTags`), and Next decides an entry's
+ * staleness from the tags it was STORED with — so a `doc:` tag drops the entries that
+ * read the document, on a self-hosted host as on any other. Until EC-515 the read
+ * named only the baseline sweep (`unstable_cache` judged the reading wrapper's tags),
+ * every precise tag was inert on a self-hosted host, and every publish carried the
+ * sweep to compensate (wave-0091). Measured both ways in EC-515's harness, and again
+ * with the host-owned scope in EC-620's.
+ */
+declare function revalidationTags(event: RevalidationEvent, project: RevalidationProject): string[];
+declare const canvasCacheKeyBrand: unique symbol;
+/**
+ * What identifies one published canvas resolution — the argument the canvas route
+ * hands the host's cache function (`CanvasRouteOptions.published`), which therefore
+ * IS that entry's key: Next keys a `'use cache'` entry by (build id, function id,
+ * serialized arguments), so whatever identifies an entry has to be an argument, and
+ * nothing else may be. It encodes three facts ({@link parseCanvasCacheKey}):
+ *
+ * - `scope` — the tag scope (the project id the studio publishes under; `''` if none).
+ * - `mode` — which content world the loader reads (the delivery kit's `contentMode`:
+ *   `live` / `fallback` / `empty`; `''` for a host driving the route directly with
+ *   one world).
+ * - `url` — the request path, locale prefix included.
+ *
+ * **An opaque string, not an object — measured (EC-620).** Next wraps every
+ * `'use cache'` function in React's per-request `cache()`, which memoizes by argument
+ * IDENTITY. `Page` and `generateMetadata` each build the key for the same URL; as two
+ * equal objects they missed that memo and a cold URL ran the loader twice (page and
+ * metadata filling the entry concurrently), as one string they share the in-flight
+ * miss — one load, exactly as the kit-owned entry did. A string is also trivially
+ * stable for Next's own key serialization. The brand keeps a hand-built string out.
+ *
+ * The mode is in the key because an entry can outlive the world that wrote it (a
+ * shared or remote cache handler, a host whose env changed under a warm cache) and a
+ * hit never asks the loader whether it still applies. Before EC-543 the key was
+ * `(scope, url)` only, and since `ELYTRA_PROJECT_ID` *is* the config slug, a live host
+ * and an empty one keyed the same URL identically — measured on 0.0.85: a warm cache
+ * written in live mode kept answering `200` with the live world's bytes after both env
+ * vars were blanked and the host itself reported `contentMode: 'empty'`. Keying on the
+ * mode makes that cross-read structurally impossible rather than something to detect —
+ * a world change is a cold miss, never a stale hit. Since EC-620 the cache function is
+ * the host's, so the property holds as long as the host keys on this value — which
+ * it does by passing it through unchanged (the canvas route refuses a key of another
+ * world).
+ */
+type CanvasCacheKey = string & {
+    readonly [canvasCacheKeyBrand]: true;
+};
+
 /**
  * What the route helper tells the content loader about the request it is
  * loading for (EC-156). Loaders that serve both perspectives from one
  * prefetched source (the fixture snapshot) can ignore it; a live loader uses
  * it to fetch the draft-perspective snapshot only for draft-mode requests —
- * it must NOT call request APIs like `draftMode()` itself, because on the
- * cached published path the loader runs inside a `'use cache'` function, where
+ * it must NOT call request APIs like `draftMode()` itself, because on a cached
+ * published path the loader runs inside the host's `'use cache'` function, where
  * request APIs are unavailable.
  */
 interface CanvasContentRequest {
@@ -503,8 +652,8 @@ interface CanvasRouteOptions {
      * Async content loader — the seam EC-145/146 plug Convex into. For the
      * fixture-backed example this memoizes a `createContentSnapshot` call.
      * Invoked per request; cache/memoize inside the loader as appropriate.
-     * With `cache` configured it only runs on a cache miss (once per
-     * revalidation cycle) — cache hits never touch the content backend.
+     * Behind a host cache function ({@link CanvasRouteOptions.published}) it runs
+     * only on a cache miss — cache hits never touch the content backend.
      * Receives the request's perspective (see {@link CanvasContentRequest});
      * zero-arg loaders remain valid.
      */
@@ -512,18 +661,38 @@ interface CanvasRouteOptions {
     /** Host component surface from `defineHostComponents`. */
     components: HostComponents;
     /**
-     * EC-146 instant publish: cache the published-perspective resolution as a
-     * `'use cache'` entry tagged with the response's own fetch-time tags,
-     * invalidated by the `/api/revalidate` webhook (EC-515). Draft mode and
-     * `next dev` always bypass it. Tag-driven only — no time-based revalidation
-     * (the AD-5 model, `CANVAS_CACHE_LIFE`). Requires `cacheComponents: true` in
-     * the host's `next.config`.
+     * The tag scope of everything this route resolves (`p:<scope>:…`) — what
+     * {@link CanvasRoute.applyCacheTags} scopes with and what every
+     * {@link CanvasCacheKey} carries. It must be the SAME scope the revalidate receiver
+     * derives its tags with (`createRevalidateRoute`'s `scope`); the delivery kit hands
+     * its one `contentScope` to both (EC-579) — a disagreement would drop nothing,
+     * silently.
+     */
+    scope?: string;
+    /**
+     * Which content world `loadContent` reads — the delivery kit passes its
+     * `contentMode` (`'live' | 'fallback' | 'empty'`). It rides in every
+     * {@link CanvasCacheKey}, so an entry written in one world can never be served in
+     * another (EC-543). A host driving this helper directly with one world may omit it.
+     */
+    mode?: string;
+    /**
+     * How a PUBLISHED request gets its outcome — the host's cache seam (EC-620). Pass
+     * your own `'use cache'` function: it receives the request's {@link CanvasCacheKey}
+     * (keep that its only argument — it is the entry's key), calls
+     * {@link CanvasRoute.resolve} with it, declares the result's tags with
+     * {@link CanvasRoute.applyCacheTags}, picks its `cacheLife`, and returns the
+     * outcome (module example above; the scaffold's page ships it as the default).
+     *
+     * Omit it and every published request resolves fresh — dynamic and uncached. Draft
+     * mode never calls it. `Page` and `generateMetadata` call it with the same key.
      */
-    cache?: CanvasCacheOptions;
+    published?: (key: CanvasCacheKey) => Promise<CanvasPageOutcome>;
     /**
      * EC-146 hook: receives the merged `CacheTags` of everything this request
      * read (the `resolvePage` tags plus the baked relations/listings/links). On a
-     * cache hit these are the stored tags of the run that wrote the entry.
+     * cache hit (through a host {@link CanvasRouteOptions.published} function) these
+     * are the stored tags of the run that wrote the entry.
      */
     onTags?: (tags: CacheTags, info: CanvasRequestInfo) => void;
     /** Override the generated `<head>` metadata for a resolved page. */
@@ -583,14 +752,47 @@ interface CanvasRoute {
      */
     generateMetadata: (props: CanvasRouteProps, parent: ResolvingMetadata) => Promise<Metadata>;
     /**
-     * `export const generateStaticParams = route.generateStaticParams` — REQUIRED in
-     * the catch-all page file under `cacheComponents` (EC-515, measured on Next
-     * 16.2.10): without it, awaiting the catch-all's `params` fails `next build`
-     * ("Uncached data was accessed outside of <Suspense>"). Wrapping the page in
-     * `<Suspense>` (or a root `loading.tsx`) instead also builds, but answers every
-     * 404 and every redirect with HTTP 200 — the status is committed before the
-     * content resolves. Declaring params keeps the page blocking, so `notFound()` is a
-     * real 404 and a redirect a real 308/307.
+     * Resolve one PUBLISHED request — with no cache scope of its own (EC-620). Call it
+     * from the `'use cache'` function you pass as {@link CanvasRouteOptions.published},
+     * with the key the route handed that function. A key of another scope or content
+     * mode (a cache function shared with a route of another world) is refused loudly:
+     * the entry would be keyed under one world and resolved in another (EC-543).
+     *
+     * The outcome carries everything a cache decision needs: `tags` (what the
+     * resolution read — hand them to {@link applyCacheTags}) and, on a `render`
+     * outcome, `readsNow` (a listing on the page compared against the clock, so the
+     * page changes as time passes — bound that entry's life).
+     */
+    resolve: (key: CanvasCacheKey) => Promise<CanvasPageOutcome>;
+    /**
+     * Declare a result's tags on the CURRENT `'use cache'` entry, scoped with this
+     * route's scope — exactly the strings the revalidate receiver revalidates (EC-620).
+     * Any accessor result works (`{ tags }`): a resolution from {@link resolve}, or a
+     * `listDocuments` result in a route of your own.
+     *
+     * It makes the {@link entryTagCalls} calls: the project sweep first and alone, the
+     * rest in chunks of at most 128. Next keeps 128 tags per `cacheTag()` call and drops
+     * the rest with only a warning, and the sweep sorts last — one `cacheTag(...tags)`
+     * call loses it on a page that read ~125 documents, and with it every redirect and
+     * asset invalidation (measured, EC-515/EC-620).
+     *
+     * Callable ONLY inside a `'use cache'` function: anywhere else Next's own `cacheTag`
+     * throws (E819 during a request or a prerender; E886 when neither `cacheComponents`
+     * nor `experimental.useCache` is enabled) — a loud error, never a silent no-op.
+     */
+    applyCacheTags: (result: {
+        tags: CacheTags;
+    }) => void;
+    /**
+     * `export const generateStaticParams = route.generateStaticParams` — needed in the
+     * catch-all page file only when the HOST enables `cacheComponents` (that flag's
+     * rule, not the kit's; measured on Next 16.2.10, EC-515): without it, awaiting the
+     * catch-all's `params` fails `next build` ("Uncached data was accessed outside of
+     * <Suspense>"). Wrapping the page in `<Suspense>` (or a root `loading.tsx`) instead
+     * also builds, but answers every 404 and every redirect with HTTP 200 — the status
+     * is committed before the content resolves. Declaring params keeps the page
+     * blocking, so `notFound()` is a real 404 and a redirect a real 308/307. A host
+     * without `cacheComponents` needs none of it.
      *
      * It names ONE param set: {@link CANVAS_VALIDATION_SLUG}, a sample that Next
      * prerenders to validate the route and that resolves to not-found without
@@ -609,9 +811,71 @@ interface CanvasRoute {
  * route answers it with not-found and never resolves it against content.
  */
 declare const CANVAS_VALIDATION_SLUG: readonly string[];
-/** Create the `{ Page, generateMetadata }` pair for `app/[[...slug]]/page.tsx`. */
+/**
+ * THE edge mapping of Next's draft mode onto the delivery perspective (EC-595 binding
+ * point 1): draft mode reads the draft variant, everything else the published snapshot.
+ * The kit's other request-time read (`pageOpensFullBleed`) imports this one, and the
+ * package exports it for a host's own server components, so the mapping is declared
+ * once. A request API: never call it inside a cache scope.
+ */
+declare function requestPerspective(): Promise<Perspective>;
+/**
+ * Create the canvas route for `app/[[...slug]]/page.tsx` — `{ Page, generateMetadata,
+ * generateStaticParams }` to export, plus `resolve` / `applyCacheTags` for the host's
+ * own cache function ({@link CanvasRouteOptions.published}).
+ */
 declare function createCanvasRoute(options: CanvasRouteOptions): CanvasRoute;
 
+/**
+ * A resolved document → Next.js `Metadata` (EC-171, reshaped by EC-187, and by EC-590 —
+ * EC-565 Round 3 "3g, extensibility"): **`seoMetadata(doc, ctx)`**, the kit's pure,
+ * exported SEO reader. The route's `generateMetadata` calls it (the default), so a
+ * project WRAPS it (`{ ...seoMetadata(doc, ctx), other }` for its own sub-fields),
+ * REPLACES it, or ignores it.
+ *
+ * What it reads — never a dictated field name:
+ * - the document's **SEO object**: the field under its collection's SEO ROLE
+ *   (`seoField`, default a field named `seo`; the engine's `seoFields()` declares it).
+ *   Its sub-field names are the contract ({@link SEO_SUBFIELDS}); a sub-field the object
+ *   omits emits nothing, a sub-field the project added is theirs to read.
+ * - the document's **display title**: the ONE `resolveDocumentTitle` over its TITLE ROLE
+ *   (`titleField`, default `title` → `name`) — the resolve result carries it
+ *   (`result.title`), so a function `titleField` titles the page too.
+ *
+ * Mapping:
+ * - `title`: `seo.title` → the display title.
+ * - `description`: `seo.description`.
+ * - `openGraph`: title (`seo.ogTitle` → the effective title), description
+ *   (`seo.ogDescription` → `seo.description`), image (`seo.image`) — and `locale` from the
+ *   page's resolved locale when, and only when, the code carries a territory (EC-531,
+ *   EC-610). The site-wide half of Open Graph (`type`, `siteName`, the site image) is the
+ *   LAYOUT's; the canvas route merges this object over the layout's
+ *   (`mergeMetadataOverParent`), so a page states only what is its own. Site-level SEO
+ *   defaults live on the project's own settings document and are read by its layout —
+ *   this reader needs none (EC-590 (b): nothing here ever read a settings document).
+ * - `robots`: `seo.noindex` → `{ index: false }`.
+ * - `alternates.canonical`: `seo.canonical` (EC-228), verbatim.
+ *
+ * Image resolution (EC-202/EC-266): `seo.image` is an asset field, delivered as a resolved
+ * asset object (`{ id, url, … }`) → its `url`; a string is a passthrough URL or a raw asset
+ * id resolved against the page's baked `assets`; anything unresolvable is dropped — an
+ * `og:image` must carry a real URL, never an internal id.
+ *
+ * `hreflang` alternates are intentionally NOT derived here (a per-page translation map is
+ * the sitemap's — EC-517).
+ */
+interface SeoMetadataContext {
+    /** The SEO role field name — `result.seoField`. Default: the conventional `seo`. */
+    seoField?: string | null;
+    /** The display title — `result.title` (the title role, resolved). */
+    title?: string | null;
+    /** The page's resolved locale (`result.tags.locale`) — for `og:locale`. */
+    locale?: string;
+    /** The page-scoped baked assets (a raw asset-id `image` resolves against them). */
+    assets?: readonly ResolvedAsset[];
+}
+/** The {@link SeoMetadataContext} of a resolve result — the default route's one line. */
+declare function seoContextOf(result: ResolvePageResult, assets?: readonly ResolvedAsset[]): SeoMetadataContext;
 /**
  * EC-531, narrowed by EC-610 (owner ruling 3, 2026-10-23): `og:locale` ONLY in the
  * shape Open Graph specifies — `language_TERRITORY` with an underscore (`de_DE`),
@@ -623,7 +887,10 @@ declare function createCanvasRoute(options: CanvasRouteOptions): CanvasRoute;
  * Brazil, Latin America), and a wrong valid value looks deliberate.
  */
 declare function openGraphLocale(locale: string): string | null;
-declare function canvasPageMetadata(result: ResolvePageResult, assets?: readonly ResolvedAsset[]): Metadata;
+/** The document's SEO object (the field under its SEO role), or an empty record. */
+declare function seoObjectOf(doc: Record<string, unknown> | null | undefined, seoField?: string | null | undefined): Record<string, unknown>;
+/** The kit's SEO reader — see the module docs. Pure: data in, `Metadata` out. */
+declare function seoMetadata(doc: Record<string, unknown> | null | undefined, ctx?: SeoMetadataContext): Metadata;
 /**
  * EC-610 (owner ruling 1, 2026-10-13): **the site provides the default tags, and
  * the page's tags are merged on top** — a value the page states overrides the
@@ -650,72 +917,39 @@ declare function canvasPageMetadata(result: ResolvePageResult, assets?: readonly
 declare function mergeMetadataOverParent(parent: ResolvedMetadata | null | undefined, page: Metadata): Metadata;
 
 /**
- * `sitemap.xml` from published routes (EC-171): walk the same route records
- * `resolvePage` resolves against, resolve every candidate URL in the
- * **published** perspective, and emit `MetadataRoute.Sitemap` entries per
- * locale — Next's `app/sitemap.ts` convention. Pages marked `noindex` (and
- * URLs that do not resolve, e.g. a page that was never published) are
- * omitted.
- *
- * Dynamic routes (`/blog/:slug`): a route record does not declare which
- * collection feeds its params, so enumeration is delegated to the host's
- * {@link SitemapParamsProvider} — it gets a published-perspective accessor
- * client and returns one param record per concrete URL (typically from
- * `listDocuments`). **Honest limit:** parameterized routes without a provider
- * (or provider entries missing a param) are skipped and reported in
- * `skipped`, never guessed. `lastModified` is omitted — the delivery shape
- * carries no per-page timestamps today.
- *
- * Hierarchy mounts (`/:path*`, EC-218): a page-tree mount self-describes its
- * URLs, so it is enumerated automatically from the collection's published
- * documents (composing each page's nested path from its parent chain) — no
- * params provider entry needed.
- *
- * **Enumeration is a candidate list, not the output (EC-486).** Every branch
- * above — static, provider-fed, and mount — only proposes paths; each one is
- * then put back through `resolvePage`, and a path the resolver refuses is
- * dropped. So the sitemap cannot claim a URL the delivery host would 404, even
- * though the mount branch enumerates its collection independently of route
- * precedence. Do not read the enumeration in isolation: the gate below it is
- * what makes the two agree. What a mount enumerated and the resolver then
- * refused is reported in {@link CanvasSitemapResult.skipped}, never dropped in
- * silence.
+ * `sitemap.xml` from published routes (EC-171, reshaped by EC-590): the URL of every
+ * published document of every collection a route names, per locale — Next's
+ * `app/sitemap.ts` convention. Documents marked `noindex` in their SEO object, and URLs
+ * that do not resolve, are omitted.
+ *
+ * **The router enumerates, no host provider (EC-590; EC-565 Round 3, 3e).** A route record
+ * names the collection it serves (`document.collection`), so the router's `urlsFor` —
+ * the same reverse direction the studio's live link and every rendered link read —
+ * yields one URL per published document: template routes (`/blog/:slug`), hierarchy
+ * mounts (`/:path*`, composed through the parent and slug roles) and literal-id routes
+ * alike. The former `SitemapParamsProvider` existed because "a route record does not
+ * declare which collection feeds its params" — false for every document-bound route
+ * (F6c RESTATED). A document-less static route (`/contact`, no `document`) is listed by
+ * its pattern.
+ *
+ * **Enumeration is a candidate list, not the output (EC-486).** Every candidate is put
+ * back through `resolvePage`, and a path the resolver refuses is dropped — so the sitemap
+ * cannot claim a URL the delivery host would 404. What was enumerated and then refused is
+ * reported in {@link CanvasSitemapResult.skipped}, never dropped in silence. `lastModified`
+ * is omitted — the delivery shape carries no per-page timestamps today.
  *
  * Host usage (`app/sitemap.ts`):
  *
  * ```ts
  * import { createCanvasSitemap } from '@elytracms/next'
- * import { loadContent } from '../lib/content'
- *
- * export default createCanvasSitemap({
- *   loadContent,
- *   baseUrl: 'https://example.com',
- *   params: ({ route, client }) =>
- *     route.id === 'r-post'
- *       ? (client.listDocuments('post').ok ? … : []) // slug per published post
- *       : null,
- * })
+ * import { elytra } from '../lib/elytra'
+ *
+ * export default createCanvasSitemap({ loadContent: elytra.loadContent, baseUrl: elytra.frontendUrl! })
  * ```
  */
-interface SitemapRouteContext {
-    route: RouteRecord;
-    locale: Locale;
-    /** Published-perspective accessor client bound to `locale`. */
-    client: ContentClient;
-}
-/**
- * Enumerate the param sets of one dynamic route — one record per concrete
- * URL (e.g. `[{ slug: 'hello-world' }, …]`). Return `null`/`undefined` to
- * skip the route (reported in `skipped`).
- */
-type SitemapParamsProvider = (ctx: SitemapRouteContext) => readonly Record<string, string>[] | null | undefined;
 interface CanvasSitemapOptions {
     /** Absolute site origin, e.g. `https://example.com` (no trailing slash needed). */
     baseUrl: string;
-    /** Route records to enumerate; defaults to the source's own route table. */
-    routes?: readonly RouteRecord[];
-    /** Param enumeration for dynamic routes (see {@link SitemapParamsProvider}). */
-    params?: SitemapParamsProvider;
 }
 interface SitemapSkippedRoute {
     routeId: string;
@@ -724,13 +958,12 @@ interface SitemapSkippedRoute {
 }
 interface CanvasSitemapResult {
     entries: MetadataRoute.Sitemap;
-    /** Routes that could not be enumerated — explicit, never silent. */
+    /** Routes whose candidates could not be published — explicit, never silent. */
     skipped: SitemapSkippedRoute[];
 }
 /**
- * Enumerate the sitemap entries of one content source (published
- * perspective). Pure over the prefetched source — synchronous accessors,
- * deterministic ordering (sorted by URL).
+ * Enumerate the sitemap entries of one content source (published perspective). Pure over
+ * the prefetched source — synchronous accessors, deterministic ordering (sorted by URL).
  */
 declare function canvasSitemapEntries(source: ContentSource, options: CanvasSitemapOptions): CanvasSitemapResult;
 interface CreateCanvasSitemapOptions extends CanvasSitemapOptions {
@@ -747,112 +980,6 @@ interface CreateCanvasSitemapOptions extends CanvasSitemapOptions {
  */
 declare function createCanvasSitemap(options: CreateCanvasSitemapOptions): () => Promise<MetadataRoute.Sitemap>;
 
-/**
- * Cache-tag pipeline (EC-146, vision AD-5) — the pure half.
- *
- * This module defines (a) the **canonical Next.js tag string format** mapping
- * the accessor-level `CacheTags` (EC-143) onto `cacheTag` / `revalidateTag` keys,
- * (b) the **tag derivation for a revalidation event** ({@link revalidationTags},
- * EC-579 — the receiver's half of the one emitter), and (c) the **pure half of the
- * route's cache entry** (EC-515): its key ({@link canvasCacheKey}), its `cacheTag`
- * calls ({@link entryTagCalls}), its life ({@link CANVAS_CACHE_LIFE}) and the
- * resolver registry the module-level `'use cache'` function reads its loader from
- * ({@link registerCanvasResolver}). No Next.js imports — everything here is
- * unit-testable; `route.tsx` holds the one `'use cache'` function that calls
- * `cacheTag` / `cacheLife` with these values.
- *
- * This is the ONE tag module: the entries are tagged here and the invalidations
- * are derived here, from the same formatters and the same scope. Before EC-579 the
- * format was mirrored twice more (the studio's browser dispatcher and an inline
- * literal in the Convex emitter), and each emitter brought its own scope.
- *
- * ## Tag format
- *
- * - `doc:<collection>:<id>` — one per document whose content was actually in
- *   the response (fetch-time tagging: includes depth-1 populated relation
- *   targets, and documents inside filtered/dynamic lists *after* the filter
- *   ran).
- * - `collection:<name>:<locale>` — the coarse membership tag: every response
- *   that read from a collection carries it, so create/delete/newly-matching
- *   documents sweep cached lists without read-set tracking.
- * - `route:<pattern>:<locale>` — the resolved URL path plus every hop of a
- *   redirect chain.
- * - `asset:<id>` — one per asset whose delivery shape the page *baked*
- *   (page-scoped images + `seoOgImage`, EC-227); editing that asset record
- *   (alt/dimensions/re-upload) drops exactly the pages that baked it. Not
- *   locale-scoped — an asset record is locale-agnostic.
- * - `project` — the whole-project sweep tag attached to **every** cached
- *   entry; derived for the events whose effect no narrower tag names (a redirect
- *   change, an asset edit — see {@link revalidationTags}).
- *
- * ## Project scope
- *
- * Every tag is prefixed `p:<projectId>:` when a scope is configured (e.g.
- * `p:prj_aurora:doc:post:post-1`). The cost is a few bytes per tag and it
- * keeps multi-project hosts (one Next app serving several builder projects)
- * from cross-invalidating, so the prefix is **on whenever the host knows its
- * project id** — decision: include it. Since EC-579 the scope has ONE owner: the
- * host. The webhook carries an event, not tags, and the receiver derives the
- * tags with the same scope its cache entries are written under (the delivery
- * kit hands both the one `contentScope`), so emitter and host can no longer
- * disagree about it.
- */
-/** Apply the optional multi-project scope prefix to one tag. */
-declare function scopeCacheTag(tag: string, scope?: string): string;
-/**
- * Tag for one document identity. `docKey` is the EC-143 `documentKey` string
- * (`<collection>:<id>`), exactly as found in `CacheTags.docs`.
- */
-declare function docCacheTag(docKey: string, scope?: string): string;
-/** The coarse membership tag of one collection in one locale. */
-declare function collectionCacheTag(collection: string, locale: string, scope?: string): string;
-/** Tag for one resolved route path (or redirect-chain hop) in one locale. */
-declare function routeCacheTag(pattern: string, locale: string, scope?: string): string;
-/**
- * The whole-project sweep tag. Attached to every cached page entry; derived for
- * the events no narrower tag covers ({@link revalidationTags}).
- */
-declare function projectSweepTag(scope?: string): string;
-/**
- * Map an accessor-level `CacheTags` (what one request actually read) onto the
- * full, deterministic (sorted, deduplicated) set of Next tag strings for the
- * cache entry — including the project sweep tag.
- */
-declare function nextCacheTags(tags: CacheTags, scope?: string): string[];
-/** The receiver's own project — what its cached entries are tagged with. */
-interface RevalidationProject {
-    /** The tag scope of this host's cache entries (`p:<scope>:…`), if any. */
-    scope?: string | undefined;
-    /** Every locale this host serves — one `collection:` tag per locale. */
-    locales: readonly string[];
-}
-/**
- * The tags one revalidation event invalidates on this host — sorted, deduplicated,
- * scoped with the receiver's OWN scope, so the emitter never needs to know it.
- *
- * - `publish` / `unpublish` / `delete` → `doc:<collection>:<id>` (its detail page and
- *   every cached list that contained it) + `collection:<collection>:<locale>` for
- *   EVERY locale this host serves (list membership may have changed, and a URL
- *   cached as not-found for a document that now exists carries it too). **No
- *   sweep** — a publish drops exactly the entries that read the document or its
- *   collection (EC-515);
- * - `redirects` → the sweep (routing can change any URL; see the `redirects` trigger
- *   in the studio's `convex/triggers.ts` for why a targeted `route:` tag is wrong);
- * - `asset` → `asset:<id>` + the sweep (a page reading the asset through a document
- *   asset FIELD carries no `asset:` tag — EC-566 D16, EC-589);
- * - `probe` → nothing (the doctor's no-op ping).
- *
- * Why the precise tags are enough now (EC-515, option D): each route entry declares
- * its tags with `cacheTag` from INSIDE the cached function, and Next decides an
- * entry's staleness from the tags it was STORED with — so a `doc:` tag drops the
- * entries that read the document, on a self-hosted host as on any other. Until
- * then the read named only the baseline sweep (`unstable_cache` judged the
- * reading wrapper's tags), every precise tag was inert on a self-hosted host, and
- * every publish carried the sweep to compensate (wave-0091). Measured both ways
- * in EC-515's harness.
- */
-declare function revalidationTags(event: RevalidationEvent, project: RevalidationProject): string[];
-
 /**
  * Pure request logic of the revalidation webhook receiver (EC-146), kept free of
  * Next.js imports so it is unit-testable. `revalidate.ts` wires it into a route
@@ -1310,7 +1437,8 @@ declare function createPreviewDisableRoute(): PreviewRouteHandlers;
  * const route = elytra.canvasRoute()
  * export default route.Page
  * export const generateMetadata = route.generateMetadata
- * export const generateStaticParams = route.generateStaticParams // cacheComponents (EC-515)
+ * export const generateStaticParams = route.generateStaticParams // only if YOU enable cacheComponents
+ * // (to cache: pass your own 'use cache' function as `published` — see `route.tsx`, EC-620)
  *
  * // app/api/revalidate/route.ts
  * export const { POST } = elytra.revalidateRoute()
@@ -1334,7 +1462,13 @@ declare function createPreviewDisableRoute(): PreviewRouteHandlers;
  * project declared with `defineCollection` keeps its literal types through the host and
  * `InferDocument<typeof host, 'post'>` (`@elytracms/core/cms-core`) is a delivered post.
  */
-interface ElytraHostOptions<Collections extends readonly CollectionDef[] = readonly CollectionDef[]> {
+interface ElytraHostOptions<Collections extends readonly CollectionDef[] = readonly CollectionDef[]> extends Omit<WorkspaceProjectEntry, 'slug' | 'locales' | 'collections' | 'routes' | 'components' | 'frontendUrl'> {
+    /**
+     * The project's display name (the entry's own `name` — `{ ...site }` carries it).
+     * EC-583: the options ARE the config's project entry plus the host-only keys below,
+     * and the kit resolves them through the one resolver the studio boots through.
+     */
+    name: string;
     /**
      * The project slug (config-as-code identity, mirrors `elytra.config.ts`).
      * Used as the content scope when no live backend is configured.
@@ -1400,8 +1534,9 @@ interface ElytraHostOptions<Collections extends readonly CollectionDef[] = reado
      */
     components?: readonly HostComponentEntry[];
     /**
-     * The public base URL of the delivery site (mirrors the config's
-     * `frontendUrl`) — exposed on the handle for sitemap/canonical use.
+     * The public base URL of the delivery site (the config's project-level
+     * `frontendUrl`). The handle's {@link ElytraHost.frontendUrl} is the RESOLVED one —
+     * the bound environment's own URL when it declares one (EC-583).
      */
     frontendUrl?: string;
     /**
@@ -1438,18 +1573,18 @@ interface HostCanvasRouteOptions {
      */
     wrap?: (children: ReactNode, ctx: CanvasWrapContext) => ReactNode;
     /**
-     * Tagged cache entry (instant publish): one `'use cache'` entry per URL, tagged
-     * with what its resolution read (EC-515; the host enables `cacheComponents`).
-     * Always on and always scoped to the kit's {@link ElytraHost.contentScope}, with
-     * the kit's {@link ElytraHost.contentMode} in the entry key (EC-543). `false`
-     * disables caching entirely.
+     * The host's cache function for published requests (EC-620 — see
+     * `CanvasRouteOptions.published`): your own `'use cache'` function that calls
+     * `route.resolve(key)`, `route.applyCacheTags(outcome)` and picks its `cacheLife`.
+     * Omit it and the route resolves every request fresh (dynamic, uncached).
      *
-     * There is no scope override (EC-579): the kit's revalidate receiver derives its
-     * tags with that same `contentScope`, so one value scopes both the entries and
-     * their invalidation. An override here was the one way left for the two to
-     * disagree — and a disagreement drops nothing, silently.
+     * The route it builds is always scoped to the kit's {@link ElytraHost.contentScope}
+     * with the kit's {@link ElytraHost.contentMode} in every cache key (EC-543), and
+     * there is no override (EC-579): the kit's revalidate receiver derives its tags with
+     * that same `contentScope`, so one value scopes both the entries and their
+     * invalidation — a disagreement would drop nothing, silently.
      */
-    cache?: false;
+    published?: CanvasRouteOptions['published'];
 }
 interface LoadGlobalsOptions {
     /** Perspective of the chrome read. Default `'published'` (live is published-only). */
@@ -1506,19 +1641,37 @@ interface ElytraHost<Collections extends readonly CollectionDef[] = readonly Col
     contentMode: ElytraContentMode;
     /** The resolved env bag (documented names, trimmed, empty = unset). */
     env: ElytraHostEnv;
-    /** Materialized route records (a derive is run once, at factory time). */
+    /**
+     * The ONE resolved project (EC-583) — the options resolved through
+     * `resolveProject`, the same rules the studio boots through: composed, defaulted,
+     * validation slots normalized, routes materialized, every boot rule applied. The
+     * kit reads its locales, collections, routes and frontend URL from here.
+     */
+    project: ResolvedProject;
+    /**
+     * The project's route issue set at boot (EC-590 — the ONE router's: route conflicts,
+     * mount conflicts, reachability). Surfaced on the console at build and in dev; the
+     * editorial redirects (data) are judged per snapshot by the content client's
+     * `routerIssues` and in the studio.
+     */
+    routeIssues: readonly CmsValidationIssue[];
+    /** Materialized route records (the resolved project's; a derive ran once, at factory time). */
     routes: RouteRecord[];
     /** The registered component surface — exactly the `components` option's list (EC-591). */
     components: HostComponents;
-    /** The public base URL of the delivery site, when configured. */
+    /**
+     * The public base URL of the delivery site, when configured — the resolved project's
+     * (`projectFrontendUrl`): the bound environment's own `frontendUrl`, else the
+     * project-level one. The same answer the studio's live links read (EC-583).
+     */
     frontendUrl?: string;
     /**
      * The content loader (the seam every kit surface reads through): live
      * delivery snapshot when env is configured — published, or the token-gated
      * draft for draft-mode requests — else the fallback source.
      *
-     * An UNCACHED read (EC-515): only the canvas route's entry caches. Under
-     * `cacheComponents`, live-mode I/O in a layout or page outside `<Suspense>` fails
+     * An UNCACHED read: the kit caches nothing itself (EC-620 — caching is the host's).
+     * Under `cacheComponents`, live-mode I/O in a layout or page outside `<Suspense>` fails
      * `next build` — call it inside a `<Suspense>`'d component (route handlers and
      * `sitemap.ts` just render dynamically).
      */
@@ -1580,10 +1733,10 @@ declare function createElytraHost<const Collections extends readonly CollectionD
  * `DRAFT_PREVIEW_TOKEN` — the same single secret that gates the kit's
  * preview-enable route (see `host-env.ts`).
  *
- * Routes: config-sourced route records (AD-3/AD-11, EC-207 — the host repo's
- * own `cms/`, passed via options) and the implicit per-locale home fallback are
- * MERGED (EC-177 gap 2), never XOR'd — config records win per pattern+locale.
- * The backend never carries route data.
+ * Routes: the config's route records (AD-3/AD-11, EC-207), exactly as resolved —
+ * the backend never carries route data, and the engine derives none (EC-590: the
+ * implicit "`/` → the lowest-id `page`" home fallback is gone with every other
+ * engine-dictated name; a project declares its `/`, the scaffold ships one).
  */
 interface LiveContentOptions {
     /** Convex deployment URL, e.g. `https://your-deployment-123.convex.cloud`. */
@@ -1596,7 +1749,7 @@ interface LiveContentOptions {
     locales: LocaleConfigInput;
     /** CMS collection schema — config-owned (AD-11); drives depth-1 relation population. */
     collections: readonly CollectionDef[];
-    /** Route records — config-owned (AD-3/AD-11); merged with the home fallback. */
+    /** Route records — config-owned (AD-3/AD-11), the resolved project's. */
     routes: readonly RouteRecord[];
     /** `DRAFT_PREVIEW_TOKEN` — required for draft-perspective loads. */
     draftToken?: string;
@@ -1616,7 +1769,6 @@ interface DeliverySnapshotPayload {
     documents: unknown[];
     assets: unknown[];
 }
-
 /**
  * Assemble a fetched delivery-snapshot payload into a `ContentSource` — the
  * pure half of {@link loadLiveContent}, exported so the parsing/assembly rules
@@ -1718,4 +1870,4 @@ declare function evaluatePreviewRequest(requestUrl: string | URL, expectedToken:
  */
 declare const PACKAGE = "@elytracms/next";
 
-export { type AssetImageLoaderOptions, type BakedListing, CANVAS_VALIDATION_SLUG, type CanvasCacheOptions, type CanvasContentRequest, type CanvasPageOutcome, CanvasRenderer, type CanvasRendererProps, type CanvasRequestInfo, type CanvasRoute, type CanvasRouteOptions, type CanvasRouteProps, type CanvasSitemapOptions, type CanvasSitemapResult, type CanvasWrapContext, type ContentSnapshot, type ContentSnapshotOptions, type ContentSource, type CreateCanvasSitemapOptions, type DeliveryPresentation, ELYTRA_HOST_ENV_KEYS, type ElytraContentMode, type ElytraHost, type ElytraHostEnv, type ElytraHostImageOptions, type ElytraHostOptions, ElytraImage, type ElytraImageAsset, type ElytraImageProps, type GlobalsConventions, type HostCanvasRouteOptions, type HostComponent, type HostComponents, type LiveContentOptions, type LoadGlobalsOptions, type NextImageOptions, PACKAGE, type PreviewEvaluation, type PreviewRouteHandlers, type PreviewRouteOptions, type ResolveCanvasPageOptions, type ResolveGlobalsOptions, type ResolvedLink, type ResolvedNavEntry, type ResolvedNavLink, type RevalidateEvaluation, type RevalidateRouteHandlers, type RevalidateRouteOptions, type RevalidationProject, type SiteGlobals, type SitemapParamsProvider, type SitemapRouteContext, type SitemapSkippedRoute, type StaticContentData, assembleLiveSource, bodyItemsOf, canvasPageMetadata, canvasSitemapEntries, collectionCacheTag, createAssetImageLoader, createCanvasRoute, createCanvasSitemap, createContentSnapshot, createElytraHost, createPreviewDisableRoute, createPreviewRoute, createRevalidateRoute, createStaticContentSource, defineHostComponents, docCacheTag, elytraHostImage, evaluatePreviewRequest, evaluateRevalidateRequest, firstBlockFullBleed, loadLiveContent, mergeCacheTags, mergeMetadataOverParent, nextCacheTags, openGraphLocale, pathFromSlug, projectSweepTag, resolveCanvasPage, resolveGlobals, resolveHostEnv, revalidationTags, routeCacheTag, safeRedirectTarget, scopeCacheTag, withNextImage };
+export { type AssetImageLoaderOptions, type BakedListing, CANVAS_VALIDATION_SLUG, type CanvasCacheKey, type CanvasContentRequest, type CanvasPageOutcome, CanvasRenderer, type CanvasRendererProps, type CanvasRequestInfo, type CanvasRoute, type CanvasRouteOptions, type CanvasRouteProps, type CanvasSitemapOptions, type CanvasSitemapResult, type CanvasWrapContext, type ContentSnapshot, type ContentSnapshotOptions, type ContentSource, type CreateCanvasSitemapOptions, type DeliveryPresentation, ELYTRA_HOST_ENV_KEYS, type ElytraContentMode, type ElytraHost, type ElytraHostEnv, type ElytraHostImageOptions, type ElytraHostOptions, ElytraImage, type ElytraImageAsset, type ElytraImageProps, type GlobalsConventions, type HostCanvasRouteOptions, type HostComponent, type HostComponents, type LiveContentOptions, type LoadGlobalsOptions, type NextImageOptions, PACKAGE, type PreviewEvaluation, type PreviewRouteHandlers, type PreviewRouteOptions, type ResolveCanvasPageOptions, type ResolveGlobalsOptions, type ResolvedLink, type ResolvedNavEntry, type ResolvedNavLink, type RevalidateEvaluation, type RevalidateRouteHandlers, type RevalidateRouteOptions, type RevalidationProject, type SeoMetadataContext, type SiteGlobals, type SitemapSkippedRoute, type StaticContentData, assembleLiveSource, bodyItemsOf, canvasSitemapEntries, collectionCacheTag, createAssetImageLoader, createCanvasRoute, createCanvasSitemap, createContentSnapshot, createElytraHost, createPreviewDisableRoute, createPreviewRoute, createRevalidateRoute, createStaticContentSource, defineHostComponents, docCacheTag, elytraHostImage, evaluatePreviewRequest, evaluateRevalidateRequest, firstBlockFullBleed, loadLiveContent, mergeCacheTags, mergeMetadataOverParent, nextCacheTags, openGraphLocale, pathFromSlug, projectSweepTag, requestPerspective, resolveCanvasPage, resolveGlobals, resolveHostEnv, revalidationTags, routeCacheTag, safeRedirectTarget, scopeCacheTag, seoContextOf, seoMetadata, seoObjectOf, withNextImage };