smartrte-core 0.2.0 → 1.0.0-beta.1

package/dist/foundation/list/shadow.js

@@ -0,0 +1,75 @@
+import { resolvePos } from "../positions.js";
+import { repair } from "../schema.js";
+import { isTextNode } from "../identity.js";
+const sortedRecord = (value) => {
+    if (!value)
+        return undefined;
+    return Object.fromEntries(Object.keys(value).sort().map((key) => [key, value[key]]));
+};
+/**
+ * Comparator equivalence is normalized document structure with IDs stripped,
+ * plus semantic selection position. Operation streams are intentionally not
+ * compared: canonical editing is allowed to express the same user intent with
+ * a different operation sequence, and the legacy engine has no stable IDs.
+ */
+export const normalizedStructureWithoutIds = (document, schema) => {
+    const repaired = repair(document, schema).doc;
+    const strip = (node) => isTextNode(node)
+        ? { type: "text", text: node.text, ...(node.marks?.length ? { marks: node.marks.map((mark) => ({ type: mark.type, attrs: sortedRecord(mark.attrs) })) } : {}) }
+        : {
+            type: node.type,
+            ...(node.attrs && Object.keys(node.attrs).length ? { attrs: sortedRecord(node.attrs) } : {}),
+            ...(node.children ? { children: node.children.map(strip) } : {}),
+        };
+    return strip(repaired);
+};
+export const semanticSelectionPosition = (document, selection) => {
+    const endpoint = (pos) => {
+        const resolved = resolvePos(document, pos);
+        return { path: [...pos.path], offset: pos.offset, ownerType: resolved.parent.type, kind: resolved.kind };
+    };
+    return { type: selection.type, anchor: endpoint(selection.anchor), head: endpoint(selection.head) };
+};
+const hash = (value) => {
+    const input = JSON.stringify(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");
+};
+export const compareShadowDocuments = (args) => {
+    const legacyStructure = normalizedStructureWithoutIds(args.legacyDocument, args.schema);
+    const canonicalStructure = normalizedStructureWithoutIds(args.canonicalDocument, args.schema);
+    const legacySelection = semanticSelectionPosition(args.legacyDocument, args.legacySelection);
+    const canonicalSelection = semanticSelectionPosition(args.canonicalDocument, args.canonicalSelection);
+    const legacyStructureJson = JSON.stringify(legacyStructure);
+    const canonicalStructureJson = JSON.stringify(canonicalStructure);
+    const legacySelectionJson = JSON.stringify(legacySelection);
+    const canonicalSelectionJson = JSON.stringify(canonicalSelection);
+    const documentEquivalent = legacyStructureJson === canonicalStructureJson;
+    const selectionEquivalent = legacySelectionJson === canonicalSelectionJson;
+    return {
+        equivalent: documentEquivalent && selectionEquivalent,
+        documentEquivalent,
+        selectionEquivalent,
+        legacyStructureHash: hash(legacyStructure),
+        canonicalStructureHash: hash(canonicalStructure),
+        legacySelectionHash: hash(legacySelection),
+        canonicalSelectionHash: hash(canonicalSelection),
+        ...(!documentEquivalent || !selectionEquivalent ? { classification: args.classification || (documentEquivalent ? "selection-only" : "unknown") } : {}),
+    };
+};
+/** Privacy-safe logger payload: hashes and classification, never document text. */
+export const shadowLogRecord = (scenarioId, result) => ({
+    scenarioId,
+    equivalent: result.equivalent,
+    documentEquivalent: result.documentEquivalent,
+    selectionEquivalent: result.selectionEquivalent,
+    legacyStructureHash: result.legacyStructureHash,
+    canonicalStructureHash: result.canonicalStructureHash,
+    legacySelectionHash: result.legacySelectionHash,
+    canonicalSelectionHash: result.canonicalSelectionHash,
+    ...(result.classification ? { classification: result.classification } : {}),
+});

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

@@ -0,0 +1,10 @@
+import { shadowLogRecord } from "./shadow.js";
+export interface ShadowCorpusSummary {
+    readonly seed: number;
+    readonly scenarios: number;
+    readonly equivalent: number;
+    readonly divergences: Readonly<Record<string, number>>;
+    readonly logs: readonly ReturnType<typeof shadowLogRecord>[];
+}
+/** Browser-neutral replay of the production legacy-HTML comparator boundary. */
+export declare const runListShadowReplayCorpus: (scenarios?: number, seed?: number) => ShadowCorpusSummary;

package/dist/foundation/list/shadowCorpus.js

@@ -0,0 +1,41 @@
+import { foundationSchema } from "../schema.js";
+import { compareShadowDocuments, shadowLogRecord } from "./shadow.js";
+import { parseCanonicalListHtml, serializeCanonicalListHtml } from "./formats.js";
+/** Browser-neutral replay of the production legacy-HTML comparator boundary. */
+export const runListShadowReplayCorpus = (scenarios = 1000, seed = 1369441024) => {
+    const logs = [];
+    const divergences = {};
+    let equivalent = 0;
+    for (let index = 0; index < scenarios; index += 1) {
+        const label = ((seed ^ Math.imul(index + 1, 2654435761)) >>> 0).toString(36);
+        const nested = {
+            type: "list", id: `nested-${label}`, attrs: { style: index % 2 ? "lower-alpha" : "circle" }, children: [{
+                    type: "list_item", id: `nested-item-${label}`, children: [{ type: "paragraph", id: `nested-p-${label}`, children: [{ type: "text", text: `nested-${label}` }] }],
+                }],
+        };
+        const canonical = { type: "doc", id: `doc-${label}`, children: [{
+                    type: "list", id: `list-${label}`, attrs: {
+                        style: index % 2 ? "decimal" : "disc",
+                        ...(index % 3 === 0 ? { checkable: true } : {}),
+                        ...(index % 5 === 0 ? { start: 3 } : {}),
+                    }, children: [0, 1, 2].map((itemIndex) => ({
+                        type: "list_item", id: `item-${label}-${itemIndex}`,
+                        ...(index % 3 === 0 ? { attrs: { checked: itemIndex === 1 } } : {}),
+                        children: [{ type: itemIndex === 0 && index % 4 === 0 ? "heading" : "paragraph", id: `p-${label}-${itemIndex}`, ...(itemIndex === 0 && index % 4 === 0 ? { attrs: { level: 2 } } : {}), children: [{ type: "text", text: `content-${label}-${itemIndex}` }] }, ...(itemIndex === 1 ? [nested] : [])],
+                    })),
+                }] };
+        const legacy = parseCanonicalListHtml(serializeCanonicalListHtml(canonical, { clean: true }));
+        const pos = { path: [0, 0, 0], offset: 0 };
+        const result = compareShadowDocuments({
+            legacyDocument: legacy, legacySelection: { type: "text", anchor: pos, head: pos },
+            canonicalDocument: canonical, canonicalSelection: { type: "text", anchor: pos, head: pos },
+            schema: foundationSchema,
+        });
+        if (result.equivalent)
+            equivalent += 1;
+        else
+            divergences[result.classification || "unknown"] = (divergences[result.classification || "unknown"] || 0) + 1;
+        logs.push(shadowLogRecord(`browser-${index}`, result));
+    }
+    return { seed, scenarios, equivalent, divergences, logs };
+};

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

@@ -0,0 +1,50 @@
+import type { PositionLookup, ResolvedScope } from "../scope/types.js";
+import type { SmartDocument, SmartOperation, SmartSchema } from "../types.js";
+export interface CommandContext {
+    readonly schema: SmartSchema;
+    readonly positions: PositionLookup;
+}
+export type ListCommand<P> = (document: SmartDocument, scope: ResolvedScope, params: P, ctx: CommandContext) => SmartOperation[];
+export interface CreateListParams {
+    readonly listIds: readonly string[];
+    readonly itemIds: readonly string[];
+    readonly preset?: string;
+    readonly style?: string;
+    readonly start?: number;
+    readonly checkable?: boolean;
+}
+export interface UnwrapListParams {
+    /** New ID used only when unwrapping a middle run splits one list in two. */
+    readonly splitListIds?: readonly string[];
+}
+export interface IndentListParams {
+    /** One deterministic ID per selected list that needs a new nested list. */
+    readonly nestedListIds?: readonly string[];
+}
+export interface OutdentListParams extends UnwrapListParams {
+}
+export interface SetListPresetParams {
+    readonly preset?: string;
+}
+export interface SetListStyleParams {
+    readonly style?: string;
+    /** Optional list-level checklist mode used by the list toolbar adapter. */
+    readonly checkable?: boolean;
+}
+export interface SetListCheckedParams {
+    readonly checked: boolean;
+}
+export interface MoveListItemsParams {
+    readonly direction: "up" | "down";
+}
+export interface RestartListNumberingParams {
+    readonly start: number;
+}
+export interface ContinueListNumberingParams {
+}
+export interface InsertListFragmentParams {
+    readonly fragment: SmartDocument;
+    readonly position: "before" | "after" | "start" | "end";
+    /** Deterministic IDs used when plain fragment blocks must become items. */
+    readonly itemIds?: readonly string[];
+}

package/dist/foundation/list/types.js

@@ -0,0 +1 @@
+export {};

package/dist/foundation/mapping.d.ts

@@ -0,0 +1,11 @@
+import type { SmartOperation, SmartPos, SmartRange, SmartSelection, SmartTransaction, TransactionMap } from "./types.js";
+export declare class FoundationTransactionMap implements TransactionMap {
+    private readonly operations;
+    private readonly deletedKeys;
+    constructor(transactionOrOperations: SmartTransaction | readonly SmartOperation[]);
+    map(pos: SmartPos, bias?: -1 | 1): SmartPos;
+    mapRange(range: SmartRange): SmartRange;
+    mapSelection(selection: SmartSelection): SmartSelection;
+    deleted(pos: SmartPos): boolean;
+}
+export declare const createTransactionMap: (transactionOrOperations: SmartTransaction | readonly SmartOperation[]) => TransactionMap;

package/dist/foundation/mapping.js

@@ -0,0 +1,40 @@
+import { mapPosThroughOperation } from "./operations.js";
+export class FoundationTransactionMap {
+    constructor(transactionOrOperations) {
+        this.deletedKeys = new Set();
+        this.operations = "operations" in transactionOrOperations
+            ? transactionOrOperations.operations
+            : transactionOrOperations;
+    }
+    map(pos, bias = 1) {
+        let current = { path: [...pos.path], offset: pos.offset };
+        let wasDeleted = false;
+        this.operations.forEach((operation) => {
+            const result = mapPosThroughOperation(current, operation, bias);
+            current = result.pos;
+            wasDeleted || (wasDeleted = result.deleted);
+        });
+        if (wasDeleted)
+            this.deletedKeys.add(JSON.stringify(pos));
+        return current;
+    }
+    mapRange(range) {
+        return { from: this.map(range.from, -1), to: this.map(range.to, 1) };
+    }
+    mapSelection(selection) {
+        return { ...selection, anchor: this.map(selection.anchor, -1), head: this.map(selection.head, 1) };
+    }
+    deleted(pos) {
+        if (this.deletedKeys.has(JSON.stringify(pos)))
+            return true;
+        let current = pos;
+        for (const operation of this.operations) {
+            const result = mapPosThroughOperation(current, operation);
+            if (result.deleted)
+                return true;
+            current = result.pos;
+        }
+        return false;
+    }
+}
+export const createTransactionMap = (transactionOrOperations) => new FoundationTransactionMap(transactionOrOperations);

package/dist/foundation/marks/canonical.d.ts

@@ -0,0 +1,9 @@
+import type { Attrs, SmartMark } from "../types.js";
+export declare const stableValue: (value: unknown) => string;
+export declare const markKey: (mark: SmartMark) => string;
+export declare const compareMarks: (left: SmartMark, right: SmartMark) => number;
+export declare const canonicalMarkOrder: (marks: readonly SmartMark[] | undefined) => SmartMark[];
+export declare const canonicalColor: (input: unknown) => string | null;
+export declare const canonicalFontSize: (input: unknown) => number | null;
+export declare const canonicalFontFamily: (input: unknown) => string | null;
+export declare const canonicalMarkAttrs: (markType: string, attrs: Attrs | undefined) => Attrs | null;

package/dist/foundation/marks/canonical.js

@@ -0,0 +1,72 @@
+const namedColors = Object.freeze({
+    black: "#000000", white: "#ffffff", red: "#ff0000", green: "#008000",
+    blue: "#0000ff", yellow: "#ffff00", gray: "#808080", grey: "#808080",
+    transparent: "#00000000",
+});
+export const stableValue = (value) => {
+    if (Array.isArray(value))
+        return `[${value.map(stableValue).join(",")}]`;
+    if (value && typeof value === "object")
+        return `{${Object.entries(value)
+            .sort(([left], [right]) => left.localeCompare(right))
+            .map(([key, item]) => `${JSON.stringify(key)}:${stableValue(item)}`).join(",")}}`;
+    return JSON.stringify(value);
+};
+export const markKey = (mark) => `${mark.type}:${stableValue(mark.attrs || {})}`;
+export const compareMarks = (left, right) => left.type.localeCompare(right.type) || stableValue(left.attrs || {}).localeCompare(stableValue(right.attrs || {}));
+export const canonicalMarkOrder = (marks) => [...(marks || [])].sort(compareMarks).map((mark) => ({ type: mark.type, ...(mark.attrs ? { attrs: { ...mark.attrs } } : {}) }));
+export const canonicalColor = (input) => {
+    if (typeof input !== "string")
+        return null;
+    const value = input.trim().toLowerCase();
+    if (namedColors[value])
+        return namedColors[value];
+    const hex = /^#([0-9a-f]{3}|[0-9a-f]{6}|[0-9a-f]{8})$/.exec(value);
+    if (hex) {
+        const raw = hex[1].length === 3 ? hex[1].split("").map((part) => part + part).join("") : hex[1];
+        return `#${raw}`;
+    }
+    const rgb = /^rgba?\(\s*(\d{1,3})\s*,\s*(\d{1,3})\s*,\s*(\d{1,3})(?:\s*,\s*(0|1|0?\.\d+))?\s*\)$/.exec(value);
+    if (!rgb)
+        return null;
+    const parts = rgb.slice(1, 4).map(Number);
+    if (parts.some((part) => part > 255))
+        return null;
+    const base = `#${parts.map((part) => part.toString(16).padStart(2, "0")).join("")}`;
+    if (rgb[4] === undefined || Number(rgb[4]) === 1)
+        return base;
+    return `${base}${Math.round(Number(rgb[4]) * 255).toString(16).padStart(2, "0")}`;
+};
+export const canonicalFontSize = (input) => {
+    const raw = typeof input === "number" ? input : typeof input === "string"
+        ? (() => {
+            const match = /^(\d+(?:\.\d+)?)(px|pt)?$/i.exec(input.trim());
+            if (!match)
+                return Number.NaN;
+            return Number(match[1]) * (match[2]?.toLowerCase() === "pt" ? 4 / 3 : 1);
+        })()
+        : Number.NaN;
+    return Number.isFinite(raw) && raw >= 1 && raw <= 512 ? Number(raw.toFixed(3)) : null;
+};
+export const canonicalFontFamily = (input) => {
+    if (typeof input !== "string")
+        return null;
+    const value = input.split(",").map((family) => family.trim().replace(/^(['"])(.*)\1$/, "$2").replace(/\s+/g, " ").toLowerCase())
+        .filter(Boolean).join(", ");
+    return value || null;
+};
+export const canonicalMarkAttrs = (markType, attrs) => {
+    if (markType === "textColor" || markType === "backgroundColor") {
+        const value = canonicalColor(attrs?.value);
+        return value ? { value } : null;
+    }
+    if (markType === "fontSize") {
+        const valuePx = canonicalFontSize(attrs?.valuePx);
+        return valuePx === null ? null : { valuePx };
+    }
+    if (markType === "fontFamily") {
+        const value = canonicalFontFamily(attrs?.value);
+        return value ? { value } : null;
+    }
+    return attrs ? Object.fromEntries(Object.entries(attrs).sort(([left], [right]) => left.localeCompare(right))) : {};
+};

package/dist/foundation/marks/commands.d.ts

@@ -0,0 +1,21 @@
+import type { ResolvedScope } from "../scope/types.js";
+import type { SmartDocument } from "../types.js";
+import type { MarkApplyParams, MarkClearAllParams, MarkCommand, MarkCommandContext, MarkRemoveParams, MarkSetAttrsParams, MarkToggleParams, LinkEditParams, MarkApplicationReport } from "./types.js";
+/** Reports atoms skipped by mark application without changing the command contract. */
+export declare const reportMarkApplication: (document: SmartDocument, scope: ResolvedScope, markType: string, ctx: MarkCommandContext) => MarkApplicationReport;
+export declare const applyMarkCommand: MarkCommand<MarkApplyParams>;
+export declare const removeMarkCommand: MarkCommand<MarkRemoveParams>;
+export declare const toggleMarkCommand: MarkCommand<MarkToggleParams>;
+export declare const setMarkAttrsCommand: MarkCommand<MarkSetAttrsParams>;
+export declare const clearAllMarksCommand: MarkCommand<MarkClearAllParams>;
+export declare const removeLinkCommand: MarkCommand<MarkRemoveParams>;
+export declare const editLinkCommand: MarkCommand<LinkEditParams>;
+export declare const markCommands: {
+    readonly "mark.apply": MarkCommand<MarkApplyParams>;
+    readonly "mark.remove": MarkCommand<MarkRemoveParams>;
+    readonly "mark.toggle": MarkCommand<MarkToggleParams>;
+    readonly "mark.setAttrs": MarkCommand<MarkSetAttrsParams>;
+    readonly "mark.clearAll": MarkCommand<MarkClearAllParams>;
+    readonly "link.remove": MarkCommand<MarkRemoveParams>;
+    readonly "link.edit": MarkCommand<LinkEditParams>;
+};

package/dist/foundation/marks/commands.js

@@ -0,0 +1,136 @@
+import { isTextNode } from "../identity.js";
+import { nodeAtPath } from "../positions.js";
+import { normalizeLinkInput, sanitizeLinkTarget } from "../security/urlPolicy.js";
+import { canonicalMarkAttrs, markKey } from "./canonical.js";
+import { resolveMarkRun } from "./resolveMarkRun.js";
+const inlineScopes = (scope) => {
+    if (scope.kind === "inline-range")
+        return [scope];
+    if (scope.kind !== "mixed")
+        return [];
+    return scope.parts.flatMap(inlineScopes);
+};
+const markFor = (params, ctx) => {
+    const spec = ctx.schema.marks[params.markType];
+    if (!spec)
+        throw new Error(`Unknown mark type "${params.markType}".`);
+    let attrs = canonicalMarkAttrs(params.markType, params.attrs);
+    if (params.markType === "link") {
+        const href = normalizeLinkInput(String(params.attrs?.href || "")).href;
+        if (!href)
+            throw new Error("Link mark requires a safe URL.");
+        attrs = { href, ...(sanitizeLinkTarget(params.attrs?.target) ? { target: sanitizeLinkTarget(params.attrs?.target) } : {}) };
+    }
+    if (attrs === null)
+        throw new Error(`Invalid attributes for mark "${params.markType}".`);
+    const errors = Object.entries(spec.attributes || {}).filter(([name, attribute]) => attribute.required && attrs?.[name] === undefined || attrs?.[name] !== undefined && attribute.validate && !attribute.validate(attrs[name]));
+    if (errors.length)
+        throw new Error(`Invalid attributes for mark "${params.markType}": ${errors[0][0]}.`);
+    return { type: params.markType, ...(Object.keys(attrs).length ? { attrs } : {}) };
+};
+const textMarksInRange = (document, range) => {
+    const owner = nodeAtPath(document, range.from.path);
+    if (!owner || isTextNode(owner) || range.from.path.some((part, index) => part !== range.to.path[index]))
+        return [];
+    let offset = 0;
+    const marks = [];
+    (owner.children || []).forEach((node) => {
+        const width = isTextNode(node) ? node.text.length : 1;
+        if (isTextNode(node) && offset < range.to.offset && offset + width > range.from.offset)
+            marks.push(...(node.marks || []));
+        offset += width;
+    });
+    return [...new Map(marks.map((mark) => [markKey(mark), mark])).values()];
+};
+const ranges = (scope, ctx) => inlineScopes(scope).flatMap((part) => part.runs.filter((run) => run.to > run.from).flatMap((run) => {
+    const content = ctx.positions.contentRangeOf(run.ownerNodeId);
+    return content ? [{ from: { path: [...content.from.path], offset: run.from }, to: { path: [...content.to.path], offset: run.to } }] : [];
+}));
+const markAllowedInOwner = (document, range, markType, ctx) => {
+    const owner = nodeAtPath(document, range.from.path);
+    if (!owner || isTextNode(owner))
+        return false;
+    const allowed = ctx.schema.nodes[owner.type]?.marks;
+    return allowed !== "" && (allowed === undefined || allowed === "_all" || allowed.includes(markType));
+};
+/** Reports atoms skipped by mark application without changing the command contract. */
+export const reportMarkApplication = (document, scope, markType, ctx) => {
+    const ownerIds = new Set();
+    const skippedOwners = new Set();
+    const skipped = new Set();
+    for (const part of inlineScopes(scope))
+        for (const run of part.runs) {
+            ownerIds.add(run.ownerNodeId);
+            const content = ctx.positions.contentRangeOf(run.ownerNodeId);
+            if (content && !markAllowedInOwner(document, content, markType, ctx))
+                skippedOwners.add(run.ownerNodeId);
+            if (!run.containsAtoms)
+                continue;
+            const owner = content ? nodeAtPath(document, content.from.path) : undefined;
+            if (!owner || isTextNode(owner))
+                continue;
+            let offset = 0;
+            for (const child of owner.children || []) {
+                const width = isTextNode(child) ? child.text.length : 1;
+                if (!isTextNode(child) && offset < run.to && offset + width > run.from) {
+                    const allowed = ctx.schema.nodes[child.type]?.marks;
+                    if (allowed !== "_all" && (!Array.isArray(allowed) || !allowed.includes(markType)))
+                        skipped.add(child.id);
+                }
+                offset += width;
+            }
+        }
+    return {
+        ownerCount: ownerIds.size,
+        ownerIdsSkipped: [...skippedOwners],
+        atomOwnersSkipped: [...skipped],
+        partial: skipped.size > 0 || skippedOwners.size > 0,
+    };
+};
+const removalsFor = (document, range, types) => textMarksInRange(document, range).filter((mark) => types.has(mark.type)).map((mark) => ({ type: "removeMark", range, mark }));
+export const applyMarkCommand = (document, scope, params, ctx) => {
+    const mark = markFor(params, ctx);
+    const excluded = new Set([mark.type, ...(ctx.schema.marks[mark.type]?.excludes || [])]);
+    return ranges(scope, ctx).filter((range) => markAllowedInOwner(document, range, params.markType, ctx)).flatMap((range) => [
+        ...removalsFor(document, range, excluded),
+        { type: "addMark", range, mark },
+    ]);
+};
+export const removeMarkCommand = (document, scope, params, ctx) => ranges(scope, ctx).flatMap((range) => removalsFor(document, range, new Set([params.markType])));
+export const toggleMarkCommand = (document, scope, params, ctx) => params.coverage === "all"
+    ? removeMarkCommand(document, scope, params, ctx)
+    : applyMarkCommand(document, scope, params, ctx);
+export const setMarkAttrsCommand = applyMarkCommand;
+export const clearAllMarksCommand = (document, scope, _params, ctx) => ranges(scope, ctx).flatMap((range) => textMarksInRange(document, range).map((mark) => ({ type: "removeMark", range, mark })));
+const collapsedLinkRun = (document, scope) => {
+    const inline = inlineScopes(scope)[0];
+    return inline?.collapsed && inline.storedMarkAnchor
+        ? resolveMarkRun(document, inline.storedMarkAnchor.pos, "link")
+        : null;
+};
+export const removeLinkCommand = (document, scope, params, ctx) => {
+    const run = collapsedLinkRun(document, scope);
+    return run
+        ? [{ type: "removeMark", range: run.range, mark: run.mark }]
+        : removeMarkCommand(document, scope, { markType: params.markType || "link" }, ctx);
+};
+export const editLinkCommand = (document, scope, params, ctx) => {
+    const run = collapsedLinkRun(document, scope);
+    const attrs = { href: params.href, ...(params.target ? { target: params.target } : {}) };
+    if (!run)
+        return applyMarkCommand(document, scope, { markType: "link", attrs }, ctx);
+    const replacement = markFor({ markType: "link", attrs }, ctx);
+    return [
+        { type: "removeMark", range: run.range, mark: run.mark },
+        { type: "addMark", range: run.range, mark: replacement },
+    ];
+};
+export const markCommands = {
+    "mark.apply": applyMarkCommand,
+    "mark.remove": removeMarkCommand,
+    "mark.toggle": toggleMarkCommand,
+    "mark.setAttrs": setMarkAttrsCommand,
+    "mark.clearAll": clearAllMarksCommand,
+    "link.remove": removeLinkCommand,
+    "link.edit": editLinkCommand,
+};

package/dist/foundation/marks/dom.d.ts

@@ -0,0 +1,2 @@
+import type { SmartTextNode } from "../types.js";
+export declare const renderMarkedText: (node: SmartTextNode, document: Document) => Node;

package/dist/foundation/marks/dom.js

@@ -0,0 +1,46 @@
+import { canonicalMarkOrder, stableValue } from "./canonical.js";
+const elementForMark = (mark, document) => {
+    const tag = mark.type === "bold" ? "strong"
+        : mark.type === "italic" ? "em"
+            : mark.type === "underline" ? "u"
+                : mark.type === "strike" ? "s"
+                    : mark.type === "code" ? "code"
+                        : mark.type === "superscript" ? "sup"
+                            : mark.type === "subscript" ? "sub"
+                                : mark.type === "link" ? "a" : "span";
+    const element = document.createElement(tag);
+    element.setAttribute("data-smart-mark", mark.type);
+    if (mark.attrs)
+        element.setAttribute("data-smart-mark-attrs", stableValue(mark.attrs));
+    if (mark.type === "link") {
+        element.setAttribute("href", String(mark.attrs?.href || ""));
+        element.setAttribute("title", "Ctrl/Cmd+click to open link");
+        if (mark.attrs?.target)
+            element.setAttribute("target", String(mark.attrs.target));
+    }
+    else if (mark.type === "textColor")
+        element.style.color = String(mark.attrs?.value || "");
+    else if (mark.type === "backgroundColor")
+        element.style.backgroundColor = String(mark.attrs?.value || "");
+    else if (mark.type === "fontSize")
+        element.style.fontSize = `${String(mark.attrs?.valuePx || "")}px`;
+    else if (mark.type === "fontFamily")
+        element.style.fontFamily = String(mark.attrs?.value || "");
+    else if (mark.type === "suggestion") {
+        element.style.textDecoration = mark.attrs?.kind === "delete" ? "line-through" : "underline";
+        if (mark.attrs?.authorId)
+            element.setAttribute("data-suggestion-author", String(mark.attrs.authorId));
+        if (mark.attrs?.kind)
+            element.setAttribute("data-suggestion-kind", String(mark.attrs.kind));
+    }
+    return element;
+};
+export const renderMarkedText = (node, document) => {
+    let output = document.createTextNode(node.text);
+    [...canonicalMarkOrder(node.marks)].reverse().forEach((mark) => {
+        const wrapper = elementForMark(mark, document);
+        wrapper.appendChild(output);
+        output = wrapper;
+    });
+    return output;
+};

package/dist/foundation/marks/editor.d.ts

@@ -0,0 +1,8 @@
+import type { FoundationEditor } from "../editor.js";
+import type { Attrs, SmartOperation } from "../types.js";
+import type { InlineToolDeclaration } from "./types.js";
+export type MarkIntent = "apply" | "remove" | "toggle" | "setAttrs" | "clearAll" | "editLink";
+/** Editor-state adapter; the underlying mark commands remain pure and editor-free. */
+export declare const executeMarkTool: (editor: FoundationEditor, declaration: InlineToolDeclaration, intent: MarkIntent, attrs?: Attrs, options?: {
+    addToHistory?: boolean;
+}) => SmartOperation[];

package/dist/foundation/marks/editor.js

@@ -0,0 +1,50 @@
+import { canonicalMarkAttrs, canonicalMarkOrder } from "./canonical.js";
+import { applyMarkCommand, clearAllMarksCommand, editLinkCommand, removeLinkCommand, removeMarkCommand, toggleMarkCommand } from "./commands.js";
+import { marksAtInsertion } from "./stored.js";
+const updateCollapsed = (current, declaration, intent, attrs) => {
+    if (intent === "clearAll")
+        return [];
+    const exists = current.some((mark) => mark.type === declaration.markType);
+    const remove = intent === "remove" || intent === "toggle" && exists;
+    const without = current.filter((mark) => mark.type !== declaration.markType
+        && !(declaration.excludes || []).includes(mark.type));
+    if (remove)
+        return canonicalMarkOrder(without);
+    const canonicalAttrs = canonicalMarkAttrs(declaration.markType, attrs);
+    if (canonicalAttrs === null || declaration.validate?.(canonicalAttrs) === false) {
+        throw new Error(`Invalid attributes for mark "${declaration.markType}".`);
+    }
+    return canonicalMarkOrder([...without, {
+            type: declaration.markType,
+            ...(Object.keys(canonicalAttrs).length ? { attrs: canonicalAttrs } : {}),
+        }]);
+};
+/** Editor-state adapter; the underlying mark commands remain pure and editor-free. */
+export const executeMarkTool = (editor, declaration, intent, attrs, options = {}) => {
+    const scope = editor.resolveScope({ want: "inline-range" });
+    if (!("kind" in scope) || scope.kind !== "inline-range")
+        return [];
+    const inline = scope;
+    const description = editor.resolveScope({ want: "describe" });
+    if (inline.collapsed && !(declaration.markType === "link" && (intent === "remove" || intent === "editLink"))) {
+        const current = editor.storedMarks || marksAtInsertion(editor.document, editor.selection.head, editor.schema);
+        editor.setStoredMarks(updateCollapsed(current, declaration, intent, attrs), { source: "toolbar" });
+        return [];
+    }
+    const context = { schema: editor.schema, positions: editor.positions };
+    const coverage = description.marks.some((entry) => entry.mark.type === declaration.markType && entry.coverage === "all")
+        ? "all"
+        : description.marks.some((entry) => entry.mark.type === declaration.markType) ? "partial" : "none";
+    const operations = intent === "clearAll" ? clearAllMarksCommand(editor.document, inline, {}, context)
+        : intent === "remove" && declaration.markType === "link" ? removeLinkCommand(editor.document, inline, { markType: "link" }, context)
+            : intent === "editLink" && declaration.markType === "link" ? editLinkCommand(editor.document, inline, attrs, context)
+                : intent === "remove" ? removeMarkCommand(editor.document, inline, { markType: declaration.markType }, context)
+                    : intent === "toggle" ? toggleMarkCommand(editor.document, inline, { markType: declaration.markType, attrs, coverage }, context)
+                        : applyMarkCommand(editor.document, inline, { markType: declaration.markType, attrs }, context);
+    if (operations.length)
+        editor.transact((builder) => {
+            builder.operations.push(...operations);
+            builder.setSelection(editor.selection);
+        }, { source: "toolbar", addToHistory: options.addToHistory ?? true });
+    return operations;
+};

package/dist/foundation/marks/formats.d.ts

@@ -0,0 +1,37 @@
+import type { SmartDocument, SmartMark, SmartNode } from "../types.js";
+export declare const MARKDOWN_SUPPORTED_MARKS: readonly ["bold", "italic", "code", "strike", "link"];
+export declare const MARKDOWN_UNSUPPORTED_MARKS: readonly ["underline", "textColor", "backgroundColor", "fontSize", "fontFamily", "superscript", "subscript"];
+export interface CanonicalDocxRunProperties {
+    readonly bold?: boolean;
+    readonly italic?: boolean;
+    readonly underline?: boolean;
+    readonly strike?: boolean;
+    readonly code?: boolean;
+    readonly superscript?: boolean;
+    readonly subscript?: boolean;
+    readonly color?: string;
+    readonly backgroundColor?: string;
+    readonly fontSizeHalfPoints?: number;
+    readonly fontFamily?: string;
+    readonly link?: {
+        href: string;
+        target?: string;
+    };
+}
+export interface CanonicalDocxRun {
+    readonly text: string;
+    readonly properties: CanonicalDocxRunProperties;
+}
+export declare const docxProperties: (marks: readonly SmartMark[]) => CanonicalDocxRunProperties;
+/**
+ * The per-node half of docxProperties, matching FeatureFormatCodec.serialize's
+ * (node, ctx) => unknown shape (formats/codec.ts) - Phase 11 Tier 2's marks
+ * codec slice. Real single-node function already existed (docxProperties
+ * operates on one text node's marks array already); this only adapts its
+ * signature to accept a SmartNode directly, it does not add new logic.
+ */
+export declare const markRunDocxProperties: (node: SmartNode) => CanonicalDocxRunProperties;
+/** Semantic DOCX run model. Conversion to OOXML lives in the product adapter. */
+export declare const canonicalMarksToDocxRuns: (document: SmartDocument) => CanonicalDocxRun[];
+/** PDF fidelity is visual/lossy; this payload deliberately contains no mark identity. */
+export declare const canonicalMarksPdfText: (document: SmartDocument) => string;