smartrte-core 0.2.0 → 1.0.0-beta.1

package/dist/foundation/list/index.d.ts

@@ -0,0 +1,8 @@
+export * from "./schema.js";
+export * from "./types.js";
+export * from "./commands.js";
+export * from "./input.js";
+export * from "./shadow.js";
+export * from "./shadowCorpus.js";
+export * from "./formats.js";
+export * from "./presets.js";

package/dist/foundation/list/index.js

@@ -0,0 +1,8 @@
+export * from "./schema.js";
+export * from "./types.js";
+export * from "./commands.js";
+export * from "./input.js";
+export * from "./shadow.js";
+export * from "./shadowCorpus.js";
+export * from "./formats.js";
+export * from "./presets.js";

package/dist/foundation/list/input.d.ts

@@ -0,0 +1,35 @@
+import type { SmartDocument, SmartOperation, SmartPos } from "../types.js";
+import type { CommandContext } from "./types.js";
+export interface ListSelectionTarget {
+    readonly ownerId: string;
+    readonly offset: number;
+}
+export interface ListInputResult {
+    readonly operations: SmartOperation[];
+    readonly selectionTarget: ListSelectionTarget;
+    readonly intent: "split" | "indent" | "outdent" | "unwrap" | "merge-backward" | "merge-forward" | "line-break" | "check";
+}
+export interface ListEnterIds {
+    readonly itemId: string;
+    readonly blockId: string;
+    readonly emptyBlockId: string;
+    /**
+     * The list id used for the suffix when an empty middle item exits a list.
+     * It is caller-supplied so structural input remains deterministic.
+     */
+    readonly splitListId: string;
+}
+export declare const listItemAt: (document: SmartDocument, pos: SmartPos) => {
+    itemId: string;
+    listId: string;
+    depth: number;
+} | null;
+/** Backspace target: deepest last visible descendant of the preceding sibling. */
+/** Delete target: first visible descendant when present, otherwise next sibling. */
+export declare const resolveFollowingContentTarget: (document: SmartDocument, itemId: string, ctx: CommandContext) => {
+    itemId: string;
+    ownerId: string;
+} | null;
+export declare const enterInList: (document: SmartDocument, pos: SmartPos, ids: ListEnterIds, ctx: CommandContext) => ListInputResult | null;
+export declare const backspaceAtListItemStart: (document: SmartDocument, pos: SmartPos, ctx: CommandContext) => ListInputResult | null;
+export declare const deleteAtListItemEnd: (document: SmartDocument, pos: SmartPos, ctx: CommandContext) => ListInputResult | null;

package/dist/foundation/list/input.js

@@ -0,0 +1,320 @@
+import { cloneNode, isTextNode } from "../identity.js";
+import { nodeAtPath } from "../positions.js";
+import { outdentList, unwrapList } from "./commands.js";
+import { resolvePrecedingContentTarget as resolveSharedPrecedingContentTarget } from "../structural/contentTarget.js";
+const inlineSize = (node) => (node.children || []).reduce((size, child) => size + (isTextNode(child) ? child.text.length : 1), 0);
+const textChildren = (node) => (node.children || []).filter(isTextNode).map((child) => child.text).join("");
+const isInlineOwner = (node) => node.type === "paragraph" || node.type === "heading";
+const isElementNode = (node) => !isTextNode(node);
+const contextAt = (document, pos) => {
+    const owner = nodeAtPath(document, pos.path);
+    if (!owner || isTextNode(owner) || !isInlineOwner(owner))
+        return null;
+    for (let depth = pos.path.length - 1; depth >= 0; depth -= 1) {
+        const path = pos.path.slice(0, depth + 1);
+        const node = nodeAtPath(document, path);
+        if (!node || isTextNode(node) || node.type !== "list_item")
+            continue;
+        const listPath = path.slice(0, -1);
+        const list = nodeAtPath(document, listPath);
+        if (!list || isTextNode(list) || list.type !== "list")
+            return null;
+        const ownerIndex = (node.children || []).findIndex((child) => !isTextNode(child) && child.id === owner.id);
+        return {
+            item: node,
+            itemPath: path,
+            list,
+            listPath,
+            itemIndex: path[path.length - 1],
+            owner,
+            ownerPath: [...pos.path],
+            ownerIndex,
+        };
+    }
+    return null;
+};
+export const listItemAt = (document, pos) => {
+    const context = contextAt(document, pos);
+    if (!context)
+        return null;
+    let depth = 0;
+    for (let index = 0; index < context.listPath.length; index += 1) {
+        const ancestor = nodeAtPath(document, context.listPath.slice(0, index + 1));
+        if (ancestor && !isTextNode(ancestor) && ancestor.type === "list")
+            depth += 1;
+    }
+    return { itemId: context.item.id, listId: context.list.id, depth: Math.max(0, depth - 1) };
+};
+const itemScope = (document, context) => ({
+    kind: "list-selection",
+    listId: context.list.id,
+    items: [{ itemId: context.item.id, depth: listItemAt(document, { path: context.ownerPath, offset: 0 })?.depth || 0, hasChildList: Boolean(nestedList(context.item)) }],
+    partialSubtree: false,
+    promotedFromPartial: false,
+    range: { from: { path: context.listPath, offset: context.itemIndex }, to: { path: context.listPath, offset: context.itemIndex + 1 } },
+    isolatingAncestorId: null,
+    clamped: false,
+});
+const nestedList = (item) => {
+    for (let index = (item.children?.length || 0) - 1; index >= 0; index -= 1) {
+        const child = item.children?.[index];
+        if (child && !isTextNode(child) && child.type === "list")
+            return child;
+    }
+    return null;
+};
+const firstContentOwner = (item) => {
+    for (const child of item.children || [])
+        if (!isTextNode(child) && child.type !== "list" && isInlineOwner(child))
+            return child;
+    return null;
+};
+const deepestFirstItem = (item) => {
+    const nested = nestedList(item);
+    const first = nested?.children?.[0];
+    return first && !isTextNode(first) ? deepestFirstItem(first) : item;
+};
+/** Backspace target: deepest last visible descendant of the preceding sibling. */
+/** Delete target: first visible descendant when present, otherwise next sibling. */
+export const resolveFollowingContentTarget = (document, itemId, ctx) => {
+    const located = ctx.positions.positionOf(itemId);
+    if (!located || located.parent.type !== "list")
+        return null;
+    const current = located.parent.children?.[located.pos.offset];
+    if (!current || isTextNode(current))
+        return null;
+    const ownNested = nestedList(current);
+    const firstChild = ownNested?.children?.[0];
+    if (firstChild && !isTextNode(firstChild)) {
+        const target = deepestFirstItem(firstChild);
+        const owner = firstContentOwner(target);
+        return owner ? { itemId: target.id, ownerId: owner.id } : null;
+    }
+    const sibling = located.parent.children?.[located.pos.offset + 1];
+    if (!sibling || isTextNode(sibling))
+        return null;
+    const owner = firstContentOwner(sibling);
+    return owner ? { itemId: sibling.id, ownerId: owner.id } : null;
+};
+const splitInlineOwner = (owner, offset, newId) => {
+    const before = [];
+    const after = [];
+    let consumed = 0;
+    let split = false;
+    for (const child of owner.children || []) {
+        if (split) {
+            after.push(child);
+            continue;
+        }
+        const size = isTextNode(child) ? child.text.length : 1;
+        const local = offset - consumed;
+        if (local >= size) {
+            before.push(child);
+            consumed += size;
+            continue;
+        }
+        if (isTextNode(child)) {
+            if (local > 0)
+                before.push({ ...child, text: child.text.slice(0, local) });
+            if (local < size)
+                after.push({ ...child, text: child.text.slice(local) });
+        }
+        else if (local === 0)
+            after.push(child);
+        else
+            before.push(child);
+        split = true;
+        consumed += size;
+    }
+    const left = { ...owner, children: before };
+    return [left, { ...owner, id: newId, children: after }];
+};
+const emptyParagraph = (id) => ({ type: "paragraph", id, children: [] });
+export const enterInList = (document, pos, ids, ctx) => {
+    const context = contextAt(document, pos);
+    if (!context)
+        return null;
+    const scope = itemScope(document, context);
+    const depth = scope.items[0].depth;
+    const itemEmpty = (context.item.children || []).filter(isElementNode).filter((child) => child.type !== "list")
+        .every((child) => isInlineOwner(child) && inlineSize(child) === 0);
+    if (itemEmpty) {
+        if (depth > 0)
+            return {
+                operations: outdentList(document, scope, {}, ctx),
+                selectionTarget: { ownerId: context.owner.id, offset: 0 },
+                intent: "outdent",
+            };
+        const listChildren = context.list.children || [];
+        const splitsAfterItem = context.itemIndex > 0 && context.itemIndex < listChildren.length - 1;
+        return {
+            operations: unwrapList(document, scope, splitsAfterItem
+                ? { splitListIds: [ids.splitListId] }
+                : {}, ctx),
+            selectionTarget: { ownerId: context.owner.id, offset: 0 },
+            intent: "unwrap",
+        };
+    }
+    const ownerLength = inlineSize(context.owner);
+    const itemChildren = context.item.children || [];
+    const atItemStart = context.ownerIndex === 0 && pos.offset === 0;
+    const nonListChildren = itemChildren.filter((child) => isTextNode(child) || child.type !== "list");
+    const atItemEnd = context.ownerIndex === nonListChildren.length - 1 && pos.offset === ownerLength;
+    let first;
+    let second;
+    let target;
+    if (atItemStart) {
+        first = { type: "list_item", id: ids.itemId, children: [emptyParagraph(ids.emptyBlockId)] };
+        second = context.item;
+        target = { ownerId: context.owner.id, offset: 0 };
+    }
+    else if (atItemEnd) {
+        first = context.item;
+        second = { type: "list_item", id: ids.itemId, children: [emptyParagraph(ids.emptyBlockId)] };
+        target = { ownerId: ids.emptyBlockId, offset: 0 };
+    }
+    else {
+        const [leftOwner, rightOwner] = splitInlineOwner(context.owner, pos.offset, ids.blockId);
+        const beforeBlocks = itemChildren.slice(0, context.ownerIndex);
+        const afterBlocks = itemChildren.slice(context.ownerIndex + 1);
+        first = { ...context.item, children: [...beforeBlocks, leftOwner] };
+        // Nested lists and every block after the split stay with the second half.
+        second = { ...context.item, id: ids.itemId, children: [rightOwner, ...afterBlocks] };
+        target = { ownerId: rightOwner.id, offset: 0 };
+    }
+    const children = [...(context.list.children || [])];
+    children.splice(context.itemIndex, 1, first, second);
+    return {
+        operations: [{ type: "replaceNode", pos: { path: context.listPath.slice(0, -1), offset: context.listPath[context.listPath.length - 1] }, before: context.list, after: { ...context.list, children } }],
+        selectionTarget: target,
+        intent: "split",
+    };
+};
+const rootListForItem = (document, itemId, ctx) => {
+    let position = ctx.positions.positionOf(itemId);
+    if (!position)
+        return null;
+    let list = position.parent;
+    while (list.type === "list") {
+        const listPosition = ctx.positions.positionOf(list.id);
+        if (!listPosition || listPosition.parent.type !== "list_item")
+            return list;
+        const parentItemPosition = ctx.positions.positionOf(listPosition.parent.id);
+        if (!parentItemPosition)
+            return list;
+        list = parentItemPosition.parent;
+    }
+    return null;
+};
+const transformElement = (node, transform) => {
+    const direct = transform(node);
+    if (!direct)
+        return null;
+    const children = direct.children ? [] : undefined;
+    direct.children?.forEach((child) => {
+        if (isTextNode(child))
+            children.push(child);
+        else {
+            const next = transformElement(child, transform);
+            if (next)
+                children.push(next);
+        }
+    });
+    return children ? { ...direct, children } : direct;
+};
+const mergeOwners = (target, source, backward) => {
+    if (!isInlineOwner(target) || !isInlineOwner(source) || target.type !== source.type)
+        return target;
+    const children = [];
+    [...(target.children || []), ...(source.children || []).map(cloneNode)].forEach((child) => {
+        const previous = children[children.length - 1];
+        if (previous && isTextNode(previous) && isTextNode(child)
+            && JSON.stringify(previous.marks || []) === JSON.stringify(child.marks || [])) {
+            children[children.length - 1] = { ...previous, text: previous.text + child.text };
+        }
+        else
+            children.push(child);
+    });
+    return { ...target, children };
+};
+const mergeItems = (document, sourceItemId, targetItemId, sourceOwnerId, targetOwnerId, backward, ctx) => {
+    const root = rootListForItem(document, sourceItemId, ctx);
+    if (!root)
+        throw new Error("List merge root was not found.");
+    const rootLocated = ctx.positions.positionOf(root.id);
+    const sourceLocated = ctx.positions.positionOf(sourceItemId);
+    const targetLocated = ctx.positions.positionOf(targetItemId);
+    if (!rootLocated || !sourceLocated || !targetLocated)
+        throw new Error("List merge positions are stale.");
+    const sourceItem = sourceLocated.parent.children?.[sourceLocated.pos.offset];
+    const targetItem = targetLocated.parent.children?.[targetLocated.pos.offset];
+    if (!sourceItem || isTextNode(sourceItem) || !targetItem || isTextNode(targetItem))
+        throw new Error("List merge items are invalid.");
+    const sourceOwner = (sourceItem.children || []).find((child) => !isTextNode(child) && child.id === sourceOwnerId);
+    const targetOwner = (targetItem.children || []).find((child) => !isTextNode(child) && child.id === targetOwnerId);
+    if (!sourceOwner || isTextNode(sourceOwner) || !targetOwner || isTextNode(targetOwner))
+        throw new Error("List merge owners are invalid.");
+    const sourceOtherChildren = (sourceItem.children || []).filter((child) => isTextNode(child) || child.id !== sourceOwnerId);
+    const targetOffset = inlineSize(targetOwner);
+    const transformed = transformElement(root, (candidate) => {
+        if (candidate.id === sourceItemId)
+            return null;
+        if (candidate.id !== targetItemId)
+            return candidate;
+        const mergedOwner = mergeOwners(targetOwner, sourceOwner, backward);
+        const targetChildren = (candidate.children || []).map((child) => !isTextNode(child) && child.id === targetOwnerId ? mergedOwner : child);
+        return { ...candidate, children: [...targetChildren, ...sourceOtherChildren] };
+    });
+    if (!transformed)
+        throw new Error("List merge removed its root.");
+    const cleaned = transformElement(transformed, (candidate) => candidate.type === "list" && !(candidate.children?.length) ? null : candidate);
+    if (!cleaned)
+        throw new Error("List merge produced an empty root list.");
+    return {
+        // retiredInto marks this as a semantic merge, not a plain content
+        // change - an annotation anchored to the source item or its owner can
+        // snap to the corresponding target instead of orphaning. See
+        // annotations/range.ts.
+        operations: [{
+                type: "replaceNode", pos: { path: [...rootLocated.pos.path], offset: rootLocated.pos.offset }, before: root, after: cleaned,
+                retiredInto: [
+                    { retiredId: sourceItemId, survivorId: targetItemId },
+                    { retiredId: sourceOwnerId, survivorId: targetOwnerId },
+                ],
+            }],
+        selectionTarget: { ownerId: targetOwnerId, offset: targetOffset },
+        intent: backward ? "merge-backward" : "merge-forward",
+    };
+};
+export const backspaceAtListItemStart = (document, pos, ctx) => {
+    const context = contextAt(document, pos);
+    if (!context || pos.offset !== 0 || context.ownerIndex !== 0)
+        return null;
+    const metadata = listItemAt(document, pos);
+    const scope = itemScope(document, context);
+    if (metadata.depth > 0)
+        return {
+            operations: outdentList(document, scope, {}, ctx),
+            selectionTarget: { ownerId: context.owner.id, offset: 0 },
+            intent: "outdent",
+        };
+    if (context.itemIndex === 0)
+        return {
+            operations: unwrapList(document, scope, {}, ctx),
+            selectionTarget: { ownerId: context.owner.id, offset: 0 },
+            intent: "unwrap",
+        };
+    const resolved = resolveSharedPrecedingContentTarget(document, context.item.id, ctx);
+    const targetItem = resolved && [...resolved.lineage].reverse().find((entry) => entry.type === "list_item");
+    const target = resolved && targetItem ? { itemId: targetItem.nodeId, ownerId: resolved.ownerId } : null;
+    return target ? mergeItems(document, context.item.id, target.itemId, context.owner.id, target.ownerId, true, ctx) : null;
+};
+export const deleteAtListItemEnd = (document, pos, ctx) => {
+    const context = contextAt(document, pos);
+    if (!context || pos.offset !== inlineSize(context.owner))
+        return null;
+    const target = resolveFollowingContentTarget(document, context.item.id, ctx);
+    if (!target)
+        return null;
+    return mergeItems(document, target.itemId, context.item.id, target.ownerId, context.owner.id, false, ctx);
+};

package/dist/foundation/list/plugin.d.ts

@@ -0,0 +1,21 @@
+import { type KeyboardShortcutContribution, type PluginCommand } from "../plugin/types.js";
+/**
+ * Wraps the ten existing, already-tested list commands (list/commands.ts)
+ * with the description Phase 10's doc generation needs. list has no
+ * per-item declaration layer the way block/marks/atom do (no single
+ * "declaration" maps 1:1 to a toolbar button set) - list.setPreset's
+ * `preset` param covers what a bulleted/numbered/checklist toolbar would
+ * offer, so no separate toolbar-contribution list is built here.
+ */
+export declare const listPluginCommands: Record<string, PluginCommand>;
+/**
+ * Tab/Shift+Tab inside a list-selection scope, priority 10 - lower than
+ * block's code-indent (20), so a code-block caret's Tab wins first (see
+ * block/plugin.ts's blockPluginShortcuts); indentList/outdentList
+ * themselves need a fresh id per invocation (nestedListIds/splitListIds),
+ * which a static KeyboardShortcutContribution.params can't hold, so the
+ * dispatch caller (surface/input.ts) generates it at invocation time, the
+ * same way every other id-generating command call in this codebase already
+ * does (e.g. CanonicalAuthorityEditor.tsx's table commands).
+ */
+export declare const listPluginShortcuts: readonly KeyboardShortcutContribution[];

package/dist/foundation/list/plugin.js

@@ -0,0 +1,71 @@
+import { definePluginCommand } from "../plugin/types.js";
+import { continueListNumbering, createList, indentList, moveListItems, outdentList, restartListNumbering, setListChecked, setListPreset, setListStyle, unwrapList, } from "./commands.js";
+/**
+ * Wraps the ten existing, already-tested list commands (list/commands.ts)
+ * with the description Phase 10's doc generation needs. list has no
+ * per-item declaration layer the way block/marks/atom do (no single
+ * "declaration" maps 1:1 to a toolbar button set) - list.setPreset's
+ * `preset` param covers what a bulleted/numbered/checklist toolbar would
+ * offer, so no separate toolbar-contribution list is built here.
+ */
+export const listPluginCommands = {
+    "list.create": definePluginCommand({
+        id: "list.create", run: createList,
+        description: "Wraps the selected blocks in a new list (or converts an existing list's items) using the given preset.",
+        options: { preset: { description: "The list preset id, e.g. \"bulleted\" or \"numbered\"." } },
+    }),
+    "list.unwrap": definePluginCommand({
+        id: "list.unwrap", run: unwrapList,
+        description: "Removes the selected list items from their list, promoting their content back to plain blocks.",
+    }),
+    "list.indent": definePluginCommand({
+        id: "list.indent", run: indentList,
+        description: "Nests the selected list items one level deeper under the preceding sibling item.",
+    }),
+    "list.outdent": definePluginCommand({
+        id: "list.outdent", run: outdentList,
+        description: "Moves the selected list items one level shallower, or unwraps them entirely if already at the top level.",
+    }),
+    "list.setPreset": definePluginCommand({
+        id: "list.setPreset", run: setListPreset,
+        description: "Changes the selected list's preset (e.g. bulleted, numbered, checklist), restyling its markers accordingly.",
+        options: { preset: { description: "The new preset id." } },
+    }),
+    "list.setStyle": definePluginCommand({
+        id: "list.setStyle", run: setListStyle,
+        description: "Changes the selected list's marker style (e.g. disc, decimal, lower-alpha) independent of its preset.",
+    }),
+    "list.setChecked": definePluginCommand({
+        id: "list.setChecked", run: setListChecked,
+        description: "Toggles a checklist item's checked state.",
+        options: { checked: { description: "The new checked state.", required: true } },
+    }),
+    "list.move": definePluginCommand({
+        id: "list.move", run: moveListItems,
+        description: "Moves the selected list items up or down among their siblings.",
+        options: { direction: { description: "\"up\" or \"down\".", required: true } },
+    }),
+    "list.restartNumbering": definePluginCommand({
+        id: "list.restartNumbering", run: restartListNumbering,
+        description: "Restarts an ordered list's numbering at the given value from this item onward.",
+        options: { start: { description: "The number to restart counting from.", required: true } },
+    }),
+    "list.continueNumbering": definePluginCommand({
+        id: "list.continueNumbering", run: continueListNumbering,
+        description: "Removes an explicit numbering restart, letting this item continue the count from the preceding item.",
+    }),
+};
+/**
+ * Tab/Shift+Tab inside a list-selection scope, priority 10 - lower than
+ * block's code-indent (20), so a code-block caret's Tab wins first (see
+ * block/plugin.ts's blockPluginShortcuts); indentList/outdentList
+ * themselves need a fresh id per invocation (nestedListIds/splitListIds),
+ * which a static KeyboardShortcutContribution.params can't hold, so the
+ * dispatch caller (surface/input.ts) generates it at invocation time, the
+ * same way every other id-generating command call in this codebase already
+ * does (e.g. CanonicalAuthorityEditor.tsx's table commands).
+ */
+export const listPluginShortcuts = [
+    { id: "list.indent", commandId: "list.indent", key: "Tab", scopeKinds: ["list-selection"], priority: 10 },
+    { id: "list.outdent", commandId: "list.outdent", key: "Tab", shift: true, scopeKinds: ["list-selection"], priority: 10 },
+];

package/dist/foundation/list/presets.d.ts

@@ -0,0 +1,16 @@
+export type FoundationSmartListKind = "bullet" | "ordered";
+export type FoundationSmartListStyle = "disc" | "circle" | "square" | "decimal" | "decimal-leading-zero" | "lower-alpha" | "upper-alpha" | "lower-roman" | "upper-roman";
+export type FoundationSmartListPreset = "bullet-disc" | "bullet-diamond" | "bullet-square" | "bullet-arrow" | "bullet-star" | "bullet-arrow-circle" | "ordered-decimal" | "ordered-decimal-paren" | "ordered-outline" | "ordered-upper-alpha" | "ordered-upper-roman" | "ordered-leading-zero";
+export interface FoundationSmartListPresetDefinition {
+    id: FoundationSmartListPreset;
+    kind: FoundationSmartListKind;
+    label: string;
+    styles: readonly FoundationSmartListStyle[];
+    markers?: readonly string[];
+    outline?: boolean;
+    suffix?: "." | ")";
+}
+/** The only list preset catalog accepted by canonical commands and schema. */
+export declare const FOUNDATION_SMART_LIST_PRESETS: readonly FoundationSmartListPresetDefinition[];
+export declare const isFoundationSmartListPreset: (value: unknown) => value is FoundationSmartListPreset;
+export declare const foundationListStyleForPresetDepth: (id: FoundationSmartListPreset, depth: number) => FoundationSmartListStyle;

package/dist/foundation/list/presets.js

@@ -0,0 +1,21 @@
+/** The only list preset catalog accepted by canonical commands and schema. */
+export const FOUNDATION_SMART_LIST_PRESETS = [
+    { id: "ordered-decimal", kind: "ordered", label: "1. / a. / i.", styles: ["decimal", "lower-alpha", "lower-roman"], suffix: "." },
+    { id: "ordered-decimal-paren", kind: "ordered", label: "1) / a) / i)", styles: ["decimal", "lower-alpha", "lower-roman"], suffix: ")" },
+    { id: "ordered-outline", kind: "ordered", label: "1. / 1.1. / 1.1.1.", styles: ["decimal", "decimal", "decimal"], suffix: ".", outline: true },
+    { id: "ordered-upper-alpha", kind: "ordered", label: "A. / a. / i.", styles: ["upper-alpha", "lower-alpha", "lower-roman"], suffix: "." },
+    { id: "ordered-upper-roman", kind: "ordered", label: "I. / A. / 1.", styles: ["upper-roman", "upper-alpha", "decimal"], suffix: "." },
+    { id: "ordered-leading-zero", kind: "ordered", label: "01. / a. / i.", styles: ["decimal-leading-zero", "lower-alpha", "lower-roman"], suffix: "." },
+    { id: "bullet-disc", kind: "bullet", label: "● / ○ / ■", styles: ["disc", "circle", "square"] },
+    { id: "bullet-diamond", kind: "bullet", label: "❖ / ➢ / ■", styles: ["disc", "circle", "square"], markers: ["❖", "➢", "■"] },
+    { id: "bullet-square", kind: "bullet", label: "□ / ▣ / ▪", styles: ["square", "square", "square"], markers: ["□", "▣", "▪"] },
+    { id: "bullet-arrow", kind: "bullet", label: "➜ / ◆ / ●", styles: ["disc", "circle", "square"], markers: ["➜", "◆", "●"] },
+    { id: "bullet-star", kind: "bullet", label: "★ / ○ / ■", styles: ["disc", "circle", "square"], markers: ["★", "○", "■"] },
+    { id: "bullet-arrow-circle", kind: "bullet", label: "➢ / ○ / ■", styles: ["disc", "circle", "square"], markers: ["➢", "○", "■"] },
+];
+const presetMap = new Map(FOUNDATION_SMART_LIST_PRESETS.map((preset) => [preset.id, preset]));
+export const isFoundationSmartListPreset = (value) => typeof value === "string" && presetMap.has(value);
+export const foundationListStyleForPresetDepth = (id, depth) => {
+    const styles = presetMap.get(id).styles;
+    return styles[Math.min(Math.max(0, depth), styles.length - 1)];
+};

package/dist/foundation/list/schema.d.ts

@@ -0,0 +1,35 @@
+export declare const listNodeSpecs: readonly [{
+    readonly type: "list";
+    readonly group: "block";
+    readonly semanticRole: "list";
+    readonly content: "list_item+";
+    readonly attributes: {
+        readonly preset: {
+            validate: (value: unknown) => value is import("./presets.js").FoundationSmartListPreset;
+        };
+        readonly style: {
+            validate: (value: unknown) => value is string;
+        };
+        readonly start: {
+            validate: (value: unknown) => boolean;
+        };
+        readonly checkable: {
+            readonly validate: (value: unknown) => value is boolean;
+            readonly default: false;
+        };
+    };
+}, {
+    readonly type: "list_item";
+    readonly group: "block";
+    readonly semanticRole: "list-item";
+    readonly content: "block+";
+    readonly attributes: {
+        readonly checked: {
+            readonly validate: (value: unknown) => value is boolean;
+            readonly default: false;
+        };
+        readonly numberOverride: {
+            validate: (value: unknown) => boolean;
+        };
+    };
+}];

package/dist/foundation/list/schema.js

@@ -0,0 +1,29 @@
+import { isFoundationSmartListPreset } from "./presets.js";
+const optionalString = { validate: (value) => typeof value === "string" };
+const optionalPreset = { validate: isFoundationSmartListPreset };
+const optionalBoolean = { validate: (value) => typeof value === "boolean" };
+const positiveInteger = { validate: (value) => Number.isInteger(value) && Number(value) >= 1 };
+export const listNodeSpecs = [
+    {
+        type: "list",
+        group: "block",
+        semanticRole: "list",
+        content: "list_item+",
+        attributes: {
+            preset: optionalPreset,
+            style: optionalString,
+            start: positiveInteger,
+            checkable: { default: false, ...optionalBoolean },
+        },
+    },
+    {
+        type: "list_item",
+        group: "block",
+        semanticRole: "list-item",
+        content: "block+",
+        attributes: {
+            checked: { default: false, ...optionalBoolean },
+            numberOverride: positiveInteger,
+        },
+    },
+];

package/dist/foundation/list/shadow.d.ts

@@ -0,0 +1,54 @@
+import type { SmartDocument, SmartSchema, SmartSelection } from "../types.js";
+export type ShadowDivergenceClassification = "expected-normalization" | "equivalent-serialization" | "selection-only" | "visual-only" | "semantic" | "data-loss" | "unknown";
+export interface ShadowComparisonResult {
+    readonly equivalent: boolean;
+    readonly documentEquivalent: boolean;
+    readonly selectionEquivalent: boolean;
+    readonly legacyStructureHash: string;
+    readonly canonicalStructureHash: string;
+    readonly legacySelectionHash: string;
+    readonly canonicalSelectionHash: string;
+    readonly classification?: ShadowDivergenceClassification;
+}
+/**
+ * Comparator equivalence is normalized document structure with IDs stripped,
+ * plus semantic selection position. Operation streams are intentionally not
+ * compared: canonical editing is allowed to express the same user intent with
+ * a different operation sequence, and the legacy engine has no stable IDs.
+ */
+export declare const normalizedStructureWithoutIds: (document: SmartDocument, schema: SmartSchema) => unknown;
+export declare const semanticSelectionPosition: (document: SmartDocument, selection: SmartSelection) => {
+    type: "text" | "node" | "cell" | "none";
+    anchor: {
+        path: number[];
+        offset: number;
+        ownerType: string;
+        kind: "inline" | "structural";
+    };
+    head: {
+        path: number[];
+        offset: number;
+        ownerType: string;
+        kind: "inline" | "structural";
+    };
+};
+export declare const compareShadowDocuments: (args: {
+    legacyDocument: SmartDocument;
+    legacySelection: SmartSelection;
+    canonicalDocument: SmartDocument;
+    canonicalSelection: SmartSelection;
+    schema: SmartSchema;
+    classification?: ShadowDivergenceClassification;
+}) => ShadowComparisonResult;
+/** Privacy-safe logger payload: hashes and classification, never document text. */
+export declare const shadowLogRecord: (scenarioId: string, result: ShadowComparisonResult) => {
+    classification?: ShadowDivergenceClassification | undefined;
+    scenarioId: string;
+    equivalent: boolean;
+    documentEquivalent: boolean;
+    selectionEquivalent: boolean;
+    legacyStructureHash: string;
+    canonicalStructureHash: string;
+    legacySelectionHash: string;
+    canonicalSelectionHash: string;
+};