smartrte-core 0.2.1 → 1.0.0-beta.2

package/dist/foundation/marks/formats.js

@@ -0,0 +1,49 @@
+import { isTextNode } from "../identity.js";
+import { canonicalMarkOrder } from "./canonical.js";
+export const MARKDOWN_SUPPORTED_MARKS = Object.freeze(["bold", "italic", "code", "strike", "link"]);
+export const MARKDOWN_UNSUPPORTED_MARKS = Object.freeze([
+    "underline", "textColor", "backgroundColor", "fontSize", "fontFamily", "superscript", "subscript",
+]);
+export const docxProperties = (marks) => {
+    const properties = {};
+    canonicalMarkOrder(marks).forEach((mark) => {
+        if (mark.type === "bold" || mark.type === "italic" || mark.type === "underline" || mark.type === "strike"
+            || mark.type === "code" || mark.type === "superscript" || mark.type === "subscript")
+            properties[mark.type] = true;
+        else if (mark.type === "textColor")
+            properties.color = mark.attrs?.value;
+        else if (mark.type === "backgroundColor")
+            properties.backgroundColor = mark.attrs?.value;
+        else if (mark.type === "fontSize")
+            properties.fontSizeHalfPoints = Math.round(Number(mark.attrs?.valuePx || 0) * 1.5);
+        else if (mark.type === "fontFamily")
+            properties.fontFamily = mark.attrs?.value;
+        else if (mark.type === "link")
+            properties.link = { href: String(mark.attrs?.href || ""), ...(mark.attrs?.target ? { target: String(mark.attrs.target) } : {}) };
+    });
+    return properties;
+};
+/**
+ * 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 const markRunDocxProperties = (node) => isTextNode(node) ? docxProperties(node.marks || []) : {};
+/** Semantic DOCX run model. Conversion to OOXML lives in the product adapter. */
+export const canonicalMarksToDocxRuns = (document) => {
+    const runs = [];
+    const visit = (node) => {
+        if (isTextNode(node))
+            runs.push({ text: node.text, properties: docxProperties(node.marks || []) });
+        else if (node.type === "hard_break")
+            runs.push({ text: "\n", properties: {} });
+        else
+            node.children?.forEach(visit);
+    };
+    visit(document);
+    return runs;
+};
+/** PDF fidelity is visual/lossy; this payload deliberately contains no mark identity. */
+export const canonicalMarksPdfText = (document) => canonicalMarksToDocxRuns(document).map((run) => run.text).join("");

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

@@ -0,0 +1,8 @@
+import type { SmartDocument, SmartOperation, SmartPos } from "../types.js";
+export interface HardBreakMigrationResult {
+    readonly document: SmartDocument;
+    readonly migratedBreaks: number;
+}
+/** Migrates legacy canonical newline text to atomic, unmarked hard_break nodes. */
+export declare const migrateNewlineTextToHardBreaks: (document: SmartDocument) => HardBreakMigrationResult;
+export declare const insertHardBreak: (document: SmartDocument, pos: SmartPos, id?: string) => SmartOperation[];

package/dist/foundation/marks/hardBreak.js

@@ -0,0 +1,80 @@
+import { cloneNode, createNodeId, isTextNode } from "../identity.js";
+import { nodeAtPath } from "../positions.js";
+/** Migrates legacy canonical newline text to atomic, unmarked hard_break nodes. */
+export const migrateNewlineTextToHardBreaks = (document) => {
+    let migratedBreaks = 0;
+    const visit = (node) => {
+        if (isTextNode(node)) {
+            if (!node.text.includes("\n"))
+                return node;
+            throw new Error("Text-node migration must be performed by its inline owner.");
+        }
+        const children = [];
+        let changed = false;
+        (node.children || []).forEach((child) => {
+            if (!isTextNode(child) || !child.text.includes("\n")) {
+                const visited = visit(child);
+                if (visited !== child)
+                    changed = true;
+                children.push(visited);
+                return;
+            }
+            changed = true;
+            const pieces = child.text.split("\n");
+            pieces.forEach((piece, index) => {
+                if (piece)
+                    children.push({ type: "text", text: piece, ...(child.marks?.length ? { marks: [...child.marks] } : {}) });
+                if (index < pieces.length - 1) {
+                    children.push({ type: "hard_break", id: createNodeId() });
+                    migratedBreaks += 1;
+                }
+            });
+        });
+        if (!changed)
+            return node;
+        return { ...node, ...(node.children ? { children } : {}) };
+    };
+    return { document: visit(document), migratedBreaks };
+};
+const splitChildrenAt = (children, offset) => {
+    const before = [];
+    const after = [];
+    let cursor = 0;
+    let split = false;
+    children.forEach((child) => {
+        if (split)
+            return after.push(child);
+        const width = isTextNode(child) ? child.text.length : 1;
+        if (offset > cursor + width) {
+            before.push(child);
+            cursor += width;
+            return;
+        }
+        const local = offset - cursor;
+        if (isTextNode(child)) {
+            if (local > 0)
+                before.push({ ...child, text: child.text.slice(0, local) });
+            if (local < width)
+                after.push({ ...child, text: child.text.slice(local) });
+        }
+        else if (local === 0)
+            after.push(child);
+        else if (local === 1)
+            before.push(child);
+        else
+            throw new Error("Hard-break insertion position is inside an atom.");
+        split = true;
+        cursor += width;
+    });
+    if (!split && cursor !== offset)
+        throw new Error("Hard-break insertion position is out of bounds.");
+    return [before, after];
+};
+export const insertHardBreak = (document, pos, id = createNodeId()) => {
+    const owner = nodeAtPath(document, pos.path);
+    if (!owner || isTextNode(owner) || !owner.children)
+        throw new Error("hard_break requires an inline owner position.");
+    const [before, after] = splitChildrenAt(owner.children, pos.offset);
+    const replacement = { ...owner, children: [...before, { type: "hard_break", id }, ...after] };
+    return [{ type: "replaceNode", pos: { path: pos.path.slice(0, -1), offset: pos.path[pos.path.length - 1] }, before: cloneNode(owner), after: replacement }];
+};

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

@@ -0,0 +1,11 @@
+export * from "./types.js";
+export * from "./canonical.js";
+export * from "./schema.js";
+export * from "./commands.js";
+export * from "./hardBreak.js";
+export * from "./resolveMarkRun.js";
+export * from "./normalization.js";
+export * from "./dom.js";
+export * from "./stored.js";
+export * from "./editor.js";
+export * from "./formats.js";

package/dist/foundation/marks/index.js

@@ -0,0 +1,11 @@
+export * from "./types.js";
+export * from "./canonical.js";
+export * from "./schema.js";
+export * from "./commands.js";
+export * from "./hardBreak.js";
+export * from "./resolveMarkRun.js";
+export * from "./normalization.js";
+export * from "./dom.js";
+export * from "./stored.js";
+export * from "./editor.js";
+export * from "./formats.js";

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

@@ -0,0 +1,2 @@
+import type { NormalizerRegistration } from "../types.js";
+export declare const createMarkNormalizer: () => NormalizerRegistration;

package/dist/foundation/marks/normalization.js

@@ -0,0 +1,49 @@
+import { isTextNode } from "../identity.js";
+import { nodeAtPath } from "../positions.js";
+import { canonicalMarkOrder, stableValue } from "./canonical.js";
+const normalizedInlineChildren = (children) => {
+    const output = [];
+    children.forEach((child) => {
+        if (isTextNode(child) && !child.text)
+            return;
+        const normalized = isTextNode(child) && child.marks?.length
+            ? { ...child, marks: canonicalMarkOrder(child.marks) }
+            : child;
+        const previous = output[output.length - 1];
+        if (isTextNode(normalized) && previous && isTextNode(previous)
+            && stableValue(previous.marks || []) === stableValue(normalized.marks || [])) {
+            output[output.length - 1] = { ...previous, text: previous.text + normalized.text };
+        }
+        else
+            output.push(normalized);
+    });
+    return output;
+};
+const inlineOwner = (node, schema) => schema.nodes[node.type]?.content?.includes("inline") === true;
+export const createMarkNormalizer = () => ({
+    id: "foundation.mark-normalization",
+    priority: 100,
+    normalize(document, context) {
+        const root = nodeAtPath(document, context.affectedPath);
+        if (!root || isTextNode(root))
+            return { operations: [] };
+        const operations = [];
+        const visit = (node, path) => {
+            if (inlineOwner(node, context.schema)) {
+                const children = normalizedInlineChildren(node.children || []);
+                if (stableValue(children) !== stableValue(node.children || []))
+                    operations.push({
+                        type: "replaceNode",
+                        pos: { path: path.slice(0, -1), offset: path[path.length - 1] },
+                        before: node,
+                        after: { ...node, children },
+                    });
+                return;
+            }
+            node.children?.forEach((child, index) => { if (!isTextNode(child))
+                visit(child, [...path, index]); });
+        };
+        visit(root, [...context.affectedPath]);
+        return { operations };
+    },
+});

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

@@ -0,0 +1,14 @@
+import { type PluginCommand, type ToolbarContribution } from "../plugin/types.js";
+import { inlineMarkSpecs } from "./schema.js";
+/**
+ * Wraps the seven existing, already-tested mark commands (marks/commands.ts)
+ * with the description Phase 10's doc generation needs. The commands
+ * themselves are unchanged - all are generic (apply/remove/toggle/setAttrs
+ * to any mark type via a `markType` param), so individual marks like bold
+ * or italic are not separate commands; they are toolbar/shortcut
+ * contributions that invoke the same command with a different `params`.
+ */
+export declare const markPluginCommands: Record<string, PluginCommand>;
+/** One toolbar contribution per inlineToolDeclarations entry (schema.ts), each invoking mark.toggle with that mark's type as params. */
+export declare const markToolbarContributions: readonly ToolbarContribution[];
+export { inlineMarkSpecs };

package/dist/foundation/marks/plugin.js

@@ -0,0 +1,63 @@
+import { definePluginCommand } from "../plugin/types.js";
+import { clearAllMarksCommand, editLinkCommand, removeLinkCommand, removeMarkCommand, applyMarkCommand, setMarkAttrsCommand, toggleMarkCommand, } from "./commands.js";
+import { inlineMarkSpecs, inlineToolDeclarations } from "./schema.js";
+/**
+ * Wraps the seven existing, already-tested mark commands (marks/commands.ts)
+ * with the description Phase 10's doc generation needs. The commands
+ * themselves are unchanged - all are generic (apply/remove/toggle/setAttrs
+ * to any mark type via a `markType` param), so individual marks like bold
+ * or italic are not separate commands; they are toolbar/shortcut
+ * contributions that invoke the same command with a different `params`.
+ */
+export const markPluginCommands = {
+    "mark.apply": definePluginCommand({
+        id: "mark.apply", run: applyMarkCommand,
+        description: "Applies a mark (e.g. bold, link) to the current inline selection, removing any mutually-excluded mark first.",
+        options: { markType: { description: "The mark type to apply, e.g. \"bold\" or \"link\".", required: true }, attrs: { description: "Mark attributes, if the mark type requires any (e.g. link's href)." } },
+    }),
+    "mark.remove": definePluginCommand({
+        id: "mark.remove", run: removeMarkCommand,
+        description: "Removes a mark type from the current inline selection.",
+        options: { markType: { description: "The mark type to remove.", required: true } },
+    }),
+    "mark.toggle": definePluginCommand({
+        id: "mark.toggle", run: toggleMarkCommand,
+        description: "Applies a mark, or removes it if the selection is already fully covered by it (params.coverage === \"all\").",
+        options: {
+            markType: { description: "The mark type to toggle.", required: true },
+            attrs: { description: "Mark attributes, if the mark type requires any." },
+            coverage: { description: "\"all\" when the selection is already fully covered by this mark - toggles it off instead of re-applying it." },
+        },
+        examples: [
+            { description: "Toggle bold on the current selection", params: { markType: "bold" } },
+            { description: "Toggle bold off, given the selection is already fully bold", params: { markType: "bold", coverage: "all" } },
+        ],
+    }),
+    "mark.setAttrs": definePluginCommand({
+        id: "mark.setAttrs", run: setMarkAttrsCommand,
+        description: "Sets a mark's attributes on the current selection (an alias of mark.apply - re-applying overwrites existing attributes).",
+        options: { markType: { description: "The mark type to update.", required: true }, attrs: { description: "The new attributes." } },
+    }),
+    "mark.clearAll": definePluginCommand({
+        id: "mark.clearAll", run: clearAllMarksCommand,
+        description: "Removes every mark present on the current inline selection, regardless of type.",
+    }),
+    "link.remove": definePluginCommand({
+        id: "link.remove", run: removeLinkCommand,
+        description: "Removes the link mark from the current selection, or from the link run at a collapsed caret inside one.",
+    }),
+    "link.edit": definePluginCommand({
+        id: "link.edit", run: editLinkCommand,
+        description: "Sets or replaces the link mark's href/target on the current selection, or on the link run at a collapsed caret inside one.",
+        options: { href: { description: "The link URL.", required: true }, target: { description: "The link's target attribute, e.g. \"_blank\"." } },
+        examples: [{ description: "Turn the selection into a link", params: { href: "https://example.com" } }],
+    }),
+};
+/** One toolbar contribution per inlineToolDeclarations entry (schema.ts), each invoking mark.toggle with that mark's type as params. */
+export const markToolbarContributions = inlineToolDeclarations.map((declaration) => ({
+    id: `marks.toolbar.${declaration.id}`,
+    commandId: "mark.toggle",
+    params: { markType: declaration.markType, coverage: "partial" },
+    label: declaration.id,
+}));
+export { inlineMarkSpecs };

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

@@ -0,0 +1,8 @@
+import type { SmartDocument, SmartMark, SmartPos, SmartRange } from "../types.js";
+export interface ResolvedMarkRun {
+    readonly mark: SmartMark;
+    readonly range: SmartRange;
+    readonly ownerNodeId: string;
+}
+/** Resolves the complete contiguous run for one exact mark at a collapsed position. */
+export declare const resolveMarkRun: (document: SmartDocument, pos: SmartPos, markType: string) => ResolvedMarkRun | null;

package/dist/foundation/marks/resolveMarkRun.js

@@ -0,0 +1,47 @@
+import { isTextNode } from "../identity.js";
+import { nodeAtPath } from "../positions.js";
+import { markKey } from "./canonical.js";
+/** Resolves the complete contiguous run for one exact mark at a collapsed position. */
+export const resolveMarkRun = (document, pos, markType) => {
+    const owner = nodeAtPath(document, pos.path);
+    if (!owner || isTextNode(owner))
+        return null;
+    let offset = 0;
+    const segments = (owner.children || []).map((node) => {
+        const from = offset;
+        offset += isTextNode(node) ? node.text.length : 1;
+        return { node, from, to: offset };
+    });
+    const active = [...segments].reverse().find((segment) => isTextNode(segment.node)
+        && segment.from < pos.offset && pos.offset <= segment.to
+        && segment.node.marks?.some((mark) => mark.type === markType))
+        ?? segments.find((segment) => isTextNode(segment.node)
+            && segment.from <= pos.offset && pos.offset < segment.to
+            && segment.node.marks?.some((mark) => mark.type === markType));
+    if (!active || !isTextNode(active.node))
+        return null;
+    const mark = active.node.marks?.find((candidate) => candidate.type === markType);
+    if (!mark)
+        return null;
+    const key = markKey(mark);
+    let from = active.from;
+    let to = active.to;
+    const index = segments.indexOf(active);
+    for (let cursor = index - 1; cursor >= 0; cursor -= 1) {
+        const segment = segments[cursor];
+        if (!isTextNode(segment.node) || !segment.node.marks?.some((candidate) => markKey(candidate) === key))
+            break;
+        from = segment.from;
+    }
+    for (let cursor = index + 1; cursor < segments.length; cursor += 1) {
+        const segment = segments[cursor];
+        if (!isTextNode(segment.node) || !segment.node.marks?.some((candidate) => markKey(candidate) === key))
+            break;
+        to = segment.to;
+    }
+    return {
+        mark,
+        ownerNodeId: owner.id,
+        range: { from: { path: [...pos.path], offset: from }, to: { path: [...pos.path], offset: to } },
+    };
+};

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

@@ -0,0 +1,167 @@
+export declare const inlineMarkSpecs: readonly [{
+    readonly type: "bold";
+    readonly inclusive: true;
+}, {
+    readonly type: "italic";
+    readonly inclusive: true;
+}, {
+    readonly type: "underline";
+    readonly inclusive: true;
+}, {
+    readonly type: "strike";
+    readonly inclusive: true;
+}, {
+    readonly type: "code";
+    readonly inclusive: true;
+}, {
+    readonly type: "superscript";
+    readonly inclusive: true;
+    readonly excludes: ["subscript"];
+}, {
+    readonly type: "subscript";
+    readonly inclusive: true;
+    readonly excludes: ["superscript"];
+}, {
+    readonly type: "textColor";
+    readonly inclusive: true;
+    readonly excludes: ["textColor"];
+    readonly attributes: {
+        readonly value: {
+            required: boolean;
+            validate: (value: unknown) => boolean;
+        };
+    };
+}, {
+    readonly type: "backgroundColor";
+    readonly inclusive: true;
+    readonly excludes: ["backgroundColor"];
+    readonly attributes: {
+        readonly value: {
+            required: boolean;
+            validate: (value: unknown) => boolean;
+        };
+    };
+}, {
+    readonly type: "fontSize";
+    readonly inclusive: true;
+    readonly excludes: ["fontSize"];
+    readonly attributes: {
+        readonly valuePx: {
+            required: boolean;
+            validate: (value: unknown) => boolean;
+        };
+    };
+}, {
+    readonly type: "fontFamily";
+    readonly inclusive: true;
+    readonly excludes: ["fontFamily"];
+    readonly attributes: {
+        readonly value: {
+            required: boolean;
+            validate: (value: unknown) => boolean;
+        };
+    };
+}, {
+    readonly type: "link";
+    readonly inclusive: false;
+    readonly excludes: ["link"];
+    readonly attributes: {
+        readonly href: {
+            required: boolean;
+            validate: (value: unknown) => boolean;
+        };
+        readonly target: {
+            readonly validate: (value: unknown) => boolean;
+        };
+    };
+}, {
+    readonly type: "suggestion";
+    readonly inclusive: false;
+    readonly attributes: {
+        readonly id: {
+            required: boolean;
+            validate: (value: unknown) => boolean;
+        };
+        readonly authorId: {
+            required: boolean;
+            validate: (value: unknown) => boolean;
+        };
+        readonly kind: {
+            readonly required: true;
+            readonly validate: (value: unknown) => value is "insert" | "delete";
+        };
+        readonly createdAt: {
+            required: boolean;
+            validate: (value: unknown) => boolean;
+        };
+    };
+}];
+/** A hard break is one inline cursor unit and never carries marks itself. */
+export declare const hardBreakNodeSpec: {
+    readonly type: "hard_break";
+    readonly group: "inline";
+    readonly atomic: true;
+    readonly selectable: false;
+    readonly marks: "";
+};
+export declare const inlineToolDeclarations: readonly [{
+    readonly id: "bold";
+    readonly markType: "bold";
+    readonly inclusive: true;
+}, {
+    readonly id: "italic";
+    readonly markType: "italic";
+    readonly inclusive: true;
+}, {
+    readonly id: "underline";
+    readonly markType: "underline";
+    readonly inclusive: true;
+}, {
+    readonly id: "strikethrough";
+    readonly markType: "strike";
+    readonly inclusive: true;
+}, {
+    readonly id: "inlineCode";
+    readonly markType: "code";
+    readonly inclusive: true;
+}, {
+    readonly id: "superscript";
+    readonly markType: "superscript";
+    readonly inclusive: true;
+    readonly excludes: readonly ["subscript"];
+}, {
+    readonly id: "subscript";
+    readonly markType: "subscript";
+    readonly inclusive: true;
+    readonly excludes: readonly ["superscript"];
+}, {
+    readonly id: "textColor";
+    readonly markType: "textColor";
+    readonly inclusive: true;
+    readonly excludes: readonly ["textColor"];
+    readonly validate: (attrs: Readonly<Record<string, unknown>> | undefined) => boolean;
+}, {
+    readonly id: "backgroundColor";
+    readonly markType: "backgroundColor";
+    readonly inclusive: true;
+    readonly excludes: readonly ["backgroundColor"];
+    readonly validate: (attrs: Readonly<Record<string, unknown>> | undefined) => boolean;
+}, {
+    readonly id: "fontSize";
+    readonly markType: "fontSize";
+    readonly inclusive: true;
+    readonly excludes: readonly ["fontSize"];
+    readonly validate: (attrs: Readonly<Record<string, unknown>> | undefined) => boolean;
+}, {
+    readonly id: "fontFamily";
+    readonly markType: "fontFamily";
+    readonly inclusive: true;
+    readonly excludes: readonly ["fontFamily"];
+    readonly validate: (attrs: Readonly<Record<string, unknown>> | undefined) => boolean;
+}, {
+    readonly id: "link";
+    readonly markType: "link";
+    readonly inclusive: false;
+    readonly excludes: readonly ["link"];
+    readonly validate: (attrs: Readonly<Record<string, unknown>> | undefined) => boolean;
+}];

package/dist/foundation/marks/schema.js

@@ -0,0 +1,50 @@
+import { normalizeLinkInput } from "../security/urlPolicy.js";
+import { canonicalColor, canonicalFontFamily, canonicalFontSize } from "./canonical.js";
+const stringValue = { required: true, validate: (value) => typeof value === "string" && Boolean(value) };
+const numberValue = { required: true, validate: (value) => typeof value === "number" && Number.isFinite(value) };
+export const inlineMarkSpecs = [
+    { type: "bold", inclusive: true },
+    { type: "italic", inclusive: true },
+    { type: "underline", inclusive: true },
+    { type: "strike", inclusive: true },
+    { type: "code", inclusive: true },
+    { type: "superscript", inclusive: true, excludes: ["subscript"] },
+    { type: "subscript", inclusive: true, excludes: ["superscript"] },
+    { type: "textColor", inclusive: true, excludes: ["textColor"], attributes: { value: stringValue } },
+    { type: "backgroundColor", inclusive: true, excludes: ["backgroundColor"], attributes: { value: stringValue } },
+    { type: "fontSize", inclusive: true, excludes: ["fontSize"], attributes: { valuePx: numberValue } },
+    { type: "fontFamily", inclusive: true, excludes: ["fontFamily"], attributes: { value: stringValue } },
+    { type: "link", inclusive: false, excludes: ["link"], attributes: {
+            href: stringValue,
+            target: { validate: (value) => typeof value === "string" && Boolean(value) },
+        } },
+    // Phase 12a §2.3: a proposed inline insert/delete, applied to real
+    // document text like any other mark rather than a separate not-yet-
+    // applied record. Not inclusive - typing at a suggestion's boundary
+    // should not silently extend someone else's (or an already-decided)
+    // proposal.
+    { type: "suggestion", inclusive: false, attributes: {
+            id: stringValue,
+            authorId: stringValue,
+            kind: { required: true, validate: (value) => value === "insert" || value === "delete" },
+            createdAt: numberValue,
+        } },
+];
+/** A hard break is one inline cursor unit and never carries marks itself. */
+export const hardBreakNodeSpec = {
+    type: "hard_break", group: "inline", atomic: true, selectable: false, marks: "",
+};
+export const inlineToolDeclarations = [
+    { id: "bold", markType: "bold", inclusive: true },
+    { id: "italic", markType: "italic", inclusive: true },
+    { id: "underline", markType: "underline", inclusive: true },
+    { id: "strikethrough", markType: "strike", inclusive: true },
+    { id: "inlineCode", markType: "code", inclusive: true },
+    { id: "superscript", markType: "superscript", inclusive: true, excludes: ["subscript"] },
+    { id: "subscript", markType: "subscript", inclusive: true, excludes: ["superscript"] },
+    { id: "textColor", markType: "textColor", inclusive: true, excludes: ["textColor"], validate: (attrs) => canonicalColor(attrs?.value) !== null },
+    { id: "backgroundColor", markType: "backgroundColor", inclusive: true, excludes: ["backgroundColor"], validate: (attrs) => canonicalColor(attrs?.value) !== null },
+    { id: "fontSize", markType: "fontSize", inclusive: true, excludes: ["fontSize"], validate: (attrs) => canonicalFontSize(attrs?.valuePx) !== null },
+    { id: "fontFamily", markType: "fontFamily", inclusive: true, excludes: ["fontFamily"], validate: (attrs) => canonicalFontFamily(attrs?.value) !== null },
+    { id: "link", markType: "link", inclusive: false, excludes: ["link"], validate: (attrs) => normalizeLinkInput(String(attrs?.href || "")).href !== null },
+];

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

@@ -0,0 +1,2 @@
+import type { SmartDocument, SmartMark, SmartPos, SmartSchema } from "../types.js";
+export declare const marksAtInsertion: (document: SmartDocument, pos: SmartPos, schema: SmartSchema) => SmartMark[];

package/dist/foundation/marks/stored.js

@@ -0,0 +1,31 @@
+import { isTextNode } from "../identity.js";
+import { nodeAtPath } from "../positions.js";
+import { canonicalMarkOrder } from "./canonical.js";
+export const marksAtInsertion = (document, pos, schema) => {
+    const owner = nodeAtPath(document, pos.path);
+    if (!owner || isTextNode(owner))
+        return [];
+    let offset = 0;
+    const segments = (owner.children || []).map((node) => {
+        const from = offset;
+        offset += isTextNode(node) ? node.text.length : 1;
+        return { node, from, to: offset };
+    });
+    const inside = segments.find((segment) => isTextNode(segment.node) && segment.from < pos.offset && pos.offset < segment.to);
+    if (inside && isTextNode(inside.node))
+        return canonicalMarkOrder(inside.node.marks);
+    const candidates = [
+        [...segments].reverse().find((segment) => isTextNode(segment.node) && segment.to === pos.offset),
+        segments.find((segment) => isTextNode(segment.node) && segment.from === pos.offset),
+    ];
+    const marks = new Map();
+    candidates.forEach((segment) => {
+        if (!segment || !isTextNode(segment.node))
+            return;
+        segment.node.marks?.forEach((mark) => {
+            if (schema.marks[mark.type]?.inclusive !== false)
+                marks.set(mark.type, mark);
+        });
+    });
+    return canonicalMarkOrder([...marks.values()]);
+};

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

@@ -0,0 +1,40 @@
+import type { ResolvedScope } from "../scope/types.js";
+import type { Attrs, SmartDocument, SmartOperation, SmartSchema } from "../types.js";
+import type { PositionLookup } from "../scope/types.js";
+export interface MarkCommandContext {
+    readonly schema: SmartSchema;
+    readonly positions: PositionLookup;
+}
+export type MarkCommand<P> = (document: SmartDocument, scope: ResolvedScope, params: P, ctx: MarkCommandContext) => SmartOperation[];
+export interface MarkApplyParams {
+    readonly markType: string;
+    readonly attrs?: Attrs;
+}
+export interface MarkRemoveParams {
+    readonly markType: string;
+}
+export interface MarkToggleParams extends MarkApplyParams {
+    /** Supplied from Phase 2 describe(); commands do not recompute coverage. */
+    readonly coverage: "all" | "partial" | "none";
+}
+export interface MarkSetAttrsParams extends MarkApplyParams {
+}
+export interface MarkClearAllParams {
+}
+export interface LinkEditParams {
+    readonly href: string;
+    readonly target?: string;
+}
+export interface InlineToolDeclaration {
+    readonly id: string;
+    readonly markType: string;
+    readonly inclusive: boolean;
+    readonly excludes?: readonly string[];
+    readonly validate?: (attrs: Attrs | undefined) => boolean;
+}
+export interface MarkApplicationReport {
+    readonly ownerCount: number;
+    readonly ownerIdsSkipped: readonly string[];
+    readonly atomOwnersSkipped: readonly string[];
+    readonly partial: boolean;
+}

package/dist/foundation/marks/types.js

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