smoodly 0.0.33 → 0.0.34

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));

package/dist/env.d.ts

@@ -1,3 +1,4 @@
+import { readCurrentSpace } from "./current-space.ts";
 export type SmoodlyEnv = {
     /** The content project. */
     url: string;
@@ -20,6 +21,6 @@ export type ContentConfig = {
     key: string;
     spaceId: string;
 };
-/** The space a key acts in: its `space_id` claim when it is a JWT that carries one, else the default space. */
-export declare function spaceIdOfKey(key: string): string;
-export declare function publicContentConfig(env: SmoodlyEnv): ContentConfig;
+/** The public config, with the space the database says the secret key acts in —
+ *  asked, never read out of the key, so it cannot disagree with where rows land. */
+export declare function publicContentConfig(env: SmoodlyEnv, db?: Parameters<typeof readCurrentSpace>[0]): Promise<ContentConfig>;

package/dist/env.js

@@ -1,7 +1,8 @@
 // The one config shape (spec 2026-09-04 §4/§6). Self-host sets three
 // names; the cloud sets five. The two defaults are what keep a single
 // code path: a default for an absent value is not a mode branch.
-import { DEFAULT_SPACE_ID } from "./sql-space.js";
+import { createSmoodlyClient } from "./client.js";
+import { readCurrentSpace } from "./current-space.js";
 const REQUIRED = ["SMOODLY_URL", "SMOODLY_SECRET_KEY", "SMOODLY_PUBLISHABLE_KEY"];
 export function resolveSmoodlyEnv(env) {
     const missing = REQUIRED.filter((name) => !env[name]);
@@ -21,21 +22,18 @@ export function resolveSmoodlyEnv(env) {
 /** `resolveSmoodlyEnv(process.env)` — call lazily, never at module load,
  *  so `next build` without env still succeeds. */
 export const smoodlyEnv = () => resolveSmoodlyEnv(process.env);
-/** The space a key acts in: its `space_id` claim when it is a JWT that carries one, else the default space. */
-export function spaceIdOfKey(key) {
-    const parts = key.split(".");
-    if (parts.length !== 3)
-        return DEFAULT_SPACE_ID;
-    try {
-        // base64url → base64, padded; atob exists in Node 22 and every browser, so no Buffer here.
-        const b64 = parts[1].replace(/-/g, "+").replace(/_/g, "/").padEnd(Math.ceil(parts[1].length / 4) * 4, "=");
-        const claims = JSON.parse(atob(b64));
-        return typeof claims.space_id === "string" && claims.space_id ? claims.space_id : DEFAULT_SPACE_ID;
+/** One lookup per process per content project and key: the space never
+ *  changes for a key. A failed lookup is not cached, so the next call retries. */
+const spaces = new Map();
+/** The public config, with the space the database says the secret key acts in —
+ *  asked, never read out of the key, so it cannot disagree with where rows land. */
+export function publicContentConfig(env, db) {
+    const cacheKey = `${env.url}\n${env.secretKey}`;
+    let space = spaces.get(cacheKey);
+    if (!space) {
+        space = readCurrentSpace(db ?? createSmoodlyClient(env));
+        spaces.set(cacheKey, space);
+        space.catch(() => spaces.delete(cacheKey));
     }
-    catch {
-        return DEFAULT_SPACE_ID;
-    }
-}
-export function publicContentConfig(env) {
-    return { url: env.url, key: env.publishableKey, spaceId: spaceIdOfKey(env.secretKey) };
+    return space.then((spaceId) => ({ url: env.url, key: env.publishableKey, spaceId }));
 }

package/dist/index.d.ts

@@ -60,6 +60,8 @@ export type { EntryFetcher, ResolveFieldsOptions, AssetFetcher } from "./resolve
 export { SEGMENT_RE, isSegment, assertSegment, slugify, joinPath, splitPath, segmentFor, isHomeNode, pagePathIn, chainOf, assertDepth, pagePath, pagePathRows, entryPathRows, collectionSegment, buildPageTree, perLocaleSegments, assertSupportedLocale, unsupportedLocale, pageAlternates, entryAlternates, } from "./paths.ts";
 export type { LocaleSet, PathTarget, PathRow, PageLike, EntryLike, PageTreeNode, PagePathOptions, LocaleAlternate, PageAlternate } from "./paths.ts";
 export { fixedPathFor } from "./localize.ts";
+export { addressMap, assertAddress, codeAddresses, collectionKey, lastPart, ownerCollection, pageKey, type Addresses, type CodeAddress } from "./addresses.ts";
+export { anchorUrl, anchorsFor, candidates, fullPath, pickHit, type AnchorKey, type Anchors } from "./anchors.ts";
 export type { PageStore, PageRecord, PageLocale, PageVersion, PageScan, PageStoreOptions, CreatePageInput, AddLocaleOptions } from "./store.ts";
 export { pathOptions, pageErrors, localeRow, pageRefEdges, DEFAULT_LOCALES } from "./store.ts";
 export type { SmoodlyConfig, ResolvedConfig } from "./config.ts";
@@ -155,7 +157,7 @@ export declare const smoodly: {
 };
 export { NODE_ATTR, ZONE_ATTR, EMPTY_ATTR, BLANK_ATTR, FIELD_ATTR, ITEM_ATTR, EDITOR_ATTR, resolveMarkPath } from "./marks.ts";
 export type { MarkNode, MarkPath, Marks, Scope } from "./marks.ts";
-export { resolveSmoodlyEnv, smoodlyEnv, publicContentConfig, spaceIdOfKey } from "./env.ts";
+export { resolveSmoodlyEnv, smoodlyEnv, publicContentConfig } from "./env.ts";
 export type { SmoodlyEnv, ContentConfig } from "./env.ts";
 export { clientOptions, createSmoodlyClient } from "./client.ts";
 export { createSmoodlySite, pageContextOf } from "./site.ts";

package/dist/index.js

@@ -43,6 +43,8 @@ export { affectedTargets, pageTag, entryTag, globalTag, pagesTreeTag, collection
 export { resolveTree, resolveFields, resolveMedia } from "./resolve.js";
 export { SEGMENT_RE, isSegment, assertSegment, slugify, joinPath, splitPath, segmentFor, isHomeNode, pagePathIn, chainOf, assertDepth, pagePath, pagePathRows, entryPathRows, collectionSegment, buildPageTree, perLocaleSegments, assertSupportedLocale, unsupportedLocale, pageAlternates, entryAlternates, } from "./paths.js";
 export { fixedPathFor } from "./localize.js";
+export { addressMap, assertAddress, codeAddresses, collectionKey, lastPart, ownerCollection, pageKey } from "./addresses.js";
+export { anchorUrl, anchorsFor, candidates, fullPath, pickHit } from "./anchors.js";
 export { pathOptions, pageErrors, localeRow, pageRefEdges, DEFAULT_LOCALES } from "./store.js";
 export { DEFAULT_TOOLSET } from "./toolset.js";
 export { collectionOrder, collectionDepth, DEFAULT_ORDER } from "./collections.js";
@@ -64,6 +66,6 @@ export const smoodly = {
     marks,
 };
 export { NODE_ATTR, ZONE_ATTR, EMPTY_ATTR, BLANK_ATTR, FIELD_ATTR, ITEM_ATTR, EDITOR_ATTR, resolveMarkPath } from "./marks.js";
-export { resolveSmoodlyEnv, smoodlyEnv, publicContentConfig, spaceIdOfKey } from "./env.js";
+export { resolveSmoodlyEnv, smoodlyEnv, publicContentConfig } from "./env.js";
 export { clientOptions, createSmoodlyClient } from "./client.js";
 export { createSmoodlySite, pageContextOf } from "./site.js";

package/dist/next/page-renderer.js

@@ -13,7 +13,7 @@ import { EditorBridge } from "../admin/next/bridge.js";
 import { CanvasBoundary } from "./canvas-boundary.js";
 import { DRAFT_META_NAME } from "../admin/editor/canvas-diagnosis.js";
 import { fixedPathFor } from "../localize.js";
-import { joinPath } from "../paths.js";
+import { decodeSegment, joinPath } from "../paths.js";
 import { renderPage } from "../render.js";
 import { entryTag, pageTag, globalTag } from "../revalidate.js";
 import { pageContextOf } from "../site.js";
@@ -137,7 +137,7 @@ export function createPageRenderer(options) {
     /** Resolved AFTER connection(), inside page()/metadata(), so a wiring
      *  error surfaces as a rejected promise like every other failure. */
     const fixedPath = (Page) => (locale) => fixedPathFor(Page.schema, locale, site.locales, site.homePageSlug);
-    const literal = (segments) => () => joinPath(segments);
+    const literal = (segments) => () => joinPath(segments.map(decodeSegment));
     /** A global item for a layout: cached per (item, locale) under the
      *  global tag outside draft mode, the live draft inside it. */
     async function getSmoodlyGlobal(item, opts) {

package/dist/path-index.d.ts

@@ -1,4 +1,5 @@
 import type { PathRow, PathTarget } from "./paths.ts";
+import { type Anchors } from "./anchors.ts";
 export type { PathRow, PathTarget } from "./paths.ts";
 /** A rewrite target; `redirectLocales` names the locales whose old live rows stay as redirects (none = drop them). */
 export type RewriteTarget = PathTarget & {
@@ -27,14 +28,24 @@ export interface PathIndex {
 export declare const pathTakenError: (locale: string, path: string) => Error;
 export declare const pathLiveError: (locale: string, path: string) => Error;
 export declare class MemoryPathIndex implements PathIndex {
+    private anchors;
     private rows;
+    /** Held by reference: the config's addresses, read on every call (spec 2026-09-29 anchored paths §2). */
+    constructor(anchors?: Anchors);
+    /** A stored row as callers see it: the full URL, or nothing when its anchor has no address. */
+    private shown;
+    private shownAll;
     rewrite(targets: RewriteTarget[], rows: PathRow[]): Promise<void>;
     remove(targets: PathTarget[]): Promise<void>;
+    private hit;
     resolve(locale: string, path: string): Promise<PathHit | null>;
     pathsOf(target: PathTarget): Promise<Record<string, string>>;
     redirectsOf(target: PathTarget): Promise<PathRow[]>;
+    /** Every live URL in the locale; an editor's row under a code address is left out, since visitors never reach it (spec §4). */
     listLive(locale: string): Promise<PathRow[]>;
     listRedirects(locale: string): Promise<PathRow[]>;
+    /** A redirect by hand stays absolute (anchor ''): refused where the URL resolves live; a redirect there is replaced. */
     addRedirect(row: PathRow): Promise<void>;
+    /** Deletes the redirect rows a URL reaches, under any candidate anchor; a live row there is left alone. */
     removeRedirect(locale: string, path: string): Promise<void>;
 }