smartrte-react 0.3.4 → 1.0.0-beta.1

package/dist/adapters/domTableCommandBridge.js

@@ -0,0 +1,231 @@
+import { applyOperations, createNodeId, createScopeIndex, foundationSchema, insertTableColumnCommand, insertTableCommand, insertTableRowCommand, mergeTableCellsCommand, occupancyGridFor, parseCanonicalTableHtml, removeTableColumnCommand, removeTableRowCommand, removeTableCommand, repair, serializeCanonicalTableHtml, setTableCellAttributesCommand, setTableColumnWidthCommand, setTableHeaderCommand, setTableRowHeightCommand, splitTableCellCommand, } from "smartrte-core/foundation";
+const canonicalTable = (element) => {
+    const repaired = repair(parseCanonicalTableHtml(element.outerHTML)).doc;
+    const table = repaired.children[0];
+    return table && table.type === "table" ? { document: repaired, table: table } : null;
+};
+const tableScope = (table, start, end = start) => {
+    const grid = occupancyGridFor(table);
+    const top = Math.max(0, Math.min(start.row, end.row));
+    const bottom = Math.min(grid.rows - 1, Math.max(start.row, end.row));
+    const left = Math.max(0, Math.min(start.column, end.column));
+    const right = Math.min(grid.columns - 1, Math.max(start.column, end.column));
+    const exclusive = { top, left, bottom: bottom + 1, right: right + 1 };
+    return {
+        kind: "table-grid", tableId: table.id, rect: { top, left, bottom, right },
+        cellIds: grid.anchors.filter((cell) => cell.top <= bottom && cell.bottom > top && cell.left <= right && cell.right > left).map((cell) => cell.cellId),
+        coveredCellIds: grid.coveredIn(exclusive).map((cell) => cell.cellId),
+        rectangular: grid.isRectangular(exclusive), range: { from: { path: [0], offset: 0 }, to: { path: [0], offset: 1 } },
+        isolatingAncestorId: null, clamped: false,
+    };
+};
+const commandContext = (document) => ({ schema: foundationSchema, positions: createScopeIndex().positions(document, foundationSchema) });
+const generated = (count, prefix) => Array.from({ length: count }, () => `${prefix}-${createNodeId()}`);
+const domGrid = (table) => {
+    const slots = [];
+    Array.from(table.rows).forEach((row, rowIndex) => {
+        slots[rowIndex] || (slots[rowIndex] = []);
+        let column = 0;
+        Array.from(row.cells).forEach((cell) => {
+            while (slots[rowIndex][column])
+                column += 1;
+            for (let r = rowIndex; r < rowIndex + Math.max(1, cell.rowSpan); r += 1) {
+                slots[r] || (slots[r] = []);
+                for (let c = column; c < column + Math.max(1, cell.colSpan); c += 1)
+                    slots[r][c] = cell;
+            }
+            column += Math.max(1, cell.colSpan);
+        });
+    });
+    return slots;
+};
+const copyVisualAttributes = (from, to) => {
+    if (from.className)
+        to.className = from.className;
+    const retained = from.getAttribute("style");
+    if (retained)
+        for (const declaration of retained.split(";")) {
+            const separator = declaration.indexOf(":");
+            if (separator > 0)
+                to.style.setProperty(declaration.slice(0, separator).trim(), declaration.slice(separator + 1).trim());
+        }
+};
+const projectAttributesInPlace = (element, after) => {
+    const table = after.children[0];
+    const modelGrid = occupancyGridFor(table);
+    const grid = domGrid(element);
+    const widths = Array.isArray(table.attrs?.columnWidths) ? table.attrs.columnWidths : [];
+    if (widths.length) {
+        let group = element.querySelector(":scope > colgroup");
+        if (!group) {
+            group = element.ownerDocument.createElement("colgroup");
+            element.prepend(group);
+        }
+        while (group.children.length < widths.length)
+            group.appendChild(element.ownerDocument.createElement("col"));
+        while (group.children.length > widths.length)
+            group.lastElementChild?.remove();
+        widths.forEach((width, index) => { group.children[index].style.width = `${width}px`; });
+    }
+    (table.children || []).forEach((row, rowIndex) => {
+        if (row.type !== "table_row")
+            return;
+        const height = Number(row.attrs?.height);
+        if (Number.isFinite(height) && height > 0)
+            element.rows[rowIndex].style.height = `${height}px`;
+    });
+    modelGrid.anchors.forEach((cell) => {
+        const target = grid[cell.top]?.[cell.left];
+        if (!target)
+            return;
+        target.style.background = cell.node.attrs?.background ? String(cell.node.attrs.background) : "";
+        target.style.color = cell.node.attrs?.textColor ? String(cell.node.attrs.textColor) : "";
+        target.style.border = cell.node.attrs?.borders ? String(cell.node.attrs.borders) : "";
+        target.style.verticalAlign = cell.node.attrs?.verticalAlign ? String(cell.node.attrs.verticalAlign) : "";
+        if (widths.length) {
+            const width = widths.slice(cell.left, cell.right).reduce((sum, value) => sum + value, 0);
+            target.style.width = `${width}px`;
+            target.style.minWidth = `${width}px`;
+            target.style.maxWidth = `${width}px`;
+        }
+        const rowHeight = Number(table.children?.[cell.top]?.attrs?.height);
+        if (Number.isFinite(rowHeight) && rowHeight > 0)
+            target.style.height = `${rowHeight}px`;
+    });
+    return element;
+};
+const replaceDomTable = (table, document) => {
+    const container = table.ownerDocument.createElement("div");
+    container.innerHTML = serializeCanonicalTableHtml(document, { fragment: true });
+    const replacement = container.querySelector("table");
+    if (!(replacement instanceof HTMLTableElement))
+        return null;
+    copyVisualAttributes(table, replacement);
+    const beforeGrid = domGrid(table);
+    const afterGrid = domGrid(replacement);
+    const copied = new Set();
+    afterGrid.forEach((row, rowIndex) => row.forEach((cell, column) => {
+        if (!cell || copied.has(cell))
+            return;
+        const source = beforeGrid[rowIndex]?.[column];
+        if (source)
+            copyVisualAttributes(source, cell);
+        if (cell.tagName === "TH" && source?.tagName !== "TH") {
+            cell.style.fontWeight = "700";
+            cell.style.background = cell.style.background || "#f3f4f6";
+            cell.style.textAlign = cell.style.textAlign || "left";
+        }
+        else if (cell.tagName === "TD" && source?.tagName === "TH") {
+            if (["700", "bold"].includes(cell.style.fontWeight))
+                cell.style.fontWeight = "";
+            if (["rgb(243, 244, 246)", "#f3f4f6"].includes(cell.style.background))
+                cell.style.background = "";
+            if (cell.style.textAlign === "left")
+                cell.style.textAlign = "";
+        }
+        copied.add(cell);
+    }));
+    table.replaceWith(replacement);
+    return replacement;
+};
+export const executeDomTableCommand = (element, command) => {
+    if (command.id === "table.remove")
+        return null;
+    const parsed = canonicalTable(element);
+    if (!parsed)
+        return null;
+    const { document, table } = parsed;
+    const grid = occupancyGridFor(table);
+    const start = "start" in command.input ? command.input.start : "row" in command.input ? command.input : { row: "index" in command.input ? command.input.index : 0, column: 0 };
+    const end = "end" in command.input && command.input.end ? command.input.end : start;
+    const scope = tableScope(table, start, end);
+    const ctx = commandContext(document);
+    let operations = [];
+    if (command.id === "table.row.add")
+        operations = insertTableRowCommand(document, scope, {
+            rowIndex: command.input.index, rowId: `row-${createNodeId()}`,
+            cellIds: generated(grid.columns, "cell"), paragraphIds: generated(grid.columns, "paragraph"),
+        }, ctx);
+    else if (command.id === "table.row.remove")
+        operations = removeTableRowCommand(document, scope, { rowIndex: command.input.index }, ctx);
+    else if (command.id === "table.column.add")
+        operations = insertTableColumnCommand(document, scope, {
+            columnIndex: command.input.index, cellIds: generated(grid.rows, "cell"), paragraphIds: generated(grid.rows, "paragraph"),
+        }, ctx);
+    else if (command.id === "table.column.remove")
+        operations = removeTableColumnCommand(document, scope, { columnIndex: command.input.index }, ctx);
+    else if (command.id === "table.cell.merge")
+        operations = mergeTableCellsCommand(document, scope, {}, ctx);
+    else if (command.id === "table.cell.split") {
+        const target = grid.at(command.input.row, command.input.column);
+        const count = target ? (target.bottom - target.top) * (target.right - target.left) - 1 : 0;
+        operations = splitTableCellCommand(document, scope, { cellIds: generated(count, "cell"), paragraphIds: generated(count, "paragraph") }, ctx);
+    }
+    else if (command.id.startsWith("table.header.")) {
+        const point = command.input;
+        const targetCells = command.id === "table.header.cell.toggle" ? [grid.at(point.row, point.column)].filter(Boolean)
+            : command.id === "table.header.row.toggle" ? grid.anchors.filter((cell) => cell.top <= point.row && cell.bottom > point.row)
+                : grid.anchors.filter((cell) => cell.left <= point.column && cell.right > point.column);
+        const makeHeader = targetCells.some((cell) => cell?.node.attrs?.header !== true);
+        if (command.id === "table.header.cell.toggle" && point.row > 0 && point.column > 0)
+            return null;
+        const headerScope = { ...scope, cellIds: targetCells.map((cell) => cell.cellId) };
+        operations = command.id === "table.header.cell.toggle"
+            ? setTableCellAttributesCommand(document, headerScope, { attrs: { header: makeHeader } }, ctx)
+            : setTableHeaderCommand(document, scope, { target: makeHeader ? command.id === "table.header.row.toggle" ? "row" : "column" : "none" }, ctx);
+    }
+    else if (command.id === "table.cell.style.set")
+        operations = setTableCellAttributesCommand(document, scope, { attrs: {
+                ...(command.input.backgroundColor !== undefined ? { background: command.input.backgroundColor || undefined } : {}),
+                ...(command.input.textColor !== undefined ? { textColor: command.input.textColor || undefined } : {}),
+            } }, ctx);
+    else if (command.id === "table.cell.border.toggle") {
+        const visible = scope.cellIds.some((id) => grid.anchors.find((cell) => cell.cellId === id)?.node.attrs?.borders && grid.anchors.find((cell) => cell.cellId === id)?.node.attrs?.borders !== "none");
+        operations = setTableCellAttributesCommand(document, scope, { attrs: { borders: visible ? "none" : command.input.visibleBorder || "1px solid #d1d5db" } }, ctx);
+    }
+    else if (command.id === "table.column.width.set")
+        operations = setTableColumnWidthCommand(document, scope, { index: command.input.index, width: command.input.widthPx }, ctx);
+    else if (command.id === "table.row.height.set")
+        operations = setTableRowHeightCommand(document, scope, { index: command.input.index, height: command.input.heightPx }, ctx);
+    if (!operations.length)
+        return null;
+    const after = applyOperations(document, operations);
+    if (["table.cell.style.set", "table.cell.border.toggle", "table.column.width.set", "table.row.height.set"].includes(command.id)) {
+        return projectAttributesInPlace(element, after);
+    }
+    return replaceDomTable(element, after);
+};
+export const executeDomTableRemoval = (element) => {
+    const parsed = canonicalTable(element);
+    if (!parsed)
+        return false;
+    const scope = tableScope(parsed.table, { row: 0, column: 0 });
+    if (!removeTableCommand(parsed.document, scope, {}, commandContext(parsed.document)).length)
+        return false;
+    element.remove();
+    return true;
+};
+export const executeDomTableInsert = (root, afterBlockIndex, rows, columns, withHeader = false) => {
+    if (rows < 1 || columns < 1)
+        return null;
+    const document = repair(parseCanonicalTableHtml(root.innerHTML)).doc;
+    const index = Math.max(0, Math.min(afterBlockIndex, document.children.length - 1));
+    const target = document.children[index];
+    if (!target || !("id" in target))
+        return null;
+    const blockScope = {
+        kind: "block-range", blockIds: [target.id], promotedFromPartial: false,
+        commonParentId: document.id, range: { from: { path: [], offset: index }, to: { path: [], offset: index + 1 } },
+        isolatingAncestorId: null, clamped: false,
+    };
+    const total = rows * columns;
+    const tableId = `table-${createNodeId()}`;
+    const operations = insertTableCommand(document, blockScope, {
+        rows, columns, withHeader, placement: "after",
+        ids: { tableId, rowIds: generated(rows, "row"), cellIds: generated(total, "cell"), paragraphIds: generated(total, "paragraph") },
+    }, commandContext(document));
+    if (!operations.length)
+        return null;
+    root.innerHTML = serializeCanonicalTableHtml(applyOperations(document, operations), { fragment: true });
+    return root.querySelector(`table[data-smart-id="${tableId}"]`);
+};

package/dist/adapters/internalFlags.d.ts

@@ -1,13 +1,5 @@
-import type { CoreInlineMark } from "./inlineMarkCoreExecution.js";
 export interface SmartRteInternalFlags {
-    coreBold?: boolean;
-    coreItalic?: boolean;
-    coreUnderline?: boolean;
-    coreSuperscript?: boolean;
-    coreSubscript?: boolean;
-    coreInlineMarks?: boolean;
     shadowMode?: boolean;
 }
 export declare const getSmartRteInternalFlags: () => SmartRteInternalFlags;
-export declare const isCoreInlineMarkFlagEnabled: (mark: CoreInlineMark) => boolean;
 export declare const isShadowModeFlagEnabled: () => boolean;

package/dist/adapters/internalFlags.js

@@ -1,30 +1,6 @@
-const markFlagNames = {
-    bold: "coreBold",
-    italic: "coreItalic",
-    underline: "coreUnderline",
-    superscript: "coreSuperscript",
-    subscript: "coreSubscript",
-};
-const legacyMarkFlagNames = {
-    bold: "__SMART_RTE_CORE_BOLD__",
-    italic: "__SMART_RTE_CORE_ITALIC__",
-    underline: "__SMART_RTE_CORE_UNDERLINE__",
-    superscript: "__SMART_RTE_CORE_SUPERSCRIPT__",
-    subscript: "__SMART_RTE_CORE_SUBSCRIPT__",
-};
 const getGlobal = () => globalThis;
 const readBoolean = (value) => typeof value === "boolean" ? value : undefined;
 export const getSmartRteInternalFlags = () => getGlobal().__SMART_RTE_INTERNAL_FLAGS__ || {};
-export const isCoreInlineMarkFlagEnabled = (mark) => {
-    const flags = getSmartRteInternalFlags();
-    const individual = readBoolean(flags[markFlagNames[mark]]);
-    if (individual !== undefined)
-        return individual;
-    const grouped = readBoolean(flags.coreInlineMarks);
-    if (grouped !== undefined)
-        return grouped;
-    return getGlobal()[legacyMarkFlagNames[mark]] === true;
-};
 export const isShadowModeFlagEnabled = () => {
     const configured = readBoolean(getSmartRteInternalFlags().shadowMode);
     if (configured !== undefined)

package/dist/adapters/legacyListShadowComparator.d.ts

@@ -0,0 +1,26 @@
+import { shadowLogRecord } from "smartrte-core/foundation";
+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/foundation";
+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/pdfPrint.d.ts

@@ -0,0 +1,8 @@
+import type { SmartDocument } from "smartrte-core/foundation";
+/**
+ * The only genuinely browser-specific piece of PDF export: opening a print
+ * window is a windowing operation, not format logic, so it stays here
+ * rather than in packages/core. buildPdfPrintDocument (the actual HTML
+ * content) is framework-agnostic and lives in core.
+ */
+export declare const printSmartDocumentAsPdf: (document: SmartDocument, hostWindow: Window, delayMs?: number) => boolean;

package/dist/adapters/pdfPrint.js

@@ -0,0 +1,22 @@
+import { buildPdfPrintDocument } from "smartrte-core/foundation";
+/**
+ * The only genuinely browser-specific piece of PDF export: opening a print
+ * window is a windowing operation, not format logic, so it stays here
+ * rather than in packages/core. buildPdfPrintDocument (the actual HTML
+ * content) is framework-agnostic and lives in core.
+ */
+export const printSmartDocumentAsPdf = (document, hostWindow, delayMs = 150) => {
+    const printWindow = hostWindow.open("", "_blank", "width=900,height=700");
+    if (!printWindow)
+        return false;
+    printWindow.addEventListener("load", () => {
+        printWindow.setTimeout(() => {
+            printWindow.focus();
+            printWindow.print();
+        }, delayMs);
+    }, { once: true });
+    printWindow.document.open();
+    printWindow.document.write(buildPdfPrintDocument(document));
+    printWindow.document.close();
+    return true;
+};