smoodly 0.0.51 → 0.0.52

package/dist/next/page-renderer.d.ts

@@ -3,7 +3,7 @@ import type { Metadata } from "next";
 import type { Descriptor } from "../fields.ts";
 import { type PairedPage } from "../render.tsx";
 import type { GlobalSchema } from "../global.ts";
-import { type SmoodlySite } from "../site.ts";
+import { type ContentReads } from "../site.ts";
 /** Logged once per renderer when Next's cacheComponents is on (spec 2026-09-27 cache components §2). */
 export declare const CACHE_COMPONENTS_WARNING = "smoodly: Next's cacheComponents is on, and Smoodly does not support it \u2014 a missing page answers 200 with noindex instead of 404, and a redirect answers 200 instead of 308. Turn cacheComponents off in next.config.ts; the Next.js guide's \"Cache Components\" section says why (https://smoodly.io/docs/frameworks/nextjs).";
 /** A registered section, as renderPage's registry needs it. */
@@ -22,7 +22,7 @@ export type PageRegistration = ((props: any) => ReactElement) & {
     };
 };
 export type PageRendererOptions = {
-    site: SmoodlySite;
+    site: ContentReads;
     sections: SectionEntry[];
     /** Registered Elements: what the custom section's default richtext renderer needs when no RichText is bound (spec 2026-09-14 §6). */
     elements?: SectionEntry[];

package/dist/next/page-renderer.js

@@ -8,6 +8,7 @@ import { jsx as _jsx, Fragment as _Fragment, jsxs as _jsxs } from "react/jsx-run
 import { Suspense } from "react";
 import { draftMode } from "next/headers";
 import { notFound, permanentRedirect, unstable_rethrow } from "next/navigation";
+import { markCanvasPath, readCanvasMarker } from "../canvas-marker.js";
 import { BRIDGE_CSS } from "../marks.js";
 import { CanvasBridgeSlot, CanvasNetSlot } from "./canvas-slot.js";
 import { DRAFT_META_NAME } from "../admin/editor/canvas-diagnosis.js";
@@ -36,8 +37,9 @@ export function createPageRenderer(options) {
      *  The hit for a located target (locate is uncached: the id it returns IS the cache tag): the read
      *  layer's unit, run by Next's adapter — the draft inside draft mode, one cached unit outside it. */
     const load = (target, locale, path, version) => nextReads.run(hitUnit(site, target, locale, path, version));
-    /** A redirect row (spec 2026-09-26 redirects §7): the node's CURRENT path in this locale, through href, the query kept; no path there is a 404. */
-    async function redirectTo(target, locale, params) {
+    /** A redirect row (spec 2026-09-26 redirects §7): the node's CURRENT path in this locale, through href, the query
+     *  and the canvas marker kept; no path there is a 404. */
+    async function redirectTo(target, locale, params, flags) {
         const current = (await site.targetPaths(target))[locale];
         if (!current)
             notFound();
@@ -50,7 +52,8 @@ export function createPageRenderer(options) {
                     query.append(k, item);
         }
         const qs = query.toString();
-        permanentRedirect(href(current, locale) + (qs ? `?${qs}` : ""));
+        const to = href(current, locale) + (qs ? `?${qs}` : "");
+        permanentRedirect(flags ? markCanvasPath(to, flags) : to);
     }
     function render(hit, editor, locale) {
         if (hit.kind === "page") {
@@ -94,28 +97,32 @@ export function createPageRenderer(options) {
         cacheComponentsWarned = true;
         console.warn(CACHE_COMPONENTS_WARNING);
     }
-    async function page(pathFor, opts, accept) {
+    async function page(address, opts, accept) {
         warnCacheComponents(); // before buildGate(), so a build's prerender prints it too
         // A CMS route renders on its first visit and is cached until a tag expires it (plan 2026-10-09 next
         // cached routes): nothing here may touch a dynamic API at run time. At build, the gate keeps a route
         // without a dynamic segment off the database (DESIGN.md §3).
         await buildGate();
         const locale = opts?.locale ?? site.locales.default;
-        const path = pathFor(locale);
         const { isEnabled: draft } = await draftMode();
+        const { pathFor, marker } = address(draft);
+        const path = pathFor(locale);
         // searchParams is a dynamic API: read inside draft mode only, where the render is dynamic anyway.
         const params = draft ? await opts?.searchParams : undefined;
-        // Both parameters exist only inside draft mode: the public site never sees an editor bridge or an old version.
-        const editor = draft && params?.["smoodly-editor"] === "1";
+        // The flags exist only inside draft mode: the public site never sees an editor bridge or an old version. The
+        // canvas marks the path (Vercel strips the query); the query still works where a host keeps it.
         const versionParam = params?.["smoodly-version"];
-        const version = draft && typeof versionParam === "string" && versionParam !== "" ? versionParam : undefined;
+        const editor = draft && (marker?.editor === true || params?.["smoodly-editor"] === "1");
+        const version = !draft ? undefined
+            : marker?.version ?? (typeof versionParam === "string" && versionParam !== "" ? versionParam : undefined);
+        const flags = marker?.editor ? { editor: true } : marker?.version ? { version: marker.version } : null;
         const target = await site.locate(locale, path);
         // No document to tag: a redirect row, a miss or a code-owned page. Next caches the response like a
         // page, so it hears the addresses tag (reads.ts missUnit, decision 4).
         const tagAddress = () => nextReads.run(missUnit(site));
         if (target?.redirect) {
             await tagAddress();
-            await redirectTo(target, locale, params);
+            await redirectTo(target, locale, params, flags);
         }
         if (!target)
             await tagAddress();
@@ -168,10 +175,14 @@ export function createPageRenderer(options) {
     }
     return {
         getSmoodlyGlobal,
-        renderSmoodlyPath: (segments, opts) => page(literal(segments), opts, any),
+        renderSmoodlyPath: (segments, opts) => page((draft) => {
+            // The catch-all's segments may end with the canvas marker; only a draft-mode render reads it.
+            const marker = draft ? readCanvasMarker(segments) : null;
+            return { pathFor: literal(marker ? marker.segments : segments), marker };
+        }, opts, any),
         smoodlyMetadata: (segments, opts) => metadata(literal(segments), opts, any),
         /** A fixed registration rendered from the developer's own route file. */
-        renderSmoodlyPage: (Page, opts) => page(fixedPath(Page), opts, only(Page)),
+        renderSmoodlyPage: (Page, opts) => page(() => ({ pathFor: fixedPath(Page), marker: null }), opts, only(Page)),
         smoodlyPageMetadata: (Page, opts) => metadata(fixedPath(Page), opts, only(Page)),
     };
 }

package/dist/next/queries.d.ts

@@ -1,10 +1,10 @@
 import type { CollectionSchema } from "../collections.ts";
 import type { GlobalSchema } from "../global.ts";
 import { type SmoodlyQueries } from "../reads.ts";
-import type { SmoodlySite } from "../site.ts";
+import type { ContentReads } from "../site.ts";
 export type { SmoodlyQueries, QueryOptions, EntriesQuery, TypedEntryItem, GlobalValue } from "../reads.ts";
 export declare function createSmoodlyQueries<const C extends readonly CollectionSchema<any, string>[], const S extends readonly GlobalSchema<any, string>[] = []>(options: {
-    site: SmoodlySite;
+    site: ContentReads;
     collections: C;
     globals?: S;
 }): SmoodlyQueries<C, S>;

package/dist/path-index.d.ts

@@ -1,5 +1,4 @@
 import type { PathRow, PathTarget } from "./paths.ts";
-import { type Anchors } from "./anchors.ts";
 export type { PathRow, PathTarget } from "./paths.ts";
 /** A rewrite target; `redirectLocales` names the locales whose old live rows stay as redirects (none = drop them). */
 export type RewriteTarget = PathTarget & {
@@ -29,26 +28,3 @@ export interface PathIndex {
 }
 export declare const pathTakenError: (locale: string, path: string) => Error;
 export declare const pathLiveError: (locale: string, path: string) => Error;
-export declare class MemoryPathIndex implements PathIndex {
-    private anchors;
-    private rows;
-    /** Held by reference: the config's addresses, read on every call (spec 2026-09-29 anchored paths §2). */
-    constructor(anchors?: Anchors);
-    /** A stored row as callers see it: the full URL, or nothing when its anchor has no address. */
-    private shown;
-    private shownAll;
-    rewrite(targets: RewriteTarget[], rows: PathRow[]): Promise<void>;
-    remove(targets: PathTarget[]): Promise<void>;
-    private hit;
-    resolve(locale: string, path: string): Promise<PathHit | null>;
-    pathsOf(target: PathTarget): Promise<Record<string, string>>;
-    livePathsIn(kind: "page" | "entry", ids: string[], locale: string): Promise<Record<string, string>>;
-    redirectsOf(target: PathTarget): Promise<PathRow[]>;
-    /** Every live URL in the locale; an editor's row under a code address is left out, since visitors never reach it (spec §4). */
-    listLive(locale: string): Promise<PathRow[]>;
-    listRedirects(locale: string): Promise<PathRow[]>;
-    /** A redirect by hand stays absolute (anchor ''): refused where the URL resolves live; a redirect there is replaced. */
-    addRedirect(row: PathRow): Promise<void>;
-    /** Deletes the redirect rows a URL reaches, under any candidate anchor; a live row there is left alone. */
-    removeRedirect(locale: string, path: string): Promise<void>;
-}

package/dist/path-index.js

@@ -1,100 +1,2 @@
-import { candidates, fullPath, pickHit, sameUrlKeys } from "./anchors.js";
-const sameTarget = (a, b) => a.kind === b.kind && a.id === b.id;
 export const pathTakenError = (locale, path) => new Error(`smoodly: the path "${path}" (${locale}) is already taken.`);
 export const pathLiveError = (locale, path) => new Error(`smoodly: "${path}" (${locale}) is a live address.`);
-const key = (locale, anchor, path) => `${locale} ${anchor} ${path}`;
-const stored = (r) => ({ kind: r.kind, id: r.id, locale: r.locale, anchor: r.anchor ?? "", path: r.path, redirect: false });
-export class MemoryPathIndex {
-    /** Held by reference: the config's addresses, read on every call (spec 2026-09-29 anchored paths §2). */
-    constructor(anchors = { addresses: {}, homePageSlug: "home", defaultLocale: "en" }) {
-        this.anchors = anchors;
-        this.rows = [];
-    }
-    /** A stored row as callers see it: the full URL, or nothing when its anchor has no address. */
-    shown(r) {
-        const path = fullPath(this.anchors, r.anchor, r.path, r.locale);
-        return path === null ? null : { kind: r.kind, id: r.id, locale: r.locale, path };
-    }
-    shownAll(rows) {
-        return rows.map((r) => this.shown(r)).filter((r) => r !== null);
-    }
-    async rewrite(targets, rows) {
-        const incoming = rows.map(stored);
-        const ofTarget = (r) => targets.find((t) => sameTarget(t, r));
-        // Every key a new row's full URL answers to: live wins a redirect there under any anchor (a redirect by
-        // hand has none), and an old row at the same full URL is the same address, not an old one.
-        const newKeys = new Set(incoming.flatMap((r) => sameUrlKeys(this.anchors, r.locale, r.anchor, r.path).map((k) => key(r.locale, k.anchor, k.path))));
-        // 1. redirect rows at the new live addresses go, whoever they point at (live wins, rename-back reclaims)
-        let kept = this.rows.filter((r) => !(r.redirect && newKeys.has(key(r.locale, r.anchor, r.path))));
-        // 2. the targets' old live rows: flipped to redirects in the named locales unless the address stays live
-        kept = kept.map((r) => {
-            const t = !r.redirect ? ofTarget(r) : undefined;
-            return t && t.redirectLocales?.includes(r.locale) && !newKeys.has(key(r.locale, r.anchor, r.path)) ? { ...r, redirect: true } : r;
-        });
-        // 3. the targets' remaining live rows go — and so do their redirect rows in a locale the target has no new live row in
-        const liveLocales = new Set(incoming.map((r) => `${r.kind} ${r.id} ${r.locale}`));
-        kept = kept.filter((r) => !ofTarget(r) || (r.redirect && liveLocales.has(`${r.kind} ${r.id} ${r.locale}`)));
-        // 4. the new live rows: a collision now is with another target's live row under the same anchor
-        const taken = new Set(kept.map((r) => key(r.locale, r.anchor, r.path)));
-        for (const r of incoming) {
-            const k = key(r.locale, r.anchor, r.path);
-            if (taken.has(k))
-                throw pathTakenError(r.locale, fullPath(this.anchors, r.anchor, r.path, r.locale) ?? r.path);
-            taken.add(k);
-        }
-        this.rows = [...kept, ...incoming];
-    }
-    async remove(targets) {
-        this.rows = this.rows.filter((r) => !targets.some((t) => sameTarget(t, r)));
-    }
-    hit(locale, url) {
-        const { keys, coded } = candidates(this.anchors, locale, url);
-        return pickHit(this.rows.filter((r) => r.locale === locale), keys, coded);
-    }
-    async resolve(locale, path) {
-        const row = this.hit(locale, path);
-        return row ? { kind: row.kind, id: row.id, redirect: row.redirect } : null;
-    }
-    async pathsOf(target) {
-        const out = {};
-        for (const r of this.shownAll(this.rows.filter((r) => !r.redirect && sameTarget(r, target))))
-            out[r.locale] = r.path;
-        return out;
-    }
-    async livePathsIn(kind, ids, locale) {
-        const wanted = new Set(ids);
-        const out = {};
-        for (const r of this.shownAll(this.rows.filter((r) => !r.redirect && r.kind === kind && r.locale === locale && wanted.has(r.id))))
-            out[r.id] = r.path;
-        return out;
-    }
-    async redirectsOf(target) {
-        return this.shownAll(this.rows.filter((r) => r.redirect && sameTarget(r, target)));
-    }
-    /** Every live URL in the locale; an editor's row under a code address is left out, since visitors never reach it (spec §4). */
-    async listLive(locale) {
-        const served = (r) => !(r.anchor === "" && candidates(this.anchors, locale, r.path).coded);
-        return this.shownAll(this.rows.filter((r) => !r.redirect && r.locale === locale && served(r))).sort((a, b) => a.path.localeCompare(b.path));
-    }
-    async listRedirects(locale) {
-        return this.shownAll(this.rows.filter((r) => r.redirect && r.locale === locale)).sort((a, b) => a.path.localeCompare(b.path));
-    }
-    /** A redirect by hand stays absolute (anchor ''): refused where the URL resolves live; a redirect there is replaced. */
-    async addRedirect(row) {
-        const existing = this.hit(row.locale, row.path);
-        if (existing && !existing.redirect)
-            throw pathLiveError(row.locale, row.path);
-        // An editor's page hidden under a code address still holds its row: a redirect never stacks on it.
-        if (this.rows.some((r) => !r.redirect && r.locale === row.locale && r.anchor === "" && r.path === row.path))
-            throw pathLiveError(row.locale, row.path);
-        // Every redirect the URL reaches goes, under any anchor: the new one replaces them all.
-        const { keys } = candidates(this.anchors, row.locale, row.path);
-        const replaced = (r) => r.redirect && r.locale === row.locale && keys.some((k) => k.anchor === r.anchor && k.path === r.path);
-        this.rows = [...this.rows.filter((r) => !replaced(r)), { ...stored({ ...row, anchor: "" }), redirect: true }];
-    }
-    /** Deletes the redirect rows a URL reaches, under any candidate anchor; a live row there is left alone. */
-    async removeRedirect(locale, path) {
-        const { keys } = candidates(this.anchors, locale, path);
-        this.rows = this.rows.filter((r) => !(r.redirect && r.locale === locale && keys.some((k) => k.anchor === r.anchor && k.path === r.path)));
-    }
-}

package/dist/push.d.ts

@@ -0,0 +1,30 @@
+import type { ResolvedConfig } from "./config.ts";
+import { type RegistryJson } from "./registry-json.ts";
+/** The pushing site: where it lives, where its admin is mounted, how it delivers, and whether the host says this build
+ *  is a preview deployment (`transient`: its admin works, but a publish never calls it). */
+export type SiteInfo = {
+    url: string;
+    adminPath: string;
+    mode: "live" | "static";
+    deployHook?: string;
+    transient: boolean;
+};
+export type PushBody = {
+    registry: RegistryJson;
+    site: SiteInfo | null;
+    package: string;
+};
+/** The site's address from SITE_URL; null when it is unset (the space then records no address). */
+export declare function siteInfo(config: ResolvedConfig, env: Record<string, string | undefined>, mode: "live" | "static"): SiteInfo | null;
+export declare function pushBody(config: ResolvedConfig, env: Record<string, string | undefined>, mode: "live" | "static"): PushBody;
+export type PushApi = {
+    apiUrl: string;
+    spaceId: string;
+    key: string;
+    fetch?: typeof fetch;
+};
+/** One push: the space's version of the registry, and whether this push changed it. A refusal throws `SmoodlyApiError`. */
+export declare function pushSchema(api: PushApi, body: PushBody): Promise<{
+    version: number;
+    changed: boolean;
+}>;

package/dist/push.js

@@ -0,0 +1,52 @@
+// The push (spec 2026-10-16 the control plane §4): a site tells its space the registry it runs, its own address and
+// delivery mode, and the package version, at `POST /v1/spaces/:space/schema` under the secret key. `smoodly push`, Astro's
+// build hook, the Next templates' prebuild and the API client in development all send this one body. The space keeps
+// the registry, versions it and purges its pages when it changed; a failed push never fails a build.
+import { SmoodlyApiError } from "./api-client.js";
+import { serializeRegistry } from "./registry-json.js";
+import { SMOODLY_VERSION } from "./version.js";
+/** A preview deployment, as the three hosts the spec names say it: Vercel, Netlify, Cloudflare Pages. */
+function isPreview(env) {
+    if (env.VERCEL_ENV === "preview")
+        return true;
+    if (env.CONTEXT === "deploy-preview")
+        return true;
+    return !!env.CF_PAGES_BRANCH && !!env.CF_PAGES_PRODUCTION_BRANCH && env.CF_PAGES_BRANCH !== env.CF_PAGES_PRODUCTION_BRANCH;
+}
+/** The site's address from SITE_URL; null when it is unset (the space then records no address). */
+export function siteInfo(config, env, mode) {
+    const url = env.SITE_URL?.replace(/\/+$/, "");
+    if (!url)
+        return null;
+    return {
+        url,
+        adminPath: config.admin.path,
+        mode,
+        ...(env.SMOODLY_DEPLOY_HOOK ? { deployHook: env.SMOODLY_DEPLOY_HOOK } : {}),
+        transient: isPreview(env),
+    };
+}
+export function pushBody(config, env, mode) {
+    return { registry: serializeRegistry(config), site: siteInfo(config, env, mode), package: SMOODLY_VERSION };
+}
+/** One push: the space's version of the registry, and whether this push changed it. A refusal throws `SmoodlyApiError`. */
+export async function pushSchema(api, body) {
+    const apiUrl = api.apiUrl.replace(/\/+$/, "");
+    const doFetch = api.fetch ?? fetch;
+    let res;
+    try {
+        res = await doFetch(`${apiUrl}/v1/spaces/${encodeURIComponent(api.spaceId)}/schema`, {
+            method: "POST",
+            headers: { authorization: `Bearer ${api.key}`, "content-type": "application/json", accept: "application/json" },
+            body: JSON.stringify(body),
+        });
+    }
+    catch (e) {
+        throw new TypeError(`smoodly: can't reach SMOODLY_API_URL (${apiUrl}): ${e instanceof Error ? e.message : String(e)}`);
+    }
+    const answer = (await res.json().catch(() => null));
+    if (!answer || !answer.ok) {
+        throw new SmoodlyApiError(res.status, answer?.code ?? "internal", answer?.message ?? `smoodly: SMOODLY_API_URL (${apiUrl}) answered ${res.status} with no message.`);
+    }
+    return { version: answer.data.version, changed: answer.data.changed };
+}

package/dist/read-counter.d.ts

@@ -0,0 +1,2 @@
+/** One read for the adapters' counters: a database call in the service's client, an API call in api-client.ts. */
+export declare function countRead(): void;

package/dist/read-counter.js

@@ -0,0 +1,6 @@
+// Where a framework adapter hears each read (spec 2026-10-07 delivery model): the Astro request scope installs a counter, so a test can hold a live page to one lookup. A global, not an import: the client stays free of any adapter.
+const READ_COUNTER = Symbol.for("smoodly:read-counter");
+/** One read for the adapters' counters: a database call in the service's client, an API call in api-client.ts. */
+export function countRead() {
+    globalThis[READ_COUNTER]?.();
+}

package/dist/reads.d.ts

@@ -3,7 +3,7 @@ import type { GlobalSchema } from "./global.ts";
 import type { PathTarget } from "./paths.ts";
 import { type EntryItem, type PageItem } from "./read-shapes.ts";
 import type { Materialize } from "./schema.ts";
-import type { AddressWithGlobals, EntryQuery, PageTreeItem, SiteHit, SmoodlySite } from "./site.ts";
+import type { AddressWithGlobals, ContentReads, EntryQuery, PageTreeItem, SiteHit } from "./site.ts";
 /** One content read, as the framework's cache needs it. */
 export type ReadUnit<T> = {
     /** What the published read holds: two calls with one key may share a cached `read(false)`. A draft read
@@ -56,17 +56,17 @@ export type SmoodlyQueries<C extends readonly CollectionSchema<any, string>[], S
  *  what the unit holds, not only where: an address that changes owner — a deploy handing it to a code
  *  record, which fires no tag — can never serve the previous occupant (spec 2026-09-29 pre-install fixes
  *  §5). `version` is History's stored version and counts inside draft mode only. */
-export declare function hitUnit(site: SmoodlySite, target: PathTarget, locale: string, path: string, version?: string): ReadUnit<SiteHit | null>;
+export declare function hitUnit(site: ContentReads, target: PathTarget, locale: string, path: string, version?: string): ReadUnit<SiteHit | null>;
 /** An address with no document to tag — a miss, a redirect row or a code-owned page. The unit reads
  *  nothing: it exists so a cached response hears the `addresses` tag, which every address-changing
  *  operation fires (revalidate.ts). Next runs it (its route cache stores a 404 like a page); Astro never
  *  caches such a response and does not call it. One key for every address: the tag reaches the route
  *  entry before the lookup, so a per-address key would only write one data-cache row per scanned 404. */
-export declare function missUnit(site: SmoodlySite): ReadUnit<null>;
+export declare function missUnit(site: ContentReads): ReadUnit<null>;
 /** Astro's route read of an address: one lookup outside draft mode — the tags come with the document, so no
  *  locate comes first; in draft mode, locate then load as the editing tables need (spec 2026-10-07 delivery
  *  model §3). A redirect row answers as a redirect; a code-owned page answers where no record lives. */
-export declare function addressUnit(site: SmoodlySite, locale: string, path: string, version?: string): ReadUnit<SiteHit | {
+export declare function addressUnit(site: ContentReads, locale: string, path: string, version?: string): ReadUnit<SiteHit | {
     kind: "redirect";
     target: PathTarget;
 } | null>;
@@ -74,12 +74,12 @@ export declare function addressUnit(site: SmoodlySite, locale: string, path: str
  *  `lookupWithGlobals`, and the shell seeds each value into the request scope under `globalUnit`'s key, so the
  *  layout's loaders cost no call. The tags are the hit's; a global's tag joins when the layout reads it. A draft
  *  read brings no globals: a preview reads live. */
-export declare function addressWithGlobalsUnit(site: SmoodlySite, locale: string, path: string, items: readonly GlobalSchema<any>[], version?: string): ReadUnit<AddressWithGlobals>;
+export declare function addressWithGlobalsUnit(site: ContentReads, locale: string, path: string, items: readonly GlobalSchema<any>[], version?: string): ReadUnit<AddressWithGlobals>;
 /** A global item's unit, by schema: the one `q.getGlobal` runs for the same item and locale. */
-export declare function globalUnit<V>(site: SmoodlySite, item: GlobalSchema<V>, locale: string): ReadUnit<V | null>;
+export declare function globalUnit<V>(site: ContentReads, item: GlobalSchema<V>, locale: string): ReadUnit<V | null>;
 /** The typed queries over a site, run by the framework's adapter. */
 export declare function createQueries<const C extends readonly CollectionSchema<any, string>[], const S extends readonly GlobalSchema<any, string>[] = []>(options: {
-    site: SmoodlySite;
+    site: ContentReads;
     collections: C;
     globals?: S;
 }, adapter: ReadAdapter): SmoodlyQueries<C, S>;

package/dist/reads.js

@@ -51,6 +51,9 @@ export function addressUnit(site, locale, path, version) {
 function tagsOfHit(value) {
     if (!value || value.kind === "redirect")
         return [];
+    // A published document carries its delivery row's tags (its own and every ref it embeds).
+    if (value.tags)
+        return value.tags;
     if (value.kind === "entry")
         return [entryTag(value.entry.id)];
     // A code-owned page has no row to expire it by.

package/dist/registry-json.d.ts

@@ -0,0 +1,11 @@
+import { type ResolvedConfig } from "./config.ts";
+export type RegistryJson = {
+    v: 1;
+    config: Record<string, unknown>;
+};
+/** The pushed form of a resolved config: its defineConfig input, as data. */
+export declare function serializeRegistry(config: ResolvedConfig): RegistryJson;
+/** A resolved config from its pushed form: the ref thunks resolve by name within the same registry. */
+export declare function hydrateRegistry(json: RegistryJson): ResolvedConfig;
+/** The registry's fingerprint: SHA-256 hex of its key-sorted JSON. */
+export declare function registryHash(json: RegistryJson): Promise<string>;

package/dist/registry-json.js

@@ -0,0 +1,81 @@
+// The registry as JSON (spec 2026-10-16 the control plane §4): what `smoodly push` carries to the space. It is the
+// defineConfig input, rebuilt from the resolved config, with the only functions a config holds replaced: a ref's
+// target thunk becomes the name of the collection it returns, and any other function (a view the config does not
+// need) is dropped. Hydrating is defineConfig over the revived input, so the derived parts (addresses, anchors, the
+// styles descriptors) come from the one function that computes them.
+import { defineConfig } from "./config.js";
+const COLLECTION = "$collection";
+const isPlain = (value) => value !== null && typeof value === "object" && !Array.isArray(value);
+/** Plain data out of a config value: a `target` thunk becomes `{ $collection: name }`, any other function goes. */
+function toData(value, key) {
+    if (typeof value === "function") {
+        return key === "target" ? { [COLLECTION]: value().name } : undefined;
+    }
+    if (Array.isArray(value))
+        return value.map((item) => toData(item));
+    if (isPlain(value)) {
+        const out = {};
+        for (const [k, v] of Object.entries(value)) {
+            const data = toData(v, k);
+            if (data !== undefined)
+                out[k] = data;
+        }
+        return out;
+    }
+    return value;
+}
+/** The pushed form of a resolved config: its defineConfig input, as data. */
+export function serializeRegistry(config) {
+    const { sections, elements, collections, globals, pages } = config.registry;
+    const input = {
+        registry: { sections, elements, collections, globals, pages },
+        locales: config.locales,
+        ...(config.timeZone !== undefined ? { timeZone: config.timeZone } : {}),
+        pages: { tree: { depth: config.pageDepth } },
+        styles: config.styles,
+        css: config.css,
+        custom: { breakpoint: config.custom.breakpoint, toolset: config.custom.toolset },
+        homePageSlug: config.homePageSlug,
+        ...(config.database !== undefined ? { database: config.database } : {}),
+        media: config.media,
+        admin: { path: config.admin.path },
+        routing: config.routing,
+    };
+    return { v: 1, config: toData(input) };
+}
+/** `{ $collection: name }` back into a thunk over the hydrated registry's own collections and globals. */
+function revive(value, byName) {
+    if (Array.isArray(value))
+        return value.map((item) => revive(item, byName));
+    if (!isPlain(value))
+        return value;
+    const keys = Object.keys(value);
+    if (keys.length === 1 && keys[0] === COLLECTION && typeof value[COLLECTION] === "string") {
+        const name = value[COLLECTION];
+        return () => {
+            const target = byName.get(name);
+            if (!target)
+                throw new Error(`smoodly: the pushed registry has a ref to "${name}", which it does not register.`);
+            return target;
+        };
+    }
+    return Object.fromEntries(Object.entries(value).map(([k, v]) => [k, revive(v, byName)]));
+}
+/** A resolved config from its pushed form: the ref thunks resolve by name within the same registry. */
+export function hydrateRegistry(json) {
+    const byName = new Map();
+    const input = revive(json.config, byName);
+    // The thunks run only after defineConfig, which keeps the collections and globals it was given.
+    for (const c of [...(input.registry.collections ?? []), ...(input.registry.globals ?? [])])
+        byName.set(c.name, c);
+    return defineConfig(input);
+}
+/** JSON with every object's keys sorted, so two equal registries stringify alike whatever their key order. */
+function sortedJson(value) {
+    return JSON.stringify(value, (_key, v) => isPlain(v) ? Object.fromEntries(Object.keys(v).sort().map((k) => [k, v[k]])) : v);
+}
+/** The registry's fingerprint: SHA-256 hex of its key-sorted JSON. */
+export async function registryHash(json) {
+    const digest = await crypto.subtle.digest("SHA-256", new TextEncoder().encode(sortedJson(json)));
+    return [...new Uint8Array(digest)].map((b) => b.toString(16).padStart(2, "0")).join("");
+}

package/dist/render.d.ts

@@ -5,7 +5,6 @@ import { type StyleValues } from "./styles.ts";
 import { type CustomOptions } from "./custom/CustomSection.tsx";
 import { type EditorWrap, type PageContext, type PageTree, type ZoneContent } from "./page-context.ts";
 export type { TreeNode, PageTree, PageLink, PageContextLink, PageContextAlternate, PageContext, ZoneContent, EditorWrap } from "./page-context.ts";
-export { EMPTY_PAGE_CONTEXT } from "./page-context.ts";
 type AnyPaired = ComponentType<any> & {
     schema: {
         name: string;

package/dist/render.js

@@ -8,7 +8,7 @@ import { createCustomSection } from "./custom/CustomSection.js";
 import { EMPTY_PAGE_CONTEXT } from "./page-context.js";
 import { renderGuarded } from "./section-guard.js";
 import { PLACEHOLDER_STYLE } from "./section-crash.js";
-export { EMPTY_PAGE_CONTEXT } from "./page-context.js";
+;
 export function Zone({ of: content }) {
     // A malformed tree (bad data, a client that skipped isPageTree) must not
     // crash the render — treat a non-array nodes as empty rather than throw.

package/dist/resolve.d.ts

@@ -2,7 +2,8 @@ import type { Descriptor } from "./fields.ts";
 import type { CollectionSchema } from "./collections.ts";
 import type { PageTree } from "./page-context.ts";
 import { type GlobalSchema } from "./global.ts";
-import { type AssetRecord } from "./media.ts";
+import { type AssetRecord, type ImageDefaults } from "./media.ts";
+import type { CutSigner } from "./media-cut.ts";
 import { type ElementSchemas } from "./richtext-walk.ts";
 import type { SectionLike } from "./refs.ts";
 import type { Toolset } from "./toolset.ts";
@@ -31,6 +32,11 @@ type ResolveOptions = {
     paths?: PathLookup;
     /** Media (spec 2026-09-08 §9): one batched asset fetch per page, values become resolved objects. */
     assets?: AssetFetcher;
+    /** Signs each image's cut where the service cuts (spec 2026-10-18 media on R2 and Images §5); absent, no cut. */
+    signer?: CutSigner;
+    /** The project's image quality and srcset cap, stamped on each image under its field's own (spec 2026-10-18 image
+     *  quality and max width §6). */
+    images?: ImageDefaults;
     /** The registered global items a placement node may name (spec 2026-09-07 §4). */
     globals?: GlobalSchema[];
     /** Registered Elements a richtext document may embed (spec 2026-09-08 block nodes §2). */
@@ -48,17 +54,17 @@ type ResolveOptions = {
 };
 export declare function resolveTree(tree: PageTree, options: ResolveOptions): Promise<PageTree>;
 /** One value set's media, resolved in place. Exported for the site layer's global-item settings. */
-export declare function resolveMedia(values: Record<string, unknown>, descriptors: Record<string, Descriptor>, fetch: AssetFetcher, elements?: ElementSchemas): Promise<void>;
-/** Many value sets, one asset round (plus one for posters): the tree's
- *  nodes and every entry hydrated through a ref, or a list page's items.
- *  Exported for the site layer's content API. */
-export declare function resolveMediaSets(sets: MediaSet[], fetch: AssetFetcher, elements?: ElementSchemas): Promise<void>;
+export declare function resolveMedia(values: Record<string, unknown>, descriptors: Record<string, Descriptor>, fetch: AssetFetcher, elements?: ElementSchemas, signer?: CutSigner, defaults?: ImageDefaults): Promise<void>;
 export type ResolveFieldsOptions = {
     collections: CollectionSchema<any>[];
     fetch: EntryFetcher;
     /** Each hydrated ref's address (spec 2026-09-29 content API contract §2). */
     paths?: PathLookup;
     assets?: AssetFetcher;
+    /** Signs each image's cut (spec 2026-10-18 media on R2 and Images §5); absent, no cut. */
+    signer?: CutSigner;
+    /** The project's image quality and srcset cap (spec 2026-10-18 image quality and max width §6). */
+    images?: ImageDefaults;
     /** Registered Elements a richtext document may embed (spec 2026-09-08 block nodes §2). */
     elements?: SectionLike[];
     maxDepth?: number;

package/dist/resolve.js

@@ -7,7 +7,7 @@
 // chain gets a shallow copy (refs as ids), so traversal terminates by
 // construction and the output stays JSON-serializable.
 import { globalLink, GLOBAL_NODE_TYPE, SETTINGS_KEY, STYLES_KEY, CSS_KEY } from "./global.js";
-import { applyAssets, collectAssetIds } from "./media.js";
+import { applyAssets, collectAssetIds, signCuts } from "./media.js";
 import { elementSchemas } from "./richtext-walk.js";
 import { SEO_KEY } from "./seo.js";
 import { CUSTOM_NODE_TYPE, customSchema, customToolset } from "./custom/index.js";
@@ -62,7 +62,7 @@ export async function resolveTree(tree, options) {
             sets.push({ values: resolved.fields, descriptors: options.page.fields });
         if (resolved.meta)
             sets.push({ values: resolved.meta, descriptors: META_DESCRIPTORS });
-        await resolveMediaSets([...sets, ...hydrated], options.assets, elementSchemas(options.elements));
+        await resolveMediaSets([...sets, ...hydrated], options.assets, elementSchemas(options.elements), options.signer, options.images);
     }
     return resolved;
 }
@@ -83,19 +83,22 @@ async function fetchAssets(fetch, ids) {
     return out;
 }
 /** One value set's media, resolved in place. Exported for the site layer's global-item settings. */
-export async function resolveMedia(values, descriptors, fetch, elements = {}) {
-    await resolveMediaSets([{ values, descriptors }], fetch, elements);
+export async function resolveMedia(values, descriptors, fetch, elements = {}, signer, defaults) {
+    await resolveMediaSets([{ values, descriptors }], fetch, elements, signer, defaults);
 }
 /** Many value sets, one asset round (plus one for posters): the tree's
  *  nodes and every entry hydrated through a ref, or a list page's items.
  *  Exported for the site layer's content API. */
-export async function resolveMediaSets(sets, fetch, elements = {}) {
+async function resolveMediaSets(sets, fetch, elements = {}, signer, defaults) {
     const ids = new Set();
     for (const { values, descriptors } of sets)
         collectAssetIds(values, descriptors, ids, elements);
     const assets = await fetchAssets(fetch, ids);
+    const cuts = signer ? [] : undefined;
     for (const { values, descriptors } of sets)
-        applyAssets(values, descriptors, assets, elements);
+        applyAssets(values, descriptors, assets, elements, cuts, defaults);
+    if (signer && cuts)
+        await signCuts(cuts, signer);
 }
 /** Placements first (spec 2026-09-07 §4): fetch every linked item in one
  *  call per item, rewrite each node into the item's section node — the
@@ -148,7 +151,7 @@ export async function resolveFields(fields, descriptors, options) {
     collectTasks(resolved, descriptors, tasks);
     const hydrated = await runResolution(tasks, { ...options, maxDepth: options.maxDepth ?? Infinity });
     if (options.assets)
-        await resolveMediaSets([{ values: resolved, descriptors }, ...hydrated], options.assets, elementSchemas(options.elements));
+        await resolveMediaSets([{ values: resolved, descriptors }, ...hydrated], options.assets, elementSchemas(options.elements), options.signer, options.images);
     return resolved;
 }
 /** Many value sets (a list's entries), one resolution: every ref batched per
@@ -159,7 +162,7 @@ export async function resolveFieldSets(sets, options) {
         collectTasks(values, descriptors, tasks);
     const hydrated = await runResolution(tasks, { ...options, maxDepth: options.maxDepth ?? Infinity });
     if (options.assets)
-        await resolveMediaSets([...sets, ...hydrated], options.assets, elementSchemas(options.elements));
+        await resolveMediaSets([...sets, ...hydrated], options.assets, elementSchemas(options.elements), options.signer, options.images);
 }
 /** Hydrates every task's refs in place and returns each hydrated entry
  *  copy with its collection's descriptors — the media pass walks those