smoodly 0.0.44 → 0.0.46

package/dist/next/queries.js

@@ -1,92 +1,5 @@
-// The in-app read API (spec 2026-09-11): five typed queries over the
-// framework-free site layer, each draft-aware inside the editor preview
-// and cached under a tag outside it — the pattern getSmoodlyGlobal set.
-// Lives in next/ because draftMode and unstable_cache are Next's; an
-// Astro glue wraps the same site reads over its own cache seam.
-import { unstable_cache } from "next/cache";
-import { draftMode } from "next/headers";
-import { connection } from "next/server";
-import { collectionTag, entryTag, pageTag, pagesTreeTag, globalTag } from "../revalidate.js";
-import { referencedCollections } from "../read-shapes.js";
-/** JSON with object keys sorted at every level and `undefined` dropped, so two spellings of one query share a unit. */
-function stable(value) {
-    if (Array.isArray(value))
-        return value.map(stable);
-    if (value !== null && typeof value === "object") {
-        return Object.fromEntries(Object.entries(value)
-            .filter(([, v]) => v !== undefined)
-            .sort(([a], [b]) => (a < b ? -1 : 1))
-            .map(([k, v]) => [k, stable(v)]));
-    }
-    return value;
-}
-/** A stable key for an entries query: only what was given, normalized. */
-function entriesKey(o) {
-    const { locale: _locale, ...rest } = o;
-    return JSON.stringify(stable(rest));
-}
+import { createQueries } from "../reads.js";
+import { nextReads } from "./reads.js";
 export function createSmoodlyQueries(options) {
-    const { site } = options;
-    const collectionByName = new Map(options.collections.map((c) => [c.name, c]));
-    const globalByName = new Map((options.globals ?? []).map((s) => [s.name, s]));
-    const localeOf = (o) => o?.locale ?? site.locales.default;
-    /** Every query gates on the request (never a build prerender), then reads live in draft mode or cached under `tags`. */
-    async function run(key, tags, read) {
-        await connection();
-        const { isEnabled: draft } = await draftMode();
-        if (draft)
-            return read(true);
-        return unstable_cache(() => read(false), ["smoodly-q", site.cacheKey, ...key], { tags })();
-    }
-    /** The tag needs the id: a path is located first, uncached, as the renderer does. */
-    async function idOf(kind, locale, pathOrId) {
-        if (!pathOrId.startsWith("/"))
-            return pathOrId;
-        await connection();
-        const target = await site.locate(locale, pathOrId);
-        return target?.kind === kind ? target.id : null;
-    }
-    return {
-        getPageTree: (o) => {
-            const locale = localeOf(o);
-            return run(["pageTree", locale], [pagesTreeTag()], (draft) => site.getPagesTree({ locale, draft }));
-        },
-        async getPage(pathOrId, o) {
-            const locale = localeOf(o);
-            const id = await idOf("page", locale, pathOrId);
-            if (!id)
-                return null;
-            return run(["page", locale, pathOrId], [pageTag(id)], (draft) => site.getPage(pathOrId, { locale, draft }));
-        },
-        getEntries: (collection, o = {}) => {
-            const locale = localeOf(o);
-            const { locale: _locale, ...query } = o;
-            // The unit also depends on every collection its references resolve into (spec 2026-09-29 content API contract §6).
-            const schema = collectionByName.get(collection);
-            const tags = [collection, ...(schema ? referencedCollections(schema, [...options.collections]) : [])];
-            return run(["entries", collection, locale, entriesKey(o)], [...new Set(tags)].map(collectionTag), (draft) => site.getEntries(collection, { ...query, locale, draft }));
-        },
-        async getEntry(collection, idOrPath, o) {
-            const locale = localeOf(o);
-            const id = await idOf("entry", locale, idOrPath);
-            if (!id)
-                return null;
-            return run(["entry", collection, locale, idOrPath], [entryTag(id)], async (draft) => {
-                const hit = await site.getEntry(collection, idOrPath, { locale, draft });
-                // The site layer also answers a bare root slug, but the unit would sit under
-                // a tag no op ever fires — so a slug is refused here rather than cached stale.
-                if (hit && !idOrPath.startsWith("/") && hit.id !== idOrPath) {
-                    throw new Error(`smoodly: getEntry("${collection}", "${idOrPath}") takes an id or a path — for a slug, pass the entry's path.`);
-                }
-                return hit;
-            });
-        },
-        async getGlobal(name, o) {
-            const locale = localeOf(o);
-            const item = globalByName.get(name);
-            if (!item)
-                throw new Error(`smoodly: no global item named "${name}".`);
-            return run(["global", name, locale], [globalTag(name)], (draft) => site.getGlobal(item, { locale, draft }));
-        },
-    };
+    return createQueries(options, nextReads);
 }

package/dist/next/reads.d.ts

@@ -0,0 +1,2 @@
+import type { ReadAdapter } from "../reads.ts";
+export declare const nextReads: ReadAdapter;

package/dist/next/reads.js

@@ -0,0 +1,18 @@
+// The read layer's adapter for Next (spec 2026-10-02 astro cloud fit §6): the one place in the Next glue
+// that knows where a read is cached. The gate is `connection()`, so a build prerenders nothing against
+// the database; inside draft mode a unit reads the live draft and touches no cache; outside it the
+// published read is one `unstable_cache` unit under the unit's key and tags, which the admin's
+// operations expire (revalidate.ts). Next's cache key is the callback's source text plus the key parts,
+// so every unit is cached from the one closure below (a unit's `tagsOf` is ignored: the tags go in before the read): a second call site would split a shared unit.
+import { unstable_cache } from "next/cache";
+import { draftMode } from "next/headers";
+import { connection } from "next/server";
+export const nextReads = {
+    gate: () => connection(),
+    async run(unit) {
+        const { isEnabled: draft } = await draftMode();
+        if (draft)
+            return unit.read(true);
+        return unstable_cache(() => unit.read(false), unit.key, { tags: unit.tags })();
+    },
+};

package/dist/page-context.d.ts

@@ -0,0 +1,89 @@
+import type { PageAlternate } from "./paths.ts";
+import type { StyleValues } from "./styles.ts";
+export type TreeNode = {
+    id: string;
+    type: string;
+    fields: Record<string, unknown>;
+    /** The developer's knobs (spec 2026-09-14 §3). */
+    settings?: Record<string, unknown>;
+    /** Smoodly's styles steps (spec 2026-09-14 §2); absent keys are Default. */
+    styles?: Record<string, unknown>;
+    /** The custom-CSS snippet (spec 2026-09-14 §4), scoped by the wrapper. */
+    css?: string;
+};
+/** `meta` is the page's own metadata (SEO title, description, og image).
+ * It rides inside the tree deliberately: trees are already JSONB in
+ * page_versions, so this needs no DDL change, and page meta becomes
+ * versioned with content — draft SEO edits stay unpublished, and publish
+ * moves content and meta together. */
+export type PageTree = {
+    zones: Record<string, TreeNode[]>;
+    meta?: Record<string, unknown>;
+    fields?: Record<string, unknown>;
+};
+/** Where a rendered page sits in the tree — what a view needs for
+ *  breadcrumbs and sub-navigation without a query (spec 2026-09-05 §5).
+ *  `path` is the locale-relative CMS path (what the content API returns);
+ *  `url` is that path through the app's `href` seam — `/fi/yritys` under
+ *  next-intl, `/yritys` without it — so a page shape links the same way
+ *  in both layouts. `fields` is the linked page's own page fields (spec
+ *  2026-09-10 page fields §3): the published tree's outside draft mode,
+ *  raw (no asset resolution), defaults applied, `{}` for a folder. */
+export type PageLink = {
+    title: string;
+    path: string;
+    hasPage: boolean;
+    fields: Record<string, unknown>;
+};
+export type PageContextLink = PageLink & {
+    url: string;
+};
+/** The page's address in one other locale, `url` through the app's href seam (spec 2026-09-15 §3). */
+export type PageContextAlternate = PageAlternate & {
+    url: string;
+};
+export type PageContext<Fields = Record<string, unknown>> = {
+    id: string;
+    title: string;
+    path: string;
+    url: string;
+    /** The locale the page was rendered in. */
+    locale: string;
+    /** The page's own fields, typed from its schema on the view; resolved, defaults applied. */
+    fields: Fields;
+    /** Root first, parent last. */
+    ancestors: ReadonlyArray<PageContextLink>;
+    children: ReadonlyArray<PageContextLink>;
+    /** One key per supported locale: the page's `{ slug, path, url }` there, or null where it is
+     *  absent or unpublished (draft mode: absent only). What a language switch links to. */
+    locales: Readonly<Record<string, PageContextAlternate | null>>;
+};
+/** The `page` prop of a view rendered outside the site (a test, a preview
+ *  of a shape): a real object, so a view never guards an optional prop, but
+ *  no position in the tree. Frozen: one singleton shared by every such
+ *  render, so a view that pushed onto it would leak into the next. */
+export declare const EMPTY_PAGE_CONTEXT: PageContext;
+/** A paired view as the render layer sees it: anything carrying its schema's name. React's `renderPage` narrows it. */
+export type PairedLike = {
+    schema: {
+        name: string;
+        title?: string;
+    };
+};
+/** The adapter's canvas net (spec 2026-09-27 section guard §5): called per section, in editor mode only.
+ *  Framework-neutral: `child` and the return are the framework's node type (React: ReactNode). */
+export type EditorWrap = (child: unknown, section: {
+    id: string;
+    title: string;
+}) => unknown;
+export type ZoneContent = {
+    readonly name: string;
+    readonly nodes: TreeNode[];
+    readonly components: ReadonlyMap<string, PairedLike>;
+    /** The config's CSS values behind the styles set (spec 2026-09-14 §2). */
+    readonly styleValues: StyleValues;
+    readonly editor: boolean;
+    /** Control flow the guard must let through — the adapter's (Next: unstable_rethrow; spec 2026-09-27 section guard §2). */
+    readonly rethrow?: (error: unknown) => void;
+    readonly editorWrap?: EditorWrap;
+};

package/dist/page-context.js

@@ -0,0 +1,8 @@
+/** The `page` prop of a view rendered outside the site (a test, a preview
+ *  of a shape): a real object, so a view never guards an optional prop, but
+ *  no position in the tree. Frozen: one singleton shared by every such
+ *  render, so a view that pushed onto it would leak into the next. */
+export const EMPTY_PAGE_CONTEXT = Object.freeze({
+    id: "", title: "", path: "/", url: "/", locale: "", fields: Object.freeze({}), ancestors: Object.freeze([]), children: Object.freeze([]),
+    locales: Object.freeze({}),
+});

package/dist/pairing.d.ts

@@ -1,27 +1,8 @@
 import type { ComponentType, ReactElement } from "react";
 import type { BuilderMap, ElementSchema, SectionSchema, Values } from "./schema.ts";
-import type { PageContext, ZoneContent } from "./render.tsx";
+import type { Props } from "./view-props.ts";
 import type { StyleProps } from "./styles.ts";
-/** What the view receives. A page view gets its zones and where it sits
- * in the tree; a section/element view gets field values flat, settings
- * complete (defaults filled) and Smoodly's styles steps as stored (Default
- * stores nothing — spec 2026-09-14 §2). The page branch keys on `kind` — an
- * optional-only check would match section schemas too, since a type
- * lacking `__zones` still extends `{ __zones?: X }`. */
-export type Props<S> = S extends {
-    kind: "page";
-    __zones?: infer Z extends Record<string, unknown>;
-    __fields?: infer F extends BuilderMap;
-} ? {
-    zones: Record<keyof Z & string, ZoneContent>;
-    page: PageContext<Values<F>>;
-} : S extends {
-    __f?: infer F extends BuilderMap;
-    __s?: infer St extends BuilderMap;
-} ? Values<F> & {
-    settings: Values<St>;
-    styles: StyleProps;
-} : never;
+export type { Props };
 /** What hard-coded JSX may pass: fields flat, settings optional and partial, styles optional. */
 type ExternalProps<F extends BuilderMap, St extends BuilderMap> = Values<F> & {
     settings?: Partial<Values<St>>;
@@ -38,4 +19,3 @@ export declare function element<F extends BuilderMap, St extends BuilderMap>(sch
     settings: Values<St>;
     styles: StyleProps;
 }>): PairedComponent<ElementSchema<F, St>, F, St>;
-export {};

package/dist/project.d.ts

@@ -0,0 +1,69 @@
+import type { Assembler } from "./assemble.ts";
+import type { CollectionSchema } from "./collections.ts";
+import type { EntryStore } from "./entry-store.ts";
+import type { GlobalSchema } from "./global.ts";
+import type { LocaleSet } from "./paths.ts";
+import type { PublishedKey, PublishedStore } from "./published.ts";
+import { type SectionLike } from "./refs.ts";
+import type { SiteEntry, SitePage } from "./site.ts";
+import type { PageStore } from "./store.ts";
+/** The documents one projection writes before the rest are left to heal on read (§2). */
+export declare const PROJECTION_CAP = 100;
+/** `cap` overrides the projector's own for one call: a rebuild passes Infinity, a test a small number. */
+export type ProjectOptions = {
+    cap?: number;
+};
+export type Projector = {
+    /** Writes the delivery rows of these pages in every supported locale (a row per visible locale, removed where not visible). Returns the keys it could not fit under the cap, already marked stale. */
+    pages(ids: string[], options?: ProjectOptions): Promise<PublishedKey[]>;
+    /** The same for entries and globals, by id (the collection is found through the registry). */
+    entries(ids: string[], options?: ProjectOptions): Promise<PublishedKey[]>;
+    /** One page document, one locale, written now: what heal-on-read calls. `seen`: the caller read a row for it,
+     *  so a target no longer visible has a row to remove; without one nothing is written. The write is best effort:
+     *  a failed put or remove is logged and the assembled document is served all the same. */
+    healPage(id: string, locale: string, options?: HealOptions): Promise<SitePage | null>;
+    healEntry(id: string, locale: string, options?: HealOptions): Promise<SiteEntry | null>;
+    healGlobal<V>(item: GlobalSchema<V>, locale: string, options?: HealOptions): Promise<V | null>;
+    /** Flags rows to rebuild on their next read: what an op does with the targets of a projection that threw. */
+    markStale(keys: PublishedKey[]): Promise<void>;
+};
+export type HealOptions = {
+    seen?: boolean;
+};
+export type ProjectorDeps = {
+    assembler: Assembler;
+    stores: () => {
+        pages: PageStore;
+        entries: EntryStore;
+        published: PublishedStore;
+    };
+    collections: CollectionSchema<any>[];
+    globals: GlobalSchema[];
+    /** The ref walk behind a page row's tags. */
+    sections: SectionLike[];
+    elements?: SectionLike[];
+    locales: LocaleSet;
+    /** The fingerprint a row is current against: the site's cacheKey (§4). */
+    model: string;
+    cap?: number;
+};
+export declare function createProjector(deps: ProjectorDeps): Projector;
+export type ProjectAllDeps = {
+    stores: {
+        pages: PageStore;
+        entries: EntryStore;
+    };
+    projector: Projector;
+    /** Every registered collection's and global's name: the entries are listed per name. */
+    names: string[];
+    /** Ids per batch; each batch is written whole, past the projector's cap. */
+    cap?: number;
+};
+/** The rebuild (spec 2026-10-07 delivery model §2): every page and entry of the space projected, in batches of
+ *  `cap` ids, none left stale. Import ends with it, and `smoodly rebuild` is it. The counts are the pages and the
+ *  entries (globals included) published in some locale; `stale` is what a batch could not write, 0 by design. */
+export declare function projectAll(deps: ProjectAllDeps): Promise<{
+    pages: number;
+    entries: number;
+    stale: number;
+}>;

package/dist/project.js

@@ -0,0 +1,210 @@
+import { ASSET_COLLECTION } from "./media.js";
+import { collectEntryRefs, collectTreeRefs } from "./refs.js";
+import { collectionTag, entryTag, globalTag, pageTag } from "./revalidate.js";
+/** The documents one projection writes before the rest are left to heal on read (§2). */
+export const PROJECTION_CAP = 100;
+/** The entry ids a document depends on (media is not an entry). */
+const entryTags = (edges) => edges.filter((e) => e.targetCollection !== ASSET_COLLECTION).map((e) => entryTag(e.targetId));
+const unique = (tags) => [...new Set(tags)];
+/** A heal's write is derived and the visitor's read must not fail on it (spec §2 Failure): logged, not thrown. */
+async function bestEffort(what, write) {
+    try {
+        await write();
+    }
+    catch (e) {
+        console.error(`smoodly: ${what} in the delivery tables failed; the next read rebuilds it.`, e);
+    }
+}
+export function createProjector(deps) {
+    const { assembler, collections, globals, locales, model } = deps;
+    const cap = deps.cap ?? PROJECTION_CAP;
+    const isGlobal = (schema) => schema.kind === "global";
+    /** The page's row in the locale, or null where the public does not see it (absent, or an unpublished page). */
+    async function pageRow(a, record, all, locale) {
+        const row = record.locales[locale];
+        if (!row || (record.template !== null && row.status !== "published"))
+            return null;
+        const light = await a.treeRow(record, all, locale);
+        // A folder is a row without a document. A page the tree hides (path null) keeps one at its live address, which
+        // the address lookup never reaches but a locate can (a record at a code address): the read takes it by id then.
+        const path = light.hasPage ? light.path ?? (await deps.stores().pages.pathsOf(record.id))[locale] ?? null : null;
+        const document = path !== null ? await a.page(record.id, locale, path, { draft: false }) : null;
+        const raw = document ? await deps.stores().pages.getPublishedTree(record.id, locale) : null;
+        const refs = raw ? entryTags(collectTreeRefs(raw, deps.sections, deps.elements)) : [];
+        return {
+            ...light, document,
+            tags: unique([pageTag(record.id), ...refs]),
+            model, stale: false, publishedAt: Date.now(),
+        };
+    }
+    /** The schema an entry id belongs to, and its record: one `get` per registered collection until found. */
+    async function findEntry(id) {
+        const { entries } = deps.stores();
+        for (const schema of [...collections, ...globals]) {
+            const record = await entries.get(schema.name, id);
+            if (record)
+                return { schema, record };
+        }
+        return null;
+    }
+    /** The entry's or global's row in the locale, or null where it is not published. A collection
+     *  without a `path` gets a document too (its list items), with `path` null. */
+    async function entryRow(a, schema, record, locale) {
+        const row = record.locales[locale];
+        if (!row || row.status !== "published")
+            return null;
+        const { entries } = deps.stores();
+        const fields = (await entries.getMany(schema.name, [record.id], locale, { status: "published" }))[record.id];
+        if (!fields)
+            return null;
+        let document;
+        let path = null;
+        if (isGlobal(schema)) {
+            document = await a.global(schema, locale, { draft: false });
+        }
+        else {
+            path = schema.path !== undefined ? (await entries.pathsOf(schema.name, record.id))[locale] ?? null : null;
+            if (path !== null) {
+                document = await a.entry(record.id, locale, path, { draft: false });
+            }
+            else {
+                // The list item is all an address-less entry serves: the same projection getEntries makes.
+                const [read] = await a.entries(schema.name, { locale, ids: [record.id] });
+                document = read && {
+                    kind: "entry", locale, collection: schema.name, entry: { ...read.record, fields: read.item.fields },
+                    path: null, locales: read.item.locales, ...(read.item.seo ? { seo: read.item.seo } : {}),
+                };
+            }
+        }
+        if (document == null)
+            return null;
+        return {
+            id: record.id, locale, collection: schema.name, parentId: record.parentId, sort: record.sort, slug: row.slug, path,
+            createdAt: record.createdAt, updatedAt: row.updatedAt, fields, document,
+            tags: unique([
+                entryTag(record.id), collectionTag(schema.name), ...(isGlobal(schema) ? [globalTag(schema.name)] : []),
+                ...entryTags(collectEntryRefs(fields, schema, deps.elements)),
+            ]),
+            model, stale: false, publishedAt: Date.now(),
+        };
+    }
+    /** Builds rows for each (id, locale) until the cap; the rest are marked stale and returned. */
+    async function project(cap, kind, targets, idOf, build, put) {
+        const { published } = deps.stores();
+        const rows = [];
+        const gone = [];
+        const over = [];
+        for (const t of targets) {
+            for (const locale of locales.supported) {
+                if (rows.length >= cap) {
+                    over.push({ kind, id: idOf(t), locale });
+                    continue;
+                }
+                const row = await build(t, locale);
+                if (row)
+                    rows.push(row);
+                else
+                    gone.push({ kind, id: idOf(t), locale });
+            }
+        }
+        if (rows.length > 0)
+            await put(rows);
+        if (gone.length > 0)
+            await published.remove(gone);
+        if (over.length > 0)
+            await published.markStale(over);
+        return over;
+    }
+    return {
+        async pages(ids, options) {
+            const all = await deps.stores().pages.listPages();
+            const a = assembler.batch({ pages: all });
+            const byId = new Map(all.map((p) => [p.id, p]));
+            // A page no longer in the tree has no row in any locale.
+            const missing = ids.filter((id) => !byId.has(id));
+            if (missing.length > 0)
+                await deps.stores().published.remove(missing.map((id) => ({ kind: "page", id })));
+            return project(options?.cap ?? cap, "page", ids.filter((id) => byId.has(id)).map((id) => byId.get(id)), (p) => p.id, (p, locale) => pageRow(a, p, all, locale), (rows) => deps.stores().published.putPages(rows));
+        },
+        async entries(ids, options) {
+            const a = assembler.batch();
+            const found = [];
+            const missing = [];
+            for (const id of ids) {
+                const hit = await findEntry(id);
+                if (hit)
+                    found.push(hit);
+                else
+                    missing.push({ kind: "entry", id });
+            }
+            if (missing.length > 0)
+                await deps.stores().published.remove(missing);
+            return project(options?.cap ?? cap, "entry", found, (h) => h.record.id, (h, locale) => entryRow(a, h.schema, h.record, locale), (rows) => deps.stores().published.putEntries(rows));
+        },
+        async healPage(id, locale, options) {
+            const { pages, published } = deps.stores();
+            // One record first: a page the public does not see in the locale costs no table read.
+            const record = await pages.getPage(id);
+            const row = record?.locales[locale];
+            const visible = row !== undefined && (record.template === null || row.status === "published");
+            const all = visible ? await pages.listPages() : [];
+            const projected = visible ? await pageRow(assembler.batch({ pages: all }), record, all, locale) : null;
+            if (!projected) {
+                if (options?.seen !== false)
+                    await bestEffort(`removing page ${id} (${locale})`, () => published.remove([{ kind: "page", id, locale }]));
+                return null;
+            }
+            await bestEffort(`writing page ${id} (${locale})`, () => published.putPages([projected]));
+            return projected.document;
+        },
+        async healEntry(id, locale, options) {
+            const { published } = deps.stores();
+            const hit = await findEntry(id);
+            const row = hit ? await entryRow(assembler.batch(), hit.schema, hit.record, locale) : null;
+            if (!row) {
+                if (options?.seen !== false)
+                    await bestEffort(`removing entry ${id} (${locale})`, () => published.remove([{ kind: "entry", id, locale }]));
+                return null;
+            }
+            await bestEffort(`writing entry ${id} (${locale})`, () => published.putEntries([row]));
+            return row.document;
+        },
+        async healGlobal(item, locale, options) {
+            const { entries, published } = deps.stores();
+            const [record] = await entries.list(item.name);
+            if (!record)
+                return null;
+            const row = await entryRow(assembler.batch(), item, record, locale);
+            if (!row) {
+                if (options?.seen !== false)
+                    await bestEffort(`removing global ${item.name} (${locale})`, () => published.remove([{ kind: "entry", id: record.id, locale }]));
+                return null;
+            }
+            await bestEffort(`writing global ${item.name} (${locale})`, () => published.putEntries([row]));
+            return row.document;
+        },
+        markStale: (keys) => deps.stores().published.markStale(keys),
+    };
+}
+/** The rebuild (spec 2026-10-07 delivery model §2): every page and entry of the space projected, in batches of
+ *  `cap` ids, none left stale. Import ends with it, and `smoodly rebuild` is it. The counts are the pages and the
+ *  entries (globals included) published in some locale; `stale` is what a batch could not write, 0 by design. */
+export async function projectAll(deps) {
+    const size = deps.cap ?? PROJECTION_CAP;
+    const whole = { cap: Infinity };
+    const published = (r) => Object.values(r.locales).some((l) => l?.status === "published");
+    let stale = 0;
+    const pages = await deps.stores.pages.listPages();
+    for (let i = 0; i < pages.length; i += size) {
+        stale += (await deps.projector.pages(pages.slice(i, i + size).map((p) => p.id), whole)).length;
+    }
+    const entries = (await Promise.all(deps.names.map((name) => deps.stores.entries.list(name)))).flat();
+    for (let i = 0; i < entries.length; i += size) {
+        stale += (await deps.projector.entries(entries.slice(i, i + size).map((e) => e.id), whole)).length;
+    }
+    return {
+        pages: pages.filter((p) => p.template !== null && published(p)).length,
+        entries: entries.filter(published).length,
+        stale,
+    };
+}

package/dist/published.d.ts

@@ -0,0 +1,96 @@
+import type { EntryOrder } from "./collections.ts";
+import { type Where } from "./entry-store.ts";
+import type { SiteEntry, SitePage } from "./site.ts";
+/** A page's delivery row: a published page, or a folder present in the locale (document null, hasPage false). */
+export type PublishedPageRow = {
+    id: string;
+    locale: string;
+    parentId: string | null;
+    sort: number | null;
+    /** The served address; null when the tree hides the node (no path, or a code address wins). */
+    path: string | null;
+    title: string;
+    hasPage: boolean;
+    /** The page fields with defaults, raw (no asset resolution): what a tree item and a link show. */
+    linkFields: Record<string, unknown>;
+    document: SitePage | null;
+    tags: string[];
+    model: string;
+    stale: boolean;
+    publishedAt: number;
+};
+/** An entry's or a global's delivery row. A global's `document` is the value `getGlobal` returns; its collection is the item's name. */
+export type PublishedEntryRow = {
+    id: string;
+    locale: string;
+    collection: string;
+    parentId: string | null;
+    sort: number | null;
+    slug: string | null;
+    path: string | null;
+    createdAt: number;
+    updatedAt: number;
+    /** The published snapshot, raw, slug included: what `where` and `order` read. */
+    fields: Record<string, unknown>;
+    document: SiteEntry | unknown;
+    tags: string[];
+    model: string;
+    stale: boolean;
+    publishedAt: number;
+};
+/** `globals`: present when the lookup asked for global items by name — the locale's rows of those collections,
+ *  as `entries` returns them (document, model, stale; the raw fields may be empty), so a page is one call. */
+export type PublishedRoute = ({
+    kind: "page";
+    row: PublishedPageRow;
+} | {
+    kind: "entry";
+    row: PublishedEntryRow;
+}) & {
+    globals?: PublishedEntryRow[];
+};
+/** `model` and `stale` ride along so a tree read can rebuild what is behind before answering (spec 2026-10-07 §4). */
+export type PublishedTreeRow = Pick<PublishedPageRow, "id" | "parentId" | "sort" | "path" | "title" | "hasPage" | "linkFields" | "model" | "stale">;
+export type PublishedQuery = {
+    locale: string;
+    where?: Where;
+    order?: EntryOrder;
+    limit?: number;
+    parent?: string | null;
+    ids?: string[];
+};
+export type PublishedKey = {
+    kind: "page" | "entry";
+    id: string;
+    locale?: string;
+};
+export interface PublishedStore {
+    /** Upsert by (id, locale). */
+    putPages(rows: PublishedPageRow[]): Promise<void>;
+    putEntries(rows: PublishedEntryRow[]): Promise<void>;
+    /** Every locale of the id when `locale` is absent. */
+    remove(keys: PublishedKey[]): Promise<void>;
+    /** The one-call lookup: a reachable page or entry at the address, else null. With `globals` (collection names of
+     *  global items), the locale's rows of those collections come along on the route (schema v9), still one call. */
+    byAddress(locale: string, path: string, globals?: readonly string[]): Promise<PublishedRoute | null>;
+    page(id: string, locale: string): Promise<PublishedPageRow | null>;
+    entry(id: string, locale: string): Promise<PublishedEntryRow | null>;
+    /** Filtered, ordered and limited over `fields`, in the store (SQL or the memory matcher). */
+    entries(collection: string, q: PublishedQuery): Promise<PublishedEntryRow[]>;
+    /** The light columns of every row in the locale, with the model and stale flag, in tree order (sort asc nulls last, published, id). */
+    tree(locale: string): Promise<PublishedTreeRow[]>;
+    markStale(keys: PublishedKey[]): Promise<void>;
+}
+export declare class MemoryPublishedStore implements PublishedStore {
+    private pages;
+    private entryRows;
+    putPages(rows: PublishedPageRow[]): Promise<void>;
+    putEntries(rows: PublishedEntryRow[]): Promise<void>;
+    remove(keys: PublishedKey[]): Promise<void>;
+    byAddress(locale: string, path: string, globals?: readonly string[]): Promise<PublishedRoute | null>;
+    page(id: string, locale: string): Promise<PublishedPageRow | null>;
+    entry(id: string, locale: string): Promise<PublishedEntryRow | null>;
+    entries(collection: string, q: PublishedQuery): Promise<PublishedEntryRow[]>;
+    tree(locale: string): Promise<PublishedTreeRow[]>;
+    markStale(keys: PublishedKey[]): Promise<void>;
+}