smartrte-react 0.3.3 → 0.3.5

package/dist/adapters/domTableCommandBridge.js

@@ -0,0 +1,201 @@
+import { createSmartEditor, tablePlugin, } from "smartrte-core";
+import { serializeSmartDocument, smartDocumentFromHtml } from "./domSmartDocument.js";
+const cellsOf = (row) => Array.from(row.children).filter((node) => node instanceof HTMLTableCellElement);
+const cellGrid = (table) => {
+    const rows = Array.from(table.rows);
+    const grid = [];
+    rows.forEach((row, rowIndex) => {
+        grid[rowIndex] || (grid[rowIndex] = []);
+        let column = 0;
+        cellsOf(row).forEach((cell) => {
+            var _a;
+            while (grid[rowIndex][column])
+                column += 1;
+            const rowspan = Math.max(1, cell.rowSpan || 1);
+            const colspan = Math.max(1, cell.colSpan || 1);
+            for (let rowOffset = 0; rowOffset < rowspan; rowOffset += 1) {
+                grid[_a = rowIndex + rowOffset] || (grid[_a] = []);
+                for (let columnOffset = 0; columnOffset < colspan; columnOffset += 1) {
+                    grid[rowIndex + rowOffset][column + columnOffset] = cell;
+                }
+            }
+            column += colspan;
+        });
+    });
+    return grid;
+};
+const copyVisualAttributes = (from, to) => {
+    const style = from.getAttribute("style");
+    const className = from.getAttribute("class");
+    if (style)
+        to.setAttribute("style", style);
+    if (className)
+        to.setAttribute("class", className);
+};
+const reconcileHeaderStyle = (from, to) => {
+    if (from.tagName === to.tagName)
+        return;
+    if (to.tagName === "TH") {
+        to.style.fontWeight = "700";
+        to.style.background = to.style.background || "#f3f4f6";
+        to.style.textAlign = to.style.textAlign || "left";
+        return;
+    }
+    if (to.style.fontWeight === "700" || to.style.fontWeight === "bold")
+        to.style.fontWeight = "";
+    if (to.style.background === "rgb(243, 244, 246)" || to.style.background === "#f3f4f6") {
+        to.style.background = "";
+    }
+};
+/**
+ * Executes a core table command while replacing only the affected table.
+ * Visual table/cell attributes are transferred by logical grid position.
+ */
+export const executeDomTableCommand = (table, command) => {
+    const document = smartDocumentFromHtml(table.outerHTML, table.ownerDocument);
+    if (document.children.length !== 1 || document.children[0].type !== "table")
+        return null;
+    const editor = createSmartEditor({
+        state: { document, selection: { type: "node", path: [0] } },
+        plugins: [tablePlugin],
+    });
+    if (!editor.execute(command.id, { ...command.input, tablePath: [0] }))
+        return null;
+    if (command.id === "table.column.width.set") {
+        let group = table.querySelector(":scope > colgroup");
+        if (!group) {
+            group = table.ownerDocument.createElement("colgroup");
+            table.insertBefore(group, table.firstChild);
+        }
+        const logicalWidth = Math.max(...cellGrid(table).map((row) => row.length));
+        while (group.children.length < logicalWidth) {
+            group.appendChild(table.ownerDocument.createElement("col"));
+        }
+        const column = group.children[command.input.index];
+        if (!column)
+            return null;
+        column.style.width = `${command.input.widthPx}px`;
+        const seen = new Set();
+        cellGrid(table).forEach((row) => {
+            const target = row[command.input.index];
+            if (!target || seen.has(target))
+                return;
+            seen.add(target);
+            target.style.width = `${command.input.widthPx}px`;
+            target.style.minWidth = `${command.input.widthPx}px`;
+            target.style.maxWidth = `${command.input.widthPx}px`;
+        });
+        return table;
+    }
+    if (command.id === "table.row.height.set") {
+        const row = table.rows[command.input.index];
+        if (!row)
+            return null;
+        row.style.height = `${command.input.heightPx}px`;
+        cellsOf(row).forEach((target) => {
+            target.style.height = `${command.input.heightPx}px`;
+        });
+        return table;
+    }
+    if (command.id === "table.cell.style.set") {
+        const end = command.input.end || command.input.start;
+        const top = Math.min(command.input.start.row, end.row);
+        const bottom = Math.max(command.input.start.row, end.row);
+        const left = Math.min(command.input.start.column, end.column);
+        const right = Math.max(command.input.start.column, end.column);
+        const grid = cellGrid(table);
+        const targets = new Set();
+        for (let row = top; row <= bottom; row += 1) {
+            for (let column = left; column <= right; column += 1) {
+                const target = grid[row]?.[column];
+                if (target)
+                    targets.add(target);
+            }
+        }
+        targets.forEach((target) => {
+            if (command.input.backgroundColor !== undefined) {
+                target.style.backgroundColor = command.input.backgroundColor || "";
+            }
+            if (command.input.textColor !== undefined) {
+                target.style.color = command.input.textColor || "";
+            }
+        });
+        return table;
+    }
+    if (command.id === "table.cell.border.toggle") {
+        const end = command.input.end || command.input.start;
+        const top = Math.min(command.input.start.row, end.row);
+        const bottom = Math.max(command.input.start.row, end.row);
+        const left = Math.min(command.input.start.column, end.column);
+        const right = Math.max(command.input.start.column, end.column);
+        const grid = cellGrid(table);
+        const targets = new Set();
+        for (let row = top; row <= bottom; row += 1) {
+            for (let column = left; column <= right; column += 1) {
+                const target = grid[row]?.[column];
+                if (target)
+                    targets.add(target);
+            }
+        }
+        targets.forEach((target) => {
+            target.style.border = target.style.border && target.style.border !== "none"
+                ? "none"
+                : command.input.visibleBorder || "1px solid #d1d5db";
+        });
+        return table;
+    }
+    const container = table.ownerDocument.createElement("div");
+    container.innerHTML = serializeSmartDocument(editor.state.document);
+    const replacement = container.querySelector("table");
+    if (!(replacement instanceof HTMLTableElement))
+        return null;
+    copyVisualAttributes(table, replacement);
+    const previousGrid = cellGrid(table);
+    const nextGrid = cellGrid(replacement);
+    const previousPosition = (row, column) => {
+        if (command.id === "table.row.add") {
+            if (row === command.input.index)
+                return null;
+            return { row: row > command.input.index ? row - 1 : row, column };
+        }
+        if (command.id === "table.row.remove") {
+            return { row: row >= command.input.index ? row + 1 : row, column };
+        }
+        if (command.id === "table.column.add") {
+            if (column === command.input.index)
+                return null;
+            return { row, column: column > command.input.index ? column - 1 : column };
+        }
+        if (command.id === "table.column.remove") {
+            return { row, column: column >= command.input.index ? column + 1 : column };
+        }
+        return { row, column };
+    };
+    const copied = new Set();
+    nextGrid.forEach((row, rowIndex) => row.forEach((nextCell, column) => {
+        if (!nextCell || copied.has(nextCell))
+            return;
+        const position = previousPosition(rowIndex, column);
+        const previousCell = position ? previousGrid[position.row]?.[position.column] : undefined;
+        if (previousCell) {
+            copyVisualAttributes(previousCell, nextCell);
+            reconcileHeaderStyle(previousCell, nextCell);
+        }
+        copied.add(nextCell);
+    }));
+    table.replaceWith(replacement);
+    return replacement;
+};
+export const executeDomTableRemoval = (table) => {
+    const document = smartDocumentFromHtml(table.outerHTML, table.ownerDocument);
+    if (document.children.length !== 1 || document.children[0].type !== "table")
+        return false;
+    const editor = createSmartEditor({
+        state: { document, selection: { type: "node", path: [0] } },
+        plugins: [tablePlugin],
+    });
+    if (!editor.execute("table.remove", { tablePath: [0] }))
+        return false;
+    table.remove();
+    return true;
+};

package/dist/adapters/legacyListShadowComparator.d.ts

@@ -0,0 +1,26 @@
+import { shadowLogRecord } from "smartrte-core";
+export interface NamedListIntentReplay {
+    readonly intent: string;
+    readonly equivalent: boolean;
+    readonly selectionCompared: boolean;
+    readonly classification?: string;
+    readonly hash: string;
+}
+/**
+ * Replays the named list intents against the retained command snapshots and
+ * the canonical commands.  The retained selection can be a node selection
+ * after list toggles; it is intentionally converted to the first text owner
+ * so both engines are compared at the same semantic editing point rather than
+ * comparing legacy path identity or operation streams.
+ */
+export declare const runNamedListIntent: (intent: string) => NamedListIntentReplay;
+export declare const runNamedListIntentCorpus: () => NamedListIntentReplay[];
+export interface DualEngineShadowSummary {
+    readonly seed: number;
+    readonly scenarios: number;
+    readonly equivalent: number;
+    readonly divergences: Readonly<Record<string, number>>;
+    readonly logs: readonly ReturnType<typeof shadowLogRecord>[];
+}
+/** Executes both the legacy model commands and canonical pure commands. */
+export declare const runDualEngineListShadowCorpus: (scenarios?: number, seed?: number) => DualEngineShadowSummary;

package/dist/adapters/legacyListShadowComparator.js

@@ -0,0 +1,316 @@
+import { applyOperations, compareShadowDocuments, createTransactionMap, createList, createScopeIndex, foundationSchema, indentList, moveListItems, outdentList, setListChecked, setListPreset, setListStyle, shadowLogRecord, unwrapList, isTextNode, } from "smartrte-core";
+import { applyTransaction as applyLegacyTransaction, indentListItems as legacyIndentListItems, moveBlocks as legacyMoveBlocks, outdentListItems as legacyOutdentListItems, setChecklistItemChecked as legacySetChecklistItemChecked, toggleList as legacyToggleList, } from "smartrte-core/legacy";
+const p = (id, text) => ({ type: "paragraph", id, children: [{ type: "text", text }] });
+const item = (id, text, nested) => ({ type: "list_item", id, children: [p(`${id}-p`, text), ...(nested ? [nested] : [])] });
+const list = (id, children, style = "decimal") => ({ type: "list", id, attrs: { style }, children });
+const scope = (listId, ids, depth = 0) => ({
+    kind: "list-selection", listId, items: ids.map((itemId) => ({ itemId, depth, hasChildList: false })),
+    partialSubtree: false, promotedFromPartial: false,
+    range: { from: { path: [], offset: 0 }, to: { path: [], offset: 0 } }, isolatingAncestorId: null, clamped: false,
+});
+const ctx = (document) => ({ schema: foundationSchema, positions: createScopeIndex().positions(document, foundationSchema) });
+const inlineToLegacy = (node) => isTextNode(node)
+    ? { type: "text", text: node.text }
+    : { type: "formula", value: String(node.attrs?.originalType || node.type) };
+const blockToLegacy = (node) => {
+    if (node.type === "paragraph")
+        return { type: "paragraph", children: (node.children || []).map(inlineToLegacy) };
+    if (node.type === "heading")
+        return { type: "heading", level: Number(node.attrs?.level || 1), children: (node.children || []).map(inlineToLegacy) };
+    if (node.type === "list")
+        return {
+            type: "list", style: String(node.attrs?.style || "disc"),
+            ...(typeof node.attrs?.preset === "string" ? { preset: node.attrs.preset } : {}),
+            ...(node.attrs?.checkable === true ? { checklist: true } : {}),
+            children: (node.children || []).filter((child) => !isTextNode(child)).map((child) => ({
+                type: "listItem", ...(child.attrs?.checked !== undefined ? { checked: child.attrs.checked === true } : {}),
+                children: (child.children || []).filter((entry) => !isTextNode(entry)).map(blockToLegacy),
+            })),
+        };
+    return { type: "paragraph", children: [{ type: "text", text: "" }] };
+};
+const toLegacy = (document) => ({
+    type: "doc", children: document.children.filter((node) => !isTextNode(node)).map(blockToLegacy),
+});
+let canonicalId = 0;
+const inlineFromLegacy = (node) => node.type === "text"
+    ? { type: "text", text: node.text }
+    : { type: "unknown", id: `legacy-atom-${canonicalId++}`, attrs: { originalType: node.type, originalGroup: "inline", raw: node, editable: false } };
+const blockFromLegacy = (node) => {
+    const id = `legacy-${canonicalId++}`;
+    if (node.type === "paragraph")
+        return { type: "paragraph", id, children: node.children.map(inlineFromLegacy) };
+    if (node.type === "heading")
+        return { type: "heading", id, attrs: { level: node.level }, children: node.children.map(inlineFromLegacy) };
+    if (node.type === "list")
+        return {
+            type: "list", id, attrs: {
+                style: node.style,
+                ...(node.preset ? { preset: node.preset } : {}),
+                ...(node.checklist ? { checkable: true } : {}),
+            }, children: node.children.map((entry) => ({
+                type: "list_item", id: `legacy-${canonicalId++}`,
+                ...(entry.checked !== undefined ? { attrs: { checked: entry.checked } } : {}),
+                children: entry.children.map(blockFromLegacy),
+            })),
+        };
+    return { type: "paragraph", id, children: [{ type: "text", text: "" }] };
+};
+const fromLegacy = (document) => {
+    canonicalId = 0;
+    return { type: "doc", id: "legacy-doc", children: document.children.map(blockFromLegacy) };
+};
+const firstOwner = (document) => {
+    const visit = (nodes, path) => {
+        for (let index = 0; index < nodes.length; index += 1) {
+            const node = nodes[index];
+            if (isTextNode(node))
+                continue;
+            const next = [...path, index];
+            if (node.type === "paragraph" || node.type === "heading")
+                return next;
+            const found = visit(node.children || [], next);
+            if (found)
+                return found;
+        }
+        return null;
+    };
+    return visit(document.children, []) || [];
+};
+const firstOwnerUnder = (document, path) => {
+    let node = document;
+    for (const index of path) {
+        if (isTextNode(node) || !node.children)
+            break;
+        node = node.children[index];
+    }
+    if (!node || isTextNode(node))
+        return firstOwner(document);
+    const visit = (candidate, candidatePath) => {
+        if (!isTextNode(candidate) && (candidate.type === "paragraph" || candidate.type === "heading"))
+            return candidatePath;
+        if (isTextNode(candidate))
+            return null;
+        for (let index = 0; index < (candidate.children || []).length; index += 1) {
+            const found = visit(candidate.children[index], [...candidatePath, index]);
+            if (found)
+                return found;
+        }
+        return null;
+    };
+    return visit(node, [...path]) || firstOwner(document);
+};
+const legacyPointToFoundation = (document, point) => {
+    const path = point.path.length ? [...point.path.slice(0, -1)] : firstOwner(document);
+    return { path, offset: point.offset };
+};
+const legacySelectionToFoundation = (document, selection) => {
+    if (selection.type === "text") {
+        const anchor = legacyPointToFoundation(document, selection.anchor);
+        const head = legacyPointToFoundation(document, selection.focus);
+        return { type: "text", anchor, head };
+    }
+    if (selection.type === "node") {
+        const owner = firstOwnerUnder(document, selection.path);
+        return { type: "text", anchor: { path: owner, offset: 0 }, head: { path: owner, offset: 0 } };
+    }
+    const owner = firstOwner(document);
+    return { type: "text", anchor: { path: owner, offset: 0 }, head: { path: owner, offset: 0 } };
+};
+const replayHash = (value) => {
+    const input = JSON.stringify(value) ?? String(value);
+    let state = 2166136261;
+    for (let index = 0; index < input.length; index += 1) {
+        state ^= input.charCodeAt(index);
+        state = Math.imul(state, 16777619);
+    }
+    return (state >>> 0).toString(16).padStart(8, "0");
+};
+const listScope = (listId, itemIds, depth = 0) => scope(listId, itemIds, depth);
+/**
+ * Replays the named list intents against the retained command snapshots and
+ * the canonical commands.  The retained selection can be a node selection
+ * after list toggles; it is intentionally converted to the first text owner
+ * so both engines are compared at the same semantic editing point rather than
+ * comparing legacy path identity or operation streams.
+ */
+export const runNamedListIntent = (intent) => {
+    const suffix = intent.replace(/[^a-z0-9]+/gi, "-").toLowerCase();
+    let canonical;
+    let legacy;
+    let legacySelection;
+    let canonicalOperations = [];
+    const compare = (initialSelection, transaction) => {
+        const nextLegacy = applyLegacyTransaction({ document: legacy, selection: legacySelection }, transaction);
+        const legacyDocument = fromLegacy(nextLegacy.document);
+        const legacySemanticSelection = legacySelectionToFoundation(legacyDocument, nextLegacy.selection);
+        const canonicalSemanticSelection = createTransactionMap(canonicalOperations).mapSelection(initialSelection);
+        const result = compareShadowDocuments({
+            legacyDocument,
+            legacySelection: legacySemanticSelection,
+            canonicalDocument: canonical,
+            canonicalSelection: canonicalSemanticSelection,
+            schema: foundationSchema,
+        });
+        const classification = !result.documentEquivalent && intent === "list.setPreset"
+            ? "expected-normalization"
+            : result.classification;
+        return {
+            intent,
+            equivalent: result.equivalent,
+            selectionCompared: true,
+            ...(classification ? { classification } : {}),
+            hash: replayHash([result.legacyStructureHash, result.canonicalStructureHash, result.legacySelectionHash, result.canonicalSelectionHash]),
+        };
+    };
+    if (intent === "list.create" || intent === "list.create.numbered") {
+        canonical = { type: "doc", id: `doc-${suffix}`, children: [p(`a-${suffix}`, "a"), p(`b-${suffix}`, "b")] };
+        legacy = toLegacy(canonical);
+        legacySelection = { type: "text", anchor: { path: [0, 0], offset: 0 }, focus: { path: [1, 0], offset: 0 } };
+        const initialSelection = { type: "text", anchor: { path: [0], offset: 0 }, head: { path: [1], offset: 0 } };
+        canonicalOperations = createList(canonical, {
+            kind: "block-range", blockIds: [`a-${suffix}`, `b-${suffix}`], promotedFromPartial: true,
+            commonParentId: canonical.id, range: { from: { path: [], offset: 0 }, to: { path: [], offset: 2 } }, isolatingAncestorId: null, clamped: false,
+        }, { listIds: [`list-${suffix}`], itemIds: [`ia-${suffix}`, `ib-${suffix}`], style: intent.endsWith("numbered") ? "decimal" : "disc" }, ctx(canonical));
+        canonical = applyOperations(canonical, canonicalOperations);
+        const legacyTransaction = legacyToggleList.execute({ document: legacy, selection: legacySelection }, { style: intent.endsWith("numbered") ? "decimal" : "disc" });
+        return compare(initialSelection, legacyTransaction);
+    }
+    const baseList = (attrs = {}, includeNested = false) => ({
+        type: "doc", id: `doc-${suffix}`, children: [list(`list-${suffix}`, [
+                item(`a-${suffix}`, "a", includeNested ? list(`nested-${suffix}`, [item(`nested-item-${suffix}`, "nested")]) : undefined),
+                item(`b-${suffix}`, "b"), item(`c-${suffix}`, "c"),
+            ], String(attrs.style || "disc"))],
+    });
+    if (intent === "list.setPreset") {
+        canonical = baseList({ style: "disc" });
+        legacy = toLegacy(canonical);
+        legacySelection = { type: "text", anchor: { path: [0, 1, 0, 0], offset: 0 }, focus: { path: [0, 1, 0, 0], offset: 0 } };
+        const initialSelection = { type: "text", anchor: { path: [0, 1, 0], offset: 0 }, head: { path: [0, 1, 0], offset: 0 } };
+        canonicalOperations = setListPreset(canonical, listScope(`list-${suffix}`, [`b-${suffix}`]), { preset: "bullet-disc" }, ctx(canonical));
+        canonical = applyOperations(canonical, canonicalOperations);
+        return compare(initialSelection, legacyToggleList.execute({ document: legacy, selection: legacySelection }, { style: "disc", preset: "bullet-disc" }));
+    }
+    if (intent === "list.setStyle") {
+        canonical = baseList({ style: "disc" });
+        legacy = toLegacy(canonical);
+        legacySelection = { type: "text", anchor: { path: [0, 1, 0, 0], offset: 0 }, focus: { path: [0, 1, 0, 0], offset: 0 } };
+        const initialSelection = { type: "text", anchor: { path: [0, 1, 0], offset: 0 }, head: { path: [0, 1, 0], offset: 0 } };
+        canonicalOperations = setListStyle(canonical, listScope(`list-${suffix}`, [`b-${suffix}`]), { style: "upper-roman" }, ctx(canonical));
+        canonical = applyOperations(canonical, canonicalOperations);
+        return compare(initialSelection, legacyToggleList.execute({ document: legacy, selection: legacySelection }, { style: "upper-roman" }));
+    }
+    if (intent === "list.indent") {
+        canonical = baseList();
+        legacy = toLegacy(canonical);
+        legacySelection = { type: "text", anchor: { path: [0, 1, 0, 0], offset: 0 }, focus: { path: [0, 1, 0, 0], offset: 0 } };
+        const initialSelection = { type: "text", anchor: { path: [0, 1, 0], offset: 0 }, head: { path: [0, 1, 0], offset: 0 } };
+        canonicalOperations = indentList(canonical, listScope(`list-${suffix}`, [`b-${suffix}`]), { nestedListIds: [`nested-${suffix}`] }, ctx(canonical));
+        canonical = applyOperations(canonical, canonicalOperations);
+        return compare(initialSelection, legacyIndentListItems.execute({ document: legacy, selection: legacySelection }));
+    }
+    if (intent === "list.outdent") {
+        canonical = baseList({}, true);
+        legacy = toLegacy(canonical);
+        legacySelection = { type: "text", anchor: { path: [0, 0, 1, 0, 0, 0], offset: 0 }, focus: { path: [0, 0, 1, 0, 0, 0], offset: 0 } };
+        const initialSelection = { type: "text", anchor: { path: [0, 0, 1, 0, 0], offset: 0 }, head: { path: [0, 0, 1, 0, 0], offset: 0 } };
+        canonicalOperations = outdentList(canonical, listScope(`nested-${suffix}`, [`nested-item-${suffix}`], 1), {}, ctx(canonical));
+        canonical = applyOperations(canonical, canonicalOperations);
+        return compare(initialSelection, legacyOutdentListItems.execute({ document: legacy, selection: legacySelection }));
+    }
+    if (intent === "list.move" || intent === "list.move.reverse") {
+        canonical = baseList();
+        legacy = toLegacy(canonical);
+        legacySelection = { type: "text", anchor: { path: [0, 1, 0, 0], offset: 0 }, focus: { path: [0, 1, 0, 0], offset: 0 } };
+        const initialSelection = { type: "text", anchor: { path: [0, 1, 0], offset: 0 }, head: { path: [0, 1, 0], offset: 0 } };
+        const direction = intent === "list.move" ? "up" : "down";
+        canonicalOperations = moveListItems(canonical, listScope(`list-${suffix}`, [`b-${suffix}`]), { direction }, ctx(canonical));
+        canonical = applyOperations(canonical, canonicalOperations);
+        return compare(initialSelection, legacyMoveBlocks.execute({ document: legacy, selection: legacySelection }, { parentPath: [0], blockIndexes: [1], direction }));
+    }
+    if (intent === "list.setChecked") {
+        const checklistBase = baseList();
+        const checklistNode = checklistBase.children[0];
+        canonical = { ...checklistBase, children: [{ ...checklistNode, attrs: { ...(checklistNode.attrs || {}), checkable: true } }] };
+        legacy = toLegacy(canonical);
+        legacySelection = { type: "text", anchor: { path: [0, 1, 0, 0], offset: 0 }, focus: { path: [0, 1, 0, 0], offset: 0 } };
+        const initialSelection = { type: "text", anchor: { path: [0, 1, 0], offset: 0 }, head: { path: [0, 1, 0], offset: 0 } };
+        canonicalOperations = setListChecked(canonical, listScope(`list-${suffix}`, [`b-${suffix}`]), { checked: true }, ctx(canonical));
+        canonical = applyOperations(canonical, canonicalOperations);
+        return compare(initialSelection, legacySetChecklistItemChecked.execute({ document: legacy, selection: legacySelection }, { path: [0, 1], checked: true }));
+    }
+    if (intent === "list.unwrap") {
+        canonical = baseList({ style: "decimal" });
+        legacy = toLegacy(canonical);
+        legacySelection = { type: "text", anchor: { path: [0, 0, 0, 0], offset: 0 }, focus: { path: [0, 2, 0, 0], offset: 0 } };
+        const initialSelection = { type: "text", anchor: { path: [0, 0, 0], offset: 0 }, head: { path: [0, 2, 0], offset: 0 } };
+        canonicalOperations = unwrapList(canonical, listScope(`list-${suffix}`, [`a-${suffix}`, `b-${suffix}`, `c-${suffix}`]), {}, ctx(canonical));
+        canonical = applyOperations(canonical, canonicalOperations);
+        return compare(initialSelection, legacyToggleList.execute({ document: legacy, selection: legacySelection }, { style: "decimal" }));
+    }
+    throw new Error(`Unknown named list replay intent: ${intent}`);
+};
+export const runNamedListIntentCorpus = () => [
+    "list.create", "list.setPreset", "list.setStyle", "list.indent", "list.outdent", "list.move", "list.move.reverse", "list.create.numbered", "list.setChecked", "list.unwrap",
+].map(runNamedListIntent);
+const applyLegacy = (document, selection, transaction) => applyLegacyTransaction({ document, selection }, transaction).document;
+/** Executes both the legacy model commands and canonical pure commands. */
+export const runDualEngineListShadowCorpus = (scenarios = 1000, seed = 3500212992) => {
+    const logs = [];
+    const divergences = {};
+    let equivalent = 0;
+    for (let index = 0; index < scenarios; index += 1) {
+        const label = ((seed ^ Math.imul(index + 1, 1103515245)) >>> 0).toString(36);
+        const mode = index % 5;
+        const nested = list(`nested-${label}`, [item(`nested-item-${label}`, `nested-${label}`)]);
+        let canonical = mode === 2
+            ? { type: "doc", id: `doc-${label}`, children: [p(`a-${label}`, `a-${label}`), p(`b-${label}`, `b-${label}`)] }
+            : mode === 1
+                ? { type: "doc", id: `doc-${label}`, children: [list(`list-${label}`, [item(`a-${label}`, `a-${label}`, nested), item(`c-${label}`, `c-${label}`)])] }
+                : { type: "doc", id: `doc-${label}`, children: [list(`list-${label}`, [item(`a-${label}`, `a-${label}`), item(`b-${label}`, `b-${label}`), item(`c-${label}`, `c-${label}`)])] };
+        let legacy = toLegacy(canonical);
+        const beforeCanonical = canonical;
+        if (mode === 0) {
+            const legacySelection = { type: "text", anchor: { path: [0, 1, 0, 0], offset: 0 }, focus: { path: [0, 1, 0, 0], offset: 0 } };
+            legacy = applyLegacy(legacy, legacySelection, legacyIndentListItems.execute({ document: legacy, selection: legacySelection }));
+            canonical = applyOperations(canonical, indentList(canonical, scope(`list-${label}`, [`b-${label}`]), { nestedListIds: [`new-${label}`] }, ctx(canonical)));
+        }
+        else if (mode === 1) {
+            const legacySelection = { type: "text", anchor: { path: [0, 0, 1, 0, 0, 0], offset: 0 }, focus: { path: [0, 0, 1, 0, 0, 0], offset: 0 } };
+            legacy = applyLegacy(legacy, legacySelection, legacyOutdentListItems.execute({ document: legacy, selection: legacySelection }));
+            canonical = applyOperations(canonical, outdentList(canonical, scope(`nested-${label}`, [`nested-item-${label}`], 1), {}, ctx(canonical)));
+        }
+        else if (mode === 2) {
+            const legacySelection = { type: "text", anchor: { path: [0, 0], offset: 0 }, focus: { path: [1, 0], offset: 0 } };
+            legacy = applyLegacy(legacy, legacySelection, legacyToggleList.execute({ document: legacy, selection: legacySelection }, { style: "disc" }));
+            canonical = applyOperations(canonical, createList(canonical, {
+                kind: "block-range", blockIds: [`a-${label}`, `b-${label}`], promotedFromPartial: true, commonParentId: canonical.id,
+                range: { from: { path: [], offset: 0 }, to: { path: [], offset: 2 } }, isolatingAncestorId: null, clamped: false,
+            }, { listIds: [`list-${label}`], itemIds: [`ia-${label}`, `ib-${label}`], style: "disc" }, ctx(canonical)));
+        }
+        else if (mode === 3) {
+            const legacySelection = { type: "text", anchor: { path: [0, 0, 0, 0], offset: 0 }, focus: { path: [0, 2, 0, 0], offset: 0 } };
+            legacy = applyLegacy(legacy, legacySelection, legacyToggleList.execute({ document: legacy, selection: legacySelection }, { style: "decimal" }));
+            canonical = applyOperations(canonical, unwrapList(canonical, scope(`list-${label}`, [`a-${label}`, `b-${label}`, `c-${label}`]), {}, ctx(canonical)));
+        }
+        else {
+            const legacySelection = { type: "text", anchor: { path: [0, 1, 0, 0], offset: 0 }, focus: { path: [0, 1, 0, 0], offset: 0 } };
+            legacy = applyLegacy(legacy, legacySelection, legacyToggleList.execute({ document: legacy, selection: legacySelection }, { style: "upper-roman" }));
+            canonical = applyOperations(canonical, setListStyle(canonical, scope(`list-${label}`, [`b-${label}`]), { style: "upper-roman" }, ctx(canonical)));
+        }
+        const legacyCanonical = fromLegacy(legacy);
+        const first = { path: firstOwner(canonical), offset: 0 };
+        const result = compareShadowDocuments({
+            legacyDocument: legacyCanonical, legacySelection: { type: "text", anchor: first, head: first },
+            canonicalDocument: canonical, canonicalSelection: { type: "text", anchor: first, head: first }, schema: foundationSchema,
+            classification: "semantic",
+        });
+        if (result.equivalent)
+            equivalent += 1;
+        else
+            divergences[result.classification || "unknown"] = (divergences[result.classification || "unknown"] || 0) + 1;
+        logs.push(shadowLogRecord(`dual-${mode}-${index}`, result));
+        void beforeCanonical;
+    }
+    return { seed, scenarios, equivalent, divergences, logs };
+};

package/dist/adapters/pdfFormat.d.ts

@@ -0,0 +1,23 @@
+import type { SmartDocument } from "smartrte-core";
+export declare const PDF_MEDIA_TYPE = "application/pdf";
+export interface PdfTextItemSnapshot {
+    text: string;
+    x: number;
+    y: number;
+    width: number;
+    height: number;
+    fontFamily?: string;
+}
+export interface PdfPageSnapshot {
+    width: number;
+    items: readonly PdfTextItemSnapshot[];
+}
+export interface PdfImportResult {
+    document: SmartDocument;
+    layoutHtml: string;
+    pages: number;
+}
+export declare const reconstructPdfPages: (pages: readonly PdfPageSnapshot[], ownerDocument: Document) => PdfImportResult;
+export declare const importPdfDocument: (arrayBuffer: ArrayBuffer, ownerDocument: Document) => Promise<PdfImportResult>;
+export declare const buildPdfPrintDocument: (document: SmartDocument) => string;
+export declare const printSmartDocumentAsPdf: (document: SmartDocument, hostWindow: Window, delayMs?: number) => boolean;