smartrte-core 0.2.1 → 1.0.0-beta.1

package/dist/foundation/block/commands.js

@@ -0,0 +1,197 @@
+import { cloneNode, isTextNode } from "../identity.js";
+import { moveContiguousSiblings } from "../structural/move.js";
+const cleanAttrs = (attrs) => Object.fromEntries(Object.entries(attrs).filter(([, value]) => value !== undefined));
+const blockScopes = (scope) => {
+    if (scope.kind === "block-range")
+        return [scope];
+    if (scope.kind !== "mixed")
+        return [];
+    const collect = (mixed) => mixed.parts.flatMap((part) => part.kind === "block-range" ? [part] : part.kind === "mixed" ? collect(part) : []);
+    return collect(scope);
+};
+const selectedBlockIds = (scope) => [...new Set(blockScopes(scope).flatMap((entry) => entry.blockIds))];
+const locate = (nodeId, ctx) => {
+    const resolved = ctx.positions.positionOf(nodeId);
+    const node = resolved?.parent.children?.[resolved.pos.offset];
+    if (!resolved || !node || isTextNode(node) || node.id !== nodeId)
+        throw new Error(`Unknown or stale block ID "${nodeId}".`);
+    return { node, pos: { path: [...resolved.pos.path], offset: resolved.pos.offset } };
+};
+const semanticRole = (node, ctx) => ctx.schema.nodes[node.type]?.semanticRole || node.type;
+const ancestorWithRole = (nodeId, role, ctx) => {
+    const resolved = ctx.positions.positionOf(nodeId);
+    if (!resolved)
+        return null;
+    for (let index = resolved.ancestors.length - 1; index >= 0; index -= 1) {
+        const candidate = resolved.ancestors[index];
+        if (semanticRole(candidate, ctx) === role)
+            return candidate;
+    }
+    return null;
+};
+const ancestorTargets = (scope, role, ctx) => {
+    const targets = new Map();
+    selectedBlockIds(scope).forEach((nodeId) => {
+        const ancestor = ancestorWithRole(nodeId, role, ctx);
+        if (!ancestor || targets.has(ancestor.id))
+            return;
+        targets.set(ancestor.id, locate(ancestor.id, ctx));
+    });
+    return [...targets.values()].sort((left, right) => right.pos.path.length - left.pos.path.length || right.pos.offset - left.pos.offset);
+};
+const typeAttrs = (node, type, attrs) => {
+    const next = { ...(node.attrs || {}) };
+    delete next.level;
+    delete next.language;
+    Object.assign(next, attrs || {});
+    if (type === "heading" && next.level === undefined)
+        next.level = 1;
+    return cleanAttrs(next);
+};
+const uniqueMarks = (node) => {
+    const marks = new Map();
+    node.children?.forEach((child) => {
+        if (!isTextNode(child))
+            return;
+        child.marks?.forEach((mark) => marks.set(JSON.stringify(mark), mark));
+    });
+    return [...marks.values()];
+};
+export const setBlockTypeCommand = (_document, scope, params, ctx) => selectedBlockIds(scope).flatMap((nodeId) => {
+    const { node, pos } = locate(nodeId, ctx);
+    if (!["paragraph", "heading", "code_block"].includes(node.type))
+        return [];
+    const afterAttrs = typeAttrs(node, params.type, params.attrs);
+    if (node.type === params.type) {
+        return JSON.stringify(node.attrs || {}) === JSON.stringify(afterAttrs) ? [] : [{
+                type: "setNodeAttributes",
+                pos: { path: [...pos.path, pos.offset], offset: 0 },
+                before: node.attrs || {},
+                after: afterAttrs,
+            }];
+    }
+    const operations = [];
+    if (params.type === "code_block") {
+        const range = ctx.positions.contentRangeOf(node.id);
+        if (!range)
+            return [];
+        uniqueMarks(node).forEach((mark) => operations.push({ type: "removeMark", range, mark }));
+    }
+    operations.push({
+        type: "setNodeType",
+        pos: { path: [...pos.path, pos.offset], offset: 0 },
+        before: node.type,
+        after: params.type,
+        beforeAttrs: node.attrs || {},
+        afterAttrs,
+    });
+    return operations;
+});
+const groupedBlocks = (scope, ctx) => {
+    const entries = selectedBlockIds(scope).map((nodeId) => ({ nodeId, ...locate(nodeId, ctx) }));
+    const byParent = new Map();
+    entries.forEach((entry) => {
+        const key = JSON.stringify(entry.pos.path);
+        byParent.set(key, [...(byParent.get(key) || []), entry]);
+    });
+    return [...byParent.values()].map((group) => group.sort((a, b) => a.pos.offset - b.pos.offset))
+        .filter((group) => group.every((entry, index) => index === 0 || entry.pos.offset === group[index - 1].pos.offset + 1))
+        .sort((left, right) => right[0].pos.offset - left[0].pos.offset);
+};
+export const wrapBlocks = (_document, scope, params, ctx) => {
+    const groups = groupedBlocks(scope, ctx);
+    const listTargets = ancestorTargets(scope, "list", ctx);
+    const nonListGroups = groups.filter((group) => !ancestorWithRole(group[0].node.id, "list", ctx));
+    const targetCount = listTargets.length + nonListGroups.length;
+    if (params.wrapperIds.length < targetCount)
+        throw new Error(`block.wrap requires ${targetCount} caller-provided wrapper ID(s).`);
+    let wrapperCursor = 0;
+    const listOperations = listTargets.map(({ node, pos }) => {
+        const wrapper = {
+            type: params.type,
+            id: params.wrapperIds[wrapperCursor++],
+            ...(params.attrs && Object.keys(params.attrs).length ? { attrs: cleanAttrs(params.attrs) } : {}),
+            children: [cloneNode(node)],
+        };
+        return { type: "replaceNode", pos, before: node, after: wrapper };
+    });
+    const blockOperations = nonListGroups.flatMap((group) => {
+        const first = group[0];
+        const wrapper = {
+            type: params.type,
+            id: params.wrapperIds[wrapperCursor++],
+            ...(params.attrs && Object.keys(params.attrs).length ? { attrs: cleanAttrs(params.attrs) } : {}),
+            children: group.map((entry) => cloneNode(entry.node)),
+        };
+        const operations = [{ type: "replaceNode", pos: first.pos, before: first.node, after: wrapper }];
+        group.slice(1).forEach((entry) => operations.push({
+            type: "removeNode",
+            pos: { path: [...first.pos.path], offset: first.pos.offset + 1 },
+            node: entry.node,
+        }));
+        return operations;
+    });
+    return [...listOperations, ...blockOperations];
+};
+export const unwrapBlocks = (_document, scope, params, ctx) => {
+    const wrapperType = params.type || "blockquote";
+    const wrappers = new Map();
+    selectedBlockIds(scope).forEach((nodeId) => {
+        const selected = locate(nodeId, ctx);
+        const target = selected.node.type === wrapperType
+            ? selected.node
+            : ancestorWithRole(nodeId, wrapperType === "blockquote" ? "blockquote" : wrapperType, ctx);
+        if (!target || wrappers.has(target.id))
+            return;
+        wrappers.set(target.id, locate(target.id, ctx));
+    });
+    return [...wrappers.values()].sort((left, right) => right.pos.path.length - left.pos.path.length || right.pos.offset - left.pos.offset).flatMap(({ node, pos }) => {
+        if (node.type !== wrapperType)
+            return [];
+        const children = (node.children || []).filter((child) => !isTextNode(child));
+        if (!children.length)
+            return [];
+        const operations = [{ type: "replaceNode", pos, before: node, after: cloneNode(children[0]) }];
+        children.slice(1).forEach((child, index) => operations.push({
+            type: "insertNode",
+            pos: { path: [...pos.path], offset: pos.offset + index + 1 },
+            node: cloneNode(child),
+        }));
+        return operations;
+    });
+};
+export const setBlockAttributes = (_document, scope, params, ctx) => selectedBlockIds(scope).flatMap((nodeId) => {
+    const { node, pos } = locate(nodeId, ctx);
+    const after = cleanAttrs({ ...(node.attrs || {}), ...params.attrs });
+    return JSON.stringify(node.attrs || {}) === JSON.stringify(after) ? [] : [{
+            type: "setNodeAttributes",
+            pos: { path: [...pos.path, pos.offset], offset: 0 },
+            before: node.attrs || {},
+            after,
+        }];
+});
+export const moveBlockCommand = (_document, scope, params, ctx) => moveContiguousSiblings(selectedBlockIds(scope), params.direction, ctx);
+const changeIndent = (scope, amount, ctx) => selectedBlockIds(scope).flatMap((nodeId) => {
+    const { node, pos } = locate(nodeId, ctx);
+    const current = Number(node.attrs?.indentLevel) || 0;
+    const indentLevel = Math.max(0, Math.min(10, current + amount));
+    if (indentLevel === current)
+        return [];
+    return [{
+            type: "setNodeAttributes",
+            pos: { path: [...pos.path, pos.offset], offset: 0 },
+            before: node.attrs || {},
+            after: cleanAttrs({ ...(node.attrs || {}), indentLevel: indentLevel || undefined }),
+        }];
+});
+export const indentBlockCommand = (_document, scope, params, ctx) => changeIndent(scope, Math.max(1, params.amount || 1), ctx);
+export const outdentBlockCommand = (_document, scope, params, ctx) => changeIndent(scope, -Math.max(1, params.amount || 1), ctx);
+export const blockCommands = {
+    "block.setType": setBlockTypeCommand,
+    "block.wrap": wrapBlocks,
+    "block.unwrap": unwrapBlocks,
+    "block.setAttributes": setBlockAttributes,
+    "block.move": moveBlockCommand,
+    "block.indent": indentBlockCommand,
+    "block.outdent": outdentBlockCommand,
+};

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

@@ -0,0 +1,33 @@
+import { parseCanonicalListHtml, parseCanonicalListMarkdown, serializeCanonicalListHtml, serializeCanonicalListMarkdown } from "../list/formats.js";
+import type { SmartDocument, SmartElementNode } from "../types.js";
+export { parseCanonicalListHtml as parseCanonicalBlockHtml, parseCanonicalListMarkdown as parseCanonicalBlockMarkdown, serializeCanonicalListHtml as serializeCanonicalBlockHtml, serializeCanonicalListMarkdown as serializeCanonicalBlockMarkdown, };
+export interface CanonicalDocxBlock {
+    readonly nodeId: string;
+    readonly kind: "paragraph" | "heading" | "blockquote" | "code";
+    readonly text: string;
+    readonly style: string;
+    readonly outlineLevel?: number;
+    readonly alignment?: "left" | "center" | "right" | "justify";
+    /** DOCX left indentation in twips (720 twips per canonical indent level). */
+    readonly indentTwips?: number;
+    readonly language?: string;
+    readonly quoteDepth?: number;
+}
+/**
+ * The per-node half of canonicalBlocksToDocx's visit() body, matching
+ * FeatureFormatCodec.serialize's (node, ctx) => unknown shape
+ * (formats/codec.ts) - Phase 11 Tier 2's block codec slice. `quoteDepth`
+ * defaults to 0 for a direct single-node call (a codec invocation has no
+ * ancestor-walk context); canonicalBlocksToDocx below still owns tracking
+ * the real depth across a blockquote's descendants and passes it through.
+ * Returns null for a block type this mapping doesn't cover (e.g. `table`,
+ * `list`), matching FeatureFormatCodec.parse's null-for-inapplicable
+ * convention.
+ */
+export declare const blockToDocxEntry: (node: SmartElementNode, quoteDepth?: number) => CanonicalDocxBlock | null;
+/** Semantic DOCX mapping. Heading styles and paragraph properties are retained;
+ * unsupported custom visual CSS is deliberately not transported. */
+export declare const canonicalBlocksToDocx: (document: SmartDocument) => CanonicalDocxBlock[];
+/** PDF fidelity is visual-only; this deterministic text projection is used by
+ * fixture tests and by render adapters as the non-destructive fallback. */
+export declare const canonicalBlocksPdfText: (document: SmartDocument) => string;

package/dist/foundation/block/formats.js

@@ -0,0 +1,57 @@
+import { isTextNode } from "../identity.js";
+import { parseCanonicalListHtml, parseCanonicalListMarkdown, serializeCanonicalListHtml, serializeCanonicalListMarkdown, } from "../list/formats.js";
+export { parseCanonicalListHtml as parseCanonicalBlockHtml, parseCanonicalListMarkdown as parseCanonicalBlockMarkdown, serializeCanonicalListHtml as serializeCanonicalBlockHtml, serializeCanonicalListMarkdown as serializeCanonicalBlockMarkdown, };
+const textOf = (node) => (node.children || []).map((child) => isTextNode(child) ? child.text : child.type === "hard_break" ? "\n" : "").join("");
+/**
+ * The per-node half of canonicalBlocksToDocx's visit() body, matching
+ * FeatureFormatCodec.serialize's (node, ctx) => unknown shape
+ * (formats/codec.ts) - Phase 11 Tier 2's block codec slice. `quoteDepth`
+ * defaults to 0 for a direct single-node call (a codec invocation has no
+ * ancestor-walk context); canonicalBlocksToDocx below still owns tracking
+ * the real depth across a blockquote's descendants and passes it through.
+ * Returns null for a block type this mapping doesn't cover (e.g. `table`,
+ * `list`), matching FeatureFormatCodec.parse's null-for-inapplicable
+ * convention.
+ */
+export const blockToDocxEntry = (node, quoteDepth = 0) => {
+    if (!["paragraph", "heading", "code_block"].includes(node.type))
+        return null;
+    const level = node.type === "heading" ? Math.max(1, Math.min(6, Number(node.attrs?.level) || 1)) : undefined;
+    const alignment = typeof node.attrs?.align === "string" && ["left", "center", "right", "justify"].includes(node.attrs.align)
+        ? node.attrs.align : undefined;
+    const indentLevel = Math.max(0, Number(node.attrs?.indentLevel) || 0);
+    return {
+        nodeId: node.id,
+        kind: node.type === "code_block" ? "code" : node.type === "heading" ? "heading" : "paragraph",
+        text: textOf(node),
+        style: node.type === "heading" ? `Heading${level}` : node.type === "code_block" ? "Code" : quoteDepth ? "Quote" : "Normal",
+        ...(level ? { outlineLevel: level - 1 } : {}),
+        ...(alignment ? { alignment } : {}),
+        ...(indentLevel ? { indentTwips: indentLevel * 720 } : {}),
+        ...(node.type === "code_block" && typeof node.attrs?.language === "string" ? { language: node.attrs.language } : {}),
+        ...(quoteDepth ? { quoteDepth } : {}),
+    };
+};
+/** Semantic DOCX mapping. Heading styles and paragraph properties are retained;
+ * unsupported custom visual CSS is deliberately not transported. */
+export const canonicalBlocksToDocx = (document) => {
+    const output = [];
+    const visit = (node, quoteDepth = 0) => {
+        if (node.type === "blockquote") {
+            (node.children || []).forEach((child) => { if (!isTextNode(child))
+                visit(child, quoteDepth + 1); });
+            return;
+        }
+        const entry = blockToDocxEntry(node, quoteDepth);
+        if (entry)
+            output.push(entry);
+    };
+    document.children.forEach((node) => { if (!isTextNode(node))
+        visit(node); });
+    return output;
+};
+/** PDF fidelity is visual-only; this deterministic text projection is used by
+ * fixture tests and by render adapters as the non-destructive fallback. */
+export const canonicalBlocksPdfText = (document) => canonicalBlocksToDocx(document)
+    .map((block) => `${block.kind === "heading" ? `${"#".repeat((block.outlineLevel || 0) + 1)} ` : ""}${block.quoteDepth ? `${"> ".repeat(block.quoteDepth)}` : ""}${block.text}`)
+    .join("\n");

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

@@ -0,0 +1,5 @@
+export * from "./types.js";
+export * from "./schema.js";
+export * from "./commands.js";
+export * from "./input.js";
+export * from "./formats.js";

package/dist/foundation/block/index.js

@@ -0,0 +1,5 @@
+export * from "./types.js";
+export * from "./schema.js";
+export * from "./commands.js";
+export * from "./input.js";
+export * from "./formats.js";

package/dist/foundation/block/input.d.ts

@@ -0,0 +1,19 @@
+import type { SmartDocument, SmartOperation, SmartPos } from "../types.js";
+import type { BlockCommandContext } from "./types.js";
+export interface CodeBlockInputResult {
+    readonly operations: SmartOperation[];
+    readonly selectionTarget: {
+        readonly ownerId: string;
+        readonly offset: number;
+    };
+    readonly intent: "newline" | "indent" | "exit-before" | "exit-after" | "fragment";
+}
+export declare const insertCodeBlockNewline: (document: SmartDocument, pos: SmartPos, options?: {
+    readonly exitOnTrailingEmptyLine?: boolean;
+    readonly paragraphId?: string;
+}) => CodeBlockInputResult | null;
+export declare const indentInsideCodeBlock: (document: SmartDocument, pos: SmartPos) => CodeBlockInputResult | null;
+/** Ctrl/Cmd+Enter exits before only at offset zero; otherwise it exits after. */
+export declare const exitCodeBlock: (document: SmartDocument, pos: SmartPos, paragraphId?: string) => CodeBlockInputResult | null;
+/** Canonical fragment insertion only; Phase 8 owns clipboard parsing. */
+export declare const insertPlainCodeFragment: (document: SmartDocument, pos: SmartPos, fragment: SmartDocument, _ctx: BlockCommandContext) => CodeBlockInputResult | null;

package/dist/foundation/block/input.js

@@ -0,0 +1,67 @@
+import { createNodeId, isTextNode } from "../identity.js";
+import { nodeAtPath } from "../positions.js";
+const codeAt = (document, pos) => {
+    const node = nodeAtPath(document, pos.path);
+    return node && !isTextNode(node) && node.type === "code_block" ? node : null;
+};
+const textOf = (node) => {
+    if (isTextNode(node))
+        return node.text;
+    if (node.type === "hard_break")
+        return "\n";
+    return (node.children || []).map(textOf).join(node.type === "doc" || node.type === "blockquote" ? "\n" : "");
+};
+export const insertCodeBlockNewline = (document, pos, options = {}) => {
+    const code = codeAt(document, pos);
+    if (!code)
+        return null;
+    const text = textOf(code);
+    if (options.exitOnTrailingEmptyLine && pos.offset === text.length && text.endsWith("\n")) {
+        return exitCodeBlock(document, pos, options.paragraphId || createNodeId());
+    }
+    return {
+        operations: [{ type: "insertText", pos, text: "\n" }],
+        selectionTarget: { ownerId: code.id, offset: pos.offset + 1 },
+        intent: "newline",
+    };
+};
+export const indentInsideCodeBlock = (document, pos) => {
+    const code = codeAt(document, pos);
+    if (!code)
+        return null;
+    return {
+        operations: [{ type: "insertText", pos, text: "\t" }],
+        selectionTarget: { ownerId: code.id, offset: pos.offset + 1 },
+        intent: "indent",
+    };
+};
+/** Ctrl/Cmd+Enter exits before only at offset zero; otherwise it exits after. */
+export const exitCodeBlock = (document, pos, paragraphId = createNodeId()) => {
+    const code = codeAt(document, pos);
+    if (!code || !pos.path.length)
+        return null;
+    const parentPath = pos.path.slice(0, -1);
+    const codeIndex = pos.path[pos.path.length - 1];
+    const before = pos.offset === 0;
+    return {
+        operations: [{
+                type: "insertNode",
+                pos: { path: parentPath, offset: codeIndex + (before ? 0 : 1) },
+                node: { type: "paragraph", id: paragraphId, children: [] },
+            }],
+        selectionTarget: { ownerId: paragraphId, offset: 0 },
+        intent: before ? "exit-before" : "exit-after",
+    };
+};
+/** Canonical fragment insertion only; Phase 8 owns clipboard parsing. */
+export const insertPlainCodeFragment = (document, pos, fragment, _ctx) => {
+    const code = codeAt(document, pos);
+    if (!code)
+        return null;
+    const text = fragment.children.map(textOf).join("\n");
+    return {
+        operations: text ? [{ type: "insertText", pos, text }] : [],
+        selectionTarget: { ownerId: code.id, offset: pos.offset + text.length },
+        intent: "fragment",
+    };
+};

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

@@ -0,0 +1,26 @@
+import { type KeyboardShortcutContribution, type PluginCommand, type ToolbarContribution } from "../plugin/types.js";
+/**
+ * Wraps the seven existing, already-tested block commands (block/commands.ts)
+ * with the description Phase 10's doc generation needs.
+ */
+export declare const blockPluginCommands: Record<string, PluginCommand>;
+/**
+ * Tab inside a code block always wins over list indent/outdent (priority
+ * 20 > 10); Tab inside a list wins unless the caret is also in a table (the
+ * list command itself has nothing to do outside a list-selection scope, so
+ * it naturally yields); nothing is declared for table-grid, so Tab inside a
+ * table falls through to native browser/table-cell navigation, unchanged.
+ * This reproduces surface/input.ts's pre-Phase-11-Tier-0 hardcoded Tab
+ * precedence, now data-driven - see plugin/dispatch.ts's resolveShortcut.
+ */
+export declare const blockPluginShortcuts: readonly KeyboardShortcutContribution[];
+/**
+ * One toolbar contribution per blockToolDeclarations entry that needs no
+ * caller-generated ids at invocation time (every "setType" and
+ * "setAttributes" declaration - headings, paragraph, code block, and the
+ * four alignments). The "wrapToggle" (blockquote) declaration needs fresh
+ * wrapperIds per invocation, which a static toolbar contribution's params
+ * cannot supply, so it is intentionally not represented here - a UI layer
+ * invokes block.wrap directly once it has generated ids.
+ */
+export declare const blockToolbarContributions: readonly ToolbarContribution[];

package/dist/foundation/block/plugin.js

@@ -0,0 +1,79 @@
+import { definePluginCommand } from "../plugin/types.js";
+import { indentBlockCommand, moveBlockCommand, outdentBlockCommand, setBlockAttributes, setBlockTypeCommand, unwrapBlocks, wrapBlocks, } from "./commands.js";
+import { indentInsideCodeBlock } from "./input.js";
+import { blockToolDeclarations } from "./schema.js";
+/**
+ * Wraps the seven existing, already-tested block commands (block/commands.ts)
+ * with the description Phase 10's doc generation needs.
+ */
+export const blockPluginCommands = {
+    "block.setType": definePluginCommand({
+        id: "block.setType", run: setBlockTypeCommand,
+        description: "Converts the selected blocks to a different type (paragraph, heading, or code block), preserving IDs and inline content where the target type allows it.",
+        options: { type: { description: "The target block type.", required: true }, attrs: { description: "Attributes for the new type, e.g. heading level." } },
+        examples: [{ description: "Convert the selection to a level-2 heading", params: { type: "heading", attrs: { level: 2 } } }],
+    }),
+    "block.wrap": definePluginCommand({
+        id: "block.wrap", run: wrapBlocks,
+        description: "Wraps the selected blocks in a blockquote, one wrapper per contiguous group.",
+        options: { type: { description: "Currently only \"blockquote\".", required: true }, wrapperIds: { description: "Caller-provided ids, one per wrapper node created.", required: true } },
+    }),
+    "block.unwrap": definePluginCommand({
+        id: "block.unwrap", run: unwrapBlocks,
+        description: "Removes the enclosing blockquote (or other wrapper) from the selected blocks, promoting their content back out.",
+    }),
+    "block.setAttributes": definePluginCommand({
+        id: "block.setAttributes", run: setBlockAttributes,
+        description: "Sets attributes (e.g. alignment, indent level) on the selected blocks.",
+        options: { attrs: { description: "The attributes to set.", required: true } },
+        examples: [{ description: "Center-align the selected blocks", params: { attrs: { align: "center" } } }],
+    }),
+    "block.move": definePluginCommand({
+        id: "block.move", run: moveBlockCommand,
+        description: "Moves the selected contiguous blocks up or down among their siblings.",
+        options: { direction: { description: "\"up\" or \"down\".", required: true } },
+    }),
+    "block.indent": definePluginCommand({
+        id: "block.indent", run: indentBlockCommand,
+        description: "Increases the selected blocks' indent level.",
+        options: { amount: { description: "How many levels to indent by (default 1)." } },
+    }),
+    "block.outdent": definePluginCommand({
+        id: "block.outdent", run: outdentBlockCommand,
+        description: "Decreases the selected blocks' indent level.",
+        options: { amount: { description: "How many levels to outdent by (default 1)." } },
+    }),
+    "block.code.indentTab": definePluginCommand({
+        id: "block.code.indentTab", run: (document, scope) => scope.kind === "block-range" ? indentInsideCodeBlock(document, scope.range.to)?.operations ?? [] : [],
+        description: "Inserts a literal tab character at the caret when it is inside a code block; produces no operations otherwise.",
+    }),
+};
+/**
+ * Tab inside a code block always wins over list indent/outdent (priority
+ * 20 > 10); Tab inside a list wins unless the caret is also in a table (the
+ * list command itself has nothing to do outside a list-selection scope, so
+ * it naturally yields); nothing is declared for table-grid, so Tab inside a
+ * table falls through to native browser/table-cell navigation, unchanged.
+ * This reproduces surface/input.ts's pre-Phase-11-Tier-0 hardcoded Tab
+ * precedence, now data-driven - see plugin/dispatch.ts's resolveShortcut.
+ */
+export const blockPluginShortcuts = [
+    { id: "block.code.indentTab", commandId: "block.code.indentTab", key: "Tab", scopeKinds: ["block-range"], priority: 20 },
+];
+/**
+ * One toolbar contribution per blockToolDeclarations entry that needs no
+ * caller-generated ids at invocation time (every "setType" and
+ * "setAttributes" declaration - headings, paragraph, code block, and the
+ * four alignments). The "wrapToggle" (blockquote) declaration needs fresh
+ * wrapperIds per invocation, which a static toolbar contribution's params
+ * cannot supply, so it is intentionally not represented here - a UI layer
+ * invokes block.wrap directly once it has generated ids.
+ */
+export const blockToolbarContributions = blockToolDeclarations
+    .filter((declaration) => declaration.kind === "setType" || declaration.kind === "setAttributes")
+    .map((declaration) => ({
+    id: `block.toolbar.${declaration.id}`,
+    commandId: declaration.kind === "setType" ? "block.setType" : "block.setAttributes",
+    params: declaration.kind === "setType" ? { type: declaration.type, attrs: "attrs" in declaration ? declaration.attrs : undefined } : { attrs: "attrs" in declaration ? declaration.attrs : undefined },
+    label: declaration.id,
+}));

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

@@ -0,0 +1,49 @@
+import type { Attrs, NodeSpec } from "../types.js";
+/** Node specs owned by the block family - extracted out of foundation/schema.ts's previously hardcoded foundationSchema literal (Phase 10). */
+export declare const blockNodeSpecs: readonly NodeSpec[];
+export declare const blockToolDeclarations: readonly [...{
+    id: string;
+    kind: "setType";
+    type: "heading";
+    attrs: {
+        level: number;
+    };
+    validate: (attrs: Attrs | undefined) => boolean;
+}[], {
+    readonly id: "paragraph";
+    readonly kind: "setType";
+    readonly type: "paragraph";
+}, {
+    readonly id: "codeBlock";
+    readonly kind: "setType";
+    readonly type: "code_block";
+}, {
+    readonly id: "blockquote";
+    readonly kind: "wrapToggle";
+    readonly type: "blockquote";
+    readonly nestable: true;
+}, {
+    readonly id: "alignLeft";
+    readonly kind: "setAttributes";
+    readonly attrs: {
+        readonly align: "left";
+    };
+}, {
+    readonly id: "alignCenter";
+    readonly kind: "setAttributes";
+    readonly attrs: {
+        readonly align: "center";
+    };
+}, {
+    readonly id: "alignRight";
+    readonly kind: "setAttributes";
+    readonly attrs: {
+        readonly align: "right";
+    };
+}, {
+    readonly id: "alignJustify";
+    readonly kind: "setAttributes";
+    readonly attrs: {
+        readonly align: "justify";
+    };
+}];

package/dist/foundation/block/schema.js

@@ -0,0 +1,27 @@
+const stringAttr = { validate: (value) => typeof value === "string" };
+const alignmentAttr = { validate: (value) => ["left", "center", "right", "justify"].includes(String(value)) };
+const indentLevelAttr = { validate: (value) => Number.isInteger(value) && Number(value) >= 0 && Number(value) <= 10 };
+const blockAttrs = { align: alignmentAttr, indentLevel: indentLevelAttr };
+/** Node specs owned by the block family - extracted out of foundation/schema.ts's previously hardcoded foundationSchema literal (Phase 10). */
+export const blockNodeSpecs = [
+    { type: "paragraph", group: "block", content: "inline*", attributes: blockAttrs },
+    { type: "heading", group: "block", content: "inline*", attributes: { ...blockAttrs, level: { required: true, default: 1, validate: (v) => Number.isInteger(v) && Number(v) >= 1 && Number(v) <= 6 } } },
+    { type: "blockquote", group: "block", content: "block+", attributes: blockAttrs, defining: true },
+    { type: "code_block", group: "block", content: "text*", marks: "", attributes: { ...blockAttrs, language: stringAttr }, defining: true },
+];
+export const blockToolDeclarations = [
+    ...Array.from({ length: 6 }, (_, index) => ({
+        id: `heading${index + 1}`,
+        kind: "setType",
+        type: "heading",
+        attrs: { level: index + 1 },
+        validate: (attrs) => Number.isInteger(attrs?.level) && Number(attrs?.level) >= 1 && Number(attrs?.level) <= 6,
+    })),
+    { id: "paragraph", kind: "setType", type: "paragraph" },
+    { id: "codeBlock", kind: "setType", type: "code_block" },
+    { id: "blockquote", kind: "wrapToggle", type: "blockquote", nestable: true },
+    { id: "alignLeft", kind: "setAttributes", attrs: { align: "left" } },
+    { id: "alignCenter", kind: "setAttributes", attrs: { align: "center" } },
+    { id: "alignRight", kind: "setAttributes", attrs: { align: "right" } },
+    { id: "alignJustify", kind: "setAttributes", attrs: { align: "justify" } },
+];

package/dist/foundation/block/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 BlockCommandContext {
+    readonly schema: SmartSchema;
+    readonly positions: PositionLookup;
+}
+export type BlockCommand<P> = (document: SmartDocument, scope: ResolvedScope, params: P, ctx: BlockCommandContext) => SmartOperation[];
+export interface SetBlockTypeParams {
+    readonly type: "paragraph" | "heading" | "code_block";
+    readonly attrs?: Attrs;
+}
+export interface WrapBlocksParams {
+    readonly type: "blockquote";
+    readonly attrs?: Attrs;
+    readonly wrapperIds: readonly string[];
+}
+export interface UnwrapBlocksParams {
+    readonly type?: "blockquote";
+}
+export interface SetBlockAttributesParams {
+    readonly attrs: Attrs;
+}
+export interface MoveBlocksParams {
+    readonly direction: "up" | "down";
+}
+export interface IndentBlocksParams {
+    readonly amount?: number;
+}
+export interface OutdentBlocksParams {
+    readonly amount?: number;
+}
+export interface BlockToolDeclaration {
+    readonly id: string;
+    readonly kind: "setType" | "wrapToggle" | "setAttributes";
+    readonly type?: "paragraph" | "heading" | "code_block" | "blockquote";
+    readonly attrs?: Attrs;
+    readonly nestable?: boolean;
+    readonly validate?: (attrs: Attrs | undefined) => boolean;
+}

package/dist/foundation/block/types.js

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

package/dist/foundation/boundaries.d.ts

@@ -0,0 +1,11 @@
+import type { NormalizerRegistration, SmartDocument, SmartOperation, SmartSchema } from "./types.js";
+/**
+ * Returns deterministic insert operations for missing outside-edge caret
+ * blocks.  The traversal is scoped by the supplied root path, allowing the
+ * normalizer to remain local for ordinary typing.
+ */
+export declare const editableBoundaryOperations: (document: SmartDocument, schema: SmartSchema, rootPath?: readonly number[]) => SmartOperation[];
+export interface EditableBoundaryNormalizerOptions {
+    readonly priority?: number;
+}
+export declare const createEditableBoundaryNormalizer: (options?: EditableBoundaryNormalizerOptions) => NormalizerRegistration;