smoodly 0.0.32 → 0.0.34

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

@@ -34,6 +34,21 @@ export function collection(input) {
         input.fields[input.order.by]?.descriptor.localized === true) {
         throw new Error(`smoodly: collection "${input.name}" orders by "${input.order.by}", which is localized — order fields are shared across locales.`);
     }
+    // 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.`);
+        if (typeof from === "string" && !Object.prototype.hasOwnProperty.call(input.fields, from)) {
+            throw new Error(`smoodly: collection "${input.name}" slug field "${key}" follows an unknown field "${from}".`);
+        }
+    }
     return {
         kind: "collection",
         name: input.name,

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

@@ -57,9 +57,11 @@ export { affectedTargets, pageTag, entryTag, globalTag, pagesTreeTag, collection
 export type { AffectedTargets } from "./revalidate.ts";
 export { resolveTree, resolveFields, resolveMedia } from "./resolve.ts";
 export type { EntryFetcher, ResolveFieldsOptions, AssetFetcher } from "./resolve.ts";
-export { SEGMENT_RE, isSegment, assertSegment, joinPath, splitPath, segmentFor, isHomeNode, pagePathIn, chainOf, assertDepth, pagePath, pagePathRows, entryPathRows, collectionSegment, buildPageTree, perLocaleSegments, assertSupportedLocale, unsupportedLocale, pageAlternates, entryAlternates, } from "./paths.ts";
+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

@@ -41,8 +41,10 @@ export { SupabasePathIndex } from "./supabase-path-index.js";
 export { entryErrors, compareEntries, DEFAULT_ENTRY_LOCALES, localizedKeys, splitFields, entryLocaleRow, entryFieldsIn, entryRefEdges, entryTitleIn, matchesWhere, } from "./entry-store.js";
 export { affectedTargets, pageTag, entryTag, globalTag, pagesTreeTag, collectionTag } from "./revalidate.js";
 export { resolveTree, resolveFields, resolveMedia } from "./resolve.js";
-export { SEGMENT_RE, isSegment, assertSegment, joinPath, splitPath, segmentFor, isHomeNode, pagePathIn, chainOf, assertDepth, pagePath, pagePathRows, entryPathRows, collectionSegment, buildPageTree, perLocaleSegments, assertSupportedLocale, unsupportedLocale, pageAlternates, entryAlternates, } from "./paths.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>;
 }

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