@input/pen-types 0.1.0

package/dist/index.d.ts

@@ -0,0 +1,2477 @@
+type Unsubscribe = () => void;
+type Spacing = number | {
+    top?: number;
+    right?: number;
+    bottom?: number;
+    left?: number;
+};
+type BorderDef = {
+    width?: number;
+    style?: string;
+    color?: string;
+};
+
+/**
+ * Which side of a position inserted text lands on. `-1` sticks to the
+ * character before the position, `1` to the character after — so a caret with
+ * `assoc: -1` stays put when text is inserted at its offset, and one with
+ * `assoc: 1` is pushed along by it.
+ *
+ * This is the single declaration; `@input/pen-types/anchors` re-exports it.
+ */
+type Assoc = -1 | 1;
+type DefaultAssoc = 1;
+interface Point {
+    readonly blockId: string;
+    readonly offset: number;
+}
+interface TextSplice {
+    readonly from: number;
+    readonly to: number;
+    readonly insertLength: number;
+}
+interface BlockTextChange {
+    readonly blockId: string;
+    readonly splices: readonly TextSplice[];
+    readonly formatRanges: readonly {
+        from: number;
+        to: number;
+    }[];
+}
+type StructuralChange = {
+    readonly type: "block-inserted";
+    readonly blockId: string;
+    readonly parentId: string | null;
+    readonly index: number;
+} | {
+    readonly type: "block-removed";
+    readonly blockId: string;
+    readonly parentId: string | null;
+    readonly index: number;
+} | {
+    readonly type: "block-moved";
+    readonly blockId: string;
+    readonly fromParentId: string | null;
+    readonly fromIndex: number;
+    readonly toParentId: string | null;
+    readonly toIndex: number;
+} | {
+    readonly type: "block-props-changed";
+    readonly blockId: string;
+    readonly keys: readonly string[];
+} | {
+    readonly type: "block-split";
+    readonly blockId: string;
+    readonly newBlockId: string;
+    readonly offset: number;
+} | {
+    readonly type: "blocks-merged";
+    readonly targetBlockId: string;
+    readonly sourceBlockId: string;
+    readonly joinOffset: number;
+} | {
+    readonly type: "table-changed";
+    readonly blockId: string;
+} | {
+    readonly type: "apps-changed";
+    readonly appIds: readonly string[];
+} | {
+    readonly type: "metadata-changed";
+    readonly namespaces: readonly string[];
+};
+interface ChangeSummary {
+    readonly commitId: number;
+    readonly blockText: readonly BlockTextChange[];
+    readonly structural: readonly StructuralChange[];
+    readonly affectedBlockIds: readonly string[];
+}
+
+/**
+ * A resolved document location in the logical text domain (AN1, AN10).
+ */
+interface AnchorTarget {
+    readonly blockId: string;
+    readonly offset: number;
+    readonly cell?: {
+        readonly row: number;
+        readonly col: number;
+    };
+}
+/**
+ * A frozen CRDT-relative position minted against one block or cell (AN12).
+ */
+interface Anchor {
+    readonly kind: "anchor";
+    readonly blockId: string;
+    readonly assoc: Assoc;
+    readonly cell?: {
+        readonly row: number;
+        readonly col: number;
+    };
+    readonly position: Uint8Array;
+    readonly provenance: "local" | "wire";
+}
+/**
+ * A pair of anchors that bound a range (AN5).
+ */
+interface AnchorRange {
+    readonly kind: "anchor-range";
+    readonly from: Anchor;
+    readonly to: Anchor;
+}
+/**
+ * A resolved {@link AnchorRange} plus the AN5 collapse signal.
+ */
+interface ResolvedAnchorRange {
+    readonly from: AnchorTarget;
+    readonly to: AnchorTarget;
+    readonly collapsed: boolean;
+}
+/**
+ * Resolver flag for {@link CRDTAdapter.resolveRelativePosition} (AN13).
+ *
+ * Local-provenance anchors pass `true`; wire-provenance anchors pass `false`.
+ */
+interface ResolveRelativePositionOptions {
+    readonly followUndoneDeletions?: boolean;
+}
+/**
+ * Editor-facing anchor mint, resolve, and wire surface (AN6, AN8, AN9, AN11).
+ */
+interface EditorAnchors {
+    /** Mint a local-provenance anchor, or `null` plus `anchor-target-missing` if the target is gone. */
+    create(target: AnchorTarget, assoc?: Assoc): Anchor | null;
+    /** Mint a range (`from` assoc `-1`, `to` assoc `1`), or `null` if either end is missing. */
+    range(range: {
+        anchor: AnchorTarget;
+        focus: AnchorTarget;
+    }): AnchorRange | null;
+    /** Resolve to a live target, or `null` (AN1). */
+    resolve(anchor: Anchor): AnchorTarget | null;
+    /** Resolve both ends and set `collapsed` when they meet (AN5). */
+    resolveRange(range: AnchorRange): ResolvedAnchorRange | null;
+    /** Encode the v1 wire JSON (AN11). */
+    serialize(anchor: Anchor): string;
+    /** Decode untrusted input; never throws (AN6). */
+    deserialize(input: string): Anchor | null;
+    /** Live minted-or-deserialized count for the AN9 budget. */
+    readonly liveCount: number;
+}
+
+interface Block<Type extends string = string, Props extends Record<string, unknown> = Record<string, unknown>> {
+    id: string;
+    type: Type;
+    props: Props;
+    content?: string;
+    children?: Block[];
+}
+type AnchorPosition = "before" | "after" | "left" | "right" | "overlay";
+type AppPlacement = {
+    mode: "inline";
+    blockId: string;
+    index: number;
+} | {
+    mode: "anchored";
+    blockId: string;
+    anchor: AnchorPosition;
+};
+interface App<Type extends string = string, Config extends Record<string, unknown> = Record<string, unknown>> {
+    id: string;
+    type: Type;
+    config: Config;
+    placement: AppPlacement;
+}
+interface Range {
+    index: number;
+    length: number;
+}
+
+type OpOriginType = "user" | "ai" | "ai-session" | "suggestion-resolution" | "collaborator" | "extension" | "history" | "input-rule" | "app" | "import" | "system" | "migration";
+interface StructuredOpOrigin {
+    type: OpOriginType | (string & {});
+    groupId?: string;
+    requestId?: string;
+    actorId?: string;
+    source?: string;
+    intent?: string;
+}
+type OpOrigin = OpOriginType | StructuredOpOrigin;
+interface MutationGroupMetadata {
+    groupId: string;
+    originType: string;
+    requestId?: string;
+    actorId?: string;
+    source?: string;
+}
+type StructuralOriginTag = {
+    kind: "split";
+    blockId: string;
+    newBlockId: string;
+    offset: number;
+} | {
+    kind: "merge";
+    targetBlockId: string;
+    sourceBlockId: string;
+};
+interface ApplyOptions {
+    origin?: OpOrigin;
+    undoGroup?: boolean;
+    groupId?: string;
+    undoGroupId?: string;
+    /** In-transaction AN14 stamp for split/merge recipes. Not hung on origin. */
+    structural?: StructuralOriginTag;
+}
+declare const MUTATION_GROUP_METADATA_KEY = "mutation-group";
+type Position = "first" | "last" | {
+    before: string;
+} | {
+    after: string;
+} | {
+    parent: string;
+    index: number;
+};
+type DocumentOp = SpliceTextOp | FormatTextOp | InsertBlockOp | DeleteBlockOp | MoveBlockOp | SetPropsOp | SetMetaOp | GridOp | AppOp | StreamOpenOp;
+type InlineInsert = string | {
+    readonly nodeType: string;
+    readonly props: Record<string, unknown>;
+};
+interface SpliceTextOp {
+    type: "splice-text";
+    blockId: string;
+    cell?: {
+        row: number;
+        col: number;
+    };
+    from: number;
+    to: number;
+    insert: InlineInsert | readonly InlineInsert[];
+    marks?: Record<string, unknown | null>;
+}
+interface FormatTextOp {
+    type: "format-text";
+    blockId: string;
+    cell?: {
+        row: number;
+        col: number;
+    };
+    from: number;
+    to: number;
+    marks: Record<string, unknown | null>;
+}
+interface InsertBlockOp {
+    type: "insert-block";
+    blockId: string;
+    blockType: string;
+    props: Record<string, unknown>;
+    position: Position;
+}
+interface DeleteBlockOp {
+    type: "delete-block";
+    blockId: string;
+}
+interface MoveBlockOp {
+    type: "move-block";
+    blockId: string;
+    position: Position;
+}
+interface SetPropsOp {
+    type: "set-props";
+    blockId: string;
+    props: Record<string, unknown | null>;
+}
+interface SetMetaOp {
+    type: "set-meta";
+    blockId: string;
+    namespace: string;
+    data: Record<string, unknown> | null;
+}
+type GridChange = {
+    kind: "insert-row";
+    index: number;
+} | {
+    kind: "delete-row";
+    index: number;
+} | {
+    kind: "insert-column";
+    index: number;
+} | {
+    kind: "delete-column";
+    index: number;
+} | {
+    kind: "merge-cells";
+    anchor: {
+        row: number;
+        col: number;
+    };
+    head: {
+        row: number;
+        col: number;
+    };
+} | {
+    kind: "split-cell";
+    row: number;
+    col: number;
+};
+interface GridOp {
+    type: "grid";
+    blockId: string;
+    change: GridChange;
+}
+type AppChange = {
+    kind: "create";
+    appId: string;
+    appType: string;
+    config: Record<string, unknown>;
+    placement: AppPlacement;
+} | {
+    kind: "update";
+    appId: string;
+    patch: Record<string, unknown>;
+} | {
+    kind: "delete";
+    appId: string;
+};
+interface AppOp {
+    type: "app";
+    change: AppChange;
+}
+/** Synthetic open-time op for stream veto (`06-commit-pipeline.md` ST1). */
+interface StreamOpenOp {
+    type: "stream-open";
+    blockId: string;
+}
+
+/**
+ * Caret display side at line-wrap and bidi-run boundaries (`03-selection.md` §1.1).
+ * Meaningless for a non-collapsed text selection.
+ */
+type Affinity = "upstream" | "downstream";
+type SelectionOrigin = "pointer" | "keyboard" | "ime" | "programmatic" | "mapped" | "restore" | "gc";
+interface TextSelection {
+    type: "text";
+    anchor: Point;
+    focus: Point;
+    /**
+     * Written by SelectionAuthority. Absent on v1 manager
+     * objects; readers default to `"downstream"`.
+     */
+    readonly affinity?: Affinity;
+    /**
+     * Preserved visual x for vertical caret motion. Null unless the last
+     * motion was vertical. Written by SelectionAuthority.
+     */
+    readonly goalX?: number | null;
+}
+interface BlockSelection {
+    type: "block";
+    readonly blockIds: readonly string[];
+    /** Block that extends/shrinks on shift-arrow. Written by SelectionAuthority. */
+    readonly head?: string;
+}
+interface AppSelection {
+    type: "app";
+    appId: string;
+}
+interface CellSelection {
+    type: "cell";
+    blockId: string;
+    anchor: {
+        row: number;
+        col: number;
+    };
+    head: {
+        row: number;
+        col: number;
+    };
+    rowIds?: string[];
+    columnIds?: string[];
+}
+type SelectionState = TextSelection | BlockSelection | AppSelection | CellSelection | null;
+/**
+ * Read view of `SelectionState`. Helpers only read, so they take this
+ * rather than the live writable value. Nested fields are readonly
+ * (cell coords are readonly). A live `SelectionState` assigns here,
+ * and so does any deep-readonly unwrap of the same value.
+ */
+type ReadonlySelectionState = {
+    readonly type: "text";
+    readonly anchor: Point;
+    readonly focus: Point;
+    readonly affinity?: Affinity;
+    readonly goalX?: number | null;
+} | {
+    readonly type: "block";
+    readonly blockIds: readonly string[];
+    readonly head?: string;
+} | {
+    readonly type: "app";
+    readonly appId: string;
+} | {
+    readonly type: "cell";
+    readonly blockId: string;
+    readonly anchor: {
+        readonly row: number;
+        readonly col: number;
+    };
+    readonly head: {
+        readonly row: number;
+        readonly col: number;
+    };
+    readonly rowIds?: readonly string[];
+    readonly columnIds?: readonly string[];
+} | null;
+/**
+ * Serializable selection as of a commit. Same variants as `SelectionState`.
+ * `affinity` / `goalX` / `head` are required here because
+ * `snapshotSelectionRecord` already writes them.
+ *
+ * Computed v1 fields (`isCollapsed` / `isMultiBlock` / `blockRange` /
+ * `toRange`) live on helpers in `@input/pen-core`, not on either shape.
+ */
+type SelectionRecordState = {
+    readonly type: "text";
+    readonly anchor: Point;
+    readonly focus: Point;
+    readonly affinity: Affinity;
+    readonly goalX: number | null;
+} | {
+    readonly type: "block";
+    readonly blockIds: readonly string[];
+    readonly head: string;
+} | {
+    readonly type: "app";
+    readonly appId: string;
+} | {
+    readonly type: "cell";
+    readonly blockId: string;
+    readonly anchor: {
+        readonly row: number;
+        readonly col: number;
+    };
+    readonly head: {
+        readonly row: number;
+        readonly col: number;
+    };
+} | null;
+interface SelectionRecord {
+    readonly state: SelectionRecordState;
+    readonly version: number;
+    readonly origin: SelectionOrigin;
+    readonly commitId: number;
+}
+
+interface DocumentRange {
+    start: {
+        blockId: string;
+        offset: number;
+    };
+    end: {
+        blockId: string;
+        offset: number;
+    };
+    readonly isMultiBlock: boolean;
+    readonly blockRange: string[];
+    contains(point: {
+        blockId: string;
+        offset: number;
+    }): boolean;
+    overlaps(other: DocumentRange): boolean;
+    equals(other: DocumentRange): boolean;
+    toTextSelection(): TextSelection;
+}
+
+type DocumentProfile = "structured" | "flow";
+interface CRDTArray<T> {
+    readonly length: number;
+    get(index: number): T;
+    toArray(): T[];
+    [Symbol.iterator](): Iterator<T>;
+}
+interface CRDTMap<T> {
+    get(key: string): T | undefined;
+    has(key: string): boolean;
+    entries(): IterableIterator<[string, T]>;
+    keys(): IterableIterator<string>;
+    readonly size: number;
+}
+interface LoadDocumentOptions {
+    /**
+     * Apply structural repairs (duplicate `blockOrder` entries, dangling
+     * references, orphans). Defaults to `true`. The diagnostic list from
+     * `onDiagnostic` / `getDocumentLoadReport` is the API for what changed.
+     */
+    repair?: boolean;
+}
+interface CRDTAdapter {
+    createDocument(): CRDTDocument;
+    loadDocument(binary: Uint8Array, options?: LoadDocumentOptions): CRDTDocument;
+    encodeState(doc: CRDTDocument): Uint8Array;
+    encodeUpdate(doc: CRDTDocument, since?: Uint8Array): Uint8Array;
+    applyUpdate(doc: CRDTDocument, update: Uint8Array): void;
+    transact(doc: CRDTDocument, fn: () => void, origin?: unknown): void;
+    createUndoManager(doc: CRDTDocument, options?: UndoManagerOptions): CRDTUndoManager;
+    createAwareness?(doc: CRDTDocument): Awareness;
+    observe(doc: CRDTDocument, callback: (event: CRDTEvent) => void): Unsubscribe;
+    createSnapshot(doc: CRDTDocument): Uint8Array;
+    restoreSnapshot(doc: CRDTDocument, snapshot: Uint8Array): CRDTDocument;
+    mergeUpdates?(updates: Uint8Array[]): Uint8Array;
+    fork?(doc: CRDTDocument): CRDTDocument;
+    merge?(target: CRDTDocument, source: CRDTDocument): void;
+    getClientId(doc: CRDTDocument): number;
+    getDocumentProfile?(doc: CRDTDocument): DocumentProfile | null;
+    setDocumentProfile?(doc: CRDTDocument, profile: DocumentProfile): void;
+    raw<T>(doc: CRDTDocument): T;
+    createMap(): unknown;
+    createArray(): unknown;
+    createText(): unknown;
+    initBlockMap(doc: CRDTDocument, blockId: string, blockType: string, contentType: "inline" | "nested" | "table" | "subdocument" | "none"): unknown;
+    getAttributionRanges?(doc: CRDTDocument, blockId: string): AttributionRange[];
+    /** Mint an encoded relative position for `target`, or `null` if it is missing. */
+    createRelativePosition(doc: CRDTDocument, target: AnchorTarget, assoc: Assoc): Uint8Array | null;
+    /**
+     * Resolve an encoded relative position (AN1).
+     *
+     * `options.followUndoneDeletions` is the AN13 path flag, never a constant.
+     * The three-argument form is shipped; a two-arg adapter was never frozen.
+     * Host policy lives on `editor.anchors.resolve` (provenance), not here.
+     */
+    resolveRelativePosition(doc: CRDTDocument, encoded: Uint8Array, options?: ResolveRelativePositionOptions): AnchorTarget | null;
+}
+interface AttributionRange {
+    offset: number;
+    length: number;
+    clientId: number;
+}
+type DocumentScopeKind = "root" | "subdocument";
+interface DocumentScopeInfo {
+    id: string;
+    guid: string;
+    kind: DocumentScopeKind;
+    parentId: string | null;
+    ownerBlockId: string | null;
+}
+interface DocumentScope extends DocumentScopeInfo {
+    readonly doc: CRDTDocument;
+}
+interface CreateSubdocumentOptions {
+    scopeId?: string;
+    guid?: string;
+    autoLoad?: boolean;
+}
+interface DocumentScopeLookupOptions {
+    scopeId?: string;
+}
+interface ReplaceScopeDocumentOptions {
+    destroyReplacedDoc?: boolean;
+}
+interface DocumentScopeReplacementEvent {
+    previousScope: DocumentScopeInfo;
+    scope: DocumentScope;
+}
+interface DocumentSessionAttachOptions {
+    onScopeReplaced?: (event: DocumentScopeReplacementEvent) => void;
+}
+interface DocumentSession {
+    readonly adapter: CRDTAdapter;
+    readonly rootScope: DocumentScope;
+    getScope(scopeId: string): DocumentScope | null;
+    getScopeByGuid(guid: string): DocumentScope | null;
+    getScopeForBlock(blockId: string, options?: DocumentScopeLookupOptions): DocumentScope | null;
+    listScopes(): readonly DocumentScope[];
+    getAwareness(scopeId?: string): Awareness | null;
+    observe(scopeId: string, callback: (event: CRDTEvent) => void): Unsubscribe;
+    observeAll(callback: (event: CRDTEvent) => void): Unsubscribe;
+    createSubdocument(blockId: string, options?: CreateSubdocumentOptions): DocumentScope | null;
+    loadSubdocument(scopeId: string): void;
+    replaceScopeDocument(scopeId: string, doc: CRDTDocument, options?: ReplaceScopeDocumentOptions): void;
+    attachEditor(options?: DocumentSessionAttachOptions): Unsubscribe;
+    destroy(): void;
+}
+interface CRDTDocument {
+    readonly adapter: CRDTAdapter;
+}
+interface PenDocument {
+    readonly blockOrder: CRDTArray<string>;
+    readonly blocks: CRDTMap<unknown>;
+    readonly apps: CRDTMap<unknown>;
+    readonly metadata: CRDTMap<unknown>;
+    readonly adapter: CRDTAdapter;
+}
+interface UndoManagerOptions {
+    trackedOriginTypes?: string[];
+    captureTimeout?: number;
+    /**
+     * Maximum undo/redo stack items to retain.
+     * Defaults to 500 (CH7). Y.UndoManager has no native cap; the Yjs
+     * adapter trims oldest items on `stack-item-added`.
+     */
+    maxDepth?: number;
+}
+interface CRDTUndoManager {
+    undo(): boolean;
+    redo(): boolean;
+    canUndo(): boolean;
+    canRedo(): boolean;
+    stopCapturing(): void;
+    setCaptureTimeout?(ms: number): void;
+    addTrackedOrigin(originType: string): void;
+    removeTrackedOrigin(originType: string): void;
+    destroy(): void;
+    onStackItemAdded?(callback: (stackItem: CRDTUndoStackItem, kind: "undo" | "redo") => void): Unsubscribe;
+    onStackItemUpdated?(callback: (stackItem: CRDTUndoStackItem, kind: "undo" | "redo") => void): Unsubscribe;
+    onStackItemPopped?(callback: (stackItem: CRDTUndoStackItem, kind: "undo" | "redo") => void): Unsubscribe;
+}
+interface CRDTUndoStackItem {
+    getMeta<T>(key: string): T | undefined;
+    setMeta(key: string, value: unknown): void;
+}
+interface AwarenessChangeEvent {
+    added: number[];
+    updated: number[];
+    removed: number[];
+}
+interface Awareness {
+    getLocalState(): Record<string, unknown> | null;
+    setLocalState(state: Record<string, unknown> | null): void;
+    getStates(): Map<number, Record<string, unknown>>;
+    on(event: "change", callback: (changes: AwarenessChangeEvent) => void): void;
+    off(event: "change", callback: (changes: AwarenessChangeEvent) => void): void;
+    destroy(): void;
+}
+interface GenerationZone {
+    id: string;
+    blockId: string;
+    range: DocumentRange;
+    status: "idle" | "streaming" | "complete" | "error";
+}
+interface CRDTEvent {
+    origin: OpOrigin;
+    readonly affectedBlocks: readonly string[];
+    ops: readonly DocumentOp[];
+    timestamp: number;
+    scope?: DocumentScopeInfo;
+    /** Pipeline-stamped commit source; observer-originated events omit this. */
+    readonly source?: "apply" | "remote" | "undo" | "redo" | "stream";
+}
+
+type Precedence = "highest" | "high" | "default" | "low" | "lowest";
+interface FacetSpec<Input, Output> {
+    readonly name: string;
+    combine(inputs: readonly Input[]): Output;
+    compareOutput?(a: Output, b: Output): boolean;
+    compareInput?(a: Input, b: Input): boolean;
+    readonly static?: boolean;
+}
+interface Facet<Input, Output = readonly Input[]> {
+    readonly name: string;
+    of(value: Input, precedence?: Precedence): FacetProvider;
+    compute(deps: readonly FacetDependency[], fn: (editor: Editor) => Input, precedence?: Precedence): FacetProvider;
+}
+type FacetDependency = Facet<unknown, unknown> | "document" | "selection";
+interface FacetProvider {
+    readonly facetName: string;
+    readonly precedence: Precedence;
+}
+type FacetOutput<F> = F extends Facet<infer _Input, infer Output> ? Output : never;
+type DefineFacet = <Input, Output = readonly Input[]>(spec: FacetSpec<Input, Output>) => Facet<Input, Output>;
+
+type Decoration = InlineDecoration | BlockDecoration | AppDecoration;
+interface InlineDecoration {
+    type: "inline";
+    blockId: string;
+    from: number;
+    to: number;
+    attributes: Record<string, string | number | boolean>;
+    virtualText?: string;
+    virtualPlacement?: "before" | "after";
+    /** When true, decorated text is omitted from rendered output (e.g. hidden delete ranges). */
+    omitFromRender?: boolean;
+    key?: string;
+}
+/** Generic decoration attribute written when {@link InlineDecoration.omitFromRender} is true. */
+declare const DECORATION_OMIT_FROM_RENDER_ATTRIBUTE = "data-pen-omit-from-render";
+interface BlockDecoration {
+    type: "block";
+    blockId: string;
+    attributes: Record<string, string | number | boolean>;
+    position?: "before" | "after" | "wrap";
+}
+interface AppDecoration {
+    type: "app";
+    blockId: string;
+    offset: number;
+    component: unknown;
+    key: string;
+}
+interface DecorationSet {
+    readonly decorations: readonly Decoration[];
+    readonly generation: number;
+    forBlock(blockId: string): readonly Decoration[];
+    inlineForBlock(blockId: string): readonly InlineDecoration[];
+    equals(other: DecorationSet): boolean;
+}
+
+interface ServerExtensionContext {
+    editor: Editor;
+    emit(event: string, payload?: unknown): void;
+    getState<T>(name: string): T | undefined;
+}
+interface ClientExtensionContext extends ServerExtensionContext {
+    dom?: Document;
+}
+interface Extension {
+    name: string;
+    version: string;
+    readonly dependencies?: readonly string[];
+    readonly facets?: readonly FacetProvider[];
+    activateServer?(ctx: ServerExtensionContext): Promise<void>;
+    deactivateServer?(): Promise<void>;
+    activateClient?(ctx: ClientExtensionContext): Promise<void>;
+    deactivateClient?(): Promise<void>;
+    observe?(events: readonly CommitEvent[], editor: Editor): void;
+    state?: ExtensionStateSpec<unknown>;
+}
+interface ExtensionStateSpec<T> {
+    init(editor: Editor): T;
+    apply?(state: T, events: readonly CommitEvent[], editor: Editor): T;
+}
+
+type BlockCapabilityKey = "table";
+
+interface BlockCapabilityMap {
+    table: TableBlockHandle;
+}
+
+interface LayoutSchema {
+    modes: readonly ("flex" | "grid")[];
+    defaultMode: "flex" | "grid";
+    allowedChildren?: string[];
+    minChildren?: number;
+    maxChildren?: number;
+}
+interface LayoutProps {
+    display: "flex" | "grid";
+    direction?: "row" | "column" | "row-reverse" | "column-reverse";
+    wrap?: "nowrap" | "wrap" | "wrap-reverse";
+    gap?: number | string;
+    alignItems?: "start" | "center" | "end" | "stretch" | "baseline";
+    justifyContent?: "start" | "center" | "end" | "between" | "around" | "evenly";
+    columns?: string;
+    rows?: string;
+    autoFlow?: "row" | "column" | "dense";
+    padding?: Spacing;
+    margin?: Spacing;
+    background?: string;
+    border?: BorderDef;
+    borderRadius?: number | string;
+    width?: string;
+    maxWidth?: string;
+    minHeight?: string;
+    overflow?: "visible" | "hidden" | "auto";
+}
+
+type ColumnType = "text" | "number" | "checkbox" | "select" | "multiSelect" | "date" | "url" | "email" | "relation" | "formula";
+interface SelectOption {
+    id: string;
+    value: string;
+    color?: string;
+    label?: string;
+}
+interface NumberFormat {
+    style: "plain" | "currency" | "percent";
+    decimals?: number;
+    currency?: string;
+}
+interface DateFormat {
+    includeTime?: boolean;
+    dateStyle?: "short" | "medium" | "long";
+}
+
+interface TableRowHandle {
+    readonly id: string;
+    readonly index: number;
+}
+interface InlineNodeDeltaInsert {
+    type: string;
+    props: Record<string, unknown>;
+}
+interface InlineDelta {
+    insert: string | InlineNodeDeltaInsert;
+    attributes?: Record<string, unknown>;
+}
+interface TableColumnSchema {
+    id: string;
+    title: string;
+    type: ColumnType;
+    width?: number;
+    hidden?: boolean;
+    pinned?: "left" | "right";
+    options?: SelectOption[];
+    format?: NumberFormat | DateFormat;
+    readonly?: boolean;
+}
+interface TableCellHandle {
+    readonly id: string;
+    readonly row: number;
+    readonly col: number;
+    textContent(): string;
+    length(): number;
+    inlineDeltas(): InlineDelta[];
+    textDeltas(): Array<{
+        insert: string;
+        attributes?: Record<string, unknown>;
+    }>;
+}
+interface BlockHandle {
+    readonly id: string;
+    readonly type: string;
+    readonly props: Readonly<Record<string, unknown>>;
+    readonly index: number;
+    readonly prev: BlockHandle | null;
+    readonly next: BlockHandle | null;
+    readonly parent: BlockHandle | null;
+    readonly children: readonly BlockHandle[];
+    descendants(type?: string): Iterable<BlockHandle>;
+    ancestors(): Iterable<BlockHandle>;
+    siblings(): Iterable<BlockHandle>;
+    readonly layout: LayoutProps | null;
+    readonly isLayoutChild: boolean;
+    layoutParent(): BlockHandle | null;
+    anchoredApps(): readonly AppHandle[];
+    textContent(options?: {
+        resolved?: boolean;
+    }): string;
+    inlineDeltas(): InlineDelta[];
+    textDeltas(): Array<{
+        insert: string;
+        attributes?: Record<string, unknown>;
+    }>;
+    length(): number;
+    as<K extends BlockCapabilityKey>(capability: K): BlockCapabilityMap[K] | null;
+    meta(namespace: string): Readonly<Record<string, unknown>> | null;
+}
+interface TableBlockHandle extends BlockHandle {
+    tableRowCount(): number;
+    tableColumnCount(): number;
+    tableRow(row: number): TableRowHandle | null;
+    tableCell(row: number, col: number): TableCellHandle | null;
+    tableColumns(): readonly TableColumnSchema[];
+}
+interface AppHandle {
+    readonly id: string;
+    readonly type: string;
+    readonly placement: AppPlacement;
+    readonly config: Readonly<Record<string, unknown>>;
+    readonly anchorBlock: BlockHandle | null;
+}
+
+interface MarkdownNode {
+    type: string;
+    children?: MarkdownNode[];
+    value?: string;
+    url?: string;
+    alt?: string;
+    title?: string | null;
+    depth?: number;
+    lang?: string | null;
+    ordered?: boolean;
+    start?: number | null;
+    checked?: boolean | null;
+    attributes?: Record<string, unknown>;
+}
+interface HTMLImportTextNode {
+    type: "text";
+    textContent: string;
+}
+interface HTMLImportElement {
+    type: "element";
+    tagName: string;
+    attributes: Record<string, string>;
+    children: HTMLImportNode[];
+    textContent?: string;
+    getAttribute(name: string): string | null;
+    hasAttribute(name: string): boolean;
+}
+type HTMLImportNode = HTMLImportElement | HTMLImportTextNode;
+interface XMLElement {
+    tagName: string;
+    attributes: Record<string, string>;
+    children: XMLElement[];
+    textContent?: string;
+}
+interface Exporter<Output = string, Extra extends Record<string, unknown> = Record<string, never>> {
+    name: string;
+    mimeType: string;
+    fileExtension: string;
+    /**
+     * Serialize the current document as it exists.
+     *
+     * Exporters are document-preservation surfaces, not authoring policy
+     * surfaces: they should generally serialize existing blocks even when those
+     * block types are hidden from menus or disallowed as new insertions in the
+     * active documentProfile.
+     */
+    export(editor: Editor, options?: ExportOptions<Extra>): Output | Promise<Output>;
+    exportFragment?(blocks: BlockHandle[], options?: ExportOptions<Extra>): Output;
+}
+interface ExportOptions<Extra extends Record<string, unknown> = Record<string, never>> {
+    /**
+     * Export flags shape serialization output, but they do not redefine document
+     * authoring policy. Use schema/profile-aware helpers on authoring surfaces
+     * (menus, tools, paste/import) when deciding what users may insert.
+     */
+    includeApps?: boolean;
+    includeLayout?: boolean;
+    includeMetadata?: boolean;
+    includeSuggestions?: boolean;
+    prettyPrint?: boolean;
+    extra?: Extra;
+}
+interface Importer<Input = string, Parsed = unknown> {
+    name: string;
+    mimeType: string;
+    parse?(input: Input, editor: Editor): Parsed | Promise<Parsed>;
+    /**
+     * Import is an authoring boundary. Implementations should normalize parsed
+     * content against the active schema/documentProfile before applying writes so
+     * callers can observe dropped or transformed content deterministically.
+     */
+    import(input: Input, editor: Editor, options?: ImportOptions): ImportResult | void | Promise<ImportResult | void>;
+}
+interface ImportOptions {
+    position?: Position;
+    replace?: boolean;
+    validate?: boolean;
+    normalize?: boolean;
+    undoGroup?: boolean;
+}
+interface ImportResult {
+    /**
+     * Summary of import-side normalization. This reports what parsed content was
+     * accepted into the current authoring surface; it may therefore differ from
+     * what an exporter would serialize from an already-existing document.
+     */
+    parsedTopLevelBlockCount: number;
+    importedTopLevelBlockCount: number;
+    droppedBlockCount: number;
+    droppedBlockTypes: string[];
+    normalized: boolean;
+}
+
+interface KeyBindingContext {
+    blockType?: string[];
+    hasSelection?: boolean;
+    collapsed?: boolean;
+    withinLayout?: string[];
+}
+interface KeyBinding {
+    key: string;
+    priority?: number;
+    context?: KeyBindingContext;
+    description?: string;
+    handler: (editor: Editor, event: KeyboardEvent) => boolean;
+}
+interface InputRuleContext {
+    editor: Editor;
+    blockId: string;
+    blockType: string;
+    textBefore: string;
+    fullText: string;
+}
+type InputRuleHandler = (match: RegExpMatchArray, context: InputRuleContext) => DocumentOp[] | null;
+interface InputRule {
+    id: string;
+    match: RegExp;
+    blockTypes?: string[];
+    handler: InputRuleHandler;
+}
+
+interface BlockA11ySpec<Props = Record<string, unknown>> {
+    label: string | ((props: Props) => string);
+    roleDescription?: string;
+}
+/** Surface label for `pen.a11yLabel`: `aria-label` string or `aria-labelledby` id. */
+type A11yLabel = string | {
+    readonly labelledBy: string;
+};
+declare function isA11yLabelledBy(value: A11yLabel): value is {
+    readonly labelledBy: string;
+};
+interface EditorAnnouncer {
+    announce(message: string, priority?: "polite" | "assertive", key?: string): void;
+}
+
+type PropSchema = {
+    type?: string | string[];
+    default?: unknown;
+    enum?: unknown[];
+    description?: string;
+    properties?: Record<string, PropSchema>;
+    items?: PropSchema;
+    minimum?: number;
+    maximum?: number;
+    [key: string]: unknown;
+};
+type ContentType = "inline" | "none" | "table" | "subdocument" | BlockSchema[];
+declare function isNestedContent(content: ContentType): content is BlockSchema[];
+interface BlockDisplay {
+    title: string;
+    description?: string;
+    icon?: string;
+    group?: string;
+    aliases?: string[];
+    hidden?: boolean;
+}
+interface ImportInlineMark {
+    type: string;
+    props?: Record<string, unknown>;
+    start: number;
+    end: number;
+}
+interface ImportContentSource {
+    markdownNodes?: MarkdownNode[];
+    markdownHtml?: string;
+    htmlElement?: HTMLImportElement;
+}
+interface BlockImportMatch<Type extends string = string, Props extends Record<string, unknown> = Record<string, unknown>> {
+    type: Type;
+    props: Props;
+    content?: string;
+    marks?: ImportInlineMark[];
+    children?: BlockImportMatch[];
+    importContentSource?: ImportContentSource;
+}
+type InferProps<P extends Record<string, PropSchema>> = {
+    [K in keyof P]: unknown;
+};
+type FieldEditorType = "richtext" | "plaintext" | "code" | "table" | "subdocument" | "none";
+type FlowBlockCapability = "flow-inline" | "flow-structural" | "flow-delegated" | "flow-disallowed";
+type BlockSelectionRole = "editable-inline" | "structural" | "delegated";
+interface BlockAuthoring {
+    flowCapability?: FlowBlockCapability;
+    selectionRole?: BlockSelectionRole;
+}
+interface BlockSchema<Type extends string = string, Props extends Record<string, PropSchema> = Record<string, PropSchema>, Content extends ContentType = "inline"> {
+    type: Type;
+    propSchema: Props;
+    content: Content;
+    layout?: LayoutSchema;
+    serialize: {
+        toMarkdown?: (block: Block<Type, InferProps<Props>>) => string;
+        fromMarkdown?: (node: MarkdownNode) => BlockImportMatch<Type, InferProps<Props>> | null;
+        toHTML?: (block: Block<Type, InferProps<Props>>) => string;
+        fromHTML?: (element: HTMLImportElement) => BlockImportMatch<Type, InferProps<Props>> | null;
+        toXML?: (block: Block<Type, InferProps<Props>>) => string;
+        fromXML?: (element: XMLElement) => Block<Type, InferProps<Props>> | null;
+    };
+    normalize?: (block: Block<Type, InferProps<Props>>) => Block<Type, InferProps<Props>>;
+    validateProps?: (raw: Record<string, unknown>) => InferProps<Props>;
+    fieldEditor?: FieldEditorType;
+    keyBindings?: readonly KeyBinding[];
+    placeholder?: string;
+    display?: BlockDisplay;
+    authoring?: BlockAuthoring;
+    isContainer?: boolean;
+    aiDescription?: string;
+    a11y?: BlockA11ySpec<InferProps<Props>>;
+}
+interface InlineSchema<Type extends string = string, Props extends Record<string, PropSchema> = Record<string, PropSchema>> {
+    type: Type;
+    propSchema: Props;
+    kind: "mark" | "node";
+    serialize: {
+        toMarkdown?: (text: string, props: Record<string, unknown>) => string;
+        fromMarkdown?: (node: MarkdownNode) => Record<string, unknown> | null;
+        toHTML?: (text: string, props: Record<string, unknown>) => string;
+        toXML?: (text: string, props: Record<string, unknown>) => string;
+    };
+    apply?(content: unknown, range: Range, value: unknown): void;
+    remove?(content: unknown, range: Range): void;
+    query?(content: unknown, index: number): unknown | null;
+    priority?: number;
+    expand?: "after" | "before" | "both" | "none";
+    system?: boolean;
+    aiDescription?: string;
+    a11y?: BlockA11ySpec<InferProps<Props>>;
+}
+interface AppSchema<Type extends string = string, Config extends Record<string, PropSchema> = Record<string, PropSchema>> {
+    type: Type;
+    configSchema: Config;
+    defaultPlacement: AppPlacement["mode"];
+    allowedPlacements: AppPlacement["mode"][];
+    onAnchorDeleted?: "delete" | "orphan";
+    isolation?: "none" | "error-boundary" | "iframe";
+    serialize: {
+        toMarkdown?: (app: App<Type>) => string;
+        toHTML?: (app: App<Type>) => string;
+        toXML?: (app: App<Type>) => string;
+    };
+    aiDescription?: string;
+}
+interface SchemaRegistry {
+    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;
+    })[];
+    onUnknownBlock?: (type: string, raw: unknown) => BlockSchema | "drop" | "passthrough";
+    onUnknownInline?: (type: string, raw: unknown) => InlineSchema | "drop" | "passthrough";
+}
+interface ComposableSchema extends SchemaRegistry {
+    extend(schemas: readonly (BlockSchema | InlineSchema)[]): ComposableSchema;
+    without(types: readonly string[]): ComposableSchema;
+    override(type: string, overrides: Partial<BlockSchema>): ComposableSchema;
+    overrideSystemMark(type: string, schema: InlineSchema): ComposableSchema;
+}
+
+/**
+ * Host-owned persistence for a Pen document's Yjs bytes and version snapshots.
+ *
+ * `@input/pen-snapshots` calls the version-snapshot members. The update-log
+ * members and {@link PenPersistence.compact} are host-implemented: Pen never
+ * calls them (API10). See `PERSISTENCE.md` for the per-member disposition,
+ * including {@link AssetProvider} / {@link AssetUploadOptions}.
+ */
+interface PenPersistence {
+    /**
+     * Load the latest persisted state for `docId`.
+     *
+     * @remarks
+     * Host-implemented. Pen never calls `loadDocument`. The host calls this
+     * when it opens a stored document, then feeds the bytes to
+     * `CRDTAdapter.loadDocument` (or `Editor.loadDocument` after adapting).
+     * Return `null` when the host has no bytes for `docId` — the host then
+     * creates a new document with `adapter.createDocument()`. Rejection is
+     * host-defined; Pen is not on the stack and does not catch it. A rejected
+     * load is an aborted open.
+     */
+    loadDocument(docId: string): Promise<Uint8Array | null>;
+    /**
+     * Persist a full encoded document state.
+     *
+     * @remarks
+     * Host-implemented. Pen never calls `saveSnapshot`. The host calls this
+     * on its own schedule (idle, interval, unload) with
+     * `adapter.encodeState` / `Y.encodeStateAsUpdate` bytes. This is a
+     * full-state write, not an incremental update. Rejection is host-defined;
+     * Pen does not catch it. A rejected save means that full state is not
+     * durable — if the host also keeps an update log, that log is the
+     * recovery path.
+     */
+    saveSnapshot(docId: string, state: Uint8Array): Promise<void>;
+    /**
+     * Append a Yjs update to the document's update log.
+     *
+     * @remarks
+     * Host-implemented. Pen never calls `appendUpdate`. The host typically
+     * calls this from a `Y.Doc` update observer after encoding the update.
+     * Rejection is host-defined; Pen does not catch it. A dropped append
+     * leaves a gap in the log, so a later rebuild from `getUpdates` is
+     * incomplete unless the host also has a later `saveSnapshot`. Hosts that
+     * persist only full snapshots may implement this as a no-op.
+     */
+    appendUpdate(docId: string, update: Uint8Array): Promise<void>;
+    /**
+     * Read updates from the document's update log.
+     *
+     * @remarks
+     * Host-implemented. Pen never calls `getUpdates`. The host calls this to
+     * rebuild state or feed a replica. `since` is an opaque cursor the host
+     * defines (often the last persisted update or a state vector); omit it
+     * to read the whole log. Rejection is host-defined; Pen does not catch
+     * it. Hosts that persist only full snapshots may return `[]`.
+     */
+    getUpdates(docId: string, since?: Uint8Array): Promise<Uint8Array[]>;
+    /**
+     * Compact stored updates for `docId`.
+     *
+     * @remarks
+     * Host-implemented. Pen never calls `compact`. The host calls this when
+     * it wants to shrink its own update log. Compaction is a host storage
+     * concern: `Y.mergeUpdates` folds an update log, not tombstones. Snapshot
+     * retention and `gc: true` are separate tradeoffs — see the compaction
+     * notes in `@input/pen-yjs`. Rejection is host-defined; Pen does not
+     * catch it. A rejected compact leaves the log as stored.
+     */
+    compact(docId: string): Promise<void>;
+    /**
+     * Persist a version snapshot.
+     *
+     * @remarks
+     * Called by `@input/pen-snapshots` `SnapshotManager.createSnapshot`.
+     * If this rejects, `createSnapshot` rejects and no version is listed.
+     * Pen does not catch the rejection; the host chooses the error type.
+     */
+    saveVersionSnapshot(docId: string, snapshot: Uint8Array, metadata: VersionMetadata): Promise<void>;
+    /**
+     * List version snapshots.
+     *
+     * @remarks
+     * Called by `@input/pen-snapshots` `SnapshotManager.createSnapshot` (latest
+     * entry after write, `{ limit: 1 }`) and `SnapshotManager.listSnapshots`.
+     * If this rejects, the calling method rejects. If `createSnapshot`
+     * receives an empty list after a successful write, it synthesizes an
+     * entry with a fresh id. There is no `getVersionSnapshots`.
+     */
+    listVersions(docId: string, options?: {
+        limit?: number;
+        before?: string;
+    }): Promise<VersionEntry[]>;
+    /**
+     * Load a version snapshot for restore.
+     *
+     * @remarks
+     * Called by `@input/pen-snapshots` `SnapshotManager.restoreSnapshot`.
+     * Restore uses the returned `snapshot` bytes. A missing version throws
+     * `Snapshot ${versionId} not found` from the manager. If this rejects,
+     * restore rejects. Pen does not catch the rejection.
+     * Listing is {@link PenPersistence.listVersions}.
+     */
+    loadVersion(docId: string, versionId: string): Promise<{
+        state: Uint8Array;
+        snapshot: Uint8Array;
+    }>;
+}
+interface VersionMetadata {
+    label?: string;
+    trigger: "auto" | "manual" | "ai-generation" | "import";
+    clientId: number;
+    timestamp: number;
+}
+interface VersionEntry {
+    id: string;
+    metadata: VersionMetadata;
+    createdAt: number;
+}
+interface AssetRef {
+    id: string;
+    url: string;
+    mimeType: string;
+    size: number;
+}
+interface AssetUploadOptions {
+    mimeType?: string;
+    /**
+     * Maximum accepted size in bytes. Pen enforces this before calling
+     * {@link AssetProvider.upload} and forwards the same limit to the provider.
+     * Oversize files emit `asset-upload-failed` naming this limit and the actual
+     * size; they are not uploaded and produce no image block.
+     */
+    maxSize?: number;
+    /**
+     * Upload progress in the range `[0, 1]`. Pen forwards this callback to
+     * {@link AssetProvider.upload}; the provider invokes it during the upload.
+     */
+    onProgress?: (progress: number) => void;
+}
+interface AssetProvider {
+    /**
+     * Host-declared maximum upload size in bytes.
+     *
+     * @remarks
+     * Read by `@input/pen-dom` `uploadImageFiles` and
+     * `@input/pen-interop/html` `applyHtmlImageSrcPolicy` before `upload`.
+     * The same limit is forwarded as {@link AssetUploadOptions.maxSize}.
+     */
+    readonly maxSize?: number;
+    /**
+     * Store `file` and return a durable ref.
+     *
+     * @remarks
+     * Called by `@input/pen-dom` `uploadImageFiles` (paste/drop) and
+     * `@input/pen-interop/html` `applyHtmlImageSrcPolicy` when `imageSrc` is
+     * `"ingest"`.
+     */
+    upload(file: File | Blob, options?: AssetUploadOptions): Promise<AssetRef>;
+    /**
+     * Return a URL the renderer can use for `ref`.
+     *
+     * @remarks
+     * Called after a successful `upload` at the same two sites.
+     */
+    resolve(ref: AssetRef): string;
+    /**
+     * Remove an asset from host storage.
+     *
+     * @remarks
+     * Host-implemented. Pen never calls `delete`. Pen cannot know whether a
+     * removed block's asset is still referenced by another document, a version
+     * snapshot, or a collaborator's pending undo. Hosts own reference counting
+     * and should call `delete` only when their count reaches zero.
+     */
+    delete(ref: AssetRef): Promise<void>;
+}
+
+type A11yMessageKey = "blockConverted" | "undoApplied" | "redoApplied" | "blockSelectionEntered" | "blockSelectionChanged" | "cellSelectionChanged" | "suggestionAppeared" | "suggestionAccepted" | "suggestionRejected" | "streamingStarted" | "streamingFinished" | "findMatches" | "atomSelected" | "collaboratorJoined" | "collaboratorEditing";
+type A11yMessageCatalog = Record<A11yMessageKey, string>;
+
+type NoMessageParams = Record<never, never>;
+type A11yMessageParams = {
+    blockConverted: {
+        blockType: string;
+    };
+    undoApplied: {
+        hint: string;
+    };
+    redoApplied: {
+        hint: string;
+    };
+    blockSelectionEntered: {
+        count: number;
+    };
+    blockSelectionChanged: {
+        count: number;
+    };
+    cellSelectionChanged: {
+        rows: number;
+        columns: number;
+    };
+    suggestionAppeared: NoMessageParams;
+    suggestionAccepted: NoMessageParams;
+    suggestionRejected: NoMessageParams;
+    streamingStarted: NoMessageParams;
+    streamingFinished: NoMessageParams;
+    findMatches: {
+        count: number;
+    };
+    atomSelected: {
+        atomType: string;
+    };
+    collaboratorJoined: {
+        name: string;
+    };
+    collaboratorEditing: {
+        name: string;
+    };
+};
+type PluralMessage = {
+    readonly other: string;
+} & Partial<Record<Exclude<Intl.LDMLPluralRule, "other">, string>>;
+type MessageValue = string | PluralMessage;
+type MessageParamsByKey = {
+    [K in A11yMessageKey as `pen.a11y.${K}`]: A11yMessageParams[K];
+} & {
+    "pen.selection.blocksSelected": {
+        count: number;
+    };
+    "pen.ai.review.accept": NoMessageParams;
+    "pen.schema.paragraph.title": NoMessageParams;
+    "pen.schema.paragraph.description": NoMessageParams;
+    "pen.schema.paragraph.placeholder": NoMessageParams;
+    "pen.schema.heading.title": NoMessageParams;
+    "pen.schema.heading.placeholder": NoMessageParams;
+    "pen.display.group.basic": NoMessageParams;
+    "pen.display.group.lists": NoMessageParams;
+    "pen.display.group.other": NoMessageParams;
+    "pen.schema.document.emptyPlaceholder": NoMessageParams;
+    "pen.editor.label": NoMessageParams;
+    "pen.toolbar.formatting": NoMessageParams;
+    "pen.drag.reorderBlock": NoMessageParams;
+    "pen.blockHandle.reorder": NoMessageParams;
+    "pen.blockHandle.moveUp": NoMessageParams;
+    "pen.blockHandle.moveDown": NoMessageParams;
+    "pen.search.input.placeholder": NoMessageParams;
+    "pen.search.input.label": NoMessageParams;
+    "pen.search.replace.placeholder": NoMessageParams;
+    "pen.search.replace.label": NoMessageParams;
+    "pen.search.results.label": NoMessageParams;
+    "pen.search.results.none": NoMessageParams;
+    "pen.search.results.count": {
+        current: number;
+        count: number;
+    };
+    "pen.search.next": NoMessageParams;
+    "pen.search.previous": NoMessageParams;
+    "pen.search.replaceMatch": NoMessageParams;
+    "pen.search.replaceAll": NoMessageParams;
+    "pen.search.toggle.caseSensitive": NoMessageParams;
+    "pen.search.toggle.regex": NoMessageParams;
+    "pen.search.toggle.wholeWord": NoMessageParams;
+    "pen.slash.input.placeholder": NoMessageParams;
+    "pen.slash.list.label": NoMessageParams;
+    "pen.suggestion.list.label": NoMessageParams;
+    "pen.table.addColumn": NoMessageParams;
+    "pen.table.addRow": NoMessageParams;
+    "pen.table.columnPlaceholder": {
+        index: number;
+    };
+    "pen.table.columnMenu.label": {
+        title: string;
+    };
+    "pen.table.columnMenu.type": NoMessageParams;
+    "pen.table.columnMenu.insertLeft": NoMessageParams;
+    "pen.table.columnMenu.insertRight": NoMessageParams;
+    "pen.table.columnMenu.delete": NoMessageParams;
+    "pen.table.columnType.text": NoMessageParams;
+    "pen.table.columnType.number": NoMessageParams;
+    "pen.table.columnType.select": NoMessageParams;
+    "pen.table.columnType.checkbox": NoMessageParams;
+    "pen.table.columnType.date": NoMessageParams;
+    "pen.table.columnType.url": NoMessageParams;
+    "pen.table.columnType.email": NoMessageParams;
+    "pen.toggle.collapse": NoMessageParams;
+    "pen.toggle.expand": NoMessageParams;
+    "pen.toggle.empty": NoMessageParams;
+    "pen.checklist.toggle": NoMessageParams;
+    "pen.ai.suggestion.previous": NoMessageParams;
+    "pen.ai.suggestion.next": NoMessageParams;
+    "pen.ai.suggestion.count": {
+        current: number;
+        count: number;
+    };
+    "pen.ai.suggestion.groupPrevious": NoMessageParams;
+    "pen.ai.suggestion.groupNext": NoMessageParams;
+    "pen.ai.prompt.placeholder": NoMessageParams;
+    "pen.ai.turn.pending": {
+        count: number;
+    };
+    "pen.ai.turn.working": NoMessageParams;
+    "pen.ai.turn.accepted": NoMessageParams;
+    "pen.ai.turn.rejected": NoMessageParams;
+    "pen.ai.turn.error": NoMessageParams;
+    "pen.ai.turn.done": NoMessageParams;
+    "pen.ai.review.reject": NoMessageParams;
+    "pen.ai.session.inlineEdit": NoMessageParams;
+    "pen.ai.session.selectedRange": NoMessageParams;
+    "pen.ai.session.selectedText": NoMessageParams;
+    "pen.ai.session.targetActive": NoMessageParams;
+    "pen.ai.session.targetPinned": NoMessageParams;
+    "pen.ai.session.followUp": NoMessageParams;
+    "pen.ai.session.runEdit": NoMessageParams;
+    "pen.ai.commandMenu.placeholder": NoMessageParams;
+    "pen.ai.commandMenu.label": NoMessageParams;
+    "pen.ai.command.rewrite": NoMessageParams;
+    "pen.ai.command.rewrite.description": NoMessageParams;
+    "pen.ai.command.continue": NoMessageParams;
+    "pen.ai.command.continue.description": NoMessageParams;
+    "pen.ai.command.summarize": NoMessageParams;
+    "pen.ai.command.summarize.description": NoMessageParams;
+    "pen.ai.command.fixGrammar": NoMessageParams;
+    "pen.ai.command.fixGrammar.description": NoMessageParams;
+    "pen.ai.command.simplify": NoMessageParams;
+    "pen.ai.command.simplify.description": NoMessageParams;
+    "pen.ai.command.expand": NoMessageParams;
+    "pen.ai.command.expand.description": NoMessageParams;
+    "pen.ai.command.translate": NoMessageParams;
+    "pen.ai.command.translate.description": NoMessageParams;
+    "pen.ai.shortcut.undoInline": NoMessageParams;
+    "pen.ai.shortcut.redoInline": NoMessageParams;
+    "pen.ai.suggestion.keep": NoMessageParams;
+    "pen.ai.suggestion.undo": NoMessageParams;
+    "pen.ai.suggestion.heading": NoMessageParams;
+    "pen.ai.suggestion.applyHint": NoMessageParams;
+    "pen.ai.suggestion.dismiss": NoMessageParams;
+    "pen.ai.suggestion.apply": NoMessageParams;
+    "pen.ai.suggestion.kind.spelling": NoMessageParams;
+    "pen.ai.suggestion.kind.grammar": NoMessageParams;
+    "pen.ai.suggestion.kind.clarity": NoMessageParams;
+    "pen.ai.suggestion.kind.rephrase": NoMessageParams;
+    "pen.ai.suggestion.kind.other": NoMessageParams;
+    "pen.ai.review.section.content": NoMessageParams;
+    "pen.ai.review.section.block": NoMessageParams;
+    "pen.ai.review.section.row": NoMessageParams;
+    "pen.ai.review.section.cell": NoMessageParams;
+    "pen.ai.review.section.schema": NoMessageParams;
+    "pen.ai.review.section.view": NoMessageParams;
+    "pen.ai.review.kind.added": NoMessageParams;
+    "pen.ai.review.kind.removed": NoMessageParams;
+    "pen.ai.review.kind.updated": NoMessageParams;
+    "pen.ai.review.kind.moved": NoMessageParams;
+    "pen.ai.review.subgroup.content.added": NoMessageParams;
+    "pen.ai.review.subgroup.content.removed": NoMessageParams;
+    "pen.ai.review.subgroup.content.updated": NoMessageParams;
+    "pen.ai.review.subgroup.content.moved": NoMessageParams;
+    "pen.ai.review.subgroup.block.added": NoMessageParams;
+    "pen.ai.review.subgroup.block.removed": NoMessageParams;
+    "pen.ai.review.subgroup.block.updated": NoMessageParams;
+    "pen.ai.review.subgroup.block.moved": NoMessageParams;
+    "pen.ai.review.subgroup.row.added": NoMessageParams;
+    "pen.ai.review.subgroup.row.removed": NoMessageParams;
+    "pen.ai.review.subgroup.row.updated": NoMessageParams;
+    "pen.ai.review.subgroup.row.moved": NoMessageParams;
+    "pen.ai.review.subgroup.cell.added": NoMessageParams;
+    "pen.ai.review.subgroup.cell.removed": NoMessageParams;
+    "pen.ai.review.subgroup.cell.updated": NoMessageParams;
+    "pen.ai.review.subgroup.cell.moved": NoMessageParams;
+    "pen.ai.review.subgroup.schema.added": NoMessageParams;
+    "pen.ai.review.subgroup.schema.removed": NoMessageParams;
+    "pen.ai.review.subgroup.schema.updated": NoMessageParams;
+    "pen.ai.review.subgroup.schema.moved": NoMessageParams;
+    "pen.ai.review.subgroup.view.added": NoMessageParams;
+    "pen.ai.review.subgroup.view.removed": NoMessageParams;
+    "pen.ai.review.subgroup.view.updated": NoMessageParams;
+    "pen.ai.review.subgroup.view.moved": NoMessageParams;
+    "pen.ai.review.action.insert": NoMessageParams;
+    "pen.ai.review.action.delete": NoMessageParams;
+    "pen.ai.review.action.move": NoMessageParams;
+    "pen.ai.review.action.convert": NoMessageParams;
+    "pen.ai.review.action.change": NoMessageParams;
+    "pen.ai.review.blockSuggestion.insert": {
+        blockType: string;
+    };
+    "pen.ai.review.blockSuggestion.delete": {
+        blockType: string;
+    };
+    "pen.ai.review.blockSuggestion.move": {
+        blockType: string;
+    };
+    "pen.ai.review.blockSuggestion.convert": {
+        blockType: string;
+    };
+    "pen.ai.review.blockType.fallback": NoMessageParams;
+    "pen.ai.review.acceptGroup": NoMessageParams;
+    "pen.ai.review.rejectGroup": NoMessageParams;
+    "pen.ai.review.acceptSubgroup": NoMessageParams;
+    "pen.ai.review.rejectSubgroup": NoMessageParams;
+    "pen.ai.review.expand": NoMessageParams;
+    "pen.ai.review.collapse": NoMessageParams;
+    "pen.ai.review.structuralSuggestion": NoMessageParams;
+    "pen.ai.review.noPendingChanges": NoMessageParams;
+    "pen.ai.session.close": NoMessageParams;
+};
+type MessageKey = keyof MessageParamsByKey;
+type MessageParams<K extends MessageKey> = MessageParamsByKey[K];
+type MessageCatalog = {
+    [K in MessageKey]: MessageValue;
+};
+type MessageArgs<K extends MessageKey> = [
+    keyof MessageParamsByKey[K]
+] extends [never] ? [params?: MessageParamsByKey[K]] : [params: MessageParamsByKey[K]];
+declare const DEFAULT_MESSAGE_CATALOG: MessageCatalog;
+declare function isMessageKey(value: string): value is MessageKey;
+declare function isPluralMessage(value: unknown): value is PluralMessage;
+
+type EditorViewMode = DocumentProfile;
+/** Named commit-pipeline phases (`06-commit-pipeline.md`). */
+type PipelinePhase = "hooks" | "validate" | "execute" | "normalize" | "summarize" | "map-selection" | "settle-facets" | "emit";
+type InteractionModel = "content-first" | "block-first";
+/**
+ * Which rung `Mod-a` enters the T1 select-all ladder on
+ * (`spec/rules/selection.md` T1).
+ *
+ * `"block-first"` starts at the active block and escalates on each press.
+ * `"document-first"` enters at the top rung, so one press covers all content.
+ */
+type SelectAllBehavior = "document-first" | "block-first";
+interface DocumentState {
+    readonly documentProfile: DocumentProfile;
+    readonly blockOrder: readonly string[];
+    readonly blockCount: number;
+    readonly blocks: Iterable<BlockHandle>;
+    readonly isEmpty: boolean;
+    readonly generation: number;
+    allBlocks(): Iterable<BlockHandle>;
+    blockAt(index: number): string | null;
+    indexOf(blockId: string): number;
+    parentOf(blockId: string): string | null;
+}
+interface UndoManager {
+    undo(): boolean;
+    redo(): boolean;
+    canUndo(): boolean;
+    canRedo(): boolean;
+    stopCapturing(): void;
+    syncExplicitUndoGroup(groupId: string | null): void;
+    setGroupTimeout(ms: number): void;
+    registerTrackedOrigins(origins: OpOrigin[]): Unsubscribe;
+    onStackChange(callback: () => void): Unsubscribe;
+}
+interface UndoHistoryMetadataEntry<T = unknown> {
+    before: T | null;
+    after: T | null;
+}
+interface UndoHistoryMetadataRestoreContext {
+    editor: Editor;
+    direction: "undo" | "redo";
+    requestId: number;
+}
+interface UndoHistoryMetadataController {
+    getCurrentEntryMetadata<T>(key: string): UndoHistoryMetadataEntry<T> | null;
+    setCurrentEntryMetadata<T>(key: string, value: UndoHistoryMetadataEntry<T>): boolean;
+    registerMetadataRestorer<T>(key: string, restore: (value: T | null, context: UndoHistoryMetadataRestoreContext) => void): Unsubscribe;
+}
+interface UndoHistoryRestore {
+    focusBlockId: string | null;
+    requestId: number;
+}
+interface HistoryAppliedEvent {
+    kind: "undo" | "redo";
+    selection: SelectionState;
+    focusBlockId: string | null;
+    requestId: number;
+}
+type CommitEventSource = "apply" | "remote" | "undo" | "redo" | "stream";
+/** Dropped ops and validation failures for one commit (`06-commit-pipeline.md`). */
+type Diagnostic = DiagnosticEvent;
+
+interface CommitEvent {
+    readonly commitId: number;
+    readonly origin: StructuredOpOrigin;
+    readonly summary: ChangeSummary;
+    readonly selectionBefore: SelectionRecord;
+    readonly selectionAfter: SelectionRecord;
+    readonly source: CommitEventSource;
+    readonly diagnostics: readonly Diagnostic[];
+}
+interface SchemaEngine {
+    markDirty(blockId: string): void;
+    normalizeDirty(): void;
+    normalizeAll(): void;
+    deferBlock(blockId: string): void;
+    undeferBlock(blockId: string): void;
+}
+interface DiagnosticEvent {
+    code: string;
+    level: "warn" | "error" | "info";
+    source: string;
+    message: string;
+    remediation?: string;
+    op?: DocumentOp;
+    extension?: string;
+    error?: unknown;
+    [key: string]: unknown;
+}
+interface DocumentValidationError {
+    code: "MISSING_SHARED_TYPE" | "INVALID_BLOCK_STRUCTURE" | "ORPHAN_BLOCK" | "DUPLICATE_BLOCK_ORDER" | "UNKNOWN_CONTENT_TYPE" | "MISSING_BLOCK_MAP_KEY" | "INVALID_SUBDOCUMENT";
+    blockId?: string;
+    message: string;
+    severity: "error" | "warning";
+}
+interface PenEventMap {
+    commit: (event: CommitEvent) => void;
+    historyApplied: (event: HistoryAppliedEvent) => void;
+    decorationsChange: (generation: number) => void;
+    selectionChange: (record: SelectionRecord) => void;
+    diagnostic: (event: DiagnosticEvent) => void;
+    "crdt:corruption": (errors: DocumentValidationError[]) => void;
+    "crdt:recovered": (method: "snapshot" | "repair") => void;
+}
+declare const HOOK_PRIORITY_AUTH = 100;
+declare const HOOK_PRIORITY_SUGGEST = 200;
+declare const HOOK_PRIORITY_INPUT_RULE = 300;
+declare const HOOK_PRIORITY_DEFAULT = 500;
+interface EditorPresetContext {
+    schema: SchemaRegistry;
+    documentProfile: DocumentProfile;
+}
+interface EditorPresetResult {
+    extensions?: Extension[];
+    schema?: SchemaRegistry;
+}
+interface EditorPreset {
+    resolve(context: EditorPresetContext): EditorPresetResult;
+}
+interface CreateEditorOptions {
+    schema?: SchemaRegistry;
+    preset?: EditorPreset;
+    extensions?: Extension[];
+    crdt?: CRDTAdapter;
+    assets?: AssetProvider;
+    document?: CRDTDocument;
+    documentSession?: DocumentSession;
+    documentScopeId?: string;
+    documentProfile?: DocumentProfile;
+    editorViewMode?: EditorViewMode;
+    locale?: string;
+    messages?: Partial<MessageCatalog>;
+    a11yLabel?: A11yLabel;
+}
+interface CommandContext {
+    editor: Editor;
+    selection: SelectionState;
+    activeBlock: BlockHandle | null;
+}
+interface InlineCompletionSuggestion {
+    id: string;
+    blockId: string;
+    offset: number;
+    text: string;
+    type: "inline" | "block";
+    blockType?: string;
+    props?: Record<string, unknown>;
+    previewBlocks?: readonly InlineCompletionPreviewBlock[];
+    accept?: (editor: Editor, suggestion: InlineCompletionSuggestion) => boolean;
+}
+interface InlineCompletionPreviewBlock {
+    id: string;
+    text: string;
+    blockType?: string;
+    props?: Record<string, unknown>;
+}
+interface InlineCompletionState {
+    visibleSuggestion: InlineCompletionSuggestion | null;
+}
+interface InlineCompletionController {
+    getState(): InlineCompletionState;
+    subscribe(listener: () => void): () => void;
+    showSuggestion(suggestion: InlineCompletionSuggestion): void;
+    dismissSuggestion(): void;
+    acceptSuggestion(): boolean;
+    hasVisibleSuggestion(): boolean;
+    buildDecorations(): readonly Decoration[];
+    destroy(): void;
+}
+interface TextStreamWriter {
+    append(text: string, marks?: Record<string, unknown>): void;
+    splice(from: number, to: number, text: string): void;
+    readonly position: Point;
+    flush(): void;
+    close(): void;
+    abort(): void;
+}
+interface OpenTextStreamOptions {
+    origin: OpOrigin;
+    flushIntervalMs?: number;
+    deferNormalization?: boolean;
+}
+interface Editor {
+    apply(ops: DocumentOp[], options?: ApplyOptions): void;
+    openTextStream(target: {
+        blockId: string;
+    }, options: OpenTextStreamOptions): TextStreamWriter;
+    loadDocument(doc: CRDTDocument): void;
+    onBeforeApply(hook: (ops: DocumentOp[], options: ApplyOptions) => DocumentOp[], options?: {
+        priority?: number;
+    }): Unsubscribe;
+    facet<F extends Facet<unknown, unknown>>(facet: F): FacetOutput<F>;
+    whenReady(): Promise<void>;
+    readonly schema: SchemaRegistry;
+    readonly selection: SelectionState;
+    /** CRDT-relative positions that survive commits (AN1–AN14). */
+    readonly anchors: EditorAnchors;
+    readonly documentState: DocumentState;
+    readonly internals: EditorInternals;
+    readonly lastChangeSummary: ChangeSummary | null;
+    readonly clientId: number;
+    readonly documentScope: DocumentScope;
+    readonly documentProfile: DocumentProfile;
+    readonly editorViewMode: EditorViewMode;
+    blocks(type?: string): Iterable<BlockHandle>;
+    getBlock(blockId: string): BlockHandle | null;
+    firstBlock(): BlockHandle | null;
+    lastBlock(): BlockHandle | null;
+    blockCount(): number;
+    getBlockRevision(blockId: string): number;
+    setSelection(selection: SelectionState, options?: {
+        origin?: SelectionOrigin;
+    }): void;
+    getSelection(): SelectionState;
+    selectBlock(blockId: string): void;
+    selectBlocks(blockIds: string[]): void;
+    selectCell(blockId: string, row: number, col: number): void;
+    selectCellRange(blockId: string, anchor: {
+        row: number;
+        col: number;
+    }, head: {
+        row: number;
+        col: number;
+    }): void;
+    selectText(blockId: string, from: number, to: number): void;
+    selectTextRange(anchor: {
+        blockId: string;
+        offset: number;
+    }, focus: {
+        blockId: string;
+        offset: number;
+    }): void;
+    selectAll(behavior?: SelectAllBehavior): void;
+    getSelectedText(): string;
+    getSelectedBlocks(): BlockHandle[];
+    replaceSelection(content: string | Block[]): void;
+    deleteSelection(options?: ApplyOptions): void;
+    requestDecorationUpdate(): void;
+    getDecorations(): DecorationSet;
+    scrollToBlock?(blockId: string): void;
+    onSelectionChange(callback: PenEventMap["selectionChange"]): Unsubscribe;
+    onHistoryApplied(callback: PenEventMap["historyApplied"]): Unsubscribe;
+    on<K extends keyof PenEventMap>(event: K, handler: PenEventMap[K]): Unsubscribe;
+    on(event: `ext:${string}:${string}`, handler: (...args: unknown[]) => void): Unsubscribe;
+    readonly undoManager: UndoManager;
+    getExtensionState<T>(name: string): T | undefined;
+    normalizeAll(): void;
+    /**
+     * Deactivates extensions and tears down observation. Does not destroy an
+     * attached field editor — hosts own that call. The returned promise
+     * settles when queued teardown finishes; callers that ignore it stay
+     * correct.
+     */
+    destroy(): Promise<void>;
+}
+interface EditorInternals {
+    readonly adapter: CRDTAdapter;
+    readonly crdtDoc: CRDTDocument;
+    readonly doc: PenDocument;
+    readonly engine: SchemaEngine;
+    readonly awareness: Awareness | null;
+    readonly documentSession: DocumentSession | null;
+    readonly documentScope: DocumentScope;
+    readonly viewId: string;
+    emit<K extends keyof PenEventMap>(event: K, ...args: Parameters<PenEventMap[K]>): void;
+    hasListeners<K extends keyof PenEventMap>(event: K): boolean;
+    onApplyBoundary(hook: (event: {
+        phase: "before" | "after";
+        ops: readonly DocumentOp[];
+        origin: OpOrigin;
+        applied: boolean;
+    }) => void): Unsubscribe;
+    onPipelinePhase(listener: (phase: PipelinePhase) => void): Unsubscribe;
+    assignSlot: (key: string, value: unknown) => void;
+    getBlockText(blockId: string): unknown;
+    getCellText(blockId: string, row: number, col: number): unknown;
+}
+
+type ConnectionState = "disconnected" | "connecting" | "connected" | "syncing" | "error";
+interface MultiplayerSessionContext {
+    editor: Editor;
+    awareness: Awareness;
+}
+interface MultiplayerSession {
+    readonly connectionState: ConnectionState;
+    connect(): void;
+    disconnect(): void;
+    destroy(): void;
+    onStateChange(listener: (state: ConnectionState) => void): Unsubscribe;
+}
+
+interface Command<P = void> {
+    readonly name: string;
+}
+type CommandResult = boolean | {
+    ops: DocumentOp[];
+    options?: ApplyOptions;
+} | {
+    selection: SelectionState;
+};
+type CommandHandler<P> = (editor: Editor, param: P) => CommandResult | false;
+interface CommandHandlerRegistration<P = unknown> {
+    readonly command: Command<P>;
+    readonly handler: CommandHandler<P>;
+}
+type DefineCommand = <P = void>(name: string) => Command<P>;
+interface CommandHandlerProvider extends FacetProvider {
+    readonly command: Command<unknown>;
+    readonly handler: CommandHandler<unknown>;
+    readonly precedence: Precedence;
+}
+
+interface ToolRegistry {
+    registerTool(def: ToolDefinition): void;
+    unregisterTool(name: string): void;
+    listTools(): readonly ToolDefinition[];
+    getTool(name: string): ToolDefinition | null;
+}
+interface ToolRuntime extends ToolRegistry {
+    executeTool(name: string, input: unknown, ctx: ToolContext): Promise<unknown> | AsyncIterable<unknown>;
+}
+type ToolExecutionResult = Promise<unknown> | AsyncIterable<unknown>;
+interface ToolDefinition {
+    name: string;
+    description: string;
+    inputSchema: PropSchema;
+    handler: (input: unknown, ctx: ToolContext) => Promise<unknown> | AsyncIterable<unknown>;
+    /**
+     * Tool authority (AIB3). A tool that writes to the document declares
+     * `mutating: true` and is default-denied unless the grant allowlists it;
+     * `destructive: true` additionally marks irreversible effects.
+     *
+     * Left undefined, authority falls back to name-based classification, which
+     * is a heuristic — declare these on any tool whose name is not obviously
+     * read-only.
+     */
+    mutating?: boolean;
+    destructive?: boolean;
+}
+type ModelToolChoice = {
+    type: "auto";
+} | {
+    type: "any";
+} | {
+    type: "tool";
+    name: string;
+};
+interface ModelAdapterCapabilities {
+    partialToolInput?: boolean;
+    forcedToolChoice?: boolean;
+}
+interface ModelAdapter {
+    capabilities?: ModelAdapterCapabilities;
+    stream(options: {
+        messages: ModelMessage[];
+        tools: ToolSchema[];
+        signal?: AbortSignal;
+        requestMode?: string;
+        operation?: ModelRequestedOperation;
+        sessionId?: string;
+        turnId?: string;
+        generationId?: string;
+        toolChoice?: ModelToolChoice;
+    }): AsyncIterable<ModelStreamEvent>;
+}
+type ModelOperationKind = "rewrite-selection" | "rewrite-block" | "continue-block" | "document-transform";
+interface ModelOperationSelectionTarget {
+    kind: "selection";
+    blockId: string | null;
+    anchor: {
+        blockId: string;
+        offset: number;
+    };
+    focus: {
+        blockId: string;
+        offset: number;
+    };
+    sourceText: string;
+}
+interface ModelOperationScopedRangeTarget {
+    kind: "scoped-range";
+    blockId: string | null;
+    anchor: {
+        blockId: string;
+        offset: number;
+    };
+    focus: {
+        blockId: string;
+        offset: number;
+    };
+    sourceText: string;
+    blockIds: readonly string[];
+    contentFormat: "text" | "markdown";
+    scope: "block" | "paragraph" | "document" | "heading";
+}
+type ModelOperationRangeTarget = ModelOperationSelectionTarget | ModelOperationScopedRangeTarget;
+declare function isScopedSelectionTarget(target: ModelOperationRangeTarget): target is ModelOperationScopedRangeTarget;
+interface ModelOperationBlockTarget {
+    kind: "block";
+    blockId: string;
+    blockType: string | null;
+    sourceText: string;
+    insertionOffset?: number;
+}
+interface ModelOperationDocumentTarget {
+    kind: "document";
+    activeBlockId: string | null;
+    blockIds?: readonly string[];
+    placement?: "append-after-block" | "replace-empty-block" | "replace-blocks";
+    transform?: "write" | "rewrite" | "remove";
+}
+interface ModelOperationProvenance {
+    documentVersion?: number | null;
+    blockRevision?: number | null;
+    selectionSignature?: string | null;
+    syncedGeneration?: number | null;
+}
+interface ModelRequestedOperation {
+    kind: ModelOperationKind;
+    target: ModelOperationSelectionTarget | ModelOperationScopedRangeTarget | ModelOperationBlockTarget | ModelOperationDocumentTarget;
+    promptIntent?: string;
+    provenance?: ModelOperationProvenance | null;
+}
+type ModelStreamEvent = {
+    type: "text-delta";
+    delta: string;
+} | {
+    type: "replace-preview";
+    operation: ModelRequestedOperation;
+    text: string;
+} | {
+    type: "replace-final";
+    operation: ModelRequestedOperation;
+    text: string;
+} | {
+    type: "insert-preview";
+    operation: ModelRequestedOperation;
+    text: string;
+} | {
+    type: "insert-final";
+    operation: ModelRequestedOperation;
+    text: string;
+} | {
+    type: "conflict";
+    reason: string;
+    operation?: ModelRequestedOperation;
+} | {
+    type: "structured-data";
+    contract?: "grid" | "app";
+    data: unknown;
+    final?: boolean;
+} | {
+    type: "tool-input-start";
+    toolCallId: string;
+    toolName: string;
+} | {
+    type: "tool-input-delta";
+    toolCallId: string;
+    inputTextDelta: string;
+} | {
+    type: "tool-call";
+    toolCallId: string;
+    toolName: string;
+    input: unknown;
+} | {
+    type: "done";
+    usage?: {
+        promptTokens: number;
+        completionTokens: number;
+    };
+} | {
+    type: "error";
+    error: unknown;
+};
+interface ToolSchema {
+    name: string;
+    description: string;
+    inputSchema: PropSchema;
+}
+interface ModelMessage {
+    role: "system" | "user" | "assistant" | "tool";
+    content: string | ModelMessagePart[];
+    toolCallId?: string;
+    toolName?: string;
+}
+type ModelMessagePart = {
+    type: "text";
+    text: string;
+} | {
+    type: "tool-call";
+    toolCallId: string;
+    toolName: string;
+    input: unknown;
+} | {
+    type: "tool-result";
+    toolCallId: string;
+    result: unknown;
+    isError?: boolean;
+};
+interface ToolContext {
+    readonly editor: Editor;
+    readonly docId: string;
+    emit(part: PenStreamPart): void;
+    insertBlock(blockType: string, props: Record<string, unknown>, position: Position): string;
+    updateBlock(blockId: string, props: Record<string, unknown>): void;
+    deleteBlock(blockId: string): void;
+    beginStreaming(zoneId: string, blockId: string): void;
+    appendDelta(delta: string): void;
+    endStreaming(status: "complete" | "cancelled" | "error"): void;
+}
+declare function isAsyncIterable(value: unknown): value is AsyncIterable<unknown>;
+
+type PenStreamPart = GenStartPart | GenDeltaPart | GenEndPart | BlockInsertPart | BlockUpdatePart | BlockDeletePart | BlockMovePart | LayoutUpdatePart | AppCreatePart | AppUpdatePart | AppDeletePart | StepStartPart | StepEndPart | ToolInputStartPart | ToolInputDeltaPart | ToolInputAvailablePart | ToolOutputPart | ToolErrorPart | DataPart | ErrorPart | AbortPart | PingPart | DonePart;
+interface GenStartPart {
+    type: "gen-start";
+    zoneId: string;
+    blockId: string;
+}
+interface GenDeltaPart {
+    type: "gen-delta";
+    zoneId: string;
+    delta: string;
+}
+interface GenEndPart {
+    type: "gen-end";
+    zoneId: string;
+    status: "complete" | "cancelled" | "error";
+}
+interface BlockInsertPart {
+    type: "block-insert";
+    blockId: string;
+    blockType: string;
+    props?: Record<string, unknown>;
+    position: Position;
+}
+interface BlockUpdatePart {
+    type: "block-update";
+    blockId: string;
+    props: Record<string, unknown>;
+}
+interface BlockDeletePart {
+    type: "block-delete";
+    blockId: string;
+}
+interface BlockMovePart {
+    type: "block-move";
+    blockId: string;
+    position: Position;
+}
+interface LayoutUpdatePart {
+    type: "layout-update";
+    blockId: string;
+    layout: Partial<LayoutProps>;
+}
+interface AppCreatePart {
+    type: "app-create";
+    appId: string;
+    appType: string;
+    config: Record<string, unknown>;
+    placement: AppPlacement;
+}
+interface AppUpdatePart {
+    type: "app-update";
+    appId: string;
+    patch: Record<string, unknown>;
+}
+interface AppDeletePart {
+    type: "app-delete";
+    appId: string;
+}
+interface StepStartPart {
+    type: "step-start";
+    stepIndex: number;
+    label?: string;
+}
+interface StepEndPart {
+    type: "step-end";
+    stepIndex: number;
+}
+interface ToolInputStartPart {
+    type: "tool-input-start";
+    toolCallId: string;
+    toolName: string;
+}
+interface ToolInputDeltaPart {
+    type: "tool-input-delta";
+    toolCallId: string;
+    inputDelta: string;
+}
+interface ToolInputAvailablePart {
+    type: "tool-input-available";
+    toolCallId: string;
+    toolName: string;
+    input: unknown;
+}
+interface ToolOutputPart {
+    type: "tool-output";
+    toolCallId: string;
+    output: unknown;
+}
+interface ToolErrorPart {
+    type: "tool-error";
+    toolCallId: string;
+    error: string;
+}
+interface DataPart {
+    type: `data-${string}`;
+    id?: string;
+    data: unknown;
+    transient?: boolean;
+}
+interface ErrorPart {
+    type: "error";
+    errorText: string;
+    code?: string;
+}
+interface AbortPart {
+    type: "abort";
+    reason: string;
+}
+interface PingPart {
+    type: "ping";
+}
+interface DonePart {
+    type: "done";
+}
+/** Frozen protocol version for stream handshake (AIB5). */
+declare const PEN_STREAM_PROTOCOL_VERSION = 1;
+/**
+ * Wire request for `PenTransport.stream`. `context` is the serializable
+ * subset (AIB2). A live `Editor` is not expressible on the wire — pass it
+ * to `directTransport` / `createSSEHandler` at construction.
+ */
+interface PenStreamRequest {
+    prompt: string;
+    context?: {
+        docId?: string;
+        selection?: SelectionState;
+        blockId?: string;
+    };
+    tools?: ToolSchema[];
+    toolCalls?: Array<{
+        toolCallId: string;
+        name: string;
+        input: unknown;
+    }>;
+    messages?: ModelMessage[];
+    signal?: AbortSignal;
+    streamId?: string;
+    protocolVersion?: number;
+}
+
+type FieldEditorBehavior = "inline-richtext" | "inline-plaintext" | "inline-code" | "grid" | "none";
+type FieldEditorInputMode = "richtext" | "code" | "table" | "none";
+
+type FieldEditorFocusReason = "user-pointer" | "keyboard" | "programmatic" | "default" | "backend" | "selection-sync";
+type FieldEditorFocusOptions = {
+    reason?: FieldEditorFocusReason;
+    domFocus?: boolean;
+    passive?: boolean;
+};
+interface FieldEditor {
+    readonly focusBlockId: string | null;
+    readonly activeBlockIds: readonly string[];
+    readonly isEditing: boolean;
+    readonly isFocused: boolean;
+    readonly isComposing: boolean;
+    readonly inputMode: FieldEditorInputMode;
+    selection: SelectionState | null;
+    focus(options?: FieldEditorFocusOptions): boolean;
+    blur(): void;
+    activate(blockId: string): void;
+    activateCell?(blockId: string, row: number, col: number): void;
+    activateCellFromElement?(blockId: string, row: number, col: number, element: HTMLElement): void;
+    deactivate(): void;
+    suspendForPointerSelection?(): void;
+    syncTextSelection?(blockId: string, anchorOffset: number, focusOffset: number): void;
+    activateTextSelection?(blockId: string, anchorOffset: number, focusOffset: number, options?: FieldEditorFocusOptions): void;
+    focusTextSelection?(blockId: string, anchorOffset: number, focusOffset: number, options?: FieldEditorFocusOptions): Promise<boolean>;
+    commitProgrammaticTextSelection?(blockId: string, anchorOffset: number, focusOffset: number): void;
+    waitForAttachment?(blockId?: string | null): Promise<boolean>;
+    expandTo(blockId: string): void;
+    contractToFocused(): void;
+    attachElement(el: HTMLElement): void;
+    delegate(blockSchema: BlockSchema): boolean;
+    getPendingMarks?(): Readonly<Record<string, unknown | null>>;
+    togglePendingMark?(markType: string): boolean;
+    clearPendingMarks?(): void;
+    destroy(): void;
+    onActivate?(callback: (blockIds: string[]) => void): Unsubscribe;
+    onDeactivate?(callback: (blockIds: string[]) => void): Unsubscribe;
+    onSelectionChange?(callback: (record: SelectionRecord) => void): Unsubscribe;
+}
+interface StreamingTarget {
+    readonly generationZone: GenerationZone | null;
+    beginStreaming(zoneId: string, blockId: string, origin?: OpOrigin): void;
+    appendDelta(delta: string): void;
+    endStreaming(status: "complete" | "cancelled" | "error"): void;
+}
+
+declare const AI_REQUEST_REFUSED_CODE = "ai-request-refused";
+declare const AI_EGRESS_INVENTORY_CODE = "ai-egress-inventory";
+type AIRequestFeature = "generation" | "suggestions" | "autocomplete" | "agentic-step";
+type AIDocumentExcerptKind = "selection" | "target" | "context" | "tool-result";
+interface AIDocumentExcerpt {
+    readonly blockId: string;
+    readonly kind: AIDocumentExcerptKind;
+    readonly text: string;
+}
+interface AIRequestContext {
+    readonly feature: AIRequestFeature;
+    readonly messages: readonly ModelMessage[];
+    readonly documentExcerpts: readonly AIDocumentExcerpt[];
+    readonly tools: readonly ToolSchema[];
+}
+type AIRequestFilter = (context: AIRequestContext) => AIRequestContext | null;
+
+declare const PEN_DOCUMENT_FORMAT = 3;
+declare const PEN_FORMAT_METADATA_KEY = "penFormat";
+declare const DOCUMENT_PROFILE_METADATA_KEY = "documentProfile";
+declare const MIGRATION_LEDGER_METADATA_KEY = "penMigrations";
+/**
+ * Metadata keys Pen writes. Hosts may use any other key; Pen never inspects
+ * those and preserves them verbatim (DUR1, DUR4).
+ */
+declare const RESERVED_METADATA_KEYS: readonly ["penFormat", "documentProfile", "penMigrations"];
+type ReservedMetadataKey = (typeof RESERVED_METADATA_KEYS)[number];
+/**
+ * Store-generation identity written at `metadata.penFormat`.
+ *
+ * `format` and `minReader` are about the Yjs store shape, not about schemas.
+ * v2 does not change that shape, so it writes `minReader: 1` (DUR1).
+ */
+interface PenFormatStamp {
+    format: number;
+    minReader: number;
+    writer: string;
+}
+/**
+ * Absent stamps are v1-by-absence, not corrupt. `writer` is `"unknown"` until
+ * a v2 session writes the real stamp.
+ */
+declare const IMPLICIT_V1_FORMAT_STAMP: PenFormatStamp;
+
+declare const INLINE_COMPLETION_VISIBLE_BLOCK_ATTRIBUTE = "data-pen-inline-completion-visible";
+
+/**
+ * The review surface's class vocabulary (RS4).
+ *
+ * One module names every class the review surface can put on screen, because
+ * those names are a host contract rather than an implementation detail: the
+ * renderer refuses inline `style` from decoration attributes (SEC2), so a
+ * class is the only hook that survives to the DOM, and a host that wants to
+ * theme review presentation has nothing else to hang a rule on.
+ *
+ * It lives in the contract layer because two packages emit these names —
+ * `@input/pen-ai` from review decorations and `@input/pen-dom` when it
+ * reconciles a `suggestion` mark — and neither depends on the other.
+ *
+ * One class, one job. The exported sheet styles every name here; hosts theme
+ * through `--pen-ai-review-*` custom properties rather than adding a second
+ * insert/delete taxonomy on the same span.
+ */
+declare const REVIEW_SURFACE_CLASSES: Readonly<{
+    /** Inserted text in a proposed edit. */
+    readonly suggestionInsert: "pen-suggestion-insert";
+    /** Deleted text in a proposed edit, including in-flight originals. */
+    readonly suggestionDelete: "pen-suggestion-delete";
+    /** Text still arriving, shown before anything is written. */
+    readonly preview: "pen-ai-review-preview";
+    /** Selection context kept visible around an edit under review. */
+    readonly context: "pen-ai-review-context";
+    /** The range an edit under review affects. */
+    readonly affectedRange: "pen-ai-affected-range";
+    /** A block carrying a proposed structural change. */
+    readonly blockSuggestion: "pen-block-suggestion";
+}>;
+/**
+ * Per-action block-suggestion classes, enumerated rather than interpolated so
+ * the vocabulary stays a closed set a host can style exhaustively and the
+ * contract layer stays free of runtime (API3).
+ */
+declare const REVIEW_SURFACE_BLOCK_SUGGESTION_CLASSES: Readonly<{
+    readonly "insert-block": "pen-block-suggestion-insert-block";
+    readonly "delete-block": "pen-block-suggestion-delete-block";
+    readonly "move-block": "pen-block-suggestion-move-block";
+    readonly "convert-block": "pen-block-suggestion-convert-block";
+    readonly "split-block": "pen-block-suggestion-split-block";
+    readonly "format-text": "pen-block-suggestion-format-text";
+}>;
+/**
+ * The custom properties that theme the review surface. Hosts set these; they
+ * do not re-implement the rule blocks the exported sheet already carries.
+ */
+declare const REVIEW_SURFACE_CUSTOM_PROPERTIES: Readonly<{
+    readonly insertColor: "--pen-ai-review-insert-color";
+    readonly insertBackground: "--pen-ai-review-insert-background";
+    readonly deleteColor: "--pen-ai-review-delete-color";
+    readonly contextBackground: "--pen-ai-review-context-background";
+    readonly contextBoxShadow: "--pen-ai-review-context-box-shadow";
+    readonly borderRadius: "--pen-ai-review-border-radius";
+    readonly inlinePaddingBlock: "--pen-ai-review-inline-padding-block";
+    readonly inlineMarginBlock: "--pen-ai-review-inline-margin-block";
+}>;
+
+interface PenTransport {
+    stream(request: PenStreamRequest): AsyncIterable<PenStreamPart>;
+    reconnect?(streamId: string): AsyncIterable<PenStreamPart>;
+    connect(): Promise<void>;
+    disconnect(): Promise<void>;
+    readonly connected: boolean;
+    onConnectionChange(callback: (connected: boolean) => void): Unsubscribe;
+}
+interface ServerConfig {
+    port?: number;
+    host?: string;
+    transport?: "stdio" | "sse" | "ws";
+}
+
+declare const PEN_CLIPBOARD_PAYLOAD_VERSION = 1;
+/** Spec JSON flavor written on copy (SEC4 / IOP1). */
+declare const PEN_CLIPBOARD_JSON_MIME = "application/x-pen-blocks+json";
+/** Pre-SEC4 flavor. Readers still accept it. */
+declare const PEN_CLIPBOARD_JSON_MIME_LEGACY = "application/x-pen-blocks";
+interface PenClipboardDelta {
+    insert: string | {
+        type: string;
+        props?: Record<string, unknown>;
+    };
+    attributes?: Record<string, unknown>;
+}
+interface PenClipboardBlock {
+    type: string;
+    props?: Record<string, unknown>;
+    content?: string;
+    deltas?: readonly PenClipboardDelta[];
+    children?: readonly PenClipboardBlock[];
+    /** Partial inline copy: paste inserts into the current block, not as a new block. */
+    isPartial?: boolean;
+}
+interface PenClipboardPayload {
+    version: number;
+    blockTypes: readonly string[];
+    blocks: readonly PenClipboardBlock[];
+}
+
+interface BlockRenderContext {
+    editable: boolean;
+    selected: boolean;
+    decorations: readonly Decoration[];
+    ref: unknown;
+}
+type BlockRenderer<Props = Record<string, unknown>> = (block: BlockHandle, ctx: BlockRenderContext) => unknown;
+
+interface BlockSuggestion {
+    id: string;
+    action: "insert-block" | "delete-block" | "move-block" | "convert-block";
+    author: string;
+    authorType: "user" | "ai";
+    createdAt: number;
+    model?: string;
+    sessionId?: string;
+    requestId?: string;
+    turnId?: string;
+    generationId?: string;
+    previousState?: {
+        type?: string;
+        position?: Position;
+        props?: Record<string, unknown>;
+    };
+}
+
+/**
+ * The only ID source in Pen (HOST4, `spec/rules/host.md`). Returns a v4 UUID.
+ *
+ * `crypto.randomUUID` is secure-context-only, so it is absent on plain-HTTP origins — which
+ * is how a phone on the LAN reaches a dev server — and on Safari below 15.4. Calling it
+ * directly therefore throws in environments Pen supports, which is why no other module may
+ * (enforced by the `pen/no-bare-random-uuid` lint rule).
+ *
+ * `crypto.getRandomValues` has no such restriction and gives the same entropy, so the
+ * insecure-context path is a real UUID, not a degraded one. The final branch runs only where
+ * Web Crypto is absent entirely: same shape, weaker randomness, no throw. Pen IDs identify
+ * blocks and requests; they are not secrets and are not used for authorization.
+ */
+declare function generateId(): string;
+
+/**
+ * Extension-slot keys shared across core, renderers, and extensions.
+ *
+ * These are the contract `editor.internals.assignSlot` speaks. They are
+ * not host-app API — a host using `createEditor` never names them — but
+ * they are the extension author write surface, and several packages
+ * re-export the key they own (`SEARCH_CONTROLLER_SLOT`,
+ * `MULTIPLAYER_CONTROLLER_SLOT`, `SNAPSHOTS_CONTROLLER_SLOT`,
+ * `AUTOCOMPLETE_CONTROLLER_SLOT`).
+ *
+ * Marking them with the internal JSDoc tag would remove them from the
+ * published `.d.ts` (`stripInternal`) while every in-repo consumer
+ * still imports them from the root barrel. `package.json` exports only
+ * `.` (no internal subpath), so hiding them in this package alone
+ * breaks typecheck. Keep them public until this package gains an
+ * internal entry or the consumers write facets directly.
+ */
+declare const FIELD_EDITOR_SLOT_KEY = "field-editor";
+declare const COLLECT_KEY_BINDINGS_SLOT_KEY = "core:collect-key-bindings";
+declare const AWAIT_EXTENSION_LIFECYCLE_SLOT_KEY = "core:await-extension-lifecycle";
+declare const INPUT_RULES_ENGINE_SLOT_KEY = "input-rules:engine";
+declare const UNDO_HISTORY_RESTORE_SLOT_KEY = "undo:history-restore";
+declare const UNDO_HISTORY_METADATA_CONTROLLER_SLOT_KEY = "undo:history-metadata-controller";
+declare const INLINE_COMPLETION_SLOT = "ai:inline-completion";
+declare const AI_CONTROLLER_SLOT = "ai:controller";
+declare const AI_INLINE_HISTORY_SLOT = "ai:inline-history";
+declare const AI_REVIEW_CONTROLLER_SLOT = "ai:review";
+declare const AI_AUTOCOMPLETE_CONTROLLER_SLOT = "ai-autocomplete:controller";
+declare const AI_SUGGESTIONS_CONTROLLER_SLOT = "ai-suggestions:controller";
+declare const SEARCH_CONTROLLER_SLOT = "search:controller";
+declare const MULTIPLAYER_CONTROLLER_SLOT = "multiplayer:controller";
+declare const SNAPSHOTS_CONTROLLER_SLOT = "snapshots:controller";
+declare const ANNOUNCER_SLOT_KEY = "pen.announcer";
+/**
+ * Tag placed on Yjs transaction origins by the undo manager. The rendering
+ * layer checks this instead of relying on `constructor.name` (which breaks
+ * under minification).
+ */
+declare const HISTORY_ORIGIN_TAG = "__pen_history__";
+
+export { type A11yLabel, type A11yMessageCatalog, type A11yMessageKey, type AIDocumentExcerpt, type AIDocumentExcerptKind, type AIRequestContext, type AIRequestFeature, type AIRequestFilter, AI_AUTOCOMPLETE_CONTROLLER_SLOT, AI_CONTROLLER_SLOT, AI_EGRESS_INVENTORY_CODE, AI_INLINE_HISTORY_SLOT, AI_REQUEST_REFUSED_CODE, AI_REVIEW_CONTROLLER_SLOT, AI_SUGGESTIONS_CONTROLLER_SLOT, ANNOUNCER_SLOT_KEY, AWAIT_EXTENSION_LIFECYCLE_SLOT_KEY, type AbortPart, type Affinity, type Anchor, type AnchorPosition, type AnchorRange, type AnchorTarget, type App, type AppChange, type AppCreatePart, type AppDecoration, type AppDeletePart, type AppHandle, type AppOp, type AppPlacement, type AppSchema, type AppSelection, type AppUpdatePart, type ApplyOptions, type AssetProvider, type AssetRef, type AssetUploadOptions, type Assoc, type AttributionRange, type Awareness, type AwarenessChangeEvent, type Block, type BlockA11ySpec, type BlockAuthoring, type BlockCapabilityKey, type BlockCapabilityMap, type BlockDecoration, type BlockDeletePart, type BlockDisplay, type BlockHandle, type BlockImportMatch, type BlockInsertPart, type BlockMovePart, type BlockRenderContext, type BlockRenderer, type BlockSchema, type BlockSelection, type BlockSelectionRole, type BlockSuggestion, type BlockTextChange, type BlockUpdatePart, type BorderDef, COLLECT_KEY_BINDINGS_SLOT_KEY, type CRDTAdapter, type CRDTArray, type CRDTDocument, type CRDTEvent, type CRDTMap, type CRDTUndoManager, type CRDTUndoStackItem, type CellSelection, type ChangeSummary, type ClientExtensionContext, type ColumnType, type Command, type CommandContext, type CommandHandler, type CommandHandlerProvider, type CommandHandlerRegistration, type CommandResult, type CommitEvent, type CommitEventSource, type ComposableSchema, type ConnectionState, type ContentType, type CreateEditorOptions, type CreateSubdocumentOptions, DECORATION_OMIT_FROM_RENDER_ATTRIBUTE, DEFAULT_MESSAGE_CATALOG, DOCUMENT_PROFILE_METADATA_KEY, type DataPart, type DateFormat, type Decoration, type DecorationSet, type DefaultAssoc, type DefineCommand, type DefineFacet, type DeleteBlockOp, type Diagnostic, type DiagnosticEvent, type DocumentOp, type DocumentProfile, type DocumentRange, type DocumentScope, type DocumentScopeInfo, type DocumentScopeKind, type DocumentScopeLookupOptions, type DocumentScopeReplacementEvent, type DocumentSession, type DocumentSessionAttachOptions, type DocumentState, type DocumentValidationError, type DonePart, type Editor, type EditorAnchors, type EditorAnnouncer, type EditorInternals, type EditorPreset, type EditorPresetContext, type EditorPresetResult, type EditorViewMode, type ErrorPart, type ExportOptions, type Exporter, type Extension, type ExtensionStateSpec, FIELD_EDITOR_SLOT_KEY, type Facet, type FacetDependency, type FacetOutput, type FacetProvider, type FacetSpec, type FieldEditor, type FieldEditorBehavior, type FieldEditorFocusOptions, type FieldEditorFocusReason, type FieldEditorInputMode, type FieldEditorType, type FlowBlockCapability, type FormatTextOp, type GenDeltaPart, type GenEndPart, type GenStartPart, type GenerationZone, type GridChange, type GridOp, HISTORY_ORIGIN_TAG, HOOK_PRIORITY_AUTH, HOOK_PRIORITY_DEFAULT, HOOK_PRIORITY_INPUT_RULE, HOOK_PRIORITY_SUGGEST, type HTMLImportElement, type HTMLImportNode, type HTMLImportTextNode, type HistoryAppliedEvent, IMPLICIT_V1_FORMAT_STAMP, INLINE_COMPLETION_SLOT, INLINE_COMPLETION_VISIBLE_BLOCK_ATTRIBUTE, INPUT_RULES_ENGINE_SLOT_KEY, type ImportContentSource, type ImportInlineMark, type ImportOptions, type ImportResult, type Importer, type InlineCompletionController, type InlineCompletionPreviewBlock, type InlineCompletionState, type InlineCompletionSuggestion, type InlineDecoration, type InlineDelta, type InlineInsert, type InlineNodeDeltaInsert, type InlineSchema, type InputRule, type InputRuleContext, type InputRuleHandler, type InsertBlockOp, type InteractionModel, type KeyBinding, type KeyBindingContext, type LayoutProps, type LayoutSchema, type LayoutUpdatePart, type LoadDocumentOptions, MIGRATION_LEDGER_METADATA_KEY, MULTIPLAYER_CONTROLLER_SLOT, MUTATION_GROUP_METADATA_KEY, type MarkdownNode, type MessageArgs, type MessageCatalog, type MessageKey, type MessageParams, type MessageParamsByKey, type MessageValue, type ModelAdapter, type ModelAdapterCapabilities, type ModelMessage, type ModelMessagePart, type ModelOperationBlockTarget, type ModelOperationDocumentTarget, type ModelOperationKind, type ModelOperationProvenance, type ModelOperationRangeTarget, type ModelOperationScopedRangeTarget, type ModelOperationSelectionTarget, type ModelRequestedOperation, type ModelStreamEvent, type ModelToolChoice, type MoveBlockOp, type MultiplayerSession, type MultiplayerSessionContext, type MutationGroupMetadata, type NumberFormat, type OpOrigin, type OpOriginType, type OpenTextStreamOptions, PEN_CLIPBOARD_JSON_MIME, PEN_CLIPBOARD_JSON_MIME_LEGACY, PEN_CLIPBOARD_PAYLOAD_VERSION, PEN_DOCUMENT_FORMAT, PEN_FORMAT_METADATA_KEY, PEN_STREAM_PROTOCOL_VERSION, type PenClipboardBlock, type PenClipboardDelta, type PenClipboardPayload, type PenDocument, type PenEventMap, type PenFormatStamp, type PenPersistence, type PenStreamPart, type PenStreamRequest, type PenTransport, type PingPart, type PipelinePhase, type PluralMessage, type Point, type Position, type Precedence, type PropSchema, RESERVED_METADATA_KEYS, REVIEW_SURFACE_BLOCK_SUGGESTION_CLASSES, REVIEW_SURFACE_CLASSES, REVIEW_SURFACE_CUSTOM_PROPERTIES, type Range, type ReadonlySelectionState, type ReplaceScopeDocumentOptions, type ReservedMetadataKey, type ResolveRelativePositionOptions, type ResolvedAnchorRange, SEARCH_CONTROLLER_SLOT, SNAPSHOTS_CONTROLLER_SLOT, type SchemaEngine, type SchemaRegistry, type SelectAllBehavior, type SelectOption, type SelectionOrigin, type SelectionRecord, type SelectionRecordState, type SelectionState, type ServerConfig, type ServerExtensionContext, type SetMetaOp, type SetPropsOp, type Spacing, type SpliceTextOp, type StepEndPart, type StepStartPart, type StreamOpenOp, type StreamingTarget, type StructuralChange, type StructuralOriginTag, type StructuredOpOrigin, type TableBlockHandle, type TableCellHandle, type TableColumnSchema, type TableRowHandle, type TextSelection, type TextSplice, type TextStreamWriter, type ToolContext, type ToolDefinition, type ToolErrorPart, type ToolExecutionResult, type ToolInputAvailablePart, type ToolInputDeltaPart, type ToolInputStartPart, type ToolOutputPart, type ToolRegistry, type ToolRuntime, type ToolSchema, UNDO_HISTORY_METADATA_CONTROLLER_SLOT_KEY, UNDO_HISTORY_RESTORE_SLOT_KEY, type UndoHistoryMetadataController, type UndoHistoryMetadataEntry, type UndoHistoryMetadataRestoreContext, type UndoHistoryRestore, type UndoManager, type UndoManagerOptions, type Unsubscribe, type VersionEntry, type VersionMetadata, type XMLElement, generateId, isA11yLabelledBy, isAsyncIterable, isMessageKey, isNestedContent, isPluralMessage, isScopedSelectionTarget };