smartrte-core 0.2.1 → 1.0.0-beta.2

package/dist/foundation/clipboard/normalizers.js

@@ -0,0 +1,229 @@
+import { parseCanonicalListMarkdown, serializeCanonicalListHtml } from "../list/formats.js";
+const listTags = new Set(["UL", "OL"]);
+const blockSelector = ":scope > p, :scope > h1, :scope > h2, :scope > h3, :scope > h4, :scope > h5, :scope > h6, :scope > ul, :scope > ol, :scope > blockquote, :scope > pre, :scope > table, :scope > div";
+const msoListPattern = /(?:^|;)\s*mso-list\s*:\s*([^\s;]+)\s+level(\d+)\s+([^\s;]+)/i;
+const unwrap = (element) => element.replaceWith(...Array.from(element.childNodes));
+const normalizeTransparentContainers = (document) => {
+    const docsWrapper = document.body.querySelector('[id^="docs-internal-guid-"]');
+    if (docsWrapper && docsWrapper.parentElement === document.body)
+        unwrap(docsWrapper);
+    [...document.body.querySelectorAll("div")].reverse().forEach((element) => {
+        if (element.querySelector(blockSelector))
+            unwrap(element);
+        else if (element.parentElement === document.body || element.parentElement?.tagName === "LI") {
+            const paragraph = document.createElement("p");
+            paragraph.append(...Array.from(element.childNodes));
+            element.replaceWith(paragraph);
+        }
+    });
+    const directNodes = Array.from(document.body.childNodes);
+    let paragraph = null;
+    directNodes.forEach((node) => {
+        if (node.nodeType === Node.TEXT_NODE && node.textContent) {
+            paragraph || (paragraph = document.createElement("p"));
+            if (!paragraph.parentNode)
+                document.body.insertBefore(paragraph, node);
+            paragraph.append(node);
+        }
+        else if (node.nodeType === Node.ELEMENT_NODE && !["BR", "SPAN", "B", "STRONG", "I", "EM", "U", "S", "A", "CODE"].includes(node.tagName)) {
+            paragraph = null;
+        }
+        else if (node.nodeType === Node.ELEMENT_NODE) {
+            paragraph || (paragraph = document.createElement("p"));
+            if (!paragraph.parentNode)
+                document.body.insertBefore(paragraph, node);
+            paragraph.append(node);
+        }
+    });
+};
+const declaredLevel = (item) => {
+    const value = Number(item.getAttribute("data-aria-level") || item.getAttribute("aria-level"));
+    return Number.isInteger(value) && value > 0 ? value : null;
+};
+const listShell = (source) => {
+    const shell = source.cloneNode(false);
+    shell.removeAttribute("start");
+    return shell;
+};
+const msoListEntry = (element) => {
+    if (element.tagName !== "P")
+        return null;
+    const match = msoListPattern.exec(element.getAttribute("style") || "");
+    if (!match)
+        return null;
+    const markerElement = Array.from(element.querySelectorAll("span")).find((span) => /(?:^|;)\s*mso-list\s*:\s*Ignore(?:\s*;|\s*$)/i.test(span.getAttribute("style") || ""));
+    const marker = markerElement?.textContent?.replace(/\u00a0/g, " ").trim() || "";
+    const ordered = /^(?:\d+|[a-z]+|[ivxlcdm]+)[.)]/i.test(marker);
+    const start = ordered ? Number.parseInt(marker, 10) : undefined;
+    return {
+        element: element,
+        markerElement: markerElement ?? null,
+        listKey: `${match[1]}:${match[3]}`,
+        level: Math.max(1, Number(match[2]) || 1),
+        tagName: ordered ? "OL" : "UL",
+        ...(start !== undefined && Number.isFinite(start) && start > 1 ? { start } : {}),
+    };
+};
+/** Converts real Office `mso-list` paragraph runs before generic wrappers move them. */
+const normalizeMsoLists = (document) => {
+    const visit = (parent) => {
+        const children = Array.from(parent.children);
+        for (let index = 0; index < children.length;) {
+            const first = msoListEntry(children[index]);
+            if (!first) {
+                visit(children[index]);
+                index += 1;
+                continue;
+            }
+            const entries = [first];
+            let cursor = index + 1;
+            while (cursor < children.length) {
+                const next = msoListEntry(children[cursor]);
+                if (!next || next.listKey !== first.listKey)
+                    break;
+                entries.push(next);
+                cursor += 1;
+            }
+            const roots = [];
+            const lists = [];
+            const lastItems = [];
+            entries.forEach((entry) => {
+                entry.markerElement?.remove();
+                Array.from(entry.element.children).forEach((child) => {
+                    if (!child.textContent?.trim() && !child.querySelector("img,br,table"))
+                        child.remove();
+                });
+                const level = Math.min(entry.level, lists.length + 1);
+                const parentItem = level > 1 ? lastItems[level - 2] : undefined;
+                let list = lists[level - 1];
+                const needsList = !list || list.tagName !== entry.tagName || (level > 1 && list.parentElement !== parentItem);
+                if (needsList) {
+                    list = document.createElement(entry.tagName.toLowerCase());
+                    if (entry.tagName === "OL" && entry.start)
+                        list.setAttribute("start", String(entry.start));
+                    if (level === 1)
+                        roots.push(list);
+                    else
+                        parentItem?.append(list);
+                    lists[level - 1] = list;
+                }
+                lists.length = level;
+                lastItems.length = level;
+                const item = document.createElement("li");
+                item.append(...Array.from(entry.element.childNodes));
+                list.append(item);
+                lastItems[level - 1] = item;
+            });
+            entries[0].element.replaceWith(...roots);
+            entries.slice(1).forEach((entry) => entry.element.remove());
+            roots.forEach(visit);
+            index = cursor;
+        }
+    };
+    visit(document.body);
+};
+/** Regroups Office/Docs runs that encode each visual item as a sibling list. */
+const normalizeDeclaredLevelLists = (document) => {
+    const visit = (parent) => {
+        const children = Array.from(parent.children);
+        for (let index = 0; index < children.length;) {
+            const first = children[index];
+            const firstItems = listTags.has(first.tagName) ? Array.from(first.children).filter((child) => child.tagName === "LI") : [];
+            if (!firstItems.some((item) => declaredLevel(item) !== null)) {
+                index += 1;
+                continue;
+            }
+            const run = [];
+            while (index < children.length && listTags.has(children[index].tagName))
+                run.push(children[index++]);
+            const entries = run.flatMap((list) => Array.from(list.children)
+                .filter((child) => child.tagName === "LI")
+                .map((item) => ({ level: declaredLevel(item) || 1, list, item: item })));
+            if (!entries.length)
+                continue;
+            const roots = [];
+            const stacks = [];
+            const lastItems = [];
+            entries.forEach((entry) => {
+                const level = Math.min(entry.level, stacks.length + 1);
+                const parentItem = level > 1 ? lastItems[level - 2] : undefined;
+                let target = stacks[level - 1];
+                const needsList = !target || target.tagName !== entry.list.tagName || (level > 1 && target.parentElement !== parentItem);
+                if (needsList) {
+                    target = listShell(entry.list);
+                    if (level === 1)
+                        roots.push(target);
+                    else
+                        parentItem?.append(target);
+                    stacks[level - 1] = target;
+                }
+                stacks.length = level;
+                lastItems.length = level;
+                entry.item.removeAttribute("aria-level");
+                entry.item.removeAttribute("data-aria-level");
+                target.append(entry.item);
+                lastItems[level - 1] = entry.item;
+            });
+            run[0].replaceWith(...roots);
+            run.slice(1).forEach((list) => list.remove());
+        }
+        Array.from(parent.children).forEach((child) => visit(child));
+    };
+    visit(document.body);
+};
+const normalizedHtml = (payload, id) => {
+    normalizeMsoLists(payload.document);
+    normalizeTransparentContainers(payload.document);
+    normalizeDeclaredLevelLists(payload.document);
+    return { html: payload.document.body.innerHTML, plainText: payload.plainText, repairs: [`${id}:transparent-containers-and-declared-list-levels`] };
+};
+export const wordClipboardNormalizer = {
+    id: "word",
+    sources: ["word"],
+    normalize: (payload) => normalizedHtml(payload, "word"),
+};
+export const googleDocsClipboardNormalizer = {
+    id: "google-docs",
+    sources: ["google-docs"],
+    normalize: (payload) => normalizedHtml(payload, "google-docs"),
+};
+export const spreadsheetClipboardNormalizer = {
+    id: "spreadsheet",
+    sources: ["spreadsheet"],
+    normalize(payload) {
+        normalizeTransparentContainers(payload.document);
+        return { html: payload.document.body.innerHTML, plainText: payload.plainText, repairs: ["spreadsheet:transparent-containers"] };
+    },
+};
+export const htmlClipboardNormalizer = {
+    id: "generic-html",
+    sources: ["html", "native"],
+    normalize: (payload) => normalizedHtml(payload, "generic-html"),
+};
+export const markdownClipboardNormalizer = {
+    id: "markdown",
+    sources: ["markdown"],
+    normalize(payload) {
+        const document = parseCanonicalListMarkdown(payload.plainText);
+        return {
+            html: serializeCanonicalListHtml(document, { clean: true, fragment: true }),
+            plainText: payload.plainText,
+            repairs: ["markdown:gfm-parse"],
+        };
+    },
+};
+export const plainTextClipboardNormalizer = {
+    id: "plain-text",
+    sources: ["plain-text"],
+    normalize(payload) {
+        return { html: payload.html, plainText: payload.plainText, repairs: [] };
+    },
+};
+export const capturedSourceNormalizers = Object.freeze([
+    wordClipboardNormalizer,
+    googleDocsClipboardNormalizer,
+    spreadsheetClipboardNormalizer,
+    markdownClipboardNormalizer,
+    htmlClipboardNormalizer,
+    plainTextClipboardNormalizer,
+]);

package/dist/foundation/clipboard/pipeline.d.ts

@@ -0,0 +1,13 @@
+import type { ClipboardFragment, ClipboardPipelineOptions, RawClipboardPayload } from "./types.js";
+export declare const DEFAULT_MAX_CLIPBOARD_BYTES: number;
+export declare class ClipboardPayloadTooLargeError extends Error {
+    readonly actualBytes: number;
+    readonly maximumBytes: number;
+    constructor(actualBytes: number, maximumBytes: number);
+}
+export declare const estimateClipboardPayloadBytes: (payload: RawClipboardPayload) => number;
+/**
+ * The only public raw-payload entry point. Its call graph fixes the security
+ * order as detect -> sanitize -> normalize -> parse -> schema repair.
+ */
+export declare const parseClipboardPayload: (payload: RawClipboardPayload, options: ClipboardPipelineOptions) => ClipboardFragment;

package/dist/foundation/clipboard/pipeline.js

@@ -0,0 +1,58 @@
+import { createNodeId } from "../identity.js";
+import { parseCanonicalListHtml } from "../list/formats.js";
+import { foundationSchema, repair } from "../schema.js";
+import { detectClipboardSource } from "./detection.js";
+import { capturedSourceNormalizers } from "./normalizers.js";
+import { sanitizeClipboardHtml } from "./sanitizer.js";
+import { parseNativeClipboardDocument } from "./serialization.js";
+export const DEFAULT_MAX_CLIPBOARD_BYTES = 5 * 1024 * 1024;
+export class ClipboardPayloadTooLargeError extends Error {
+    constructor(actualBytes, maximumBytes) {
+        super(`Clipboard payload is ${actualBytes} bytes; the limit is ${maximumBytes} bytes.`);
+        this.actualBytes = actualBytes;
+        this.maximumBytes = maximumBytes;
+        this.name = "ClipboardPayloadTooLargeError";
+    }
+}
+export const estimateClipboardPayloadBytes = (payload) => {
+    const values = payload.representations
+        ? Object.values(payload.representations)
+        : [payload.html || "", payload.plainText || "", payload.native || ""];
+    return values.reduce((total, value) => total + new TextEncoder().encode(value).byteLength, 0);
+};
+const genericNormalizer = {
+    id: "generic-html",
+    sources: ["native", "word", "google-docs", "spreadsheet", "markdown", "html", "plain-text"],
+    normalize(payload) {
+        return { html: payload.html, plainText: payload.plainText, repairs: [] };
+    },
+};
+const textAsHtml = (ownerDocument, text) => text.split(/\r?\n\r?\n/).map((paragraph) => {
+    const element = ownerDocument.createElement("p");
+    element.textContent = paragraph;
+    return element.outerHTML;
+}).join("");
+/**
+ * The only public raw-payload entry point. Its call graph fixes the security
+ * order as detect -> sanitize -> normalize -> parse -> schema repair.
+ */
+export const parseClipboardPayload = (payload, options) => {
+    const bytes = estimateClipboardPayloadBytes(payload);
+    const maximum = Math.max(1, Math.floor(options.maxBytes ?? DEFAULT_MAX_CLIPBOARD_BYTES));
+    if (bytes > maximum)
+        throw new ClipboardPayloadTooLargeError(bytes, maximum);
+    const detection = detectClipboardSource(payload);
+    const plainText = payload.plainText || "";
+    const rawHtml = payload.html || textAsHtml(options.ownerDocument, plainText);
+    const sanitized = sanitizeClipboardHtml(options.ownerDocument, detection.source, rawHtml, plainText);
+    const normalizer = options.normalizerMode === "generic" ? genericNormalizer
+        : options.normalizers?.find((candidate) => candidate.sources.includes(detection.source))
+            || capturedSourceNormalizers.find((candidate) => candidate.sources.includes(detection.source))
+            || genericNormalizer;
+    const normalized = normalizer.normalize(sanitized);
+    const parsed = detection.source === "native" && payload.native
+        ? parseNativeClipboardDocument(payload.native)
+        : parseCanonicalListHtml(normalized.html);
+    const repaired = repair({ ...parsed, id: parsed.id || createNodeId() }, options.schema ?? foundationSchema);
+    return { source: detection.source, document: repaired.doc, repairs: [...normalized.repairs, ...repaired.repairs] };
+};

package/dist/foundation/clipboard/sanitizer.d.ts

@@ -0,0 +1,3 @@
+import type { ClipboardSource, SanitizedClipboardPayload } from "./types.js";
+/** Security boundary. Source normalizers can only receive the branded result. */
+export declare const sanitizeClipboardHtml: (ownerDocument: Document, source: ClipboardSource, html: string, plainText: string) => SanitizedClipboardPayload;

package/dist/foundation/clipboard/sanitizer.js

@@ -0,0 +1,58 @@
+import createDOMPurify from "dompurify";
+import { sanitizeLinkHref, sanitizeResourceUrl } from "../security/urlPolicy.js";
+const allowedClipboardImageData = new Set(["image/png", "image/jpeg", "image/gif", "image/webp"]);
+const dangerousCss = /(?:expression\s*\(|url\s*\(|@import\b|behavior\s*:|-moz-binding\s*:)/i;
+const parseSanitizedDocument = (ownerDocument, html) => {
+    const parser = new ownerDocument.defaultView.DOMParser();
+    return parser.parseFromString(html, "text/html");
+};
+/** Security boundary. Source normalizers can only receive the branded result. */
+export const sanitizeClipboardHtml = (ownerDocument, source, html, plainText) => {
+    if (!ownerDocument.defaultView)
+        throw new Error("Clipboard sanitization requires a DOM window.");
+    const purifier = createDOMPurify(ownerDocument.defaultView);
+    purifier.addHook("uponSanitizeAttribute", (_node, event) => {
+        const name = event.attrName.toLowerCase();
+        if (name.startsWith("on")) {
+            event.keepAttr = false;
+            return;
+        }
+        if (name === "style" && dangerousCss.test(event.attrValue)) {
+            event.keepAttr = false;
+            return;
+        }
+        if (name === "href" || name === "xlink:href") {
+            const safe = sanitizeLinkHref(event.attrValue);
+            if (safe)
+                event.attrValue = safe;
+            else
+                event.keepAttr = false;
+            return;
+        }
+        if (name === "src" || name === "poster") {
+            const safe = sanitizeResourceUrl(event.attrValue, { allowedDataMimeTypes: allowedClipboardImageData });
+            if (safe)
+                event.attrValue = safe;
+            else
+                event.keepAttr = false;
+        }
+    });
+    const sanitized = purifier.sanitize(html, {
+        ALLOWED_NAMESPACES: ["http://www.w3.org/1999/xhtml", "http://www.w3.org/1998/Math/MathML"],
+        ALLOW_DATA_ATTR: true,
+        ALLOW_UNKNOWN_PROTOCOLS: false,
+        FORBID_TAGS: ["script", "iframe", "object", "embed", "form", "style", "svg"],
+        FORBID_CONTENTS: ["script", "iframe", "object", "embed", "form", "style", "svg"],
+        CUSTOM_ELEMENT_HANDLING: {
+            tagNameCheck: /^x-[a-z0-9-]+$/,
+            attributeNameCheck: null,
+            allowCustomizedBuiltInElements: false,
+        },
+    });
+    return {
+        source,
+        html: sanitized,
+        plainText,
+        document: parseSanitizedDocument(ownerDocument, sanitized),
+    };
+};

package/dist/foundation/clipboard/serialization.d.ts

@@ -0,0 +1,5 @@
+import type { SmartDocument } from "../types.js";
+import { type ClipboardRepresentations } from "./types.js";
+export declare const serializeNativeClipboardDocument: (document: SmartDocument) => string;
+export declare const parseNativeClipboardDocument: (value: string) => SmartDocument;
+export declare const serializeClipboardRepresentations: (document: SmartDocument) => ClipboardRepresentations;

package/dist/foundation/clipboard/serialization.js

@@ -0,0 +1,33 @@
+import { isTextNode } from "../identity.js";
+import { serializeCanonicalListHtml } from "../list/formats.js";
+import { NATIVE_CLIPBOARD_MIME } from "./types.js";
+const nodeText = (node) => {
+    if (isTextNode(node))
+        return node.text;
+    if (node.type === "hard_break")
+        return "\n";
+    if (node.type === "image" || node.type === "block_image")
+        return String(node.attrs?.alt || "");
+    if (node.type === "formula" || node.type === "block_formula")
+        return String(node.attrs?.source || "");
+    const separator = node.type === "table_cell" ? "\t" : node.type === "paragraph" || node.type === "heading"
+        || node.type === "code_block" || node.type === "list_item" || node.type === "table_row" ? "\n" : "";
+    return (node.children || []).map(nodeText).join(separator === "\t" ? "" : "") + separator;
+};
+export const serializeNativeClipboardDocument = (document) => JSON.stringify({
+    format: "smartrte-canonical-fragment",
+    version: 1,
+    document,
+});
+export const parseNativeClipboardDocument = (value) => {
+    const envelope = JSON.parse(value);
+    if (envelope.format !== "smartrte-canonical-fragment" || envelope.version !== 1 || envelope.document?.type !== "doc") {
+        throw new Error("Invalid native Smart RTE clipboard fragment.");
+    }
+    return structuredClone(envelope.document);
+};
+export const serializeClipboardRepresentations = (document) => ({
+    [NATIVE_CLIPBOARD_MIME]: serializeNativeClipboardDocument(document),
+    "text/html": serializeCanonicalListHtml(document, { clean: true }),
+    "text/plain": document.children.map(nodeText).join("").replace(/\n+$/g, ""),
+});

package/dist/foundation/clipboard/transfer.d.ts

@@ -0,0 +1,11 @@
+import type { PositionLookup } from "../scope/types.js";
+import type { SmartDocument, SmartOperation, SmartSelection } from "../types.js";
+export declare const sliceClipboardSelection: (document: SmartDocument, selection: SmartSelection) => SmartDocument;
+export interface ClipboardDeletionResult {
+    readonly operations: readonly SmartOperation[];
+    readonly selectionTarget: {
+        readonly ownerId: string;
+        readonly offset: number;
+    };
+}
+export declare const deleteClipboardSelection: (document: SmartDocument, selection: SmartSelection, positions: PositionLookup) => ClipboardDeletionResult;

package/dist/foundation/clipboard/transfer.js

@@ -0,0 +1,108 @@
+import { isTextNode } from "../identity.js";
+import { comparePos, nodeAtPath } from "../positions.js";
+const samePath = (left, right) => left.length === right.length && left.every((part, index) => part === right[index]);
+const size = (node) => isTextNode(node) ? node.text.length : 1;
+const split = (children, offset) => {
+    const before = [];
+    const after = [];
+    let cursor = 0;
+    children.forEach((node) => {
+        const end = cursor + size(node);
+        if (end <= offset)
+            before.push(structuredClone(node));
+        else if (cursor >= offset)
+            after.push(structuredClone(node));
+        else if (isTextNode(node)) {
+            const local = offset - cursor;
+            if (local)
+                before.push({ ...node, text: node.text.slice(0, local) });
+            if (local < node.text.length)
+                after.push({ ...node, text: node.text.slice(local) });
+        }
+        cursor = end;
+    });
+    return [before, after];
+};
+const range = (selection) => comparePos(selection.anchor, selection.head) <= 0
+    ? { from: selection.anchor, to: selection.head } : { from: selection.head, to: selection.anchor };
+const element = (document, pos) => {
+    const node = nodeAtPath(document, pos.path);
+    if (!node || isTextNode(node))
+        throw new Error("Clipboard selection owner is invalid.");
+    return node;
+};
+export const sliceClipboardSelection = (document, selection) => {
+    const selected = range(selection);
+    if (selection.type === "node" || selection.type === "cell") {
+        const parent = nodeAtPath(document, selected.from.path);
+        if (!parent || isTextNode(parent) || !parent.children)
+            throw new Error("Clipboard node selection parent is invalid.");
+        return { type: "doc", id: document.id, children: parent.children.slice(selected.from.offset, selected.to.offset).map((node) => structuredClone(node)) };
+    }
+    const fromOwner = element(document, selected.from);
+    if (samePath(selected.from.path, selected.to.path)) {
+        const [, tail] = split(fromOwner.children || [], selected.from.offset);
+        const [content] = split(tail, selected.to.offset - selected.from.offset);
+        return { type: "doc", id: document.id, children: [{ ...fromOwner, children: content }] };
+    }
+    const parentPath = selected.from.path.slice(0, -1);
+    if (!samePath(parentPath, selected.to.path.slice(0, -1)))
+        throw new Error("Clipboard copy is clamped to one structural parent.");
+    const parent = nodeAtPath(document, parentPath);
+    const toOwner = element(document, selected.to);
+    if (!parent || isTextNode(parent) || !parent.children)
+        throw new Error("Clipboard selection parent is invalid.");
+    const fromIndex = selected.from.path[selected.from.path.length - 1];
+    const toIndex = selected.to.path[selected.to.path.length - 1];
+    const [, first] = split(fromOwner.children || [], selected.from.offset);
+    const [last] = split(toOwner.children || [], selected.to.offset);
+    return {
+        type: "doc", id: document.id,
+        children: [
+            { ...fromOwner, children: first },
+            ...parent.children.slice(fromIndex + 1, toIndex).map((node) => structuredClone(node)),
+            { ...toOwner, children: last },
+        ],
+    };
+};
+export const deleteClipboardSelection = (document, selection, positions) => {
+    const selected = range(selection);
+    if (selection.type === "node" || selection.type === "cell") {
+        const parent = nodeAtPath(document, selected.from.path);
+        if (!parent || isTextNode(parent) || !parent.children)
+            throw new Error("Clipboard node deletion parent is invalid.");
+        const operations = [];
+        for (let index = selected.to.offset - 1; index >= selected.from.offset; index -= 1)
+            operations.push({
+                type: "removeNode", pos: { path: [...selected.from.path], offset: index }, node: parent.children[index],
+            });
+        return { operations, selectionTarget: { ownerId: parent.id, offset: selected.from.offset } };
+    }
+    const owner = element(document, selected.from);
+    const ownerPosition = positions.positionOf(owner.id);
+    if (!ownerPosition)
+        throw new Error("Clipboard deletion owner position is unavailable.");
+    if (samePath(selected.from.path, selected.to.path)) {
+        const [before] = split(owner.children || [], selected.from.offset);
+        const [, after] = split(owner.children || [], selected.to.offset);
+        return {
+            operations: [{ type: "replaceNode", pos: ownerPosition.pos, before: owner, after: { ...owner, children: [...before, ...after] } }],
+            selectionTarget: { ownerId: owner.id, offset: selected.from.offset },
+        };
+    }
+    const parentPath = selected.from.path.slice(0, -1);
+    const parent = nodeAtPath(document, parentPath);
+    const toOwner = element(document, selected.to);
+    if (!samePath(parentPath, selected.to.path.slice(0, -1)) || !parent || isTextNode(parent) || !parent.children) {
+        throw new Error("Clipboard deletion is clamped to one structural parent.");
+    }
+    const fromIndex = selected.from.path[selected.from.path.length - 1];
+    const toIndex = selected.to.path[selected.to.path.length - 1];
+    const [before] = split(owner.children || [], selected.from.offset);
+    const [, after] = split(toOwner.children || [], selected.to.offset);
+    const operations = [];
+    for (let index = toIndex; index > fromIndex; index -= 1)
+        operations.push({ type: "removeNode", pos: { path: [...parentPath], offset: index }, node: parent.children[index] });
+    operations.push({ type: "replaceNode", pos: ownerPosition.pos, before: owner, after: { ...owner, children: [...before, ...after] } });
+    return { operations, selectionTarget: { ownerId: owner.id, offset: selected.from.offset } };
+};

package/dist/foundation/clipboard/types.d.ts

@@ -0,0 +1,65 @@
+import type { Repair, SmartDocument, SmartSchema } from "../types.js";
+export declare const NATIVE_CLIPBOARD_MIME = "application/x-smart-rte+json";
+export type ClipboardSource = "native" | "word" | "google-docs" | "spreadsheet" | "markdown" | "html" | "plain-text";
+export interface RawClipboardPayload {
+    readonly html?: string;
+    readonly plainText?: string;
+    readonly native?: string;
+    readonly types?: readonly string[];
+    /** Complete MIME map when available; used by size guards and adapters. */
+    readonly representations?: Readonly<Record<string, string>>;
+}
+export interface ClipboardDetection {
+    /** A normalizer-selection hint. Correctness must not depend on this value. */
+    readonly source: ClipboardSource;
+    readonly signals: readonly string[];
+}
+declare const sanitizedClipboardBrand: unique symbol;
+/** Only the sanitizer stage can construct this input for a source normalizer. */
+export interface SanitizedClipboardPayload {
+    readonly [sanitizedClipboardBrand]: true;
+    readonly source: ClipboardSource;
+    readonly html: string;
+    readonly plainText: string;
+    readonly document: Document;
+}
+export interface NormalizedClipboardPayload {
+    readonly html: string;
+    readonly plainText: string;
+    readonly repairs: readonly string[];
+}
+export interface SourceNormalizer {
+    readonly id: string;
+    readonly sources: readonly ClipboardSource[];
+    normalize(payload: SanitizedClipboardPayload): NormalizedClipboardPayload;
+}
+export interface ClipboardFragment {
+    readonly source: ClipboardSource;
+    readonly document: SmartDocument;
+    readonly repairs: readonly (Repair | string)[];
+}
+export interface ClipboardRepresentations {
+    readonly [NATIVE_CLIPBOARD_MIME]: string;
+    readonly "text/html": string;
+    readonly "text/plain": string;
+}
+export interface ClipboardPipelineOptions {
+    readonly ownerDocument: Document;
+    readonly normalizers?: readonly SourceNormalizer[];
+    /** Test/audit switch proving detection is never required for correctness. */
+    readonly normalizerMode?: "detected" | "generic";
+    readonly maxBytes?: number;
+    /**
+     * The schema pasted content is repaired against - defaults to
+     * `foundationSchema` (the full built-in set) for full backward
+     * compatibility. An editor instance constructed with a restricted plugin
+     * set (see packages/react's capabilityPresets.ts) must pass its own
+     * `editor.schema` here, or pasted content matching an *excluded* plugin's
+     * node types (e.g. a pasted `<table>` under a table-less preset) would
+     * incorrectly validate against the full schema instead of demoting to
+     * `unknown` - defeating Phase 10's disable-safety guarantee specifically
+     * for the paste path.
+     */
+    readonly schema?: SmartSchema;
+}
+export {};

package/dist/foundation/clipboard/types.js

@@ -0,0 +1 @@
+export const NATIVE_CLIPBOARD_MIME = "application/x-smart-rte+json";

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

@@ -0,0 +1,3 @@
+export * from "./types.js";
+export * from "./transform.js";
+export * from "./rebase.js";

package/dist/foundation/collab/index.js

@@ -0,0 +1,3 @@
+export * from "./types.js";
+export * from "./transform.js";
+export * from "./rebase.js";

package/dist/foundation/collab/rebase.d.ts

@@ -0,0 +1,28 @@
+import type { SmartTransaction } from "../types.js";
+import type { RebaseResult } from "./types.js";
+/**
+ * Rebases `transaction` (whose `baseRevision` is behind the current
+ * revision) through every transaction committed since, in commit order.
+ * Each of `transaction`'s own operations is threaded through every
+ * operation of every missed transaction in sequence - the standard
+ * single-step operational-transform composition, built on `mapOperation`/
+ * `transformOperation`.
+ *
+ * Atomic per transaction: if any one operation conflicts, the whole
+ * transaction is rejected as a conflict rather than partially applied -
+ * matching `applyTransactionAtomic`'s own existing all-or-nothing
+ * semantics, and avoiding a confusing state where only part of a user's
+ * intent materializes.
+ *
+ * Does not check retention/resync - `missed` is whatever the caller
+ * supplies; a caller backed by a bounded revision log is responsible for
+ * returning `resync-required` itself before ever calling this when the
+ * requested history has already been evicted (see editor.ts's dispatch).
+ *
+ * `newBaseRevision` is the revision the rebased transaction should be
+ * stamped with (i.e. the live revision the caller is about to apply
+ * against) - taken explicitly from the caller rather than inferred from
+ * `missed`'s own entries, so a gap or reordering bug in how the caller
+ * assembled `missed` can't silently produce a wrong revision stamp here.
+ */
+export declare const rebaseTransaction: (transaction: SmartTransaction, missed: readonly SmartTransaction[], newBaseRevision: number) => RebaseResult;