smartrte-core 0.2.1 → 1.0.0-beta.2

package/dist/foundation/table/grid.js

@@ -0,0 +1,178 @@
+import { createNodeId, isTextNode } from "../identity.js";
+const positiveInt = (value) => Number.isInteger(value) && Number(value) > 0 ? Number(value) : 1;
+const role = (node, wanted) => node.type === wanted;
+const rowsOf = (table) => (table.children || []).filter((node) => !isTextNode(node) && role(node, "table_row"));
+const cellsOf = (row) => (row.children || []).filter((node) => !isTextNode(node) && role(node, "table_cell"));
+const intersects = (cell, rect) => cell.top < rect.bottom && cell.bottom > rect.top && cell.left < rect.right && cell.right > rect.left;
+const contained = (cell, rect) => cell.top >= rect.top && cell.bottom <= rect.bottom && cell.left >= rect.left && cell.right <= rect.right;
+const cache = new WeakMap();
+export const occupancyGridFor = (table) => {
+    const cached = cache.get(table);
+    if (cached)
+        return cached;
+    const rows = rowsOf(table);
+    const slots = Array.from({ length: rows.length }, () => []);
+    const anchors = [];
+    rows.forEach((row, rowIndex) => {
+        let column = 0;
+        cellsOf(row).forEach((node, childIndex) => {
+            while (slots[rowIndex]?.[column])
+                column += 1;
+            const rowspan = positiveInt(node.attrs?.rowspan);
+            const colspan = positiveInt(node.attrs?.colspan);
+            const cell = {
+                cellId: node.id, top: rowIndex, left: column,
+                bottom: rowIndex + rowspan, right: column + colspan,
+                isAnchor: true, rowIndex, childIndex, node,
+            };
+            anchors.push(cell);
+            for (let r = cell.top; r < cell.bottom; r += 1) {
+                slots[r] || (slots[r] = []);
+                for (let c = cell.left; c < cell.right; c += 1)
+                    if (!slots[r][c])
+                        slots[r][c] = r === cell.top && c === cell.left
+                            ? cell
+                            : { ...cell, isAnchor: false };
+            }
+            column += colspan;
+        });
+    });
+    const columns = slots.reduce((width, row) => Math.max(width, row.length), 0);
+    const grid = Object.freeze({
+        tableId: table.id,
+        rows: rows.length,
+        columns,
+        anchors: Object.freeze(anchors),
+        at: (row, col) => slots[row]?.[col] || null,
+        anchorsIn: (rect) => anchors.filter((cell) => contained(cell, rect)),
+        coveredIn: (rect) => anchors.filter((cell) => intersects(cell, rect) && !contained(cell, rect)),
+        isRectangular: (rect) => {
+            if (rect.top < 0 || rect.left < 0 || rect.bottom > rows.length || rect.right > columns || rect.top >= rect.bottom || rect.left >= rect.right)
+                return false;
+            for (let row = rect.top; row < rect.bottom; row += 1)
+                for (let col = rect.left; col < rect.right; col += 1) {
+                    const cell = slots[row]?.[col];
+                    if (!cell || !contained(cell, rect))
+                        return false;
+                }
+            return true;
+        },
+    });
+    cache.set(table, grid);
+    return grid;
+};
+export const validateTableGeometry = (table) => {
+    const issues = [];
+    const rows = rowsOf(table);
+    const slots = Array.from({ length: rows.length }, () => []);
+    rows.forEach((row, rowIndex) => {
+        let column = 0;
+        cellsOf(row).forEach((cell) => {
+            while (slots[rowIndex]?.[column])
+                column += 1;
+            const rowspan = positiveInt(cell.attrs?.rowspan);
+            const colspan = positiveInt(cell.attrs?.colspan);
+            if (rowIndex + rowspan > rows.length)
+                issues.push({ code: "overhang", row: rowIndex, column, cellId: cell.id, message: "Cell rowspan extends beyond the table." });
+            for (let r = rowIndex; r < Math.min(rows.length, rowIndex + rowspan); r += 1)
+                for (let c = column; c < column + colspan; c += 1) {
+                    if (slots[r]?.[c])
+                        issues.push({ code: "overlap", row: r, column: c, cellId: cell.id, message: "Two cells claim one logical coordinate." });
+                    else
+                        slots[r][c] = cell.id;
+                }
+            column += colspan;
+        });
+    });
+    const width = slots.reduce((max, row) => Math.max(max, row.length), 0);
+    slots.forEach((row, rowIndex) => {
+        if (row.length !== width)
+            issues.push({ code: "unequal-width", row: rowIndex, message: "Rows do not materialize the same logical width." });
+        for (let col = 0; col < width; col += 1)
+            if (!row[col])
+                issues.push({ code: "hole", row: rowIndex, column: col, message: "Logical coordinate is unclaimed." });
+    });
+    const grid = occupancyGridFor(table);
+    let leadingHeaderRows = 0;
+    while (leadingHeaderRows < grid.rows && Array.from({ length: grid.columns }, (_, col) => grid.at(leadingHeaderRows, col)?.node.attrs?.header === true).every(Boolean))
+        leadingHeaderRows += 1;
+    let leadingHeaderColumns = 0;
+    while (leadingHeaderColumns < grid.columns && Array.from({ length: grid.rows }, (_, row) => grid.at(row, leadingHeaderColumns)?.node.attrs?.header === true).every(Boolean))
+        leadingHeaderColumns += 1;
+    for (let row = 0; row < grid.rows; row += 1) {
+        for (let col = 0; col < grid.columns; col += 1) {
+            const header = grid.at(row, col)?.node.attrs?.header === true;
+            const expected = row < leadingHeaderRows || col < leadingHeaderColumns;
+            if (header !== expected)
+                issues.push({ code: "noncontiguous-header", row, column: col, cellId: grid.at(row, col)?.cellId, message: "Header cells must be the union of contiguous leading rows and columns." });
+        }
+    }
+    return issues;
+};
+const emptyCell = (cellId = createNodeId(), paragraphId = createNodeId()) => ({
+    type: "table_cell", id: cellId, attrs: { colspan: 1, rowspan: 1, header: false },
+    children: [{ type: "paragraph", id: paragraphId, children: [] }],
+});
+export const repairTableGeometry = (table) => {
+    const repairs = validateTableGeometry(table);
+    if (!repairs.length)
+        return { table, repairs };
+    const sourceRows = rowsOf(table);
+    const slots = Array.from({ length: sourceRows.length }, () => []);
+    const placements = [];
+    sourceRows.forEach((row, rowIndex) => {
+        let column = 0;
+        cellsOf(row).forEach((cell) => {
+            const rowspan = Math.min(positiveInt(cell.attrs?.rowspan), sourceRows.length - rowIndex);
+            const colspan = positiveInt(cell.attrs?.colspan);
+            const fits = (left) => {
+                for (let r = rowIndex; r < rowIndex + rowspan; r += 1)
+                    for (let c = left; c < left + colspan; c += 1)
+                        if (slots[r]?.[c])
+                            return false;
+                return true;
+            };
+            while (!fits(column))
+                column += 1;
+            const normalized = { ...cell, attrs: { ...(cell.attrs || {}), rowspan, colspan, header: cell.attrs?.header === true } };
+            placements.push({ row: rowIndex, column, rowspan, colspan, cell: normalized });
+            for (let r = rowIndex; r < rowIndex + rowspan; r += 1)
+                for (let c = column; c < column + colspan; c += 1)
+                    slots[r][c] = normalized;
+            column += colspan;
+        });
+    });
+    let width = slots.reduce((max, row) => Math.max(max, row.length), 0);
+    for (let row = 0; row < sourceRows.length; row += 1)
+        for (let col = 0; col < width; col += 1)
+            if (!slots[row][col]) {
+                const cell = emptyCell();
+                placements.push({ row, column: col, rowspan: 1, colspan: 1, cell });
+                slots[row][col] = cell;
+            }
+    width = slots.reduce((max, row) => Math.max(max, row.length), width);
+    // Preserve only header cells that already form complete leading rows or
+    // columns. A stray Word header in the middle is demoted; promoting all rows
+    // before it changes document semantics and surprises screen-reader users.
+    let headerRows = 0;
+    while (headerRows < sourceRows.length && Array.from({ length: width }, (_, col) => slots[headerRows]?.[col]?.attrs?.header === true).every(Boolean))
+        headerRows += 1;
+    let headerColumns = 0;
+    while (headerColumns < width && Array.from({ length: sourceRows.length }, (_, row) => slots[row]?.[headerColumns]?.attrs?.header === true).every(Boolean))
+        headerColumns += 1;
+    const keepHeader = new Set();
+    for (let row = 0; row < sourceRows.length; row += 1)
+        for (let col = 0; col < width; col += 1) {
+            const owner = slots[row]?.[col];
+            if (owner?.attrs?.header === true && (row < headerRows || col < headerColumns))
+                keepHeader.add(owner.id);
+        }
+    const rows = sourceRows.map((row, rowIndex) => ({
+        ...row,
+        children: placements.filter((placement) => placement.row === rowIndex).sort((a, b) => a.column - b.column).map(({ cell, rowspan, colspan }) => ({
+            ...cell,
+            attrs: { ...(cell.attrs || {}), rowspan, colspan, header: keepHeader.has(cell.id) },
+        })),
+    }));
+    return { table: { ...table, children: rows }, repairs };
+};

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

@@ -0,0 +1,6 @@
+export * from "./types.js";
+export * from "./schema.js";
+export * from "./grid.js";
+export * from "./commands.js";
+export * from "./formats.js";
+export * from "./selection.js";

package/dist/foundation/table/index.js

@@ -0,0 +1,6 @@
+export * from "./types.js";
+export * from "./schema.js";
+export * from "./grid.js";
+export * from "./commands.js";
+export * from "./formats.js";
+export * from "./selection.js";

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

@@ -0,0 +1,23 @@
+import { type ContextMenuContribution, type PluginCommand } from "../plugin/types.js";
+/**
+ * Wraps the fourteen existing, already-tested table commands
+ * (table/commands.ts's tableCommands) with the description Phase 10's doc
+ * generation needs. Every one already emits Phase 8c's fine-grained
+ * operations (insertNode/removeNode/moveNode/setNodeAttributes scoped to
+ * the affected row/cell, plus a cell-scoped replaceNode for merge) - this
+ * wrap does not touch that, it only adds metadata around commands that are
+ * already, individually, exactly what a PluginCommand's `run` needs.
+ */
+export declare const tablePluginCommands: Record<string, PluginCommand>;
+/**
+ * Phase 11.5 §2.3: table.insertRow/table.insertColumn need caller-generated
+ * ids (rowId/cellIds/paragraphIds) that can't live in a static `params` -
+ * the dispatching UI must merge fresh ids in at invocation time, the same
+ * way surface/input.ts's Tab handling special-cases list.indent/outdent's
+ * dynamic params. table.splitCell has the same requirement plus only
+ * applies to an already-merged cell, which needs more than a scope-kind
+ * check to detect - left out of this first pass rather than shown
+ * unconditionally. table.setHeader/moveRow/moveColumn already have
+ * dedicated toolbar buttons; not duplicated here.
+ */
+export declare const tableContextMenuContributions: readonly ContextMenuContribution[];

package/dist/foundation/table/plugin.js

@@ -0,0 +1,119 @@
+import { definePluginCommand } from "../plugin/types.js";
+import { tableCommands } from "./commands.js";
+/**
+ * Wraps the fourteen existing, already-tested table commands
+ * (table/commands.ts's tableCommands) with the description Phase 10's doc
+ * generation needs. Every one already emits Phase 8c's fine-grained
+ * operations (insertNode/removeNode/moveNode/setNodeAttributes scoped to
+ * the affected row/cell, plus a cell-scoped replaceNode for merge) - this
+ * wrap does not touch that, it only adds metadata around commands that are
+ * already, individually, exactly what a PluginCommand's `run` needs.
+ */
+export const tablePluginCommands = {
+    "table.insert": definePluginCommand({
+        id: "table.insert", run: tableCommands["table.insert"],
+        description: "Inserts a new table with the given row/column count at the current position.",
+        options: {
+            rows: { description: "Number of rows.", required: true },
+            columns: { description: "Number of columns.", required: true },
+            withHeader: { description: "Whether the first row is a header row." },
+            placement: { description: "\"before\" or \"after\" the current block." },
+            ids: { description: "Caller-provided ids for the table, its rows, cells, and paragraphs.", required: true },
+        },
+    }),
+    "table.remove": definePluginCommand({
+        id: "table.remove", run: tableCommands["table.remove"],
+        description: "Removes the selected table entirely.",
+    }),
+    "table.insertRow": definePluginCommand({
+        id: "table.insertRow", run: tableCommands["table.insertRow"],
+        description: "Inserts a new row into the selected table, bumping the rowspan of any cell whose span crosses the insertion point.",
+        options: {
+            position: { description: "\"before\" or \"after\" the current row." },
+            rowIndex: { description: "Explicit row index to insert at, instead of relative to the current row." },
+            rowId: { description: "Caller-provided id for the new row.", required: true },
+            cellIds: { description: "Caller-provided ids for the new row's cells." },
+            paragraphIds: { description: "Caller-provided ids for the new cells' paragraphs." },
+        },
+    }),
+    "table.removeRow": definePluginCommand({
+        id: "table.removeRow", run: tableCommands["table.removeRow"],
+        description: "Removes a row from the selected table, relocating any cell anchored there whose rowspan reaches further down.",
+        options: { rowIndex: { description: "The row index to remove; defaults to the current row." } },
+    }),
+    "table.insertColumn": definePluginCommand({
+        id: "table.insertColumn", run: tableCommands["table.insertColumn"],
+        description: "Inserts a new column into the selected table, one operation per affected row.",
+        options: {
+            position: { description: "\"before\" or \"after\" the current column." },
+            columnIndex: { description: "Explicit column index to insert at." },
+            cellIds: { description: "Caller-provided ids for the new column's cells, one per row needing one." },
+            paragraphIds: { description: "Caller-provided ids for the new cells' paragraphs." },
+        },
+    }),
+    "table.removeColumn": definePluginCommand({
+        id: "table.removeColumn", run: tableCommands["table.removeColumn"],
+        description: "Removes a column from the selected table, one operation per affected row.",
+        options: { columnIndex: { description: "The column index to remove; defaults to the current column." } },
+    }),
+    "table.mergeCells": definePluginCommand({
+        id: "table.mergeCells", run: tableCommands["table.mergeCells"],
+        description: "Merges the selected rectangular cell range into one cell, concatenating simple inline content or preserving block content.",
+    }),
+    "table.splitCell": definePluginCommand({
+        id: "table.splitCell", run: tableCommands["table.splitCell"],
+        description: "Splits a previously-merged cell back into its individual cells.",
+        options: { cellIds: { description: "Caller-provided ids for the newly-created cells.", required: true }, paragraphIds: { description: "Caller-provided ids for the new cells' paragraphs.", required: true } },
+    }),
+    "table.setHeader": definePluginCommand({
+        id: "table.setHeader", run: tableCommands["table.setHeader"],
+        description: "Sets which leading rows and/or columns of the table are headers.",
+        options: { target: { description: "\"row\", \"column\", \"both\", or \"none\".", required: true } },
+    }),
+    "table.setCellAttributes": definePluginCommand({
+        id: "table.setCellAttributes", run: tableCommands["table.setCellAttributes"],
+        description: "Sets attributes on the selected cell(s).",
+        options: { attrs: { description: "The attributes to set.", required: true } },
+    }),
+    "table.setColumnWidth": definePluginCommand({
+        id: "table.setColumnWidth", run: tableCommands["table.setColumnWidth"],
+        description: "Sets a single column's width.",
+        options: { index: { description: "The column index.", required: true }, width: { description: "The new width in pixels.", required: true } },
+    }),
+    "table.setRowHeight": definePluginCommand({
+        id: "table.setRowHeight", run: tableCommands["table.setRowHeight"],
+        description: "Sets a single row's height.",
+        options: { index: { description: "The row index.", required: true }, height: { description: "The new height in pixels.", required: true } },
+    }),
+    "table.moveRow": definePluginCommand({
+        id: "table.moveRow", run: tableCommands["table.moveRow"],
+        description: "Moves a row up or down, refusing moves that would split a rowspan.",
+        options: { direction: { description: "\"up\" or \"down\".", required: true }, index: { description: "The row index; defaults to the current row." } },
+    }),
+    "table.moveColumn": definePluginCommand({
+        id: "table.moveColumn", run: tableCommands["table.moveColumn"],
+        description: "Moves a column left or right, refusing moves that would split a colspan.",
+        options: { direction: { description: "\"left\" or \"right\".", required: true }, index: { description: "The column index; defaults to the current column." } },
+    }),
+};
+/**
+ * Phase 11.5 §2.3: table.insertRow/table.insertColumn need caller-generated
+ * ids (rowId/cellIds/paragraphIds) that can't live in a static `params` -
+ * the dispatching UI must merge fresh ids in at invocation time, the same
+ * way surface/input.ts's Tab handling special-cases list.indent/outdent's
+ * dynamic params. table.splitCell has the same requirement plus only
+ * applies to an already-merged cell, which needs more than a scope-kind
+ * check to detect - left out of this first pass rather than shown
+ * unconditionally. table.setHeader/moveRow/moveColumn already have
+ * dedicated toolbar buttons; not duplicated here.
+ */
+export const tableContextMenuContributions = [
+    { id: "table.contextMenu.insertRowAbove", commandId: "table.insertRow", params: { position: "before" }, label: "Insert row above", scopeKinds: ["table-grid"] },
+    { id: "table.contextMenu.insertRowBelow", commandId: "table.insertRow", params: { position: "after" }, label: "Insert row below", scopeKinds: ["table-grid"] },
+    { id: "table.contextMenu.removeRow", commandId: "table.removeRow", label: "Delete row", scopeKinds: ["table-grid"] },
+    { id: "table.contextMenu.insertColumnLeft", commandId: "table.insertColumn", params: { position: "before" }, label: "Insert column left", scopeKinds: ["table-grid"] },
+    { id: "table.contextMenu.insertColumnRight", commandId: "table.insertColumn", params: { position: "after" }, label: "Insert column right", scopeKinds: ["table-grid"] },
+    { id: "table.contextMenu.removeColumn", commandId: "table.removeColumn", label: "Delete column", scopeKinds: ["table-grid"] },
+    { id: "table.contextMenu.mergeCells", commandId: "table.mergeCells", label: "Merge cells", scopeKinds: ["table-grid"] },
+    { id: "table.contextMenu.removeTable", commandId: "table.remove", label: "Delete table", scopeKinds: ["table-grid"] },
+];

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

@@ -0,0 +1,2 @@
+import type { NodeSpec } from "../types.js";
+export declare const tableNodeSpecs: readonly NodeSpec[];

package/dist/foundation/table/schema.js

@@ -0,0 +1,38 @@
+const positiveInt = { default: 1, validate: (value) => Number.isInteger(value) && Number(value) >= 1 };
+const optionalString = { validate: (value) => typeof value === "string" };
+export const tableNodeSpecs = [
+    {
+        type: "table", group: "block", semanticRole: "table", content: "table_row+", isolating: false,
+        attributes: {
+            columnWidths: { validate: (value) => Array.isArray(value) && value.every((width) => Number.isFinite(width) && Number(width) > 0) },
+            caption: optionalString,
+            layout: { validate: (value) => value === "auto" || value === "fixed" },
+        },
+    },
+    // "table_cell*", not "+": a row every one of whose columns is covered by
+    // an earlier row's rowspan legitimately has zero own cells (e.g. after
+    // merging a selection that spans that row's full width). Row count still
+    // has to match grid.rows for rowspan bookkeeping, so the row node itself
+    // must exist even when empty - it cannot simply be deleted. See
+    // docs/bugs/table-row-empty-rowspan-coverage-rejected.md.
+    { type: "table_row", group: "block", semanticRole: "table-row", content: "table_cell*", attributes: { height: { validate: (value) => Number.isFinite(value) && Number(value) > 0 } } },
+    {
+        type: "table_cell", group: "block", semanticRole: "table-cell", content: "block+", isolating: true,
+        attributes: {
+            colspan: positiveInt, rowspan: positiveInt,
+            header: { default: false, validate: (value) => typeof value === "boolean" },
+            background: optionalString,
+            // `borders`: legacy uniform (all 4 sides) CSS border shorthand -
+            // still the only shape HTML paste-import ever produces. `borderTop`/
+            // `borderRight`/`borderBottom`/`borderLeft`: per-side overrides (the
+            // "which sides" control the border-options UI added) - each, when
+            // set, wins over `borders` for that one side only; see
+            // surface/renderer.ts's per-side application order. Independent
+            // optional strings rather than one structured attr so an unset side
+            // round-trips as simply absent, matching every other optional cell
+            // style attr in this schema.
+            borders: optionalString, borderTop: optionalString, borderRight: optionalString, borderBottom: optionalString, borderLeft: optionalString,
+            verticalAlign: { validate: (value) => value === "top" || value === "middle" || value === "bottom" },
+        },
+    },
+];

package/dist/foundation/table/selection.d.ts

@@ -0,0 +1,7 @@
+import type { PositionLookup } from "../scope/types.js";
+import type { SmartElementNode, SmartSelection } from "../types.js";
+import type { CellSelectionRect, Rect } from "./types.js";
+/** Expands a logical rectangle until every intersected merged cell is fully contained. */
+export declare const snapTableCellRect: (table: SmartElementNode, input: Rect) => CellSelectionRect;
+/** Model cell selections store direction as anchor/head positions while the overlay consumes the snapped rectangle. */
+export declare const cellSelectionFromIds: (anchorCellId: string, headCellId: string, positions: PositionLookup) => SmartSelection | null;

package/dist/foundation/table/selection.js

@@ -0,0 +1,35 @@
+import { occupancyGridFor } from "./grid.js";
+/** Expands a logical rectangle until every intersected merged cell is fully contained. */
+export const snapTableCellRect = (table, input) => {
+    const grid = occupancyGridFor(table);
+    const rect = {
+        top: Math.max(0, Math.min(input.top, grid.rows - 1)),
+        left: Math.max(0, Math.min(input.left, grid.columns - 1)),
+        bottom: Math.max(1, Math.min(input.bottom, grid.rows)),
+        right: Math.max(1, Math.min(input.right, grid.columns)),
+    };
+    let changed = true;
+    while (changed) {
+        changed = false;
+        grid.anchors.forEach((cell) => {
+            if (cell.top < rect.bottom && cell.bottom > rect.top && cell.left < rect.right && cell.right > rect.left) {
+                const next = { top: Math.min(rect.top, cell.top), left: Math.min(rect.left, cell.left), bottom: Math.max(rect.bottom, cell.bottom), right: Math.max(rect.right, cell.right) };
+                if (next.top !== rect.top || next.left !== rect.left || next.bottom !== rect.bottom || next.right !== rect.right) {
+                    Object.assign(rect, next);
+                    changed = true;
+                }
+            }
+        });
+    }
+    const anchor = grid.at(rect.top, rect.left);
+    const head = grid.at(rect.bottom - 1, rect.right - 1);
+    if (!anchor || !head)
+        throw new Error("Cell selection rectangle does not resolve to a complete table grid.");
+    return { tableId: table.id, anchorCellId: anchor.cellId, headCellId: head.cellId, rect, cellIds: grid.anchorsIn(rect).map((cell) => cell.cellId) };
+};
+/** Model cell selections store direction as anchor/head positions while the overlay consumes the snapped rectangle. */
+export const cellSelectionFromIds = (anchorCellId, headCellId, positions) => {
+    const anchor = positions.contentRangeOf(anchorCellId)?.from;
+    const head = positions.contentRangeOf(headCellId)?.to;
+    return anchor && head ? { type: "cell", anchor, head } : null;
+};

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

@@ -0,0 +1,109 @@
+import type { Attrs, SmartDocument, SmartElementNode, SmartOperation, SmartSchema } from "../types.js";
+import type { PositionLookup, ResolvedScope } from "../scope/types.js";
+export interface Rect {
+    readonly top: number;
+    readonly left: number;
+    /** Exclusive. */
+    readonly bottom: number;
+    /** Exclusive. */
+    readonly right: number;
+}
+export interface GridCell {
+    readonly cellId: string;
+    readonly top: number;
+    readonly left: number;
+    /** Exclusive. */
+    readonly bottom: number;
+    /** Exclusive. */
+    readonly right: number;
+    readonly isAnchor: boolean;
+    readonly rowIndex: number;
+    readonly childIndex: number;
+    readonly node: SmartElementNode;
+}
+export interface OccupancyGrid {
+    readonly tableId: string;
+    readonly rows: number;
+    readonly columns: number;
+    readonly anchors: readonly GridCell[];
+    at(row: number, col: number): GridCell | null;
+    anchorsIn(rect: Rect): GridCell[];
+    coveredIn(rect: Rect): GridCell[];
+    isRectangular(rect: Rect): boolean;
+}
+export interface TableGeometryIssue {
+    readonly code: "overlap" | "overhang" | "hole" | "unequal-width" | "noncontiguous-header" | "invalid-child";
+    readonly row: number;
+    readonly column?: number;
+    readonly cellId?: string;
+    readonly message: string;
+}
+export interface TableCommandContext {
+    readonly schema: SmartSchema;
+    readonly positions: PositionLookup;
+}
+export type TableCommand<P> = (document: SmartDocument, scope: ResolvedScope, params: P, ctx: TableCommandContext) => SmartOperation[];
+export interface TableIds {
+    readonly tableId: string;
+    readonly rowIds: readonly string[];
+    readonly cellIds: readonly string[];
+    readonly paragraphIds: readonly string[];
+}
+export interface InsertTableParams {
+    readonly rows: number;
+    readonly columns: number;
+    readonly withHeader?: boolean;
+    readonly placement?: "before" | "after";
+    readonly ids: TableIds;
+}
+export interface RowParams {
+    readonly position?: "before" | "after";
+    readonly rowIndex?: number;
+    readonly rowId?: string;
+    readonly cellIds?: readonly string[];
+    readonly paragraphIds?: readonly string[];
+}
+export interface ColumnParams {
+    readonly position?: "before" | "after";
+    readonly columnIndex?: number;
+    readonly cellIds?: readonly string[];
+    readonly paragraphIds?: readonly string[];
+}
+export interface HeaderParams {
+    readonly target: "row" | "column" | "both" | "none";
+}
+export interface CellAttributesParams {
+    readonly attrs: Attrs;
+}
+/**
+ * `widths`, when supplied, seeds the full columnWidths array instead of
+ * the command's own `Array(columns).fill(120)` fallback - the command
+ * layer has no way to know a table's real *rendered* per-column widths
+ * (that's DOM state, not model state), so a caller that already measured
+ * them (a resize-handle UI, mid-drag) should pass them through rather
+ * than let every other column silently reset to a fabricated default.
+ */
+export interface ColumnWidthParams {
+    readonly index: number;
+    readonly width: number;
+    readonly widths?: readonly number[];
+}
+export interface RowHeightParams {
+    readonly index: number;
+    readonly height: number;
+}
+export interface MoveTableAxisParams {
+    readonly direction: "up" | "down" | "left" | "right";
+    readonly index?: number;
+}
+export interface SplitCellParams {
+    readonly cellIds: readonly string[];
+    readonly paragraphIds: readonly string[];
+}
+export interface CellSelectionRect {
+    readonly tableId: string;
+    readonly anchorCellId: string;
+    readonly headCellId: string;
+    readonly rect: Rect;
+    readonly cellIds: readonly string[];
+}

package/dist/foundation/table/types.js

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

package/dist/foundation/transactions.d.ts

@@ -0,0 +1,41 @@
+import type { PersistedEditorDocument, SmartDocument, SmartSchema, SmartTransaction } from "./types.js";
+export declare class StaleTransactionError extends Error {
+    constructor(expected: number, actual: number);
+}
+/**
+ * A transaction was behind the current revision, but not too far behind to
+ * rebase - and at least one of its operations could not be safely
+ * transformed against what was committed in the meantime (see
+ * collab/transform.ts's doc comment for exactly which shapes this covers:
+ * concurrent moves sharing an array, or a concurrent edit to content a
+ * merge absorbed). The transaction is rejected outright rather than
+ * partially or incorrectly applied - the caller (a real transport
+ * implementation, in 12b-server/transport) decides what happens to the
+ * user's edit from here (e.g. surface it for manual resolution, retry as a
+ * fresh transaction against current state, or convert it to a suggestion).
+ */
+export declare class RebaseConflictError extends Error {
+    readonly reasons: readonly {
+        readonly operationIndex: number;
+        readonly reason: string;
+    }[];
+    constructor(reasons: readonly {
+        readonly operationIndex: number;
+        readonly reason: string;
+    }[]);
+}
+/**
+ * A transaction's baseRevision is older than anything this editor instance
+ * has retained (see FoundationEditor's revisionLogLimit) - there is not
+ * enough history left to rebase through. The caller must resync (reload
+ * the full document at the current revision, e.g. via replaceState) rather
+ * than attempt a partial rebase against an incomplete operation log.
+ */
+export declare class ResyncRequiredError extends Error {
+    readonly atRevision: number;
+    constructor(atRevision: number);
+}
+export declare const invertTransaction: (transaction: SmartTransaction) => SmartTransaction;
+export declare const assertTransactionSerializable: (transaction: SmartTransaction) => void;
+export declare const applyTransactionAtomic: (state: PersistedEditorDocument, transaction: SmartTransaction, schema: SmartSchema) => PersistedEditorDocument;
+export declare const documentsEqual: (left: SmartDocument, right: SmartDocument) => boolean;