canopycms 0.0.68-int.98 → 0.1.0

package/dist/editor/undo-removal.d.ts

@@ -0,0 +1,57 @@
+import type { FieldConfig } from '../config/index.js';
+import type { CommentThread } from '../comment-store.js';
+import { type CanopyPathSegment } from './canopy-path.js';
+/**
+ * One list a removal sits inside (a block list, or an object list holding the removed item's
+ * list): the index of the item enclosing the removal, and every other item.
+ */
+export interface RemovalAnchor {
+    index: number;
+    siblings: unknown[];
+}
+/**
+ * What a form's Remove took out, for Undo. Paths are canopy paths (`blocks[2].items`), which skip
+ * a block's `value` wrapper; `restoreRemoval` resolves them against the value it restores into.
+ */
+export type FieldRemoval = ({
+    kind: 'list-item';
+    /** The list field's own path. */
+    listPath: CanopyPathSegment[];
+    index: number;
+    /** The removed item itself, so its list-item key comes back with it. */
+    item: unknown;
+    /** Names the item in the Undo toast. */
+    label: string;
+} | {
+    kind: 'value';
+    path: CanopyPathSegment[];
+    value: unknown;
+    label: string;
+}) & {
+    /**
+     * The enclosing lists as they were before the removal (`removalAnchors`). Undo puts nothing
+     * back once one has changed, so an item never lands in whichever block now holds its index.
+     */
+    anchors?: RemovalAnchor[];
+    /** `clear` for an optional object's Clear, which its toast calls clearing, not removing. */
+    action?: 'remove' | 'clear';
+};
+/**
+ * The canopy path `restoreRemoval` puts a removal back at: a list item returns to its old index,
+ * or to the list's end when the list is now shorter than that.
+ */
+export declare function restoredFieldPath(fields: readonly FieldConfig[], value: Record<string, unknown>, removal: FieldRemoval): CanopyPathSegment[];
+/** The enclosing lists of a removal in `value`, taken before the removal applies; see `anchors`. */
+export declare function removalAnchors(fields: readonly FieldConfig[], value: Record<string, unknown>, removal: FieldRemoval): RemovalAnchor[] | undefined;
+/**
+ * `value` with a removal put back, or undefined when it can't be: the list or field is gone, an
+ * enclosing list has changed, the item is already there, or the image field has been filled.
+ * Edits made after the removal are kept, because it changes only the one list or field, in the
+ * value as it is now.
+ */
+export declare function restoreRemoval(fields: readonly FieldConfig[], value: Record<string, unknown>, removal: FieldRemoval): Record<string, unknown> | undefined;
+/**
+ * How many open field threads a removal at `path` moves to the entry: those inside it keyed to an
+ * item at or below it. One keyed only above stays on its field, which a Clear leaves in place.
+ */
+export declare function openThreadsWithin(threads: readonly CommentThread[], entryPath: string, path: readonly CanopyPathSegment[]): number;

package/dist/editor/undo-removal.js

@@ -0,0 +1,163 @@
+import equal from 'fast-deep-equal';
+import { isPlainRecord } from '../validation/field-traversal.js';
+import { normalizeCanopyPath, parseCanopyPath } from './canopy-path.js';
+const findField = (fields, name) => {
+    for (const field of fields) {
+        if (field.type === 'group') {
+            const inGroup = findField(field.fields, name);
+            if (inGroup)
+                return inGroup;
+        }
+        else if (field.name === name) {
+            return field;
+        }
+    }
+    return undefined;
+};
+/**
+ * The path into the stored value for a canopy path, with the enclosing lists it passes through,
+ * or undefined when the value no longer has it.
+ */
+const resolvePath = (fields, value, path) => {
+    let scope = fields;
+    let node = value;
+    const out = [];
+    const anchors = [];
+    const anchor = (list, index) => anchors.push({ index, siblings: list.filter((_, i) => i !== index) });
+    let i = 0;
+    while (i < path.length) {
+        const name = path[i];
+        const field = typeof name === 'string' ? findField(scope, name) : undefined;
+        if (typeof name !== 'string' || !field)
+            return undefined;
+        out.push(name);
+        node = isPlainRecord(node) ? node[name] : undefined;
+        i += 1;
+        if (i === path.length)
+            return { path: out, anchors };
+        const index = path[i];
+        if (field.type === 'block') {
+            const block = typeof index === 'number' && Array.isArray(node) ? node[index] : undefined;
+            if (typeof index !== 'number' || !isPlainRecord(block))
+                return undefined;
+            const template = field.templates.find((t) => t.name === block.template);
+            if (!template || !Array.isArray(node))
+                return undefined;
+            anchor(node, index);
+            out.push(index, 'value');
+            node = block.value;
+            scope = template.fields;
+            i += 1;
+        }
+        else if (field.type === 'object') {
+            const objectField = field;
+            if (objectField.list) {
+                if (typeof index !== 'number' || !Array.isArray(node))
+                    return undefined;
+                anchor(node, index);
+                out.push(index);
+                node = node[index];
+                i += 1;
+            }
+            scope = objectField.fields;
+        }
+        else {
+            return undefined;
+        }
+    }
+    return { path: out, anchors };
+};
+const getAt = (root, path) => path.reduce((node, segment) => {
+    if (typeof segment === 'number')
+        return Array.isArray(node) ? node[segment] : undefined;
+    return isPlainRecord(node) ? node[segment] : undefined;
+}, root);
+const setAt = (root, path, next) => {
+    if (path.length === 0)
+        return next;
+    const [head, ...rest] = path;
+    if (typeof head === 'number') {
+        const list = Array.isArray(root) ? [...root] : [];
+        list[head] = setAt(list[head], rest, next);
+        return list;
+    }
+    const record = isPlainRecord(root) ? root : {};
+    return { ...record, [head]: setAt(record[head], rest, next) };
+};
+/** Equal once stored: JSON drops `undefined` keys, as the server's copy of a draft does. */
+const sameContent = (a, b) => equal(JSON.parse(JSON.stringify(a ?? null)), JSON.parse(JSON.stringify(b ?? null)));
+const removalPath = (removal) => removal.kind === 'list-item' ? removal.listPath : removal.path;
+const anchorsHold = (then, now) => then === undefined ||
+    (then.length === now.length &&
+        then.every((anchor, i) => anchor.index === now[i].index &&
+            // By content as stored, so the server's copy of the same items still holds.
+            sameContent(anchor.siblings, now[i].siblings)));
+/**
+ * The canopy path `restoreRemoval` puts a removal back at: a list item returns to its old index,
+ * or to the list's end when the list is now shorter than that.
+ */
+export function restoredFieldPath(fields, value, removal) {
+    if (removal.kind !== 'list-item')
+        return removal.path;
+    const resolved = resolvePath(fields, value, removal.listPath);
+    const list = resolved ? getAt(value, resolved.path) : undefined;
+    return [...removal.listPath, Math.min(removal.index, Array.isArray(list) ? list.length : 0)];
+}
+/** The enclosing lists of a removal in `value`, taken before the removal applies; see `anchors`. */
+export function removalAnchors(fields, value, removal) {
+    return resolvePath(fields, value, removalPath(removal))?.anchors;
+}
+/**
+ * `value` with a removal put back, or undefined when it can't be: the list or field is gone, an
+ * enclosing list has changed, the item is already there, or the image field has been filled.
+ * Edits made after the removal are kept, because it changes only the one list or field, in the
+ * value as it is now.
+ */
+export function restoreRemoval(fields, value, removal) {
+    const resolved = resolvePath(fields, value, removalPath(removal));
+    if (!resolved || !anchorsHold(removal.anchors, resolved.anchors))
+        return undefined;
+    const { path } = resolved;
+    // An enclosing object cleared since would come back holding only this.
+    if (!isPlainRecord(path.length > 1 ? getAt(value, path.slice(0, -1)) : value))
+        return undefined;
+    const current = getAt(value, path);
+    let next;
+    if (removal.kind === 'list-item') {
+        if (current !== undefined && current !== null && !Array.isArray(current))
+            return undefined;
+        // Already back (a Discard or Reload restored it, or an earlier Undo did).
+        if (Array.isArray(current) && current.some((item) => sameContent(item, removal.item))) {
+            return undefined;
+        }
+        const list = Array.isArray(current) ? [...current] : [];
+        list.splice(Math.min(removal.index, list.length), 0, removal.item);
+        next = list;
+    }
+    else {
+        if (current !== undefined && current !== null)
+            return undefined;
+        next = removal.value;
+    }
+    const restored = setAt(value, path, next);
+    return isPlainRecord(restored) ? restored : undefined;
+}
+/**
+ * How many open field threads a removal at `path` moves to the entry: those inside it keyed to an
+ * item at or below it. One keyed only above stays on its field, which a Clear leaves in place.
+ */
+export function openThreadsWithin(threads, entryPath, path) {
+    const prefix = parseCanopyPath(normalizeCanopyPath(path));
+    const isIndex = (segment) => typeof segment === 'number';
+    const itemsAbove = prefix.filter(isIndex).length - (isIndex(prefix[prefix.length - 1]) ? 1 : 0);
+    return threads.filter((thread) => {
+        if (thread.type !== 'field' || thread.resolved || thread.onRemovedItem)
+            return false;
+        if (thread.entryPath !== entryPath || !thread.canopyPath)
+            return false;
+        if ((thread.itemKeys?.length ?? 0) <= itemsAbove)
+            return false;
+        const segments = parseCanopyPath(thread.canopyPath);
+        return prefix.length <= segments.length && prefix.every((s, i) => segments[i] === s);
+    }).length;
+}

package/dist/editor/user-display.d.ts

@@ -0,0 +1,4 @@
+/** What the editor calls a user id CanopyCMS itself acts as (system-users.ts). */
+export declare const SYSTEM_USER_LABEL = "CanopyCMS bot";
+/** A user id as text where no name lookup is available: a bot by its label, anyone else by id. */
+export declare const userIdLabel: (userId: string) => string;

package/dist/editor/user-display.js

@@ -0,0 +1,5 @@
+import { isSystemUserId } from '../system-users.js';
+/** What the editor calls a user id CanopyCMS itself acts as (system-users.ts). */
+export const SYSTEM_USER_LABEL = 'CanopyCMS bot';
+/** A user id as text where no name lookup is available: a bot by its label, anyone else by id. */
+export const userIdLabel = (userId) => isSystemUserId(userId) ? SYSTEM_USER_LABEL : userId;

package/dist/editor/utils/confirm-modal.d.ts

@@ -0,0 +1,8 @@
+import { modals } from '@mantine/modals';
+type ConfirmModalProps = Parameters<typeof modals.openConfirmModal>[0];
+/**
+ * `modals.openConfirmModal` with `sm` actions: its own Buttons would otherwise take the theme's
+ * compact `xs` default. A `size` the caller sets replaces it.
+ */
+export declare function openConfirm(props: ConfirmModalProps): string;
+export {};

package/dist/editor/utils/confirm-modal.js

@@ -0,0 +1,12 @@
+import { modals } from '@mantine/modals';
+/**
+ * `modals.openConfirmModal` with `sm` actions: its own Buttons would otherwise take the theme's
+ * compact `xs` default. A `size` the caller sets replaces it.
+ */
+export function openConfirm(props) {
+    return modals.openConfirmModal({
+        ...props,
+        confirmProps: Object.assign({ size: 'sm' }, props.confirmProps),
+        cancelProps: Object.assign({ size: 'sm' }, props.cancelProps),
+    });
+}

package/dist/editor/utils/editor-errors.d.ts

@@ -0,0 +1,19 @@
+/** Where in the editor an error was caught, for the log line and the copied details. */
+export interface EditorErrorContext {
+    /** `editor` for the crash screen, `field` for a field boundary, `rich-text` for MDXEditor. */
+    boundary: 'editor' | 'field' | 'rich-text';
+    /** The field's canopy path, for a field or rich-text boundary. */
+    fieldPath?: string;
+    /** React's component stack, when React supplied one. */
+    componentStack?: string;
+}
+/**
+ * The single point every error an editor boundary catches passes through. Logs it, because a
+ * boundary must never hide a crash; an adopter-facing report hook belongs here too.
+ */
+export declare function reportEditorError(error: unknown, context: EditorErrorContext): void;
+/**
+ * The text "Copy error details" puts on the clipboard. Sanitised, because an author pastes it
+ * into a chat or a ticket: stack frames can name local paths, and a message can carry a token.
+ */
+export declare function formatErrorDetails(error: unknown, context: EditorErrorContext): string;

package/dist/editor/utils/editor-errors.js

@@ -0,0 +1,32 @@
+import { getErrorMessage, sanitizeErrorMessage } from '../../utils/error.js';
+/**
+ * The single point every error an editor boundary catches passes through. Logs it, because a
+ * boundary must never hide a crash; an adopter-facing report hook belongs here too.
+ */
+export function reportEditorError(error, context) {
+    const where = context.fieldPath ? `${context.boundary} ${context.fieldPath}` : context.boundary;
+    console.error(`[canopycms] editor error caught (${where})`, error, context.componentStack ?? '');
+}
+const MAX_DETAILS_LENGTH = 8000;
+/**
+ * The text "Copy error details" puts on the clipboard. Sanitised, because an author pastes it
+ * into a chat or a ticket: stack frames can name local paths, and a message can carry a token.
+ */
+export function formatErrorDetails(error, context) {
+    const lines = [
+        'CanopyCMS editor error',
+        `Time: ${new Date().toISOString()}`,
+        `Caught by: ${context.boundary}${context.fieldPath ? ` (${context.fieldPath})` : ''}`,
+        `Error: ${error instanceof Error ? `${error.name}: ${error.message}` : getErrorMessage(error)}`,
+    ];
+    if (typeof navigator !== 'undefined')
+        lines.push(`Browser: ${navigator.userAgent}`);
+    if (error instanceof Error && error.stack)
+        lines.push('', 'Stack:', error.stack);
+    if (context.componentStack)
+        lines.push('', 'Component stack:', context.componentStack.trim());
+    const details = sanitizeErrorMessage(lines.join('\n'));
+    return details.length > MAX_DETAILS_LENGTH
+        ? `${details.slice(0, MAX_DETAILS_LENGTH)}\n[truncated]`
+        : details;
+}

package/dist/editor/utils/focus-return.d.ts

@@ -0,0 +1,56 @@
+import { type MouseEvent, type RefObject } from 'react';
+/**
+ * Mantine's own `returnFocus` records the focused element at open, and a menu item has unmounted
+ * with its menu by close, so an overlay opened from one returns focus here instead.
+ * `FOCUS_RETURN_ATTR` marks an overlay whose exit callback does; `focusIfIdle` treats focus inside it as idle.
+ */
+export declare const FOCUS_RETURN_ATTR = "data-focus-return";
+/**
+ * Focuses `target` unless the user has moved focus on: nothing is focused, or focus is inside an
+ * overlay `FOCUS_RETURN_ATTR` marks, as a closing one is until after its exit callback.
+ */
+export declare function focusIfIdle(target: HTMLElement | null): void;
+/**
+ * Run by `useMenuItemFocusReturn` when its menu has closed after an item acted: focuses the menu's
+ * `target` trigger once the item has unmounted and dropped focus to the page. Mantine calls it just before
+ * unmounting the items, hence the frame's wait; `returnFocus` would instead steal focus from an
+ * overlay the item opened, which holds it by then.
+ * @internal Exported for tests.
+ */
+export declare function focusIfDropped(target: HTMLElement | null): void;
+/**
+ * Props for a Mantine `Menu` and its `Menu.Dropdown` that run `focusIfDropped` on `trigger` after an
+ * item acted. A menu dismissed by a press elsewhere keeps focus where that press left it.
+ */
+export declare function useMenuItemFocusReturn(trigger: RefObject<HTMLElement | null>): {
+    menu: {
+        onExitTransitionEnd: () => void;
+    };
+    dropdown: {
+        onClickCapture: (event: MouseEvent) => void;
+    };
+};
+/** The focused control to hand focus back to, or null when it is a menu item (gone once it acts) or the page. */
+export declare function rememberOpener(): HTMLElement | null;
+/** The remembered opener while it is still on the page, else the menu trigger that stands in for it. */
+export declare function returnTarget(opener: HTMLElement | null, standIn: () => HTMLElement | null): HTMLElement | null;
+/**
+ * Props that make a Mantine `Modal`, `Drawer` or `modals.openConfirmModal` focus `returnFocusTo()`
+ * once it has closed; none, keeping Mantine's default, without one.
+ */
+export declare function focusReturnProps(returnFocusTo?: () => HTMLElement | null): {
+    returnFocus?: false;
+    onExitTransitionEnd?: () => void;
+    [FOCUS_RETURN_ATTR]?: true;
+};
+/**
+ * Focus for a list of removable badges, each with a `Remove …` button. The button that removes an
+ * item is gone once it acts, so `focusAfterRemove(index, fallback)` moves focus, once the list has
+ * re-rendered without the item, to the Remove button now at that index (the next item's, else the
+ * previous one's), else to the `fallback` control: the section's "Add …" button, or whatever stands
+ * in for it while that is hidden or disabled. Put `listRef` on the element holding the badges.
+ */
+export declare function useFocusAfterRemove<L extends HTMLElement = HTMLDivElement>(): {
+    listRef: RefObject<L>;
+    focusAfterRemove: (index: number, fallback: RefObject<HTMLElement | null>) => void;
+};

package/dist/editor/utils/focus-return.js

@@ -0,0 +1,106 @@
+import { useEffect, useRef, useState } from 'react';
+/**
+ * Mantine's own `returnFocus` records the focused element at open, and a menu item has unmounted
+ * with its menu by close, so an overlay opened from one returns focus here instead.
+ * `FOCUS_RETURN_ATTR` marks an overlay whose exit callback does; `focusIfIdle` treats focus inside it as idle.
+ */
+export const FOCUS_RETURN_ATTR = 'data-focus-return';
+/**
+ * Focuses `target` unless the user has moved focus on: nothing is focused, or focus is inside an
+ * overlay `FOCUS_RETURN_ATTR` marks, as a closing one is until after its exit callback.
+ */
+export function focusIfIdle(target) {
+    const active = document.activeElement;
+    if (!active || active === document.body || active.closest(`[${FOCUS_RETURN_ATTR}]`)) {
+        target?.focus({ preventScroll: true });
+    }
+}
+/**
+ * Run by `useMenuItemFocusReturn` when its menu has closed after an item acted: focuses the menu's
+ * `target` trigger once the item has unmounted and dropped focus to the page. Mantine calls it just before
+ * unmounting the items, hence the frame's wait; `returnFocus` would instead steal focus from an
+ * overlay the item opened, which holds it by then.
+ * @internal Exported for tests.
+ */
+export function focusIfDropped(target) {
+    requestAnimationFrame(() => {
+        const active = document.activeElement;
+        if (!active || active === document.body)
+            target?.focus({ preventScroll: true });
+    });
+}
+/**
+ * Props for a Mantine `Menu` and its `Menu.Dropdown` that run `focusIfDropped` on `trigger` after an
+ * item acted. A menu dismissed by a press elsewhere keeps focus where that press left it.
+ */
+export function useMenuItemFocusReturn(trigger) {
+    const acted = useRef(false);
+    return {
+        menu: {
+            onExitTransitionEnd: () => {
+                if (acted.current)
+                    focusIfDropped(trigger.current);
+                acted.current = false;
+            },
+        },
+        dropdown: {
+            onClickCapture: (event) => {
+                if (event.target instanceof Element &&
+                    event.target.closest('[role="menuitem"]:not([aria-disabled="true"])')) {
+                    acted.current = true;
+                }
+            },
+        },
+    };
+}
+/** The focused control to hand focus back to, or null when it is a menu item (gone once it acts) or the page. */
+export function rememberOpener() {
+    const active = document.activeElement;
+    return active instanceof HTMLElement &&
+        active !== document.body &&
+        !active.closest('[role="menuitem"]')
+        ? active
+        : null;
+}
+/** The remembered opener while it is still on the page, else the menu trigger that stands in for it. */
+export function returnTarget(opener, standIn) {
+    return opener?.isConnected ? opener : standIn();
+}
+/**
+ * Props that make a Mantine `Modal`, `Drawer` or `modals.openConfirmModal` focus `returnFocusTo()`
+ * once it has closed; none, keeping Mantine's default, without one.
+ */
+export function focusReturnProps(returnFocusTo) {
+    if (!returnFocusTo)
+        return {};
+    return {
+        returnFocus: false,
+        onExitTransitionEnd: () => focusIfIdle(returnFocusTo()),
+        [FOCUS_RETURN_ATTR]: true,
+    };
+}
+/**
+ * Focus for a list of removable badges, each with a `Remove …` button. The button that removes an
+ * item is gone once it acts, so `focusAfterRemove(index, fallback)` moves focus, once the list has
+ * re-rendered without the item, to the Remove button now at that index (the next item's, else the
+ * previous one's), else to the `fallback` control: the section's "Add …" button, or whatever stands
+ * in for it while that is hidden or disabled. Put `listRef` on the element holding the badges.
+ */
+export function useFocusAfterRemove() {
+    const listRef = useRef(null);
+    const [pending, setPending] = useState(null);
+    useEffect(() => {
+        if (!pending)
+            return;
+        const removeButtons = listRef.current?.querySelectorAll('button[aria-label^="Remove "]');
+        const target = removeButtons && removeButtons.length > 0
+            ? removeButtons[Math.min(pending.index, removeButtons.length - 1)]
+            : pending.fallback.current;
+        target?.focus();
+        setPending(null);
+    }, [pending]);
+    return {
+        listRef,
+        focusAfterRemove: (index, fallback) => setPending({ index, fallback }),
+    };
+}

package/dist/entry-link-resolver.d.ts

@@ -23,12 +23,22 @@ export type EntryLinkUrlResolver = (entry: {
 }) => string;
 /** URL path for an entry's location in the content tree; delegates to `computeEntryUrl`. */
 export declare function resolveEntryUrl(location: Pick<IdLocation, 'collection' | 'slug'>, contentRoot: string): string;
+export interface ResolveEntryLinksOptions {
+    /**
+     * Whether a link to this content id may show its target. When set, a link to a target it
+     * refuses, or to a missing one, shows nothing of that target's URL or slug: an inline
+     * markdown link (`[text](entry:ID)`, or an image) becomes its bare text, and any other form
+     * becomes `#`.
+     */
+    isLinkable?: (id: string) => boolean;
+}
 /**
  * Replace `entry:CONTENT_ID` tokens with resolved URL paths, skipping code blocks and
  * spans so examples mentioning the syntax survive. A missing ID becomes "#" (dead link)
  * plus a warning; an anchor fragment is preserved (`entry:ID#heading` => `/path#heading`).
+ * See {@link ResolveEntryLinksOptions.isLinkable} for links to a target the caller withholds.
  */
-export declare function resolveEntryLinksInText(text: string, idIndex: ContentIdIndex, contentRoot: string, customResolver?: EntryLinkUrlResolver): string;
+export declare function resolveEntryLinksInText(text: string, idIndex: ContentIdIndex, contentRoot: string, customResolver?: EntryLinkUrlResolver, options?: ResolveEntryLinksOptions): string;
 /** Quick-check pattern for early bail-out (no `g` flag, safe for `.test()`). */
 export declare const ENTRY_LINK_QUICK_CHECK: RegExp;
 /**

package/dist/entry-link-resolver.js

@@ -27,19 +27,26 @@ export function resolveEntryUrl(location, contentRoot) {
  * Replace `entry:CONTENT_ID` tokens with resolved URL paths, skipping code blocks and
  * spans so examples mentioning the syntax survive. A missing ID becomes "#" (dead link)
  * plus a warning; an anchor fragment is preserved (`entry:ID#heading` => `/path#heading`).
+ * See {@link ResolveEntryLinksOptions.isLinkable} for links to a target the caller withholds.
  */
-export function resolveEntryLinksInText(text, idIndex, contentRoot, customResolver) {
+export function resolveEntryLinksInText(text, idIndex, contentRoot, customResolver, options = {}) {
+    const { isLinkable } = options;
     const parts = splitByCodeRegions(text);
     return parts
         .map((part) => {
         if (part.isCode)
             return part.text;
-        return part.text.replace(ENTRY_LINK_PATTERN, (_match, id, anchor) => {
-            const location = idIndex.findById(id);
-            if (!location || location.type !== 'entry' || !location.collection || !location.slug) {
+        const partText = isLinkable
+            ? unwrapInlineLinks(part.text, (id) => !isLinkable(id) || !findEntry(idIndex, id))
+            : part.text;
+        return partText.replace(ENTRY_LINK_PATTERN, (_match, id, anchor) => {
+            const location = findEntry(idIndex, id);
+            if (!location) {
                 log.warn('resolve', `Entry link target not found: entry:${id}`);
-                return anchor ?? '#';
+                return isLinkable ? '#' : (anchor ?? '#');
             }
+            if (isLinkable && !isLinkable(id))
+                return '#';
             let url;
             if (customResolver) {
                 url = customResolver({
@@ -56,6 +63,59 @@ export function resolveEntryLinksInText(text, idIndex, contentRoot, customResolv
     })
         .join('');
 }
+function findEntry(idIndex, id) {
+    const location = idIndex.findById(id);
+    if (!location || location.type !== 'entry' || !location.collection || !location.slug) {
+        return undefined;
+    }
+    return location;
+}
+/**
+ * `](entry:ID#anchor "title")`: the target half of an inline markdown link. A match starts only at
+ * a literal `](entry:`, its anchor stops at `]` and its title at the next `"`, so failed matches
+ * scan stretches that don't overlap, keeping the scan linear.
+ */
+const INLINE_LINK_TARGET = new RegExp(`\\]\\(entry:(${BASE58_CHAR}{12})(?:#[^\\s)>"'\\]]*)?(?:[ \\t]+"[^"\\n]*")?\\)`, 'g');
+/**
+ * Replace each inline markdown link (or image) whose `entry:` target `shouldUnwrap` names with
+ * its bracketed text. A link whose opening `[` can't be found is left alone, for the caller's
+ * token pass to neutralize.
+ */
+function unwrapInlineLinks(text, shouldUnwrap) {
+    let out = '';
+    let cursor = 0;
+    // A failed search from `close` saw no `[` it could match before it, and a later `]` only adds
+    // depth, so later searches stop there: the bracket scans stay linear in the text.
+    let scanFloor = 0;
+    for (const match of text.matchAll(INLINE_LINK_TARGET)) {
+        const close = match.index;
+        if (close < cursor || !shouldUnwrap(match[1]))
+            continue;
+        const open = findOpeningBracket(text, close, Math.max(cursor, scanFloor));
+        if (open === -1) {
+            scanFloor = close;
+            continue;
+        }
+        const isImage = open > cursor && text[open - 1] === '!' && text[open - 2] !== '\\';
+        const start = isImage ? open - 1 : open;
+        out += text.slice(cursor, start) + text.slice(open + 1, close);
+        cursor = close + match[0].length;
+    }
+    return out + text.slice(cursor);
+}
+/** The `[` matching the `]` at `close`, searching back no further than `floor`; -1 if none. */
+function findOpeningBracket(text, close, floor) {
+    let depth = 1;
+    for (let i = close - 1; i >= floor; i--) {
+        if (i > floor && text[i - 1] === '\\')
+            continue;
+        if (text[i] === ']')
+            depth++;
+        else if (text[i] === '[' && --depth === 0)
+            return i;
+    }
+    return -1;
+}
 /** Quick-check pattern for early bail-out (no `g` flag, safe for `.test()`). */
 export const ENTRY_LINK_QUICK_CHECK = /entry:[123456789ABCDEFGHJKLMNPQRSTUVWXYZabcdefghijkmnopqrstuvwxyz]{12}/;
 /**

package/dist/entry-schema-registry.d.ts

@@ -16,9 +16,9 @@ import type { EntrySchemaRegistry } from './schema/types.js';
  * array; more than one `isTitle` per schema, or one on a non-string field or inside a list;
  * more than one `isBody`, or one on a field that is not markdown/mdx or is named one of
  * `RESOLVED_REFERENCE_KEYS`; a top-level or inline-group field named `unavailable`. This is also the one
- * place the shared field-shape checks run: select fields must have options,
- * reference fields must have `collections` or `entryTypes`, no inline groups
- * inside object/block fields, no field-name collisions after group flattening.
+ * place the shared field-shape checks run: field names a path can spell, select fields must have options,
+ * reference fields must have `collections` or `entryTypes`, no inline groups inside object/block fields,
+ * no field-name collisions after group flattening, valid `mdxAllow`, `stampOnPublish` placement.
  *
  * @example
  * ```typescript

package/dist/entry-schema-registry.js

@@ -2,7 +2,7 @@ import { countTitleFields, findInvalidTitleFields, findTitleFieldsInLists, } fro
 import { countBodyFields, findInvalidBodyFields, findReservedBodyFieldName, } from './utils/body-field.js';
 import { RESOLVED_REFERENCE_KEYS, RESTRICTED_REFERENCE_MARKER } from './entry-schema.js';
 import { flattenGroupFields } from './utils/flatten-group-fields.js';
-import { ensureSelectFieldsHaveOptions, ensureReferenceFieldsHaveScope, ensureItemTitleFieldsExist, ensureNoFlattenedFieldNameCollisions, ensureNoGroupsInsideComplexFields, } from './config/validation.js';
+import { ensureFieldNamesSpellInPaths, ensureSelectFieldsHaveOptions, ensureReferenceFieldsHaveScope, ensureItemTitleFieldsExist, ensureNoFlattenedFieldNameCollisions, ensureNoGroupsInsideComplexFields, ensureMarkdownFieldOptions, ensureStampOnPublishPlacement, } from './config/validation.js';
 /** Look up a field's type by dotted path (e.g., "meta.order").
  * Groups are transparent — their children are searched at the same path level. */
 function findFieldType(fields, dottedPath) {
@@ -39,9 +39,9 @@ function findFieldType(fields, dottedPath) {
  * array; more than one `isTitle` per schema, or one on a non-string field or inside a list;
  * more than one `isBody`, or one on a field that is not markdown/mdx or is named one of
  * `RESOLVED_REFERENCE_KEYS`; a top-level or inline-group field named `unavailable`. This is also the one
- * place the shared field-shape checks run: select fields must have options,
- * reference fields must have `collections` or `entryTypes`, no inline groups
- * inside object/block fields, no field-name collisions after group flattening.
+ * place the shared field-shape checks run: field names a path can spell, select fields must have options,
+ * reference fields must have `collections` or `entryTypes`, no inline groups inside object/block fields,
+ * no field-name collisions after group flattening, valid `mdxAllow`, `stampOnPublish` placement.
  *
  * @example
  * ```typescript
@@ -95,10 +95,13 @@ export function createEntrySchemaRegistry(registry) {
         if (flattenGroupFields(schema).some((f) => f.name === RESTRICTED_REFERENCE_MARKER)) {
             throw new Error(`Entry schema registry entry "${key}": field "${RESTRICTED_REFERENCE_MARKER}" is reserved — a resolved reference carries "${RESTRICTED_REFERENCE_MARKER}: true" only when the reader may not read its target, so a field with that name cannot be delivered on a reference to this entry type. Rename the field.`);
         }
+        ensureFieldNamesSpellInPaths(schema);
         ensureSelectFieldsHaveOptions(schema);
         ensureReferenceFieldsHaveScope(schema);
         ensureItemTitleFieldsExist(schema);
         ensureNoGroupsInsideComplexFields(schema);
+        ensureMarkdownFieldOptions(schema);
+        ensureStampOnPublishPlacement(schema, `Entry schema registry entry "${key}"`);
         ensureNoFlattenedFieldNameCollisions(schema, `entry schema "${key}"`);
     }
     return registry;