smoodly 0.0.46 → 0.0.48

package/dist/astro/index.js

@@ -2,28 +2,36 @@
 // astro.config mounts the admin, the preview address and the page shell, adds the middleware that
 // collects cache tags, and supplies the project's config and its views as virtual modules. The project
 // holds no glue file. This module runs in the build tool, and in a script through createContent; never on the server.
-import { join, relative } from "node:path";
+import { mkdir, writeFile } from "node:fs/promises";
+import { dirname, join, relative } from "node:path";
 import { fileURLToPath } from "node:url";
 import { DEFAULT_ADMIN_PATH } from "../admin-path.js";
 import { createSupabaseStores, siteOptions } from "../bind.js";
+import { loadConfig, loadConfigFile } from "../cli/load-config.js";
 import { createSmoodlyClient } from "../client.js";
 import { createSmoodlyContent } from "../content/content-api.js";
+import { markerJson, MARKER_PATH } from "../deploy-state.js";
 import { resolveSmoodlyEnv, siteUrl } from "../env.js";
 import { mediaRemotePattern } from "../image/remote-pattern.js";
 import { loadSmoodlyEnv } from "./env-files.js";
 import { astroRouting, localeHref } from "./locale-paths.js";
 import { PREVIEW_BASE } from "./preview.js";
+import { hostRedirects, redirectEntries, rootRedirect } from "./static.js";
 import { createSmoodlySite } from "../site.js";
 // In the repository this file is TypeScript; in the published package tsc made it JavaScript, and the
 // .astro files were copied beside it unchanged.
 const ext = import.meta.url.endsWith(".ts") ? ".ts" : ".js";
 const here = (path) => fileURLToPath(new URL(path, import.meta.url));
-/** The three routes, most specific first; a page file of the project's own wins over the shell for its address. */
-export function routes(adminPath) {
+/** The three routes, most specific first; a page file of the project's own wins over the shell for its address.
+ *  The admin and the preview address are always on demand; the page shell is the prerendered one in static
+ *  output (spec 2026-10-09 static mode §3) and the on-demand one in server output. */
+export function routes(adminPath, output = "server") {
     return [
-        { pattern: `${adminPath}/[...path]`, entrypoint: here(`./routes/admin${ext}`) },
-        { pattern: `${PREVIEW_BASE}/[...path]`, entrypoint: here("./routes/preview.astro") },
-        { pattern: "/[...path]", entrypoint: here("./routes/page.astro") },
+        { pattern: `${adminPath}/[...path]`, entrypoint: here(`./routes/admin${ext}`), prerender: false },
+        { pattern: `${PREVIEW_BASE}/[...path]`, entrypoint: here("./routes/preview.astro"), prerender: false },
+        output === "static"
+            ? { pattern: "/[...path]", entrypoint: here("./routes/static-page.astro"), prerender: true }
+            : { pattern: "/[...path]", entrypoint: here("./routes/page.astro"), prerender: false },
     ];
 }
 /** The views by file name, under the project's source dir (root-relative, "/src" by default): a section's
@@ -36,8 +44,10 @@ export const views = { sections: ${glob("sections")}, elements: ${glob("elements
 `;
 }
 const VIEWS_ID = "\0smoodly:views";
-/** `root` is the project's directory; `srcDir` its source dir relative to the root, with a leading slash. */
-export function virtualModules(root, configFile, srcDir = "/src") {
+const BUILD_ID = "\0smoodly:build";
+/** `root` is the project's directory; `srcDir` its source dir relative to the root, with a leading slash;
+ *  `output` astro.config's, which `smoodly:build` tells the preview route and the server. */
+export function virtualModules(root, configFile, srcDir = "/src", output = "server") {
     return {
         name: "smoodly:virtual",
         resolveId(id) {
@@ -45,20 +55,37 @@ export function virtualModules(root, configFile, srcDir = "/src") {
                 return join(root, configFile);
             if (id === "smoodly:views")
                 return VIEWS_ID;
+            if (id === "smoodly:build")
+                return BUILD_ID;
             return undefined;
         },
         load(id) {
-            return id === VIEWS_ID ? viewsModule(srcDir) : undefined;
+            if (id === VIEWS_ID)
+                return viewsModule(srcDir);
+            if (id === BUILD_ID)
+                return `export const output = ${JSON.stringify(output)};\n`;
+            return undefined;
         },
     };
 }
 export default function smoodly(options = {}) {
     const adminPath = options.adminPath ?? DEFAULT_ADMIN_PATH;
+    // Closed over by the build hooks: astro.config's output and the project's root, as the setup hook saw them, and
+    // the watermark the marker carries.
+    let output = "server";
+    let root = process.cwd();
+    let watermark = null;
+    /** The project's stores at build, from its config file (the one `options.config` names) and the env the setup hook loaded. */
+    const buildStores = async () => {
+        const loaded = options.config ? await loadConfigFile(join(root, options.config), root) : await loadConfig(root);
+        return { loaded, ...createSupabaseStores(createSmoodlyClient(resolveSmoodlyEnv(process.env)), loaded) };
+    };
     return {
         name: "smoodly",
         hooks: {
-            "astro:config:setup": ({ config, command, updateConfig, injectRoute, addMiddleware, logger }) => {
-                const root = fileURLToPath(config.root);
+            "astro:config:setup": async ({ config, command, updateConfig, injectRoute, addMiddleware, logger }) => {
+                root = fileURLToPath(config.root);
+                output = config.output === "static" ? "static" : "server";
                 // Root-relative with a leading slash, as Vite's import.meta.glob reads it; a source dir that is the root itself is "".
                 const rel = relative(root, fileURLToPath(config.srcDir)).split("\\").join("/");
                 const srcDir = rel === "" ? "" : "/" + rel;
@@ -69,12 +96,12 @@ export default function smoodly(options = {}) {
                     logger.warn("smoodly: SMOODLY_URL is not set at build — every image will fail: Astro's /_image serves only hosts in image.remotePatterns, and the media host is taken from SMOODLY_URL here. Set it where `astro build` runs.");
                 updateConfig({
                     image: { remotePatterns: mediaUrl ? [mediaRemotePattern(mediaUrl)] : [] },
-                    vite: { plugins: [virtualModules(root, options.config ?? "smoodly.config.ts", srcDir)] },
+                    vite: { plugins: [virtualModules(root, options.config ?? "smoodly.config.ts", srcDir, output)] },
                 });
-                for (const route of routes(adminPath))
-                    injectRoute({ ...route, prerender: false });
+                for (const route of routes(adminPath, output))
+                    injectRoute(route);
                 addMiddleware({ entrypoint: here(`./middleware${ext}`), order: "pre" });
-                if (!config.cache?.provider) {
+                if (output === "server" && !config.cache?.provider) {
                     logger.warn("smoodly: no cache provider in astro.config — every page renders from the database. Add `cache: { provider: memoryCache() }` (from \"astro/config\").");
                 }
                 // astro.config is evaluated before Astro loads .env, so `site: process.env.SITE_URL` there sees only the
@@ -84,9 +111,42 @@ export default function smoodly(options = {}) {
                     siteUrl(process.env);
                     updateConfig({ site: process.env.SITE_URL });
                 }
+                else if (!config.site && output === "static") {
+                    // The Deploy tile reads the build marker from the live address: without one the admin could not open, so the
+                    // build says so now, where the developer is looking (final review 2026-10-09).
+                    throw new Error("smoodly: static output needs `site` — the Deploy tile reads the build marker from the live address. Set SITE_URL in .env or where `astro build` runs, or `site` in astro.config.");
+                }
                 else if (!config.site) {
                     logger.warn("smoodly: `site` is not set — canonical, hreflang and og:url links are built from each request's own origin, which behind a proxy can be the internal host, and a live page is cached for a year. Set SITE_URL in .env or where `astro build` runs, or `site` in astro.config.");
                 }
+                // Static output (spec 2026-10-09 static mode §3): the redirect rows and the prefix-always root become the
+                // host's redirects, answered without a function. Read at build only; `astro dev` serves them on demand.
+                if (output === "static" && command === "build") {
+                    const { loaded, pages } = await buildStores();
+                    const routing = astroRouting(config.i18n, loaded.locales);
+                    const href = localeHref(loaded.locales, routing);
+                    const redirects = { ...(await redirectEntries({ pages, config: loaded, href })), ...rootRedirect(routing, href, loaded.locales) };
+                    updateConfig({ redirects: hostRedirects(config.redirects, redirects) });
+                    logger.info(`smoodly: static output — ${Object.keys(redirects).length} redirects handed to the host.`);
+                }
+            },
+            // The marker's watermark (spec 2026-10-09 static mode §5) is read BEFORE any page renders: a publish that lands
+            // while the build runs is then newer than it and counts as waiting, which it is — the build may not hold it. A
+            // row the build itself rebuilds keeps its publishedAt (a heal is not a publish, project.ts), so it never counts.
+            "astro:build:start": async () => {
+                if (output !== "static")
+                    return;
+                watermark = await (await buildStores()).published.newestPublishedAt();
+            },
+            // The build marker: beside the pages, the only trace of Smoodly in a static build.
+            "astro:build:done": async ({ dir, logger }) => {
+                if (output !== "static")
+                    return;
+                const marker = markerJson({ builtAt: Date.now(), publishedThrough: watermark });
+                const file = join(fileURLToPath(dir), MARKER_PATH);
+                await mkdir(dirname(file), { recursive: true });
+                await writeFile(file, marker);
+                logger.info(`smoodly: wrote ${MARKER_PATH}.`);
             },
         },
     };

package/dist/astro/middleware.js

@@ -18,6 +18,10 @@ export const onRequest = defineMiddleware(async (context, next) => {
     const admin = config.admin.path;
     if (pathname === admin || pathname.startsWith(`${admin}/`))
         return next();
+    // A page prerendered at build (spec 2026-10-09 static mode §3) has no request, no cookie and no cache: the
+    // static shell passes its own state, and the file carries no header of ours.
+    if (context.isPrerendered)
+        return next();
     const locals = context.locals;
     // The preview route rewrites to the page's own address, which runs the middleware again: the first pass decided.
     if (locals.smoodly)

package/dist/astro/routes/admin.js

@@ -7,7 +7,7 @@ import { AsyncLocalStorage } from "node:async_hooks";
 import { createAdminHandler } from "../../admin/handler.js";
 import { expire } from "../cache.js";
 import { DRAFT_COOKIE, PREVIEW_BASE, draftCookieValue } from "../preview.js";
-import { adminDeps, secret } from "../server.js";
+import { adminDeps, deployDeps, secret } from "../server.js";
 export const prerender = false;
 const current = new AsyncLocalStorage();
 const effects = () => {
@@ -20,6 +20,7 @@ const secure = (context) => context.url.protocol === "https:" || context.request
 const handle = createAdminHandler(() => ({
     ...adminDeps(),
     previewBase: PREVIEW_BASE,
+    deploy: deployDeps(),
     effects: {
         revalidate: (tag) => void effects().expired.add(tag),
         draft: {

package/dist/astro/routes/preview.astro

@@ -1,11 +1,23 @@
 ---
 // The preview address (DESIGN.md Vision, preview per framework): /_smoodly/preview/<the page's path>,
-// open to a browser with the draft cookie and to no other. It rewrites to the page's own address, where
-// the same route a visitor gets renders the draft, so the page sees its real address. The admin and a
-// preview address inside a preview address are no page: a closed 404 for both.
-import { adminPath, previewTarget } from "smoodly/astro/runtime";
+// open to a browser with the draft cookie and to no other. The admin and a preview address inside a
+// preview address are no page: a closed 404 for both.
+// Live output: it rewrites to the page's own address, where the same route a visitor gets renders the
+// draft, so the page sees its real address. Static output (spec 2026-10-09 static mode §3): that address
+// is a file, so the preview shell renders the draft here, telling the shell the page's real address; the
+// canvas keeps the preview prefix for the links it follows.
+import { output } from "smoodly:build";
+import { views } from "smoodly:views";
+import { adminPath, previewTarget, shell } from "smoodly/astro/runtime";
 
 const target = Astro.locals.smoodly?.draft ? previewTarget(Astro.url.pathname, adminPath) : null;
 if (target === null) return new Response("Not found", { status: 404, headers: { "cache-control": "no-store" } });
-return Astro.rewrite(target + Astro.url.search);
+if (output !== "static") return Astro.rewrite(target + Astro.url.search);
+
+const result = await shell(target, Astro.url.search, Astro.locals.smoodly!, views);
+if (result.kind === "notFound") return new Response(null, { status: 404, headers: { "cache-control": "no-store" } });
+if (result.kind === "redirect") return Astro.redirect(result.location, result.status);
+const View = result.kind === "page" ? views.pages[result.template] : views.entries[result.collection];
+const props = result.kind === "page" ? { page: result.page, zones: result.zones, head: result.head } : { entry: result.entry, head: result.head };
 ---
+<View {...props} />

package/dist/astro/routes/static-page.astro

@@ -0,0 +1,21 @@
+---
+// The static page shell (spec 2026-10-09 static mode §3), injected in place of page.astro when astro.config
+// says `output: "static"`: every published address prerendered at build from its finished document, through
+// the same shell as the live route. No cache and no request state: the file is the cache, and a visitor's
+// page carries no trace of Smoodly. Drafts are edited through the preview address (routes/preview.astro).
+import { views } from "smoodly:views";
+import { shell, staticPaths } from "smoodly/astro/runtime";
+
+export async function getStaticPaths() {
+  return staticPaths();
+}
+
+const pathname = "/" + (Astro.params.path ?? "").replace(/\/+$/, "");
+const state = { draft: false, editor: false, cacheable: false, shell: false };
+const result = await shell(pathname, "", state, views);
+if (result.kind === "notFound") return new Response(null, { status: 404 });
+if (result.kind === "redirect") return Astro.redirect(result.location, result.status);
+const View = result.kind === "page" ? views.pages[result.template] : views.entries[result.collection];
+const props = result.kind === "page" ? { page: result.page, zones: result.zones, head: result.head } : { entry: result.entry, head: result.head };
+---
+<View {...props} />

package/dist/astro/runtime.d.ts

@@ -21,6 +21,12 @@ import { type Shell, type SmoodlyLocals } from "./shell.ts";
  *  A page read from the database gets its lifetime here, before its view renders. The first call compares
  *  the project's view files to the registry and names every disagreement once. */
 export declare function shell(pathname: string, search: string, state: SmoodlyLocals, views: ViewFiles, cache?: unknown): Promise<Shell>;
+/** getStaticPaths for the static page shell (spec 2026-10-09 static mode §3): every published address of the bound site. */
+export declare const staticPaths: () => Promise<{
+    params: {
+        path: string | undefined;
+    };
+}[]>;
 /** The registry's titles and settings defaults, for the zone and the richtext renderer. */
 export declare const info: RegistryInfo;
 /** The custom section's rows and layout css, at the project's (already resolved) stacking breakpoint. */

package/dist/astro/runtime.js

@@ -18,7 +18,8 @@ import { customLayout } from "./custom.js";
 import { registryInfo } from "./defaults.js";
 import { lifetime } from "./cache.js";
 import { astroReads, preload } from "./scope.js";
-import { config, href, routing, site } from "./server.js";
+import { config, href, published, routing, site } from "./server.js";
+import { staticPaths as listStatic } from "./static.js";
 import { missingViews } from "./views-check.js";
 import { resolveShell } from "./shell.js";
 let viewsChecked = false;
@@ -38,6 +39,8 @@ export async function shell(pathname, search, state, views, cache) {
         lifetime(cache);
     return result;
 }
+/** getStaticPaths for the static page shell (spec 2026-10-09 static mode §3): every published address of the bound site. */
+export const staticPaths = () => listStatic({ published: published(), config, href });
 /** The registry's titles and settings defaults, for the zone and the richtext renderer. */
 export const info = registryInfo(config.registry);
 /** The custom section's rows and layout css, at the project's (already resolved) stacking breakpoint. */

package/dist/astro/server.d.ts

@@ -6,6 +6,12 @@ export declare const routing: import("./locale-paths.ts").LocaleRouting;
 /** Locale-relative CMS path → site URL, for the operations and the `page` prop. */
 export declare const href: (path: string, locale: string) => string;
 export declare const site: () => import("../site.ts").SmoodlySite;
+/** The delivery store: the static shell lists its addresses from it, and the deploy operations read it. */
+export declare const published: () => import("../supabase-published-store.ts").SupabasePublishedStore;
+/** The deploy operations' deps in static output (spec 2026-10-09 static mode §7); undefined on a live site. */
+export declare const deployDeps: () => (import("../admin/ops-impl.ts").DeployDeps & {
+    mode: "live" | "static";
+}) | undefined;
 /** The draft cookie's key: the server-only key every Smoodly site already holds. */
 export declare const secret: () => string;
 type AdminDeps = Omit<AdminHandlerDeps, "effects" | "previewBase">;

package/dist/astro/server.js

@@ -1,8 +1,10 @@
 // The bound stores and site layer of an Astro project (spec 2026-10-02 astro cloud fit §1), built from its
 // smoodly.config.ts through the virtual module: what the Next starter's server.ts glue does, with no file
 // in the app. Built on first use, so a build that renders nothing needs no keys.
-import { i18n } from "astro:config/server";
+import { i18n, site as configuredSite } from "astro:config/server";
+import { output } from "smoodly:build";
 import { config as loaded } from "smoodly:config";
+import { deployDepsOf } from "./deploy-deps.js";
 import { supabaseAdminAuth } from "../admin/supabase-auth.js";
 import { createSupabaseStores, siteOptions } from "../bind.js";
 import { createSmoodlyClient } from "../client.js";
@@ -26,6 +28,10 @@ function build() {
 let cached = null;
 const bound = () => (cached ?? (cached = build()));
 export const site = () => bound().site;
+/** The delivery store: the static shell lists its addresses from it, and the deploy operations read it. */
+export const published = () => bound().published;
+/** The deploy operations' deps in static output (spec 2026-10-09 static mode §7); undefined on a live site. */
+export const deployDeps = () => deployDepsOf({ output, site: configuredSite, env: process.env, store: published() });
 /** The draft cookie's key: the server-only key every Smoodly site already holds. */
 export const secret = () => smoodlyEnv().secretKey;
 let admin = null;

package/dist/astro/static.d.ts

@@ -0,0 +1,36 @@
+import type { ResolvedConfig } from "../config.ts";
+import type { PublishedStore } from "../published.ts";
+import type { PageStore } from "../store.ts";
+import { type LocaleRouting } from "./locale-paths.ts";
+type Href = (path: string, locale: string) => string;
+/** Every published page and entry address of every locale, as Astro's getStaticPaths entries. A node with
+ *  no path (hidden, or a code address wins) and an entry of a collection without addresses are not pages. */
+export declare function staticPaths(deps: {
+    published: PublishedStore;
+    config: ResolvedConfig;
+    href: Href;
+}): Promise<{
+    params: {
+        path: string | undefined;
+    };
+}[]>;
+/** The redirect rows as Astro's `redirects` config: old address → the target's current address, 308 (spec
+ *  2026-09-26 redirects §7 at the host). A target with no live path in the locale is left out: a 404 as on demand. */
+export declare function redirectEntries(deps: {
+    pages: PageStore;
+    config: ResolvedConfig;
+    href: Href;
+}): Promise<Record<string, {
+    status: 308;
+    destination: string;
+}>>;
+/** Astro's `redirects` for the build: Smoodly's entries under the developer's own, so a source astro.config names
+ *  stays the developer's (final review 2026-10-09). */
+export declare function hostRedirects<D, S>(developer: Record<string, D> | undefined, smoodly: Record<string, S>): Record<string, D | S>;
+/** Under prefix-always the root is nobody's page: the host redirects it to the default locale's home, as the
+ *  on-demand shell does with a 302 (shell.ts). */
+export declare function rootRedirect(routing: LocaleRouting, href: Href, locales: ResolvedConfig["locales"]): Record<string, {
+    status: 302;
+    destination: string;
+}>;
+export {};

package/dist/astro/static.js

@@ -0,0 +1,59 @@
+import { redirectsRoot } from "./locale-paths.js";
+/** Astro's `[...path]` param: the root is undefined, otherwise the address without its slashes at either end. */
+const param = (site) => {
+    const trimmed = site.replace(/^\/+/, "").replace(/\/+$/, "");
+    return trimmed === "" ? undefined : trimmed;
+};
+/** Every published page and entry address of every locale, as Astro's getStaticPaths entries. A node with
+ *  no path (hidden, or a code address wins) and an entry of a collection without addresses are not pages. */
+export async function staticPaths(deps) {
+    const seen = new Set();
+    const out = [];
+    const add = (site) => {
+        const p = param(site);
+        if (seen.has(p))
+            return;
+        seen.add(p);
+        out.push({ params: { path: p } });
+    };
+    const collections = (deps.config.registry.collections ?? []).map((c) => c.name);
+    for (const locale of deps.config.locales.supported) {
+        for (const row of await deps.published.tree(locale))
+            if (row.path !== null)
+                add(deps.href(row.path, locale));
+        for (const name of collections) {
+            for (const row of await deps.published.entries(name, { locale }))
+                if (row.path !== null)
+                    add(deps.href(row.path, locale));
+        }
+    }
+    return out;
+}
+/** Astro reads a redirect's source as a route pattern: brackets make a param, a star or a colon a wildcard on
+ *  some hosts. A stored path with any of them would redirect more than itself, so it is a literal address or nothing. */
+const literalAddress = (path) => !/[[\]*:]/.test(path);
+/** The redirect rows as Astro's `redirects` config: old address → the target's current address, 308 (spec
+ *  2026-09-26 redirects §7 at the host). A target with no live path in the locale is left out: a 404 as on demand. */
+export async function redirectEntries(deps) {
+    const out = {};
+    for (const locale of deps.config.locales.supported) {
+        for (const row of await deps.pages.listRedirects(locale)) {
+            if (!literalAddress(row.path))
+                continue;
+            const current = (await deps.pages.targetPaths({ kind: row.kind, id: row.id }))[locale];
+            if (current && literalAddress(current))
+                out[deps.href(row.path, locale)] = { status: 308, destination: deps.href(current, locale) };
+        }
+    }
+    return out;
+}
+/** Astro's `redirects` for the build: Smoodly's entries under the developer's own, so a source astro.config names
+ *  stays the developer's (final review 2026-10-09). */
+export function hostRedirects(developer, smoodly) {
+    return { ...smoodly, ...(developer ?? {}) };
+}
+/** Under prefix-always the root is nobody's page: the host redirects it to the default locale's home, as the
+ *  on-demand shell does with a 302 (shell.ts). */
+export function rootRedirect(routing, href, locales) {
+    return redirectsRoot("/", routing) ? { "/": { status: 302, destination: href("/", locales.default) } } : {};
+}

package/dist/cli/load-config.d.ts

@@ -2,3 +2,6 @@ import type { ResolvedConfig } from "../config.ts";
 export declare const CONFIG_FILES: string[];
 export declare const noConfig: (cwd: string) => string;
 export declare function loadConfig(cwd: string): Promise<ResolvedConfig>;
+/** One named config file (the Astro integration's `config` option names it): the project's tsconfig beside `cwd`
+ *  (default: the file's folder) resolves its aliases. */
+export declare function loadConfigFile(file: string, cwd?: string): Promise<ResolvedConfig>;

package/dist/cli/load-config.js

@@ -5,7 +5,7 @@
 // model §2). The config imports no component (the registration split), so
 // it loads outside the app. Astro keeps it at the root, Next under smoodly/.
 import { existsSync } from "node:fs";
-import { join } from "node:path";
+import { dirname, join } from "node:path";
 import { pathToFileURL } from "node:url";
 import { tsImport } from "tsx/esm/api";
 export const CONFIG_FILES = ["smoodly.config.ts", "smoodly/config.ts", "src/smoodly/config.ts"];
@@ -14,6 +14,13 @@ export async function loadConfig(cwd) {
     const file = CONFIG_FILES.map((name) => join(cwd, name)).find((path) => existsSync(path));
     if (!file)
         throw new Error(noConfig(cwd));
+    return loadConfigFile(file, cwd);
+}
+/** One named config file (the Astro integration's `config` option names it): the project's tsconfig beside `cwd`
+ *  (default: the file's folder) resolves its aliases. */
+export async function loadConfigFile(file, cwd = dirname(file)) {
+    if (!existsSync(file))
+        throw new Error(`smoodly: no config file at ${file}.`);
     const tsconfig = join(cwd, "tsconfig.json");
     const mod = (await tsImport(pathToFileURL(file).href, {
         parentURL: import.meta.url,

package/dist/cli/migrate.d.ts

@@ -29,5 +29,15 @@ export type MigrateDeps = {
     env?: Record<string, string | undefined>;
     /** Test seam: replaces the database read behind the key check. */
     readKey?: (env: Record<string, string | undefined>) => Promise<SchemaRead>;
+    /** Test seam: the delivery rows behind the site's document stamp (DESIGN §3); default: the app's config, loaded, against the key's space. */
+    delivery?: (env: Record<string, string | undefined>, cwd: string) => Promise<{
+        behind: number;
+        total: number;
+    }>;
 };
+/** The delivery line of `--check` (DESIGN §3, the document stamp): a count with the one command to run, never a verdict. */
+export declare const deliveryLine: (d: {
+    behind: number;
+    total: number;
+}) => string;
 export declare function runMigrate(args: MigrateArgs, out: (line: string) => void, deps?: MigrateDeps): Promise<number>;

package/dist/cli/migrate.js

@@ -15,6 +15,10 @@ import { resolveSmoodlyEnv } from "../env.js";
 import { loadAppEnv } from "./space-io.js";
 import { planIsEmpty, planMigrate } from "../migrations.js";
 import { loadCollections } from "./load-collections.js";
+import { loadConfig } from "./load-config.js";
+import { siteOptions } from "../bind.js";
+import { documentStamp } from "../document-stamp.js";
+import { SupabasePublishedStore } from "../supabase-published-store.js";
 export const DEFAULT_COLLECTIONS = "smoodly/collections.ts";
 /** The Astro starter keeps the setup under src/ (plan 2026-10-06 astro adapter 3); the default follows it when the Next path is absent. */
 export function collectionsFile(cwd, given, exists = existsSync) {
@@ -47,6 +51,16 @@ export function describePlan(plan, check) {
     }
     return lines;
 }
+/** The delivery line of `--check` (DESIGN §3, the document stamp): a count with the one command to run, never a verdict. */
+export const deliveryLine = (d) => d.behind === 0
+    ? `Delivery: every published document is current (${d.total}).`
+    : `Delivery: ${d.behind} of ${d.total} documents are behind the current stamp — run npx smoodly rebuild.`;
+async function countDelivery(env, cwd) {
+    const config = await loadConfig(cwd);
+    const stamp = documentStamp(siteOptions(config, () => { throw new Error("smoodly: the stamp reads no store"); }));
+    const db = createSmoodlyClient(resolveSmoodlyEnv(env));
+    return new SupabasePublishedStore(db, config.registry.collections ?? []).countBehind(stamp);
+}
 /** Errors that are a verdict on the env itself, not on the network: they fail the build. */
 const ENV_VERDICT = /SMOODLY_(SECRET|PUBLISHABLE)_KEY|SMOODLY_URL "/;
 /** The build's key check (decided 2026-10-02): a key the site would be refused with fails the
@@ -72,8 +86,15 @@ async function checkKey(out, cwd, deps) {
         out(`Key not checked: ${message}`);
         return 0;
     }
-    if ("version" in read)
+    if ("version" in read) {
         out(keyChecked(read.version));
+        try {
+            out(deliveryLine(await (deps.delivery ?? countDelivery)(env, cwd)));
+        }
+        catch (e) {
+            out(`Delivery: not checked: ${e instanceof Error ? e.message : String(e)}`);
+        }
+    }
     else if (read.missing === "key") {
         out(secretKeyRefusedMessage);
         return 1;

package/dist/cli/space-io.js

@@ -45,10 +45,10 @@ export { readSchemaVersion } from "../schema-read.js";
  *  the site built from the config as the app's glue builds them, then every page and entry. */
 export async function rebuildSpace(db, config) {
     const { pages, entries, assets, published } = createSupabaseStores(db, config);
-    const { projector, cacheKey } = createSmoodlySite(siteOptions(config, () => ({ pages, entries, assets, published })));
+    const { projector, stamp } = createSmoodlySite(siteOptions(config, () => ({ pages, entries, assets, published })));
     const names = [...(config.registry.collections ?? []), ...(config.registry.globals ?? [])].map((c) => c.name);
-    // The model fingerprint every row now carries: what a rebuild after a deploy wrote.
-    return { ...(await projectAll({ stores: { pages, entries }, projector, names })), model: cacheKey };
+    // The document stamp every row now carries, recorded as the space's current one (DESIGN §3).
+    return { ...(await projectAll({ stores: { pages, entries }, projector, names })), model: stamp };
 }
 /** The line a rebuild ends with. */
 export const rebuiltMessage = (counts) => `Rebuilt the delivery tables: ${counts.pages} ${counts.pages === 1 ? "page" : "pages"}, ${counts.entries} ${counts.entries === 1 ? "entry" : "entries"}.`;

package/dist/deploy-state.d.ts

@@ -0,0 +1,28 @@
+export declare const MARKER_PATH = "_smoodly/build.json";
+/** A press this old with no newer build is "not landed": the editor looks at the host. */
+export declare const NOT_LANDED_AFTER: number;
+export type BuildMarker = {
+    builtAt: number;
+    publishedThrough: number | null;
+};
+export declare const markerJson: (m: BuildMarker) => string;
+export declare function parseMarker(text: string): BuildMarker | null;
+export type DeployState = {
+    state: "live" | "waiting" | "building" | "not-landed" | "unreachable";
+    /** Rows published after the build's watermark. */
+    waiting: number;
+    builtAt: number | null;
+    pressedAt: number | null;
+    pressedBy: string | null;
+};
+export declare function deployState(input: {
+    marker: BuildMarker | null;
+    /** The live address answered (with the marker, or without one). */
+    reachable: boolean;
+    press: {
+        at: number;
+        by: string | null;
+    } | null;
+    waiting: number;
+    now: number;
+}): DeployState;

package/dist/deploy-state.js

@@ -0,0 +1,31 @@
+// packages/smoodly/src/deploy-state.ts
+// Static mode's Deploy tile (spec 2026-10-09 static mode §5–§6): the build writes a marker beside the
+// pages, the admin reads it from the live address, and the state is pure over the marker, the last
+// press and the count of rows newer than the build's watermark. Framework-free: the integration writes
+// the marker, the operations read it, the tile shows it.
+export const MARKER_PATH = "_smoodly/build.json";
+/** A press this old with no newer build is "not landed": the editor looks at the host. */
+export const NOT_LANDED_AFTER = 10 * 60000;
+export const markerJson = (m) => JSON.stringify({ builtAt: m.builtAt, publishedThrough: m.publishedThrough });
+export function parseMarker(text) {
+    try {
+        const got = JSON.parse(text);
+        if (typeof got?.builtAt !== "number")
+            return null;
+        const through = got.publishedThrough;
+        return { builtAt: got.builtAt, publishedThrough: typeof through === "number" ? through : null };
+    }
+    catch {
+        return null;
+    }
+}
+export function deployState(input) {
+    const base = { waiting: input.waiting, builtAt: input.marker?.builtAt ?? null, pressedAt: input.press?.at ?? null, pressedBy: input.press?.by ?? null };
+    if (!input.reachable)
+        return { ...base, state: "unreachable" };
+    const press = input.press;
+    if (press && (input.marker === null || press.at > input.marker.builtAt)) {
+        return { ...base, state: input.now - press.at > NOT_LANDED_AFTER ? "not-landed" : "building" };
+    }
+    return { ...base, state: input.waiting > 0 ? "waiting" : "live" };
+}

package/dist/document-stamp.d.ts

@@ -0,0 +1,7 @@
+import type { SiteOptions } from "./site.ts";
+/** Bumped by hand when the assembler's output changes shape; the upgrading guide names each bump. */
+export declare const DOCUMENT_FORMAT = 1;
+/** The parts of the registry that reach a document: what `cacheKey` hashes, minus the presentation. */
+export declare function documentModel(options: SiteOptions): unknown;
+/** `<format>:<model hash>` — what a delivery row's `model` column holds. */
+export declare function documentStamp(options: SiteOptions): string;