smoodly 0.0.33 → 0.0.35

package/dist/admin/shell/pages-tree.js

@@ -6,26 +6,54 @@
 // an "Add" action. The shell is not DOM-tested; every decision that
 // matters lives here.
 import { buildPageTree } from "../../paths.js";
+import { ownerCollection, pageKey } from "../../addresses.js";
 /** Registrations editors may create pages against: fixed ones are
  *  materialized by Smoodly, never offered. */
 export function openTemplates(templates) {
     return templates.filter((t) => t.slug === undefined);
 }
-/** The default-locale slug that identifies a ROOT node to the registry;
- *  a root that exists in another locale only is never code-owned. */
-const rootSlug = (record, registry) => record.parentId === null ? record.locales[registry.locales.default]?.slug : undefined;
-/** The collection a ROOT record is the mount of, if any — known from the
- *  registry, never from a column (spec 2026-09-05 §4). */
+/** The collection a record is the address of — by owner, never by slug, while code still gives
+ *  it an address (spec 2026-09-29 nested paths §3). */
 export function mountOf(record, registry) {
-    const slug = rootSlug(record, registry);
-    if (slug === undefined)
-        return null;
-    return registry.collections.find((c) => c.path?.[registry.locales.default] === slug) ?? null;
+    const name = record.fixed && registry.addresses[record.fixed] ? ownerCollection(record.fixed) : null;
+    return name === null ? null : registry.collections.find((c) => c.name === name) ?? null;
 }
-/** Fixed pages and mounts: never renamed, moved, deleted or stripped of a locale by editors. */
+/** Fixed pages and mounts: owned by a registration that still exists. Never renamed, moved,
+ *  deleted or stripped of a locale by editors. */
 export function isFixedNode(record, registry) {
-    const slug = rootSlug(record, registry);
-    return slug !== undefined && (registry.pages.some((t) => t.slug === slug) || mountOf(record, registry) !== null);
+    return !!record.fixed && registry.addresses[record.fixed] !== undefined;
+}
+/** Who owns `path` in a locale: a code address other than the home page's, which serves "/". */
+function ownerAt(path, registry, locale) {
+    for (const [key, segments] of Object.entries(registry.addresses)) {
+        const address = segments[locale];
+        if (address === undefined || segments[registry.locales.default] === registry.homePageSlug || `/${address}` !== path)
+            continue;
+        const collection = ownerCollection(key);
+        const title = collection
+            ? registry.collections.find((c) => c.name === collection)?.title ?? collection
+            : registry.pages.find((p) => pageKey(p.name) === key)?.title ?? key;
+        return { key, label: collection ? `the ${title} collection` : `the ${title} page` };
+    }
+    return null;
+}
+/** The notice on a page that sits on another code address, which visitors get instead (spec 2026-09-29 anchored paths §4). */
+function conflictNote(path, registry, locale) {
+    if (path === null)
+        return null;
+    const owner = ownerAt(path, registry, locale);
+    if (!owner)
+        return null;
+    return `${path} is set in code for ${owner.label}, so visitors don't see this page. Rename or move it.`;
+}
+/** The rename/move confirm's extra line (spec 2026-09-29 nested paths §3): code addresses below a page stay put. */
+export function codeAddressNote(path, registry, locale) {
+    if (path === null)
+        return undefined;
+    const below = Object.values(registry.addresses)
+        .map((s) => s[locale])
+        .filter((a) => a !== undefined && `/${a}`.startsWith(`${path}/`));
+    return below.length === 0 ? undefined : below.map((a) => `/${a} stays where it is — it is set in code.`).join(" ");
 }
 /** A node's title for display in a locale it may not exist in: its own,
  *  else the default locale's, else any. Display only — never content. */
@@ -54,7 +82,7 @@ export function localeStatusOf(row) {
     return row.publishedVersionId === row.draftVersionId ? "published" : "draft edits";
 }
 export function pagesTreeRows(records, registry, locale, collapsed) {
-    const opts = { locales: registry.locales, homePageSlug: registry.homePageSlug };
+    const opts = { locales: registry.locales, homePageSlug: registry.homePageSlug, addresses: registry.addresses };
     const templateTitle = (name) => registry.pages.find((t) => t.name === name)?.title ?? name;
     const rows = [];
     const walk = (nodes, depth, parentId) => {
@@ -65,6 +93,7 @@ export function pagesTreeRows(records, registry, locale, collapsed) {
             const mount = mountOf(r, registry);
             const isHome = r.parentId === null && r.locales[registry.locales.default]?.slug === registry.homePageSlug;
             const expanded = !collapsed.has(r.id);
+            const orphan = !!r.fixed && registry.addresses[r.fixed] === undefined;
             rows.push({
                 id: r.id,
                 parentId,
@@ -80,6 +109,8 @@ export function pagesTreeRows(records, registry, locale, collapsed) {
                 kind: mount ? "mount" : r.template === null ? "folder" : "page",
                 collection: mount?.name ?? null,
                 fixed: isFixedNode(r, registry),
+                conflict: r.fixed ? null : conflictNote(node.path, registry, locale),
+                orphan,
                 isHome,
                 template: r.template,
                 templateTitle: mount
@@ -87,7 +118,8 @@ export function pagesTreeRows(records, registry, locale, collapsed) {
                     : r.template === null ? "Path" : templateTitle(r.template),
                 status: !row || r.template === null ? null : localeStatusOf(row),
                 // A child needs its parent in the locale (the parent rule), so an absent node offers none.
-                canHaveChildren: present && !mount && !isHome && depth + 1 < registry.pageDepth,
+                // A record no longer in code has no URL to give a child (spec 2026-09-29 nested paths §5).
+                canHaveChildren: present && !mount && !isHome && !orphan && depth + 1 < registry.pageDepth,
                 record: r,
             });
             if (expanded)
@@ -99,8 +131,9 @@ export function pagesTreeRows(records, registry, locale, collapsed) {
 }
 /** Every row drags: root order is the listing's order, nothing code owns.
  *  Fixed nodes and the home page stay at the root — projectDrop refuses
- *  them any deeper slot, the move op refuses any other parent. */
-export const canDragRow = (_row) => true;
+ *  them any deeper slot, the move op refuses any other parent. A record
+ *  no longer in code does not move at all: deleting it is all that is open. */
+export const canDragRow = (row) => !row.orphan;
 /** Whether a row may only reorder among the root siblings. */
 export const rootOnly = (row) => row.fixed || row.isHome;
 /** Levels below a node: 0 for a leaf. From the records, because the

package/dist/admin/shell/router.d.ts

@@ -39,3 +39,8 @@ export declare function useRoute(base: string): Route;
 /** Register the calling view as dirty: navigate() asks before leaving,
  *  and beforeunload covers reload, closing the tab and a real link out. */
 export declare function useLeaveGuard(dirty: boolean): void;
+/** The tab-close half of useLeaveGuard alone, for a view that saves on
+ *  unmount (the page editor, spec 2026-09-29 pre-install fixes §4): an
+ *  in-app navigation loses nothing, so only reload, closing the tab and a
+ *  real link out ask, while a change or a save is pending. */
+export declare function useUnloadGuard(pending: boolean): void;

package/dist/admin/shell/router.js

@@ -94,3 +94,16 @@ export function useLeaveGuard(dirty) {
         return () => { guards.delete(guard); window.removeEventListener("beforeunload", onBeforeUnload); };
     }, [dirty]);
 }
+/** The tab-close half of useLeaveGuard alone, for a view that saves on
+ *  unmount (the page editor, spec 2026-09-29 pre-install fixes §4): an
+ *  in-app navigation loses nothing, so only reload, closing the tab and a
+ *  real link out ask, while a change or a save is pending. */
+export function useUnloadGuard(pending) {
+    useEffect(() => {
+        if (!pending)
+            return;
+        const onBeforeUnload = (e) => { e.preventDefault(); e.returnValue = ""; };
+        window.addEventListener("beforeunload", onBeforeUnload);
+        return () => window.removeEventListener("beforeunload", onBeforeUnload);
+    }, [pending]);
+}

package/dist/admin/ui/theme.js

@@ -667,6 +667,7 @@ body:has(.sm-admin){margin:0}
 .sm-row--clickable:hover{background:var(--surface-inset)}
 .sm-cell{overflow:hidden;text-overflow:ellipsis;white-space:nowrap;min-width:0}
 .sm-cell--muted{color:var(--text-muted);font-size:var(--meta-size)}
+.sm-cell--warn{color:var(--warn);font-size:var(--meta-size);overflow:hidden;text-overflow:ellipsis;white-space:nowrap}
 .sm-cell--mono{font-family:var(--font-mono);font-size:var(--text-sm);color:var(--text-muted)}
 .sm-cell--title{font-weight:500}
 .sm-cell--grip{overflow:visible;display:flex;align-items:center;margin-left:-4px}

package/dist/anchors.d.ts

@@ -0,0 +1,42 @@
+import { codeAddresses, type Addresses } from "./addresses.ts";
+import type { LocaleSet } from "./paths.ts";
+export type Anchors = {
+    addresses: Addresses;
+    homePageSlug: string;
+    defaultLocale: string;
+};
+export type AnchorKey = {
+    anchor: string;
+    path: string;
+};
+type PageLike = Parameters<typeof codeAddresses>[0]["pages"][number];
+type CollectionLike = Parameters<typeof codeAddresses>[0]["collections"][number];
+export declare function anchorsFor(input: {
+    locales: LocaleSet;
+    pages?: ReadonlyArray<PageLike>;
+    collections?: ReadonlyArray<CollectionLike>;
+    homePageSlug?: string;
+}): Anchors;
+/** The URL an anchor's own record serves in a locale; the home page's is "/". Null when the config names no address there. */
+export declare function anchorUrl(anchors: Anchors, anchor: string, locale: string): string | null;
+/** A stored row's full URL; null when its anchor has no address (a record no longer in code, a collection without `path`). */
+export declare function fullPath(anchors: Anchors, anchor: string, path: string, locale: string): string | null;
+/** What a request URL may hit, best first: every code address it equals or lies below (the longest first), then the
+ *  editors' tree. `coded`: the URL is code's, so a row without an anchor counts only as a redirect (spec §2). */
+export declare function candidates(anchors: Anchors, locale: string, url: string): {
+    keys: AnchorKey[];
+    coded: boolean;
+};
+/** The anchor a URL is served under: its longest code address, or `''` for the editors' tree (spec §2). A page
+ *  whose own anchor (its chain root's owner key, `''` in the editors' tree) is another one is hidden there: code wins
+ *  the address (spec §4). */
+export declare const servedAnchor: (anchors: Anchors, locale: string, url: string) => string;
+/** Every stored key that yields the same full URL as (anchor, path): a row moving between the editors' tree and a
+ *  code anchor keeps its URL, so it must be the same address to the rewrite (no redirect to itself). An anchor with
+ *  no address has only its own key. */
+export declare function sameUrlKeys(anchors: Anchors, locale: string, anchor: string, path: string): AnchorKey[];
+/** The winning row among those found for `keys`, by key order (spec §2's precedence). */
+export declare function pickHit<R extends AnchorKey & {
+    redirect: boolean;
+}>(found: R[], keys: AnchorKey[], coded: boolean): R | null;
+export {};

package/dist/anchors.js

@@ -0,0 +1,72 @@
+// Anchored paths (spec 2026-09-29 anchored paths): a `paths` row stores
+// the part editors made, under the owner key of the code address it hangs
+// on (`collection:news`, `page:about`; `''` for the editors' tree). The
+// address itself lives only in the config, so a code change moves its
+// URLs at the deploy with no write. Pure: both path index adapters join
+// the address back on through here.
+import { addressMap, codeAddresses } from "./addresses.js";
+export function anchorsFor(input) {
+    return {
+        addresses: addressMap(codeAddresses({ locales: input.locales, pages: input.pages ?? [], collections: input.collections ?? [] })),
+        homePageSlug: input.homePageSlug ?? "home",
+        defaultLocale: input.locales.default,
+    };
+}
+/** The URL an anchor's own record serves in a locale; the home page's is "/". Null when the config names no address there. */
+export function anchorUrl(anchors, anchor, locale) {
+    const byLocale = anchors.addresses[anchor];
+    const address = byLocale?.[locale];
+    if (address === undefined)
+        return null;
+    return byLocale[anchors.defaultLocale] === anchors.homePageSlug ? "/" : `/${address}`;
+}
+/** A stored row's full URL; null when its anchor has no address (a record no longer in code, a collection without `path`). */
+export function fullPath(anchors, anchor, path, locale) {
+    if (anchor === "")
+        return path;
+    const base = anchorUrl(anchors, anchor, locale);
+    if (base === null)
+        return null;
+    if (path === "")
+        return base;
+    return base === "/" ? path : `${base}${path}`;
+}
+/** What a request URL may hit, best first: every code address it equals or lies below (the longest first), then the
+ *  editors' tree. `coded`: the URL is code's, so a row without an anchor counts only as a redirect (spec §2). */
+export function candidates(anchors, locale, url) {
+    const keys = [];
+    for (const anchor of Object.keys(anchors.addresses)) {
+        const base = anchorUrl(anchors, anchor, locale);
+        if (base === null)
+            continue;
+        if (url === base)
+            keys.push({ anchor, path: "" });
+        else if (base !== "/" && url.startsWith(`${base}/`))
+            keys.push({ anchor, path: url.slice(base.length) });
+    }
+    keys.sort((a, b) => a.path.length - b.path.length);
+    return { keys: [...keys, { anchor: "", path: url }], coded: keys.length > 0 };
+}
+/** The anchor a URL is served under: its longest code address, or `''` for the editors' tree (spec §2). A page
+ *  whose own anchor (its chain root's owner key, `''` in the editors' tree) is another one is hidden there: code wins
+ *  the address (spec §4). */
+export const servedAnchor = (anchors, locale, url) => candidates(anchors, locale, url).keys[0].anchor;
+/** Every stored key that yields the same full URL as (anchor, path): a row moving between the editors' tree and a
+ *  code anchor keeps its URL, so it must be the same address to the rewrite (no redirect to itself). An anchor with
+ *  no address has only its own key. */
+export function sameUrlKeys(anchors, locale, anchor, path) {
+    const url = fullPath(anchors, anchor, path, locale);
+    return url === null ? [{ anchor, path }] : candidates(anchors, locale, url).keys;
+}
+/** The winning row among those found for `keys`, by key order (spec §2's precedence). */
+export function pickHit(found, keys, coded) {
+    for (const key of keys) {
+        const row = found.find((r) => r.anchor === key.anchor && r.path === key.path);
+        if (!row)
+            continue;
+        if (coded && key.anchor === "" && !row.redirect)
+            continue;
+        return row;
+    }
+    return null;
+}

package/dist/cli/export.js

@@ -11,6 +11,7 @@ import { schemaBehind, schemaBehindMessage } from "../schema-version.js";
 import { CONTENT_TABLES } from "../sql-space.js";
 import { FORMAT, brokenReferences, countRows, describeExport, emptyTables, fromSpace, sortRows, } from "../space-transfer.js";
 import { MEDIA_BUCKET, connectFromEnv, isNotFound, packageVersion, readSchemaVersion, readSpaceRows, schemaRefusal, } from "./space-io.js";
+import { readCurrentSpace } from "../current-space.js";
 export const defaultExportDir = (now) => `smoodly-export-${now.toISOString().slice(0, 10)}`;
 export const folderExists = (dir) => `Refusing: ${dir} already exists. Remove it, or pass --out <dir>.`;
 export const CHANGED_DURING_EXPORT = "Content changed during export — run it again.";
@@ -26,12 +27,13 @@ export async function runExport(args, out, deps = {}) {
         out(folderExists(shown));
         return 1;
     }
-    const { db, space } = deps.connection ?? connectFromEnv(cwd);
+    const { db } = deps.connection ?? connectFromEnv(cwd);
     const schema = await readSchemaVersion(db);
     if ("missing" in schema) {
         out(schemaRefusal(schema.missing, "Export"));
         return 1;
     }
+    const space = await readCurrentSpace(db);
     if (schemaBehind(schema.version)) {
         out(schemaBehindMessage(schema.version));
         return 1;

package/dist/cli/import.d.ts

@@ -15,5 +15,6 @@ export declare const notAnExport: (dir: string) => string;
 export declare const formatMismatch: (format: unknown) => string;
 export declare const RUN_AGAIN = "Run the same command again to continue: rows and files that landed are skipped.";
 export declare const MEMBERS_HEADING = "Members in the source \u2014 invite them in Settings \u203A Members:";
+export declare const nothingNew: (space: string) => string;
 export declare const CACHE_NOTE = "Restart or redeploy the app: it may have cached pages from while the space was empty.";
 export declare function runImport(args: ImportArgs, out: (line: string) => void, deps?: ImportDeps): Promise<number>;

package/dist/cli/import.js

@@ -9,13 +9,15 @@ import { readFile } from "node:fs/promises";
 import { join, resolve } from "node:path";
 import { MEDIA_CACHE_SECONDS } from "../media.js";
 import { CONTENT_TABLES } from "../sql-space.js";
-import { CONFLICT_COLUMNS, FORMAT, ROW_KEY, describeImport, emptyTables, foreignRows, insertPlan, intoSpace, notEmptyMessage, rowKey, versionMismatchMessage, } from "../space-transfer.js";
+import { CONFLICT_COLUMNS, FORMAT, ROW_KEY, describeImport, emptyTables, foreignRows, insertPlan, intoSpace, missingRows, notEmptyMessage, rowKey, versionMismatchMessage, } from "../space-transfer.js";
 import { MEDIA_BUCKET, connectFromEnv, isAlreadyExists, readSchemaVersion, readSpaceRows, schemaRefusal, } from "./space-io.js";
+import { readCurrentSpace } from "../current-space.js";
 export const BATCH_ROWS = 500;
 export const notAnExport = (dir) => `Refusing: ${dir} is not a Smoodly export (no manifest.json).`;
 export const formatMismatch = (format) => `Refusing: this export's format is ${String(format)}; this smoodly reads format ${FORMAT}. Update smoodly.`;
 export const RUN_AGAIN = "Run the same command again to continue: rows and files that landed are skipped.";
 export const MEMBERS_HEADING = "Members in the source — invite them in Settings › Members:";
+export const nothingNew = (space) => `Nothing new: space ${space} already holds everything in this export.`;
 export const CACHE_NOTE = "Restart or redeploy the app: it may have cached pages from while the space was empty.";
 export async function runImport(args, out, deps = {}) {
     const cwd = deps.cwd ?? process.cwd();
@@ -30,12 +32,13 @@ export async function runImport(args, out, deps = {}) {
         out(formatMismatch(manifest.format));
         return 1;
     }
-    const { db, space } = deps.connection ?? connectFromEnv(cwd);
+    const { db } = deps.connection ?? connectFromEnv(cwd);
     const schema = await readSchemaVersion(db);
     if ("missing" in schema) {
         out(schemaRefusal(schema.missing, "Import"));
         return 1;
     }
+    const space = await readCurrentSpace(db);
     if (schema.version !== manifest.schemaVersion) {
         out(versionMismatchMessage(schema.version, manifest.schemaVersion));
         return 1;
@@ -52,6 +55,8 @@ export async function runImport(args, out, deps = {}) {
         out(notEmptyMessage(foreign));
         return 1;
     }
+    const newRows = missingRows(target, rows);
+    let newFiles = 0;
     try {
         // Media first, so no ready asset row ever points at a missing file.
         for (const asset of rows.assets) {
@@ -66,6 +71,8 @@ export async function runImport(args, out, deps = {}) {
             });
             if (up.error && !isAlreadyExists(up.error))
                 throw new Error(`uploading ${path}: ${up.error.message}`);
+            if (!up.error)
+                newFiles++;
         }
         const size = deps.batchSize ?? BATCH_ROWS;
         for (const { table, rows: list } of insertPlan(rows)) {
@@ -83,6 +90,10 @@ export async function runImport(args, out, deps = {}) {
         out(RUN_AGAIN);
         return 1;
     }
+    if (newRows === 0 && newFiles === 0) {
+        out(nothingNew(space));
+        return 0;
+    }
     out(`Imported ${describeImport(rows)} into space ${space}.`);
     if (manifest.members.length > 0) {
         out(MEMBERS_HEADING);

package/dist/cli/space-io.d.ts

@@ -3,14 +3,13 @@ import type { ContentTable } from "../sql-space.ts";
 import { type Row } from "../space-transfer.ts";
 export type SpaceConnection = {
     db: SupabaseClient;
-    space: string;
 };
 export declare const MEDIA_BUCKET = "media";
 /** Rows per request. A host may cap below it, so a read stops at the first empty page, not the first short one. */
 export declare const PAGE_ROWS = 1000;
 /** `.env.local`, then `.env`, as Next reads them; a variable already set wins (spec §5). */
 export declare function loadAppEnv(cwd: string, env?: Record<string, string | undefined>): void;
-/** The app's content client and the space its secret key names: a cloud key's claim, or the default space. */
+/** The app's content client, from its env. */
 export declare function connectFromEnv(cwd: string): SpaceConnection;
 /** The policies show `smoodly_meta` to a write key only, so no visible row means the key is not a secret key (spec §5). */
 export declare function readSchemaVersion(db: SupabaseClient): Promise<{

package/dist/cli/space-io.js

@@ -1,13 +1,14 @@
 // packages/smoodly/src/cli/space-io.ts
 // What export and import share (spec 2026-09-28 export/import §5, §8):
-// the app's env, the client and the space its key names, the schema-
+// the app's env and client (the space is the database's answer, read
+// after the schema check so a missing schema is refused first), the schema-
 // version read that doubles as the secret-key check, paged reads of one
 // space's rows, and the two storage error tests.
 import { existsSync, readFileSync } from "node:fs";
 import { join } from "node:path";
 import { parseEnv } from "node:util";
 import { createSmoodlyClient } from "../client.js";
-import { resolveSmoodlyEnv, spaceIdOfKey } from "../env.js";
+import { resolveSmoodlyEnv } from "../env.js";
 import { SCHEMA_VERSION_KEY } from "../schema-version.js";
 import { ROW_KEY } from "../space-transfer.js";
 export const MEDIA_BUCKET = "media";
@@ -25,11 +26,10 @@ export function loadAppEnv(cwd, env = process.env) {
         }
     }
 }
-/** The app's content client and the space its secret key names: a cloud key's claim, or the default space. */
+/** The app's content client, from its env. */
 export function connectFromEnv(cwd) {
     loadAppEnv(cwd);
-    const env = resolveSmoodlyEnv(process.env);
-    return { db: createSmoodlyClient(env), space: spaceIdOfKey(env.secretKey) };
+    return { db: createSmoodlyClient(resolveSmoodlyEnv(process.env)) };
 }
 /** The policies show `smoodly_meta` to a write key only, so no visible row means the key is not a secret key (spec §5). */
 export async function readSchemaVersion(db) {

package/dist/collections.js

@@ -36,7 +36,12 @@ export function collection(input) {
     }
     // f.slug({ from }) follows a field in the entry form (spec 2026-09-28
     // ASCII slugs §5): a typo would silently never follow, so it fails here.
+    // Only the key `slug` is the entry's URL; under another key the field
+    // would look like one and never be it.
     for (const [key, builder] of Object.entries(input.fields)) {
+        if (builder.descriptor.type === "slug" && key !== "slug") {
+            throw new Error(`smoodly: collection "${input.name}" declares f.slug() as "${key}" — name it "slug": only the slug field is the entry's URL.`);
+        }
         const from = builder.descriptor.type === "slug" ? builder.descriptor.from : undefined;
         if (from === key)
             throw new Error(`smoodly: collection "${input.name}" slug field "${key}" cannot follow itself.`);

package/dist/config.d.ts

@@ -1,6 +1,8 @@
 import type { Descriptor } from "./fields.ts";
 import type { CollectionSchema } from "./collections.ts";
 import type { GlobalSchema } from "./global.ts";
+import { type Addresses } from "./addresses.ts";
+import type { Anchors } from "./anchors.ts";
 import { type StyleValues, type StyleValuesInput } from "./styles.ts";
 import { type CustomConfigInput, type ResolvedCustom } from "./custom/index.ts";
 type Registered = {
@@ -87,6 +89,10 @@ export type ResolvedConfig = Omit<SmoodlyConfig, "styles" | "custom" | "admin">
     admin: {
         path: string;
     };
+    /** Code-owned addresses by owner key (spec 2026-09-29 nested paths §3). */
+    addresses: Addresses;
+    /** The path index's view of the code-owned addresses (spec 2026-09-29 anchored paths §2): pass it to the index. */
+    anchors: Anchors;
 };
 /** `global`: the placement node type and an admin route; `asset`: the refs
  *  target of every media edge; `media`: the admin's Media screen route. */

package/dist/config.js

@@ -1,4 +1,5 @@
-import { assertSegment, fixedPageSegments, perLocaleSegments } from "./paths.js";
+import { assertSegment, fixedPageSegments } from "./paths.js";
+import { addressMap, assertAddress, codeAddresses, lastPart } from "./addresses.js";
 import { DEFAULT_MEDIA } from "./media.js";
 import { DEFAULT_ADMIN_PATH, assertAdminPath, isAdminSlug } from "./admin-path.js";
 import { resolveStyleValues, styleDescriptors } from "./styles.js";
@@ -54,17 +55,18 @@ function assertGlobalSections(config) {
         }
     }
 }
-/** Every root-level segment a registration claims, per locale: fixed page
- *  slugs and collection paths. Two claims on one (locale, segment) are a
- *  conflict — except a fixed page sitting at a collection's segment in
- *  EVERY locale of that path, which is the collection's index page. The
- *  admin's own segment is refused outright (spec 2026-09-17 slug guard §5). */
+/** Every address a registration claims, per locale: fixed page slugs and
+ *  collection paths, each one or more segments (spec 2026-09-29 nested
+ *  paths §2). Two claims on one (locale, address) are a conflict — except
+ *  a fixed page sitting at a collection's address in EVERY locale of that
+ *  path, which is the collection's index page — and nothing may sit
+ *  inside a collection's address. An address starting at the admin's
+ *  segment is refused outright (spec 2026-09-17 slug guard §5). */
 function assertRootSegments(config, adminPath) {
-    const { default: def, supported } = config.locales;
-    // Mounts claim exactly the locales their path names; fixed pages fill an
-    // omitted locale from the default one, so the check must fill the same
-    // way the materializer does or the clash only shows up at materialization.
-    const perLocale = (v) => perLocaleSegments(v, supported);
+    const { default: def } = config.locales;
+    // Fixed slugs and collection paths both fill an omitted locale from the
+    // default one — where the materializer puts the record and the entry
+    // derivation puts the entries — so the checks see every clash at boot.
     const pageSegments = (v) => fixedPageSegments(v, config.locales);
     const pages = (config.registry.pages ?? []).filter((p) => p.schema.kind === "page" && p.schema.slug !== undefined);
     const owners = new Map(); // "<locale> <segment>" → page name
@@ -74,8 +76,8 @@ function assertRootSegments(config, adminPath) {
             throw new Error(`smoodly: page "${p.schema.name}" declares a per-locale slug without the default locale "${def}".`);
         }
         for (const [locale, segment] of Object.entries(pageSegments(slug))) {
-            assertSegment(segment, `page "${p.schema.name}" fixed slug`);
-            if (isAdminSlug(segment, adminPath)) {
+            assertAddress(segment, `page "${p.schema.name}" fixed slug`);
+            if (isAdminSlug(segment.split("/")[0], adminPath)) {
                 throw new Error(`smoodly: page "${p.schema.name}" has the fixed slug "${segment}", where the admin lives — change its slug or admin.path.`);
             }
             const owner = owners.get(`${locale} ${segment}`);
@@ -96,15 +98,15 @@ function assertRootSegments(config, adminPath) {
         if (typeof c.path !== "string" && c.path[def] === undefined) {
             throw new Error(`smoodly: collection "${c.name}" declares a per-locale path without the default locale "${def}".`);
         }
-        const segments = perLocale(c.path);
+        const segments = pageSegments(c.path);
         for (const [locale, segment] of Object.entries(segments)) {
-            assertSegment(segment, `collection "${c.name}" path`);
-            if (isAdminSlug(segment, adminPath)) {
+            assertAddress(segment, `collection "${c.name}" path`);
+            if (isAdminSlug(segment.split("/")[0], adminPath)) {
                 throw new Error(`smoodly: collection "${c.name}" is mounted at "${adminPath}", where the admin lives — change its path or admin.path.`);
             }
             const other = collectionOwners.get(`${locale} ${segment}`);
             if (other) {
-                throw new Error(`smoodly: collections "${other}" and "${c.name}" both claim the root segment "${segment}" (${locale}).`);
+                throw new Error(`smoodly: collections "${other}" and "${c.name}" both claim the address "${segment}" (${locale}).`);
             }
             collectionOwners.set(`${locale} ${segment}`, c.name);
         }
@@ -116,10 +118,30 @@ function assertRootSegments(config, adminPath) {
             const page = pages.find((p) => p.schema.name === pageName);
             const everywhere = Object.entries(segments).every(([l, s]) => pageSegments(page.schema.slug)[l] === s);
             if (!everywhere) {
-                throw new Error(`smoodly: collection "${c.name}" and page registration "${pageName}" both claim the root segment "${segment}" (${locale}).`);
+                throw new Error(`smoodly: collection "${c.name}" and page registration "${pageName}" both claim the address "${segment}" (${locale}).`);
             }
         }
     }
+    // A collection's entries live below its address: nothing else may sit there (spec 2026-09-29 nested paths §2).
+    const claims = [];
+    for (const p of pages)
+        for (const [locale, address] of Object.entries(pageSegments(p.schema.slug)))
+            claims.push({ what: `page "${p.schema.name}"`, locale, address });
+    for (const c of config.registry.collections ?? []) {
+        if (c.path === undefined)
+            continue;
+        for (const [locale, address] of Object.entries(pageSegments(c.path)))
+            claims.push({ what: `collection "${c.name}"`, locale, address });
+    }
+    for (const c of config.registry.collections ?? []) {
+        if (c.path === undefined)
+            continue;
+        for (const [locale, base] of Object.entries(pageSegments(c.path))) {
+            const inside = claims.find((x) => x.locale === locale && x.address.startsWith(`${base}/`));
+            if (inside)
+                throw new Error(`smoodly: ${inside.what} at "${inside.address}" (${locale}) sits inside collection "${c.name}" — its entries live there.`);
+        }
+    }
 }
 /** A language subtag, optionally a script or region subtag (`en`, `fi`,
  *  `en-US`, `zh-Hant`). Codes are otherwise opaque strings all the way
@@ -204,6 +226,16 @@ export function defineConfig(config) {
             throw new Error(`smoodly: homePageSlug "${homePageSlug}" is also the path of collection "${c.name}".`);
         }
     }
+    // A code-owned record keeps its address's last part as its slug, and the
+    // root record slugged homePageSlug IS the home page: a nested address
+    // ending in it would serve "/" (spec 2026-09-29 nested paths §3).
+    for (const a of codeAddresses({ locales: config.locales, pages: config.registry.pages ?? [], collections: config.registry.collections ?? [] })) {
+        for (const [locale, address] of Object.entries(a.segments)) {
+            if (address.includes("/") && lastPart(address) === homePageSlug) {
+                throw new Error(`smoodly: the address "${address}" (${locale}) ends in homePageSlug "${homePageSlug}" — its record would be the home page; end it in another segment.`);
+            }
+        }
+    }
     const styles = resolveStyleValues(config.styles);
     const custom = resolveCustom(config.custom);
     const byName = new Map((config.registry.sections ?? []).map((s) => [s.schema.name, s.schema]));
@@ -214,12 +246,15 @@ export function defineConfig(config) {
     if (!Number.isInteger(media.maxSize) || media.maxSize <= 0) {
         throw new Error("smoodly: media.maxSize must be a positive integer of bytes.");
     }
+    const addresses = addressMap(codeAddresses({ locales: config.locales, pages: config.registry.pages ?? [], collections: config.registry.collections ?? [] }));
     return {
         ...config,
         homePageSlug,
         pageDepth: depth,
         media,
         admin: { path: adminPath },
+        addresses,
+        anchors: { addresses, homePageSlug, defaultLocale: config.locales.default },
         styles,
         css: config.css === true,
         custom,

package/dist/current-space.d.ts

@@ -0,0 +1,4 @@
+import type { SupabaseClient } from "@supabase/supabase-js";
+type RpcClient = Pick<SupabaseClient, "rpc">;
+export declare function readCurrentSpace(db: RpcClient): Promise<string>;
+export {};

package/dist/current-space.js

@@ -0,0 +1,9 @@
+export async function readCurrentSpace(db) {
+    const res = await db.rpc("smoodly_current_space");
+    if (res.error)
+        throw new Error(`smoodly: reading the space: ${res.error.message}`);
+    if (typeof res.data !== "string" || !res.data) {
+        throw new Error("smoodly: smoodly_current_space() returned no space — is the schema up to date?");
+    }
+    return res.data;
+}

package/dist/entry-store.js

@@ -13,6 +13,7 @@ import { collectionDepth, collectionOrder } from "./collections.js";
 import { collectEntryRefs } from "./refs.js";
 import { MemoryRefIndex } from "./ref-index.js";
 import { MemoryPathIndex } from "./path-index.js";
+import { anchorsFor } from "./anchors.js";
 import { groupRedirects } from "./store.js";
 import { assertFresh } from "./draft-token.js";
 import { globalEntryId } from "./global-id.js";
@@ -183,9 +184,10 @@ export class MemoryEntryStore {
         this.seq = 0;
         this.order = new Map();
         this.byId = (id) => this.entries.get(id);
-        this.paths = options.paths ?? new MemoryPathIndex();
         this.locales = options.locales ?? DEFAULT_ENTRY_LOCALES;
         this.schemas = [...collections, ...(options.globals ?? [])];
+        // Alone, the store's own index reads its collections' addresses (spec 2026-09-29 anchored paths §2).
+        this.paths = options.paths ?? new MemoryPathIndex(anchorsFor({ locales: this.locales, collections }));
         this.elements = options.elements;
     }
     schema(collection) {
@@ -283,7 +285,7 @@ export class MemoryEntryStore {
         return sets;
     }
     async writePaths(collection, nodes, redirect = true) {
-        await this.paths.rewrite(rewriteTargets("entry", nodes, redirect), entryPathRows(nodes, this.byId, this.schema(collection), this.locales));
+        await this.paths.rewrite(rewriteTargets("entry", nodes, redirect), entryPathRows(nodes, this.byId, collection));
     }
     writeRefs(entry) {
         this.refs.rewrite({ sourceKind: "entry", sourceId: entry.id }, entryRefEdges(this.liveFieldSets(entry), this.schema(entry.collection), this.elements));