smoodly 0.0.44 → 0.0.46

package/dist/astro/content-loaders.d.ts

@@ -0,0 +1,40 @@
+import type { LiveLoader } from "astro/loaders";
+import type { CollectionSchema } from "../collections.ts";
+import type { GlobalSchema } from "../global.ts";
+import type { PageItem } from "../read-shapes.ts";
+import type { EntriesQuery, GlobalValue, ReadAdapter, SmoodlyQueries, TypedEntryItem } from "../reads.ts";
+import type { PageTreeItem } from "../site.ts";
+export type EntryFilter = {
+    id?: string;
+    path?: string;
+    locale?: string;
+};
+export type EntriesFilter = EntriesQuery;
+export type GlobalFilter = {
+    locale?: string;
+};
+export type PageFilter = {
+    id?: string;
+    path?: string;
+    locale?: string;
+};
+export type PagesFilter = {
+    locale?: string;
+};
+export type PageTreeFilter = {
+    id: string;
+    locale?: string;
+};
+type AnyQueries = SmoodlyQueries<readonly CollectionSchema<any, string>[], readonly GlobalSchema<any, string>[]>;
+/**
+ * `open` builds the queries over the adapter it is handed; `adapter` is the one that runs the units. Each load opens
+ * its own queries over a recorder, so the cacheHint is the tags of the units the load ran — the read layer's, one
+ * source of truth (a collection's tags include the collections its references resolve into).
+ */
+export declare function loadersOver(open: (adapter: ReadAdapter) => AnyQueries, adapter: ReadAdapter): {
+    entries<C extends CollectionSchema<any, string>>(schema: C): LiveLoader<TypedEntryItem<[C], C["name"]>, EntryFilter, EntriesFilter>;
+    global<S extends GlobalSchema<any, string>>(item: S): LiveLoader<GlobalValue<[S], S["name"]>, GlobalFilter, GlobalFilter>;
+    page(): LiveLoader<PageItem, PageFilter, never>;
+    pageTree(): LiveLoader<PageTreeItem, PageTreeFilter, PagesFilter>;
+};
+export {};

package/dist/astro/content-loaders.js

@@ -0,0 +1,100 @@
+const findInTree = (items, id) => {
+    for (const item of items) {
+        if (item.id === id)
+            return item;
+        const below = findInTree(item.children, id);
+        if (below)
+            return below;
+    }
+    return undefined;
+};
+/**
+ * `open` builds the queries over the adapter it is handed; `adapter` is the one that runs the units. Each load opens
+ * its own queries over a recorder, so the cacheHint is the tags of the units the load ran — the read layer's, one
+ * source of truth (a collection's tags include the collections its references resolve into).
+ */
+export function loadersOver(open, adapter) {
+    const recorded = () => {
+        const tags = new Set();
+        const queries = open({ ...adapter, run: (unit) => { for (const t of unit.tags)
+                tags.add(t); return adapter.run(unit); } });
+        return { queries, hint: () => ({ tags: [...tags] }) };
+    };
+    return {
+        entries(schema) {
+            const name = schema.name;
+            return {
+                name: `smoodly:${name}`,
+                async loadCollection({ filter }) {
+                    const { queries, hint } = recorded();
+                    const items = (await queries.getEntries(name, filter ?? {}));
+                    return { entries: items.map((data) => ({ id: data.id, data })), cacheHint: hint() };
+                },
+                async loadEntry({ filter }) {
+                    // Astro passes filter undefined for getLiveEntry("articles") with no lookup.
+                    const f = filter;
+                    const key = f?.id ?? f?.path;
+                    if (!key)
+                        return { error: new Error(`smoodly: getLiveEntry("${name}") needs an id or a path.`) };
+                    const { queries, hint } = recorded();
+                    const data = (await queries.getEntry(name, key, { locale: f?.locale }));
+                    return data ? { id: data.id, data, cacheHint: hint() } : undefined;
+                },
+            };
+        },
+        global(item) {
+            const read = async (filter) => {
+                const { queries, hint } = recorded();
+                const data = (await queries.getGlobal(item.name, { locale: filter?.locale }));
+                return { data, hint: hint() };
+            };
+            return {
+                name: `smoodly:global:${item.name}`,
+                async loadCollection({ filter }) {
+                    // An absent or unpublished item is an empty list that still carries the read's tags: publishing it expires the list.
+                    const { data, hint } = await read(filter);
+                    return { entries: data ? [{ id: item.name, data }] : [], cacheHint: hint };
+                },
+                async loadEntry({ filter }) {
+                    const { data, hint } = await read(filter);
+                    return data ? { id: item.name, data, cacheHint: hint } : undefined;
+                },
+            };
+        },
+        page() {
+            return {
+                name: "smoodly:pages",
+                async loadCollection() {
+                    return { error: new Error('smoodly: the "pages" collection reads one page by path or id — the tree is getLiveCollection("pageTree").') };
+                },
+                async loadEntry({ filter }) {
+                    const f = filter;
+                    const key = f?.id ?? f?.path;
+                    if (!key)
+                        return { error: new Error('smoodly: getLiveEntry("pages") needs an id or a path.') };
+                    const { queries, hint } = recorded();
+                    const data = await queries.getPage(key, { locale: f?.locale });
+                    return data ? { id: data.id, data, cacheHint: hint() } : undefined;
+                },
+            };
+        },
+        pageTree() {
+            return {
+                name: "smoodly:page-tree",
+                async loadCollection({ filter }) {
+                    const { queries, hint } = recorded();
+                    const roots = await queries.getPageTree({ locale: filter?.locale });
+                    return { entries: roots.map((data) => ({ id: data.id, data })), cacheHint: hint() };
+                },
+                async loadEntry({ filter }) {
+                    const f = filter;
+                    if (!f?.id)
+                        return { error: new Error('smoodly: getLiveEntry("pageTree") needs an id.') };
+                    const { queries, hint } = recorded();
+                    const data = findInTree(await queries.getPageTree({ locale: f.locale }), f.id);
+                    return data ? { id: data.id, data, cacheHint: hint() } : undefined;
+                },
+            };
+        },
+    };
+}

package/dist/astro/content.d.ts

@@ -0,0 +1,9 @@
+/** A collection's entries: `getLiveCollection("articles", { locale, where, order, limit, parent })`, `getLiveEntry("articles", id | { path, locale })`. */
+export declare const entriesLoader: <C extends import("../collections.ts").CollectionSchema<any, string>>(schema: C) => import("astro/loaders").LiveLoader<import("../reads.ts").TypedEntryItem<[C], C["name"]>, import("./content-loaders.ts").EntryFilter, import("./content-loaders.ts").EntriesFilter>;
+/** A global item: `getLiveEntry("footer", { locale })`. */
+export declare const globalLoader: <S extends import("../global.ts").GlobalSchema<any, string>>(item: S) => import("astro/loaders").LiveLoader<import("../reads.ts").GlobalValue<[S], S["name"]>, import("./content-loaders.ts").GlobalFilter, import("./content-loaders.ts").GlobalFilter>;
+/** One page by path or id: `getLiveEntry("pages", { path, locale })`. */
+export declare const pageLoader: () => import("astro/loaders").LiveLoader<import("../read-shapes.ts").PageItem, import("./content-loaders.ts").PageFilter, never>;
+/** The page tree, roots with children nested: `getLiveCollection("pageTree", { locale })`. */
+export declare const pageTreeLoader: () => import("astro/loaders").LiveLoader<import("../site.ts").PageTreeItem, import("./content-loaders.ts").PageTreeFilter, import("./content-loaders.ts").PagesFilter>;
+export type { EntriesFilter, EntryFilter, GlobalFilter, PageFilter, PageTreeFilter, PagesFilter } from "./content-loaders.ts";

package/dist/astro/content.js

@@ -0,0 +1,17 @@
+// packages/smoodly/src/astro/content.ts
+// The project's live loaders (spec 2026-10-02 astro cloud fit §6), bound to its site and run by Astro's read
+// adapter: what src/live.config.ts hands to defineLiveCollection. The queries are built per load.
+import { createQueries } from "../reads.js";
+import { loadersOver } from "./content-loaders.js";
+import { astroReads } from "./scope.js";
+import { config, site } from "./server.js";
+// Queries are built per load, over a recorder of the units' tags (content-loaders.ts).
+const loaders = loadersOver((adapter) => createQueries({ site: site(), collections: config.registry.collections, globals: config.registry.globals }, adapter), astroReads);
+/** A collection's entries: `getLiveCollection("articles", { locale, where, order, limit, parent })`, `getLiveEntry("articles", id | { path, locale })`. */
+export const entriesLoader = loaders.entries;
+/** A global item: `getLiveEntry("footer", { locale })`. */
+export const globalLoader = loaders.global;
+/** One page by path or id: `getLiveEntry("pages", { path, locale })`. */
+export const pageLoader = loaders.page;
+/** The page tree, roots with children nested: `getLiveCollection("pageTree", { locale })`. */
+export const pageTreeLoader = loaders.pageTree;

package/dist/astro/custom.d.ts

@@ -0,0 +1 @@
+export { customLayout } from "../custom/layout.ts";

package/dist/astro/custom.js

@@ -0,0 +1,3 @@
+// What the custom section renders in Astro (spec 2026-09-14 §6), decided in custom/layout.ts (shared with
+// the React section) so Custom.astro is only markup.
+export { customLayout } from "../custom/layout.js";

package/dist/astro/defaults.d.ts

@@ -0,0 +1,20 @@
+import type { Descriptor } from "../fields.ts";
+type WithSettings = {
+    name: string;
+    title?: string;
+    settings?: Record<string, Descriptor>;
+};
+export type SchemaInfo = {
+    title: string;
+    defaults: Record<string, unknown>;
+};
+export type RegistryInfo = {
+    section(name: string): SchemaInfo;
+    element(name: string): SchemaInfo;
+    isSection(name: string): boolean;
+};
+export declare function registryInfo(registry: {
+    sections: readonly WithSettings[];
+    elements: readonly WithSettings[];
+}): RegistryInfo;
+export {};

package/dist/astro/defaults.js

@@ -0,0 +1,21 @@
+// What a view found by file name is not given by a pairing (plan 2026-10-06 astro adapter 2): React's pair()
+// (pairing.tsx) fills a section's and an element's settings defaults and the guard knows the schema's title;
+// in Astro the zone and the richtext renderer read both from here, computed once per registry.
+import { CUSTOM_NODE_TYPE } from "../custom/schema.js";
+import { defaultsOf } from "../field-defaults.js";
+export function registryInfo(registry) {
+    const table = (list) => new Map(list.map((s) => [s.name, { title: s.title ?? s.name, defaults: defaultsOf(s.settings ?? {}) }]));
+    const sections = table(registry.sections);
+    const elements = table(registry.elements);
+    // A fresh object each time: a view that writes into its settings must not change the next render's.
+    const of = (map, name, fallbackTitle) => {
+        const found = map.get(name);
+        return { title: found?.title ?? fallbackTitle, defaults: { ...(found?.defaults ?? {}) } };
+    };
+    return {
+        section: (name) => of(sections, name, name === CUSTOM_NODE_TYPE ? "Custom section" : name),
+        element: (name) => of(elements, name, name),
+        // The custom section is Smoodly's own and always registered.
+        isSection: (name) => name === CUSTOM_NODE_TYPE || sections.has(name),
+    };
+}

package/dist/astro/env-files.d.ts

@@ -0,0 +1 @@
+export declare function loadSmoodlyEnv(root: string, mode: string, env?: Record<string, string | undefined>): void;

package/dist/astro/env-files.js

@@ -0,0 +1,21 @@
+// The project's env files, for the build tool (spec 2026-10-02 astro cloud fit §1): Astro reads .env into
+// import.meta.env, and Smoodly's server code reads process.env (env.ts), so the integration copies the
+// SMOODLY_ values across when Astro starts. SITE_URL comes along too: Astro evaluates astro.config before
+// it loads any .env, so the integration sets `site` from it when astro.config leaves it unset. Vite's
+// order, later files winning; a value the host already set is never replaced. A deployed server gets its
+// values from the host and never runs this.
+import { existsSync, readFileSync } from "node:fs";
+import { join } from "node:path";
+import { parseEnv } from "node:util";
+export function loadSmoodlyEnv(root, mode, env = process.env) {
+    const found = {};
+    for (const name of [".env", ".env.local", `.env.${mode}`, `.env.${mode}.local`]) {
+        const file = join(root, name);
+        if (existsSync(file))
+            Object.assign(found, parseEnv(readFileSync(file, "utf8")));
+    }
+    for (const [key, value] of Object.entries(found)) {
+        if ((key.startsWith("SMOODLY_") || key === "SITE_URL") && value !== undefined && env[key] === undefined)
+            env[key] = value;
+    }
+}

package/dist/astro/head.d.ts

@@ -0,0 +1,13 @@
+import type { ResolvedImage } from "../media.ts";
+import type { LocaleSet } from "../paths.ts";
+import type { SiteHit } from "../site.ts";
+export type PageHead = {
+    title?: string;
+    description?: string;
+    image?: ResolvedImage;
+    noindex: boolean;
+    canonical?: string;
+    /** locale → the page's address there, for a multi-locale site; empty otherwise. */
+    languages: Record<string, string>;
+};
+export declare function headOf(hit: SiteHit, locale: string, href: (path: string, locale: string) => string, locales: LocaleSet): PageHead;

package/dist/astro/head.js

@@ -0,0 +1,19 @@
+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 } : {});
+    const own = hit.locales[locale]?.path;
+    const languages = {};
+    if (locales.supported.length > 1) {
+        for (const [l, alt] of Object.entries(hit.locales))
+            if (alt?.path)
+                languages[l] = href(alt.path, l);
+    }
+    return {
+        ...(seo.title ? { title: seo.title } : {}),
+        ...(seo.description ? { description: seo.description } : {}),
+        ...(seo.image ? { image: seo.image } : {}),
+        noindex: seo.noindex === true,
+        ...(own ? { canonical: href(own, locale) } : {}),
+        languages,
+    };
+}

package/dist/astro/image.d.ts

@@ -0,0 +1,27 @@
+import type { ResolvedImage } from "../media.ts";
+/** The srcset candidates, up to the original's width: Astro ignores any wider than the image anyway. */
+export declare const IMAGE_WIDTHS: number[];
+export declare function imageWidths(width: number): number[];
+export type ImagePlacement = {
+    box: string;
+    frame: string;
+    svg: boolean;
+};
+export declare function placeImage(image: ResolvedImage, options?: {
+    aspect?: string;
+    handlesCrop?: boolean;
+}): ImagePlacement;
+export type ImageRequest = {
+    src: string;
+    width: number;
+    height: number;
+    format: "webp";
+    widths?: number[];
+    sizes?: string;
+};
+/** What to ask Astro's image service for, or null when the original URL is served as it is: an SVG (a vector
+ *  has no sizes) or `unoptimized`. Widths, and so a srcset, only when the page says its `sizes`. */
+export declare function imageRequest(image: ResolvedImage, options?: {
+    sizes?: string;
+    unoptimized?: boolean;
+}): ImageRequest | null;

package/dist/astro/image.js

@@ -0,0 +1,29 @@
+// What <Image> renders in Astro (spec 2026-09-08 media §9; the React one is image/SmoodlyImage.tsx): a box at
+// the aspect, the picture inside placed by crop and hotspot, as inline style strings; and the candidate widths
+// Astro's image service is asked for. Pure, so Image.astro is only markup around `getImage`.
+import { boxAspectOf, frameFor } from "../image/crop-math.js";
+/** The srcset candidates, up to the original's width: Astro ignores any wider than the image anyway. */
+export const IMAGE_WIDTHS = [320, 640, 960, 1280, 1920, 2560];
+export function imageWidths(width) {
+    return [...IMAGE_WIDTHS.filter((w) => w < width), width];
+}
+const pct = (n) => `${Math.round(n * 1000) / 1000}%`;
+export function placeImage(image, options = {}) {
+    const box = boxAspectOf(image, options.aspect);
+    const frame = options.handlesCrop ? { left: 0, top: 0, width: 100, height: 100 } : frameFor(image, box);
+    return {
+        box: `display:block;position:relative;overflow:hidden;aspect-ratio:${box}`,
+        frame: `position:absolute;left:${pct(frame.left)};top:${pct(frame.top)};width:${pct(frame.width)};height:${pct(frame.height)};max-width:none`,
+        svg: image.mime === "image/svg+xml",
+    };
+}
+/** What to ask Astro's image service for, or null when the original URL is served as it is: an SVG (a vector
+ *  has no sizes) or `unoptimized`. Widths, and so a srcset, only when the page says its `sizes`. */
+export function imageRequest(image, options = {}) {
+    if (options.unoptimized || image.mime === "image/svg+xml")
+        return null;
+    return {
+        src: image.url, width: image.width, height: image.height, format: "webp",
+        ...(options.sizes ? { widths: imageWidths(image.width), sizes: options.sizes } : {}),
+    };
+}

package/dist/astro/index.d.ts

@@ -0,0 +1,43 @@
+import type { AstroIntegration } from "astro";
+import type { ResolvedConfig } from "../config.ts";
+import { type SmoodlyContent } from "../content/content-api.ts";
+import { type AstroI18n } from "./locale-paths.ts";
+export type SmoodlyOptions = {
+    /** Where the admin is mounted: the same value as `admin.path` in smoodly.config.ts. Default "/admin". */
+    adminPath?: string;
+    /** The config file, from the project root. Default "smoodly.config.ts". */
+    config?: string;
+};
+/** The three routes, most specific first; a page file of the project's own wins over the shell for its address. */
+export declare function routes(adminPath: string): {
+    pattern: string;
+    entrypoint: string;
+}[];
+/** The views by file name, under the project's source dir (root-relative, "/src" by default): a section's
+ *  is sections/<section name>.astro, an element's elements/<element name>.astro, a page type's
+ *  page-types/<page type name>.astro, an entry page's entry-pages/<collection name>.astro. */
+export declare function viewsModule(srcDir: string): string;
+/** `root` is the project's directory; `srcDir` its source dir relative to the root, with a leading slash. */
+export declare function virtualModules(root: string, configFile: string, srcDir?: string): {
+    name: string;
+    resolveId(id: string): string | undefined;
+    load(id: string): string | undefined;
+};
+export default function smoodly(options?: SmoodlyOptions): AstroIntegration;
+export type CreateContentOptions = {
+    /** astro.config's `i18n`, when the project sets one; the adapter's default routing otherwise (the default locale at the root). */
+    i18n?: AstroI18n;
+    /** The project root whose env files are read. Default: the working directory. */
+    root?: string;
+    /** The environment to read SMOODLY_ values from. Default: process.env, after the project's env files are loaded into it. */
+    env?: Record<string, string | undefined>;
+};
+/** Write content from code in an Astro project — a seed, a migration script (spec 2026-09-30 tester findings §1):
+ *  the admin's own operations with no signed-in editor, so validation and the publish checks apply and a failure
+ *  throws `SmoodlyContentError`. `const { content, href } = createContent(config)`; then `content.pages.create(…)`,
+ *  `content.entries.create(…)`, `content.globals.set(…)`, `content.media.upload(…)`; tree nodes with `node(schema, fields)`
+ *  from "smoodly". Reads the project's .env files like the integration does, so a script needs no env flag. */
+export declare function createContent(config: ResolvedConfig, options?: CreateContentOptions): {
+    content: SmoodlyContent;
+    href: (path: string, locale: string) => string;
+};

package/dist/astro/index.js

@@ -0,0 +1,111 @@
+// Smoodly as an Astro integration (spec 2026-10-02 astro cloud fit §1): `integrations: [smoodly()]` in
+// 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 { fileURLToPath } from "node:url";
+import { DEFAULT_ADMIN_PATH } from "../admin-path.js";
+import { createSupabaseStores, siteOptions } from "../bind.js";
+import { createSmoodlyClient } from "../client.js";
+import { createSmoodlyContent } from "../content/content-api.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 { 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) {
+    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") },
+    ];
+}
+/** The views by file name, under the project's source dir (root-relative, "/src" by default): a section's
+ *  is sections/<section name>.astro, an element's elements/<element name>.astro, a page type's
+ *  page-types/<page type name>.astro, an entry page's entry-pages/<collection name>.astro. */
+export function viewsModule(srcDir) {
+    const glob = (dir) => `named(import.meta.glob("${srcDir}/${dir}/*.astro", { eager: true }))`;
+    return `const named = (modules) => Object.fromEntries(Object.entries(modules).map(([file, module]) => [file.split("/").pop().replace(/\\.astro$/, ""), module.default]));
+export const views = { sections: ${glob("sections")}, elements: ${glob("elements")}, pages: ${glob("page-types")}, entries: ${glob("entry-pages")} };
+`;
+}
+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") {
+    return {
+        name: "smoodly:virtual",
+        resolveId(id) {
+            if (id === "smoodly:config")
+                return join(root, configFile);
+            if (id === "smoodly:views")
+                return VIEWS_ID;
+            return undefined;
+        },
+        load(id) {
+            return id === VIEWS_ID ? viewsModule(srcDir) : undefined;
+        },
+    };
+}
+export default function smoodly(options = {}) {
+    const adminPath = options.adminPath ?? DEFAULT_ADMIN_PATH;
+    return {
+        name: "smoodly",
+        hooks: {
+            "astro:config:setup": ({ config, command, updateConfig, injectRoute, addMiddleware, logger }) => {
+                const root = fileURLToPath(config.root);
+                // 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.");
+                updateConfig({
+                    image: { remotePatterns: mediaUrl ? [mediaRemotePattern(mediaUrl)] : [] },
+                    vite: { plugins: [virtualModules(root, options.config ?? "smoodly.config.ts", srcDir)] },
+                });
+                for (const route of routes(adminPath))
+                    injectRoute({ ...route, prerender: false });
+                addMiddleware({ entrypoint: here(`./middleware${ext}`), order: "pre" });
+                if (!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
+                // shell's value; the env files were read above, and SITE_URL from them sets `site` here. A value
+                // without a scheme is named by siteUrl, not by Astro's bare "Invalid URL".
+                if (!config.site && process.env.SITE_URL) {
+                    siteUrl(process.env);
+                    updateConfig({ site: process.env.SITE_URL });
+                }
+                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.");
+                }
+            },
+        },
+    };
+}
+/** Write content from code in an Astro project — a seed, a migration script (spec 2026-09-30 tester findings §1):
+ *  the admin's own operations with no signed-in editor, so validation and the publish checks apply and a failure
+ *  throws `SmoodlyContentError`. `const { content, href } = createContent(config)`; then `content.pages.create(…)`,
+ *  `content.entries.create(…)`, `content.globals.set(…)`, `content.media.upload(…)`; tree nodes with `node(schema, fields)`
+ *  from "smoodly". Reads the project's .env files like the integration does, so a script needs no env flag. */
+export function createContent(config, options = {}) {
+    let env = options.env;
+    if (!env) {
+        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 };
+}

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

@@ -0,0 +1,30 @@
+import { type LocaleSet } from "../paths.ts";
+/** `redirectToDefault`: Astro itself sends "/" to the default locale's home (its redirectToDefaultLocale). */
+export type LocaleRouting = {
+    prefixDefault: boolean;
+    redirectToDefault: boolean;
+};
+export declare const DEFAULT_ROUTING: LocaleRouting;
+/** Prefix-always without Astro's root redirect lets "/" through to the catch-all, so the adapter sends it where Astro would. */
+export declare const redirectsRoot: (pathname: string, routing: LocaleRouting) => boolean;
+/** `astro:config/server`'s `i18n`, the part read here. */
+export type AstroI18n = {
+    defaultLocale: string;
+    locales: (string | {
+        path: string;
+        codes: string[];
+    })[];
+    routing?: string | {
+        prefixDefaultLocale?: boolean;
+        redirectToDefaultLocale?: boolean;
+    };
+    domains?: Record<string, string>;
+};
+export declare function splitLocale(pathname: string, locales: LocaleSet, routing?: LocaleRouting): {
+    locale: string;
+    path: string;
+} | 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;

package/dist/astro/locale-paths.js

@@ -0,0 +1,38 @@
+// Which locale an address is in, and the address a locale-relative path gets (plan 2026-10-05 astro adapter
+// 1; spec 2026-10-02 astro cloud fit, "languages on Astro's own routing", plan 2026-10-06 astro adapter 2):
+// the default locale at the root and every other under its code, unless astro.config's i18n prefixes the
+// default too. The same rule both ways, so the admin's links land where the shell reads. Astro's own i18n
+// router answers its 404 for a prefixed default locale; the root under prefix-always it redirects only with
+// redirectToDefaultLocale, else it lets "/" through and the shell redirects it. The adapter agrees with it.
+import { decodeSegment, joinPath } from "../paths.js";
+export const DEFAULT_ROUTING = { prefixDefault: false, redirectToDefault: false };
+/** Prefix-always without Astro's root redirect lets "/" through to the catch-all, so the adapter sends it where Astro would. */
+export const redirectsRoot = (pathname, routing) => routing.prefixDefault && !routing.redirectToDefault && pathname.split("/").filter(Boolean).length === 0;
+export function splitLocale(pathname, locales, routing = DEFAULT_ROUTING) {
+    const segments = pathname.split("/").filter(Boolean).map(decodeSegment);
+    const first = segments[0];
+    if (first !== undefined && locales.supported.includes(first) && (routing.prefixDefault || first !== locales.default)) {
+        return { locale: first, path: joinPath(segments.slice(1)) };
+    }
+    // Every locale is prefixed: an unprefixed address is nobody's.
+    if (routing.prefixDefault)
+        return null;
+    return { locale: locales.default, path: joinPath(segments) };
+}
+/** 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) {
+    if (!i18n)
+        return DEFAULT_ROUTING;
+    if (i18n.domains && Object.keys(i18n.domains).length > 0) {
+        throw new Error("smoodly: i18n.domains is not supported yet — locales on their own hosts need the address rule to know the host. Remove `domains` from astro.config's i18n, or keep locales under path prefixes.");
+    }
+    const codes = i18n.locales.map((l) => (typeof l === "string" ? l : l.path));
+    const same = i18n.defaultLocale === locales.default && codes.every((c) => locales.supported.includes(c)) && locales.supported.every((c) => codes.includes(c));
+    if (!same) {
+        throw new Error(`smoodly: astro.config's i18n (default "${i18n.defaultLocale}", locales ${codes.join(", ")}) and smoodly.config.ts (default "${locales.default}", locales ${locales.supported.join(", ")}) disagree — give both the same locales.`);
+    }
+    const r = typeof i18n.routing === "object" && i18n.routing !== null ? i18n.routing : {};
+    return { prefixDefault: r.prefixDefaultLocale === true, redirectToDefault: r.redirectToDefaultLocale === true };
+}

package/dist/astro/middleware.d.ts

@@ -0,0 +1 @@
+export declare const onRequest: import("astro").MiddlewareHandler;