smoodly 0.0.47 → 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/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/project.d.ts

@@ -15,6 +15,9 @@ export declare const PROJECTION_CAP = 100;
 export type ProjectOptions = {
     cap?: number;
     write?: boolean;
+    /** `false` (a behind rebuild on a read, spec 2026-10-09 static mode §5): an existing row keeps its publishedAt, so
+     *  the rebuild is not counted as a publish the static site has not got. Default true: a publish, `npx smoodly rebuild`. */
+    stamp?: boolean;
 };
 export type Projector = {
     /** Writes the delivery rows of these pages in every supported locale (a row per visible locale, removed where not visible). Returns the keys it could not fit under the cap, already marked stale. */

package/dist/project.js

@@ -127,7 +127,8 @@ export function createProjector(deps) {
             const missing = ids.filter((id) => !byId.has(id));
             if (write && missing.length > 0)
                 await deps.stores().published.remove(missing.map((id) => ({ kind: "page", id })));
-            return project(options?.cap ?? cap, "page", ids.filter((id) => byId.has(id)).map((id) => byId.get(id)), (p) => p.id, (p, locale) => pageRow(a, p, all, locale), (rows) => deps.stores().published.putPages(rows), write);
+            const keep = options?.stamp === false;
+            return project(options?.cap ?? cap, "page", ids.filter((id) => byId.has(id)).map((id) => byId.get(id)), (p) => p.id, (p, locale) => pageRow(a, p, all, locale), (rows) => deps.stores().published.putPages(rows, { keep }), write);
         },
         async entries(ids, options) {
             const a = assembler.batch();
@@ -143,7 +144,8 @@ export function createProjector(deps) {
             const write = options?.write !== false;
             if (write && missing.length > 0)
                 await deps.stores().published.remove(missing);
-            return project(options?.cap ?? cap, "entry", found, (h) => h.record.id, (h, locale) => entryRow(a, h.schema, h.record, locale), (rows) => deps.stores().published.putEntries(rows), write);
+            const keep = options?.stamp === false;
+            return project(options?.cap ?? cap, "entry", found, (h) => h.record.id, (h, locale) => entryRow(a, h.schema, h.record, locale), (rows) => deps.stores().published.putEntries(rows, { keep }), write);
         },
         async healPage(id, locale, options) {
             const { pages, published } = deps.stores();
@@ -159,8 +161,9 @@ export function createProjector(deps) {
                     await bestEffort(`removing page ${id} (${locale})`, () => published.remove([{ kind: "page", id, locale }]));
                 return null;
             }
+            // A heal keeps the row's publishedAt: it rebuilds what a publish wrote, it is not one (spec 2026-10-09 static mode §5).
             if (write)
-                await bestEffort(`writing page ${id} (${locale})`, () => published.putPages([projected]));
+                await bestEffort(`writing page ${id} (${locale})`, () => published.putPages([projected], { keep: true }));
             return projected.document;
         },
         async healEntry(id, locale, options) {
@@ -174,7 +177,7 @@ export function createProjector(deps) {
                 return null;
             }
             if (write)
-                await bestEffort(`writing entry ${id} (${locale})`, () => published.putEntries([row]));
+                await bestEffort(`writing entry ${id} (${locale})`, () => published.putEntries([row], { keep: true }));
             return row.document;
         },
         async healGlobal(item, locale, options) {
@@ -190,7 +193,7 @@ export function createProjector(deps) {
                 return null;
             }
             if (write)
-                await bestEffort(`writing global ${item.name} (${locale})`, () => published.putEntries([row]));
+                await bestEffort(`writing global ${item.name} (${locale})`, () => published.putEntries([row], { keep: true }));
             return row.document;
         },
         markStale: (keys) => deps.stores().published.markStale(keys),

package/dist/published.d.ts

@@ -66,10 +66,15 @@ export type PublishedKey = {
     id: string;
     locale?: string;
 };
+export type PutOptions = {
+    keep?: boolean;
+};
 export interface PublishedStore {
     /** Upsert by (id, locale). */
-    putPages(rows: PublishedPageRow[]): Promise<void>;
-    putEntries(rows: PublishedEntryRow[]): Promise<void>;
+    /** `keep` (a heal, a behind rebuild on read): an existing row keeps its publishedAt, a new row is dated now; without it
+     *  every row is dated now (a publish, `npx smoodly rebuild`). The static build's count reads publishedAt (spec 2026-10-09 §5). */
+    putPages(rows: PublishedPageRow[], options?: PutOptions): Promise<void>;
+    putEntries(rows: PublishedEntryRow[], options?: PutOptions): Promise<void>;
     /** Every locale of the id when `locale` is absent. */
     remove(keys: PublishedKey[]): Promise<void>;
     /** The one-call lookup: a reachable page or entry at the address, else null. With `globals` (collection names of
@@ -92,6 +97,18 @@ export interface PublishedStore {
         behind: number;
         total: number;
     }>;
+    /** The latest published_at over the space's pages and entries (ms); null when nothing is published. The static build's watermark (spec 2026-10-09 static mode §5). */
+    newestPublishedAt(): Promise<number | null>;
+    /** Rows published strictly after `since` (ms), pages plus entries: the Deploy tile's "changes waiting". */
+    countPublishedAfter(since: number): Promise<number>;
+    /** The space's last Deploy press (schema v11, space_deploys); null until the first press. */
+    deployRequest(): Promise<{
+        at: number;
+        by: string | null;
+    } | null>;
+    requestDeploy(by: string | null, at?: number): Promise<void>;
+    /** When a row last went (an unpublish, a delete): a change the count of newer rows cannot see (same row, `removed_at`). */
+    lastRemovalAt(): Promise<number | null>;
 }
 export declare class MemoryPublishedStore implements PublishedStore {
     private pages;
@@ -99,13 +116,23 @@ export declare class MemoryPublishedStore implements PublishedStore {
     private recorded;
     recordedModel(): Promise<string | null>;
     recordModel(model: string): Promise<void>;
+    private deploy;
+    newestPublishedAt(): Promise<number | null>;
+    countPublishedAfter(since: number): Promise<number>;
+    deployRequest(): Promise<{
+        at: number;
+        by: string | null;
+    } | null>;
+    requestDeploy(by: string | null, at?: number): Promise<void>;
     countBehind(model: string): Promise<{
         behind: number;
         total: number;
     }>;
-    putPages(rows: PublishedPageRow[]): Promise<void>;
-    putEntries(rows: PublishedEntryRow[]): Promise<void>;
+    putPages(rows: PublishedPageRow[], options?: PutOptions): Promise<void>;
+    putEntries(rows: PublishedEntryRow[], options?: PutOptions): Promise<void>;
+    private removedAt;
     remove(keys: PublishedKey[]): Promise<void>;
+    lastRemovalAt(): Promise<number | null>;
     byAddress(locale: string, path: string, globals?: readonly string[]): Promise<PublishedRoute | null>;
     page(id: string, locale: string): Promise<PublishedPageRow | null>;
     entry(id: string, locale: string): Promise<PublishedEntryRow | null>;