rimecms 0.32.1 → 1.0.0

package/dist/core/prototype/collection/operations/update-slug-by-id.d.ts

@@ -0,0 +1,20 @@
+import type { PathRow } from '../../../adapter.js';
+import type { BuiltCollection } from '../../../config/types.js';
+import type { PrototypeApiContext } from '../../define.js';
+export type UpdateSlugByIdArgs = {
+    id: string;
+    slug: string;
+    /** The locale whose address changes; the others keep theirs. */
+    locale?: string | undefined;
+};
+type Args = UpdateSlugByIdArgs & {
+    ctx: PrototypeApiContext<BuiltCollection>;
+};
+/**
+ * A page's slug in one locale: its address changes, and the pages under it follow.
+ *
+ * On the published page only, for whoever may update it. A slug a sibling holds is refused as a
+ * field error on `_slug`.
+ */
+export declare const updateSlugById: (args: Args) => Promise<PathRow>;
+export {};

package/dist/core/prototype/collection/operations/update-slug-by-id.js

@@ -0,0 +1,53 @@
+import { RimeError, RimeFormError } from '../../../errors/index.js';
+import { toSlug } from '../../shared/url/format.server.js';
+import { refreshUrls } from '../../shared/url/refresh.server.js';
+/**
+ * A page's slug in one locale: its address changes, and the pages under it follow.
+ *
+ * On the published page only, for whoever may update it. A slug a sibling holds is refused as a
+ * field error on `_slug`.
+ */
+export const updateSlugById = async (args) => {
+    const { ctx, id } = args;
+    const { config, event, isSystemOperation } = ctx;
+    const { rime } = event.locals;
+    const locale = args.locale ?? '';
+    if (!config.$url) {
+        throw new RimeError(RimeError.BAD_REQUEST, `${config.slug} has no $url, so no slug`);
+    }
+    if (!isSystemOperation && !config.access.update(event.locals.user, { event, id })) {
+        throw new RimeError(RimeError.UNAUTHORIZED);
+    }
+    const collection = rime.collection(config.slug).system();
+    const byId = { where: { id: { equals: id } } };
+    // Without `latest`, a read with drafts answers the published version only.
+    const [page] = await collection.find({ query: byId, locale: locale || undefined });
+    if (!page) {
+        const [draft] = await collection.find({
+            query: byId,
+            locale: locale || undefined,
+            latest: true
+        });
+        if (!draft)
+            throw new RimeError(RimeError.NOT_FOUND);
+        throw new RimeError(RimeError.BAD_REQUEST, 'the slug changes on the published page');
+    }
+    const value = toSlug(args.slug);
+    if (!value)
+        throw new RimeFormError({ _slug: RimeFormError.REQUIRED_FIELD });
+    const [current] = await rime.adapter.paths.get({ slug: config.slug, ownerId: id, locale });
+    if (!current)
+        throw new RimeError(RimeError.NOT_FOUND);
+    if (current.slug === value)
+        return current;
+    const parentId = page._parent ?? null;
+    const taken = await rime.adapter.paths.siblingSlugs({ slug: config.slug, locale, parentId });
+    if (taken.includes(value))
+        throw new RimeFormError({ _slug: RimeFormError.UNIQUE_FIELD });
+    const row = await rime.adapter.paths.setSlug({ slug: config.slug, ownerId: id, locale, value });
+    if (!row)
+        throw new RimeError(RimeError.NOT_FOUND);
+    await refreshUrls({ event, config, locale, path: row.path });
+    const [updated] = await rime.adapter.paths.get({ slug: config.slug, ownerId: id, locale });
+    return updated;
+};

package/dist/core/prototype/collection/rest/index.server.js

@@ -6,6 +6,7 @@ import { restGet } from './get.server.js';
 import { restGetById } from './get-by-id.server.js';
 import { restLock, restUnlock } from './lock.server.js';
 import { restUpdateById } from './update-by-id.server.js';
+import { restUpdateSlugById } from './update-slug-by-id.server.js';
 /**
  * The REST surface a collection provides.
  *
@@ -20,5 +21,6 @@ export const rest = {
     '': { GET: restGet, POST: restCreate, DELETE: restDelete },
     '[id]': { GET: restGetById, PATCH: restUpdateById, DELETE: restDeleteById },
     '[id]/duplicate': { POST: restDuplicate },
-    '[id]/lock': { POST: restLock, DELETE: restUnlock }
+    '[id]/lock': { POST: restLock, DELETE: restUnlock },
+    '[id]/slug': { PATCH: restUpdateSlugById }
 };

package/dist/core/prototype/collection/rest/update-slug-by-id.server.d.ts

@@ -0,0 +1,2 @@
+/** `PATCH /api/<collection>/<id>/slug` with `{ slug }`: the page's address in the request's locale. */
+export declare const restUpdateSlugById: import("@sveltejs/kit").RequestHandler;

package/dist/core/prototype/collection/rest/update-slug-by-id.server.js

@@ -0,0 +1,20 @@
+import { ERROR_CONTEXT, handleError } from '../../../errors/handler.server.js';
+import { trycatch } from '../../../../util/function.js';
+import { error, json } from '@sveltejs/kit';
+import { endpoint } from './endpoint.server.js';
+/** `PATCH /api/<collection>/<id>/slug` with `{ slug }`: the page's address in the request's locale. */
+export const restUpdateSlugById = endpoint(async ({ event, collection }) => {
+    if (!event.params.id)
+        throw error(404);
+    const [readError, body] = await trycatch(() => event.request.json());
+    if (readError || typeof body?.slug !== 'string')
+        throw error(400, 'a slug is expected');
+    const [updateError, row] = await trycatch(() => collection.updateSlugById({
+        id: event.params.id,
+        slug: body.slug,
+        locale: event.locals.rime.getLocale()
+    }));
+    if (updateError)
+        return handleError(updateError, { context: ERROR_CONTEXT.API });
+    return json({ slug: row.slug, path: row.path, url: row.url });
+});

package/dist/core/prototype/collection/thumbnail/find-thumbnail.d.ts

@@ -1,9 +1,10 @@
 import type { FieldBuilder } from '../../../fields/builders/field-builder.js';
-import { FormFieldBuilder } from '../../../fields/builders/form-field-builder.js';
+import type { FormFieldBuilder } from '../../../fields/builders/form-field-builder.js';
 import type { Field, FormField } from '../../../../fields/types.js';
 interface ThumbnailFieldResult {
     field: FormFieldBuilder<FormField>;
     path: string;
 }
+/** The first relation marked `isThumbnail()`, at a path a config alone can name. */
 export declare function findThumbnailField(fields?: FieldBuilder<Field>[], basePath?: string): ThumbnailFieldResult | null;
 export {};

package/dist/core/prototype/collection/thumbnail/find-thumbnail.js

@@ -1,34 +1,11 @@
-import { FormFieldBuilder } from '../../../fields/builders/form-field-builder.js';
-import { GroupFieldBuilder } from '../../../../fields/group/index.js';
+import { walkFields } from '../../../fields/walk.js';
 import { RelationFieldBuilder } from '../../../../fields/relation/index.js';
-import { TabsBuilder } from '../../../../fields/tabs/index.js';
+/** The first relation marked `isThumbnail()`, at a path a config alone can name. */
 export function findThumbnailField(fields = [], basePath = '') {
-    for (const field of fields) {
-        // Direct check for isThumbnail
-        if (field instanceof RelationFieldBuilder &&
-            'isThumbnail' in field.get &&
-            field.get.isThumbnail === true) {
-            const path = basePath ? `${basePath}.${field.name}` : field.name;
+    for (const { field, path } of walkFields(fields, { path: basePath, determinate: true })) {
+        if (field instanceof RelationFieldBuilder && field.get.isThumbnail === true) {
             return { field, path };
         }
-        // Check in group
-        if (field instanceof GroupFieldBuilder && field.get.fields) {
-            const groupPath = basePath ? `${basePath}.${field.name}` : field.name;
-            const found = findThumbnailField(field.get.fields, groupPath);
-            if (found)
-                return found;
-        }
-        // Check in tabs
-        if (field instanceof TabsBuilder && field.get.tabs) {
-            for (const tab of field.get.tabs) {
-                if (tab.get.fields) {
-                    const tabPath = basePath ? `${basePath}.${tab.name}` : tab.name;
-                    const found = findThumbnailField(tab.get.fields, tabPath);
-                    if (found)
-                        return found;
-                }
-            }
-        }
     }
     return null;
 }

package/dist/core/prototype/collection/upload/directories/derive.js

@@ -1,3 +1,4 @@
+import { blank } from '../../../blank.js';
 import { prototypeKebab } from '../../../naming.js';
 import { date } from '../../../../../fields/date/index.js';
 import { text } from '../../../../../fields/text/index.js';
@@ -14,6 +15,7 @@ export function makeUploadDirectoriesCollectionClient(collection) {
     const directoriesCollection = {
         slug: slug,
         kebab: prototypeKebab(slug),
+        blank,
         versions: undefined,
         access: {
             read: directoriesConfig?.access?.read || collection.access.read,
@@ -40,7 +42,7 @@ export function makeUploadDirectoriesCollectionClient(collection) {
             text('parent').hidden(),
             ...(directoriesConfig?.fields || []),
             date('createdAt').hidden(),
-            date('updatedAt').hidden()
+            date('updatedAt').hidden().$index()
         ],
         type: 'collection',
         label: {

package/dist/core/prototype/collection/upload/disk/delete.server.js

@@ -1,5 +1,4 @@
 import { logger } from '../../../../logger.server.js';
-import { isFormField } from '../../../../fields/util.js';
 import { existsSync, unlink, unlinkSync } from 'fs';
 import path from 'path';
 /**
@@ -17,7 +16,7 @@ import path from 'path';
  * and with no feature importing another feature to do it.
  */
 const ownsField = (rime, config, name) => {
-    const field = config.fields.filter(isFormField).find((one) => one.name === name);
+    const field = config.fields.find((one) => one.name === name);
     if (!field)
         return false;
     return config._versions ? !!field.get.root : true;

package/dist/core/prototype/define.js

@@ -1,5 +1,6 @@
 import { isStaff } from '../auth/access.js';
 import { FileText } from '@lucide/svelte';
+import { blank } from './blank.js';
 import { prototypeKebab } from './naming.js';
 export const definePrototype = (options = {}) => {
     const name = options.name ?? '';
@@ -23,6 +24,7 @@ export const definePrototype = (options = {}) => {
             ...augmented,
             type: name,
             slug,
+            blank,
             kebab: prototypeKebab(slug),
             fields: augmented.fields || [],
             icon: augmented.icon || FileText,

package/dist/core/prototype/shared/metas/fields.js

@@ -23,5 +23,6 @@ export const metasFields = {
     createdBy: () => text('createdBy').hidden().$root().access(staffOnly),
     createdAt: () => date('createdAt').hidden(),
     updatedBy: () => text('updatedBy').hidden().access(staffOnly),
-    updatedAt: () => date('updatedAt').hidden()
+    // The default sort of every list
+    updatedAt: () => date('updatedAt').hidden().$index()
 };

package/dist/core/prototype/shared/title/find-title.d.ts

@@ -1,5 +1,5 @@
 import type { FieldBuilder } from '../../../fields/builders/field-builder.js';
-import { FormFieldBuilder } from '../../../fields/builders/form-field-builder.js';
+import type { FormFieldBuilder } from '../../../fields/builders/form-field-builder.js';
 import type { DateField } from '../../../../fields/date/index.js';
 import type { EmailField } from '../../../../fields/email/index.js';
 import type { SlugField } from '../../../../fields/slug/index.js';
@@ -10,5 +10,6 @@ interface TitleFieldResult {
     field: FormFieldBuilder<FormField>;
     path: string;
 }
+/** The first field marked `isTitle()`, at a path a config alone can name. */
 export declare function findTitleField(fields?: FieldBuilder<Field>[], basePath?: string): TitleFieldResult | null;
 export {};

package/dist/core/prototype/shared/title/find-title.js

@@ -1,35 +1,12 @@
-import { FormFieldBuilder } from '../../../fields/builders/form-field-builder.js';
-import { GroupFieldBuilder } from '../../../../fields/group/index.js';
-import { TabsBuilder } from '../../../../fields/tabs/index.js';
+import { isFormField } from '../../../fields/util.js';
+import { walkFields } from '../../../fields/walk.js';
 export const hasMaybeTitle = (field) => ['text', 'date', 'slug', 'email', 'richText'].includes(field.type);
+/** The first field marked `isTitle()`, at a path a config alone can name. */
 export function findTitleField(fields = [], basePath = '') {
-    for (const field of fields) {
-        // Direct check for isTitle
-        if (field instanceof FormFieldBuilder &&
-            hasMaybeTitle(field.get) &&
-            'isTitle' in field.get &&
-            field.get.isTitle === true) {
-            const path = basePath ? `${basePath}.${field.name}` : field.name;
+    for (const { field, path } of walkFields(fields, { path: basePath, determinate: true })) {
+        if (isFormField(field) && hasMaybeTitle(field.get) && field.get.isTitle === true) {
             return { field, path };
         }
-        // Check in group
-        if (field instanceof GroupFieldBuilder && field.get.fields) {
-            const groupPath = basePath ? `${basePath}.${field.name}` : field.name;
-            const found = findTitleField(field.get.fields, groupPath);
-            if (found)
-                return found;
-        }
-        // Check in tabs
-        if (field instanceof TabsBuilder && field.get.tabs) {
-            for (const tab of field.get.tabs) {
-                if (tab.get.fields) {
-                    const tabPath = basePath ? `${basePath}.${tab.name}` : tab.name;
-                    const found = findTitleField(tab.get.fields, tabPath);
-                    if (found)
-                        return found;
-                }
-            }
-        }
     }
     return null;
 }

package/dist/core/prototype/shared/url/addresses.server.d.ts

@@ -0,0 +1,26 @@
+import type { BuiltCollection } from '../../../config/types.js';
+import type { GenericDoc } from '../../types.js';
+import type { RequestEvent } from '@sveltejs/kit';
+/** The locales a page has an address in: `''` when the config has no localization. */
+export declare const addressLocales: (event: RequestEvent) => any;
+/** Gives these pages their address in every locale they have none in. */
+export declare const addAddresses: (args: {
+    event: RequestEvent;
+    config: BuiltCollection;
+    ids: string[];
+}) => Promise<void>;
+/**
+ * The document with its address as it now is: the read that produced it ran before a create or an
+ * update gave it one.
+ */
+export declare const withAddress: <T extends GenericDoc>(args: {
+    event: RequestEvent;
+    config: BuiltCollection;
+    doc: T;
+}) => Promise<T>;
+/**
+ * Once per process, on the first request: every page of a collection with `$url` gets the address
+ * it is missing. One query per collection and locale once they all have one. The requests after
+ * it are not held: nothing to await once it is done.
+ */
+export declare const ensureAddresses: (event: RequestEvent) => Promise<void>;

package/dist/core/prototype/shared/url/addresses.server.js

@@ -0,0 +1,119 @@
+import { walkFields } from '../../../fields/walk.js';
+import { logger } from '../../../logger.server.js';
+import { getValueAtPath } from '../../../../util/object.js';
+import { hasUrl } from './enabled.js';
+import { freeSlug, toSlug } from './format.server.js';
+import { formatRows, readForUrls } from './refresh.server.js';
+/** The locales a page has an address in: `''` when the config has no localization. */
+export const addressLocales = (event) => {
+    const codes = event.locals.rime.config.getLocalesCodes();
+    return codes.length ? codes : [''];
+};
+/**
+ * The slug a page starts with: the collection's own slug field when it has one, its title
+ * otherwise, its id as a last resort.
+ */
+const initialSlug = (config, doc) => {
+    for (const { field, path } of walkFields(config.fields)) {
+        if (field.type !== 'slug')
+            continue;
+        const value = toSlug(getValueAtPath(path, doc));
+        if (value)
+            return value;
+    }
+    return toSlug(doc.title) || doc.id;
+};
+/**
+ * Gives these pages their address in one locale: a slug free among their siblings, under their
+ * parent, then their url.
+ *
+ * A page is placed once its parent is, so a whole tree goes in, top first, in one call.
+ */
+const addAddressesIn = async (args) => {
+    const { event, config, ids, locale } = args;
+    const { paths } = event.locals.rime.adapter;
+    const docs = await readForUrls({ event, config, locale, ids });
+    const parentOf = (id) => docs.get(id)._parent ?? null;
+    let pending = ids.filter((id) => docs.has(id));
+    const inserted = [];
+    while (pending.length) {
+        const ready = pending.filter((id) => !pending.includes(parentOf(id) ?? ''));
+        if (!ready.length)
+            break;
+        for (const id of ready) {
+            const parentId = parentOf(id);
+            const taken = await paths.siblingSlugs({ slug: config.slug, locale, parentId });
+            const slug = freeSlug(initialSlug(config, docs.get(id)), taken);
+            inserted.push(...(await paths.insert({
+                slug: config.slug,
+                ownerId: id,
+                parentId,
+                rows: [{ locale, slug }]
+            })));
+        }
+        pending = pending.filter((id) => !ready.includes(id));
+    }
+    if (pending.length) {
+        logger.warn(`${config.slug}: no address for ${pending.join(', ')} in "${locale}"`);
+    }
+    await formatRows({ event, config, locale, rows: inserted, docs });
+};
+/** Gives these pages their address in every locale they have none in. */
+export const addAddresses = async (args) => {
+    const { event, config, ids } = args;
+    if (!ids.length)
+        return;
+    for (const locale of addressLocales(event)) {
+        const missing = new Set(await event.locals.rime.adapter.paths.missingOwners({ slug: config.slug, locale }));
+        const idsHere = ids.filter((id) => missing.has(id));
+        if (idsHere.length)
+            await addAddressesIn({ event, config, ids: idsHere, locale });
+    }
+};
+/**
+ * The document with its address as it now is: the read that produced it ran before a create or an
+ * update gave it one.
+ */
+export const withAddress = async (args) => {
+    const { event, config, doc } = args;
+    const [row] = await event.locals.rime.adapter.paths.get({
+        slug: config.slug,
+        ownerId: doc.id,
+        locale: doc.locale ?? ''
+    });
+    return { ...doc, url: row?.url ?? null, _urlPath: row?.path ?? null, _slug: row?.slug ?? null };
+};
+let ensured;
+let done = false;
+/**
+ * Once per process, on the first request: every page of a collection with `$url` gets the address
+ * it is missing. One query per collection and locale once they all have one. The requests after
+ * it are not held: nothing to await once it is done.
+ */
+export const ensureAddresses = async (event) => {
+    if (done)
+        return;
+    ensured ??= (async () => {
+        const { rime } = event.locals;
+        for (const config of rime.config.raw.collections) {
+            if (!hasUrl(config))
+                continue;
+            const missing = new Set();
+            for (const locale of addressLocales(event)) {
+                const ids = await rime.adapter.paths.missingOwners({ slug: config.slug, locale });
+                ids.forEach((id) => missing.add(id));
+            }
+            if (!missing.size)
+                continue;
+            logger.info(`${config.slug}: giving ${missing.size} pages their address`);
+            await addAddresses({ event, config, ids: [...missing] });
+        }
+    })().then(() => {
+        done = true;
+    }, (error) => {
+        // Tried again on the next request.
+        ensured = undefined;
+        logger.error(`addresses: ${error.message}`, error);
+    });
+    await ensured;
+};

package/dist/core/prototype/shared/url/doc-type.d.ts

@@ -0,0 +1,6 @@
+import type { DocTypeContribution } from '../../../dev/codegen/types/contributions.server.js';
+/**
+ * A document of a config with `$url` carries its url. A collection's also carries its address:
+ * the slugs down to it and its own slug. `null` until the page has one.
+ */
+export declare const urlDocType: (type: "collection" | "area") => DocTypeContribution;

package/dist/core/prototype/shared/url/doc-type.js

@@ -0,0 +1,9 @@
+/**
+ * A document of a config with `$url` carries its url. A collection's also carries its address:
+ * the slugs down to it and its own slug. `null` until the page has one.
+ */
+export const urlDocType = (type) => ({
+    members: type === 'collection'
+        ? ['url: string | null', '_urlPath: string | null', '_slug: string | null']
+        : ['url: string | null']
+});

package/dist/core/prototype/shared/url/format.server.d.ts

@@ -0,0 +1,27 @@
+import type { BuiltArea, BuiltCollection } from '../../../config/types.js';
+import type { GenericDoc } from '../../types.js';
+/**
+ * A page's url: `$url` with its path, slug, locale and document, made absolute against
+ * `PUBLIC_RIME_URL`.
+ *
+ * ```ts
+ * formatUrl({ config, doc, path: 'services/web', locale: 'en' }) // 'https://site.test/en/services/web'
+ * formatUrl({ config, doc, path: '', locale: '' })                // an area: no path, no slug
+ * ```
+ */
+export declare const formatUrl: (args: {
+    config: BuiltCollection | BuiltArea;
+    doc: GenericDoc;
+    path: string;
+    locale: string;
+}) => string;
+/** A slug made from any text: `'Web design!'` -> `'web-design'`. Empty when nothing is left. */
+export declare const toSlug: (text: unknown) => string;
+/**
+ * `wanted`, or the first of `wanted-2`, `wanted-3`… that no sibling holds.
+ *
+ * ```ts
+ * freeSlug('web', ['web', 'web-2']) // 'web-3'
+ * ```
+ */
+export declare const freeSlug: (wanted: string, taken: string[]) => string;

package/dist/core/prototype/shared/url/format.server.js

@@ -0,0 +1,38 @@
+import { RimeError } from '../../../errors/index.js';
+import { slugify } from '../../../../util/string.js';
+/**
+ * A page's url: `$url` with its path, slug, locale and document, made absolute against
+ * `PUBLIC_RIME_URL`.
+ *
+ * ```ts
+ * formatUrl({ config, doc, path: 'services/web', locale: 'en' }) // 'https://site.test/en/services/web'
+ * formatUrl({ config, doc, path: '', locale: '' })                // an area: no path, no slug
+ * ```
+ */
+export const formatUrl = (args) => {
+    const { config, doc, path, locale } = args;
+    const segments = path ? path.split('/') : [];
+    const url = config.$url({ path: segments, slug: segments.at(-1) ?? '', locale, doc });
+    if (typeof url !== 'string') {
+        throw new RimeError(RimeError.CONFIG_ERROR, `$url of ${config.slug} must answer a string`);
+    }
+    const origin = process.env.PUBLIC_RIME_URL;
+    return origin ? new URL(url, origin).href : url;
+};
+/** A slug made from any text: `'Web design!'` -> `'web-design'`. Empty when nothing is left. */
+export const toSlug = (text) => slugify(String(text ?? '')).replace(/^-+|-+$/g, '');
+/**
+ * `wanted`, or the first of `wanted-2`, `wanted-3`… that no sibling holds.
+ *
+ * ```ts
+ * freeSlug('web', ['web', 'web-2']) // 'web-3'
+ * ```
+ */
+export const freeSlug = (wanted, taken) => {
+    if (!taken.includes(wanted))
+        return wanted;
+    let n = 2;
+    while (taken.includes(`${wanted}-${n}`))
+        n++;
+    return `${wanted}-${n}`;
+};

package/dist/core/prototype/shared/url/hooks/create-paths.server.d.ts

@@ -0,0 +1,2 @@
+/** A new page gets its address in every locale: a slug from its title, under its parent, a url. */
+export declare const createPaths: import("../../../../pipeline/types.js").Hook<"generic", "create", "after">;

package/dist/core/prototype/shared/url/hooks/create-paths.server.js

@@ -0,0 +1,9 @@
+import { Hooks } from '../../../../pipeline/define-hook.js';
+import { addAddresses, withAddress } from '../addresses.server.js';
+/** A new page gets its address in every locale: a slug from its title, under its parent, a url. */
+export const createPaths = Hooks.afterCreate(async function createPaths(args) {
+    const { event, doc } = args;
+    const config = args.config;
+    await addAddresses({ event, config, ids: [doc.id] });
+    return { ...args, doc: await withAddress({ event, config, doc }) };
+});

package/dist/core/prototype/shared/url/hooks/detach-paths.server.d.ts

@@ -0,0 +1,5 @@
+/**
+ * Before a delete, the page's children go to the top level with their subtrees, as `_parent`
+ * does, and get their new urls. The page's own rows go with it by cascade.
+ */
+export declare const detachPaths: import("../../../../pipeline/types.js").Hook<"generic", "delete", "before">;

package/dist/core/prototype/shared/url/hooks/detach-paths.server.js

@@ -0,0 +1,18 @@
+import { Hooks } from '../../../../pipeline/define-hook.js';
+import { refreshUrls } from '../refresh.server.js';
+/**
+ * Before a delete, the page's children go to the top level with their subtrees, as `_parent`
+ * does, and get their new urls. The page's own rows go with it by cascade.
+ */
+export const detachPaths = Hooks.beforeDelete(async function detachPaths(args) {
+    const { event, doc } = args;
+    const config = args.config;
+    const detached = await event.locals.rime.adapter.paths.detachChildren({
+        slug: config.slug,
+        ownerId: doc.id
+    });
+    for (const row of detached) {
+        await refreshUrls({ event, config, locale: row.locale, path: row.path });
+    }
+    return args;
+});

package/dist/core/prototype/shared/url/hooks/index.server.d.ts

@@ -6,4 +6,8 @@
  * It exists because a prototype's `hooks.server.ts` writes the run order and would otherwise carry
  * one import line per hook.
  */
-export { populateURL } from './populate-url.server.js';
+export { createPaths } from './create-paths.server.js';
+export { detachPaths } from './detach-paths.server.js';
+export { setAreaUrl } from './set-area-url.server.js';
+export { setLiveUrl } from './set-live-url.server.js';
+export { syncPaths } from './sync-paths.server.js';

package/dist/core/prototype/shared/url/hooks/index.server.js

@@ -6,4 +6,8 @@
  * It exists because a prototype's `hooks.server.ts` writes the run order and would otherwise carry
  * one import line per hook.
  */
-export { populateURL } from './populate-url.server.js';
+export { createPaths } from './create-paths.server.js';
+export { detachPaths } from './detach-paths.server.js';
+export { setAreaUrl } from './set-area-url.server.js';
+export { setLiveUrl } from './set-live-url.server.js';
+export { syncPaths } from './sync-paths.server.js';

package/dist/core/prototype/shared/url/hooks/set-area-url.server.d.ts

@@ -0,0 +1,2 @@
+/** An area's url, built on read: one document, no parent, nothing stored. */
+export declare const setAreaUrl: import("../../../../pipeline/types.js").Hook<"generic", "read", "before">;

package/dist/core/prototype/shared/url/hooks/set-area-url.server.js

@@ -0,0 +1,8 @@
+import { Hooks } from '../../../../pipeline/define-hook.js';
+import { formatUrl } from '../format.server.js';
+/** An area's url, built on read: one document, no parent, nothing stored. */
+export const setAreaUrl = Hooks.beforeRead(async function setAreaUrl(args) {
+    const { config, context } = args;
+    const url = formatUrl({ config, doc: args.doc, path: '', locale: context.params.locale ?? '' });
+    return { ...args, doc: { ...args.doc, url } };
+});

package/dist/core/prototype/shared/url/hooks/set-live-url.server.d.ts

@@ -0,0 +1,5 @@
+/**
+ * The live edit link, for staff, from the document's url: the panel opens the page there and
+ * sends it the edited version's content. No query.
+ */
+export declare const setLiveUrl: import("../../../../pipeline/types").Hook<"generic", "read", "before">;

package/dist/core/prototype/shared/url/hooks/set-live-url.server.js

@@ -0,0 +1,19 @@
+import { env } from '$env/dynamic/private';
+import { PARAMS } from '../../../../constants.js';
+import { Hooks } from '../../../../pipeline/define-hook.js';
+/**
+ * The live edit link, for staff, from the document's url: the panel opens the page there and
+ * sends it the edited version's content. No query.
+ */
+export const setLiveUrl = Hooks.beforeRead(async function setLiveUrl(args) {
+    const { config, event, context } = args;
+    const doc = args.doc;
+    if (!config.live || !event.locals.user?.isStaff || !doc.url)
+        return args;
+    let live = `${process.env.PUBLIC_RIME_URL}/${env.RIME_PANEL_ROUTE || 'panel'}/live-edit?src=${doc.url}&slug=${config.slug}&id=${doc.id}`;
+    if (doc.contentId)
+        live += `&${PARAMS.VERSION_ID}=${doc.contentId}`;
+    if (context.params.locale)
+        live += `&${PARAMS.LOCALE}=${context.params.locale}`;
+    return { ...args, doc: { ...doc, _live: live } };
+});

package/dist/core/prototype/shared/url/hooks/sync-paths.server.d.ts

@@ -0,0 +1,7 @@
+/**
+ * After a save. A move carries the page and its subtree under the new parent, in every locale at
+ * once. Any other save formats the page's own urls again, since `$url` may read any of its fields.
+ *
+ * An auto-save moves nothing and changes no url: it is skipped.
+ */
+export declare const syncPaths: import("../../../../pipeline/types.js").Hook<"generic", "update", "after">;