smoodly 0.0.45 → 0.0.47

package/dist/site.js

@@ -1,22 +1,17 @@
-import { ARRAY_FIELD_TYPES, entryFieldsIn, schemaOf } from "./entry-store.js";
-import { buildPageTree, chainOf, entryAlternates, entryPathRows, entrySegment, 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 "./section-wrapper.js";
-import { resolveStyleValues } from "./styles.js";
-import { resolveCustom } from "./custom/index.js";
-import { addressMap, codeAddresses, lastPart } from "./addresses.js";
-import { fullPath, servedAnchor } from "./anchors.js";
+import { schemaOf } from "./entry-store.js";
+import { entrySegment } from "./paths.js";
+import { lastPart } from "./addresses.js";
 import { withDefaults } from "./field-defaults.js";
 import { modelKey } from "./model-key.js";
+import { documentStamp } from "./document-stamp.js";
 import { SMOODLY_VERSION } from "./version.js";
 import { toEntryItem, toPageItem } from "./read-shapes.js";
-import { entrySeo, pageSeo, SEO_KEY } from "./seo.js";
+import { pageSeo } from "./seo.js";
+import { checkEntryQuery, createAssembler, pageFieldsOf, siteShape } from "./assemble.js";
+import { collectionOrder } from "./collections.js";
+import { createProjector } from "./project.js";
 /** The `page` prop for a loaded page. `href` is the app's seam from a
  *  locale-relative path to a site URL; the default keeps CMS paths as URLs. */
-/** 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"]);
 export function pageContextOf(hit, href = (p) => p) {
     const withUrl = (l) => ({ ...l, url: href(l.path, hit.locale) });
     return {
@@ -32,264 +27,144 @@ export function pageContextOf(hit, href = (p) => p) {
     };
 }
 export function createSmoodlySite(options) {
-    const locales = options.locales;
-    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: options.pages, 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 };
-    const mounted = options.collections.filter((c) => c.path !== undefined);
+    const shape = siteShape(options);
+    const { locales, pageSchemas, homePageSlug, styles, custom, codeOwned } = shape;
+    const assembler = createAssembler(options, shape);
     // Every cached read keys on it (spec 2026-09-30 tester findings §3): an upgrade or a model change starts a fresh cache.
     const cacheKey = `${SMOODLY_VERSION}:${modelKey({
         // Whole schemas: a collection's order, tree or title field changes a read as its fields do (functions drop out in the hash).
         collections: options.collections,
-        globals: (options.globals ?? []).map((g) => ({ name: g.name, fields: g.fields, section: g.section })),
+        globals: (options.globals ?? []).map((g) => ({ name: g.name, fields: g.fields, settings: g.settings, section: g.section })),
         sections: options.sections.map((x) => ("schema" in x ? x.schema : x)),
         elements: (options.elements ?? []).map((x) => ("schema" in x ? x.schema : x)),
-        pages: options.pages.map((x) => x.schema),
+        pages: pageSchemas,
         locales, homePageSlug, styles, custom,
     })}`;
-    /** 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) => {
-        if (template === null)
-            return {};
-        const p = (options.pages ?? []).find((x) => x.schema.kind === "page" && x.schema.name === template);
-        return p?.schema.fields ?? {};
-    };
-    /** 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) ?? {},
+    // What a delivery row is stamped with (DESIGN §3, the document stamp): the document format and the schema parts
+    // that reach a document, never the package version, so a release leaves current documents current.
+    const stamp = documentStamp(options);
+    const localeOf = (o) => o?.locale ?? locales.default;
+    const published = () => options.stores().published;
+    const projector = createProjector({
+        assembler,
+        stores: () => { const s = options.stores(); return { pages: s.pages, entries: s.entries, published: s.published }; },
+        collections: options.collections, globals: options.globals ?? [], sections: options.sections, elements: options.elements,
+        locales, model: stamp,
     });
-    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;
+    // Delivery (spec 2026-10-07 delivery model §3–§4): outside draft mode a read takes the stored document when it is
+    // current — built by this model and not marked stale — and otherwise assembles that one document, stores it and serves it.
+    const current = (row) => row.model === stamp && !row.stale;
+    /** One writer of record (DESIGN §3, the document stamp): only the deployment whose stamp the space recorded rewrites
+     *  rows; the first writer into an empty record records itself; every other deployment serves assembled documents
+     *  and writes nothing. Read only when a heal is about to write, so a current page stays one call. A "no" is kept for
+     *  the process (a later rebuild at this stamp is seen by the next process, which costs assembled reads, never wrong
+     *  ones); a "yes" is read again on each heal, so a rebuild elsewhere stops this writer at its next heal. */
+    let yields = false;
+    async function mayWrite() {
+        if (yields)
+            return false;
+        // The record is derived like the rows: a read or write of it that fails is logged, and the page is served
+        // assembled with nothing written (spec 2026-10-07 §2 Failure), never failed on it.
+        try {
+            const recorded = await published().recordedModel();
+            if (recorded === null) {
+                await published().recordModel(stamp);
+                return true;
+            }
+            yields = recorded !== stamp;
+            return !yields;
         }
-        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 = (options.pages ?? []).some((x) => x.schema.kind === "page" && x.schema.name === record.template && x.schema.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) } : {}),
-            };
+        catch (e) {
+            console.error("smoodly: reading the space's recorded document stamp failed; served assembled, nothing written.", e);
+            return false;
         }
-        return null;
     }
-    const localeOf = (o) => o?.locale ?? locales.default;
-    async function readEntries(collection, o = {}) {
+    const fresh = (row) => current(row) && row.document != null;
+    const itemOf = (doc) => toEntryItem(doc.entry, doc.entry.fields, { path: doc.path, locale: doc.locale, locales: doc.locales, ...(doc.seo ? { seo: doc.seo } : {}) });
+    /** A page row's answer: its document when current (null for a folder or a hidden node), else the healed one. */
+    const pageOf = async (row, id, locale) => row && current(row) ? row.document : projector.healPage(id, locale, { seen: row !== null, write: await mayWrite() });
+    /** An entry document is served at an address only when its collection has addresses. */
+    const served = (doc) => (doc && doc.path !== null ? doc : null);
+    const entryOf = async (row, id, locale) => row && fresh(row) ? row.document : projector.healEntry(id, locale, { seen: row !== null, write: await mayWrite() });
+    /** An entry document as the projector would write it, from an assembled read (the address-less shape, path from the item). */
+    const assembledEntry = (collection, locale) => (read) => ({
+        kind: "entry", locale, collection, entry: { ...read.record, fields: read.item.fields },
+        path: read.item.path, locales: read.item.locales, ...(read.item.seo ? { seo: read.item.seo } : {}),
+    });
+    /** The published documents of a collection's query. Stale rows are rebuilt in one batched projection and the
+     *  query read once more (spec §4): a rebuild that finds an entry unpublished removes its row, so it drops out. */
+    async function deliveredEntries(collection, o) {
         const schema = schemaOf(options.collections, collection);
+        checkEntryQuery(schema, collection, o);
         const locale = localeOf(o);
-        const draft = o.draft ?? false;
-        const { entries } = options.stores();
-        // 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.`);
+        const read = () => published().entries(collection, {
+            locale, where: o.where, order: o.order ?? collectionOrder(schema), limit: o.limit, ids: o.ids,
+            ...(o.parent !== undefined ? { parent: o.parent } : {}),
+        });
+        let rows = await read();
+        const behind = rows.filter((r) => !fresh(r)).map((r) => r.id);
+        if (behind.length > 0) {
+            // Not the writer of record: the list assembled now, nothing written (DESIGN §3).
+            if (!(await mayWrite()))
+                return (await assembler.entries(collection, { ...o, locale, draft: false })).map(assembledEntry(collection, locale));
+            // A failed rebuild never fails the read: the rows as read are served, and the next read tries again.
+            try {
+                await projector.entries(behind, { cap: Infinity });
+                rows = await read();
             }
-            // 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.`);
+            catch (e) {
+                console.error(`smoodly: rebuilding ${behind.length} ${collection} documents in the delivery tables failed; served as read.`, e);
             }
         }
-        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 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 };
-        });
+        return rows.flatMap((r) => (r.document != null ? [r.document] : []));
     }
-    const getEntries = async (collection, o = {}) => (await readEntries(collection, o)).map((r) => r.item);
+    const getEntries = async (collection, o = {}) => o.draft ? (await assembler.entries(collection, o)).map((r) => r.item) : (await deliveredEntries(collection, o)).map(itemOf);
+    /** Every entry of the collection in the locale, with the record a tree and a bare slug read `parentId` from. */
+    const readAll = async (collection, locale, draft) => draft
+        ? assembler.entries(collection, { locale, draft })
+        : (await deliveredEntries(collection, { locale })).map((doc) => ({ record: doc.entry, item: itemOf(doc) }));
     const api = {
         async getPagesTree(o) {
             const locale = localeOf(o);
-            const draft = o?.draft ?? false;
-            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. Left
-            // 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 hidden = (node) => node.path === null || servedAnchor(anchors, locale, node.path) !== (chainOf(node.record, (x) => index.get(x))[0].fixed ?? "");
-            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));
+            if (o?.draft)
+                return assembler.tree(locale, { draft: true });
+            // One light read. A row behind the model or marked stale is rebuilt before answering (spec §4), and the tree read
+            // again; a rebuild that finds the node gone or unpublished removes its row.
+            let rows = await published().tree(locale);
+            const behind = rows.filter((r) => !current(r)).map((r) => r.id);
+            if (behind.length > 0) {
+                // Not the writer of record: the tree assembled now, nothing written (DESIGN §3).
+                if (!(await mayWrite()))
+                    return assembler.tree(locale, { draft: false });
+                // One batched projection for every row behind (one tree read in the projector), then one more tree read.
+                // A failed rebuild never fails the read: the rows as read are served, and the next read tries again.
+                try {
+                    await projector.pages(behind, { cap: Infinity });
+                    rows = await published().tree(locale);
+                }
+                catch (e) {
+                    console.error(`smoodly: rebuilding ${behind.length} page documents in the delivery tables failed; served as read.`, e);
+                }
+            }
+            // A node the tree hides (path null) leaves with its subtree, as does one whose parent has no row.
+            const build = (parentId) => rows.filter((r) => r.parentId === parentId && r.path !== null).map((r) => ({
+                id: r.id, title: r.title, path: r.path, hasPage: r.hasPage, fields: r.linkFields, children: build(r.id),
+            }));
+            return build(null);
         },
         async getPage(pathOrId, o) {
             const locale = localeOf(o);
+            if (!o?.draft) {
+                // The content API stays strict (§7): a redirect row, and a code-owned page with no record, are not pages.
+                const hit = pathOrId.startsWith("/")
+                    ? (await delivered(locale, pathOrId, false)).hit
+                    : await pageOf(await published().page(pathOrId, locale), pathOrId, locale);
+                return hit?.kind === "page" ? toPageItem(hit) : null;
+            }
             const path = pathOrId.startsWith("/") ? pathOrId : (await options.stores().pages.pathsOf(pathOrId))[locale];
             if (!path)
                 return null;
-            const hit = await site.resolve(locale, path, { draft: o?.draft ?? false });
+            const hit = await site.resolve(locale, path, { draft: true });
             return hit?.kind === "page" ? toPageItem(hit) : null;
         },
         getEntries,
@@ -298,64 +173,79 @@ export function createSmoodlySite(options) {
             const locale = localeOf(o);
             const draft = o?.draft ?? false;
             if (idOrPath.startsWith("/")) {
-                const hit = await site.resolve(locale, idOrPath, { draft });
+                const hit = draft ? await site.resolve(locale, idOrPath, { draft }) : (await delivered(locale, idOrPath, false)).hit;
                 return hit?.kind === "entry" && hit.collection === collection ? toEntryItem(hit.entry, hit.entry.fields, hit) : null;
             }
-            const [byId] = await readEntries(collection, { locale, draft, ids: [idOrPath] });
-            if (byId)
-                return byId.item;
+            if (draft) {
+                const [byId] = await assembler.entries(collection, { locale, draft, ids: [idOrPath] });
+                if (byId)
+                    return byId.item;
+            }
+            else {
+                const row = await published().entry(idOrPath, locale);
+                if (row && row.collection === collection && fresh(row))
+                    return itemOf(row.document);
+                // A miss is a record no projection wrote yet, or a slug: one `get` tells them apart.
+                if (row?.collection === collection || (await options.stores().entries.get(collection, idOrPath))) {
+                    const doc = await projector.healEntry(idOrPath, locale, { seen: row !== null, write: await mayWrite() });
+                    if (doc)
+                        return itemOf(doc);
+                }
+            }
             // A bare slug names a ROOT entry only (sibling-scoped slugs, spec §4):
             // match the localized slug directly (paths.ts owns slug derivation),
             // regardless of whether the collection even has a `path`.
-            const all = await readEntries(collection, { locale, draft });
+            const all = await readAll(collection, locale, draft);
             return all.find((r) => r.record.parentId === null && entrySegment(r.record, locale) === idOrPath)?.item ?? null;
         },
         async getEntriesTree(collection, o) {
-            const rows = await readEntries(collection, { locale: localeOf(o), draft: o?.draft ?? false });
+            const rows = await readAll(collection, localeOf(o), o?.draft ?? false);
             const build = (parentId) => rows.filter((r) => r.record.parentId === parentId).map((r) => ({ ...r.item, children: build(r.record.id) }));
             return build(null);
         },
         async getGlobal(item, o) {
             const locale = localeOf(o);
-            const draft = o?.draft ?? false;
-            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 } },
-            };
+            if (o?.draft)
+                return assembler.global(item, locale, { draft: true });
+            // The item's row by its collection, in one read: a global is a one-record collection.
+            const [row] = await published().entries(item.name, { locale, limit: 1 });
+            return row && fresh(row) ? row.document : projector.healGlobal(item, locale, { seen: row !== undefined, write: await mayWrite() });
         },
     };
+    /** The published read of an address; `code`: the code-owned page answers where the index has no row. */
+    /** `globals`: the names of global items to bring along (schema v9); `rows` is what the route carried, when it had any. */
+    async function delivered(locale, path, code, globals) {
+        const route = await published().byAddress(locale, path, globals);
+        const rows = route?.globals;
+        if (route && fresh(route.row))
+            return { hit: route.row.document, rows };
+        let healed = null;
+        if (route) {
+            // Stale: rebuilt by id. Unpublished or moved since the row was written, the address is answered as a miss.
+            const write = await mayWrite();
+            healed = route.kind === "page" ? await projector.healPage(route.row.id, locale, { write }) : served(await projector.healEntry(route.row.id, locale, { write }));
+            if (healed && healed.path === path)
+                return { hit: healed, rows };
+        }
+        // A miss: the paths index doubles as the existence check — a record to assemble, a redirect row, or nothing.
+        // A record wins over the code-owned page at its address, as the renderer has it.
+        const hit = await site.locate(locale, path);
+        if (!hit)
+            return { hit: code ? codePage(locale, path) : null };
+        if (hit.redirect)
+            return { hit: { kind: "redirect", target: { kind: hit.kind, id: hit.id } } };
+        if (route && hit.id === route.row.id)
+            return { hit: healed, rows }; // just rebuilt
+        // By id: a page the tree hides has a current row the address lookup cannot reach; anything else heals there.
+        return { hit: await site.load(hit, locale, path), rows };
+    }
     const codePath = (address) => (address === homePageSlug ? "/" : `/${address}`);
     function codePage(locale, path) {
         const spec = codeOwned.find((a) => a.template !== null && a.segments[locale] !== undefined && codePath(a.segments[locale]) === path);
         if (!spec || !locales.supported.includes(locale))
             return null;
         const template = spec.template;
-        const withSeo = options.pages.some((x) => x.schema.kind === "page" && x.schema.name === template && x.schema.seo === true);
+        const withSeo = pageSchemas.some((x) => x.kind === "page" && x.name === template && x.seo === true);
         return {
             kind: "page",
             locale,
@@ -365,7 +255,7 @@ export function createSmoodlySite(options) {
             tree: { zones: {} },
             title: spec.title,
             path,
-            fields: withDefaults(undefined, pageFields(template)),
+            fields: withDefaults(undefined, pageFieldsOf(shape, template)),
             ancestors: [],
             children: [],
             locales: Object.fromEntries(Object.entries(spec.segments).map(([l, address]) => [l, { slug: lastPart(address), path: codePath(address) }])),
@@ -376,13 +266,37 @@ export function createSmoodlySite(options) {
         locales,
         homePageSlug,
         cacheKey,
+        stamp,
         styles,
         custom,
         locate: (locale, path) => options.stores().pages.resolvePath(locale, path),
         targetPaths: (target) => options.stores().pages.targetPaths(target),
-        load(target, locale, path, opts = {}) {
+        async load(target, locale, path, opts = {}) {
             const draft = opts.draft ?? false;
-            return target.kind === "page" ? loadPage(target.id, locale, path, draft, opts.version) : loadEntry(target.id, locale, path, draft);
+            // Draft mode assembles from the editing tables; so does a stored version, which outside draft mode is nothing.
+            if (draft || opts.version !== undefined) {
+                return target.kind === "page" ? assembler.page(target.id, locale, path, { draft, version: opts.version }) : assembler.entry(target.id, locale, path, { draft });
+            }
+            return target.kind === "page"
+                ? pageOf(await published().page(target.id, locale), target.id, locale)
+                : served(await entryOf(await published().entry(target.id, locale), target.id, locale));
+        },
+        lookup: async (locale, path) => (await delivered(locale, path, true)).hit,
+        async lookupWithGlobals(locale, path, items) {
+            const { hit, rows } = await delivered(locale, path, true, items.map((i) => i.name));
+            const globals = new Map();
+            if (rows) {
+                for (const item of items) {
+                    const row = rows.find((r) => r.collection === item.name);
+                    // No row: unpublished here, or never projected — left out rather than healed on every read, because a
+                    // heal of an unpublished item writes nothing and the next read would heal again; the layout's own read
+                    // pays the call where a page renders it. A stale row heals once and is written.
+                    if (!row)
+                        continue;
+                    globals.set(item.name, fresh(row) ? row.document : await projector.healGlobal(item, locale, { seen: true, write: await mayWrite() }));
+                }
+            }
+            return { hit, globals };
         },
         async resolve(locale, path, opts) {
             // The content API stays strict (§7): a content address is not a redirect.
@@ -390,6 +304,7 @@ export function createSmoodlySite(options) {
             return target && !target.redirect ? site.load(target, locale, path, opts) : null;
         },
         codePage,
+        projector,
         ...api,
     };
     return site;

package/dist/smd-key.d.ts

@@ -0,0 +1,9 @@
+import type { StyleValues } from "./styles.ts";
+export declare const SMD_KEY = "__smd";
+export type SmdInternal = {
+    node?: string;
+    css?: string;
+    values?: StyleValues;
+    /** Pre-scoped layout CSS (the custom section, spec 2026-09-14 §6), emitted before the editor's css so the box wins. */
+    layoutCss?: string;
+};

package/dist/smd-key.js

@@ -0,0 +1 @@
+export const SMD_KEY = "__smd";

package/dist/sql-space.d.ts

@@ -6,6 +6,11 @@ export declare const DEFAULT_SPACE = "'00000000-0000-0000-0000-000000000000'";
 export declare const SPACE_COL = "\"space_id\" uuid not null default '00000000-0000-0000-0000-000000000000'";
 export declare const CONTENT_TABLES: readonly ["pages", "page_locales", "page_versions", "entries", "entry_locales", "entry_versions", "refs", "paths", "assets"];
 export type ContentTable = (typeof CONTENT_TABLES)[number];
+/** The delivery model's derived tables (spec 2026-10-07 §1): policy-covered and
+ *  space-stamped like content, but not transferred (export skips them, import
+ *  rebuilds them) and not counted toward the row cap, since they are derived.
+ *  `published_models` (schema v10) holds one row per space: the document stamp the space recorded as current. */
+export declare const DELIVERY_TABLES: readonly ["published_pages", "published_entries", "published_models"];
 export declare function currentSpaceSQL(): string;
 /** One permissive policy per action (spec 2026-09-29 pre-install fixes §3):
  *  the write key's insert, update and delete, each alone for its action; its