smoodly 0.0.51 → 0.0.53

package/dist/astro/components/Head.astro

@@ -4,7 +4,9 @@
 // link per locale the page is published in, the Open Graph values, and noindex. Next writes the same through
 // smoodlyMetadata. Absolute addresses from `site` in astro.config, else the request's origin. A layout places
 // it inside <head>; `fallback` titles a document Smoodly has no title for (an entry whose collection has no
-// seo). A layout that writes its own <title> leaves `fallback` out and reads `of.title` itself.
+// seo). A layout that writes its own <title> leaves `fallback` out and reads `of.title` itself. A page that shows an
+// image preconnects to the media host, with no crossorigin: an <img> is fetched with credentials and would not use an
+// anonymous connection (spec 2026-10-18 media on R2 and Images §7).
 const { of: head, fallback } = Astro.props;
 const origin = (Astro.site ?? Astro.url).origin;
 const absolute = (path: string) => new URL(path, origin).href;
@@ -12,6 +14,7 @@ const title = head.title ?? fallback;
 const canonical = head.canonical ? absolute(head.canonical) : undefined;
 const image = head.image;
 ---
+{head.mediaOrigin && <link rel="preconnect" href={head.mediaOrigin} />}
 {title && <title>{title}</title>}
 {head.description && <meta name="description" content={head.description} />}
 {canonical && <link rel="canonical" href={canonical} />}

package/dist/astro/components/Image.astro

@@ -1,20 +1,15 @@
 ---
-// <Image>: a box at the aspect (declared, chosen or natural), the picture inside placed by crop and hotspot,
-// dimensions set so nothing shifts (spec 2026-09-08 media §9; the React one is image/SmoodlyImage.tsx). The
-// bytes come through Astro's image service: `getImage` turns the media URL into the /_image endpoint with a
-// srcset of widths, so a 4 MB upload is served at the size the page asks for. The media host is allowed by the
-// integration (index.ts). An SVG, or `unoptimized`, is the original. Data attributes land on the box.
-import { getImage } from "astro:assets";
-import { imageRequest, placeImage } from "smoodly/astro/runtime";
+// <Image>: the one image markup (src/image/markup.ts) written as HTML, attribute for attribute what React writes for
+// <SmoodlyImage> (spec 2026-10-18 media on R2 and Images §7): a box, a plain <img> over the cut's widths, or a <picture>
+// with a <source> per crop the view places in `media`. No Astro image service and no Smoodly JavaScript. Data
+// attributes land on the box. In a prerendered page of static output the addresses become files of the site's own
+// output, AVIF and WebP (static-media.ts, spec §8); the preview address, rendered on demand, keeps the media host's.
+import { imageHtml, imageMarkup, staticImage } from "smoodly/astro/runtime";
+import { output } from "smoodly:build";
 
-const { image, aspect, sizes, priority, loading, alt, unoptimized, class: className, style, ...data } = Astro.props;
-const placed = placeImage(image, { aspect });
-const request = imageRequest(image, { sizes, unoptimized });
-const transformed = request ? await getImage(request) : null;
-const src = transformed?.src ?? image.url;
-const srcset = transformed?.srcSet.attribute || undefined;
+const { image, aspect, media, sizes, priority, loading, alt, quality, maxWidth, class: className, style, ...data } = Astro.props;
+let markup = imageMarkup(image, { aspect, media, sizes, priority, loading, alt, quality, maxWidth });
+if (output === "static" && Astro.isPrerendered) markup = await staticImage(markup);
+const html = imageHtml(markup, { class: className, style: typeof style === "string" && style ? style : undefined, data });
 ---
-<span class={className} style={typeof style === "string" && style ? `${placed.box};${style}` : placed.box} {...data}>
-  <img src={src} srcset={srcset} sizes={srcset ? sizes : undefined} alt={alt ?? image.alt} width={image.width} height={image.height}
-    loading={priority ? "eager" : loading ?? "lazy"} fetchpriority={priority ? "high" : undefined} decoding="async" style={placed.frame} />
-</span>
+<Fragment set:html={html} />

package/dist/astro/components/Video.astro

@@ -1,5 +1,8 @@
 ---
-// A <video> over the bucket's CDN with its poster and size, no transcoding (spec 2026-09-08 media §9).
+// A <video> from the media host with its poster (a cut where there is one) and size, no transcoding (spec 2026-09-08
+// media §9).
+import { posterUrl } from "smoodly/astro/runtime";
+
 const { video, ...rest } = Astro.props;
 ---
-<video src={video.url} poster={video.poster?.url} width={video.width} height={video.height} playsinline {...rest}></video>
+<video src={video.url} poster={posterUrl(video)} width={video.width} height={video.height} playsinline {...rest}></video>

package/dist/astro/head.d.ts

@@ -9,5 +9,8 @@ export type PageHead = {
     canonical?: string;
     /** locale → the page's address there, for a multi-locale site; empty otherwise. */
     languages: Record<string, string>;
+    /** The media host of the first image the page shows, for a preconnect (spec 2026-10-18 media on R2 and Images §7):
+     *  the connection opens while the HTML is parsed. */
+    mediaOrigin?: string;
 };
 export declare function headOf(hit: SiteHit, locale: string, href: (path: string, locale: string) => string, locales: LocaleSet): PageHead;

package/dist/astro/head.js

@@ -1,3 +1,23 @@
+import { isResolvedImage } from "../richtext-href.js";
+/** The origin of the first resolved image in a document (its cut's, else its original's), depth first. */
+function firstImageOrigin(value, depth = 0) {
+    if (depth > 32 || value === null || typeof value !== "object")
+        return undefined;
+    if (isResolvedImage(value) && typeof value.mime === "string" && value.mime.startsWith("image/")) {
+        try {
+            return new URL(value.cut ?? value.url).origin;
+        }
+        catch {
+            return undefined;
+        }
+    }
+    for (const v of Array.isArray(value) ? value : Object.values(value)) {
+        const found = firstImageOrigin(v, depth + 1);
+        if (found)
+            return found;
+    }
+    return undefined;
+}
 export function headOf(hit, locale, href, locales) {
     // A page type without seo: true still titles the document with its page title; an entry without seo leaves the title to the layout.
     const seo = hit.seo ?? (hit.kind === "page" ? { title: hit.title } : {});
@@ -8,6 +28,9 @@ export function headOf(hit, locale, href, locales) {
             if (alt?.path)
                 languages[l] = href(alt.path, l);
     }
+    // What the page shows: a page's tree and its own fields, an entry's fields; never the social image alone.
+    const shown = hit.kind === "page" ? [hit.tree, hit.fields] : [hit.entry.fields];
+    const mediaOrigin = firstImageOrigin(shown);
     return {
         ...(seo.title ? { title: seo.title } : {}),
         ...(seo.description ? { description: seo.description } : {}),
@@ -15,5 +38,6 @@ export function headOf(hit, locale, href, locales) {
         noindex: seo.noindex === true,
         ...(own ? { canonical: href(own, locale) } : {}),
         languages,
+        ...(mediaOrigin ? { mediaOrigin } : {}),
     };
 }

package/dist/astro/index.js

@@ -6,18 +6,18 @@ 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 { apiTransport, 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 { DEFAULT_API_URL, apiEnv, siteUrl } from "../env.js";
+import { createSmoodlyApi } from "../api-client.js";
+import { pushBody, pushSchema } from "../push.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";
+import { collectStaticMedia, STATIC_MEDIA_DIR } from "./static-media.js";
+import { downloadStaticMedia } from "./static-media-node.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";
@@ -75,10 +75,30 @@ export default function smoodly(options = {}) {
     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) };
+    /** The files the prerendered pages registered (static output). */
+    let staticMedia = new Map();
+    /** astro.config's `i18n`, which the build holds the config's `routing` against. */
+    let i18n;
+    /** The project's config at build, from its config file (the one `options.config` names), loaded once and shared by
+     *  every hook; and its API client, from the env the setup hook loaded, made once. Two steps, since the routing
+     *  check wants the config before any env is needed. */
+    let builtConfig = null;
+    const buildConfig = () => (builtConfig ?? (builtConfig = options.config ? loadConfigFile(join(root, options.config), root) : loadConfig(root)));
+    let builtApi = null;
+    const buildApi = () => (builtApi ?? (builtApi = (async () => {
+        const loaded = await buildConfig();
+        return { loaded, api: createSmoodlyApi({ ...apiEnv(process.env), config: loaded }) };
+    })()));
+    /** A build read that fails names the service's address and stops the build before any page renders (a static build
+     *  with the Worker down would otherwise fail page by page). */
+    const fromApi = async (read) => {
+        try {
+            return await read();
+        }
+        catch (e) {
+            const address = process.env.SMOODLY_API_URL || DEFAULT_API_URL;
+            throw new Error(`smoodly: the static build needs Smoodly's API — SMOODLY_API_URL (${address}) did not answer: ${e instanceof Error ? e.message : String(e)}. Start the service (npm run dev:service) or set the address.`);
+        }
     };
     return {
         name: "smoodly",
@@ -86,23 +106,21 @@ export default function smoodly(options = {}) {
             "astro:config:setup": async ({ config, command, updateConfig, injectRoute, addMiddleware, logger }) => {
                 root = fileURLToPath(config.root);
                 output = config.output === "static" ? "static" : "server";
+                i18n = config.i18n;
                 // 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;
                 loadSmoodlyEnv(root, command === "dev" ? "development" : "production");
-                // The media host, for Astro's image service: <Image> is served resized through /_image only from an allowed host.
-                const mediaUrl = process.env.SMOODLY_URL;
-                if (!mediaUrl)
-                    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.");
+                // No image service config: <Image> is plain markup over the cuts from Smoodly's media host (spec 2026-10-18 media
+                // on R2 and Images §7), so no remote pattern and no /_image.
                 updateConfig({
-                    image: { remotePatterns: mediaUrl ? [mediaRemotePattern(mediaUrl)] : [] },
                     vite: { plugins: [virtualModules(root, options.config ?? "smoodly.config.ts", srcDir, output)] },
                 });
                 for (const route of routes(adminPath, output))
                     injectRoute(route);
                 addMiddleware({ entrypoint: here(`./middleware${ext}`), order: "pre" });
                 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\").");
+                    logger.warn("smoodly: no cache provider in astro.config — every page renders from the service. 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
                 // shell's value; the env files were read above, and SITE_URL from them sets `site` here. A value
@@ -122,10 +140,10 @@ export default function smoodly(options = {}) {
                 // 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 { loaded, api } = await buildApi();
+                    const routing = astroRouting(config.i18n, loaded.locales, loaded.routing);
                     const href = localeHref(loaded.locales, routing);
-                    const redirects = { ...(await redirectEntries({ pages, config: loaded, href })), ...rootRedirect(routing, href, loaded.locales) };
+                    const redirects = { ...(await fromApi(() => redirectEntries({ delivery: api, 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.`);
                 }
@@ -133,15 +151,33 @@ export default function smoodly(options = {}) {
             // 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 () => {
+            // The schema push (spec 2026-10-16 the control plane §4) comes first, in either output: the space then holds the
+            // registry this build renders with. A failed push never fails the build; the site runs against the schema the space has.
+            "astro:build:start": async ({ logger }) => {
+                const loaded = await buildConfig();
+                // The runtime's startup check, at build in either output: a deploy that builds must not refuse every request.
+                astroRouting(i18n, loaded.locales, loaded.routing);
+                try {
+                    const env = apiEnv(process.env);
+                    const { version, changed } = await pushSchema(env, pushBody(loaded, process.env, output === "static" ? "static" : "live"));
+                    logger.info(changed ? `smoodly: pushed schema version ${version} to ${env.spaceId}.` : `smoodly: schema unchanged (version ${version}).`);
+                }
+                catch (e) {
+                    logger.warn(`smoodly: the schema push failed — ${e instanceof Error ? e.message : String(e)}; the site runs against the schema the space has.`);
+                }
                 if (output !== "static")
                     return;
-                watermark = await (await buildStores()).published.newestPublishedAt();
+                // The media every prerendered page registers (static-media.ts), collected in this process for the build's end.
+                staticMedia = collectStaticMedia();
+                const { api } = await buildApi();
+                watermark = await fromApi(() => api.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;
+                // Every image the pages show, into the output beside them (spec 2026-10-18 media on R2 and Images §8).
+                logger.info(`smoodly: wrote ${await downloadStaticMedia(staticMedia.values(), fileURLToPath(dir))} media files into ${STATIC_MEDIA_DIR}.`);
                 const marker = markerJson({ builtAt: Date.now(), publishedThrough: watermark });
                 const file = join(fileURLToPath(dir), MARKER_PATH);
                 await mkdir(dirname(file), { recursive: true });
@@ -162,10 +198,8 @@ export function createContent(config, options = {}) {
         loadSmoodlyEnv(options.root ?? process.cwd(), process.env.NODE_ENV === "production" ? "production" : "development");
         env = process.env;
     }
-    const db = createSmoodlyClient(resolveSmoodlyEnv(env));
-    const { pages, entries, assets, members, published } = createSupabaseStores(db, config);
-    const href = localeHref(config.locales, astroRouting(options.i18n, config.locales));
-    // The site's projector: a publish from a script writes the delivery rows as the admin's does.
-    const { projector } = createSmoodlySite(siteOptions(config, () => ({ pages, entries, assets, published })));
-    return { content: createSmoodlyContent({ config, pages, entries, assets, members, href, projector }), href };
+    const href = localeHref(config.locales, astroRouting(options.i18n, config.locales, config.routing));
+    // Over Smoodly's API with the secret key (spec 2026-10-14 §1): the service runs the operations, so a publish from a
+    // script writes the delivery rows and expires the site's tags as the admin's does.
+    return { content: createSmoodlyContent({ config, href, transport: apiTransport(apiEnv(env)) }), href };
 }

package/dist/astro/locale-paths.d.ts

@@ -26,5 +26,8 @@ export declare function splitLocale(pathname: string, locales: LocaleSet, routin
 } | null;
 /** Locale-relative CMS path → site URL: what the operations and the `page` prop link with. */
 export declare const localeHref: (locales: LocaleSet, routing?: LocaleRouting) => (path: string, locale: string) => string;
-/** The rule astro.config's i18n asks for; its locales must be the config's, or links and reads would disagree. */
-export declare function astroRouting(i18n: AstroI18n | undefined, locales: LocaleSet): LocaleRouting;
+/** The rule astro.config's i18n asks for; its locales must be the config's, and its prefixDefaultLocale the config's
+ *  `routing` (which the pushed registry carries to the space's links), or links and reads would disagree. */
+export declare function astroRouting(i18n: AstroI18n | undefined, locales: LocaleSet, configRouting?: {
+    prefixDefaultLocale: boolean;
+}): LocaleRouting;

package/dist/astro/locale-paths.js

@@ -21,8 +21,16 @@ export function splitLocale(pathname, locales, routing = DEFAULT_ROUTING) {
 }
 /** Locale-relative CMS path → site URL: what the operations and the `page` prop link with. */
 export const localeHref = (locales, routing = DEFAULT_ROUTING) => (path, locale) => locale === locales.default && !routing.prefixDefault ? path : path === "/" ? `/${locale}` : `/${locale}${path}`;
-/** The rule astro.config's i18n asks for; its locales must be the config's, or links and reads would disagree. */
-export function astroRouting(i18n, locales) {
+/** The rule astro.config's i18n asks for; its locales must be the config's, and its prefixDefaultLocale the config's
+ *  `routing` (which the pushed registry carries to the space's links), or links and reads would disagree. */
+export function astroRouting(i18n, locales, configRouting) {
+    const routing = readAstroRouting(i18n, locales);
+    if (configRouting && configRouting.prefixDefaultLocale !== routing.prefixDefault) {
+        throw new Error(`smoodly: astro.config's i18n.routing.prefixDefaultLocale is ${routing.prefixDefault} but smoodly.config's routing.prefixDefaultLocale is ${configRouting.prefixDefaultLocale} — make them agree.`);
+    }
+    return routing;
+}
+function readAstroRouting(i18n, locales) {
     if (!i18n)
         return DEFAULT_ROUTING;
     if (i18n.domains && Object.keys(i18n.domains).length > 0) {

package/dist/astro/routes/admin.js

@@ -1,26 +1,28 @@
 // The admin in an Astro project (spec 2026-10-02 astro cloud fit §4), injected by the integration at the
-// admin path: the page, the package's files and the operations endpoint are the framework-free handler's
-// (admin/handler.ts), made once per server. This file adds only what is Astro's: the tags an operation
-// expires go to the response cache together, and draft mode is the draft cookie, scoped to the preview
-// address. The request's own effects ride an AsyncLocalStorage, so one handler serves requests at once.
+// admin path: the page, the package's files, the revalidate route and the preview route are the
+// framework-free handler's (admin/handler.ts), made once per server. This file adds only what is Astro's:
+// the tags the service's revalidate call names go to the response cache together, and draft mode is the
+// draft cookie, scoped to the preview address. The request's own effects ride an AsyncLocalStorage, so one handler serves requests at once.
 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, deployDeps, secret } from "../server.js";
+import { output } from "smoodly:build";
+import { adminDeps, secret } from "../server.js";
 export const prerender = false;
 const current = new AsyncLocalStorage();
 const effects = () => {
     const got = current.getStore();
     if (!got)
-        throw new Error("smoodly: an admin operation ran outside its request.");
+        throw new Error("smoodly: an admin route ran outside its request.");
     return got;
 };
 const secure = (context) => context.url.protocol === "https:" || context.request.headers.get("x-forwarded-proto")?.split(",")[0]?.trim() === "https";
 const handle = createAdminHandler(() => ({
     ...adminDeps(),
     previewBase: PREVIEW_BASE,
-    deploy: deployDeps(),
+    // The Deploy tile's mode is the build's output; the deploy operations themselves run in the service.
+    delivery: output === "static" ? "static" : "live",
     effects: {
         revalidate: (tag) => void effects().expired.add(tag),
         draft: {

package/dist/astro/runtime.d.ts

@@ -8,7 +8,8 @@ export { crashMessage } from "../crash-message.ts";
 export { styleAttribute } from "./style.ts";
 export { richtextChunks, type RichTextChunk } from "./richtext.ts";
 export { CUSTOM_NODE_TYPE } from "../custom/schema.ts";
-export { IMAGE_WIDTHS, imageRequest, imageWidths, placeImage } from "./image.ts";
+export { imageHtml, imageMarkup, posterUrl } from "../image/markup.ts";
+export { staticImage } from "./static-media.ts";
 export { previewPath, previewTarget } from "./preview.ts";
 export { href } from "./server.ts";
 export type { Shell, SmoodlyLocals } from "./shell.ts";
@@ -18,7 +19,7 @@ export type { PageHead } from "./head.ts";
 export type { ViewFiles } from "./views-check.ts";
 import { type Shell, type SmoodlyLocals } from "./shell.ts";
 /** The shell's decision with the project's bound site: what routes/page.astro calls, with `Astro.cache`.
- *  A page read from the database gets its lifetime here, before its view renders. The first call compares
+ *  A page read from the service 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. */

package/dist/astro/runtime.js

@@ -11,20 +11,21 @@ export { crashMessage } from "../crash-message.js";
 export { styleAttribute } from "./style.js";
 export { richtextChunks } from "./richtext.js";
 export { CUSTOM_NODE_TYPE } from "../custom/schema.js";
-export { IMAGE_WIDTHS, imageRequest, imageWidths, placeImage } from "./image.js";
+export { imageHtml, imageMarkup, posterUrl } from "../image/markup.js";
+export { staticImage } from "./static-media.js";
 export { previewPath, previewTarget } from "./preview.js";
 export { href } from "./server.js";
 import { customLayout } from "./custom.js";
 import { registryInfo } from "./defaults.js";
 import { lifetime } from "./cache.js";
 import { astroReads, preload } from "./scope.js";
-import { config, href, pages, published, routing, site } from "./server.js";
+import { config, delivery, href, 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;
 /** The shell's decision with the project's bound site: what routes/page.astro calls, with `Astro.cache`.
- *  A page read from the database gets its lifetime here, before its view renders. The first call compares
+ *  A page read from the service 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 async function shell(pathname, search, state, views, cache) {
     if (!viewsChecked) {
@@ -40,7 +41,7 @@ export async function shell(pathname, search, state, views, 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(), pages: pages(), config, href });
+export const staticPaths = () => listStatic({ delivery: delivery(), 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

@@ -1,22 +1,18 @@
 import type { AdminHandlerDeps } from "../admin/handler.ts";
 import type { ResolvedConfig } from "../config.ts";
+import type { ContentReads, DeliveryReads } from "../site.ts";
 export declare const config: ResolvedConfig;
 /** The address rule: astro.config's i18n when it is set, else the default locale at the root. */
 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 page store, for the paths index the static shell lists entry addresses from. */
-export declare const pages: () => import("../supabase-store.ts").SupabasePageStore;
-/** 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;
+export declare const site: () => ContentReads;
+/** The delivery reads of the static shell and the build: the addresses and the watermark, over the API. */
+export declare const delivery: () => DeliveryReads;
 /** 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">;
-/** The admin's wiring. The publishable key is asked for here, not on a live page. */
+type AdminDeps = Omit<AdminHandlerDeps, "effects" | "previewBase" | "delivery">;
+/** The admin's wiring: the page, the revalidate route the service calls and the preview route the browser
+ *  posts the grant to. Operations run in the service, which also tells the page where editors sign in. */
 export declare function adminDeps(): AdminDeps;
 export {};

package/dist/astro/server.js

@@ -1,52 +1,46 @@
-// 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, site as configuredSite } from "astro:config/server";
-import { output } from "smoodly:build";
+// The bound reads of an Astro project (spec 2026-10-02 astro cloud fit §1; spec 2026-10-14 §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. Every read goes over Smoodly's content API; the site opens no store. Built on first use, so a build that
+// renders nothing needs no keys.
+import { i18n } from "astro:config/server";
 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";
-import { presenceConfig, smoodlyEnv } from "../env.js";
-import { createSmoodlySite } from "../site.js";
+import { output } from "smoodly:build";
+import { createSmoodlyApi } from "../api-client.js";
+import { pushBody } from "../push.js";
+import { apiEnv, presenceConfig, smoodlyEnv } from "../env.js";
 import { astroRouting, localeHref } from "./locale-paths.js";
 export const config = loaded;
 if (!config?.registry) {
     throw new Error("smoodly: smoodly.config.ts must export `config`, the result of defineConfig(…).");
 }
 /** The address rule: astro.config's i18n when it is set, else the default locale at the root. */
-export const routing = astroRouting(i18n, config.locales);
+export const routing = astroRouting(i18n, config.locales, config.routing);
 /** Locale-relative CMS path → site URL, for the operations and the `page` prop. */
 export const href = localeHref(config.locales, routing);
 function build() {
-    const db = createSmoodlyClient(smoodlyEnv());
-    const stores = createSupabaseStores(db, config);
-    const site = createSmoodlySite(siteOptions(config, () => ({ pages: stores.pages, entries: stores.entries, assets: stores.assets, published: stores.published })));
-    return { db, ...stores, site };
+    // The site's reads go over Smoodly's API (SMOODLY_API_URL, SMOODLY_SPACE_ID, SMOODLY_SECRET_KEY). In `astro dev` the
+    // client pushes the schema first, in the mode the build would (spec 2026-10-16 the control plane §4).
+    const dev = process.env.NODE_ENV === "development";
+    const api = createSmoodlyApi({ ...apiEnv(), config, push: dev ? pushBody(config, process.env, output === "static" ? "static" : "live") : false });
+    return { api };
 }
 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 page store, for the paths index the static shell lists entry addresses from. */
-export const pages = () => bound().pages;
-/** 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() });
+export const site = () => bound().api;
+/** The delivery reads of the static shell and the build: the addresses and the watermark, over the API. */
+export const delivery = () => bound().api;
 /** The draft cookie's key: the server-only key every Smoodly site already holds. */
 export const secret = () => smoodlyEnv().secretKey;
 let admin = null;
-/** The admin's wiring. The publishable key is asked for here, not on a live page. */
+/** The admin's wiring: the page, the revalidate route the service calls and the preview route the browser
+ *  posts the grant to. Operations run in the service, which also tells the page where editors sign in. */
 export function adminDeps() {
     if (admin)
         return admin;
     const env = smoodlyEnv("admin");
-    const { db, pages, entries, assets, members, site } = bound();
     admin = {
-        config, pages, entries, assets, members, href, projector: site.projector,
-        auth: supabaseAdminAuth({ authUrl: env.authUrl, authKey: env.authKey, db }),
-        signIn: { url: env.authUrl, key: env.authKey },
+        // Where editors sign in comes from the service (GET /v1/auth, spec 2026-10-16 sign-in and the dashboard §4).
+        config, apiUrl: env.apiUrl, spaceId: env.spaceId,
         presence: () => presenceConfig(env),
     };
     return admin;

package/dist/astro/shell.d.ts

@@ -2,7 +2,7 @@ import type { ResolvedConfig } from "../config.ts";
 import { type ReadAdapter } from "../reads.ts";
 import { type EntryItem } from "../read-shapes.ts";
 import type { PageContext } from "../page-context.ts";
-import { type SmoodlySite } from "../site.ts";
+import { type ContentReads } from "../site.ts";
 import { type PageHead } from "./head.ts";
 import { type LocaleRouting } from "./locale-paths.ts";
 import type { ZoneContent } from "./zone.ts";
@@ -14,7 +14,7 @@ export type SmoodlyLocals = {
     editor: boolean;
     /** History's stored version, inside a preview only. */
     version?: string;
-    /** Set by the shell when it rendered a page read from the database: the response may be cached under its tags. */
+    /** Set by the shell when it rendered a page read from the service: the response may be cached under its tags. */
     cacheable: boolean;
     /** Set by the shell when it rendered a page at all: in a preview, only that response is a canvas. */
     shell: boolean;
@@ -29,7 +29,7 @@ declare global {
     }
 }
 export type ShellDeps = {
-    site: SmoodlySite;
+    site: ContentReads;
     config: ResolvedConfig;
     href: (path: string, locale: string) => string;
     routing: LocaleRouting;

package/dist/astro/shell.js

@@ -52,7 +52,7 @@ export async function resolveShell(deps, pathname, search, state, views) {
         console.warn(`smoodly: no src/page-types/${hit.template}.astro — the record at ${hit.path} is a 404.`);
         return NOT_FOUND;
     }
-    // Only a page read from the database has a tag to expire it by.
+    // Only a page read from the service has a tag to expire it by.
     state.cacheable = !hit.record.id.startsWith("code:") && !state.draft;
     state.shell = true;
     const zoneNames = Object.keys(schema.zones ?? {});

package/dist/astro/static-media-node.d.ts

@@ -0,0 +1,4 @@
+import type { StaticEntry } from "./static-media.ts";
+/** Every file, fetched eight at a time (a cut asked in its format by Accept) and written under `outDir`; a file that
+ *  answers non-200 fails the build by its address. Answers how many were written. */
+export declare function downloadStaticMedia(entries: Iterable<StaticEntry>, outDir: string, fetcher?: typeof fetch): Promise<number>;

package/dist/astro/static-media-node.js

@@ -0,0 +1,25 @@
+// The Node half of static media (static-media.ts): the download the build runs at `astro:build:done` over what the
+// prerendered pages registered. Loaded by the integration only: a live page never imports it.
+import { mkdir, writeFile } from "node:fs/promises";
+import { dirname, join } from "node:path";
+const CONCURRENCY = 8;
+const ACCEPT = { avif: "image/avif", webp: "image/webp", original: undefined };
+/** Every file, fetched eight at a time (a cut asked in its format by Accept) and written under `outDir`; a file that
+ *  answers non-200 fails the build by its address. Answers how many were written. */
+export async function downloadStaticMedia(entries, outDir, fetcher = fetch) {
+    const queue = [...entries];
+    const total = queue.length;
+    const work = async () => {
+        for (let entry = queue.shift(); entry; entry = queue.shift()) {
+            const accept = ACCEPT[entry.format];
+            const res = await fetcher(entry.url, accept ? { headers: { accept } } : {});
+            if (res.status !== 200)
+                throw new Error(`smoodly: the static build could not download ${entry.url} (${res.status}) — every image a page shows is written into the output.`);
+            const target = join(outDir, entry.path);
+            await mkdir(dirname(target), { recursive: true });
+            await writeFile(target, new Uint8Array(await res.arrayBuffer()));
+        }
+    };
+    await Promise.all(Array.from({ length: Math.min(CONCURRENCY, total) }, work));
+    return total;
+}

package/dist/astro/static-media.d.ts

@@ -0,0 +1,17 @@
+import type { ImageMarkup } from "../image/markup.ts";
+export type StaticFormat = "avif" | "webp" | "original";
+/** One file a static build writes: where it comes from, in which format, and its path in the output. */
+export type StaticEntry = {
+    url: string;
+    format: StaticFormat;
+    path: string;
+};
+export declare const STATIC_MEDIA_DIR = "/_smoodly/media";
+/** `/_smoodly/media/<sha256(sourceUrl + format), first 16 hex>.<ext>`: the same address and format, the same file. */
+export declare function staticMediaPath(sourceUrl: string, format: StaticFormat, ext: string): Promise<string>;
+/** The markup with every media address replaced by a file of the output, each file handed to `register`. */
+export declare function rewriteForStatic(m: ImageMarkup, register: (entry: StaticEntry) => void): Promise<ImageMarkup>;
+/** The build's collector (index.ts, astro:build:start): every file the pages register, once per path. */
+export declare function collectStaticMedia(): Map<string, StaticEntry>;
+/** What Image.astro calls in a prerendered page of static output: the rewrite, each file handed to the build. */
+export declare function staticImage(m: ImageMarkup): Promise<ImageMarkup>;