smoodly 0.0.44 → 0.0.46

package/dist/assemble.js

@@ -0,0 +1,359 @@
+// The assembler (spec 2026-10-07 delivery model §3): the loaded page, entry, global, tree and entry list
+// as the site layer reads them, split out of site.ts so the live reads and the projector that fills the
+// delivery tables share one implementation. Framework-free and React-free, like the site layer.
+import { ARRAY_FIELD_TYPES, entryFieldsIn, schemaOf } from "./entry-store.js";
+import { buildPageTree, chainOf, entryAlternates, entryPathRows, pageAlternates, pagePath, } from "./paths.js";
+import { resolveFields, resolveFieldSets, resolveMedia, resolveTree } from "./resolve.js";
+import { elementSchemas } from "./richtext-walk.js";
+import { globalNodeId, SETTINGS_KEY, STYLES_KEY, CSS_KEY } from "./global.js";
+import { SMD_KEY } from "./smd-key.js";
+import { resolveStyleValues } from "./styles.js";
+import { resolveCustom } from "./custom/index.js";
+import { addressMap, codeAddresses } from "./addresses.js";
+import { fullPath, servedAnchor } from "./anchors.js";
+import { withDefaults } from "./field-defaults.js";
+import { toEntryItem } from "./read-shapes.js";
+import { entrySeo, pageSeo, SEO_KEY } from "./seo.js";
+import { schemaOf as registeredSchema } from "./registration.js";
+/** Field types whose stored value is an object: not filterable (memory and SQL would disagree). */
+const OBJECT_FIELD_TYPES = new Set(["image", "video", "file", "richtext", "object"]);
+/** What the site computes from its options before any read: the registered shapes, the code-owned addresses and the resolved styles. */
+export function siteShape(options) {
+    const locales = options.locales;
+    const pageSchemas = options.pages.map((p) => registeredSchema(p));
+    const homePageSlug = options.homePageSlug ?? "home";
+    const styles = resolveStyleValues(options.styles);
+    const custom = resolveCustom(options.custom);
+    const elements = elementSchemas(options.elements);
+    // Code-owned addresses from the site's own registry (spec 2026-09-29 nested paths §3): a code-owned root's path.
+    const codeOwned = codeAddresses({ locales, pages: pageSchemas, collections: options.collections });
+    const addresses = addressMap(codeOwned);
+    const pathOpts = { locales, homePageSlug, addresses };
+    /** The same addresses as the path index sees them: an entry's stored part joined to its collection's (spec 2026-09-29 anchored paths §2). */
+    const anchors = { addresses, homePageSlug, defaultLocale: locales.default };
+    return { locales, pageSchemas, homePageSlug, styles, custom, elements, codeOwned, addresses, pathOpts, anchors };
+}
+/** A template's page-field descriptors (spec 2026-09-10 page fields §3); none for a folder. */
+export function pageFieldsOf(shape, template) {
+    if (template === null)
+        return {};
+    return shape.pageSchemas.find((x) => x.kind === "page" && x.name === template)?.fields ?? {};
+}
+/** The checks `getEntries` makes before any read, in draft mode and outside it: one function both paths call. */
+export function checkEntryQuery(schema, collection, o) {
+    // A filter that silently matched nothing would be worse than an error (spec 2026-09-11 §3).
+    for (const key of Object.keys(o.where ?? {})) {
+        if (key === "slug") {
+            throw new Error(`smoodly: getEntries("${collection}"): "slug" is not filterable — where filters fields; find an entry by its path instead.`);
+        }
+        if (key === SEO_KEY)
+            throw new Error(`smoodly: getEntries("${collection}"): "${SEO_KEY}" is reserved — the SEO panel's values are not filterable.`);
+        if (!(key in schema.fields))
+            throw new Error(`smoodly: getEntries("${collection}"): "${key}" is not a field of the collection.`);
+        // The memory adapter's `===` never matches an object while SQL's `@>` matches a subset, so the two would disagree.
+        if (OBJECT_FIELD_TYPES.has(schema.fields[key].type ?? "")) {
+            throw new Error(`smoodly: getEntries("${collection}"): "${key}" holds an object — filter on a scalar field instead.`);
+        }
+        // Any-of reads the text form of the whole field (PostgREST's `->>`), which for
+        // an array is its JSON — `["a"]` never matches "a" — so refuse rather than match nothing.
+        if (Array.isArray(o.where[key]) && ARRAY_FIELD_TYPES.has(schema.fields[key].type ?? "")) {
+            throw new Error(`smoodly: getEntries("${collection}"): "${key}" is array-valued — any-of is for scalar fields; pass one value to match entries containing it.`);
+        }
+    }
+    if (o.limit !== undefined && (!Number.isInteger(o.limit) || o.limit < 0)) {
+        throw new Error(`smoodly: getEntries("${collection}"): limit must be a non-negative integer.`);
+    }
+}
+/** The reads a batch answers once per argument set (a projection asks the same ones for every page). */
+const MEMOIZED = { pages: ["listPages", "fieldsOf"], entries: ["getMany", "pathsIn"], assets: ["getMany"] };
+export function createAssembler(options, shape) {
+    const { locales, pageSchemas, styles, custom, elements, pathOpts, anchors } = shape;
+    const mounted = options.collections.filter((c) => c.path !== undefined);
+    /** The resolver's fetcher, bound to a locale: the merged fields of that
+     *  locale — published ones (a versioned collection's snapshot) on the
+     *  public path, the live rows in draft mode. */
+    const fetcher = (draft, locale) => (collection, ids) => options.stores().entries.getMany(collection, ids, locale, draft ? undefined : { status: "published" });
+    /** The resolver's path lookup, bound to a locale: each EntryRef's address (spec 2026-09-29 content API contract §2). */
+    const pathLookup = (locale) => (collection, ids) => options.stores().entries.pathsIn(collection, ids, locale);
+    /** The media fetcher (spec 2026-09-08 §9) — absent when the site runs without an asset store. */
+    const assetFetcher = () => {
+        const assets = options.stores().assets;
+        return assets ? (ids) => assets.getMany(ids) : undefined;
+    };
+    const sectionSettings = (name) => {
+        const s = options.sections.find((x) => ("schema" in x ? x.schema : x).name === name);
+        return (s && ("schema" in s ? s.schema : s).settings) ?? {};
+    };
+    /** Visible to the public in a locale: present there, and a folder or a
+     *  published page. Draft mode sees every present node. Presence is the
+     *  locale row — nothing falls back (spec 2026-09-06 §3). */
+    const visible = (node, locale, draft) => {
+        const row = node.locales[locale];
+        return row !== undefined && (draft || node.template === null || row.status === "published");
+    };
+    const hasPage = (node, locale, draft) => {
+        const row = node.locales[locale];
+        return node.template !== null && row !== undefined && (draft || row.status === "published");
+    };
+    const pageFields = (template) => pageFieldsOf(shape, template);
+    /** The version whose fields a link shows: the draft's in draft mode, else the published one. */
+    const versionFor = (node, locale, draft) => {
+        const row = node.locales[locale];
+        if (!row || node.template === null)
+            return null;
+        return draft ? row.draftVersionId : row.publishedVersionId;
+    };
+    /** Raw page fields (no asset resolution) of many nodes in ONE store read
+     *  (spec 2026-09-10 page fields §3), defaults applied; `{}` for a folder. */
+    async function linkFields(nodes, locale, draft) {
+        const { pages } = options.stores();
+        const wanted = new Map(); // node id → version id
+        for (const n of nodes) {
+            const v = versionFor(n, locale, draft);
+            if (v)
+                wanted.set(n.id, v);
+        }
+        const byVersion = wanted.size > 0 ? await pages.fieldsOf([...new Set(wanted.values())]) : {};
+        const out = new Map();
+        for (const n of nodes) {
+            const v = wanted.get(n.id);
+            out.set(n.id, n.template === null ? {} : withDefaults(v ? byVersion[v] : undefined, pageFields(n.template)));
+        }
+        return out;
+    }
+    /** Only ever called for a node PRESENT in the locale (visible() or an ancestor of one). */
+    const link = (node, byId, locale, draft, fields) => ({
+        title: node.locales[locale].title,
+        path: pagePath(node, byId, locale, pathOpts),
+        hasPage: hasPage(node, locale, draft),
+        fields: fields.get(node.id) ?? {},
+    });
+    async function loadPage(id, locale, path, draft, version) {
+        const { pages } = options.stores();
+        const record = await pages.getPage(id);
+        if (!record || record.template === null)
+            return null;
+        const row = record.locales[locale];
+        if (!row)
+            return null;
+        let raw;
+        if (version !== undefined) {
+            // History: a stored version of THIS page in THIS locale, and only inside draft mode.
+            const stored = draft ? await pages.getVersion(version) : null;
+            raw = stored && stored.pageId === id && stored.locale === locale ? stored.tree : null;
+        }
+        else {
+            raw = draft ? await pages.getDraftTree(id, locale) : row.status === "published" ? await pages.getPublishedTree(id, locale) : null;
+        }
+        if (!raw)
+            return null;
+        const tree = await resolveTree(raw, {
+            sections: options.sections,
+            collections: options.collections,
+            globals: options.globals,
+            elements: options.elements,
+            fetch: fetcher(draft, locale), paths: pathLookup(locale),
+            assets: assetFetcher(),
+            page: { fields: pageFields(record.template) },
+            custom,
+        });
+        const all = await pages.listPages();
+        const index = new Map(all.map((n) => [n.id, n]));
+        const byId = (x) => index.get(x);
+        const chain = chainOf(record, byId);
+        const kids = all.filter((n) => n.parentId === id && visible(n, locale, draft));
+        const fields = await linkFields([...chain.slice(0, -1), ...kids], locale, draft);
+        const ancestors = chain.slice(0, -1).map((n) => link(n, byId, locale, draft, fields));
+        const children = kids.map((n) => link(n, byId, locale, draft, fields));
+        // Alternates advertise PUBLISHED locales only; the editor (draft) sees every present
+        // one. Derived from the tree already listed — no index lookup (spec 2026-09-15 §2).
+        const alternates = pageAlternates(record, byId, pathOpts, (l) => draft || record.locales[l]?.status === "published");
+        const withSeo = pageSchemas.some((x) => x.kind === "page" && x.name === record.template && x.seo === true);
+        return {
+            kind: "page",
+            locale,
+            record,
+            template: record.template,
+            tree,
+            title: row.title,
+            path,
+            fields: withDefaults(tree.fields, pageFields(record.template)),
+            ancestors,
+            children,
+            locales: alternates,
+            ...(withSeo ? { seo: pageSeo(tree.meta, row.title) } : {}),
+        };
+    }
+    async function loadEntry(id, locale, path, draft) {
+        const { entries } = options.stores();
+        for (const schema of mounted) {
+            const record = await entries.get(schema.name, id);
+            if (!record)
+                continue;
+            // No row, or a draft row outside draft mode, is a 404 for THIS locale.
+            const row = record.locales[locale];
+            if (!row)
+                return null;
+            if (!draft && row.status !== "published")
+                return null;
+            const raw = draft
+                ? entryFieldsIn(record, locale)
+                : (await entries.getMany(schema.name, [id], locale, { status: "published" }))[id];
+            if (!raw)
+                return null;
+            const fields = await resolveFields(raw, schema.fields, { collections: options.collections, elements: options.elements, fetch: fetcher(draft, locale), paths: pathLookup(locale), assets: assetFetcher() });
+            // Alternates advertise PUBLISHED locales only; the editor (draft) sees every present one.
+            // One record is in memory (a nested entry's parents are not), so the `paths` index
+            // supplies the paths — the same single lookup as before (spec 2026-09-15 §2).
+            const known = await entries.pathsOf(schema.name, id);
+            const alternates = entryAlternates(record, locales, (l) => draft || record.locales[l]?.status === "published", (l) => known[l] ?? null);
+            return {
+                kind: "entry", locale, collection: schema.name, entry: { ...record, fields }, path, locales: alternates,
+                ...(schema.seo ? { seo: entrySeo(fields, schema) } : {}),
+            };
+        }
+        return null;
+    }
+    const localeOf = (o) => o?.locale ?? locales.default;
+    async function readEntries(collection, o = {}) {
+        const schema = schemaOf(options.collections, collection);
+        const locale = localeOf(o);
+        const draft = o.draft ?? false;
+        const { entries } = options.stores();
+        checkEntryQuery(schema, collection, o);
+        // The store filters, orders and limits over the snapshot shown (spec 2026-09-29 content API contract §5): the
+        // locale gate — presence in draft mode, published otherwise — is part of the query, so `limit` counts rows that are really there.
+        const rows = await entries.query(collection, {
+            locale, draft, where: o.where, order: o.order, limit: o.limit, ids: o.ids,
+            ...(o.parent !== undefined ? { parent: o.parent } : {}),
+        });
+        // Paths need every ancestor: a tree collection reads the whole collection for that, a flat one does not.
+        const all = schema.tree ? await entries.list(collection) : rows.map((r) => r.record);
+        // References and media resolve for the whole list in one pass (§2, §6).
+        const sets = rows.map((r) => ({ values: structuredClone(r.fields), descriptors: schema.fields }));
+        await resolveFieldSets(sets, { collections: options.collections, elements: options.elements, fetch: fetcher(draft, locale), paths: pathLookup(locale), assets: assetFetcher() });
+        const index = new Map(all.map((e) => [e.id, e]));
+        const byId = (x) => index.get(x);
+        return rows.map(({ record }, i) => {
+            const paths = entryPathRows([record], byId, schema.name);
+            const pathIn = (l) => {
+                const row = paths.find((r) => r.locale === l);
+                return row ? fullPath(anchors, row.anchor ?? "", row.path, l) : null;
+            };
+            const item = toEntryItem(record, sets[i].values, {
+                path: pathIn(locale),
+                locale,
+                locales: entryAlternates(record, locales, (l) => draft || record.locales[l]?.status === "published", pathIn),
+                ...(schema.seo ? { seo: entrySeo(sets[i].values, schema) } : {}),
+            });
+            return { record, item };
+        });
+    }
+    /** A node the public tree leaves out, with its subtree: a record no longer in code (no path, spec
+     *  2026-09-29 nested paths §5), and a page where another code address wins, which visitors never
+     *  reach (anchored paths §4). */
+    const hiddenAt = (path, record, byId, locale) => path === null || servedAnchor(anchors, locale, path) !== (chainOf(record, byId)[0].fixed ?? "");
+    async function tree(locale, { draft }) {
+        const all = await options.stores().pages.listPages();
+        const shown = all.filter((n) => visible(n, locale, draft));
+        const index = new Map(shown.map((n) => [n.id, n]));
+        const fields = await linkFields(shown, locale, draft);
+        // Every node the walk reaches is present with a present chain.
+        const hidden = (node) => hiddenAt(node.path, node.record, (x) => index.get(x), locale);
+        const toItems = (nodes) => nodes.flatMap((node) => hidden(node) ? [] : [{
+                id: node.record.id,
+                title: node.record.locales[locale].title,
+                path: node.path,
+                hasPage: hasPage(node.record, locale, draft),
+                fields: fields.get(node.record.id) ?? {},
+                children: toItems(node.children),
+            }]);
+        return toItems(buildPageTree(shown, locale, pathOpts));
+    }
+    async function treeRow(record, all, locale) {
+        const index = new Map(all.map((n) => [n.id, n]));
+        const byId = (x) => index.get(x);
+        const path = pagePath(record, byId, locale, pathOpts);
+        const fields = await linkFields([record], locale, false);
+        return {
+            id: record.id,
+            locale,
+            parentId: record.parentId,
+            sort: record.sort,
+            path: hiddenAt(path, record, byId, locale) ? null : path,
+            title: record.locales[locale].title,
+            hasPage: hasPage(record, locale, false),
+            linkFields: fields.get(record.id) ?? {},
+        };
+    }
+    async function global(item, locale, { draft }) {
+        const { entries } = options.stores();
+        const [record] = await entries.list(item.name);
+        if (!record)
+            return null;
+        const row = record.locales[locale];
+        if (!row || (!draft && row.status !== "published"))
+            return null;
+        const raw = draft
+            ? entryFieldsIn(record, locale)
+            : (await entries.getMany(item.name, [record.id], locale, { status: "published" }))[record.id];
+        if (!raw)
+            return null;
+        const fields = await resolveFields(raw, item.fields, { collections: options.collections, elements: options.elements, fetch: fetcher(draft, locale), paths: pathLookup(locale), assets: assetFetcher() });
+        if (!item.section)
+            return { locale, fields };
+        const { [SETTINGS_KEY]: settings, [STYLES_KEY]: steps, [CSS_KEY]: css, ...rest } = fields;
+        const fetch = assetFetcher();
+        const own = settings !== null && typeof settings === "object" ? settings : {};
+        if (fetch)
+            await resolveMedia(own, sectionSettings(item.section), fetch, elements);
+        // The layout node id, the css and the values ride the styles under the reserved key (spec 2026-09-13 §1, 2026-09-14 §2, §4):
+        // the wrapper strips it and emits data-smd-node, so the canvas selects the item and the css reaches it.
+        const stepsObject = steps !== null && typeof steps === "object" ? steps : {};
+        return {
+            locale,
+            fields: rest,
+            settings: own,
+            styles: { ...stepsObject, [SMD_KEY]: { node: globalNodeId(item.name), css: typeof css === "string" ? css : undefined, values: styles } },
+        };
+    }
+    /** A copy whose reads in MEMOIZED answer once per argument set — the promise is shared, so concurrent
+     *  identical calls make one store call. For the lifetime of the copy only; the base assembler never caches. */
+    function batch(primed) {
+        const memo = new Map();
+        if (primed?.pages)
+            memo.set(`pages.listPages:${JSON.stringify([])}`, Promise.resolve(primed.pages));
+        const wrap = (store, group) => new Proxy(store, {
+            get(target, prop) {
+                const value = Reflect.get(target, prop, target);
+                if (typeof value !== "function")
+                    return value;
+                if (!MEMOIZED[group].includes(prop))
+                    return value.bind(target);
+                return (...args) => {
+                    const key = `${group}.${String(prop)}:${JSON.stringify(args)}`;
+                    let hit = memo.get(key);
+                    if (!hit)
+                        memo.set(key, (hit = value.apply(target, args)));
+                    return hit;
+                };
+            },
+        });
+        return createAssembler({
+            ...options,
+            stores: () => {
+                const s = options.stores();
+                return { ...s, pages: wrap(s.pages, "pages"), entries: wrap(s.entries, "entries"), ...(s.assets ? { assets: wrap(s.assets, "assets") } : {}) };
+            },
+        }, shape);
+    }
+    return {
+        page: (id, locale, path, { draft, version }) => loadPage(id, locale, path, draft, version),
+        entry: (id, locale, path, { draft }) => loadEntry(id, locale, path, draft),
+        global,
+        tree,
+        entries: readEntries,
+        treeRow,
+        batch,
+    };
+}

package/dist/astro/cache.d.ts

@@ -0,0 +1,34 @@
+export type ResponseCache = {
+    enabled?: boolean;
+    readonly options?: {
+        maxAge?: number;
+    };
+    set(input: false | {
+        maxAge?: number;
+        tags?: string[];
+    }): void;
+    invalidate(options: {
+        tags: string[];
+    }): Promise<void>;
+};
+/** What the middleware knows about a request when its response is whole. */
+export type Settled = {
+    /** A verified preview. */
+    draft: boolean;
+    /** The request is under the preview address, cookie or not. */
+    preview: boolean;
+    /** The shell rendered a page read from the database and gave it a lifetime. */
+    cacheable: boolean;
+    /** When the request began, in milliseconds. */
+    started: number;
+    /** A read the response made threw (scope.ts). */
+    failed: boolean;
+};
+/** A cached page lives until a tag expires it: no timer hides a missing tag. One year, in seconds. */
+export declare const MAX_AGE: number;
+/** The shell's page, before its view renders: a view that calls `Astro.cache.set` after this has the last word. */
+export declare function lifetime(cache: ResponseCache | undefined): void;
+export declare function settle(cache: ResponseCache | undefined, response: {
+    status: number;
+}, state: Settled, tags: ReadonlySet<string>): void;
+export declare function expire(cache: ResponseCache | undefined, tags: ReadonlySet<string>): Promise<void>;

package/dist/astro/cache.js

@@ -0,0 +1,69 @@
+/** A cached page lives until a tag expires it: no timer hides a missing tag. One year, in seconds. */
+export const MAX_AGE = 60 * 60 * 24 * 365;
+// When each tag was last expired in this process, kept long enough to outlive any render: a page that
+// read its content before a publish and finished after it must not be stored for a year. One map per
+// process, however many copies of this module a bundler makes.
+const KEY = Symbol.for("smoodly:expired-tags");
+const host = globalThis;
+const expiredAt = (host[KEY] ?? (host[KEY] = new Map()));
+const REMEMBER = 10 * 60000;
+function expiredSince(tags, started) {
+    for (const tag of tags) {
+        const at = expiredAt.get(tag);
+        if (at !== undefined && at >= started)
+            return true;
+    }
+    return false;
+}
+/** The shell's page, before its view renders: a view that calls `Astro.cache.set` after this has the last word. */
+export function lifetime(cache) {
+    if (cache?.enabled)
+        cache.set({ maxAge: MAX_AGE });
+}
+export function settle(cache, response, state, tags) {
+    if (!cache?.enabled)
+        return;
+    // Astro looks the cache up before any cookie is checked: nothing under the preview address may be stored.
+    if (state.draft || state.preview)
+        return cache.set(false);
+    // A read failed: the page rendered without what it could not read (an empty list, no footer), and a database
+    // error must not be served for a year. A section's own throw is no failed read: that page is what the code makes.
+    if (state.failed)
+        return cache.set(false);
+    if (state.cacheable) {
+        // The view turned the cache off (`set(false)` drops the lifetime the shell gave): its decision stands.
+        if (cache.options?.maxAge === undefined)
+            return;
+        // No tag would expire it, or it is not the page: it keeps no lifetime.
+        if (response.status !== 200 || tags.size === 0)
+            return cache.set(false);
+    }
+    // Nothing of Smoodly's was read (a 404, a page served from code, a route of the developer's own): not ours to cache.
+    if (tags.size === 0)
+        return;
+    // A publish overtook this render: what it read may be the version before.
+    if (expiredSince(tags, state.started))
+        return cache.set(false);
+    // A developer's route that read Smoodly content is tagged, and cached only if it gave itself a lifetime.
+    cache.set({ tags: [...tags] });
+}
+export async function expire(cache, tags) {
+    if (tags.size === 0)
+        return;
+    const now = Date.now();
+    for (const [tag, at] of expiredAt)
+        if (now - at > REMEMBER)
+            expiredAt.delete(tag);
+    // Noted before the purge, so a render that settles in between is not stored either.
+    for (const tag of tags)
+        expiredAt.set(tag, now);
+    if (!cache?.enabled)
+        return;
+    try {
+        await cache.invalidate({ tags: [...tags] });
+    }
+    catch (error) {
+        // The operation succeeded and the write is in the database; a cache that cannot be told stays stale until a later purge or restart.
+        console.error(`smoodly: the cache provider failed to invalidate ${[...tags].join(", ")} — the content is saved; the cached pages may be stale.`, error);
+    }
+}

package/dist/astro/components/Custom.astro

@@ -0,0 +1,21 @@
+---
+// The custom section for Astro (spec 2026-09-14 §6; the React one is custom/CustomSection.tsx): rows of
+// richtext columns through <Section>, so spacing, width, the node id, the CSS box and selection come free;
+// the layout CSS rides the reserved key (custom.ts). Rows and columns carry the marks inline editing needs.
+// The columns render through <RichText>, so the project's elements reach them with no binding step.
+import { FIELD_ATTR, ITEM_ATTR, customLayoutOf } from "smoodly/astro/runtime";
+import RichText from "./RichText.astro";
+import Section from "./Section.astro";
+
+const { rows, styles = {} } = Astro.props;
+const layout = customLayoutOf(rows, styles);
+---
+<Section styles={layout.styles} data-custom="">
+  {layout.list.map((row, i) => (
+    <div class={row.reverse ? "smd-row smd-row--reverse" : "smd-row"} data-row={i} {...{ [ITEM_ATTR]: `rows.${i}` }}>
+      {row.columns.map((doc, j) => (
+        <div class="smd-col" {...{ [FIELD_ATTR]: `columns.${j}` }}><RichText doc={doc} /></div>
+      ))}
+    </div>
+  ))}
+</Section>

package/dist/astro/components/Guarded.astro

@@ -0,0 +1,24 @@
+---
+// The section guard for Astro (spec 2026-09-27 section guard §1, §3; DESIGN.md §3): the section renders into
+// a string first, so a throw anywhere inside it — its own code, a nested component, an element in its
+// richtext — is caught here and leaves the section out, not the page. `Astro.slots.render` is the seam
+// (probed 2026-10-06: sync, async and nested throws caught; a scoped style in the slot still reaches the
+// head). Nothing is rethrown: an Astro component cannot 404 or redirect from inside. The placeholder shows
+// in the canvas, and under `astro dev`, so a developer never misses their own crash.
+import { CRASHED_ATTR, NODE_ATTR, PLACEHOLDER_CSS, crashMessage } from "smoodly/astro/runtime";
+
+const { id, type, title, editor } = Astro.props;
+let html = "";
+let failed = false;
+let error: unknown;
+try {
+  html = await Astro.slots.render("default");
+} catch (e) {
+  failed = true;
+  error = e;
+  console.error(`smoodly: section "${type}" (node ${id}) failed to render and is left out of the page.`, e);
+}
+const placeholder = failed && (editor || import.meta.env.DEV);
+---
+{!failed && <Fragment set:html={html} />}
+{placeholder && <div {...{ [NODE_ATTR]: id, [CRASHED_ATTR]: "section" }} style={PLACEHOLDER_CSS}>{`Section “${title}” failed to render — ${crashMessage(error)}`}</div>}

package/dist/astro/components/Head.astro

@@ -0,0 +1,26 @@
+---
+// packages/smoodly/src/astro/components/Head.astro
+// The document head Smoodly knows (head.ts): the title, the description, the canonical address, one hreflang
+// 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.
+const { of: head, fallback } = Astro.props;
+const origin = (Astro.site ?? Astro.url).origin;
+const absolute = (path: string) => new URL(path, origin).href;
+const title = head.title ?? fallback;
+const canonical = head.canonical ? absolute(head.canonical) : undefined;
+const image = head.image;
+---
+{title && <title>{title}</title>}
+{head.description && <meta name="description" content={head.description} />}
+{canonical && <link rel="canonical" href={canonical} />}
+{Object.entries(head.languages).map(([lang, path]) => <link rel="alternate" hreflang={lang} href={absolute(path as string)} />)}
+{title && <meta property="og:title" content={title} />}
+{head.description && <meta property="og:description" content={head.description} />}
+{canonical && <meta property="og:url" content={canonical} />}
+{image && <meta property="og:image" content={image.url} />}
+{image && <meta property="og:image:width" content={String(image.width)} />}
+{image && <meta property="og:image:height" content={String(image.height)} />}
+{image?.alt && <meta property="og:image:alt" content={image.alt} />}
+{head.noindex && <meta name="robots" content="noindex, nofollow" />}

package/dist/astro/components/Image.astro

@@ -0,0 +1,20 @@
+---
+// <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";
+
+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;
+---
+<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>

package/dist/astro/components/RichText.astro

@@ -0,0 +1,23 @@
+---
+// The richtext renderer for Astro (spec 2026-09-08 block nodes; spec 2026-10-02 astro cloud fit §8): TipTap
+// JSON as the React renderer writes it, decided in richtext.ts. Text, marks and block tags come as escaped
+// HTML runs; an image node renders through <Image>; an element node through the project's
+// src/elements/<name>.astro, found by file name, its settings defaults filled as pair() fills them. An
+// element with no file is left out, named on the server.
+import { views } from "smoodly:views";
+import { info, richtextChunks } from "smoodly/astro/runtime";
+import Image from "./Image.astro";
+
+const { doc, sizes } = Astro.props;
+const chunks = richtextChunks(doc);
+---
+{chunks.map((chunk) => {
+  if (chunk.kind === "html") return <Fragment set:html={chunk.html} />;
+  if (chunk.kind === "image") {
+    return <figure><Image image={chunk.image} sizes={sizes} loading="lazy" />{chunk.caption !== "" && <figcaption>{chunk.caption}</figcaption>}</figure>;
+  }
+  // An own name only: `constructor` or `toString` must not find Object's members.
+  const View = Object.prototype.hasOwnProperty.call(views.elements, chunk.name) ? views.elements[chunk.name] : undefined;
+  if (!View) { console.warn(`smoodly: no src/elements/${chunk.name}.astro for element "${chunk.name}" — skipping.`); return null; }
+  return <View {...chunk.fields} settings={{ ...info.element(chunk.name).defaults, ...chunk.settings }} />;
+})}

package/dist/astro/components/Section.astro

@@ -0,0 +1,20 @@
+---
+// The root wrapper every section view renders through, for Astro (spec 2026-09-14 §2, §4; the React one
+// is section-wrapper.tsx): the real root element, Smoodly's styles set inline, the node id as
+// data-smd-node always (the custom-CSS scope needs it on the live site), the scoped style element, and
+// every other prop spread onto the root.
+import { DEFAULT_STYLE_VALUES, NODE_ATTR, SMD_KEY, inlineStyles, safeCss, scopedCss, styleAttribute } from "smoodly/astro/runtime";
+
+const { as: Tag = "section", styles = {}, class: className, style, ...rest } = Astro.props;
+const { [SMD_KEY]: smd, ...steps } = styles;
+const own = typeof style === "object" && style ? style : {};
+const inline = { ...own, ...inlineStyles(steps, smd?.values ?? DEFAULT_STYLE_VALUES) };
+const styleAttr = styleAttribute(typeof style === "string" ? style : undefined, inline);
+const css = smd?.node ? safeCss(smd.css) : "";
+const attrs = { ...rest, ...(smd?.node ? { [NODE_ATTR]: smd.node } : {}) };
+---
+<Tag class={className} style={styleAttr} {...attrs}>
+  {smd?.layoutCss && <style set:html={smd.layoutCss} is:inline></style>}
+  {css && <style set:html={scopedCss(smd.node, css)} is:inline></style>}
+  <slot />
+</Tag>

package/dist/astro/components/Video.astro

@@ -0,0 +1,5 @@
+---
+// A <video> over the bucket's CDN with its poster and size, no transcoding (spec 2026-09-08 media §9).
+const { video, ...rest } = Astro.props;
+---
+<video src={video.url} poster={video.poster?.url} width={video.width} height={video.height} playsinline {...rest}></video>

package/dist/astro/components/Zone.astro

@@ -0,0 +1,19 @@
+---
+// The zone renderer for Astro (spec 2026-10-02 astro cloud fit §8): each node of the zone through the
+// project's own section view, found by file name (the virtual module smoodly:views), inside the guard;
+// the custom section's view is the package's own. What to render is decided in zone.ts.
+import { views } from "smoodly:views";
+import { CUSTOM_NODE_TYPE, EMPTY_ATTR, NODE_ATTR, PLACEHOLDER_CSS, ZONE_ATTR, info, zoneItems } from "smoodly/astro/runtime";
+import Custom from "./Custom.astro";
+import Guarded from "./Guarded.astro";
+
+const { of: content } = Astro.props;
+const items = zoneItems(content, { registered: info.isSection, has: (type) => type === CUSTOM_NODE_TYPE || Object.hasOwn(views.sections, type), about: info.section });
+---
+{items.map((item) => {
+  if (item.kind === "empty") return <div {...{ [ZONE_ATTR]: item.zone, [EMPTY_ATTR]: "" }} style="min-height:48px"></div>;
+  if (item.kind === "unknown") return <div {...{ [NODE_ATTR]: item.id }} style={PLACEHOLDER_CSS}>Unknown section `{item.type}`</div>;
+  if (item.kind === "missing") return <div {...{ [NODE_ATTR]: item.id }} style={PLACEHOLDER_CSS}>No src/sections/{item.type}.astro</div>;
+  const View = item.type === CUSTOM_NODE_TYPE ? Custom : views.sections[item.type];
+  return <Guarded id={item.id} type={item.type} title={item.title} editor={content.editor}><View {...item.props} /></Guarded>;
+})}

package/dist/astro/components.d.ts

@@ -0,0 +1,6 @@
+export { default as Zone } from "./components/Zone.astro";
+export { default as Section } from "./components/Section.astro";
+export { default as Image } from "./components/Image.astro";
+export { default as Video } from "./components/Video.astro";
+export { default as RichText } from "./components/RichText.astro";
+export { default as Head } from "./components/Head.astro";

package/dist/astro/components.js

@@ -0,0 +1,7 @@
+// The Astro components a project's views import: `import { Zone, Section, Image } from "smoodly/astro/components"`.
+export { default as Zone } from "./components/Zone.astro";
+export { default as Section } from "./components/Section.astro";
+export { default as Image } from "./components/Image.astro";
+export { default as Video } from "./components/Video.astro";
+export { default as RichText } from "./components/RichText.astro";
+export { default as Head } from "./components/Head.astro";