smoodly 0.0.51 → 0.0.52

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,25 @@ 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 () => {
+    /** 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 API client at build, from its config file (the one `options.config` names) and the env the setup hook loaded. */
+    const buildApi = async () => {
         const loaded = options.config ? await loadConfigFile(join(root, options.config), root) : await loadConfig(root);
-        return { loaded, ...createSupabaseStores(createSmoodlyClient(resolveSmoodlyEnv(process.env)), loaded) };
+        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,16 +101,14 @@ 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))
@@ -122,10 +135,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 +146,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 = options.config ? await loadConfigFile(join(root, options.config), root) : await loadConfig(root);
+                // 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 +193,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";

package/dist/astro/runtime.js

@@ -11,14 +11,15 @@ 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";
@@ -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";
@@ -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/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>;

package/dist/astro/static-media.js

@@ -0,0 +1,55 @@
+export const STATIC_MEDIA_DIR = "/_smoodly/media";
+const hex = (bytes) => [...new Uint8Array(bytes)].map((b) => b.toString(16).padStart(2, "0")).join("");
+/** `/_smoodly/media/<sha256(sourceUrl + format), first 16 hex>.<ext>`: the same address and format, the same file. */
+export async function staticMediaPath(sourceUrl, format, ext) {
+    const digest = await crypto.subtle.digest("SHA-256", new TextEncoder().encode(`${sourceUrl}\n${format}`));
+    return `${STATIC_MEDIA_DIR}/${hex(digest).slice(0, 16)}.${ext}`;
+}
+/** An original's extension from its address (`…/a1.jpg` → `jpg`), else `bin`. */
+const extOf = (url) => /\.([a-z0-9]{1,8})$/i.exec(new URL(url).pathname)?.[1]?.toLowerCase() ?? "bin";
+const candidates = (srcset) => srcset.split(", ").map((c) => { const [url, width] = c.trim().split(/\s+/); return { url: url, ...(width ? { width } : {}) }; });
+/** The markup with every media address replaced by a file of the output, each file handed to `register`. */
+export async function rewriteForStatic(m, register) {
+    const file = async (url, format) => {
+        const path = await staticMediaPath(url, format, format === "original" ? extOf(url) : format);
+        register({ url, format, path });
+        return path;
+    };
+    const inFormat = async (list, format) => (await Promise.all(list.map(async (c) => `${await file(c.url, format)}${c.width ? ` ${c.width}` : ""}`))).join(", ");
+    // A cut lists widths; an original is one address with no descriptor.
+    const cutOf = (srcset) => (srcset && candidates(srcset).every((c) => c.width) ? candidates(srcset) : null);
+    const sources = [];
+    const both = async (base, list) => {
+        sources.push({ ...base, type: "image/avif", srcset: await inFormat(list, "avif") });
+        sources.push({ ...base, type: "image/webp", srcset: await inFormat(list, "webp") });
+    };
+    for (const { srcset, type: _type, ...base } of m.sources) {
+        const list = cutOf(srcset);
+        if (list)
+            await both(base, list);
+        else
+            sources.push({ ...base, srcset: await inFormat(candidates(srcset), "original") });
+    }
+    const main = cutOf(m.img.srcset);
+    const { srcset: _srcset, sizes, ...img } = m.img;
+    if (main) {
+        await both({ ...(sizes ? { sizes } : {}), width: img.width, height: img.height }, main);
+        return { ...m, sources, img: { ...img, src: await file(m.img.src, "webp") } };
+    }
+    return { ...m, sources, img: { ...img, ...(sizes ? { sizes } : {}), src: await file(m.img.src, "original") } };
+}
+/** Where a prerendered page hands its files: installed by the integration for one static build. */
+const COLLECTOR = Symbol.for("smoodly.staticMedia");
+/** The build's collector (index.ts, astro:build:start): every file the pages register, once per path. */
+export function collectStaticMedia() {
+    const entries = new Map();
+    globalThis[COLLECTOR] = (entry) => void entries.set(entry.path, entry);
+    return entries;
+}
+/** What Image.astro calls in a prerendered page of static output: the rewrite, each file handed to the build. */
+export async function staticImage(m) {
+    const register = globalThis[COLLECTOR];
+    if (!register)
+        throw new Error("smoodly: a static page rendered outside the integration's `astro build` — no build collects its images.");
+    return rewriteForStatic(m, register);
+}

package/dist/astro/static.d.ts

@@ -1,15 +1,10 @@
 import type { ResolvedConfig } from "../config.ts";
-import type { PublishedStore } from "../published.ts";
-import type { PageStore } from "../store.ts";
+import type { DeliveryReads } from "../site.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. Pages come from
- *  the delivery tree (a node with no path, hidden or under a code address, is not a page); entries from the paths
- *  index's live rows, kept to the entries with a published delivery row — the Supabase delivery store lists entries
- *  with their document only, no path (0.0.48 built no entry page for it), and the index is what visitors reach. */
+/** Every published page and entry address of every locale, as Astro's getStaticPaths entries, each once. */
 export declare function staticPaths(deps: {
-    published: PublishedStore;
-    pages: PageStore;
+    delivery: DeliveryReads;
     config: ResolvedConfig;
     href: Href;
 }): Promise<{
@@ -18,9 +13,9 @@ export declare function staticPaths(deps: {
     };
 }[]>;
 /** 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. */
+ *  2026-09-26 redirects §7 at the host). The service leaves out a target with no live path in the locale. */
 export declare function redirectEntries(deps: {
-    pages: PageStore;
+    delivery: DeliveryReads;
     config: ResolvedConfig;
     href: Href;
 }): Promise<Record<string, {