smartrte-core 0.2.0 → 1.0.0-beta.1

package/dist/foundation/transactions.js

@@ -0,0 +1,90 @@
+import { applyOperations, invertOperations } from "./operations.js";
+import { isTextNode } from "./identity.js";
+import { nodeAtPath, resolvePos } from "./positions.js";
+import { validate } from "./schema.js";
+export class StaleTransactionError extends Error {
+    constructor(expected, actual) {
+        super(`Stale transaction: base revision ${actual}, current revision ${expected}.`);
+        this.name = "StaleTransactionError";
+    }
+}
+/**
+ * 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 class RebaseConflictError extends Error {
+    constructor(reasons) {
+        super(`Transaction could not be rebased: ${reasons.map((entry) => entry.reason).join("; ")}`);
+        this.reasons = reasons;
+        this.name = "RebaseConflictError";
+    }
+}
+/**
+ * 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 class ResyncRequiredError extends Error {
+    constructor(atRevision) {
+        super(`Transaction is too far behind to rebase (current revision ${atRevision}); a full resync is required.`);
+        this.atRevision = atRevision;
+        this.name = "ResyncRequiredError";
+    }
+}
+export const invertTransaction = (transaction) => ({
+    id: `inverse:${transaction.id}`,
+    baseRevision: transaction.baseRevision + 1,
+    operations: invertOperations(transaction.operations),
+    selectionBefore: structuredClone(transaction.selectionAfter),
+    selectionAfter: structuredClone(transaction.selectionBefore),
+    ...(transaction.storedMarksAfter ? { storedMarksBefore: structuredClone(transaction.storedMarksAfter) } : {}),
+    ...(transaction.storedMarksBefore ? { storedMarksAfter: structuredClone(transaction.storedMarksBefore) } : {}),
+    metadata: {
+        ...structuredClone(transaction.metadata),
+        source: "api",
+        addToHistory: false,
+    },
+});
+export const assertTransactionSerializable = (transaction) => {
+    const json = JSON.stringify(transaction);
+    if (json === undefined)
+        throw new Error("Transaction is not JSON-serializable.");
+    const parsed = JSON.parse(json);
+    if (JSON.stringify(parsed) !== json)
+        throw new Error("Transaction is not stably JSON-serializable.");
+};
+export const applyTransactionAtomic = (state, transaction, schema) => {
+    if (transaction.baseRevision !== state.revision)
+        throw new StaleTransactionError(state.revision, transaction.baseRevision);
+    assertTransactionSerializable(transaction);
+    const document = applyOperations(state.document, transaction.operations);
+    const textOnly = transaction.operations.every((operation) => operation.type === "insertText" || operation.type === "deleteText" || operation.type === "addMark" || operation.type === "removeMark");
+    const affectedPaths = [...new Set(transaction.operations.flatMap((operation) => operation.type === "addMark" || operation.type === "removeMark"
+            ? [JSON.stringify(operation.range.from.path), JSON.stringify(operation.range.to.path)]
+            : "pos" in operation ? [JSON.stringify(operation.pos.path)] : []))];
+    const errors = textOnly
+        ? affectedPaths.flatMap((pathJson) => {
+            const node = nodeAtPath(document, JSON.parse(pathJson));
+            if (!node || isTextNode(node))
+                return [{ path: JSON.parse(pathJson), code: "invalid-text-owner", message: "Text operation owner no longer exists." }];
+            return validate({ type: "doc", id: "local-validation-root", children: [node] }, schema)
+                .filter((error) => error.path.length > 0);
+        })
+        : validate(document, schema);
+    if (errors.length)
+        throw new Error(`Transaction produced an invalid document: ${errors[0].message}`);
+    resolvePos(document, transaction.selectionAfter.anchor);
+    resolvePos(document, transaction.selectionAfter.head);
+    return { schemaVersion: schema.version, revision: state.revision + 1, document };
+};
+export const documentsEqual = (left, right) => JSON.stringify(left) === JSON.stringify(right);

package/dist/foundation/types.d.ts

@@ -0,0 +1,261 @@
+export type NodeGroup = "document" | "block" | "inline";
+export type Attrs = Readonly<Record<string, unknown>>;
+export interface AttributeSpec {
+    default?: unknown;
+    required?: boolean;
+    validate?: (value: unknown) => boolean;
+}
+export interface NodeSpec {
+    type: string;
+    group: NodeGroup;
+    content?: string;
+    marks?: string[] | "_all" | "";
+    attributes?: Record<string, AttributeSpec>;
+    atomic?: boolean;
+    isolating?: boolean;
+    selectable?: boolean;
+    defining?: boolean;
+    /** Structural role for scope resolution. Falls back to `type` when absent. */
+    semanticRole?: "list" | "list-item" | "table" | "table-row" | "table-cell";
+}
+export interface MarkSpec {
+    type: string;
+    attributes?: Record<string, AttributeSpec>;
+    inclusive?: boolean;
+    excludes?: string[];
+    spanning?: boolean;
+}
+export interface SmartSchema {
+    readonly nodes: Readonly<Record<string, Readonly<NodeSpec>>>;
+    readonly marks: Readonly<Record<string, Readonly<MarkSpec>>>;
+    readonly topNode: string;
+    readonly version: number;
+}
+export interface SmartMark {
+    readonly type: string;
+    readonly attrs?: Attrs;
+}
+export interface SmartTextNode {
+    readonly type: "text";
+    readonly text: string;
+    readonly marks?: readonly SmartMark[];
+}
+export interface SmartElementNode {
+    readonly type: string;
+    readonly id: string;
+    readonly attrs?: Attrs;
+    readonly children?: readonly SmartNode[];
+}
+export type SmartNode = SmartTextNode | SmartElementNode;
+export interface SmartDocument extends SmartElementNode {
+    readonly type: "doc";
+    readonly children: readonly SmartNode[];
+}
+export interface PersistedEditorDocument {
+    schemaVersion: number;
+    revision: number;
+    document: SmartDocument;
+}
+export interface SmartPos {
+    /**
+     * Path of the owning non-text node. Offset meaning is resolved from that
+     * node's schema role: UTF-16 units for an inline-content owner, child
+     * boundaries for a structural owner. Inline atomic children occupy exactly
+     * one UTF-16-offset unit and have no internal cursor positions.
+     *
+     * This is intentionally not a stored discriminated union: a stored kind
+     * could disagree with the schema after version skew. `ResolvedPos.kind` is
+     * the authoritative, schema-derived discriminant consumed by commands.
+     */
+    path: number[];
+    offset: number;
+}
+export interface ResolvedPos {
+    pos: SmartPos;
+    kind: "inline" | "structural";
+    nodeId: string;
+    parent: SmartElementNode;
+    depth: number;
+    affinity: "forward" | "backward";
+    ancestors: readonly SmartElementNode[];
+    nodeBefore: SmartNode | null;
+    nodeAfter: SmartNode | null;
+    atStart: boolean;
+    atEnd: boolean;
+    indexAt(depth: number): number;
+}
+export interface SmartRange {
+    from: SmartPos;
+    to: SmartPos;
+}
+export interface SmartSelection {
+    anchor: SmartPos;
+    head: SmartPos;
+    type: "text" | "node" | "cell" | "none";
+}
+export type SmartOperation = {
+    type: "insertNode";
+    pos: SmartPos;
+    node: SmartNode;
+} | {
+    type: "removeNode";
+    pos: SmartPos;
+    node: SmartNode;
+    /**
+     * Set when this removal is semantically a merge - the node's content
+     * was absorbed into the node at this id, not simply deleted. Purely
+     * informational: every existing consumer of `removeNode` (apply,
+     * invert, map, normalization, history rebasing) ignores it, since
+     * removal itself is unaffected either way. Populated by
+     * `mergeTableCellsCommand` for an absorbed cell; consumed by
+     * `rebaseAnnotationRange` to decide whether an annotation anchored to
+     * this id should snap to the surviving node instead of orphaning.
+     */
+    mergedInto?: string;
+} | {
+    type: "replaceNode";
+    pos: SmartPos;
+    before: SmartNode;
+    after: SmartNode;
+    /**
+     * Ids present in `before`'s subtree that have no counterpart in
+     * `after` because their content was folded into a node that does
+     * survive, paired with which surviving id each one merged into (a
+     * single `replaceNode` can retire more than one id into more than
+     * one survivor - e.g. list item merge retires both the outer
+     * `list_item` wrapper and its inner paragraph, into the target
+     * item's wrapper and paragraph respectively, not one shared
+     * survivor). Every other id difference between before/after is an
+     * ordinary content change, not a merge. Same "purely informational,
+     * ignored by every existing consumer" contract as
+     * `removeNode.mergedInto` above. Populated by list item merge
+     * (`mergeItems`); consumed by `rebaseAnnotationRange`.
+     */
+    retiredInto?: readonly {
+        readonly retiredId: string;
+        readonly survivorId: string;
+    }[];
+} | {
+    type: "moveNode";
+    from: SmartPos;
+    to: SmartPos;
+    nodeId: string;
+} | {
+    type: "splitNode";
+    pos: SmartPos;
+    depth: number;
+    newId: string;
+} | {
+    type: "mergeNode";
+    pos: SmartPos;
+    depth: number;
+    retiredId: string;
+    splitOffset: number;
+} | {
+    type: "setNodeAttributes";
+    pos: SmartPos;
+    before: Attrs;
+    after: Attrs;
+} | {
+    type: "setNodeType";
+    pos: SmartPos;
+    before: string;
+    after: string;
+    beforeAttrs: Attrs;
+    afterAttrs: Attrs;
+} | {
+    type: "insertText";
+    pos: SmartPos;
+    text: string;
+    marks?: SmartMark[];
+} | {
+    type: "deleteText";
+    pos: SmartPos;
+    text: string;
+    marks?: SmartMark[];
+} | {
+    type: "addMark";
+    range: SmartRange;
+    mark: SmartMark;
+} | {
+    type: "removeMark";
+    range: SmartRange;
+    mark: SmartMark;
+};
+export interface SmartTransaction {
+    id: string;
+    baseRevision: number;
+    operations: SmartOperation[];
+    selectionBefore: SmartSelection;
+    selectionAfter: SmartSelection;
+    storedMarksBefore?: SmartMark[];
+    storedMarksAfter?: SmartMark[];
+    metadata: {
+        source: "input" | "keyboard" | "toolbar" | "paste" | "cut" | "drop" | "api";
+        timestamp: number;
+        historyGroup?: string;
+        addToHistory: boolean;
+        compositionId?: string;
+        authorId?: string;
+    };
+}
+export interface TransactionMap {
+    map(pos: SmartPos, bias?: -1 | 1): SmartPos;
+    mapRange(range: SmartRange): SmartRange;
+    mapSelection(selection: SmartSelection): SmartSelection;
+    deleted(pos: SmartPos): boolean;
+}
+export interface NormalizerContext {
+    readonly schema: SmartSchema;
+    readonly affectedPath: readonly number[];
+    readonly pass: number;
+    readonly documentWide: boolean;
+}
+export interface NormalizerResult {
+    operations: SmartOperation[];
+}
+export interface NormalizerRegistration {
+    id: string;
+    priority: number;
+    documentWide?: boolean;
+    normalize(document: SmartDocument, context: NormalizerContext): NormalizerResult;
+}
+export interface HistoryEntry {
+    forward: SmartTransaction;
+    inverse: SmartTransaction;
+    estimatedBytes: number;
+}
+export interface SmartHistory {
+    readonly undo: readonly HistoryEntry[];
+    readonly redo: readonly HistoryEntry[];
+    readonly limit: number;
+    /** Maximum estimated serialized bytes retained in either history stack. */
+    readonly byteLimit: number;
+    readonly coalescenceWindowMs: number;
+}
+export interface ModelDomMapping {
+    nodeToDom(nodeId: string): HTMLElement | null;
+    domToNode(el: Node): {
+        nodeId: string;
+        node: SmartNode;
+    } | null;
+    posToDom(pos: SmartPos): {
+        node: Node;
+        offset: number;
+    } | null;
+    domToPos(node: Node, offset: number): SmartPos | null;
+    isEditorUiNode(el: Node): boolean;
+    rebuild(root: HTMLElement, document: SmartDocument): void;
+}
+export interface ValidationError {
+    path: number[];
+    code: string;
+    message: string;
+}
+export interface Repair {
+    path: number[];
+    code: string;
+    message: string;
+    before?: unknown;
+    after?: unknown;
+}

package/dist/foundation/types.js

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

package/dist/foundation/versioning/diffVersions.d.ts

@@ -0,0 +1,5 @@
+import type { DocumentDiff } from "../diff/types.js";
+import type { SmartSchema } from "../types.js";
+import type { DocumentVersion } from "./types.js";
+/** Thin convenience wrapper over `diffDocuments` for the common "diff two saved versions" call shape. */
+export declare const diffVersions: (a: DocumentVersion, b: DocumentVersion, schema: SmartSchema) => DocumentDiff;

package/dist/foundation/versioning/diffVersions.js

@@ -0,0 +1,3 @@
+import { diffDocuments } from "../diff/documentDiff.js";
+/** Thin convenience wrapper over `diffDocuments` for the common "diff two saved versions" call shape. */
+export const diffVersions = (a, b, schema) => diffDocuments(a.envelope.document, b.envelope.document, schema);

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

@@ -0,0 +1,2 @@
+export * from "./types.js";
+export * from "./diffVersions.js";

package/dist/foundation/versioning/index.js

@@ -0,0 +1,2 @@
+export * from "./types.js";
+export * from "./diffVersions.js";

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

@@ -0,0 +1,17 @@
+import type { PersistedEditorDocument } from "../types.js";
+/**
+ * A named, saved snapshot of the document a user can return to or compare
+ * against - distinct from the undo/redo history stack (`history.ts`), which
+ * is moment-to-moment edit state, not something a user browses or restores
+ * from days later. Reuses the existing `PersistedEditorDocument` envelope
+ * verbatim as its payload rather than a new document shape - a version
+ * *is* a full document snapshot with a revision, which is exactly what
+ * that envelope already represents.
+ */
+export interface DocumentVersion {
+    readonly id: string;
+    readonly label?: string;
+    readonly createdAt: number;
+    readonly authorId?: string;
+    readonly envelope: PersistedEditorDocument;
+}

package/dist/foundation/versioning/types.js

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

package/dist/history.d.ts

@@ -0,0 +1,20 @@
+import { type SmartEditorState, type LegacySmartTransaction } from "./transaction.js";
+export interface LegacyHistoryEntry {
+    forward: LegacySmartTransaction;
+    inverse: LegacySmartTransaction;
+}
+export interface SmartHistoryState {
+    undo: LegacyHistoryEntry[];
+    redo: LegacyHistoryEntry[];
+    limit: number;
+}
+export interface HistoryResult {
+    state: SmartEditorState;
+    history: SmartHistoryState;
+    applied: boolean;
+}
+export declare const createHistoryState: (limit?: number) => SmartHistoryState;
+export declare const invertLegacyTransaction: (state: SmartEditorState, transaction: LegacySmartTransaction) => LegacySmartTransaction;
+export declare const applyTransactionWithHistory: (state: SmartEditorState, history: SmartHistoryState, transaction: LegacySmartTransaction) => HistoryResult;
+export declare const undoHistory: (state: SmartEditorState, history: SmartHistoryState) => HistoryResult;
+export declare const redoHistory: (state: SmartEditorState, history: SmartHistoryState) => HistoryResult;

package/dist/history.js

@@ -0,0 +1,165 @@
+import { mapSelectionThroughOperation } from "./selectionMapping.js";
+import { normalizeSmartDocument } from "./schema.js";
+import { applyOperationToState, applyTransaction, getMoveDestinationAfterRemoval, } from "./transaction.js";
+import { getNodeAtTreePath, isSmartContainer } from "./tree.js";
+export const createHistoryState = (limit = 100) => ({
+    undo: [],
+    redo: [],
+    limit: Math.max(1, Math.floor(limit)),
+});
+const parentPath = (path) => path.slice(0, -1);
+const inverseForOperation = (document, selection, operation) => {
+    if (operation.type === "insertNode")
+        return [{ type: "removeNode", path: operation.path }];
+    if (operation.type === "removeNode") {
+        return [{ type: "insertNode", path: operation.path, node: getNodeAtTreePath(document, operation.path) }];
+    }
+    if (operation.type === "replaceNode") {
+        return [{ type: "replaceNode", path: operation.path, node: getNodeAtTreePath(document, operation.path) }];
+    }
+    if (operation.type === "moveNode") {
+        const movedNode = getNodeAtTreePath(document, operation.from);
+        const destination = getMoveDestinationAfterRemoval(operation.from, operation.to);
+        return [
+            { type: "removeNode", path: destination },
+            { type: "insertNode", path: operation.from, node: movedNode },
+        ];
+    }
+    if (operation.type === "splitNode") {
+        const rightPath = [
+            ...parentPath(operation.path),
+            operation.path[operation.path.length - 1] + 1,
+        ];
+        return [{ type: "mergeNode", path: rightPath }];
+    }
+    if (operation.type === "mergeNode") {
+        const leftPath = [
+            ...parentPath(operation.path),
+            operation.path[operation.path.length - 1] - 1,
+        ];
+        const left = getNodeAtTreePath(document, leftPath);
+        const position = left?.type === "text"
+            ? left.text.length
+            : isSmartContainer(left)
+                ? left.children.length
+                : 0;
+        return [{ type: "splitNode", path: leftPath, position }];
+    }
+    if (operation.type === "setNodeAttrs") {
+        const node = getNodeAtTreePath(document, operation.path);
+        const attrs = Object.fromEntries(Object.keys(operation.attrs).map((name) => [name, Object.prototype.hasOwnProperty.call(node, name) ? node[name] : undefined]));
+        return [{ type: "setNodeAttrs", path: operation.path, attrs }];
+    }
+    if (operation.type === "replaceText") {
+        const node = getNodeAtTreePath(document, operation.path);
+        return [{
+                type: "replaceText",
+                path: operation.path,
+                start: operation.start,
+                end: operation.start + operation.text.length,
+                text: node.text.slice(operation.start, operation.end),
+            }];
+    }
+    if (operation.type === "addMark" || operation.type === "removeMark") {
+        const path = parentPath(operation.path);
+        return [{ type: "replaceNode", path, node: getNodeAtTreePath(document, path) }];
+    }
+    return [{ type: "setSelection", selection }];
+};
+export const invertLegacyTransaction = (state, transaction) => {
+    let document = state.document;
+    let selection = state.selection;
+    const inverseGroups = [];
+    transaction.operations.forEach((operation) => {
+        inverseGroups.unshift(inverseForOperation(document, selection, operation));
+        const before = document;
+        const next = applyOperationToState(document, selection, operation);
+        document = next.document;
+        selection = operation.type === "setSelection"
+            ? next.selection
+            : mapSelectionThroughOperation(selection, operation, before);
+    });
+    return {
+        id: `undo:${transaction.id}`,
+        source: "history",
+        operations: inverseGroups.flat(),
+        selectionBefore: transaction.selectionAfter ?? selection,
+        selectionAfter: state.selection,
+        addToHistory: false,
+        timestamp: transaction.timestamp,
+    };
+};
+export const applyTransactionWithHistory = (state, history, transaction) => {
+    let inverse = invertLegacyTransaction(state, transaction);
+    const nextState = applyTransaction(state, transaction);
+    const restored = applyTransaction(nextState, inverse);
+    const expectedDocument = normalizeSmartDocument(state.document);
+    if (JSON.stringify(restored.document) !== JSON.stringify(expectedDocument) ||
+        JSON.stringify(restored.selection) !== JSON.stringify(state.selection)) {
+        inverse = {
+            ...inverse,
+            operations: [{ type: "replaceNode", path: [], node: expectedDocument }],
+            selectionAfter: state.selection,
+        };
+    }
+    if (!transaction.addToHistory) {
+        return { state: nextState, history, applied: true };
+    }
+    const previous = history.undo[history.undo.length - 1];
+    const canGroup = Boolean(transaction.historyGroup &&
+        previous?.forward.historyGroup === transaction.historyGroup);
+    const entry = canGroup
+        ? {
+            forward: {
+                ...previous.forward,
+                operations: [...previous.forward.operations, ...transaction.operations],
+                selectionAfter: transaction.selectionAfter ?? nextState.selection,
+                timestamp: transaction.timestamp,
+            },
+            inverse: {
+                ...inverse,
+                operations: [...inverse.operations, ...previous.inverse.operations],
+                selectionBefore: transaction.selectionAfter ?? nextState.selection,
+                selectionAfter: previous.inverse.selectionAfter,
+            },
+        }
+        : { forward: transaction, inverse };
+    const undo = canGroup
+        ? [...history.undo.slice(0, -1), entry]
+        : [...history.undo, entry];
+    if (undo.length > history.limit)
+        undo.splice(0, undo.length - history.limit);
+    return {
+        state: nextState,
+        history: { ...history, undo, redo: [] },
+        applied: true,
+    };
+};
+export const undoHistory = (state, history) => {
+    const entry = history.undo[history.undo.length - 1];
+    if (!entry)
+        return { state, history, applied: false };
+    return {
+        state: applyTransaction(state, entry.inverse),
+        history: {
+            ...history,
+            undo: history.undo.slice(0, -1),
+            redo: [...history.redo, entry],
+        },
+        applied: true,
+    };
+};
+export const redoHistory = (state, history) => {
+    const entry = history.redo[history.redo.length - 1];
+    if (!entry)
+        return { state, history, applied: false };
+    return {
+        state: applyTransaction(state, entry.forward),
+        history: {
+            ...history,
+            undo: [...history.undo, entry],
+            redo: history.redo.slice(0, -1),
+        },
+        applied: true,
+    };
+};

package/dist/html/compatibility.js

@@ -3,6 +3,12 @@ const BLOCK_TAGS = new Set([
     "p", "h1", "h2", "h3", "h4", "h5", "h6", "ul", "ol", "li",
     "blockquote", "pre", "table", "div",
 ]);
+const SEMANTIC_SRTE_ATTRIBUTES = new Set([
+    "data-srte-checklist",
+    "data-srte-checklist-strike",
+    "data-srte-checked",
+    "data-srte-list-preset",
+]);
 const attrsOf = (node) => node.attrs || [];
 const hasAttr = (node, name, value) => attrsOf(node).some((attr) => attr.name === name && (value == null || attr.value === value));
 const isTag = (node, tagName) => node.tagName === tagName;
@@ -38,7 +44,7 @@ const normalizeNode = (node) => {
             return false;
         if (attr.name === "data-row-index" || attr.name === "data-col-index")
             return false;
-        return !attr.name.startsWith("data-srte-");
+        return !attr.name.startsWith("data-srte-") || SEMANTIC_SRTE_ATTRIBUTES.has(attr.name);
     });
     if (!node.childNodes)
         return;

package/dist/index.d.ts

@@ -1,14 +1 @@
-export * from "./model.js";
-export * from "./command.js";
-export * from "./marks.js";
-export * from "./selection.js";
-export * from "./table.js";
-export * from "./transaction.js";
-export * from "./tree.js";
-export * from "./commands/list.js";
-export * from "./commands/code.js";
-export * from "./commands/marks.js";
-export * from "./commands/alignment.js";
-export * from "./html/compatibility.js";
-export * from "./markdown/compatibility.js";
-export * from "./security/urlPolicy.js";
+export * from "./foundation/index.js";

package/dist/index.js

@@ -1,14 +1,9 @@
-export * from "./model.js";
-export * from "./command.js";
-export * from "./marks.js";
-export * from "./selection.js";
-export * from "./table.js";
-export * from "./transaction.js";
-export * from "./tree.js";
-export * from "./commands/list.js";
-export * from "./commands/code.js";
-export * from "./commands/marks.js";
-export * from "./commands/alignment.js";
-export * from "./html/compatibility.js";
-export * from "./markdown/compatibility.js";
-export * from "./security/urlPolicy.js";
+// The package root is the canonical, framework-agnostic public API: the
+// foundation document model and editing engine, and nothing else. Everything
+// built on the pre-canonical model (legacyCommands/*, plugins/*, the
+// html/markdown compatibility layers, and the discriminated-union model
+// types in model.ts et al.) lives exclusively behind "smartrte-core/legacy"
+// - see legacy/index.ts. Do not re-add those exports here; that flat
+// re-export used to defeat the whole point of the /legacy subpath by making
+// the same symbols reachable from the root import too.
+export * from "./foundation/index.js";