smoodly 0.0.4 → 0.0.6

package/dist/entry-store.d.ts

@@ -1,11 +1,16 @@
-import type { CollectionSchema } from "./collections.ts";
+import type { CollectionSchema, EntryOrder } from "./collections.ts";
 import { MemoryRefIndex } from "./ref-index.ts";
+import { type PathIndex } from "./path-index.ts";
+import { type LocaleSet, type PathTarget } from "./paths.ts";
 export type EntryRecord = {
     id: string;
     collection: string;
+    parentId: string | null;
     fields: Record<string, unknown>;
+    i18n: Record<string, Record<string, unknown>> | null;
     status: "draft" | "published";
     sort: number | null;
+    locales: string[] | null;
     createdAt: number;
     updatedAt: number;
 };
@@ -15,12 +20,26 @@ export type EntryUsage = {
     sourceField: string;
 };
 export type ListOptions = {
-    /** "created" (default): oldest first. "updated": recent first. "manual": sort asc. */
-    order?: "created" | "updated" | "manual";
+    /** Absent = the collection's configured order (config); `"manual"` sorts by `sort` asc. */
+    order?: EntryOrder;
     status?: "published";
+    /**
+     * `null` lists roots; a string id lists that parent's children; omitted
+     * (or explicitly `undefined`) applies no parent filter — everything in
+     * the collection, at every depth.
+     */
+    parent?: string | null;
+};
+export type CreateEntryOptions = {
+    parentId?: string | null;
+    locales?: string[] | null;
+};
+export type EntryStoreOptions = {
+    paths?: PathIndex;
+    locales?: LocaleSet;
 };
 export interface EntryStore {
-    create(collection: string, fields: Record<string, unknown>): Promise<EntryRecord>;
+    create(collection: string, fields: Record<string, unknown>, options?: CreateEntryOptions): Promise<EntryRecord>;
     get(collection: string, id: string): Promise<EntryRecord | null>;
     list(collection: string, options?: ListOptions): Promise<EntryRecord[]>;
     /** Batched read for the resolver: fields keyed by id, missing ids omitted.
@@ -33,8 +52,22 @@ export interface EntryStore {
     }): Promise<Record<string, Record<string, unknown>>>;
     update(collection: string, id: string, fields: Record<string, unknown>): Promise<EntryRecord>;
     setStatus(collection: string, id: string, status: "draft" | "published"): Promise<EntryRecord>;
-    /** Blocked while anything references the entry (the safe-delete guard). */
+    /** Blocked while anything references the entry (the safe-delete guard),
+     * and while it still has child entries. */
     delete(collection: string, id: string): Promise<void>;
+    /**
+     * Reparents `id` under `to.parentId`. `to.index` is the moved entry's
+     * final 0-based position among the destination siblings: the entry is
+     * removed from the sibling list first, then spliced back in at `index`.
+     * Omitted, it appends; out-of-range values clamp to [0, siblings.length].
+     * Destination siblings are renumbered 1..N afterward. Like `reorder`,
+     * `move` does NOT bump `updatedAt` — reparenting/resequencing is a
+     * structure change, not an edit to the entry's content.
+     */
+    move(collection: string, id: string, to: {
+        parentId: string | null;
+        index?: number;
+    }): Promise<EntryRecord>;
     /** Rewrite manual order to 1..N for the given ids, one batched pass. */
     reorder(collection: string, orderedIds: string[]): Promise<void>;
     /** The refs index's reverse question: who points at this entry? */
@@ -45,18 +78,66 @@ export interface EntryStore {
         sourceKind: string;
         sourceId: string;
     }[]>;
+    resolvePath(locale: string, path: string): Promise<PathTarget | null>;
+    pathsOf(collection: string, id: string): Promise<Record<string, string>>;
 }
 export declare function schemaOf(collections: CollectionSchema<any>[], name: string): CollectionSchema<any>;
+export declare const DEFAULT_ENTRY_LOCALES: LocaleSet;
+export declare const entryErrors: {
+    notFound: (collection: string, id: string) => Error;
+    hasChildren: (collection: string, id: string) => Error;
+    cycle: () => Error;
+    foreignParent: () => Error;
+    /** Entry slugs are unique among SIBLINGS (DESIGN.md §3, decided
+     *  2026-09-05): the same rule pages have, since the URL is the tree.
+     *  ONE source for the text — the Supabase adapter maps its
+     *  entries_sibling_slug_key 23505 onto this same error. */
+    slugTaken: (collection: string) => Error;
+};
+/**
+ * Sort comparator for one order rule; `seq` breaks ties by creation.
+ *
+ * Nulls sort last in BOTH directions (the Supabase adapter must use
+ * `nullsFirst: false` to match). The creation tiebreak follows `direction`
+ * for non-manual orders — two entries created in the same millisecond
+ * must still land newest-first under the default order, not oldest-first
+ * — while the manual branch's tiebreak stays ascending (creation order
+ * is the natural fallback for otherwise-unordered `sort` values).
+ * Declared fields compare numerically when both values are numbers,
+ * otherwise as strings via `localeCompare`. The Supabase adapter orders
+ * by the jsonb VALUE (`fields->x`, decided 2026-09-05), so the two agree
+ * for a field holding numbers and for one holding strings (ISO dates
+ * included). Two edges still differ: MIXED types in one field — Postgres
+ * orders jsonb by type first (null < string < number < boolean < array <
+ * object) rather than by `String(...)` — and an explicit JSON `null`
+ * VALUE, which is a jsonb null and sorts FIRST in Postgres but last here
+ * (a MISSING key is SQL NULL and does sort last, matching). See the
+ * package README's follow-ups.
+ */
+export declare function compareEntries(order: EntryOrder, seq: (e: EntryRecord) => number): (a: EntryRecord, b: EntryRecord) => number;
 export declare class MemoryEntryStore implements EntryStore {
     private collections;
     private refs;
     private entries;
     private seq;
     private order;
-    constructor(collections: CollectionSchema<any>[], refs?: MemoryRefIndex);
+    private paths;
+    private locales;
+    constructor(collections: CollectionSchema<any>[], refs?: MemoryRefIndex, options?: EntryStoreOptions);
     private row;
+    private must;
+    private byId;
+    private subtree;
+    private writePaths;
     private writeRefs;
-    create(collection: string, fields: Record<string, unknown>): Promise<EntryRecord>;
+    private siblings;
+    /** The memory mirror of entries_sibling_slug_key: a string slug must be
+     *  unique among the entries sharing a parent. An absent, null or empty
+     *  slug claims no URL and never conflicts (the index's partial
+     *  predicate folds "" to null too via nullif). */
+    private assertSiblingSlug;
+    private assertParent;
+    create(collection: string, fields: Record<string, unknown>, options?: CreateEntryOptions): Promise<EntryRecord>;
     get(collection: string, id: string): Promise<EntryRecord | null>;
     list(collection: string, options?: ListOptions): Promise<EntryRecord[]>;
     getMany(collection: string, ids: string[], options?: {
@@ -64,6 +145,10 @@ export declare class MemoryEntryStore implements EntryStore {
     }): Promise<Record<string, Record<string, unknown>>>;
     update(collection: string, id: string, fields: Record<string, unknown>): Promise<EntryRecord>;
     setStatus(collection: string, id: string, status: "draft" | "published"): Promise<EntryRecord>;
+    move(collection: string, id: string, to: {
+        parentId: string | null;
+        index?: number;
+    }): Promise<EntryRecord>;
     delete(collection: string, id: string): Promise<void>;
     reorder(collection: string, orderedIds: string[]): Promise<void>;
     referencesTo(collection: string, id: string): Promise<EntryUsage[]>;
@@ -71,4 +156,6 @@ export declare class MemoryEntryStore implements EntryStore {
         sourceKind: string;
         sourceId: string;
     }[]>;
+    resolvePath(locale: string, path: string): Promise<PathTarget | null>;
+    pathsOf(collection: string, id: string): Promise<{}>;
 }

package/dist/entry-store.js

@@ -6,8 +6,11 @@
 // versioning in v1 (DESIGN.md §3). Reorder rewrites sort 1..N in one
 // pass and NEVER touches updatedAt — order is a property of the
 // collection, not an edit to its entries.
+import { collectionDepth, collectionOrder } from "./collections.js";
 import { collectEntryRefs } from "./refs.js";
 import { MemoryRefIndex } from "./ref-index.js";
+import { MemoryPathIndex } from "./path-index.js";
+import { assertDepth, chainOf, entryPathRows, slugOf } from "./paths.js";
 export function schemaOf(collections, name) {
     const schema = collections.find((c) => c.name === name);
     if (!schema)
@@ -16,38 +19,150 @@ export function schemaOf(collections, name) {
 }
 let counter = 0;
 const uid = () => `entry-${++counter}-${Date.now().toString(36)}`;
+export const DEFAULT_ENTRY_LOCALES = { default: "en", supported: ["en"] };
+export const entryErrors = {
+    notFound: (collection, id) => new Error(`smoodly: no entry "${id}" in "${collection}".`),
+    hasChildren: (collection, id) => new Error(`smoodly: "${collection}/${id}" has child entries — move or delete them first.`),
+    cycle: () => new Error("smoodly: an entry cannot be moved under itself."),
+    foreignParent: () => new Error("smoodly: the parent of an entry must be in the same collection."),
+    /** Entry slugs are unique among SIBLINGS (DESIGN.md §3, decided
+     *  2026-09-05): the same rule pages have, since the URL is the tree.
+     *  ONE source for the text — the Supabase adapter maps its
+     *  entries_sibling_slug_key 23505 onto this same error. */
+    slugTaken: (collection) => new Error(`smoodly: a "${collection}" entry with that slug already exists under this parent.`),
+};
+/**
+ * Sort comparator for one order rule; `seq` breaks ties by creation.
+ *
+ * Nulls sort last in BOTH directions (the Supabase adapter must use
+ * `nullsFirst: false` to match). The creation tiebreak follows `direction`
+ * for non-manual orders — two entries created in the same millisecond
+ * must still land newest-first under the default order, not oldest-first
+ * — while the manual branch's tiebreak stays ascending (creation order
+ * is the natural fallback for otherwise-unordered `sort` values).
+ * Declared fields compare numerically when both values are numbers,
+ * otherwise as strings via `localeCompare`. The Supabase adapter orders
+ * by the jsonb VALUE (`fields->x`, decided 2026-09-05), so the two agree
+ * for a field holding numbers and for one holding strings (ISO dates
+ * included). Two edges still differ: MIXED types in one field — Postgres
+ * orders jsonb by type first (null < string < number < boolean < array <
+ * object) rather than by `String(...)` — and an explicit JSON `null`
+ * VALUE, which is a jsonb null and sorts FIRST in Postgres but last here
+ * (a MISSING key is SQL NULL and does sort last, matching). See the
+ * package README's follow-ups.
+ */
+export function compareEntries(order, seq) {
+    return (a, b) => {
+        if (order === "manual") {
+            const d = (a.sort ?? Infinity) - (b.sort ?? Infinity);
+            return d !== 0 ? d : seq(a) - seq(b);
+        }
+        const dir = order.direction === "asc" ? 1 : -1;
+        const value = (e) => order.by === "createdAt" ? e.createdAt : order.by === "updatedAt" ? e.updatedAt : e.fields[order.by];
+        const va = value(a), vb = value(b);
+        if (va == null && vb == null)
+            return (seq(a) - seq(b)) * dir;
+        if (va == null)
+            return 1;
+        if (vb == null)
+            return -1;
+        const d = typeof va === "number" && typeof vb === "number" ? va - vb : String(va).localeCompare(String(vb));
+        return d !== 0 ? d * dir : (seq(a) - seq(b)) * dir;
+    };
+}
 export class MemoryEntryStore {
     constructor(collections, 
     // pass the SAME index to MemoryPageStore so cross-kind questions work
-    refs = new MemoryRefIndex()) {
+    refs = new MemoryRefIndex(), options = {}) {
         this.collections = collections;
         this.refs = refs;
         this.entries = new Map();
         this.seq = 0; // creation-order tiebreak (Date.now can tie)
         this.order = new Map();
+        this.byId = (id) => this.entries.get(id);
+        this.paths = options.paths ?? new MemoryPathIndex();
+        this.locales = options.locales ?? DEFAULT_ENTRY_LOCALES;
     }
     row(collection, id) {
         const entry = this.entries.get(id);
         return entry && entry.collection === collection ? entry : null;
     }
+    must(collection, id) {
+        const entry = this.row(collection, id);
+        if (!entry)
+            throw entryErrors.notFound(collection, id);
+        return entry;
+    }
+    subtree(entry) {
+        const out = [entry];
+        const walk = (parentId) => {
+            for (const e of this.entries.values())
+                if (e.parentId === parentId) {
+                    out.push(e);
+                    walk(e.id);
+                }
+        };
+        walk(entry.id);
+        return out;
+    }
+    async writePaths(collection, nodes) {
+        const schema = schemaOf(this.collections, collection);
+        await this.paths.rewrite(nodes.map((n) => ({ kind: "entry", id: n.id })), entryPathRows(nodes, this.byId, schema, this.locales));
+    }
     writeRefs(collection, id, fields) {
         const schema = schemaOf(this.collections, collection);
         this.refs.rewrite({ sourceKind: "entry", sourceId: id }, collectEntryRefs(fields, schema));
     }
-    async create(collection, fields) {
+    siblings(collection, parentId, except) {
+        return [...this.entries.values()]
+            .filter((e) => e.collection === collection && e.parentId === parentId && e.id !== except)
+            .sort(compareEntries("manual", (e) => this.order.get(e.id)));
+    }
+    /** The memory mirror of entries_sibling_slug_key: a string slug must be
+     *  unique among the entries sharing a parent. An absent, null or empty
+     *  slug claims no URL and never conflicts (the index's partial
+     *  predicate folds "" to null too via nullif). */
+    assertSiblingSlug(collection, parentId, fields, except) {
+        const slug = slugOf(fields);
+        if (slug === null)
+            return;
+        for (const e of this.siblings(collection, parentId, except)) {
+            if (slugOf(e.fields) === slug)
+                throw entryErrors.slugTaken(collection);
+        }
+    }
+    assertParent(collection, parentId, subtreeHeight) {
+        if (parentId === null)
+            return;
+        const parent = this.entries.get(parentId);
+        if (!parent)
+            throw entryErrors.notFound(collection, parentId);
+        if (parent.collection !== collection)
+            throw entryErrors.foreignParent();
+        assertDepth(chainOf(parent, this.byId).length + subtreeHeight, collectionDepth(schemaOf(this.collections, collection)), "the entry");
+    }
+    async create(collection, fields, options = {}) {
         schemaOf(this.collections, collection);
+        const parentId = options.parentId ?? null;
+        this.assertParent(collection, parentId, 1);
+        this.assertSiblingSlug(collection, parentId, fields);
         const now = Date.now();
         const entry = {
-            id: uid(),
-            collection,
-            fields: structuredClone(fields),
-            status: "draft",
-            sort: null,
-            createdAt: now,
-            updatedAt: now,
+            id: uid(), collection, parentId,
+            fields: structuredClone(fields), i18n: null,
+            status: "draft", sort: null, locales: options.locales ?? null,
+            createdAt: now, updatedAt: now,
         };
         this.entries.set(entry.id, entry);
         this.order.set(entry.id, ++this.seq);
+        try {
+            await this.writePaths(collection, [entry]);
+        }
+        catch (e) {
+            this.entries.delete(entry.id);
+            this.order.delete(entry.id);
+            throw e;
+        }
         this.writeRefs(collection, entry.id, fields);
         return structuredClone(entry);
     }
@@ -56,22 +171,13 @@ export class MemoryEntryStore {
         return entry ? structuredClone(entry) : null;
     }
     async list(collection, options) {
-        schemaOf(this.collections, collection);
+        const schema = schemaOf(this.collections, collection);
         let rows = [...this.entries.values()].filter((e) => e.collection === collection);
         if (options?.status)
             rows = rows.filter((e) => e.status === options.status);
-        const order = options?.order ?? "created";
-        rows.sort((a, b) => {
-            if (order === "updated")
-                return b.updatedAt - a.updatedAt;
-            if (order === "manual") {
-                const sa = a.sort ?? Infinity;
-                const sb = b.sort ?? Infinity;
-                if (sa !== sb)
-                    return sa - sb;
-            }
-            return this.order.get(a.id) - this.order.get(b.id);
-        });
+        if (options?.parent !== undefined)
+            rows = rows.filter((e) => e.parentId === options.parent);
+        rows.sort(compareEntries(options?.order ?? collectionOrder(schema), (e) => this.order.get(e.id)));
         return rows.map((e) => structuredClone(e));
     }
     async getMany(collection, ids, options) {
@@ -88,10 +194,17 @@ export class MemoryEntryStore {
         return out;
     }
     async update(collection, id, fields) {
-        const entry = this.row(collection, id);
-        if (!entry)
-            throw new Error(`smoodly: no entry "${id}" in "${collection}".`);
+        const entry = this.must(collection, id);
+        this.assertSiblingSlug(collection, entry.parentId, fields, id);
+        const before = entry.fields;
         entry.fields = structuredClone(fields);
+        try {
+            await this.writePaths(collection, this.subtree(entry));
+        }
+        catch (e) {
+            entry.fields = before;
+            throw e;
+        }
         entry.updatedAt = Date.now() > entry.updatedAt ? Date.now() : entry.updatedAt + 1;
         this.writeRefs(collection, id, fields);
         return structuredClone(entry);
@@ -99,19 +212,49 @@ export class MemoryEntryStore {
     async setStatus(collection, id, status) {
         const entry = this.row(collection, id);
         if (!entry)
-            throw new Error(`smoodly: no entry "${id}" in "${collection}".`);
+            throw entryErrors.notFound(collection, id);
         entry.status = status;
         entry.updatedAt = Date.now() > entry.updatedAt ? Date.now() : entry.updatedAt + 1;
         return structuredClone(entry);
     }
+    async move(collection, id, to) {
+        const entry = this.must(collection, id);
+        const subtree = this.subtree(entry);
+        if (to.parentId !== null && (to.parentId === id || subtree.some((e) => e.id === to.parentId)))
+            throw entryErrors.cycle();
+        const height = Math.max(...subtree.map((e) => chainOf(e, this.byId).length)) - chainOf(entry, this.byId).length + 1;
+        this.assertParent(collection, to.parentId, height);
+        if (to.parentId !== entry.parentId)
+            this.assertSiblingSlug(collection, to.parentId, entry.fields, id);
+        const before = { parentId: entry.parentId, sort: entry.sort };
+        entry.parentId = to.parentId;
+        const siblings = this.siblings(collection, to.parentId, id);
+        const index = Math.min(Math.max(to.index ?? siblings.length, 0), siblings.length);
+        siblings.splice(index, 0, entry);
+        const previous = new Map(siblings.map((s) => [s.id, s.sort]));
+        siblings.forEach((s, i) => (s.sort = i + 1));
+        try {
+            await this.writePaths(collection, subtree);
+        }
+        catch (e) {
+            Object.assign(entry, before);
+            for (const s of siblings)
+                s.sort = previous.get(s.id) ?? null;
+            throw e;
+        }
+        return structuredClone(entry);
+    }
     async delete(collection, id) {
         const entry = this.row(collection, id);
         if (!entry)
             return;
+        if ([...this.entries.values()].some((e) => e.parentId === id))
+            throw entryErrors.hasChildren(collection, id);
         const usage = await this.referencesTo(collection, id);
         if (usage.length > 0) {
             throw new Error(`smoodly: "${collection}/${id}" is referenced by ${usage.length} document(s) — remove those references first.`);
         }
+        await this.paths.remove([{ kind: "entry", id }]);
         this.entries.delete(id);
         this.refs.remove({ sourceKind: "entry", sourceId: id });
     }
@@ -129,4 +272,10 @@ export class MemoryEntryStore {
     async incoming(targetId) {
         return this.refs.incoming(targetId);
     }
+    resolvePath(locale, path) {
+        return this.paths.resolve(locale, path);
+    }
+    pathsOf(collection, id) {
+        return this.row(collection, id) ? this.paths.pathsOf({ kind: "entry", id }) : Promise.resolve({});
+    }
 }

package/dist/index.d.ts

@@ -2,9 +2,12 @@ import { section, element } from "./pairing.tsx";
 import { collection, toolset } from "./collections.ts";
 import { Section } from "./section-wrapper.tsx";
 import { page } from "./render.tsx";
-export { Zone, renderPage } from "./render.tsx";
-export type { PageTree, TreeNode, ZoneContent, PairedPage, Registry } from "./render.tsx";
+import { entryPage } from "./entry-page.tsx";
+export { Zone, renderPage, EMPTY_PAGE_CONTEXT } from "./render.tsx";
+export type { PageTree, TreeNode, ZoneContent, PairedPage, Registry, PageContext, PageContextLink, PageLink, PageViewProps } from "./render.tsx";
 export type { PageSchema } from "./page.ts";
+export { fixedSlug } from "./page.ts";
+export type { EntryPageSchema, PairedEntryPage, EntryPageProps } from "./entry-page.tsx";
 export { f } from "./fields.ts";
 export { z } from "./zones.ts";
 export { defineConfig } from "./config.ts";
@@ -14,18 +17,28 @@ export { SupabasePageStore } from "./supabase-store.ts";
 export { collectEntryRefs, collectTreeRefs } from "./refs.ts";
 export type { RefEdge, SectionLike } from "./refs.ts";
 export { MemoryRefIndex } from "./ref-index.ts";
+export { MemoryPathIndex } from "./path-index.ts";
+export type { PathIndex } from "./path-index.ts";
 export { MemoryEntryStore } from "./entry-store.ts";
 export { SupabaseEntryStore } from "./supabase-entry-store.ts";
-export type { EntryStore, EntryRecord, EntryUsage, ListOptions } from "./entry-store.ts";
-export { affectedPageSlugs } from "./revalidate.ts";
-export { resolveTree } from "./resolve.ts";
-export type { EntryFetcher } from "./resolve.ts";
-export type { PageStore, PageRecord, PageVersion, PageStoreOptions } from "./store.ts";
+export { SupabasePathIndex } from "./supabase-path-index.ts";
+export type { EntryStore, EntryRecord, EntryUsage, ListOptions, CreateEntryOptions, EntryStoreOptions } from "./entry-store.ts";
+export { entryErrors, compareEntries, DEFAULT_ENTRY_LOCALES } from "./entry-store.ts";
+export { affectedTargets, pageTag, entryTag } from "./revalidate.ts";
+export type { AffectedTargets } from "./revalidate.ts";
+export { resolveTree, resolveFields } from "./resolve.ts";
+export type { EntryFetcher, ResolveFieldsOptions } from "./resolve.ts";
+export { SEGMENT_RE, isSegment, assertSegment, joinPath, splitPath, segmentFor, localesOf, chainOf, assertDepth, pagePath, pagePathRows, entryPathRows, collectionSegment, buildPageTree, perLocaleSegments, } from "./paths.ts";
+export type { LocaleSet, PathTarget, PathRow, PageLike, EntryLike, PageTreeNode, PagePathOptions } from "./paths.ts";
+export { titleFor, localizeFields, fixedPathFor } from "./localize.ts";
+export type { PageStore, PageRecord, PageVersion, PageStoreOptions, PageI18n, CreatePageInput } from "./store.ts";
+export { pathOptions, pageErrors, assertPageI18n, DEFAULT_LOCALES } from "./store.ts";
 export type { SmoodlyConfig, ResolvedConfig } from "./config.ts";
 export type { FieldBuilder, Descriptor, ValueOf } from "./fields.ts";
 export type { SectionSchema, ElementSchema, BuilderMap } from "./schema.ts";
 export type { Props, PairedComponent } from "./pairing.tsx";
-export type { CollectionSchema, Toolset } from "./collections.ts";
+export type { CollectionSchema, Toolset, EntryOrder } from "./collections.ts";
+export { collectionOrder, collectionDepth, DEFAULT_ORDER } from "./collections.ts";
 export type { ZonePolicy } from "./zones.ts";
 export declare const smoodly: {
     schema: {
@@ -94,6 +107,7 @@ export declare const smoodly: {
     section: typeof section;
     element: typeof element;
     page: typeof page;
+    entryPage: typeof entryPage;
     collection: typeof collection;
     toolset: typeof toolset;
     Section: typeof Section;
@@ -101,3 +115,5 @@ export declare const smoodly: {
 export { resolveSmoodlyEnv, smoodlyEnv } from "./env.ts";
 export type { SmoodlyEnv } from "./env.ts";
 export { clientOptions, createSmoodlyClient } from "./client.ts";
+export { createSmoodlySite, pageContextOf } from "./site.ts";
+export type { SiteOptions, SitePage, SiteEntry, SiteHit, SmoodlySite, LoadOptions, PageTreeItem, SiteEntryItem, EntryTreeItem, EntryQuery, } from "./site.ts";

package/dist/index.js

@@ -3,7 +3,9 @@ import { section, element } from "./pairing.js";
 import { collection, toolset } from "./collections.js";
 import { Section } from "./section-wrapper.js";
 import { page } from "./render.js";
-export { Zone, renderPage } from "./render.js";
+import { entryPage } from "./entry-page.js";
+export { Zone, renderPage, EMPTY_PAGE_CONTEXT } from "./render.js";
+export { fixedSlug } from "./page.js";
 export { f } from "./fields.js";
 export { z } from "./zones.js";
 export { defineConfig } from "./config.js";
@@ -12,18 +14,27 @@ export { MemoryPageStore } from "./store.js";
 export { SupabasePageStore } from "./supabase-store.js";
 export { collectEntryRefs, collectTreeRefs } from "./refs.js";
 export { MemoryRefIndex } from "./ref-index.js";
+export { MemoryPathIndex } from "./path-index.js";
 export { MemoryEntryStore } from "./entry-store.js";
 export { SupabaseEntryStore } from "./supabase-entry-store.js";
-export { affectedPageSlugs } from "./revalidate.js";
-export { resolveTree } from "./resolve.js";
+export { SupabasePathIndex } from "./supabase-path-index.js";
+export { entryErrors, compareEntries, DEFAULT_ENTRY_LOCALES } from "./entry-store.js";
+export { affectedTargets, pageTag, entryTag } from "./revalidate.js";
+export { resolveTree, resolveFields } from "./resolve.js";
+export { SEGMENT_RE, isSegment, assertSegment, joinPath, splitPath, segmentFor, localesOf, chainOf, assertDepth, pagePath, pagePathRows, entryPathRows, collectionSegment, buildPageTree, perLocaleSegments, } from "./paths.js";
+export { titleFor, localizeFields, fixedPathFor } from "./localize.js";
+export { pathOptions, pageErrors, assertPageI18n, DEFAULT_LOCALES } from "./store.js";
+export { collectionOrder, collectionDepth, DEFAULT_ORDER } from "./collections.js";
 export const smoodly = {
     schema,
     section,
     element,
     page,
+    entryPage,
     collection,
     toolset,
     Section,
 };
 export { resolveSmoodlyEnv, smoodlyEnv } from "./env.js";
 export { clientOptions, createSmoodlyClient } from "./client.js";
+export { createSmoodlySite, pageContextOf } from "./site.js";

package/dist/localize.d.ts

@@ -0,0 +1,19 @@
+import { type LocaleSet } from "./paths.ts";
+/** The locale's title, or the default locale's. */
+export declare function titleFor(node: {
+    title: string;
+    i18n?: Record<string, {
+        title?: string;
+    }> | null;
+}, locale: string, set: LocaleSet): string;
+/** A fresh object: the default locale's fields, overlaid per field with
+ *  the locale's values. An overlay value that is undefined, null or ""
+ *  falls back — a translator may leave a field blank. */
+export declare function localizeFields(fields: Record<string, unknown>, i18n: Record<string, Record<string, unknown>> | null | undefined, locale: string, set: LocaleSet): Record<string, unknown>;
+/** The path a FIXED page registration is served at in one locale — the
+ *  escape hatch's addressing (spec §5: renderSmoodlyPage). Home is judged
+ *  by the default-locale segment, exactly as the stores judge the record. */
+export declare function fixedPathFor(schema: {
+    name: string;
+    slug?: string | Record<string, string>;
+}, locale: string, set: LocaleSet, homePageSlug: string): string;

package/dist/localize.js

@@ -0,0 +1,42 @@
+// Per-field locale fallback for the two overlays the stores carry
+// (spec 2026-09-05 §2): `pages.i18n[locale].title` and
+// `entries.i18n[locale]`. Slugs are paths.ts's business (segmentFor);
+// this module owns titles and entry fields. Pure and framework-free.
+import { segmentFor } from "./paths.js";
+const present = (v) => v !== undefined && v !== null && v !== "";
+/** The locale's title, or the default locale's. */
+export function titleFor(node, locale, set) {
+    if (locale === set.default)
+        return node.title;
+    const own = node.i18n?.[locale]?.title;
+    return typeof own === "string" && own.length > 0 ? own : node.title;
+}
+/** A fresh object: the default locale's fields, overlaid per field with
+ *  the locale's values. An overlay value that is undefined, null or ""
+ *  falls back — a translator may leave a field blank. */
+export function localizeFields(fields, i18n, locale, set) {
+    const out = structuredClone(fields);
+    if (locale === set.default)
+        return out;
+    for (const [key, value] of Object.entries(i18n?.[locale] ?? {})) {
+        if (present(value))
+            out[key] = structuredClone(value);
+    }
+    return out;
+}
+/** The path a FIXED page registration is served at in one locale — the
+ *  escape hatch's addressing (spec §5: renderSmoodlyPage). Home is judged
+ *  by the default-locale segment, exactly as the stores judge the record. */
+export function fixedPathFor(schema, locale, set, homePageSlug) {
+    if (schema.slug === undefined) {
+        throw new Error(`smoodly: page registration "${schema.name}" has no fixed slug — open pages are served by renderSmoodlyPath.`);
+    }
+    const slug = typeof schema.slug === "string" ? schema.slug : schema.slug[set.default];
+    if (slug === undefined) {
+        throw new Error(`smoodly: page registration "${schema.name}" declares a per-locale slug without the default locale "${set.default}".`);
+    }
+    if (slug === homePageSlug)
+        return "/";
+    const i18n = typeof schema.slug === "string" ? null : Object.fromEntries(Object.entries(schema.slug).map(([l, s]) => [l, { slug: s }]));
+    return `/${segmentFor({ slug, i18n }, locale, set)}`;
+}

package/dist/next/index.d.ts

@@ -1,3 +1,3 @@
 export { createPageRenderer } from "./page-renderer.tsx";
-export type { PageRendererOptions, RenderOptions } from "./page-renderer.tsx";
-export { pageSlugFor, metadataFrom } from "./meta.ts";
+export type { PageRendererOptions, PathRenderOptions, PageRegistration } from "./page-renderer.tsx";
+export { metadataFrom } from "./meta.ts";

package/dist/next/index.js

@@ -1,2 +1,2 @@
 export { createPageRenderer } from "./page-renderer.js";
-export { pageSlugFor, metadataFrom } from "./meta.js";
+export { metadataFrom } from "./meta.js";

package/dist/next/meta.d.ts

@@ -1,10 +1,4 @@
 import type { Metadata } from "next";
-import type { PageSchema } from "../page.ts";
-/** A route either carries a fixed registration (slug on the schema) or
- * passes the slug from its params. Having neither is a developer wiring
- * error, not runtime data — so this throws rather than returning a
- * result. */
-export declare function pageSlugFor(schema: PageSchema<any>, explicit?: string): string;
 /** Maps the page tree's meta bag onto Next metadata. Absent meta returns
  * {} so the app's own layout.tsx defaults apply untouched. */
 export declare function metadataFrom(meta: unknown): Metadata;

package/dist/next/meta.js

@@ -1,14 +1,3 @@
-/** A route either carries a fixed registration (slug on the schema) or
- * passes the slug from its params. Having neither is a developer wiring
- * error, not runtime data — so this throws rather than returning a
- * result. */
-export function pageSlugFor(schema, explicit) {
-    if (explicit)
-        return explicit;
-    if (schema.slug)
-        return schema.slug;
-    throw new Error(`smoodly: page registration "${schema.name}" has no fixed slug — pass { slug } from the route's params to renderSmoodlyPage.`);
-}
 /** Maps the page tree's meta bag onto Next metadata. Absent meta returns
  * {} so the app's own layout.tsx defaults apply untouched. */
 export function metadataFrom(meta) {