smoodly 0.0.33 → 0.0.34

package/dist/path-index.js

@@ -1,66 +1,93 @@
+import { candidates, fullPath, pickHit, sameUrlKeys } from "./anchors.js";
 const sameTarget = (a, b) => a.kind === b.kind && a.id === b.id;
-const key = (locale, path) => `${locale} ${path}`;
 export const pathTakenError = (locale, path) => new Error(`smoodly: the path "${path}" (${locale}) is already taken.`);
 export const pathLiveError = (locale, path) => new Error(`smoodly: "${path}" (${locale}) is a live address.`);
-const strip = ({ redirect: _redirect, ...row }) => row;
+const key = (locale, anchor, path) => `${locale} ${anchor} ${path}`;
+const stored = (r) => ({ kind: r.kind, id: r.id, locale: r.locale, anchor: r.anchor ?? "", path: r.path, redirect: false });
 export class MemoryPathIndex {
-    constructor() {
+    /** Held by reference: the config's addresses, read on every call (spec 2026-09-29 anchored paths §2). */
+    constructor(anchors = { addresses: {}, homePageSlug: "home", defaultLocale: "en" }) {
+        this.anchors = anchors;
         this.rows = [];
     }
+    /** A stored row as callers see it: the full URL, or nothing when its anchor has no address. */
+    shown(r) {
+        const path = fullPath(this.anchors, r.anchor, r.path, r.locale);
+        return path === null ? null : { kind: r.kind, id: r.id, locale: r.locale, path };
+    }
+    shownAll(rows) {
+        return rows.map((r) => this.shown(r)).filter((r) => r !== null);
+    }
     async rewrite(targets, rows) {
+        const incoming = rows.map(stored);
         const ofTarget = (r) => targets.find((t) => sameTarget(t, r));
-        const newKeys = new Set(rows.map((r) => key(r.locale, r.path)));
+        // Every key a new row's full URL answers to: live wins a redirect there under any anchor (a redirect by
+        // hand has none), and an old row at the same full URL is the same address, not an old one.
+        const newKeys = new Set(incoming.flatMap((r) => sameUrlKeys(this.anchors, r.locale, r.anchor, r.path).map((k) => key(r.locale, k.anchor, k.path))));
         // 1. redirect rows at the new live addresses go, whoever they point at (live wins, rename-back reclaims)
-        let kept = this.rows.filter((r) => !(r.redirect && newKeys.has(key(r.locale, r.path))));
+        let kept = this.rows.filter((r) => !(r.redirect && newKeys.has(key(r.locale, r.anchor, r.path))));
         // 2. the targets' old live rows: flipped to redirects in the named locales unless the address stays live
         kept = kept.map((r) => {
             const t = !r.redirect ? ofTarget(r) : undefined;
-            return t && t.redirectLocales?.includes(r.locale) && !newKeys.has(key(r.locale, r.path)) ? { ...r, redirect: true } : r;
+            return t && t.redirectLocales?.includes(r.locale) && !newKeys.has(key(r.locale, r.anchor, r.path)) ? { ...r, redirect: true } : r;
         });
-        // 3. the targets' remaining live rows go — and so do their redirect rows in a locale the
-        //    target has no new live row in (a removed translation: nothing could resolve them)
-        const liveLocales = new Set(rows.map((r) => `${r.kind} ${r.id} ${r.locale}`));
+        // 3. the targets' remaining live rows go — and so do their redirect rows in a locale the target has no new live row in
+        const liveLocales = new Set(incoming.map((r) => `${r.kind} ${r.id} ${r.locale}`));
         kept = kept.filter((r) => !ofTarget(r) || (r.redirect && liveLocales.has(`${r.kind} ${r.id} ${r.locale}`)));
-        // 4. the new live rows: a collision now is with another target's live row
-        const taken = new Set(kept.map((r) => key(r.locale, r.path)));
-        for (const row of rows) {
-            const k = key(row.locale, row.path);
+        // 4. the new live rows: a collision now is with another target's live row under the same anchor
+        const taken = new Set(kept.map((r) => key(r.locale, r.anchor, r.path)));
+        for (const r of incoming) {
+            const k = key(r.locale, r.anchor, r.path);
             if (taken.has(k))
-                throw pathTakenError(row.locale, row.path);
+                throw pathTakenError(r.locale, fullPath(this.anchors, r.anchor, r.path, r.locale) ?? r.path);
             taken.add(k);
         }
-        this.rows = [...kept, ...rows.map((r) => ({ ...r, redirect: false }))];
+        this.rows = [...kept, ...incoming];
     }
     async remove(targets) {
         this.rows = this.rows.filter((r) => !targets.some((t) => sameTarget(t, r)));
     }
+    hit(locale, url) {
+        const { keys, coded } = candidates(this.anchors, locale, url);
+        return pickHit(this.rows.filter((r) => r.locale === locale), keys, coded);
+    }
     async resolve(locale, path) {
-        const row = this.rows.find((r) => r.locale === locale && r.path === path);
+        const row = this.hit(locale, path);
         return row ? { kind: row.kind, id: row.id, redirect: row.redirect } : null;
     }
     async pathsOf(target) {
         const out = {};
-        for (const r of this.rows)
-            if (!r.redirect && sameTarget(r, target))
-                out[r.locale] = r.path;
+        for (const r of this.shownAll(this.rows.filter((r) => !r.redirect && sameTarget(r, target))))
+            out[r.locale] = r.path;
         return out;
     }
     async redirectsOf(target) {
-        return this.rows.filter((r) => r.redirect && sameTarget(r, target)).map(strip);
+        return this.shownAll(this.rows.filter((r) => r.redirect && sameTarget(r, target)));
     }
+    /** Every live URL in the locale; an editor's row under a code address is left out, since visitors never reach it (spec §4). */
     async listLive(locale) {
-        return this.rows.filter((r) => !r.redirect && r.locale === locale).map(strip);
+        const served = (r) => !(r.anchor === "" && candidates(this.anchors, locale, r.path).coded);
+        return this.shownAll(this.rows.filter((r) => !r.redirect && r.locale === locale && served(r))).sort((a, b) => a.path.localeCompare(b.path));
     }
     async listRedirects(locale) {
-        return this.rows.filter((r) => r.redirect && r.locale === locale).map(strip);
+        return this.shownAll(this.rows.filter((r) => r.redirect && r.locale === locale)).sort((a, b) => a.path.localeCompare(b.path));
     }
+    /** A redirect by hand stays absolute (anchor ''): refused where the URL resolves live; a redirect there is replaced. */
     async addRedirect(row) {
-        const existing = this.rows.find((r) => r.locale === row.locale && r.path === row.path);
+        const existing = this.hit(row.locale, row.path);
         if (existing && !existing.redirect)
             throw pathLiveError(row.locale, row.path);
-        this.rows = [...this.rows.filter((r) => r !== existing), { ...row, redirect: true }];
+        // An editor's page hidden under a code address still holds its row: a redirect never stacks on it.
+        if (this.rows.some((r) => !r.redirect && r.locale === row.locale && r.anchor === "" && r.path === row.path))
+            throw pathLiveError(row.locale, row.path);
+        // Every redirect the URL reaches goes, under any anchor: the new one replaces them all.
+        const { keys } = candidates(this.anchors, row.locale, row.path);
+        const replaced = (r) => r.redirect && r.locale === row.locale && keys.some((k) => k.anchor === r.anchor && k.path === r.path);
+        this.rows = [...this.rows.filter((r) => !replaced(r)), { ...stored({ ...row, anchor: "" }), redirect: true }];
     }
+    /** Deletes the redirect rows a URL reaches, under any candidate anchor; a live row there is left alone. */
     async removeRedirect(locale, path) {
-        this.rows = this.rows.filter((r) => !(r.redirect && r.locale === locale && r.path === path));
+        const { keys } = candidates(this.anchors, locale, path);
+        this.rows = this.rows.filter((r) => !(r.redirect && r.locale === locale && keys.some((k) => k.anchor === r.anchor && k.path === r.path)));
     }
 }

package/dist/paths.d.ts

@@ -1,3 +1,4 @@
+import type { Addresses } from "./addresses.ts";
 export declare const SEGMENT_RE: RegExp;
 export declare const isSegment: (s: string) => boolean;
 export declare function assertSegment(s: string, what: string): void;
@@ -24,18 +25,28 @@ export declare function perLocaleSegments(value: string | Record<string, string>
  *  (spec 2026-09-06 §3). The boot collision check (config.ts), the
  *  materializer (admin/fixed-nodes.ts) and the fixed path derivation
  *  (localize.ts) all fill through here, or a collision passes boot and
- *  only surfaces at materialization. Collection mounts are NOT filled:
- *  a per-locale path claims exactly the locales it names. */
+ *  only surfaces at materialization. Collection paths fill the same way
+ *  (addresses.ts): their entries take the default path in a locale the
+ *  path omits (collectionSegment), so the address is claimed there too. */
 export declare function fixedPageSegments(slug: string | Record<string, string>, locales: LocaleSet): Record<string, string>;
 export type PathTarget = {
     kind: "page" | "entry";
     id: string;
 };
+/** A URL row: `anchor` names the code address it hangs under (spec 2026-09-29 anchored paths §1), absent = the editors' tree;
+ *  `path` is the part editors made. Read back from the index, `path` is the full URL and `anchor` is absent. */
 export type PathRow = PathTarget & {
     locale: string;
     path: string;
+    anchor?: string;
 };
 export declare const joinPath: (segments: string[]) => string;
+/** A request's segment or a typed address's, as stored: percent-decoded and NFC-composed, so
+ *  a pasted `%C3%A4`, a typed `ä` and a decomposed `a\u0308` are one address. Next hands the
+ *  catch-all its segments still encoded. A stray `%` that is no escape stays as it is, and so
+ *  does a segment holding an encoded slash: decoded, it would become two segments and make
+ *  `/a%2Fb` an alias of `/a/b`. Slugs are ASCII, so this changes nothing a slug path holds. */
+export declare function decodeSegment(segment: string): string;
 export declare const splitPath: (path: string) => string[];
 /** The node's segment in one locale. An absent locale is an error, never
  *  a fallback: the stores' parent rule guarantees a present node has a
@@ -49,6 +60,8 @@ export declare function assertDepth(depth: number, max: number, what: string): v
 export type PageLike = {
     id: string;
     parentId: string | null;
+    /** The owner key when code owns the record (spec 2026-09-29 nested paths §3); absent or null = an editor's page. */
+    fixed?: string | null;
     /** The locales the node exists in, each with the node's OWN segment there. Presence IS the key (spec 2026-09-06 §3). */
     locales: Record<string, {
         slug: string;
@@ -57,18 +70,22 @@ export type PageLike = {
 export type PagePathOptions = {
     locales: LocaleSet;
     homePageSlug: string;
+    addresses?: Addresses;
 };
 /** Home is judged by identity: the root node whose DEFAULT-locale slug is
  *  homePageSlug serves "/" in every locale it exists in. */
 export declare const isHomeNode: (node: PageLike, opts: PagePathOptions) => boolean;
 /** The node's path in one locale: `/` for the home node, else the
- *  locale's ancestor chain joined. THE derivation — pagePathRows,
+ *  locale's ancestor chain joined. A code-owned root's path is its
+ *  address (spec 2026-09-29). THE derivation — pagePathRows,
  *  buildPageTree and the site layer all call this. */
 export declare function pagePath(node: PageLike, byId: (id: string) => PageLike | undefined, locale: string, opts: PagePathOptions): string;
 /** The same path, or null when the node or an ancestor is absent from the
- *  locale — what the Pages list shows as a dimmed "not in fi" row. */
+ *  locale — what the Pages list shows as a dimmed "not in fi" row — or
+ *  when its code-owned root has no address there. */
 export declare function pagePathIn(node: PageLike, byId: (id: string) => PageLike | undefined, locale: string, opts: PagePathOptions): string | null;
-/** One row per locale the target EXISTS in. */
+/** One row per locale the target EXISTS in (spec 2026-09-29 anchored paths §3): under a code-owned root, the root's
+ *  owner key and the chain below it (`''` for the root itself); in the editors' tree, no anchor and the full path. */
 export declare function pagePathRows(targets: PageLike[], byId: (id: string) => PageLike | undefined, opts: PagePathOptions): PathRow[];
 export type EntryLike = {
     id: string;
@@ -91,13 +108,9 @@ export declare const slugOf: (fields: Record<string, unknown>) => string | null;
 /** The entry's segment in one locale: its row's slug. An absent locale
  *  or a slug-less row is null — no URL there, never a fallback. */
 export declare function entrySegment(entry: EntryLike, locale: string): string | null;
-/** One row per locale the target EXISTS in, where the whole chain has a
- *  segment in that locale. The stores' parent rule guarantees an ancestor
- *  is present wherever a descendant is; an ancestor without a slug there
- *  simply yields no URL for the subtree in that locale. */
-export declare function entryPathRows(targets: EntryLike[], byId: (id: string) => EntryLike | undefined, collection: {
-    path?: string | Record<string, string>;
-}, set: LocaleSet): PathRow[];
+/** One row per locale the target EXISTS in, where the whole chain has a slug there, under the collection's anchor
+ *  (spec 2026-09-29 anchored paths §1): written whether or not the collection has a `path`, which the index reads. */
+export declare function entryPathRows(targets: EntryLike[], byId: (id: string) => EntryLike | undefined, collection: string): PathRow[];
 /** The locales a node is published in — the ones whose old addresses may
  *  stay as redirects (spec 2026-09-26 redirects §2: only published rows). */
 export declare function publishedLocales(node: {

package/dist/paths.js

@@ -1,7 +1,3 @@
-// The one place a URL is derived (spec 2026-09-05 §1, §4; spec
-// 2026-09-06 §3, §7). Pure and framework-free: both store adapters and
-// the tree query call these, so the `paths` index and every derived
-// `path` value agree by construction.
 export const SEGMENT_RE = /^[a-z0-9]+(?:-[a-z0-9]+)*$/;
 export const isSegment = (s) => SEGMENT_RE.test(s);
 export function assertSegment(s, what) {
@@ -47,13 +43,31 @@ export function perLocaleSegments(value, supported) {
  *  (spec 2026-09-06 §3). The boot collision check (config.ts), the
  *  materializer (admin/fixed-nodes.ts) and the fixed path derivation
  *  (localize.ts) all fill through here, or a collision passes boot and
- *  only surfaces at materialization. Collection mounts are NOT filled:
- *  a per-locale path claims exactly the locales it names. */
+ *  only surfaces at materialization. Collection paths fill the same way
+ *  (addresses.ts): their entries take the default path in a locale the
+ *  path omits (collectionSegment), so the address is claimed there too. */
 export function fixedPageSegments(slug, locales) {
     const raw = perLocaleSegments(slug, locales.supported);
     return Object.fromEntries(locales.supported.map((l) => [l, raw[l] || raw[locales.default]]));
 }
 export const joinPath = (segments) => (segments.length === 0 ? "/" : "/" + segments.join("/"));
+/** A request's segment or a typed address's, as stored: percent-decoded and NFC-composed, so
+ *  a pasted `%C3%A4`, a typed `ä` and a decomposed `a\u0308` are one address. Next hands the
+ *  catch-all its segments still encoded. A stray `%` that is no escape stays as it is, and so
+ *  does a segment holding an encoded slash: decoded, it would become two segments and make
+ *  `/a%2Fb` an alias of `/a/b`. Slugs are ASCII, so this changes nothing a slug path holds. */
+export function decodeSegment(segment) {
+    let out = segment;
+    try {
+        const decoded = decodeURIComponent(segment);
+        if (!decoded.includes("/"))
+            out = decoded;
+    }
+    catch {
+        // not an escape sequence: looked up as typed
+    }
+    return out.normalize("NFC");
+}
 export const splitPath = (path) => path.split("/").filter((s) => s.length > 0);
 /** The node's segment in one locale. An absent locale is an error, never
  *  a fallback: the stores' parent rule guarantees a present node has a
@@ -83,28 +97,56 @@ export function assertDepth(depth, max, what) {
 /** Home is judged by identity: the root node whose DEFAULT-locale slug is
  *  homePageSlug serves "/" in every locale it exists in. */
 export const isHomeNode = (node, opts) => node.parentId === null && node.locales[opts.locales.default]?.slug === opts.homePageSlug;
+/** A code-owned root's address parts in the locale from the config; null
+ *  when no registration claims it there any more (an orphan). */
+function addressParts(root, locale, opts) {
+    const address = opts.addresses?.[root.fixed]?.[locale];
+    return address === undefined ? null : address.split("/");
+}
 /** The node's path in one locale: `/` for the home node, else the
- *  locale's ancestor chain joined. THE derivation — pagePathRows,
+ *  locale's ancestor chain joined. A code-owned root's path is its
+ *  address (spec 2026-09-29). THE derivation — pagePathRows,
  *  buildPageTree and the site layer all call this. */
 export function pagePath(node, byId, locale, opts) {
-    return isHomeNode(node, opts) ? "/" : joinPath(chainOf(node, byId).map((n) => segmentFor(n, locale)));
+    if (isHomeNode(node, opts))
+        return "/";
+    const [root, ...rest] = chainOf(node, byId);
+    const own = segmentFor(root, locale); // an absent root is a broken invariant, code-owned or not
+    const head = root.fixed ? addressParts(root, locale, opts) : [own];
+    if (head === null)
+        throw new Error(`smoodly: page "${node.id}" has no address in locale "${locale}".`);
+    return joinPath([...head, ...rest.map((n) => segmentFor(n, locale))]);
 }
 /** The same path, or null when the node or an ancestor is absent from the
- *  locale — what the Pages list shows as a dimmed "not in fi" row. */
+ *  locale — what the Pages list shows as a dimmed "not in fi" row — or
+ *  when its code-owned root has no address there. */
 export function pagePathIn(node, byId, locale, opts) {
     if (!node.locales[locale])
         return null;
     if (isHomeNode(node, opts))
         return "/";
     const chain = chainOf(node, byId);
-    return chain.every((n) => n.locales[locale] !== undefined) ? joinPath(chain.map((n) => n.locales[locale].slug)) : null;
+    if (!chain.every((n) => n.locales[locale] !== undefined))
+        return null;
+    const [root, ...rest] = chain;
+    const head = root.fixed ? addressParts(root, locale, opts) : [root.locales[locale].slug];
+    return head === null ? null : joinPath([...head, ...rest.map((n) => n.locales[locale].slug)]);
 }
-/** One row per locale the target EXISTS in. */
+/** One row per locale the target EXISTS in (spec 2026-09-29 anchored paths §3): under a code-owned root, the root's
+ *  owner key and the chain below it (`''` for the root itself); in the editors' tree, no anchor and the full path. */
 export function pagePathRows(targets, byId, opts) {
     const rows = [];
     for (const target of targets) {
+        const chain = chainOf(target, byId);
+        const root = chain[0];
         for (const locale of Object.keys(target.locales)) {
-            rows.push({ kind: "page", id: target.id, locale, path: pagePath(target, byId, locale, opts) });
+            if (root.fixed) {
+                const below = chain.slice(1).map((n) => segmentFor(n, locale));
+                rows.push({ kind: "page", id: target.id, locale, anchor: root.fixed, path: below.length === 0 ? "" : joinPath(below) });
+            }
+            else {
+                rows.push({ kind: "page", id: target.id, locale, anchor: "", path: pagePath(target, byId, locale, opts) });
+            }
         }
     }
     return rows;
@@ -131,22 +173,18 @@ export const slugOf = (fields) => {
 export function entrySegment(entry, locale) {
     return entry.locales[locale]?.slug ?? null;
 }
-/** One row per locale the target EXISTS in, where the whole chain has a
- *  segment in that locale. The stores' parent rule guarantees an ancestor
- *  is present wherever a descendant is; an ancestor without a slug there
- *  simply yields no URL for the subtree in that locale. */
-export function entryPathRows(targets, byId, collection, set) {
+/** One row per locale the target EXISTS in, where the whole chain has a slug there, under the collection's anchor
+ *  (spec 2026-09-29 anchored paths §1): written whether or not the collection has a `path`, which the index reads. */
+export function entryPathRows(targets, byId, collection) {
+    // `collection:<name>` is addresses.ts's collectionKey, spelled here: addresses.ts imports this module.
     const rows = [];
     for (const target of targets) {
         const chain = chainOf(target, byId);
         for (const locale of Object.keys(target.locales)) {
-            const base = collectionSegment(collection.path, locale, set);
-            if (base === null)
-                continue;
             const segments = chain.map((e) => entrySegment(e, locale));
             if (segments.some((s) => s === null))
                 continue;
-            rows.push({ kind: "entry", id: target.id, locale, path: joinPath([base, ...segments]) });
+            rows.push({ kind: "entry", id: target.id, locale, anchor: `collection:${collection}`, path: joinPath(segments) });
         }
     }
     return rows;

package/dist/schema-version.d.ts

@@ -1,7 +1,7 @@
 /** The minimum schema version the package needs. Moves ONLY in a release
  *  that adds a table, column, function or policy the package reads; a
  *  unit test holds it equal to the highest file in `migrations/`. */
-export declare const SCHEMA_VERSION = 4;
+export declare const SCHEMA_VERSION = 5;
 export declare const SCHEMA_VERSION_KEY = "schema_version";
 export declare const CORE_FILE_RE: RegExp;
 export declare const VIEWS_FILE_RE: RegExp;

package/dist/schema-version.js

@@ -7,7 +7,7 @@
 /** The minimum schema version the package needs. Moves ONLY in a release
  *  that adds a table, column, function or policy the package reads; a
  *  unit test holds it equal to the highest file in `migrations/`. */
-export const SCHEMA_VERSION = 4;
+export const SCHEMA_VERSION = 5;
 export const SCHEMA_VERSION_KEY = "schema_version";
 export const CORE_FILE_RE = /^(\d{14})_smoodly_v(\d+)\.sql$/;
 export const VIEWS_FILE_RE = /^(\d{14})_smoodly_views\.sql$/;

package/dist/site.d.ts

@@ -27,14 +27,18 @@ export type SiteOptions = {
     styles?: StyleValuesInput;
     /** The custom section's options (spec 2026-09-14 §6); the defaults when absent. */
     custom?: CustomConfigInput;
-    /** Page shapes (entry pages are ignored): the source of each template's page-field descriptors (spec 2026-09-10 page fields §3). */
-    pages?: ReadonlyArray<SitePageSchema>;
+    /** Page shapes (entry pages are ignored): the source of each template's page-field descriptors (spec 2026-09-10 page fields §3)
+     *  and of the fixed pages' addresses (spec 2026-09-29 nested paths §3) — `config.registry.pages`. Required: a site that
+     *  missed one would take its code-owned record for an orphan and drop its URLs at the first lookup. */
+    pages: ReadonlyArray<SitePageSchema>;
 };
-/** A page registration as the site needs it: the template's page fields. */
+/** A page registration as the site needs it: the template's page fields, and a fixed page's address. */
 export type SitePageSchema = {
     schema: {
         kind: string;
         name: string;
+        title?: string;
+        slug?: string | Record<string, string>;
         fields?: Record<string, Descriptor>;
     };
 };

package/dist/site.js

@@ -6,6 +6,8 @@ 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 } from "./addresses.js";
+import { fullPath, servedAnchor } from "./anchors.js";
 import { withDefaults } from "./field-defaults.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. */
@@ -29,7 +31,11 @@ export function createSmoodlySite(options) {
     const styles = resolveStyleValues(options.styles);
     const custom = resolveCustom(options.custom);
     const elements = elementSchemas(options.elements);
-    const pathOpts = { locales, homePageSlug };
+    // Code-owned addresses from the site's own registry (spec 2026-09-29 nested paths §3): a code-owned root's path.
+    const addresses = addressMap(codeAddresses({ locales, pages: options.pages, collections: options.collections }));
+    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);
     /** The resolver's fetcher, bound to a locale: the merged fields of that
      *  locale — published ones (a versioned collection's snapshot) on the
@@ -184,8 +190,11 @@ export function createSmoodlySite(options) {
         return wanted
             .filter((record) => fieldsById[record.id] !== undefined)
             .map((record) => {
-            const rows = entryPathRows([record], byId, schema, locales);
-            const pathIn = (l) => rows.find((r) => r.locale === l)?.path ?? null;
+            const rows = entryPathRows([record], byId, schema.name);
+            const pathIn = (l) => {
+                const row = rows.find((r) => r.locale === l);
+                return row ? fullPath(anchors, row.anchor ?? "", row.path, l) : null;
+            };
             return {
                 entry: { ...record, fields: fieldsById[record.id] },
                 path: pathIn(locale),
@@ -243,18 +252,20 @@ export function createSmoodlySite(options) {
             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);
-            const toItem = (node) => ({
-                id: node.record.id,
-                title: node.record.locales[locale].title,
-                // Every node the walk reaches is present with a present chain, so
-                // buildPageTree's nullable path is never null here; pagePath is
-                // the same derivation and keeps the type honest.
-                path: node.path ?? pagePath(node.record, (x) => index.get(x), locale, pathOpts),
-                hasPage: hasPage(node.record, locale, draft),
-                fields: fields.get(node.record.id) ?? {},
-                children: node.children.map(toItem),
-            });
-            return buildPageTree(shown, locale, pathOpts).map(toItem);
+            // 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));
         },
         async getPage(pathOrId, o) {
             const locale = localeOf(o);

package/dist/space-transfer.d.ts

@@ -46,6 +46,8 @@ export declare function insertPlan(rows: TableRows): {
 export declare function brokenReferences(rows: TableRows): string[];
 /** The import's target check (spec §9.1): per table, how many of the target's row keys this export does not hold. All zero = empty, or an earlier run. */
 export declare function foreignRows(target: Record<ContentTable, string[]>, exported: TableRows): Record<ContentTable, number>;
+/** The export's rows the target does not hold yet: zero on a re-run of a finished import. */
+export declare function missingRows(target: Record<ContentTable, string[]>, exported: TableRows): number;
 export declare const countRows: (rows: TableRows) => Record<ContentTable, number>;
 export declare function formatBytes(n: number): string;
 /** "14 pages (41 versions), 32 entries (118 versions), 51 assets (38.2 MB), 9 redirects" (spec §8.5). */

package/dist/space-transfer.js

@@ -23,7 +23,7 @@ export const ROW_KEY = {
     entry_locales: ["entry_id", "locale"],
     entry_versions: ["id"],
     refs: ["source_kind", "source_id", "source_field", "target_id"],
-    paths: ["locale", "path"],
+    paths: ["locale", "anchor", "path"],
     assets: ["id"],
 };
 /** The primary key as Postgres declares it — what "on conflict do nothing" names. */
@@ -116,6 +116,13 @@ export function foreignRows(target, exported) {
         return [table, target[table].filter((key) => !own.has(key)).length];
     }));
 }
+/** The export's rows the target does not hold yet: zero on a re-run of a finished import. */
+export function missingRows(target, exported) {
+    return CONTENT_TABLES.reduce((n, table) => {
+        const held = new Set(target[table]);
+        return n + exported[table].filter((row) => !held.has(rowKey(table, row))).length;
+    }, 0);
+}
 export const countRows = (rows) => Object.fromEntries(CONTENT_TABLES.map((t) => [t, rows[t].length]));
 const plural = (n, one, many = `${one}s`) => `${n} ${n === 1 ? one : many}`;
 const listJoin = (items) => (items.length <= 1 ? items.join("") : `${items.slice(0, -1).join(", ")} and ${items[items.length - 1]}`);

package/dist/sql.js

@@ -83,6 +83,7 @@ create table if not exists "pages" (
   "parent_id" uuid references "pages" ("id") on delete restrict,
   "template" text,
   "sort" numeric,
+  "fixed" text,
   "created_at" timestamptz not null default now(),
   "updated_at" timestamptz not null default now()
 );
@@ -96,6 +97,12 @@ create table if not exists "pages" (
 create index if not exists "pages_parent_idx"
   on "pages" ("space_id", "parent_id", "sort");
 
+-- The registration that owns a code-owned record (spec 2026-09-29 nested
+-- paths §3): "collection:<name>" or "page:<name>"; null = an editor's
+-- page. Its path is its address from the config, not its slug chain.
+create unique index if not exists "pages_fixed_idx"
+  on "pages" ("space_id", "fixed") where "fixed" is not null;
+
 create table if not exists "page_locales" (
   ${SPACE_COL},
   "page_id" uuid not null references "pages" ("id") on delete cascade,
@@ -238,14 +245,18 @@ create table if not exists "refs" (
 -- A row with "redirect" set is an old address of its target (spec
 -- 2026-09-26 redirects §2): the same primary key, so a redirect can never
 -- sit where a live URL is and a live row taking the address replaces it.
+-- "anchor" names the code address a row hangs under (spec 2026-09-29
+-- anchored paths): "path" is only the part editors made, and the address
+-- itself lives in the config; '' is the editors' own tree.
 create table if not exists "paths" (
   ${SPACE_COL},
   "locale" text not null,
+  "anchor" text not null default '',
   "path" text not null,
   "kind" text not null check ("kind" in ('page', 'entry')),
   "target_id" uuid not null,
   "redirect" boolean not null default false,
-  primary key ("space_id", "locale", "path")
+  primary key ("space_id", "locale", "anchor", "path")
 );
 
 create index if not exists "paths_target_idx"
@@ -285,27 +296,42 @@ create index if not exists "assets_space_created_idx"
 -- rolls the whole rewrite back. Inserted rows get their space from the
 -- a_set_space trigger (the claim, or the default space).
 -- A target may name redirect_locales: its old live rows there stay as redirects.
+-- A row carries "keys": every (anchor, path) that yields its full URL, from
+-- the config's addresses (spec 2026-09-29 anchored paths §2). A redirect at
+-- any of them goes (live wins, a redirect by hand has no anchor), and an old
+-- row at one is the same address moving between anchors, never a redirect.
 create or replace function "smoodly_rewrite_paths"(p_targets jsonb, p_rows jsonb) returns void language sql set search_path = public as $$
   delete from "paths" p
-  using jsonb_to_recordset(p_rows) as r(locale text, path text, kind text, id uuid)
-  where p."redirect" and p."locale" = r.locale and p."path" = r.path
+  using jsonb_to_recordset(p_rows) as r(locale text, anchor text, path text, kind text, id uuid, keys jsonb)
+  where p."redirect" and p."locale" = r.locale
+    and exists (select 1 from jsonb_to_recordset(r.keys) as k(anchor text, path text) where k.anchor = p."anchor" and k.path = p."path")
     and p."space_id" = "smoodly_current_space"();
   update "paths" p set "redirect" = true
   from jsonb_to_recordset(p_targets) as t(kind text, id uuid, redirect_locales text[])
   where not p."redirect" and p."kind" = t.kind and p."target_id" = t.id
     and p."locale" = any (coalesce(t.redirect_locales, '{}'::text[]))
-    and not exists (select 1 from jsonb_to_recordset(p_rows) as r(locale text, path text, kind text, id uuid)
-                    where r.locale = p."locale" and r.path = p."path")
+    and not exists (select 1 from jsonb_to_recordset(p_rows) as r(locale text, anchor text, path text, kind text, id uuid, keys jsonb)
+                    cross join lateral jsonb_to_recordset(r.keys) as k(anchor text, path text)
+                    where r.locale = p."locale" and k.anchor = p."anchor" and k.path = p."path")
     and p."space_id" = "smoodly_current_space"();
   delete from "paths" p
   using jsonb_to_recordset(p_targets) as t(kind text, id uuid, redirect_locales text[])
   where p."kind" = t.kind and p."target_id" = t.id
-    and (not p."redirect" or not exists (select 1 from jsonb_to_recordset(p_rows) as r(locale text, path text, kind text, id uuid)
+    and (not p."redirect" or not exists (select 1 from jsonb_to_recordset(p_rows) as r(locale text, anchor text, path text, kind text, id uuid)
                                           where r.kind = p."kind" and r.id = p."target_id" and r.locale = p."locale"))
     and p."space_id" = "smoodly_current_space"();
-  insert into "paths" ("locale", "path", "kind", "target_id")
-  select r.locale, r.path, r.kind, r.id
-  from jsonb_to_recordset(p_rows) as r(locale text, path text, kind text, id uuid);
+  insert into "paths" ("locale", "anchor", "path", "kind", "target_id")
+  select r.locale, r.anchor, r.path, r.kind, r.id
+  from jsonb_to_recordset(p_rows) as r(locale text, anchor text, path text, kind text, id uuid);
+$$;
+
+-- One call reads every candidate (anchor, path) of a request (spec
+-- 2026-09-29 anchored paths §2); the caller picks by precedence. Invoker
+-- rights: the paths read policy applies, as to a plain select.
+create or replace function "smoodly_resolve_path"(p_locale text, p_keys jsonb) returns setof "paths" language sql stable set search_path = public as $$
+  select p.* from "paths" p
+  join jsonb_to_recordset(p_keys) as k(anchor text, path text) on p."anchor" = k.anchor and p."path" = k.path
+  where p."locale" = p_locale;
 $$;
 
 -- RLS on every core table. The service role bypasses it (self-host