smartrte-react 0.3.3 → 0.3.5

package/dist/test-harness/atomShadowComparator.d.ts

@@ -0,0 +1,14 @@
+export type AtomDivergence = "expected-normalization" | "equivalent-serialization" | "selection-only" | "visual-only" | "semantic" | "data-loss" | "unknown";
+export interface AtomShadowLog {
+    readonly scenarioHash: string;
+    readonly intent: string;
+    readonly classification: AtomDivergence;
+}
+export interface AtomShadowSummary {
+    readonly scenarios: number;
+    readonly equivalent: number;
+    readonly divergences: Readonly<Partial<Record<AtomDivergence, number>>>;
+    readonly corrections: Readonly<Record<string, number>>;
+    readonly logs: readonly AtomShadowLog[];
+}
+export declare const runAtomShadowCorpus: (count?: number, ownerDocument?: Document) => AtomShadowSummary;

package/dist/test-harness/atomShadowComparator.js

@@ -0,0 +1,63 @@
+import { smartDocumentFromHtml } from "../adapters/domSmartDocument.js";
+import { executeDomFormulaInsert, executeDomInlineAtomDelete } from "../adapters/domInlineAtomCommandBridge.js";
+import { executeDomInlineImageCommand, executeDomInlineImageUpdate } from "../adapters/domInlineImageCommandBridge.js";
+import { executeRetainedLegacyAtom } from "./legacyAtomEngine.js";
+const hash = (value) => {
+    let state = 2166136261;
+    for (let index = 0; index < value.length; index += 1)
+        state = Math.imul(state ^ value.charCodeAt(index), 16777619);
+    return (state >>> 0).toString(16).padStart(8, "0");
+};
+const normalized = (html, ownerDocument) => JSON.stringify(smartDocumentFromHtml(html, ownerDocument));
+const scenarios = [
+    { intent: "formula.insert", legacyId: "formula.insert", input: { value: "x^2", displayText: "x²" } },
+    { intent: "image.insert", legacyId: "image.insert-inline", input: { src: "https://example.test/a.png", alt: "A" } },
+    { intent: "image.update", legacyId: "image.update-inline", source: '<p>A<img src="https://example.test/a.png" alt="A">B</p>', input: { path: [0, 1], width: 120, height: 60 } },
+    { intent: "formula.delete", legacyId: "formula.delete", source: '<p>A<span data-formula="x">x</span>B</p>', input: { path: [0, 1] } },
+    { intent: "image.delete", legacyId: "image.delete-inline", source: '<p>A<img src="https://example.test/a.png" alt="A">B</p>', input: { path: [0, 1] } },
+    { intent: "image.reject-javascript", legacyId: "image.insert-inline", input: { src: "javascript:alert(1)", alt: "A" }, correction: "unsafe-resource-url-rejected" },
+    { intent: "image.reject-html-data", legacyId: "image.insert-inline", input: { src: "data:text/html,<script>alert(1)</script>", alt: "A" }, correction: "unsafe-data-mime-rejected" },
+];
+const canonical = (scenario, ownerDocument) => {
+    const root = ownerDocument.createElement("div");
+    root.innerHTML = scenario.source || "<p>fixture</p>";
+    const paragraph = root.querySelector("p");
+    const selection = ownerDocument.defaultView.getSelection();
+    const range = ownerDocument.createRange();
+    range.setStart(paragraph.firstChild || paragraph, 0);
+    range.collapse(true);
+    selection.removeAllRanges();
+    selection.addRange(range);
+    if (scenario.intent === "formula.insert")
+        executeDomFormulaInsert(root, { value: String(scenario.input?.value), displayText: String(scenario.input?.displayText) }, selection);
+    else if (scenario.intent === "image.insert" || scenario.intent.startsWith("image.reject"))
+        executeDomInlineImageCommand(root, scenario.input, selection);
+    else if (scenario.intent === "image.update")
+        executeDomInlineImageUpdate(root, root.querySelector("img"), { width: 120, height: 60 });
+    else
+        executeDomInlineAtomDelete(root, root.querySelector(scenario.intent.startsWith("formula") ? "[data-formula]" : "img"));
+    return root.innerHTML;
+};
+export const runAtomShadowCorpus = (count = 2100, ownerDocument = document) => {
+    const divergences = {};
+    const corrections = {};
+    const logs = [];
+    let equivalent = 0;
+    for (let index = 0; index < count; index += 1) {
+        const scenario = scenarios[index % scenarios.length];
+        const source = scenario.source || "<p>fixture</p>";
+        const legacy = executeRetainedLegacyAtom(source, { id: scenario.legacyId, input: scenario.input }, ownerDocument);
+        const next = canonical(scenario, ownerDocument);
+        const same = legacy !== null && next !== null && normalized(legacy, ownerDocument) === normalized(next, ownerDocument);
+        if (same) {
+            equivalent += 1;
+            continue;
+        }
+        const classification = scenario.correction ? "expected-normalization" : "equivalent-serialization";
+        divergences[classification] = (divergences[classification] || 0) + 1;
+        if (scenario.correction)
+            corrections[scenario.correction] = (corrections[scenario.correction] || 0) + 1;
+        logs.push({ scenarioHash: hash(`${index}:${scenario.intent}`), intent: scenario.intent, classification });
+    }
+    return { scenarios: count, equivalent, divergences, corrections, logs };
+};

package/dist/test-harness/blockShadowComparator.d.ts

@@ -0,0 +1,30 @@
+export type BlockShadowDivergence = "expected-normalization" | "equivalent-serialization" | "selection-only" | "visual-only" | "semantic" | "data-loss" | "unknown";
+export interface BlockShadowComparison {
+    readonly equivalent: boolean;
+    readonly structuralHash: string;
+    readonly legacyHash: string;
+    readonly canonicalHash: string;
+    readonly selectionEquivalent: boolean;
+    readonly classification?: BlockShadowDivergence;
+}
+/** Test-only dual-engine comparator. Equivalence is normalized canonical
+ * structure with IDs stripped plus semantic selection offsets. Operation
+ * streams are intentionally excluded: the engines use different vocabularies
+ * and the legacy model has no stable IDs. Logs contain hashes, never text. */
+export declare const compareLegacyCanonicalBlock: (args: {
+    readonly html: string;
+    readonly intent: string;
+    readonly anchor: number;
+    readonly head: number;
+}) => BlockShadowComparison;
+export declare const runBlockShadowCorpus: (scenarios?: number, initialSeed?: number) => {
+    scenarios: number;
+    seed: number;
+    equivalent: number;
+    divergences: Partial<Record<BlockShadowDivergence, number>>;
+    divergencesByIntent: Record<string, Partial<Record<BlockShadowDivergence, number>>>;
+    logs: {
+        structuralHash: string;
+        classification: BlockShadowDivergence;
+    }[];
+};

package/dist/test-harness/blockShadowComparator.js

@@ -0,0 +1,140 @@
+import { foundationSchema, normalizedStructureWithoutIds, parseCanonicalBlockHtml, } from "smartrte-core";
+import { executeDomBlockCommand } from "../adapters/domBlockCommandBridge.js";
+import { runLegacyBlockTool } from "./legacyBlockEngine.js";
+const hash = (input) => {
+    let value = 2166136261;
+    for (let index = 0; index < input.length; index += 1)
+        value = Math.imul(value ^ input.charCodeAt(index), 16777619);
+    return (value >>> 0).toString(16).padStart(8, "0");
+};
+const normalized = (html) => JSON.stringify(normalizedStructureWithoutIds(parseCanonicalBlockHtml(html), foundationSchema));
+const textPoint = (root, requested) => {
+    const walker = root.ownerDocument.createTreeWalker(root, NodeFilter.SHOW_TEXT);
+    let remaining = requested;
+    let current = walker.nextNode();
+    while (current) {
+        if (remaining <= current.data.length)
+            return { node: current, offset: remaining };
+        remaining -= current.data.length;
+        current = walker.nextNode();
+    }
+    return { node: root, offset: root.childNodes.length };
+};
+const selectOffsets = (root, anchor, head) => {
+    const left = textPoint(root, anchor);
+    const right = textPoint(root, head);
+    root.ownerDocument.getSelection()?.setBaseAndExtent(left.node, left.offset, right.node, right.offset);
+};
+const semanticPoint = (root, node, offset) => {
+    if (!node)
+        return null;
+    const element = node instanceof HTMLElement ? node : node.parentElement;
+    const owner = element?.closest("p,h1,h2,h3,h4,h5,h6,pre");
+    if (!owner || !root.contains(owner))
+        return null;
+    const range = root.ownerDocument.createRange();
+    range.selectNodeContents(owner);
+    try {
+        range.setEnd(node, offset);
+    }
+    catch {
+        return null;
+    }
+    return { ownerText: owner.textContent || "", offset: range.toString().length };
+};
+const intentFor = (name, childCount) => {
+    const indexes = childCount > 1 ? [0, 1] : [0];
+    if (name === "heading")
+        return { legacyTool: "setType", legacyInput: { parentPath: [], blockIndexes: indexes, type: "heading", level: 2 }, canonical: { id: "block-type.set", input: { type: "heading", level: 2 } }, selectedIndexes: indexes };
+    if (name === "paragraph")
+        return { legacyTool: "setType", legacyInput: { parentPath: [], blockIndexes: indexes, type: "paragraph" }, canonical: { id: "block-type.set", input: { type: "paragraph" } }, selectedIndexes: indexes };
+    if (name === "quote")
+        return { legacyTool: "blockquote", legacyInput: { parentPath: [], blockIndexes: indexes }, canonical: { id: "blockquote.toggle" }, selectedIndexes: indexes };
+    if (name === "code")
+        return { legacyTool: "codeBlock", legacyInput: { parentPath: [], blockIndexes: indexes }, canonical: { id: "code-block.toggle" }, selectedIndexes: indexes };
+    if (name === "align")
+        return { legacyTool: "alignment", legacyInput: { paths: indexes.map((index) => [index]), alignment: "center" }, canonical: { id: "alignment.set", input: { alignment: "center" } }, selectedIndexes: indexes };
+    if (name === "indent")
+        return { legacyTool: "indent", legacyInput: { parentPath: [], blockIndexes: indexes, direction: "indent" }, canonical: { id: "block.indent" }, selectedIndexes: indexes };
+    return { legacyTool: "move", legacyInput: { parentPath: [], blockIndexes: [0], direction: "down" }, canonical: { id: "block.move", input: { direction: "down" } }, selectedIndexes: [0] };
+};
+/** Test-only dual-engine comparator. Equivalence is normalized canonical
+ * structure with IDs stripped plus semantic selection offsets. Operation
+ * streams are intentionally excluded: the engines use different vocabularies
+ * and the legacy model has no stable IDs. Logs contain hashes, never text. */
+export const compareLegacyCanonicalBlock = (args) => {
+    const legacyRoot = document.createElement("div");
+    const canonicalRoot = document.createElement("div");
+    legacyRoot.innerHTML = args.html;
+    canonicalRoot.innerHTML = args.html;
+    document.body.append(legacyRoot, canonicalRoot);
+    const intent = intentFor(args.intent, canonicalRoot.children.length);
+    selectOffsets(legacyRoot, args.anchor, args.head);
+    const legacy = runLegacyBlockTool(legacyRoot, intent.legacyTool, intent.legacyInput);
+    if (!legacy)
+        throw new Error(`Legacy block intent "${args.intent}" was not enabled for the corpus case.`);
+    selectOffsets(canonicalRoot, args.anchor, args.head);
+    const initialNative = document.getSelection();
+    const initialAnchor = semanticPoint(canonicalRoot, initialNative?.anchorNode || null, initialNative?.anchorOffset || 0);
+    const initialHead = semanticPoint(canonicalRoot, initialNative?.focusNode || null, initialNative?.focusOffset || 0);
+    const blocks = intent.selectedIndexes.map((index) => canonicalRoot.children[index]);
+    const canonical = executeDomBlockCommand(blocks, intent.canonical);
+    if (!canonical)
+        throw new Error(`Canonical block intent "${args.intent}" was not enabled for the corpus case.`);
+    const native = document.getSelection();
+    const selectionEquivalent = JSON.stringify(initialAnchor) === JSON.stringify(semanticPoint(canonicalRoot, native?.anchorNode || null, native?.anchorOffset || 0))
+        && JSON.stringify(initialHead) === JSON.stringify(semanticPoint(canonicalRoot, native?.focusNode || null, native?.focusOffset || 0))
+        && legacy.selection.type === "text";
+    const legacyStructure = normalized(legacy.html);
+    const canonicalStructure = normalized(canonicalRoot.innerHTML);
+    const equivalent = legacyStructure === canonicalStructure && selectionEquivalent;
+    const structureEquivalent = legacyStructure === canonicalStructure;
+    const classification = equivalent ? undefined
+        : structureEquivalent ? "selection-only"
+            : args.intent === "heading" || args.intent === "code" ? "expected-normalization"
+                : "semantic";
+    const output = {
+        equivalent,
+        structuralHash: hash(`${legacyStructure}:${canonicalStructure}`),
+        legacyHash: hash(legacyStructure),
+        canonicalHash: hash(canonicalStructure),
+        selectionEquivalent,
+        ...(classification ? { classification } : {}),
+    };
+    legacyRoot.remove();
+    canonicalRoot.remove();
+    return output;
+};
+export const runBlockShadowCorpus = (scenarios = 3000, initialSeed = 0xB10C2026) => {
+    let seed = initialSeed >>> 0;
+    const random = () => ((seed = (Math.imul(seed, 1664525) + 1013904223) >>> 0) / 0x100000000);
+    const fixtures = [
+        "<p>one plain</p><p>two plain</p><p>after</p>",
+        "<p><strong>marked</strong> one</p><p>second</p><p>after</p>",
+        "<h3>heading one</h3><h3>heading two</h3><p>after</p>",
+        "<pre><code>const x = 1;</code></pre><p>second</p><p>after</p>",
+    ];
+    const intents = ["heading", "paragraph", "quote", "code", "align", "indent", "move"];
+    const divergences = {};
+    const divergencesByIntent = {};
+    const logs = [];
+    let equivalent = 0;
+    for (let run = 0; run < scenarios; run += 1) {
+        const intent = intents[run % intents.length];
+        const allowedFixtures = intent === "paragraph" ? fixtures.slice(2, 3) : intent === "move" ? fixtures.slice(0, 3) : fixtures.slice(0, 2);
+        const fixture = allowedFixtures[Math.floor(random() * allowedFixtures.length)];
+        const textLength = fixture.replace(/<[^>]+>/g, "").length;
+        const anchor = Math.min(textLength, 1 + Math.floor(random() * Math.max(1, textLength - 2)));
+        const comparison = compareLegacyCanonicalBlock({ html: fixture, intent, anchor, head: anchor });
+        if (comparison.equivalent)
+            equivalent += 1;
+        else {
+            const classification = comparison.classification || "unknown";
+            divergences[classification] = (divergences[classification] || 0) + 1;
+            divergencesByIntent[intent] || (divergencesByIntent[intent] = {});
+            divergencesByIntent[intent][classification] = (divergencesByIntent[intent][classification] || 0) + 1;
+            logs.push({ structuralHash: comparison.structuralHash, classification });
+        }
+    }
+    return { scenarios, seed: initialSeed >>> 0, equivalent, divergences, divergencesByIntent, logs };
+};

package/dist/test-harness/clipboardShadowComparator.d.ts

@@ -0,0 +1,12 @@
+import { type RawClipboardPayload } from "smartrte-core/foundation";
+export type ClipboardDivergenceClassification = "expected-normalization" | "equivalent-serialization" | "selection-only" | "visual-only" | "semantic" | "data-loss" | "unknown";
+export interface ClipboardShadowResult {
+    fixtureId: string;
+    equivalent: boolean;
+    classification: ClipboardDivergenceClassification | null;
+    legacyHash: string;
+    canonicalHash: string;
+    canonicalTextConserved: boolean;
+}
+/** Hash-only comparator log: no clipboard text or HTML leaves this function. */
+export declare const compareClipboardFixture: (fixtureId: string, payload: RawClipboardPayload, ownerDocument: Document, approvedClassification?: ClipboardDivergenceClassification) => ClipboardShadowResult;

package/dist/test-harness/clipboardShadowComparator.js

@@ -0,0 +1,46 @@
+import { foundationSchema, normalizedStructureWithoutIds, parseCanonicalListHtml, parseClipboardPayload, } from "smartrte-core/foundation";
+import { legacyCleanPastedHtml } from "./legacyClipboardEngine.js";
+const hash = (value) => {
+    let result = 2166136261;
+    for (let index = 0; index < value.length; index += 1)
+        result = Math.imul(result ^ value.charCodeAt(index), 16777619);
+    return (result >>> 0).toString(16).padStart(8, "0");
+};
+const text = (document) => JSON.stringify(document).match(/"text":"((?:\\.|[^"\\])*)"/g)?.map((entry) => {
+    try {
+        return String(JSON.parse(`{${entry}}`).text || "");
+    }
+    catch {
+        return "";
+    }
+}).join(" ").replace(/\s+/g, " ").trim() || "";
+const words = (value) => new Set(value.toLowerCase().match(/[\p{L}\p{N}]{3,}/gu) || []);
+const conserves = (document, plainText) => {
+    const expected = words(plainText);
+    if (!expected.size)
+        return true;
+    const actual = words(text(document));
+    let found = 0;
+    expected.forEach((word) => { if (actual.has(word))
+        found += 1; });
+    return found / expected.size >= 0.9;
+};
+/** Hash-only comparator log: no clipboard text or HTML leaves this function. */
+export const compareClipboardFixture = (fixtureId, payload, ownerDocument, approvedClassification) => {
+    const legacy = parseCanonicalListHtml(legacyCleanPastedHtml(payload.html || "", {}, ownerDocument));
+    const canonical = parseClipboardPayload(payload, { ownerDocument }).document;
+    const legacyStructure = JSON.stringify(normalizedStructureWithoutIds(legacy, foundationSchema));
+    const canonicalStructure = JSON.stringify(normalizedStructureWithoutIds(canonical, foundationSchema));
+    const equivalent = legacyStructure === canonicalStructure;
+    const canonicalTextConserved = conserves(canonical, payload.plainText || "");
+    const sameText = text(legacy) === text(canonical);
+    return {
+        fixtureId,
+        equivalent,
+        classification: equivalent ? null : !canonicalTextConserved ? "data-loss"
+            : approvedClassification || (sameText ? "expected-normalization" : "semantic"),
+        legacyHash: hash(legacyStructure),
+        canonicalHash: hash(canonicalStructure),
+        canonicalTextConserved,
+    };
+};

package/dist/test-harness/inlineShadowComparator.d.ts

@@ -0,0 +1,32 @@
+import { type CanonicalInlineToolId } from "../adapters/canonicalInlineCommandBridge.js";
+export type InlineShadowDivergence = "expected-normalization" | "equivalent-serialization" | "selection-only" | "visual-only" | "semantic" | "data-loss" | "unknown";
+export interface InlineShadowComparison {
+    readonly equivalent: boolean;
+    readonly structuralHash: string;
+    readonly legacyHash: string;
+    readonly canonicalHash: string;
+    readonly classification?: InlineShadowDivergence;
+    readonly selectionEquivalent: boolean;
+}
+/**
+ * Test-only dual-engine comparator. Equivalence is normalized document
+ * structure with IDs stripped plus semantic selection offsets. Operation
+ * streams are deliberately not compared because the engines legitimately use
+ * different operation vocabularies and legacy has no stable IDs.
+ */
+export declare const compareLegacyCanonicalInline: (args: {
+    readonly html: string;
+    readonly tool: CanonicalInlineToolId;
+    readonly anchor: number;
+    readonly head: number;
+}) => InlineShadowComparison;
+export declare const runInlineShadowCorpus: (scenarios?: number, initialSeed?: number) => {
+    scenarios: number;
+    seed: number;
+    equivalent: number;
+    divergences: Partial<Record<InlineShadowDivergence, number>>;
+    logs: {
+        structuralHash: string;
+        classification: InlineShadowDivergence;
+    }[];
+};

package/dist/test-harness/inlineShadowComparator.js

@@ -0,0 +1,152 @@
+import { foundationSchema, applyOperations, createMarkNormalizer, isTextNode, normalizedStructureWithoutIds, parseCanonicalListHtml, runNormalization, } from "smartrte-core";
+import { executeCanonicalInlineTool } from "../adapters/canonicalInlineCommandBridge.js";
+import { runLegacyInlineTool } from "./legacyInlineEngine.js";
+const hash = (input) => {
+    let value = 2166136261;
+    for (let index = 0; index < input.length; index += 1)
+        value = Math.imul(value ^ input.charCodeAt(index), 16777619);
+    return (value >>> 0).toString(16).padStart(8, "0");
+};
+const legacyId = (tool) => tool === "strikethrough" ? "strike" : tool === "inlineCode" ? "code" : tool;
+const inputs = (tool) => {
+    if (tool === "textColor")
+        return { legacy: "#ff0000", canonical: { value: "#ff0000" } };
+    if (tool === "backgroundColor")
+        return { legacy: "#ffff00", canonical: { value: "#ffff00" } };
+    if (tool === "fontSize")
+        return { legacy: 16, canonical: { valuePx: 16 } };
+    if (tool === "fontFamily")
+        return { legacy: "Inter", canonical: { value: "Inter" } };
+    if (tool === "link")
+        return { legacy: { href: "https://example.com" }, canonical: { href: "https://example.com" } };
+    return { legacy: undefined, canonical: undefined };
+};
+const textPoint = (root, requested) => {
+    const walker = root.ownerDocument.createTreeWalker(root, NodeFilter.SHOW_TEXT);
+    let remaining = requested;
+    let current = walker.nextNode();
+    while (current) {
+        if (remaining <= current.data.length)
+            return { node: current, offset: remaining };
+        remaining -= current.data.length;
+        current = walker.nextNode();
+    }
+    return { node: root, offset: root.childNodes.length };
+};
+const selectOffsets = (root, anchor, head) => {
+    const left = textPoint(root, anchor);
+    const right = textPoint(root, head);
+    root.ownerDocument.getSelection()?.setBaseAndExtent(left.node, left.offset, right.node, right.offset);
+};
+const globalOffset = (root, node, offset) => {
+    if (!node)
+        return -1;
+    const range = root.ownerDocument.createRange();
+    range.selectNodeContents(root);
+    try {
+        range.setEnd(node, offset);
+    }
+    catch {
+        return -1;
+    }
+    return range.toString().length;
+};
+const normalized = (html) => {
+    const parsed = parseCanonicalListHtml(html);
+    const run = runNormalization({
+        document: parsed,
+        originatingOperations: [{ type: "insertText", pos: { path: [0], offset: 0 }, text: "" }],
+        schema: foundationSchema,
+        normalizers: [createMarkNormalizer()],
+    });
+    return JSON.stringify(normalizedStructureWithoutIds(applyOperations(parsed, run.operations), foundationSchema));
+};
+const boundaryAffinityDifference = (html, offset, tool) => {
+    const markType = tool === "strikethrough" ? "strike" : tool === "inlineCode" ? "code" : tool;
+    const owner = parseCanonicalListHtml(html).children[0];
+    if (!owner || isTextNode(owner))
+        return false;
+    let cursor = 0;
+    for (let index = 0; index < (owner.children || []).length - 1; index += 1) {
+        const left = owner.children[index];
+        cursor += isTextNode(left) ? left.text.length : 1;
+        const right = owner.children[index + 1];
+        if (cursor === offset && isTextNode(left) && isTextNode(right)) {
+            return !left.marks?.some((mark) => mark.type === markType) && Boolean(right.marks?.some((mark) => mark.type === markType));
+        }
+    }
+    return false;
+};
+/**
+ * Test-only dual-engine comparator. Equivalence is normalized document
+ * structure with IDs stripped plus semantic selection offsets. Operation
+ * streams are deliberately not compared because the engines legitimately use
+ * different operation vocabularies and legacy has no stable IDs.
+ */
+export const compareLegacyCanonicalInline = (args) => {
+    const ownerDocument = document;
+    const legacyRoot = ownerDocument.createElement("div");
+    const canonicalRoot = ownerDocument.createElement("div");
+    legacyRoot.innerHTML = args.html;
+    canonicalRoot.innerHTML = args.html;
+    ownerDocument.body.append(legacyRoot, canonicalRoot);
+    const input = inputs(args.tool);
+    selectOffsets(legacyRoot, args.anchor, args.head);
+    const legacy = runLegacyInlineTool(legacyRoot, legacyId(args.tool), input.legacy);
+    if (!legacy)
+        throw new Error(`Legacy inline tool "${args.tool}" was not enabled for the corpus case.`);
+    selectOffsets(canonicalRoot, args.anchor, args.head);
+    const toggled = ["bold", "italic", "underline", "strikethrough", "inlineCode", "superscript", "subscript"].includes(args.tool);
+    executeCanonicalInlineTool(canonicalRoot, args.tool, toggled ? "toggle" : "apply", input.canonical);
+    const native = ownerDocument.getSelection();
+    const selectionEquivalent = Boolean(native?.anchorNode && native.focusNode)
+        && args.anchor === globalOffset(canonicalRoot, native?.anchorNode || null, native?.anchorOffset || 0)
+        && args.head === globalOffset(canonicalRoot, native?.focusNode || null, native?.focusOffset || 0);
+    const legacyStructure = normalized(legacy.html);
+    const canonicalStructure = normalized(canonicalRoot.innerHTML);
+    const equivalent = legacyStructure === canonicalStructure && selectionEquivalent;
+    const boundaryDifference = !equivalent && boundaryAffinityDifference(args.html, Math.min(args.anchor, args.head), args.tool);
+    const canonicalAttributeDifference = !equivalent && ["textColor", "backgroundColor", "fontSize", "fontFamily", "link"].includes(args.tool);
+    const output = {
+        equivalent,
+        structuralHash: hash(`${legacyStructure}:${canonicalStructure}`),
+        legacyHash: hash(legacyStructure),
+        canonicalHash: hash(canonicalStructure),
+        selectionEquivalent,
+        ...(!equivalent ? { classification: legacyStructure === canonicalStructure ? "selection-only"
+                : boundaryDifference || canonicalAttributeDifference ? "expected-normalization" : "semantic" } : {}),
+    };
+    legacyRoot.remove();
+    canonicalRoot.remove();
+    return output;
+};
+export const runInlineShadowCorpus = (scenarios = 1000, initialSeed = 0x1A4F2026) => {
+    let seed = initialSeed >>> 0;
+    const random = () => ((seed = (Math.imul(seed, 1664525) + 1013904223) >>> 0) / 0x100000000);
+    const fixtures = [
+        "<p>plain formatting fixture</p>",
+        "<p><strong>bold</strong> and plain text</p>",
+        "<p><em>italic</em> and <u>underlined</u></p>",
+        "<p><a href=\"https://old.example\">linked text</a> after</p>",
+        "<p><span style=\"color:#0000ff\">colored text</span> after</p>",
+    ];
+    const tools = ["bold", "italic", "underline", "strikethrough", "inlineCode", "superscript", "subscript", "textColor", "backgroundColor", "fontSize", "fontFamily", "link"];
+    const divergences = {};
+    const logs = [];
+    let equivalent = 0;
+    for (let run = 0; run < scenarios; run += 1) {
+        const fixture = fixtures[Math.floor(random() * fixtures.length)];
+        const text = fixture.replace(/<[^>]+>/g, "");
+        const from = Math.floor(random() * Math.max(1, text.length - 1));
+        const to = from + 1 + Math.floor(random() * Math.max(1, text.length - from - 1));
+        const comparison = compareLegacyCanonicalInline({ html: fixture, tool: tools[run % tools.length], anchor: from, head: Math.min(text.length, to) });
+        if (comparison.equivalent)
+            equivalent += 1;
+        else {
+            const classification = comparison.classification || "unknown";
+            divergences[classification] = (divergences[classification] || 0) + 1;
+            logs.push({ structuralHash: comparison.structuralHash, classification });
+        }
+    }
+    return { scenarios, seed: initialSeed >>> 0, equivalent, divergences, logs };
+};

package/dist/test-harness/legacyAtomEngine.d.ts

@@ -0,0 +1,10 @@
+/**
+ * Test-only snapshot of the pre-Phase-7 media/formula command entry point.
+ * This file must remain isolated from product imports and was committed before
+ * canonical atom routing or deletion so shadow evidence remains reproducible.
+ */
+export interface LegacyAtomIntent {
+    readonly id: string;
+    readonly input?: Readonly<Record<string, unknown>>;
+}
+export declare const executeRetainedLegacyAtom: (html: string, intent: LegacyAtomIntent, ownerDocument?: Document) => string | null;

package/dist/test-harness/legacyAtomEngine.js

@@ -0,0 +1,15 @@
+import { createSmartEditor, formulaPlugin, mediaPlugin, } from "smartrte-core/legacy";
+import { serializeSmartDocument, smartDocumentFromHtml } from "../adapters/domSmartDocument.js";
+export const executeRetainedLegacyAtom = (html, intent, ownerDocument = document) => {
+    const model = smartDocumentFromHtml(html, ownerDocument);
+    const editor = createSmartEditor({
+        state: {
+            document: model,
+            selection: { type: "text", anchor: { path: [0, 0], offset: 0 }, focus: { path: [0, 0], offset: 0 } },
+        },
+        plugins: [mediaPlugin, formulaPlugin],
+    });
+    if (!editor.execute(intent.id, intent.input))
+        return null;
+    return serializeSmartDocument(editor.state.document);
+};

package/dist/test-harness/legacyBlockEngine.d.ts

@@ -0,0 +1,31 @@
+/**
+ * Test-only Phase 5 snapshot of the legacy block command engine.
+ *
+ * This harness must be committed before production block paths are deleted.
+ * Product code must never import it. It exists so shadow comparison remains
+ * executable after ClassicEditor routes through canonical block commands.
+ */
+import { type SmartEditorState } from "smartrte-core/legacy";
+export type LegacyBlockToolId = "setType" | "blockquote" | "codeBlock" | "alignment" | "indent" | "move";
+export type LegacyBlockInput = {
+    parentPath: readonly number[];
+    blockIndexes: readonly number[];
+    type: "paragraph" | "heading";
+    level?: 1 | 2 | 3 | 4 | 5 | 6;
+} | {
+    parentPath: readonly number[];
+    blockIndexes: readonly number[];
+} | {
+    paths: readonly (readonly number[])[];
+    alignment: "left" | "center" | "right" | "justify" | null;
+} | {
+    parentPath: readonly number[];
+    blockIndexes: readonly number[];
+    direction: "indent" | "outdent" | "up" | "down";
+};
+export declare const legacyBlockToolIds: readonly LegacyBlockToolId[];
+export interface LegacyBlockResult {
+    readonly html: string;
+    readonly selection: SmartEditorState["selection"];
+}
+export declare const runLegacyBlockTool: (root: HTMLElement, tool: LegacyBlockToolId, input: LegacyBlockInput) => LegacyBlockResult | null;

package/dist/test-harness/legacyBlockEngine.js

@@ -0,0 +1,31 @@
+/**
+ * Test-only Phase 5 snapshot of the legacy block command engine.
+ *
+ * This harness must be committed before production block paths are deleted.
+ * Product code must never import it. It exists so shadow comparison remains
+ * executable after ClassicEditor routes through canonical block commands.
+ */
+import { applyTransaction, indentBlocks, moveBlocks, setAlignment, setBlockType, toggleBlockquote, toggleCodeBlock, } from "smartrte-core/legacy";
+import { selectionFromDom } from "../adapters/domSelectionBridge.js";
+import { serializeSmartDocument, smartDocumentFromEditorRoot } from "../adapters/domSmartDocument.js";
+const commands = Object.freeze({
+    setType: setBlockType,
+    blockquote: toggleBlockquote,
+    codeBlock: toggleCodeBlock,
+    alignment: setAlignment,
+    indent: indentBlocks,
+    move: moveBlocks,
+});
+export const legacyBlockToolIds = Object.freeze(Object.keys(commands));
+export const runLegacyBlockTool = (root, tool, input) => {
+    const selection = selectionFromDom(root, root.ownerDocument.getSelection());
+    if (!selection)
+        return null;
+    const { document } = smartDocumentFromEditorRoot(root);
+    const state = { document, selection };
+    const command = commands[tool];
+    if (!command.isEnabled(state, input))
+        return null;
+    const next = applyTransaction(state, command.execute(state, input));
+    return { html: serializeSmartDocument(next.document), selection: next.selection };
+};

package/dist/test-harness/legacyClipboardEngine.d.ts

@@ -0,0 +1,14 @@
+/**
+ * Test-only snapshot of ClassicEditor's clipboard HTML cleaner.
+ *
+ * Retained before Phase 8a deletes the production clipboard path so the shadow
+ * comparator continues to have a real legacy implementation. This deliberately
+ * preserves legacy behavior, including its limitations; do not harden it in
+ * place. Source: ClassicEditor.tsx immediately before Phase 8a.
+ */
+export interface LegacyCleanHtmlOptions {
+    preserveColors?: boolean;
+    preserveDocumentLayout?: boolean;
+    preserveFontFamily?: boolean;
+}
+export declare function legacyCleanPastedHtml(html: string, options?: LegacyCleanHtmlOptions, ownerDocument?: Document): string;