@input/pen-core 0.1.0

package/dist/index.d.cts

@@ -0,0 +1,998 @@
+import * as _input_pen_types from '@input/pen-types';
+import { ImportOptions, DocumentOp, DocumentProfile, FlowBlockCapability, InsertBlockOp, SetPropsOp, ImportResult, SchemaRegistry, BlockAuthoring, BlockSelectionRole, Editor, BlockSchema, InlineSchema, AppSchema, ComposableSchema, LayoutSchema, BlockDisplay, PropSchema, ContentType, BlockA11ySpec, Extension, DocumentState, DecorationSet, CreateEditorOptions, SchemaEngine, PenDocument, CRDTDocument, DiagnosticEvent, AppHandle, BlockHandle, CRDTAdapter, DocumentSession, Unsubscribe, Decoration, InlineCompletionController, DocumentRange, TextSelection, EditorAnchors, Anchor, AnchorTarget, Assoc, AnchorRange, ResolvedAnchorRange, SelectionRecord, SelectionState, SelectionOrigin, ChangeSummary, Point, Affinity, ReadonlySelectionState, CommitEvent, KeyBinding, CellSelection, ModelOperationRangeTarget, Block, FacetSpec, Facet, FacetProvider, FacetOutput, ApplyOptions, CommandHandlerRegistration, InputRule, AIRequestFilter, AIRequestContext, ModelAdapter, ModelRequestedOperation, ModelToolChoice, ModelStreamEvent, Command, StructuralOriginTag, SpliceTextOp, CommandHandler, Precedence, OpOrigin, MessageCatalog, A11yLabel, MessageKey, MessageArgs, MutationGroupMetadata, ToolExecutionResult, FieldEditorBehavior, FieldEditorInputMode, A11yMessageKey, TextSplice } from '@input/pen-types';
+export { ImportOptions as ImporterOptions } from '@input/pen-types';
+
+type PendingInlineSegment = {
+    type: "text";
+    text: string;
+    attributes?: Record<string, unknown>;
+} | {
+    type: "node";
+    nodeType: string;
+    props?: Record<string, unknown>;
+};
+interface PendingBlock {
+    type: string;
+    props: Record<string, unknown>;
+    content?: string;
+    marks?: Array<{
+        type: string;
+        props?: Record<string, unknown>;
+        start: number;
+        end: number;
+    }>;
+    segments?: PendingInlineSegment[];
+    children?: PendingBlock[];
+}
+declare function blocksToOps(blocks: PendingBlock[], options?: ImportOptions): DocumentOp[];
+
+type BlockSchemaCapabilityLike = {
+    authoring?: BlockAuthoring;
+    content?: string | unknown[];
+    display?: {
+        hidden?: boolean;
+    };
+    fieldEditor?: string;
+} | null | undefined;
+declare function getFlowCapabilityFromSchema(schema: BlockSchemaCapabilityLike): FlowBlockCapability | null;
+declare function getBlockSelectionRoleFromSchema(schema: BlockSchemaCapabilityLike): BlockSelectionRole | null;
+declare function getFlowCapabilityFromType(blockType: string | null | undefined): FlowBlockCapability | null;
+declare function shouldForceBlockScopedSelectAll(documentProfile: DocumentProfile, capability: FlowBlockCapability | null): boolean;
+declare function isContinuousTextFlowCapability(capability: FlowBlockCapability | null): boolean;
+declare function shouldAllowFlowInsertionInSlashMenu(documentProfile: DocumentProfile, capability: FlowBlockCapability | null): boolean;
+declare function shouldShowBlockInDefaultMenus(documentProfile: DocumentProfile, schema: BlockSchemaCapabilityLike): boolean;
+declare function shouldExposeBlockInTooling(documentProfile: DocumentProfile, schema: BlockSchemaCapabilityLike): boolean;
+declare function shouldAllowDirectBlockPaste(documentProfile: DocumentProfile, capability: FlowBlockCapability | null): boolean;
+declare function getBlockSelectionRoleFromType(blockType: string | null | undefined): BlockSelectionRole;
+declare function resolveBlockFlowCapability(registry: SchemaRegistry, blockType: string | null | undefined): FlowBlockCapability | null;
+type ImportNormalizationEditor = {
+    documentProfile: Editor["documentProfile"];
+    internals: {
+        emit: Editor["internals"]["emit"];
+    };
+};
+interface PendingBlockProfilePolicyViolation {
+    readonly blockType: string;
+    readonly documentProfile: DocumentProfile;
+    readonly capability: FlowBlockCapability;
+    readonly reason: "flow-disallowed-block";
+}
+interface PendingBlockImportPolicyViolation {
+    readonly blockType: string;
+    readonly documentProfile: DocumentProfile;
+    readonly capability: FlowBlockCapability | null;
+    readonly reason: "flow-disallowed-block" | "unknown-block-type";
+}
+declare function createImportResult(parsedTopLevelBlockCount: number, importedTopLevelBlockCount: number, violations: readonly Pick<PendingBlockImportPolicyViolation, "blockType">[]): ImportResult;
+declare function normalizePendingBlocksForImport(blocks: readonly PendingBlock[], documentProfile: DocumentProfile, registry: SchemaRegistry): {
+    readonly blocks: PendingBlock[];
+    readonly violations: PendingBlockImportPolicyViolation[];
+};
+declare function reportPendingBlockProfileViolations(editor: ImportNormalizationEditor, violations: readonly PendingBlockProfilePolicyViolation[], surface: string): void;
+declare function filterPendingBlocksForDocumentProfile(blocks: readonly PendingBlock[], documentProfile: DocumentProfile, registry: SchemaRegistry): {
+    readonly blocks: PendingBlock[];
+    readonly violations: PendingBlockProfilePolicyViolation[];
+};
+declare function reportPendingBlockImportViolations(editor: ImportNormalizationEditor, violations: readonly PendingBlockImportPolicyViolation[], surface: string): void;
+interface ProfilePolicyViolation {
+    readonly op: InsertBlockOp | SetPropsOp;
+    readonly blockType: string;
+    readonly documentProfile: DocumentProfile;
+    readonly capability: FlowBlockCapability;
+    readonly reason: "flow-disallowed-block";
+}
+declare function filterOpsForDocumentProfile(ops: readonly DocumentOp[], documentProfile: DocumentProfile, registry: SchemaRegistry): {
+    readonly ops: DocumentOp[];
+    readonly violations: ProfilePolicyViolation[];
+};
+
+interface SchemaRegistryConfig {
+    blocks?: readonly BlockSchema[];
+    inlines?: readonly InlineSchema[];
+    apps?: readonly AppSchema[];
+    systemMarks?: readonly InlineSchema[];
+    onUnknownBlock?: (type: string, raw: unknown) => BlockSchema | "drop" | "passthrough";
+    onUnknownInline?: (type: string, raw: unknown) => InlineSchema | "drop" | "passthrough";
+}
+declare class SchemaRegistryImpl implements ComposableSchema {
+    private readonly _blocks;
+    private readonly _inlines;
+    private readonly _apps;
+    private readonly _systemMarks;
+    private readonly _onUnknownBlock?;
+    private readonly _onUnknownInline?;
+    constructor(config: SchemaRegistryConfig);
+    resolve(type: string): BlockSchema | null;
+    resolveInline(type: string): InlineSchema | null;
+    resolveApp(type: string): AppSchema | null;
+    resolveLayout(type: string): LayoutSchema | null;
+    allBlocks(): readonly BlockSchema[];
+    allInlines(): readonly InlineSchema[];
+    allApps(): readonly AppSchema[];
+    allBlockDisplays(): readonly (BlockSchema & {
+        display: BlockDisplay;
+    })[];
+    extend(schemas: readonly (BlockSchema | InlineSchema)[]): ComposableSchema;
+    without(types: readonly string[]): ComposableSchema;
+    override(type: string, patch: Partial<BlockSchema>): ComposableSchema;
+    overrideSystemMark(type: string, schema: InlineSchema): ComposableSchema;
+}
+declare function mergeSchemas(...registries: SchemaRegistry[]): ComposableSchema;
+
+type DefineBlockConfig = Omit<Partial<BlockSchema<string, Record<string, PropSchema>, ContentType>>, "type" | "propSchema" | "validateProps"> & {
+    props?: Record<string, unknown>;
+    propSchema?: Record<string, unknown>;
+    aiDescription?: string;
+};
+type DefinedBlockSchema<Type extends string = string> = Omit<BlockSchema<Type, Record<string, PropSchema>, ContentType>, "a11y"> & {
+    a11y(spec: BlockA11ySpec): BlockSchema<Type, Record<string, PropSchema>, ContentType>;
+};
+declare function defineBlock<Type extends string>(type: Type, config: DefineBlockConfig): DefinedBlockSchema<Type>;
+declare function defineBlock<Type extends string>(config: DefineBlockConfig & {
+    type: Type;
+}): DefinedBlockSchema<Type>;
+
+type ExtensionCleanup = {
+    expose?: Record<string, unknown>;
+    destroy?: () => void;
+    decorations?: (state: DocumentState) => DecorationSet;
+};
+type DefineExtensionConfig<TConfig = void> = Omit<Extension, "version" | "setup"> & {
+    version?: string;
+    setup?: TConfig extends void ? (editor: Editor) => ExtensionCleanup | void : (editor: Editor, config: TConfig) => ExtensionCleanup | void;
+};
+declare function defineExtension<TConfig = void>(config: DefineExtensionConfig<TConfig>): Extension;
+
+declare class PropChainImpl {
+    private _schema;
+    constructor(init: Record<string, unknown>);
+    default(value: unknown): this;
+    describe(text: string): this;
+    min(value: number): this;
+    max(value: number): this;
+    optional(): PropChainImpl;
+    toSchema(): PropSchema;
+    toJSON(): Record<string, unknown>;
+}
+declare function resolveSchema(value: unknown): PropSchema;
+declare const prop: {
+    string(): PropChainImpl;
+    number(): PropChainImpl;
+    boolean(): PropChainImpl;
+    enum(values: readonly (string | number)[]): PropChainImpl;
+    array(items: PropChainImpl | PropSchema): PropChainImpl;
+    object(properties: Record<string, PropChainImpl | PropSchema>): PropChainImpl;
+    json(): PropChainImpl;
+    optional(inner: PropChainImpl): PropChainImpl;
+};
+
+/** Empty registry for hosts that do not pass `schema` or a preset that provides one. */
+declare function createEmptySchema(): SchemaRegistryImpl;
+declare function resolveEditorSchema(options?: CreateEditorOptions): SchemaRegistry;
+
+declare function sortDeltaAttributes(attributes: Record<string, unknown>, registry: SchemaRegistry): Record<string, unknown>;
+declare function deepEqual(a: unknown, b: unknown): boolean;
+type DiagnosticSink = (event: DiagnosticEvent) => void;
+declare class SchemaEngineImpl implements SchemaEngine {
+    private readonly registry;
+    private readonly doc;
+    private readonly crdtDoc;
+    private readonly dirtyBlockIds;
+    private readonly deferredBlockIds;
+    private onDiagnostic;
+    private passIndex;
+    constructor(registry: SchemaRegistry, doc: PenDocument, crdtDoc: CRDTDocument, onDiagnostic?: DiagnosticSink);
+    setOnDiagnostic(onDiagnostic: DiagnosticSink | undefined): void;
+    markDirty(blockId: string): void;
+    deferBlock(blockId: string): void;
+    undeferBlock(blockId: string): void;
+    normalizeDirty(): void;
+    normalizeAll(): void;
+    private normalizeBlock;
+    private stripSuperfluousMarks;
+    private ensureContentExists;
+    private stripDefaultProps;
+    private runBlockNormalize;
+    private normalizeLayout;
+    private deduplicateBlockIds;
+    private deduplicateBlockOrder;
+    private deduplicateArray;
+    private deduplicateAtIndices;
+    private handleDeletedBlock;
+    private breakParentCycle;
+    private walkParentCycle;
+    private parentOf;
+    private readParentIdProp;
+    private parentEdgeOwner;
+    private clearParentEdge;
+    private enforceCrossArrayMembership;
+    private isInBlockOrder;
+    private findParentWithChild;
+    private removeFromBlockOrder;
+    private insertIntoBlockOrder;
+    private getBlockOrderIndex;
+    private readPropsWithDefaults;
+    private get blockOrder();
+    private get blocksMap();
+    private getBlockMap;
+    private deleteBlock;
+    private getPassIndex;
+    private invalidatePassIndex;
+    private buildPassIndex;
+}
+
+declare function createBlockHandle(blockId: string, doc: PenDocument, crdtDoc: CRDTDocument, registry: SchemaRegistry): BlockHandle;
+declare function createAppHandle(appId: string, doc: PenDocument, crdtDoc: CRDTDocument, registry: SchemaRegistry): AppHandle;
+
+declare const suggestion: InlineSchema;
+
+declare function createEditor(options?: CreateEditorOptions): Editor;
+interface CreateHeadlessEditorOptions extends CreateEditorOptions {
+    /**
+     * Headless server/workflow editors default to the core apply pipeline only.
+     * Enable default extensions when a host explicitly needs undo, shortcuts, or
+     * delta stream behavior in a non-rendered environment.
+     */
+    useDefaultExtensions?: boolean;
+}
+declare function createHeadlessEditor(options?: CreateHeadlessEditorOptions): Editor;
+
+interface CreateDocumentSessionOptions {
+    adapter: CRDTAdapter;
+    document?: CRDTDocument;
+    destroyWhenIdle?: boolean;
+    ownsDocuments?: boolean;
+}
+declare function createDocumentSession(options: CreateDocumentSessionOptions): DocumentSession;
+
+type Handler = (...args: unknown[]) => void;
+declare class EventEmitter {
+    private readonly _handlers;
+    on(event: string, handler: Handler): Unsubscribe;
+    off(event: string, handler: Handler): void;
+    emit(event: string, ...args: unknown[]): void;
+    has(event: string): boolean;
+    removeAllListeners(event?: string): void;
+}
+
+declare function createDecorationSet(decorations: Decoration[]): DecorationSet;
+declare function emptyDecorationSet(): DecorationSet;
+declare function mergeDecorationSets(...sets: DecorationSet[]): DecorationSet;
+
+declare function getInlineCompletionController(editor: Editor): InlineCompletionController | null;
+declare function ensureInlineCompletionController(editor: Editor): {
+    controller: InlineCompletionController;
+    isOwner: boolean;
+    release: () => void;
+};
+
+declare class DocumentRangeImpl implements DocumentRange {
+    readonly start: {
+        blockId: string;
+        offset: number;
+    };
+    readonly end: {
+        blockId: string;
+        offset: number;
+    };
+    private readonly _anchor;
+    private readonly _focus;
+    private readonly _doc;
+    constructor(anchor: {
+        blockId: string;
+        offset?: number;
+    }, focus: {
+        blockId: string;
+        offset?: number;
+    }, doc: PenDocument);
+    get isMultiBlock(): boolean;
+    get blockRange(): string[];
+    contains(point: {
+        blockId: string;
+        offset: number;
+    }): boolean;
+    overlaps(other: DocumentRange): boolean;
+    equals(other: DocumentRange): boolean;
+    toTextSelection(): TextSelection;
+    private _indexOfBlock;
+}
+
+interface EditorAnchorsHost {
+    adapter: CRDTAdapter;
+    emit(event: DiagnosticEvent): void;
+    commitId(): number;
+}
+declare class EditorAnchorsImpl implements EditorAnchors {
+    private _doc;
+    private readonly _host;
+    private readonly _cache;
+    private readonly _lastTarget;
+    private _liveCount;
+    private _budgetWarned;
+    constructor(doc: CRDTDocument, host: EditorAnchorsHost);
+    get liveCount(): number;
+    updateDocument(doc: CRDTDocument): void;
+    peekLastTarget(anchor: Anchor): AnchorTarget | null;
+    rememberTarget(anchor: Anchor, target: AnchorTarget): void;
+    remint(target: AnchorTarget, assoc: Assoc, provenance: Anchor["provenance"]): Anchor | null;
+    create(target: AnchorTarget, assoc?: Assoc): Anchor | null;
+    range(range: {
+        anchor: AnchorTarget;
+        focus: AnchorTarget;
+    }): AnchorRange | null;
+    resolve(anchor: Anchor): AnchorTarget | null;
+    resolveRange(range: AnchorRange): ResolvedAnchorRange | null;
+    serialize(anchor: Anchor): string;
+    deserialize(input: string): Anchor | null;
+    private _noteMint;
+    private _rejectDecode;
+}
+
+interface SelectionAuthority {
+    readonly record: SelectionRecord;
+    set(state: SelectionState, options: {
+        origin: SelectionOrigin;
+    }): SelectionRecord;
+    onCommit(summary: ChangeSummary): void;
+}
+declare class SelectionAuthorityImpl implements SelectionAuthority {
+    private _state;
+    private _version;
+    private _origin;
+    private _commitId;
+    private _doc;
+    private _crdtDoc;
+    private readonly _registry;
+    private readonly _emitter;
+    private readonly _anchors;
+    private _editor;
+    private _fromAnchor;
+    private _toAnchor;
+    constructor(doc: PenDocument, crdtDoc: CRDTDocument, registry: SchemaRegistry, emitter: EventEmitter, anchors: EditorAnchorsImpl);
+    bindEditor(editor: Editor): void;
+    get record(): SelectionRecord;
+    getSelection(): SelectionState;
+    set(state: SelectionState, options: {
+        origin: SelectionOrigin;
+    }): SelectionRecord;
+    onCommit(summary: ChangeSummary): void;
+    updateDocument(doc: PenDocument, crdtDoc: CRDTDocument): void;
+    getSelectedText(): string;
+    getSelectedBlocks(): BlockHandle[];
+    private _accept;
+    private _repairHeldAnchors;
+    private _isNonTextBlock;
+    private _clampOffset;
+    private _logicalText;
+    /** N1: each inline embed occupies one logical offset. */
+    private _logicalLength;
+    private _tableGrid;
+    private _blockExists;
+    private _handle;
+    private _emitMissingBlock;
+    private _emitDiagnostic;
+    private _getSelectedCellText;
+}
+
+/**
+ * A pre-commit text range that a structural commit copied onto another block (AN14).
+ */
+interface ContentMove {
+    readonly fromBlockId: string;
+    readonly fromRange: {
+        readonly from: number;
+        readonly to: number;
+    };
+    readonly toBlockId: string;
+    readonly toOffset: number;
+}
+/**
+ * Derive the copy-based content moves a structural commit performed (AN14).
+ *
+ * Local Pen commits expose `block-split` / `blocks-merged` on the summary.
+ * Remote commits without those tags fall back to same-length delete/insert pairing.
+ * `intent` is accepted for the AN14 signature; recipes live on the summary.
+ */
+declare function deriveContentMoves(summary: ChangeSummary, _intent: string | undefined): readonly ContentMove[];
+/**
+ * Re-mint into the destination when the pre-commit target sat in a moved range (AN14).
+ *
+ * Returns the same object when no move applies. Remint keeps the original provenance.
+ */
+declare function repairAnchor(editor: Editor, anchor: Anchor, moves: readonly ContentMove[]): Anchor;
+
+/**
+ * Reads the selection authority's current {@link SelectionRecord} from an editor.
+ *
+ * The record carries the version and origin alongside the selection state, which
+ * the DOM reader needs to tell a projection echo from a fresh user gesture. The
+ * plain `editor.selection` state cannot answer that.
+ *
+ * @param editor - Any editor; the record lives on the runtime implementation.
+ * @returns The current record, or `null` on an editor that does not carry one.
+ */
+declare function getEditorSelectionRecord(editor: Editor): SelectionRecord | null;
+
+type ReadonlyTextSelection = Extract<ReadonlySelectionState, {
+    type: "text";
+}>;
+/**
+ * Live `TextSelection` constructor. Defaults `affinity` / `goalX`.
+ * Predicates and the block span are helpers, not fields.
+ */
+declare function createTextSelection(input: {
+    readonly anchor: Point;
+    readonly focus: Point;
+    readonly affinity?: Affinity;
+    readonly goalX?: number | null;
+}): TextSelection;
+declare function isCollapsed(sel: ReadonlySelectionState): boolean;
+declare function isMultiBlock(sel: ReadonlySelectionState): boolean;
+/**
+ * Document-order block ids covered by `sel`. Pass a plain `blockOrder`
+ * snapshot (`editor.documentState.blockOrder`) from a renderer effect —
+ * walking a live `Y.Array` through a deep-proxied document writes back.
+ */
+declare function getSelectionBlockRange(doc: PenDocument | readonly string[], sel: ReadonlySelectionState): string[];
+declare function isBlockSelected(blockOrder: readonly string[], sel: ReadonlySelectionState, blockId: string): boolean;
+declare function selectionToRange(doc: PenDocument, sel: ReadonlyTextSelection): DocumentRange;
+
+/**
+ * N1–N3 normal caret positions (`spec/rules/selection.md` §3).
+ *
+ * Pure functions over a fake doc snapshot. Not wired to the
+ * manager, commands, or reader.
+ */
+
+type NormalPositionDirection = -1 | 1;
+
+interface BlockBoundary {
+    readonly blockBoundary: string;
+}
+type NextNormalPositionResult = Point | BlockBoundary | null;
+interface AtomExtent {
+    readonly start: number;
+    readonly end: number;
+}
+type NormalPositionBlockKind = "text" | "structural";
+interface NormalPositionBlock {
+    readonly kind: NormalPositionBlockKind;
+    readonly text: string;
+    readonly atoms?: readonly AtomExtent[];
+}
+/**
+ * A document-shaped view sufficient to decide whether a point is a normal position.
+ *
+ * Deliberately not the live document: normal-position checks run on the DOM read
+ * path, and walking the CRDT there couples reading to document mutation. Build one
+ * with `buildNormalPositionSnapshot`.
+ */
+interface NormalPositionSnapshot {
+    readonly blockOrder: readonly string[];
+    readonly blocks: Readonly<Record<string, NormalPositionBlock>>;
+}
+/**
+ * Snap a point onto a normal position without stepping.
+ * Interior atom offsets go to the start (`-1`) or end (`1`).
+ * Non-text blocks yield `{ blockBoundary }` (N2).
+ */
+declare function snapToNormalPosition(doc: NormalPositionSnapshot, point: Point, direction: NormalPositionDirection): NextNormalPositionResult;
+
+/**
+ * Ops that change one block's type in place, keeping its id and its text.
+ *
+ * A nested block's `parentId` is re-asserted after the type change, because
+ * `set-props` replaces the prop set and would otherwise orphan the block out
+ * of its parent.
+ */
+declare function convertBlockOps(editor: Editor, options: {
+    blockId: string;
+    newType: string;
+    newProps?: Record<string, unknown>;
+}): DocumentOp[];
+
+/**
+ * Captures a {@link NormalPositionSnapshot} from an editor's current document.
+ *
+ * Exported so renderers can feed `snapToNormalPosition` without building a second
+ * adapter over the document shape; two snapshot builders would drift apart and the
+ * snap rule would disagree with core about where a caret may legally sit.
+ *
+ * @param editor - The editor to read block order and block content from.
+ * @returns A snapshot detached from the live document.
+ */
+declare function buildNormalPositionSnapshot(editor: Editor): NormalPositionSnapshot;
+
+declare class ExtensionManagerImpl {
+    private readonly _extensions;
+    private _sorted;
+    private readonly _stateMap;
+    private readonly _emitter;
+    constructor(emitter: EventEmitter);
+    private _emitLifecycleDiagnostic;
+    register(ext: Extension): void;
+    unregister(name: string): void;
+    activateAll(editor: Editor): Promise<void>;
+    deactivateAll(editor: Editor): Promise<void>;
+    dispatchObserve(events: readonly CommitEvent[], editor: Editor): void;
+    collectDecorations(state: DocumentState, editor: Editor): DecorationSet;
+    collectKeyBindings(registry: SchemaRegistry, extensionBindings?: readonly KeyBinding[]): readonly KeyBinding[];
+    getExtensionState<T>(name: string): T | undefined;
+    private _resortAndValidate;
+}
+declare function collectEditorKeyBindings(editor: Editor): readonly KeyBinding[];
+
+/**
+ * Named commit-pipeline phases from spec/rules/pipeline.md.
+ * Step 2.1 makes the boundaries visible; step 2.2 replaces phase 8's
+ * v1 `change` / `documentCommit` emit with `CommitEvent`.
+ */
+declare const PIPELINE_PHASES: readonly ["hooks", "validate", "execute", "normalize", "summarize", "map-selection", "settle-facets", "emit"];
+/** Nested applies beyond this queue depth in one task turn trip `apply-storm` (I7). */
+declare const APPLY_STORM_QUEUE_LIMIT = 16;
+declare const APPLY_STORM_CODE = "apply-storm";
+
+interface ResolvedCellSelectionCell {
+    row: number;
+    col: number;
+    rowId: string | null;
+    columnId: string | null;
+}
+declare function hasIndexedCellSelectionMetadata(selection: CellSelection): boolean;
+declare function resolveCellSelectionCoord(block: BlockHandle, selection: CellSelection, coord: {
+    row: number;
+    col: number;
+}): ResolvedCellSelectionCell | null;
+declare function resolveCellSelectionMatrix(block: BlockHandle, selection: CellSelection): ResolvedCellSelectionCell[][];
+
+declare function getNumberedListItemValue(block: BlockHandle | null | undefined): number | null;
+
+declare function resolveSelectionTargetBlockIds(editor: Editor, target: ModelOperationRangeTarget): string[];
+declare function renderSelectionTargetText(editor: Editor, target: ModelOperationRangeTarget, options?: {
+    resolved?: boolean;
+}): string;
+declare function renderSelectionTargetBlockText(editor: Editor, target: ModelOperationRangeTarget, options?: {
+    resolved?: boolean;
+}): string;
+
+declare function buildTableChildren(handle: BlockHandle): Block[] | undefined;
+
+interface DocumentMigration {
+    readonly id: string;
+    run(editor: Editor): void;
+}
+interface MigrationReport {
+    readonly applied: readonly string[];
+    readonly skipped: readonly string[];
+    readonly failed: readonly {
+        id: string;
+        error: unknown;
+    }[];
+}
+
+declare function runMigrations(editor: Editor, migrations: readonly DocumentMigration[]): MigrationReport;
+
+/**
+ * Grapheme/word boundary queries and match folding (LOC4, LOC5).
+ *
+ * `Intl.Segmenter` is above the HOST4 floor (Firefox only since 125). It is
+ * feature-detected on every call. When it is missing:
+ * - character operations degrade to code points, never to UTF-16 code units
+ * - word operations degrade to whitespace runs
+ *
+ * Offsets are in the logical text domain (`spec/rules/selection.md` §2): UTF-16
+ * indices into the block string with the empty-block sentinel already erased.
+ * This module does not look for the sentinel.
+ */
+interface WordRange {
+    readonly start: number;
+    readonly end: number;
+}
+declare function previousGraphemeBoundary(text: string, offset: number, locale: string): number;
+declare function nextGraphemeBoundary(text: string, offset: number, locale: string): number;
+declare function previousWordBoundary(text: string, offset: number, locale: string): number;
+declare function nextWordBoundary(text: string, offset: number, locale: string): number;
+declare function wordRangeAt(text: string, offset: number, locale: string): WordRange | null;
+/**
+ * Locale-aware case fold plus NFC for match comparison (LOC5).
+ * Maps Greek final sigma to medial sigma. Not `toLowerCase()` — that misses
+ * Turkish ı/I and ς/σ.
+ */
+declare function foldAndNormalize(text: string, locale: string): string;
+
+declare function defineFacet<Input, Output = readonly Input[]>(spec: FacetSpec<Input, Output>): Facet<Input, Output>;
+
+interface FacetSettleInput {
+    readonly commitId?: number;
+    readonly emptyCommit?: boolean;
+    readonly selectionVersion?: number;
+}
+
+interface CreateFacetRegistryOptions {
+    extensions?: readonly Extension[];
+    providers?: readonly FacetProvider[];
+    editor?: Editor;
+}
+interface FacetRegistry {
+    markReady(): void;
+    read<F extends Facet<unknown, unknown>>(facet: F): FacetOutput<F>;
+    override<F extends Facet<unknown, unknown>>(facet: F, value: FacetOutput<F>): void;
+    settle(input: FacetSettleInput): void;
+}
+declare function createFacetRegistry(options?: CreateFacetRegistryOptions): FacetRegistry;
+
+type Keymap = readonly KeyBinding[];
+type BeforeApplyHook = (ops: DocumentOp[], options: ApplyOptions) => DocumentOp[];
+type DecorationSource = ((state: DocumentState, editor: Editor) => DecorationSet) | DecorationSet;
+type ClipboardHandler = unknown;
+type CommandHandlerTable = {
+    readonly [commandName: string]: readonly CommandHandlerRegistration[];
+};
+declare const keymapFacet: _input_pen_types.Facet<Keymap, readonly KeyBinding[]>;
+declare const beforeApplyFacet: _input_pen_types.Facet<BeforeApplyHook, readonly BeforeApplyHook[]>;
+declare const decorationsFacet: _input_pen_types.Facet<DecorationSource, readonly DecorationSource[]>;
+declare const inputRulesFacet: _input_pen_types.Facet<InputRule, readonly InputRule[]>;
+declare const commandsFacet: _input_pen_types.Facet<CommandHandlerRegistration<unknown>, CommandHandlerTable>;
+declare const ariaReadOnlyFacet: _input_pen_types.Facet<boolean, boolean>;
+declare const clipboardFacet: _input_pen_types.Facet<unknown, readonly unknown[]>;
+
+type UrlContext = "link" | "image" | "media" | "download";
+interface UrlPolicy {
+    resolve(rawValue: unknown, context: UrlContext): string | null;
+}
+declare const urlPolicy: UrlPolicy;
+
+declare const urlPolicyFacet: _input_pen_types.Facet<UrlPolicy, UrlPolicy | undefined>;
+
+declare const aiEgressFacet: _input_pen_types.Facet<AIRequestFilter, AIRequestFilter | undefined>;
+declare function aiEgressExtension(filter: AIRequestFilter): Extension;
+declare function filterAIRequest(editor: Editor, context: AIRequestContext): AIRequestContext | null;
+/**
+ * The one door to a `ModelAdapter` (AIB1). `extras` carries every request field
+ * that is not filterable content, so a caller needing one of them forwards it
+ * here rather than wrapping the adapter — a wrapper would set that field after
+ * the filter ran, and would be a second call site the filter does not govern.
+ */
+declare function streamThroughEgress(editor: Editor, model: ModelAdapter, context: AIRequestContext, extras?: {
+    signal?: AbortSignal;
+    requestMode?: string;
+    operation?: ModelRequestedOperation | null;
+    sessionId?: string;
+    turnId?: string;
+    generationId?: string;
+    toolChoice?: ModelToolChoice;
+}): AsyncIterable<ModelStreamEvent>;
+
+type BlockDirection = "ltr" | "rtl";
+type BlockDirectionSetting = BlockDirection | "auto";
+
+type BlockDirectionResolver = (block: BlockHandle, editor: Editor) => BlockDirection | null | undefined;
+declare const blockDirectionFacet: _input_pen_types.Facet<BlockDirectionResolver, readonly BlockDirectionResolver[]>;
+declare const defaultDirectionFacet: _input_pen_types.Facet<BlockDirection, BlockDirection>;
+
+declare function resolveBlockDirection(editor: Editor, block: BlockHandle): BlockDirection;
+
+/**
+ * Stored text of a block. Empty string is empty; missing blocks emit a
+ * diagnostic and return "".
+ */
+declare function blockLogicalText(editor: Editor, blockId: string): string;
+
+type DefaultKeymapContext = "text" | "cell" | "block" | "any";
+type KeymapPlatform = "macos" | "windows" | "linux";
+interface DefaultKeymapBinding {
+    readonly key: string;
+    readonly command: Command<unknown>;
+    readonly param?: unknown;
+    readonly context?: DefaultKeymapContext;
+}
+declare function resolveDefaultKeymap(platform: KeymapPlatform): readonly DefaultKeymapBinding[];
+declare const defaultKeymapBindings: {
+    shared: readonly DefaultKeymapBinding[];
+    macos: readonly DefaultKeymapBinding[];
+    windowsLinux: readonly DefaultKeymapBinding[];
+};
+
+/**
+ * K1 / M2: remap a matched keymap binding for the focus block's resolved
+ * direction. Command handlers stay logical; only the dispatched command
+ * changes. Intended once per keystroke on the matched binding — direction
+ * comes from the DIR1 fingerprint cache, not a geometry measure.
+ */
+declare function resolveDirectedBinding(editor: Editor, binding: DefaultKeymapBinding): DefaultKeymapBinding;
+/** DIR1-cached resolved direction of the focus block, or null if none. */
+declare function resolveFocusBlockDirection(editor: Editor): BlockDirection | null;
+/**
+ * Pure M2 / M4 command swap. `pen.caretLeft/Right` and word variants flip
+ * under rtl; line, vertical, and delete commands are untouched.
+ */
+declare function resolveDirectedCommand<P>(command: Command<P>, direction: BlockDirection): Command<P>;
+declare function applyDirectedBinding(binding: DefaultKeymapBinding, direction: BlockDirection): DefaultKeymapBinding;
+
+declare function spliceInsertOp(blockId: string, offset: number, text: string, marks?: Record<string, unknown | null>): SpliceTextOp;
+declare function spliceDeleteOp(blockId: string, offset: number, length: number): SpliceTextOp;
+declare function buildSplitBlockRecipe(options: {
+    block: BlockHandle;
+    offset: number;
+    newBlockId: string;
+    newBlockType?: string;
+}): {
+    ops: DocumentOp[];
+    structural: StructuralOriginTag;
+};
+declare function buildMergeBlocksRecipe(options: {
+    target: BlockHandle;
+    source: BlockHandle;
+}): {
+    ops: DocumentOp[];
+    structural: StructuralOriginTag;
+};
+declare function applySplitBlock(editor: Editor, options: {
+    blockId: string;
+    offset: number;
+    newBlockId: string;
+    newBlockType?: string;
+    applyOptions?: ApplyOptions;
+}): void;
+declare function applyMergeBlocks(editor: Editor, options: {
+    targetBlockId: string;
+    sourceBlockId: string;
+    applyOptions?: ApplyOptions;
+}): void;
+
+declare function defineCommand<P = void>(name: string): Command<P>;
+declare function commandHandler<P>(command: Command<P>, handler: CommandHandler<P>, precedence?: Precedence): FacetProvider;
+
+interface CommandDispatchContext {
+    origin?: OpOrigin;
+    fromKeymap?: boolean;
+}
+interface RecordedApplyIntent {
+    ops: DocumentOp[];
+    options?: ApplyOptions;
+}
+interface RecordedSelectionIntent {
+    selection: SelectionState;
+    origin: "keyboard" | "programmatic";
+}
+interface CreateCommandRegistryOptions {
+    providers?: readonly FacetProvider[];
+    editor?: Editor;
+    apply?: (ops: DocumentOp[], options?: ApplyOptions) => void;
+    setSelection?: (selection: SelectionState, origin: "keyboard" | "programmatic") => void;
+}
+interface CommandRegistry {
+    dispatch<P>(command: Command<P>, param: P, context?: CommandDispatchContext): boolean;
+    canDispatch<P>(command: Command<P>, param: P): boolean;
+    probe(): Editor;
+    readonly recordedApplies: readonly RecordedApplyIntent[];
+    readonly recordedSelections: readonly RecordedSelectionIntent[];
+    readonly diagnostics: readonly DiagnosticEvent[];
+}
+declare function createCommandRegistry(options?: CreateCommandRegistryOptions): CommandRegistry;
+
+declare function getCommandRegistry(editor: Editor): CommandRegistry | undefined;
+
+declare function builtinCommandHandlers(): FacetProvider[];
+
+interface CaretMotionParam {
+    readonly extend: boolean;
+}
+interface SelectBlockParam {
+    readonly blockId: string;
+}
+
+type CellCaretFocus = {
+    readonly blockId: string;
+    readonly row: number;
+    readonly col: number;
+    readonly start: number;
+    readonly end: number;
+};
+type CellCaretWrite = (next: {
+    readonly start: number;
+    readonly end: number;
+}) => void;
+declare function setCellCaretFocus(editor: Editor, focus: CellCaretFocus | null, write?: CellCaretWrite | null): void;
+declare function getCellCaretFocus(editor: Editor): CellCaretFocus | null;
+
+declare const caretLeft: _input_pen_types.Command<CaretMotionParam>;
+declare const caretRight: _input_pen_types.Command<CaretMotionParam>;
+declare const caretUp: _input_pen_types.Command<CaretMotionParam>;
+declare const caretDown: _input_pen_types.Command<CaretMotionParam>;
+declare const caretLineStart: _input_pen_types.Command<CaretMotionParam>;
+declare const caretLineEnd: _input_pen_types.Command<CaretMotionParam>;
+declare const caretBlockStart: _input_pen_types.Command<CaretMotionParam>;
+declare const caretBlockEnd: _input_pen_types.Command<CaretMotionParam>;
+declare const caretDocStart: _input_pen_types.Command<CaretMotionParam>;
+declare const caretDocEnd: _input_pen_types.Command<CaretMotionParam>;
+declare const caretWordLeft: _input_pen_types.Command<CaretMotionParam>;
+declare const caretWordRight: _input_pen_types.Command<CaretMotionParam>;
+declare const selectAll: _input_pen_types.Command<void>;
+declare const selectBlock: _input_pen_types.Command<SelectBlockParam>;
+
+/**
+ * Geometry seam for `pen.caretUp` / `pen.caretDown` (G5).
+ *
+ * Core cannot import `@input/pen-dom`. The field-editor host registers
+ * `measureNow(() => verticalCaretTarget(...))` here after `createEditor()`.
+ * Headless tests inject a fake. Until a measure is registered, the handlers
+ * cross at logical block edges and emit `caret-geometry-unavailable` as a
+ * defined no-op when the caret is mid-block (no throw, no silent miss).
+ *
+ * Stored on a symbol of the editor instance so registry dispatch proxies
+ * (which forward `get` to the source) still see the same seam. `goalX` is
+ * here because v1 `SelectionState` has no field for it.
+ * No rAF / timeout / retry — S4.
+ */
+type VerticalCaretDirection = "up" | "down";
+type VerticalCaretPoint = {
+    readonly blockId: string;
+    readonly offset: number;
+};
+type VerticalCaretMeasureResult = {
+    readonly point: VerticalCaretPoint;
+    readonly goalX: number;
+};
+type VerticalCaretMeasure = (editor: Editor, current: VerticalCaretPoint, direction: VerticalCaretDirection, goalX: number | null) => VerticalCaretMeasureResult | null;
+declare function setVerticalCaretMeasure(editor: Editor, measure: VerticalCaretMeasure | null): void;
+declare function getVerticalCaretMeasure(editor: Editor): VerticalCaretMeasure | undefined;
+declare function getVerticalCaretGoalX(editor: Editor): number | null;
+declare function setVerticalCaretGoalX(editor: Editor, goalX: number | null): void;
+
+type DeleteGranularity = "grapheme" | "word" | "line";
+interface InsertTextParam {
+    readonly text: string;
+    readonly marks?: Record<string, unknown | null>;
+}
+interface DeleteParam {
+    readonly granularity: DeleteGranularity;
+}
+interface ToggleMarkParam {
+    readonly mark: string;
+    readonly value?: unknown;
+}
+interface ConvertBlockParam {
+    readonly blockId: string;
+    readonly newType: string;
+    readonly newProps?: Record<string, unknown>;
+}
+
+/**
+ * Adjacent inline atom → SELECT it. Does not mutate the document.
+ * The next delete (non-collapsed `handleDelete`) removes it through the
+ * ordinary selection-delete path.
+ */
+declare function selectAdjacentInlineAtom(editor: Editor, direction: "backward" | "forward"): SelectionState | null;
+/**
+ * One-shot helper: adjacent inline atom → DELETE it.
+ * Same detection as `selectAdjacentInlineAtom`. The live registry no
+ * longer calls this; first-press Backspace / Delete selects instead.
+ */
+declare function deleteAdjacentInlineAtom(editor: Editor, direction: "backward" | "forward"): {
+    ops: DocumentOp[];
+    caret: Point;
+} | null;
+
+declare const insertText: _input_pen_types.Command<InsertTextParam>;
+declare const deleteBackward: _input_pen_types.Command<DeleteParam>;
+declare const deleteForward: _input_pen_types.Command<DeleteParam>;
+declare const insertLineBreak: _input_pen_types.Command<void>;
+declare const splitBlock: _input_pen_types.Command<void>;
+declare const indent: _input_pen_types.Command<void>;
+declare const outdent: _input_pen_types.Command<void>;
+declare const toggleMark: _input_pen_types.Command<ToggleMarkParam>;
+declare const convertBlock: _input_pen_types.Command<ConvertBlockParam>;
+
+interface StructureBlockParam {
+    readonly blockId?: string;
+}
+declare const moveBlockUp: _input_pen_types.Command<StructureBlockParam>;
+declare const moveBlockDown: _input_pen_types.Command<StructureBlockParam>;
+declare const duplicateBlock: _input_pen_types.Command<StructureBlockParam>;
+declare const deleteBlock: _input_pen_types.Command<StructureBlockParam>;
+
+declare const tableCellNext: _input_pen_types.Command<void>;
+declare const tableCellPrev: _input_pen_types.Command<void>;
+declare const tableCellDown: _input_pen_types.Command<void>;
+declare const tableEscapeGrid: _input_pen_types.Command<void>;
+
+declare const historyUndo: _input_pen_types.Command<void>;
+declare const historyRedo: _input_pen_types.Command<void>;
+
+declare const localeFacet: _input_pen_types.Facet<string, string>;
+declare const messagesFacet: _input_pen_types.Facet<Partial<MessageCatalog>, MessageCatalog>;
+
+declare const a11yLabelFacet: _input_pen_types.Facet<A11yLabel, A11yLabel | undefined>;
+
+declare function interpolateMessage(template: string, params?: Record<string, unknown>): string;
+declare function resolveMessage<K extends MessageKey>(catalog: Partial<MessageCatalog>, key: K, ...args: MessageArgs<K>): string;
+
+declare function getOpOriginType(origin: OpOrigin): string;
+declare function getOpOriginGroupId(origin: OpOrigin): string | undefined;
+declare function getApplyOptionsGroupId(origin: OpOrigin, options?: Pick<ApplyOptions, "groupId" | "undoGroupId">): string | undefined;
+declare function createMutationGroupMetadata(origin: OpOrigin, groupId: string): MutationGroupMetadata;
+
+declare function collectToolExecutionOutput(result: ToolExecutionResult, onPart?: (part: unknown, output: unknown) => void): Promise<unknown>;
+
+type FieldEditorSchemaLike = Pick<BlockSchema, "content" | "fieldEditor">;
+declare function resolveFieldEditorBehavior(schema: FieldEditorSchemaLike | null | undefined): FieldEditorBehavior;
+declare function resolveFieldEditorInputMode(schema: FieldEditorSchemaLike | null | undefined): FieldEditorInputMode;
+declare function usesInlineTextSelection(schema: FieldEditorSchemaLike | null | undefined): boolean;
+declare function supportsInlineMarks(schema: FieldEditorSchemaLike | null | undefined): boolean;
+declare function supportsInlineInputRules(schema: FieldEditorSchemaLike | null | undefined): boolean;
+declare function delegatesToGridEditing(schema: FieldEditorSchemaLike | null | undefined): boolean;
+declare function hasFieldEditorSurface(schema: FieldEditorSchemaLike | null | undefined): boolean;
+
+declare function resolveEditorMessage<K extends MessageKey>(editor: Editor, key: K, ...args: MessageArgs<K>): string;
+
+declare const A11Y_MISSING_LABEL_CODE = "a11y-missing-label";
+interface EditorA11yLabelAttrs {
+    "aria-label"?: string;
+    "aria-labelledby"?: string;
+}
+declare function resolveEditorA11yLabel(editor: Editor): EditorA11yLabelAttrs;
+
+declare function announceEditorA11y<K extends A11yMessageKey>(editor: Editor, key: K, ...args: MessageArgs<`pen.a11y.${K}` & MessageKey>): void;
+declare function resolveA11yBlockTypeLabel(editor: Editor, type: string): string;
+
+type SchemaA11yKind = "block" | "inline";
+type SchemaA11yAttrs = {
+    label: string;
+    roleDescription?: string;
+};
+declare function resolveSchemaA11y(editor: Editor, target: {
+    kind: SchemaA11yKind;
+    type: string;
+    props: Record<string, unknown>;
+}): SchemaA11yAttrs;
+declare function resolveA11ySpec(spec: BlockA11ySpec | undefined, type: string, props: Record<string, unknown>, editor?: Editor): SchemaA11yAttrs;
+
+declare const PSEUDO_LOCALE_OPEN = "[[";
+declare const PSEUDO_LOCALE_CLOSE = " \u00B7\u00B7\u00B7]]";
+declare function toPseudoLocaleText(text: string): string;
+declare function createPseudoLocaleCatalog(catalog?: MessageCatalog): MessageCatalog;
+declare function isPseudoLocaleText(text: string): boolean;
+
+declare const HOOK_PRIORITIES: {
+    readonly AUTH: 100;
+    readonly SUGGEST: 200;
+    readonly INPUT_RULE: 300;
+    readonly DEFAULT: 500;
+};
+declare function priorityToPrecedence(priority: number): Precedence;
+declare function hookPriorityToPrecedence(priority: number): Precedence;
+declare function keyBindingPriorityToPrecedence(priority: number): Precedence;
+
+declare function singleController<T>(name: string): _input_pen_types.Facet<T, T | null>;
+declare const fieldEditorHostFacet: _input_pen_types.Facet<unknown, unknown>;
+declare const inputRulesEngineFacet: _input_pen_types.Facet<unknown, unknown>;
+declare const undoRestoreControllerFacet: _input_pen_types.Facet<unknown, unknown>;
+declare const undoMetadataControllerFacet: _input_pen_types.Facet<unknown, unknown>;
+declare const undoManagerFacet: _input_pen_types.Facet<unknown, unknown>;
+declare const aiInlineCompletionFacet: _input_pen_types.Facet<unknown, unknown>;
+declare const aiControllerFacet: _input_pen_types.Facet<unknown, unknown>;
+declare const aiInlineHistoryFacet: _input_pen_types.Facet<unknown, unknown>;
+declare const aiReviewControllerFacet: _input_pen_types.Facet<unknown, unknown>;
+declare const aiAutocompleteControllerFacet: _input_pen_types.Facet<unknown, unknown>;
+declare const aiSuggestionsControllerFacet: _input_pen_types.Facet<unknown, unknown>;
+declare const searchControllerFacet: _input_pen_types.Facet<unknown, unknown>;
+declare const multiplayerControllerFacet: _input_pen_types.Facet<unknown, unknown>;
+declare const snapshotsControllerFacet: _input_pen_types.Facet<unknown, unknown>;
+declare const assetProviderFacet: _input_pen_types.Facet<unknown, unknown>;
+declare const toolRuntimeFacet: _input_pen_types.Facet<unknown, unknown>;
+declare const announcerFacet: _input_pen_types.Facet<unknown, unknown>;
+declare const streamingTargetFacet: _input_pen_types.Facet<unknown, unknown>;
+
+declare function affectedBlockIdsFromSummary(summary: Pick<ChangeSummary, "blockText" | "structural">, documentOrder?: readonly string[]): string[];
+
+/**
+ * The splice helper is a function, not an algebra. `mapOffsetThroughSplices`
+ * is a pure convenience for derived-tier providers shifting per-block results
+ * within **one** summary. Clamp semantics only. There is no `compose`, no
+ * multi-summary form, no map modes, and no cross-commit law: code that needs a
+ * position to survive more than one commit uses an anchor (I13).
+ */
+declare function mapOffsetThroughSplices(splices: readonly TextSplice[], offset: number, assoc: Assoc): number;
+
+export { A11Y_MISSING_LABEL_CODE, APPLY_STORM_CODE, APPLY_STORM_QUEUE_LIMIT, type BeforeApplyHook, type BlockDirection, type BlockDirectionResolver, type BlockDirectionSetting, type CaretMotionParam, type CellCaretFocus, type CellCaretWrite, type ClipboardHandler, type CommandDispatchContext, type CommandHandlerTable, type CommandRegistry, type ContentMove, type ConvertBlockParam, type CreateCommandRegistryOptions, type CreateFacetRegistryOptions, type CreateHeadlessEditorOptions, type DecorationSource, type DefaultKeymapBinding, type DefaultKeymapContext, type DefinedBlockSchema, type DeleteGranularity, type DeleteParam, type DocumentMigration, DocumentRangeImpl, type EditorA11yLabelAttrs, EventEmitter, ExtensionManagerImpl, type FacetRegistry, type FacetSettleInput, HOOK_PRIORITIES, type InsertTextParam, type Keymap, type KeymapPlatform, type MigrationReport, type NormalPositionSnapshot, PIPELINE_PHASES, PSEUDO_LOCALE_CLOSE, PSEUDO_LOCALE_OPEN, type PendingBlock, type PendingBlockImportPolicyViolation, type PendingBlockProfilePolicyViolation, type ProfilePolicyViolation, type SchemaA11yAttrs, type SchemaA11yKind, SchemaEngineImpl, type SchemaRegistryConfig, SchemaRegistryImpl, type SelectBlockParam, SelectionAuthorityImpl as SelectionAuthority, type StructureBlockParam, type ToggleMarkParam, type UrlContext, type UrlPolicy, type VerticalCaretDirection, type VerticalCaretMeasure, type VerticalCaretMeasureResult, type VerticalCaretPoint, type WordRange, a11yLabelFacet, affectedBlockIdsFromSummary, aiAutocompleteControllerFacet, aiControllerFacet, aiEgressExtension, aiEgressFacet, aiInlineCompletionFacet, aiInlineHistoryFacet, aiReviewControllerFacet, aiSuggestionsControllerFacet, announceEditorA11y, announcerFacet, applyDirectedBinding, applyMergeBlocks, applySplitBlock, ariaReadOnlyFacet, assetProviderFacet, beforeApplyFacet, blockDirectionFacet, blockLogicalText, blocksToOps, buildMergeBlocksRecipe, buildNormalPositionSnapshot, buildSplitBlockRecipe, buildTableChildren, builtinCommandHandlers, caretBlockEnd, caretBlockStart, caretDocEnd, caretDocStart, caretDown, caretLeft, caretLineEnd, caretLineStart, caretRight, caretUp, caretWordLeft, caretWordRight, clipboardFacet, collectEditorKeyBindings, collectToolExecutionOutput, commandHandler, commandsFacet, convertBlock, convertBlockOps, createAppHandle, createBlockHandle, createCommandRegistry, createDecorationSet, createDocumentSession, createEditor, createEmptySchema, createFacetRegistry, createHeadlessEditor, createImportResult, createMutationGroupMetadata, createPseudoLocaleCatalog, createTextSelection, decorationsFacet, deepEqual, defaultDirectionFacet, defaultKeymapBindings, defineBlock, defineCommand, defineExtension, defineFacet, delegatesToGridEditing, deleteAdjacentInlineAtom, deleteBackward, deleteBlock, deleteForward, deriveContentMoves, duplicateBlock, emptyDecorationSet, ensureInlineCompletionController, fieldEditorHostFacet, filterAIRequest, filterOpsForDocumentProfile, filterPendingBlocksForDocumentProfile, foldAndNormalize, getApplyOptionsGroupId, getBlockSelectionRoleFromSchema, getBlockSelectionRoleFromType, getCellCaretFocus, getCommandRegistry, getEditorSelectionRecord, getFlowCapabilityFromSchema, getFlowCapabilityFromType, getInlineCompletionController, getNumberedListItemValue, getOpOriginGroupId, getOpOriginType, getSelectionBlockRange, getVerticalCaretGoalX, getVerticalCaretMeasure, hasFieldEditorSurface, hasIndexedCellSelectionMetadata, historyRedo, historyUndo, hookPriorityToPrecedence, indent, inputRulesEngineFacet, inputRulesFacet, insertLineBreak, insertText, interpolateMessage, isBlockSelected, isCollapsed, isContinuousTextFlowCapability, isMultiBlock, isPseudoLocaleText, keyBindingPriorityToPrecedence, keymapFacet, localeFacet, mapOffsetThroughSplices, mergeDecorationSets, mergeSchemas, messagesFacet, moveBlockDown, moveBlockUp, multiplayerControllerFacet, nextGraphemeBoundary, nextWordBoundary, normalizePendingBlocksForImport, outdent, previousGraphemeBoundary, previousWordBoundary, priorityToPrecedence, prop, renderSelectionTargetBlockText, renderSelectionTargetText, repairAnchor, reportPendingBlockImportViolations, reportPendingBlockProfileViolations, resolveA11yBlockTypeLabel, resolveA11ySpec, resolveBlockDirection, resolveBlockFlowCapability, resolveCellSelectionCoord, resolveCellSelectionMatrix, resolveDefaultKeymap, resolveDirectedBinding, resolveDirectedCommand, resolveEditorA11yLabel, resolveEditorMessage, resolveEditorSchema, resolveFieldEditorBehavior, resolveFieldEditorInputMode, resolveFocusBlockDirection, resolveMessage, resolveSchema, resolveSchemaA11y, resolveSelectionTargetBlockIds, runMigrations, searchControllerFacet, selectAdjacentInlineAtom, selectAll, selectBlock, selectionToRange, setCellCaretFocus, setVerticalCaretGoalX, setVerticalCaretMeasure, shouldAllowDirectBlockPaste, shouldAllowFlowInsertionInSlashMenu, shouldExposeBlockInTooling, shouldForceBlockScopedSelectAll, shouldShowBlockInDefaultMenus, singleController, snapToNormalPosition, snapshotsControllerFacet, sortDeltaAttributes, spliceDeleteOp, spliceInsertOp, splitBlock, streamThroughEgress, streamingTargetFacet, suggestion, supportsInlineInputRules, supportsInlineMarks, tableCellDown, tableCellNext, tableCellPrev, tableEscapeGrid, toPseudoLocaleText, toggleMark, toolRuntimeFacet, undoManagerFacet, undoMetadataControllerFacet, undoRestoreControllerFacet, urlPolicy, urlPolicyFacet, usesInlineTextSelection, wordRangeAt };