smartrte-core 0.2.0 → 1.0.0-beta.1

package/dist/foundation/plugin/dispatch.js

@@ -0,0 +1,34 @@
+const matchesEvent = (event, shortcut) => event.key.toLowerCase() === shortcut.key.toLowerCase() &&
+    (shortcut.primary ? Boolean(event.metaKey || event.ctrlKey) : !event.metaKey && !event.ctrlKey) &&
+    Boolean(event.altKey) === Boolean(shortcut.alt) &&
+    Boolean(event.shiftKey) === Boolean(shortcut.shift);
+/**
+ * Tries every key-matching shortcut contribution in priority order (ties
+ * broken by registration order, which is what PluginRegistry.keyboardShortcuts
+ * already provides), invoking `tryShortcut` for each and returning the
+ * first that actually produces operations.
+ *
+ * This is a fallback chain, not a static "one scope-kind owns this key"
+ * lookup, because ScopeKind alone cannot distinguish every case a real
+ * shortcut cares about (e.g. "inside a code block" and "inside a plain
+ * paragraph" are both "block-range" - see scope/resolveScope.ts). It
+ * reproduces surface/input.ts's actual current Tab precedence (code-block
+ * wins if applicable, then list unless inTable, then table/native
+ * fallthrough if nothing applies) by asking each candidate, in order,
+ * "does this genuinely apply here" via `tryShortcut` - which resolves the
+ * scope the contribution declares and runs its command - rather than by
+ * pre-filtering on a single precomputed scope-kind label. `scopeKinds` on
+ * a contribution remains meaningful as declared metadata for callers
+ * (which `resolveScope({want})` to attempt) and for doc generation, it's
+ * just no longer what this function filters by directly.
+ */
+export const resolveShortcut = (shortcuts, event, tryShortcut) => {
+    for (const shortcut of shortcuts) {
+        if (!matchesEvent(event, shortcut))
+            continue;
+        const operations = tryShortcut(shortcut);
+        if (operations?.length)
+            return { shortcut, operations };
+    }
+    return null;
+};

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

@@ -0,0 +1,4 @@
+export * from "./types.js";
+export * from "./registry.js";
+export * from "./dispatch.js";
+export * from "./builtins.js";

package/dist/foundation/plugin/index.js

@@ -0,0 +1,4 @@
+export * from "./types.js";
+export * from "./registry.js";
+export * from "./dispatch.js";
+export * from "./builtins.js";

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

@@ -0,0 +1,36 @@
+import { type SchemaContribution } from "../schemaBuilder.js";
+import type { NormalizerRegistration, SmartSchema } from "../types.js";
+import type { SourceNormalizer } from "../clipboard/types.js";
+import type { ContextMenuContribution, FoundationPlugin, KeyboardShortcutContribution, PluginCommand, RendererContribution, ToolbarContribution } from "./types.js";
+export interface PluginRegistry {
+    readonly plugins: readonly FoundationPlugin[];
+    readonly pluginIds: ReadonlySet<string>;
+    readonly schema: SmartSchema;
+    readonly commands: ReadonlyMap<string, PluginCommand>;
+    readonly normalizers: readonly NormalizerRegistration[];
+    readonly clipboardNormalizers: readonly SourceNormalizer[];
+    readonly keyboardShortcuts: readonly KeyboardShortcutContribution[];
+    readonly toolbar: readonly ToolbarContribution[];
+    readonly contextMenu: readonly ContextMenuContribution[];
+    readonly renderer: readonly RendererContribution[];
+    hasPlugin(id: string): boolean;
+}
+/**
+ * Builds one authoritative registry from a plugin list: dependency-ordered,
+ * schema merged via the existing createSchema (same duplicate-type/duplicate-
+ * mark checks it has always enforced), commands/contributions merged with
+ * hard duplicate-id errors - mirroring the validation shape
+ * packages/react/src/pluginRuntime.ts already proved out for the now-retired
+ * legacy system, rebuilt here for the canonical architecture.
+ *
+ * `baseSchema` covers node/mark types no feature family owns and that must
+ * exist regardless of which plugins are registered - `doc` (the document
+ * root), `text`, `hard_break`, and `unknown` (the disable-safety passthrough
+ * node type itself, which would be a chicken-and-egg problem if any plugin
+ * had to own it).
+ */
+export declare const createPluginRegistry: (plugins: readonly FoundationPlugin[], options: {
+    baseSchema: SchemaContribution;
+    topNode?: string;
+    schemaVersion: number;
+}) => PluginRegistry;

package/dist/foundation/plugin/registry.js

@@ -0,0 +1,115 @@
+import { createSchema } from "../schemaBuilder.js";
+/** Dependency-ordered so a plugin's `requires` are always registered before it. */
+const orderPlugins = (plugins) => {
+    const byId = new Map(plugins.map((plugin) => [plugin.id, plugin]));
+    if (byId.size !== plugins.length) {
+        const seen = new Set();
+        const duplicate = plugins.find((plugin) => (seen.has(plugin.id) ? true : (seen.add(plugin.id), false)));
+        throw new Error(`Duplicate plugin id "${duplicate?.id}".`);
+    }
+    const ordered = [];
+    const visited = new Set();
+    const visiting = new Set();
+    const visit = (plugin) => {
+        if (visited.has(plugin.id))
+            return;
+        if (visiting.has(plugin.id))
+            throw new Error(`Circular plugin dependency involving "${plugin.id}".`);
+        visiting.add(plugin.id);
+        (plugin.requires || []).forEach((requiredId) => {
+            const required = byId.get(requiredId);
+            if (!required)
+                throw new Error(`Plugin "${plugin.id}" requires missing plugin "${requiredId}".`);
+            visit(required);
+        });
+        (plugin.optional || []).forEach((optionalId) => {
+            const optional = byId.get(optionalId);
+            if (optional)
+                visit(optional);
+        });
+        visiting.delete(plugin.id);
+        visited.add(plugin.id);
+        ordered.push(plugin);
+    };
+    plugins.forEach(visit);
+    return ordered;
+};
+const byPriorityThenOrder = (items) => [...items].sort((left, right) => (right.item.priority ?? 0) - (left.item.priority ?? 0) || left.index - right.index)
+    .map(({ item }) => item);
+/**
+ * Builds one authoritative registry from a plugin list: dependency-ordered,
+ * schema merged via the existing createSchema (same duplicate-type/duplicate-
+ * mark checks it has always enforced), commands/contributions merged with
+ * hard duplicate-id errors - mirroring the validation shape
+ * packages/react/src/pluginRuntime.ts already proved out for the now-retired
+ * legacy system, rebuilt here for the canonical architecture.
+ *
+ * `baseSchema` covers node/mark types no feature family owns and that must
+ * exist regardless of which plugins are registered - `doc` (the document
+ * root), `text`, `hard_break`, and `unknown` (the disable-safety passthrough
+ * node type itself, which would be a chicken-and-egg problem if any plugin
+ * had to own it).
+ */
+export const createPluginRegistry = (plugins, options) => {
+    const ordered = orderPlugins(plugins);
+    const pluginIds = new Set(ordered.map((plugin) => plugin.id));
+    const schema = createSchema({
+        version: options.schemaVersion,
+        topNode: options.topNode,
+        nodes: [...(options.baseSchema.nodes || [])],
+        marks: [...(options.baseSchema.marks || [])],
+        extensions: ordered.map((plugin) => ({ nodes: plugin.schema?.nodes, marks: plugin.schema?.marks })),
+    });
+    const commands = new Map();
+    ordered.forEach((plugin) => {
+        Object.values(plugin.commands).forEach((command) => {
+            if (commands.has(command.id))
+                throw new Error(`Duplicate command id "${command.id}" (from plugin "${plugin.id}").`);
+            if (!command.description.trim())
+                throw new Error(`Command "${command.id}" (plugin "${plugin.id}") requires a non-empty description.`);
+            commands.set(command.id, command);
+        });
+    });
+    const normalizers = ordered.flatMap((plugin) => plugin.normalizers || []);
+    const clipboardNormalizers = ordered
+        .map((plugin, index) => ({ item: plugin.clipboard, index, priority: plugin.clipboard?.priority }))
+        .filter((entry) => Boolean(entry.item?.normalizers?.length))
+        .sort((left, right) => (right.priority ?? 0) - (left.priority ?? 0) || left.index - right.index)
+        .flatMap((entry) => entry.item.normalizers || []);
+    const contributionIds = new Set();
+    const validateContribution = (pluginId, kind, contribution) => {
+        if (!contribution.id.trim())
+            throw new Error(`Plugin "${pluginId}" has a ${kind} contribution with an empty id.`);
+        if (contributionIds.has(contribution.id))
+            throw new Error(`Duplicate ${kind} contribution id "${contribution.id}".`);
+        if (!commands.has(contribution.commandId)) {
+            throw new Error(`${kind} contribution "${contribution.id}" (plugin "${pluginId}") references missing command "${contribution.commandId}".`);
+        }
+        contributionIds.add(contribution.id);
+    };
+    const collect = (kind, pick) => byPriorityThenOrder(ordered.flatMap((plugin, pluginIndex) => (pick(plugin) || []).map((contribution, index) => {
+        validateContribution(plugin.id, kind, contribution);
+        return { item: contribution, index: pluginIndex * 100000 + index };
+    })));
+    const keyboardShortcuts = collect("Shortcut", (plugin) => plugin.keyboardShortcuts);
+    const toolbar = collect("Toolbar", (plugin) => plugin.toolbar);
+    const contextMenu = collect("Context menu", (plugin) => plugin.contextMenu);
+    const renderer = ordered
+        .map((plugin, index) => ({ item: plugin.renderer, index, priority: plugin.renderer?.priority }))
+        .filter((entry) => Boolean(entry.item))
+        .sort((left, right) => (right.priority ?? 0) - (left.priority ?? 0) || left.index - right.index)
+        .map((entry) => entry.item);
+    return {
+        plugins: ordered,
+        pluginIds,
+        schema,
+        commands,
+        normalizers,
+        clipboardNormalizers,
+        keyboardShortcuts,
+        toolbar,
+        contextMenu,
+        renderer,
+        hasPlugin: (id) => pluginIds.has(id),
+    };
+};

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

@@ -0,0 +1,141 @@
+import type { SmartDocument, SmartOperation, SmartSchema } from "../types.js";
+import type { PositionLookup, ResolvedScope, ScopeKind } from "../scope/types.js";
+import type { NormalizerRegistration } from "../types.js";
+import type { SchemaContribution } from "../schemaBuilder.js";
+import type { SourceNormalizer } from "../clipboard/types.js";
+import type { FeatureFormatCodec } from "../formats/codec.js";
+/**
+ * Shared by every existing per-family command context
+ * (TableCommandContext, BlockCommandContext, MarkCommandContext,
+ * ListCommand's CommandContext, AtomCommandContext) - all five are this
+ * exact shape today, just independently named. A PluginCommand's `run`
+ * accepts this directly; no existing command function needs to change.
+ */
+export interface PluginCommandContext {
+    readonly schema: SmartSchema;
+    readonly positions: PositionLookup;
+}
+export interface CommandExample {
+    readonly description: string;
+    readonly params: unknown;
+    readonly expectedOutcome?: string;
+}
+export interface OptionSpec {
+    readonly description: string;
+    readonly required?: boolean;
+}
+/**
+ * Wraps the existing per-family command function shape
+ * `(document, scope, params, ctx) => SmartOperation[]` with the metadata
+ * Phase 10's doc generation needs. `run` is exactly what every existing
+ * TableCommand/BlockCommand/MarkCommand/ListCommand/AtomCommand already is -
+ * converting a family to a plugin wraps its existing commands, it does not
+ * rewrite them.
+ */
+export interface PluginCommand<P = unknown> {
+    readonly id: string;
+    readonly run: (document: SmartDocument, scope: ResolvedScope, params: P, ctx: PluginCommandContext) => SmartOperation[];
+    /** Required, not optional - enforced at the type level and by a non-empty-string lint check. */
+    readonly description: string;
+    readonly examples?: readonly CommandExample[];
+    readonly options?: Record<string, OptionSpec>;
+}
+/**
+ * A command registry is necessarily heterogeneous - each entry's own
+ * params type (MarkApplyParams, TableRowParams, ...) is narrower than the
+ * `unknown` a dynamic-dispatch-by-id lookup can statically guarantee.
+ * definePluginCommand narrows the unsafe cast this requires to one place:
+ * wrap an existing, already-typed command function (TableCommand<P>,
+ * MarkCommand<P>, ...) as-is - the underlying function is never rewritten,
+ * only its params type is erased at the registry boundary, the same way
+ * every extensible command-by-id system needs to (callers are responsible
+ * for passing the right params shape for a given command id; `options`
+ * documents that shape for humans/doc-gen, it is not statically enforced).
+ */
+export declare const definePluginCommand: <P>(command: {
+    readonly id: string;
+    readonly run: (document: SmartDocument, scope: ResolvedScope, params: P, ctx: PluginCommandContext) => SmartOperation[];
+    readonly description: string;
+    readonly examples?: readonly CommandExample[];
+    readonly options?: Record<string, OptionSpec>;
+}) => PluginCommand;
+/**
+ * A keyboard shortcut declares the ScopeKind(s) (scope/types.ts's existing,
+ * already-tested taxonomy - inline-range/block-range/list-selection/
+ * table-grid/atomic-node/container-tree/mixed/empty) it applies to, so the
+ * dispatcher can pick the handler whose declared scope matches the resolved
+ * scope at the cursor instead of hardcoding precedence per key the way
+ * surface/input.ts's Tab handling does today. `priority` breaks a genuine
+ * tie between two handlers declaring the same scope kind for the same key;
+ * registration order breaks a tie in `priority`.
+ */
+export interface KeyboardShortcutContribution {
+    readonly id: string;
+    readonly commandId: string;
+    /** Fixed params for commands parameterized at the call site (e.g. mark.toggle's markType) - one command, many bindings. */
+    readonly params?: unknown;
+    readonly key: string;
+    readonly primary?: boolean;
+    readonly alt?: boolean;
+    readonly shift?: boolean;
+    readonly scopeKinds: readonly ScopeKind[];
+    readonly priority?: number;
+}
+export interface ToolbarContribution {
+    readonly id: string;
+    readonly commandId: string;
+    readonly params?: unknown;
+    readonly label: string;
+    readonly order?: number;
+}
+/**
+ * Unlike ToolbarContribution, a context menu is scope-gated: right-clicking
+ * a table cell shouldn't offer "Clear formatting", and selecting text
+ * shouldn't offer "Delete row". `scopeKinds` mirrors
+ * KeyboardShortcutContribution's field - the same declared-metadata
+ * contract, checked by resolving `scopeKinds[0]` and requiring the actual
+ * resolved scope to match it exactly (see resolveContextMenuItems in
+ * packages/react's CanonicalAuthorityEditor, which plays the same role
+ * surface/input.ts's resolveShortcut plays for keyboard shortcuts).
+ */
+export interface ContextMenuContribution {
+    readonly id: string;
+    readonly commandId: string;
+    readonly params?: unknown;
+    readonly label: string;
+    readonly order?: number;
+    readonly scopeKinds: readonly ScopeKind[];
+}
+export interface ClipboardContribution {
+    readonly normalizers?: readonly SourceNormalizer[];
+    readonly priority?: number;
+}
+export interface RendererContribution {
+    /** Node type -> a project-defined render descriptor; the DOM renderer layer resolves the actual function. */
+    readonly nodeRenderers?: Record<string, unknown>;
+    readonly priority?: number;
+}
+/**
+ * The unit of ownership for one editor feature. Registering a list of these
+ * (see registry.ts's createPluginRegistry) produces the SmartSchema,
+ * command lookup, and normalizer/clipboard/renderer/toolbar/contextMenu
+ * registrations a FoundationEditor is built from - replacing the static,
+ * module-load-time spread `foundationSchema` used before Phase 10.
+ */
+export interface FoundationPlugin {
+    readonly id: string;
+    readonly version: string;
+    readonly requires?: readonly string[];
+    readonly optional?: readonly string[];
+    /** Higher wins on a genuine tie; registration order breaks a tie in this. */
+    readonly priority?: number;
+    readonly schema?: SchemaContribution;
+    readonly commands: Record<string, PluginCommand>;
+    readonly normalizers?: readonly NormalizerRegistration[];
+    readonly keyboardShortcuts?: readonly KeyboardShortcutContribution[];
+    readonly clipboard?: ClipboardContribution;
+    readonly renderer?: RendererContribution;
+    readonly toolbar?: readonly ToolbarContribution[];
+    readonly contextMenu?: readonly ContextMenuContribution[];
+    readonly formats?: Record<string, FeatureFormatCodec>;
+}

package/dist/foundation/plugin/types.js

@@ -0,0 +1,13 @@
+/**
+ * A command registry is necessarily heterogeneous - each entry's own
+ * params type (MarkApplyParams, TableRowParams, ...) is narrower than the
+ * `unknown` a dynamic-dispatch-by-id lookup can statically guarantee.
+ * definePluginCommand narrows the unsafe cast this requires to one place:
+ * wrap an existing, already-typed command function (TableCommand<P>,
+ * MarkCommand<P>, ...) as-is - the underlying function is never rewritten,
+ * only its params type is erased at the registry boundary, the same way
+ * every extensible command-by-id system needs to (callers are responsible
+ * for passing the right params shape for a given command id; `options`
+ * documents that shape for humans/doc-gen, it is not statically enforced).
+ */
+export const definePluginCommand = (command) => command;

package/dist/foundation/positions.d.ts

@@ -0,0 +1,20 @@
+import type { ResolvedPos, SmartDocument, SmartNode, SmartPos, SmartRange, SmartSelection } from "./types.js";
+export declare const samePath: (left: readonly number[], right: readonly number[]) => boolean;
+export declare const nodeAtPath: (document: SmartDocument, path: readonly number[]) => SmartNode | undefined;
+/** Inline atomic nodes are one indivisible offset unit (the model equivalent of U+FFFC). */
+export declare const inlineSize: (node: SmartNode) => number;
+export declare const positionLimit: (node: SmartNode) => number;
+export declare const resolvePos: (document: SmartDocument, pos: SmartPos, affinity?: "forward" | "backward") => ResolvedPos;
+export declare const comparePos: (left: SmartPos, right: SmartPos) => number;
+export declare const selectionRange: (selection: SmartSelection) => SmartRange;
+export declare const graphemeBoundaries: (text: string) => number[];
+/**
+ * Grapheme-safe inline offsets. Each text child is segmented independently and
+ * each inline atom contributes one indivisible unit, so a cluster can never
+ * bridge across an atom boundary.
+ */
+export declare const inlineGraphemeBoundaries: (children: readonly SmartNode[]) => number[];
+export declare const previousGraphemeBoundary: (text: string, offset: number) => number;
+export declare const nextGraphemeBoundary: (text: string, offset: number) => number;
+export declare const moveGrapheme: (text: string, offset: number, direction: -1 | 1) => number;
+export declare const graphemeBackspaceRange: (position: ResolvedPos, text: string) => SmartRange;

package/dist/foundation/positions.js

@@ -0,0 +1,121 @@
+import { isTextNode } from "./identity.js";
+export const samePath = (left, right) => left.length === right.length && left.every((part, index) => part === right[index]);
+export const nodeAtPath = (document, path) => {
+    let node = document;
+    for (const index of path) {
+        if (isTextNode(node) || !node.children || index < 0 || index >= node.children.length)
+            return undefined;
+        node = node.children[index];
+    }
+    return node;
+};
+/** Inline atomic nodes are one indivisible offset unit (the model equivalent of U+FFFC). */
+export const inlineSize = (node) => isTextNode(node) ? node.text.length : 1;
+export const positionLimit = (node) => {
+    if (isTextNode(node))
+        return node.text.length;
+    if (node.children && (node.type === "paragraph" || node.type === "heading" || node.type === "code_block")) {
+        return node.children.reduce((total, child) => total + inlineSize(child), 0);
+    }
+    return node.children?.length || (node.type === "unknown" ? 1 : 0);
+};
+export const resolvePos = (document, pos, affinity = "backward") => {
+    const node = nodeAtPath(document, pos.path);
+    if (!node || isTextNode(node))
+        throw new Error("A SmartPos path must resolve to an owning non-text node.");
+    const limit = positionLimit(node);
+    if (!Number.isInteger(pos.offset) || pos.offset < 0 || pos.offset > limit) {
+        throw new Error(`Position offset ${pos.offset} is outside 0..${limit}.`);
+    }
+    const ancestors = [];
+    let current = document;
+    ancestors.push(document);
+    for (const index of pos.path) {
+        if (isTextNode(current) || !current.children)
+            throw new Error("Invalid position path.");
+        current = current.children[index];
+        if (!isTextNode(current))
+            ancestors.push(current);
+    }
+    const structural = node.type !== "paragraph" && node.type !== "heading" && node.type !== "code_block";
+    const before = structural && pos.offset > 0 ? node.children?.[pos.offset - 1] || null : null;
+    const after = structural && pos.offset < limit ? node.children?.[pos.offset] || null : null;
+    return {
+        pos: { path: [...pos.path], offset: pos.offset },
+        kind: structural ? "structural" : "inline",
+        nodeId: node.id,
+        parent: node,
+        depth: pos.path.length,
+        affinity,
+        ancestors: Object.freeze(ancestors),
+        nodeBefore: before,
+        nodeAfter: after,
+        atStart: pos.offset === 0,
+        atEnd: pos.offset === limit,
+        indexAt(depth) {
+            if (!Number.isInteger(depth) || depth < 0 || depth >= pos.path.length)
+                throw new Error("Position depth is out of range.");
+            return pos.path[depth];
+        },
+    };
+};
+export const comparePos = (left, right) => {
+    const length = Math.min(left.path.length, right.path.length);
+    for (let index = 0; index < length; index += 1) {
+        if (left.path[index] !== right.path[index])
+            return left.path[index] - right.path[index];
+    }
+    if (left.path.length !== right.path.length)
+        return left.path.length - right.path.length;
+    return left.offset - right.offset;
+};
+export const selectionRange = (selection) => comparePos(selection.anchor, selection.head) <= 0
+    ? { from: selection.anchor, to: selection.head }
+    : { from: selection.head, to: selection.anchor };
+const Segmenter = Intl.Segmenter;
+const segmenter = new Segmenter(undefined, { granularity: "grapheme" });
+export const graphemeBoundaries = (text) => {
+    const boundaries = [0];
+    for (const segment of segmenter.segment(text))
+        boundaries.push(segment.index + segment.segment.length);
+    return [...new Set(boundaries)].sort((a, b) => a - b);
+};
+/**
+ * Grapheme-safe inline offsets. Each text child is segmented independently and
+ * each inline atom contributes one indivisible unit, so a cluster can never
+ * bridge across an atom boundary.
+ */
+export const inlineGraphemeBoundaries = (children) => {
+    const boundaries = [0];
+    let offset = 0;
+    children.forEach((child) => {
+        if (isTextNode(child)) {
+            graphemeBoundaries(child.text).slice(1).forEach((boundary) => boundaries.push(offset + boundary));
+            offset += child.text.length;
+        }
+        else {
+            offset += 1;
+            boundaries.push(offset);
+        }
+    });
+    return [...new Set(boundaries)].sort((left, right) => left - right);
+};
+export const previousGraphemeBoundary = (text, offset) => {
+    if (!Number.isInteger(offset) || offset < 0 || offset > text.length)
+        throw new Error("Text offset is out of bounds.");
+    const boundaries = graphemeBoundaries(text);
+    for (let index = boundaries.length - 1; index >= 0; index -= 1)
+        if (boundaries[index] < offset)
+            return boundaries[index];
+    return 0;
+};
+export const nextGraphemeBoundary = (text, offset) => {
+    if (!Number.isInteger(offset) || offset < 0 || offset > text.length)
+        throw new Error("Text offset is out of bounds.");
+    return graphemeBoundaries(text).find((boundary) => boundary > offset) ?? text.length;
+};
+export const moveGrapheme = (text, offset, direction) => direction < 0 ? previousGraphemeBoundary(text, offset) : nextGraphemeBoundary(text, offset);
+export const graphemeBackspaceRange = (position, text) => ({
+    from: { path: [...position.pos.path], offset: previousGraphemeBoundary(text, position.pos.offset) },
+    to: { path: [...position.pos.path], offset: position.pos.offset },
+});

package/dist/foundation/schema.d.ts

@@ -0,0 +1,57 @@
+import type { Repair, SmartDocument, SmartNode, SmartSchema, ValidationError } from "./types.js";
+import { type PluginRegistry } from "./plugin/registry.js";
+import { type SchemaContribution } from "./schemaBuilder.js";
+export { createSchema, parseContentExpression, type SchemaContribution } from "./schemaBuilder.js";
+export declare const contentMatches: (expression: string, children: readonly SmartNode[], schema: SmartSchema) => boolean;
+/**
+ * Node/mark types no feature-family plugin owns and that must exist
+ * regardless of which plugins are registered: the document root, plain
+ * text, hard breaks, and `unknown` itself - the disable-safety passthrough
+ * node type (see repair() below), which would be a chicken-and-egg problem
+ * if any plugin had to own it.
+ */
+export declare const baseSchema: SchemaContribution;
+/**
+ * The "all built-ins" preset, now derived from the plugin registry
+ * (plugin/registry.ts, plugin/builtins.ts) rather than a hand-maintained
+ * literal - Phase 10's runtime plugin registration applies to the default
+ * editor construction too, not just custom plugin lists. Computed once and
+ * exported alongside `foundationSchema` so editor.ts can default
+ * FoundationEditorOptions.commands/keyboardShortcuts to the same registry
+ * instance instead of recomputing it.
+ */
+export declare const foundationRegistry: PluginRegistry;
+export declare const foundationSchema: SmartSchema;
+export declare const validate: (document: SmartDocument, schema?: SmartSchema) => ValidationError[];
+export declare const repair: (input: SmartDocument, schema?: SmartSchema) => {
+    doc: SmartDocument;
+    repairs: Repair[];
+};
+/**
+ * The reverse of repair()'s "preserve-unknown" case: a node whose type is
+ * now recognized by `schema` (e.g. its owning plugin was re-enabled) is
+ * restored verbatim from the `unknown` wrapper's `raw` attribute, recursing
+ * into the restored subtree in case it too contains a now-restorable
+ * `unknown` node. This is the disable-safety round trip's other half -
+ * repair() already existed and demotes unrecognized content to `unknown`
+ * without any Phase 10 changes; this direction did not exist before.
+ */
+export declare const restoreUnknownNodes: (document: SmartDocument, schema: SmartSchema) => SmartDocument;
+/**
+ * The mark-side counterpart of restoreUnknownNodes(): a text node's
+ * "unknown-mark" sentinels (see repair()'s mark-filtering loop above) are
+ * restored to their real mark type once `schema` recognizes it again,
+ * re-sorted into canonical order since the restored type string can sort
+ * differently than "unknown-mark" did.
+ */
+export declare const restoreUnknownMarks: (document: SmartDocument, schema: SmartSchema) => SmartDocument;
+export declare const serializePersistedDocument: (value: {
+    schemaVersion: number;
+    revision: number;
+    document: SmartDocument;
+}) => string;
+export declare const parsePersistedDocument: (json: string) => {
+    schemaVersion: number;
+    revision: number;
+    document: SmartDocument;
+};