@openeditor/native 0.0.33 → 0.0.35

package/README.md

@@ -1,78 +1,101 @@
 # `@openeditor/native`
 
-Component-first React Native SDK for OpenEditor.
+React Native host for the offline OpenEditor embedded runtime.
 
-Pass `attachmentRuntime` to use the system picker and host storage lifecycle. The native toolbar exposes “Upload file,” native surfaces render attachment cards, and the viewer delegates opening/sharing to the runtime.
+The document, selection, history, and DOM NodeViews live inside one internally
+scrollable WebView. React Native owns the keyboard toolbar and application
+effects such as pickers, sheets, and navigation. The bridge sends commands and
+lightweight state/revision events; document JSON only crosses it when the host
+explicitly calls `getDocument()` or `flushDocument()`.
 
-## Public surface
+On iOS, the host hides WKWebView's default previous/next/Done accessory bar so
+the OpenEditor toolbar is the only bar above the software keyboard. The SDK
+sticks that toolbar to the keyboard, reserves its document inset, and enables
+interactive keyboard dismissal while the editor scrolls. Consumers can opt
+back into the system bar with
+`webViewProps={{ hideKeyboardAccessoryView: false }}`.
 
-- `OpenEditorNative` as the primary editing surface
-- `OpenEditorNativePageHeader` for host-backed page title and icon editing
-- `OpenEditorNativeViewer` for read-only rendering
-- `OpenEditorNativeEmojiPicker` for standalone native emoji selection
-- native document bridge helpers where renderer adaptation is required
+The `theme` prop accepts the same OpenEditor theme-token contract used by the
+web React surface.
 
-Callout and Page emoji are editable in `OpenEditorNative`: pressing the emoji
-opens the native picker and commits the selected Unicode value through editor
-history. Inline emoji continue to use the device keyboard.
+## Host integration
 
-## Required peers
+Install the native peer dependencies:
 
-- `@openeditor/react-native-prose-editor`
-- `react`
-- `react-native`
-- `react-native-keyboard-controller` (optional but recommended for keyboard toolbar placement)
+```sh
+pnpm add expo-glass-effect react-native-keyboard-controller react-native-reanimated react-native-svg react-native-webview
+```
 
-## Quick start
+For Expo, install the SDK plugin so iOS WebViews receive interactive keyboard
+dismissal:
 
-```tsx
-import { useRef } from "react";
-import { OpenEditorNative, type OpenEditorNativeController } from "@openeditor/native";
-
-export function Example() {
-  const editor = useRef<OpenEditorNativeController>(null);
-  return (
-    <OpenEditorNative
-      ref={editor}
-      initialDocument={document}
-      onChange={(document) => {
-        console.log(document);
-      }}
-    />
-  );
+```json
+{
+  "expo": {
+    "plugins": ["@openeditor/native/plugin"]
+  }
 }
 ```
 
-`OpenEditorNative` follows the same uncontrolled lifecycle as web:
-`initialDocument` is read once and `ref.current.setContent(document)` performs an
-undoable programmatic replacement. Undo and redo delegate directly to the Rust
-editor engine; the React wrapper does not keep document snapshots.
-
-Pass `enabledBlocks` to restrict authoring. Page and attachment controls are
-automatically omitted until their required host runtimes are present, while
-existing nodes remain readable.
-
-## Standalone emoji picker
-
-The editor wires this automatically for callouts and pages. Hosts can also use
-the same picker for page headers or other product UI:
+Rebuild the native application after adding the plugin or a native dependency.
+Mount the SDK provider once at the app root:
 
 ```tsx
-import { OpenEditorNativeEmojiPicker } from "@openeditor/native";
+import { OpenEditorNativeProvider } from "@openeditor/native";
 
-<OpenEditorNativeEmojiPicker
-  visible={pickerOpen}
-  onEmojiSelect={setPageIcon}
-  onRequestClose={() => setPickerOpen(false)}
-/>;
+export default function RootLayout() {
+  return <OpenEditorNativeProvider>{/* app routes */}</OpenEditorNativeProvider>;
+}
 ```
 
-The native picker shares OpenEditor’s Emojibase dataset with the Frimousse web
-picker, while using a platform-native medium bottom sheet and native controls
-for scrolling, search, and touch handling. Long-press an emoji that supports
-skin tones to choose a variant from the platform-native context menu.
+The self-contained offline runtime is packaged with the component, so Metro
+asset customization is not required:
 
-## Internal notes
+```tsx
+const editor = useRef<OpenEditorNativeController>(null);
+
+<OpenEditorNative
+  ref={editor}
+  initialDocument={document}
+  contentInsets={{ top: transparentHeaderHeight, bottom: 16 }}
+  onDocumentChanged={({ documentRevision }) => {
+    scheduleAutosave(async () => {
+      const snapshot = await editor.current?.getDocument({
+        minimumRevision: documentRevision,
+      });
+      if (snapshot) await save(snapshot.document);
+    });
+  }}
+  nativeEffects={{
+    pickAttachment: pickUploadAndReturnDurableAttachment,
+    createPage: openCreatePageSheet,
+    updatePage: updatePageMetadata,
+    openPage: navigateToPage,
+  }}
+/>
+```
 
-- The native prose editor engine remains an implementation detail behind this package.
-- Shared contracts come from `@openeditor/core`; content definitions come from `@openeditor/extensions`.
+The default toolbar is a keyboard-sticky, inset pill that meets the keyboard
+edge without a synthetic spacer. It uses native iOS glass and a theme-aware
+material fallback elsewhere. A custom `renderToolbar` returns only the toolbar
+content; the SDK still owns its glass surface and positioning, so do not add
+another `KeyboardStickyView` or outer background. Use `toolbarContentInset`
+when the custom toolbar needs more than the default 76-point document clearance,
+and `toolbarOffset` only when the keyboard edge itself needs a different gap.
+
+The editor host must reach the screen's bottom edge. Do not wrap the editor in
+a bottom-padding `SafeAreaView`; the keyboard owns that edge while editing, and
+reserving the home-indicator inset there creates a visible toolbar gap.
+
+The block picker derives its available page, image, and attachment commands
+from the supplied effect handlers. If the application cannot upload media to a
+durable URL, omit the corresponding picker effect rather than returning a
+temporary `file://` URI.
+
+Do not wrap the component in a React Native `ScrollView`; give it a bounded
+flex layout so the WebView remains the only document scroll owner. Before a
+screen transition or background save, call `flushDocument()` to commit pending
+composition and receive the current snapshot.
+
+For a read-only surface, use
+`<OpenEditorNative initialDocument={document} editable={false} showToolbar={false} />`.

package/dist/controller.d.ts

@@ -0,0 +1,79 @@
+import type { OpenEditorDocument } from "@openeditor/core";
+import { type OpenEditorCommandAck, type OpenEditorNativeAttachmentResult, type OpenEditorNativeEffectRequest, type OpenEditorNativeEffectResult, type OpenEditorNativeImageResult, type OpenEditorNativePageResult, type OpenEditorRuntimeCommand, type OpenEditorRuntimeMessage, type OpenEditorRuntimeState } from "@openeditor/embedded-runtime";
+export declare class OpenEditorNativeLifecycleCancellationError extends Error {
+    readonly code = "OPENEDITOR_NATIVE_LIFECYCLE_CANCELLED";
+    constructor(message: string);
+}
+export declare const isOpenEditorNativeLifecycleCancellation: (error: unknown) => error is OpenEditorNativeLifecycleCancellationError;
+export type OpenEditorNativeEffectHandlers = {
+    pickImage?: (effect: Extract<OpenEditorNativeEffectRequest["effect"], {
+        type: "pickImage";
+    }>) => Promise<OpenEditorNativeEffectResult<OpenEditorNativeImageResult>> | OpenEditorNativeEffectResult<OpenEditorNativeImageResult>;
+    pickAttachment?: (effect: Extract<OpenEditorNativeEffectRequest["effect"], {
+        type: "pickAttachment";
+    }>) => Promise<OpenEditorNativeEffectResult<OpenEditorNativeAttachmentResult>> | OpenEditorNativeEffectResult<OpenEditorNativeAttachmentResult>;
+    createPage?: (effect: Extract<OpenEditorNativeEffectRequest["effect"], {
+        type: "createPage";
+    }>) => Promise<OpenEditorNativeEffectResult<OpenEditorNativePageResult>> | OpenEditorNativeEffectResult<OpenEditorNativePageResult>;
+    updatePage?: (effect: Extract<OpenEditorNativeEffectRequest["effect"], {
+        type: "updatePage";
+    }>) => Promise<OpenEditorNativeEffectResult<OpenEditorNativePageResult>> | OpenEditorNativeEffectResult<OpenEditorNativePageResult>;
+    openPage?: (effect: Extract<OpenEditorNativeEffectRequest["effect"], {
+        type: "openPage";
+    }>) => Promise<OpenEditorNativeEffectResult<null>> | OpenEditorNativeEffectResult<null>;
+    openAttachment?: (effect: Extract<OpenEditorNativeEffectRequest["effect"], {
+        type: "openAttachment";
+    }>) => Promise<OpenEditorNativeEffectResult<null>> | OpenEditorNativeEffectResult<null>;
+    openUrl?: (effect: Extract<OpenEditorNativeEffectRequest["effect"], {
+        type: "openUrl";
+    }>) => Promise<OpenEditorNativeEffectResult<null>> | OpenEditorNativeEffectResult<null>;
+};
+export type OpenEditorNativeControllerEvent = Extract<OpenEditorRuntimeMessage, {
+    type: "ready" | "stateChanged" | "documentChanged" | "error";
+}>;
+export type OpenEditorDocumentSnapshot = {
+    document: OpenEditorDocument;
+    revision: number;
+};
+export type OpenEditorNativeController = {
+    readonly ready: boolean;
+    waitUntilReady: () => Promise<void>;
+    getDocument: (options?: {
+        minimumRevision?: number;
+    }) => Promise<OpenEditorDocumentSnapshot>;
+    flushDocument: () => Promise<OpenEditorDocumentSnapshot>;
+    setDocument: (document: OpenEditorDocument) => Promise<number>;
+    command: (command: OpenEditorRuntimeCommand) => Promise<OpenEditorCommandAck>;
+    focus: () => Promise<void>;
+    blur: () => Promise<void>;
+    subscribe: (listener: (event: OpenEditorNativeControllerEvent) => void) => () => void;
+};
+export type OpenEditorNativeBridgeOptions = {
+    sessionId: string;
+    requestTimeoutMs?: number;
+    send: (message: string) => void;
+    getEffectHandlers?: () => OpenEditorNativeEffectHandlers | undefined;
+};
+export declare class OpenEditorNativeBridge implements OpenEditorNativeController {
+    #private;
+    readonly sessionId: string;
+    constructor(options: OpenEditorNativeBridgeOptions);
+    get ready(): boolean;
+    get runtimeReady(): boolean;
+    waitUntilReady: () => Promise<void>;
+    getDocument: (options?: {
+        minimumRevision?: number;
+    }) => Promise<OpenEditorDocumentSnapshot>;
+    flushDocument: () => Promise<OpenEditorDocumentSnapshot>;
+    setDocument: (document: OpenEditorDocument) => Promise<number>;
+    command: (command: OpenEditorRuntimeCommand) => Promise<OpenEditorCommandAck>;
+    focus: () => Promise<void>;
+    blur: () => Promise<void>;
+    subscribe: (listener: (event: OpenEditorNativeControllerEvent) => void) => () => void;
+    initialize: (document: OpenEditorDocument, editable: boolean) => Promise<OpenEditorCommandAck>;
+    markInitialized: () => void;
+    receive: (raw: string) => boolean;
+    resetRuntime: () => void;
+    dispose: (reason?: string) => void;
+}
+export declare const emptyOpenEditorNativeState: OpenEditorRuntimeState;

package/dist/controller.js

@@ -0,0 +1,254 @@
+import { OPENEDITOR_PROTOCOL, OPENEDITOR_PROTOCOL_VERSION, decodeOpenEditorRuntimeMessage, } from "@openeditor/embedded-runtime";
+export class OpenEditorNativeLifecycleCancellationError extends Error {
+    code = "OPENEDITOR_NATIVE_LIFECYCLE_CANCELLED";
+    constructor(message) {
+        super(message);
+        this.name = "OpenEditorNativeLifecycleCancellationError";
+    }
+}
+export const isOpenEditorNativeLifecycleCancellation = (error) => error instanceof OpenEditorNativeLifecycleCancellationError;
+export class OpenEditorNativeBridge {
+    #counter = 0;
+    #disposed = false;
+    #documentRevision = 0;
+    #effectHandlers;
+    #listeners = new Set();
+    #pending = new Map();
+    #ready = false;
+    #readyWaiters = new Set();
+    #revisionWaiters = new Set();
+    #runtimeReady = false;
+    #requestTimeoutMs;
+    #send;
+    sessionId;
+    constructor(options) {
+        this.sessionId = options.sessionId;
+        this.#send = options.send;
+        this.#effectHandlers = options.getEffectHandlers;
+        this.#requestTimeoutMs = options.requestTimeoutMs ?? 10_000;
+    }
+    get ready() { return this.#ready; }
+    get runtimeReady() { return this.#runtimeReady; }
+    waitUntilReady = () => this.#waitForReady();
+    getDocument = async (options) => {
+        await this.#waitForReady();
+        if ((options?.minimumRevision ?? 0) > this.#documentRevision)
+            await this.#waitForRevision(options.minimumRevision);
+        const result = await this.#sendCommand({ type: "requestDocument" }, true);
+        return result;
+    };
+    flushDocument = async () => {
+        await this.blur();
+        return this.getDocument();
+    };
+    setDocument = async (document) => (await this.command({ type: "replaceDocument", document })).documentRevision;
+    command = async (command) => {
+        await this.#waitForReady();
+        return this.#sendCommand(command, false);
+    };
+    focus = async () => { await this.command({ type: "focus" }); };
+    blur = async () => { await this.command({ type: "blur" }); };
+    subscribe = (listener) => {
+        this.#listeners.add(listener);
+        return () => { this.#listeners.delete(listener); };
+    };
+    initialize = (document, editable) => this.#sendCommand({ type: "initialize", document, editable }, false);
+    markInitialized = () => {
+        if (this.#ready)
+            return;
+        this.#ready = true;
+        for (const waiter of this.#readyWaiters) {
+            clearTimeout(waiter.timer);
+            waiter.resolve();
+        }
+        this.#readyWaiters.clear();
+    };
+    receive = (raw) => {
+        if (this.#disposed)
+            return false;
+        let message;
+        try {
+            message = decodeOpenEditorRuntimeMessage(raw);
+        }
+        catch {
+            return false;
+        }
+        if (message.sessionId !== this.sessionId)
+            return false;
+        if (message.type === "ready") {
+            this.#runtimeReady = true;
+            this.#updateRevision(message.state.documentRevision);
+            this.#emit(message);
+        }
+        else if (message.type === "ack")
+            this.#receiveAck(message);
+        else if (message.type === "documentSnapshot")
+            this.#receiveSnapshot(message);
+        else if (message.type === "nativeEffectRequest")
+            void this.#receiveEffectRequest(message);
+        else if (message.type === "error")
+            this.#receiveError(message);
+        else {
+            if (message.type === "stateChanged")
+                this.#updateRevision(message.state.documentRevision);
+            if (message.type === "documentChanged")
+                this.#updateRevision(message.documentRevision);
+            this.#emit(message);
+        }
+        return true;
+    };
+    resetRuntime = () => {
+        const replacesActiveRuntime = this.#runtimeReady || this.#ready;
+        this.#runtimeReady = false;
+        this.#ready = false;
+        this.#documentRevision = 0;
+        // onLoadStart is also emitted for the first, expected WebView load. Commands
+        // queued before that first load must remain waiting for initialization.
+        if (replacesActiveRuntime) {
+            this.#rejectPending(new OpenEditorNativeLifecycleCancellationError("OpenEditor runtime reloaded before responding."));
+        }
+    };
+    dispose = (reason = "OpenEditor native host was disposed.") => {
+        this.#disposed = true;
+        this.#runtimeReady = false;
+        this.#ready = false;
+        this.#rejectPending(new OpenEditorNativeLifecycleCancellationError(reason));
+        this.#listeners.clear();
+    };
+    #waitForReady() {
+        if (this.#disposed)
+            return Promise.reject(new Error("OpenEditor native host was disposed."));
+        if (this.#ready)
+            return Promise.resolve();
+        return new Promise((resolve, reject) => {
+            const waiter = {
+                resolve,
+                reject,
+                timer: setTimeout(() => {
+                    this.#readyWaiters.delete(waiter);
+                    reject(new Error("OpenEditor runtime did not become ready."));
+                }, this.#requestTimeoutMs),
+            };
+            this.#readyWaiters.add(waiter);
+        });
+    }
+    #waitForRevision(minimum) {
+        if (this.#documentRevision >= minimum)
+            return Promise.resolve();
+        return new Promise((resolve, reject) => {
+            const waiter = {
+                minimum,
+                resolve,
+                reject,
+                timer: setTimeout(() => {
+                    this.#revisionWaiters.delete(waiter);
+                    reject(new Error(`OpenEditor document revision ${minimum} was not reached.`));
+                }, this.#requestTimeoutMs),
+            };
+            this.#revisionWaiters.add(waiter);
+        });
+    }
+    #nextId() { this.#counter += 1; return `rn:${this.#counter}`; }
+    #sendCommand(command, needsSnapshot) {
+        const id = this.#nextId();
+        const envelope = { protocol: OPENEDITOR_PROTOCOL, version: OPENEDITOR_PROTOCOL_VERSION, sessionId: this.sessionId, type: "command", id, command };
+        return new Promise((resolve, reject) => {
+            const timer = setTimeout(() => { this.#pending.delete(id); reject(new Error(`OpenEditor runtime command timed out: ${command.type}`)); }, this.#requestTimeoutMs);
+            this.#pending.set(id, { command: command.type, resolve: (value) => resolve(value), reject, timer });
+            this.#send(JSON.stringify(envelope));
+            if (!needsSnapshot)
+                return;
+        });
+    }
+    #receiveAck(message) {
+        this.#updateRevision(message.documentRevision);
+        const pending = this.#pending.get(message.commandId);
+        if (!pending)
+            return;
+        pending.ack = message;
+        if (pending.command === "requestDocument")
+            this.#finishSnapshot(message.commandId, pending);
+        else
+            this.#finish(message.commandId, pending, message);
+    }
+    #receiveSnapshot(message) {
+        this.#updateRevision(message.documentRevision);
+        const pending = this.#pending.get(message.requestId);
+        if (!pending || pending.command !== "requestDocument")
+            return;
+        pending.snapshot = message;
+        this.#finishSnapshot(message.requestId, pending);
+    }
+    #finishSnapshot(id, pending) {
+        if (!pending.ack || !pending.snapshot)
+            return;
+        this.#finish(id, pending, { document: pending.snapshot.document, revision: pending.snapshot.documentRevision });
+    }
+    #finish(id, pending, value) {
+        this.#pending.delete(id);
+        clearTimeout(pending.timer);
+        pending.resolve(value);
+    }
+    #receiveError(message) {
+        if (message.commandId) {
+            const pending = this.#pending.get(message.commandId);
+            if (pending) {
+                this.#pending.delete(message.commandId);
+                clearTimeout(pending.timer);
+                pending.reject(new Error(`${message.code}: ${message.message}`));
+            }
+        }
+        this.#emit(message);
+    }
+    async #receiveEffectRequest(message) {
+        const handler = this.#effectHandlers?.()?.[message.effect.type];
+        let result;
+        try {
+            result = handler ? await handler(message.effect) : { status: "error", code: "missingHandler", message: `No native handler for ${message.effect.type}.` };
+        }
+        catch (error) {
+            result = { status: "error", code: "nativeEffectFailed", message: error instanceof Error ? error.message : "Native effect failed." };
+        }
+        const response = { protocol: OPENEDITOR_PROTOCOL, version: OPENEDITOR_PROTOCOL_VERSION, sessionId: this.sessionId, type: "nativeEffectResponse", id: this.#nextId(), requestId: message.id, effect: message.effect.type, result };
+        this.#send(JSON.stringify(response));
+    }
+    #updateRevision(revision) {
+        this.#documentRevision = Math.max(this.#documentRevision, revision);
+        for (const waiter of this.#revisionWaiters)
+            if (this.#documentRevision >= waiter.minimum) {
+                this.#revisionWaiters.delete(waiter);
+                clearTimeout(waiter.timer);
+                waiter.resolve();
+            }
+    }
+    #emit(message) { for (const listener of this.#listeners)
+        listener(message); }
+    #rejectPending(error) {
+        for (const pending of this.#pending.values()) {
+            clearTimeout(pending.timer);
+            pending.reject(error);
+        }
+        this.#pending.clear();
+        for (const waiter of this.#readyWaiters) {
+            clearTimeout(waiter.timer);
+            waiter.reject(error);
+        }
+        this.#readyWaiters.clear();
+        for (const waiter of this.#revisionWaiters) {
+            clearTimeout(waiter.timer);
+            waiter.reject(error);
+        }
+        this.#revisionWaiters.clear();
+    }
+}
+export const emptyOpenEditorNativeState = {
+    revision: 0,
+    documentRevision: 0,
+    activeMarks: [],
+    activeNodes: ["paragraph"],
+    canUndo: false,
+    canRedo: false,
+    editable: true,
+    focused: false,
+    selection: { type: "text", anchor: 1, head: 1 },
+};

package/dist/index.d.ts

@@ -1,101 +1,6 @@
-import { type OpenEditorDocument, type OpenEditorAttachmentRuntime, type OpenEditorAuthoringCapabilities, type OpenEditorPageRuntime, type OpenEditorPageSnapshot, type ProseMirrorNode } from "@openeditor/core";
-import { type ReactNode } from "react";
-import type { NativeRichTextEditorToolbarPlacement } from "@openeditor/react-native-prose-editor";
-export { normalizeNativeThemeColor } from "./theme.js";
-export { OpenEditorNativeEmojiPicker, type OpenEditorNativeEmojiPickerProps, type OpenEditorNativeEmojiPickerTheme, } from "./emoji-picker.js";
-export { emojiForNativeSkinTone, getOpenEditorNativeEmojiSections, openEditorNativeEmojiSkinToneOptions, type OpenEditorNativeEmoji, type OpenEditorNativeEmojiSection, type OpenEditorNativeEmojiSkinTone, } from "./emoji-data.js";
-export type OpenEditorNativeProps = OpenEditorAuthoringCapabilities & {
-    initialDocument?: OpenEditorDocument;
-    editable?: boolean;
-    placeholder?: string;
-    showToolbar?: boolean;
-    theme?: Partial<OpenEditorNativeTheme>;
-    toolbarPlacement?: NativeRichTextEditorToolbarPlacement;
-    onChange?: (document: OpenEditorDocument) => void;
-    pageRuntime?: OpenEditorPageRuntime;
-    attachmentRuntime?: OpenEditorAttachmentRuntime<any>;
-};
-export type OpenEditorNativeViewerProps = {
-    document: OpenEditorDocument;
-    theme?: Partial<OpenEditorNativeTheme>;
-    pageRuntime?: OpenEditorPageRuntime;
-    attachmentRuntime?: OpenEditorAttachmentRuntime<any>;
-    renderers?: Partial<Record<string, OpenEditorNativeViewerRenderer>>;
-};
-export type OpenEditorNativeController = {
-    getContent: () => OpenEditorDocument;
-    setContent: (document: OpenEditorDocument) => void;
-    undo: () => void;
-    redo: () => void;
-};
-export type OpenEditorNativeToolbarAction = {
-    key: string;
-    label: string;
-    onPress?: (key: string) => void;
-};
-export type OpenEditorNativeToolbarProps = {
-    actions?: readonly OpenEditorNativeToolbarAction[];
-    onActionPress?: (key: string) => void;
-    theme?: Partial<OpenEditorNativeTheme>;
-};
-export type OpenEditorNativeViewerRenderer = (context: {
-    node: ProseMirrorNode;
-    children: ReactNode;
-    theme: Required<OpenEditorNativeTheme>;
-}) => ReactNode;
-export type OpenEditorNativeToolbarTheme = {
-    height?: number;
-};
-export type OpenEditorNativeTheme = {
-    background: string;
-    surface: string;
-    surfaceMuted: string;
-    blockSurface?: string;
-    text: string;
-    textSoft?: string;
-    muted: string;
-    placeholder?: string;
-    border: string;
-    borderStrong?: string;
-    structuralLine?: string;
-    accent: string;
-    accentText: string;
-    accentStrong?: string;
-    primary: string;
-    primaryText: string;
-    codeBackground?: string;
-    codeText?: string;
-    debugBackground?: string;
-    debugText?: string;
-    debugHeading?: string;
-    debugBorder?: string;
-    debugButtonBackground?: string;
-    success?: string;
-    shadow?: string;
-    backdrop: string;
-    toolbar?: OpenEditorNativeToolbarTheme;
-};
-export declare const OpenEditorNativeToolbar: ({ actions, onActionPress, theme, }: OpenEditorNativeToolbarProps) => import("react").JSX.Element;
-export type OpenEditorNativePageHeaderProps = {
-    page: OpenEditorPageSnapshot;
-    runtime: OpenEditorPageRuntime;
-    theme?: Partial<OpenEditorNativeTheme>;
-    onPageChange?: (page: OpenEditorPageSnapshot) => void;
-};
-/** Canonical native page-title and page-icon editor for opened page surfaces. */
-export declare const OpenEditorNativePageHeader: ({ page, runtime, theme, onPageChange }: OpenEditorNativePageHeaderProps) => import("react").JSX.Element;
-export declare const OpenEditorNative: import("react").ForwardRefExoticComponent<OpenEditorAuthoringCapabilities & {
-    initialDocument?: OpenEditorDocument;
-    editable?: boolean;
-    placeholder?: string;
-    showToolbar?: boolean;
-    theme?: Partial<OpenEditorNativeTheme>;
-    toolbarPlacement?: NativeRichTextEditorToolbarPlacement;
-    onChange?: (document: OpenEditorDocument) => void;
-    pageRuntime?: OpenEditorPageRuntime;
-    attachmentRuntime?: OpenEditorAttachmentRuntime<any>;
-} & import("react").RefAttributes<OpenEditorNativeController>>;
-export declare const OpenEditorNativeViewer: ({ document, theme, renderers, pageRuntime, attachmentRuntime, }: OpenEditorNativeViewerProps) => import("react").JSX.Element;
-export { createNativeEditorDocument, fromNativeEditorDocument, sanitizeNativeEditorDocument, toNativeEditorDocument, } from "./document.js";
-export { createOpenEditorNativeToolbarItems, defaultDocumentForToolbarAction, nativeToolbarParityCoverage, openEditorNativeToolbarActionKeys, openEditorNativeToolbarItems, } from "./toolbar.js";
-export type { OpenEditorNativeToolbarActionKey } from "./toolbar.js";
+export { OpenEditorNative, type OpenEditorNativeContentInsets, type OpenEditorNativeProps, type OpenEditorNativeTheme, } from "./native-editor.js";
+export { OpenEditorNativeProvider, type OpenEditorNativeProviderProps, } from "./native-provider.js";
+export { type OpenEditorNativeController, type OpenEditorNativeControllerEvent, type OpenEditorNativeEffectHandlers, } from "./controller.js";
+export { OpenEditorNativeToolbar, defaultOpenEditorNativeToolbarItems, openEditorNativeBlockPickerItems, type OpenEditorNativeToolbarItem, type OpenEditorNativeToolbarProps, } from "./toolbar-host.js";
+export { resolveOpenEditorNativeTheme, type OpenEditorNativeColorScheme, type ResolvedOpenEditorNativeTheme, } from "./theme.js";
+export type { OpenEditorRuntimeCommand, OpenEditorRuntimeState } from "@openeditor/embedded-runtime";