oasis-editor 0.0.1 → 0.0.2

package/dist/ui/OasisEditorApp.d.ts

@@ -1,4 +1,4 @@
 import { OasisEditorAppProps } from '../OasisEditorAppProps.js';
 
-export type { OasisEditorLoadingOptions, OasisEditorAppUiProps, OasisEditorAppDocumentProps, OasisEditorAppRuntimeProps, OasisEditorAppProps, } from '../OasisEditorAppProps.js';
+export type { OasisEditorLoadingOptions, OasisEditorAppUiProps, OasisEditorAppDocumentProps, OasisEditorAppRuntimeProps, OasisEditorAppProps, ToolbarLayoutMode, } from '../OasisEditorAppProps.js';
 export declare function OasisEditorApp(props?: OasisEditorAppProps): import("solid-js").JSX.Element;

package/dist/ui/OasisEditorAppLazy.d.ts

@@ -0,0 +1,16 @@
+import { OasisEditorAppProps } from '../OasisEditorAppProps.js';
+
+/**
+ * Code-splitting boundary for the editor. Loads `OasisEditorApp` (and the
+ * ~10MB of bundled fonts it drags in) via a single dynamic `import()`, keeping
+ * that weight in a lazy chunk. While the chunk downloads, renders an
+ * `OasisEditorLoading` card with a simulated-progress bar: the bar animates
+ * exponentially toward 90% (fast at first, then slowing), then snaps to 100%
+ * when the import resolves. Real byte-level progress isn't available for
+ * dynamic ES module imports without knowing the hashed chunk URL ahead of time,
+ * so this approach gives the best honest UX — it looks and feels like progress
+ * without lying about bytes received.
+ *
+ * Must not statically import anything that pulls the editor/font graph.
+ */
+export declare function OasisEditorAppLazy(props?: OasisEditorAppProps): import("solid-js").JSX.Element;

package/dist/ui/OasisEditorAppProps.d.ts

@@ -1,9 +1,12 @@
 import { JSX } from '../solid-js';
 import { EditorDocument, EditorState } from '../../core/model.js';
 import { ToolbarRegistry } from '../components/Toolbar/registry/ToolbarRegistry.js';
+import { MenuRegistry } from '../components/Menubar/menuRegistry.js';
 import { DocumentPersistence } from '../../app/controllers/useEditorPersistence.js';
 import { OasisPlugin } from '../../core/plugin.js';
+import { OasisEditorClient, OasisEditorClientController } from '../../app/client/OasisEditorClient.js';
 
+export type ToolbarLayoutMode = "overflow" | "wrap";
 export interface OasisEditorLoadingOptions {
     label?: string;
     class?: string;
@@ -13,6 +16,9 @@ export interface OasisEditorAppUiProps {
     showChrome?: boolean;
     shell?: "document" | "inline" | "balloon";
     uiVariant?: "classic" | "docs";
+    toolbar?: {
+        layout?: ToolbarLayoutMode;
+    };
     showTitleBar?: boolean;
     showMenubar?: boolean;
     showToolbar?: boolean;
@@ -30,17 +36,19 @@ export interface OasisEditorAppDocumentProps {
     readOnly?: boolean;
     persistenceEnabled?: boolean;
     persistence?: DocumentPersistence;
-    layoutMode?: "fast" | "wordParity";
 }
 export interface OasisEditorAppRuntimeProps {
-    onReady?: () => void;
+    onReady?: (client: OasisEditorClient) => void;
     plugins?: OasisPlugin[];
+    /** @internal Used by createOasisEditor()/mount() to bind the public client. */
+    client?: OasisEditorClientController;
     /**
      * Customize the toolbar after the built-in preset and plugin contributions
      * load. Use the registry to add/insert/replace/remove/move items. Clients can
      * tailor the toolbar without forking.
      */
     customizeToolbar?: (registry: ToolbarRegistry) => void;
+    customizeMenubar?: (registry: MenuRegistry) => void;
 }
 export interface OasisEditorAppProps {
     ui?: OasisEditorAppUiProps;

package/dist/ui/OasisEditorEditor.d.ts

@@ -1,25 +1,24 @@
 import { Accessor, JSX } from '../solid-js';
 import { ToolbarHost } from '../components/Toolbar/state/createToolbarApi.js';
 import { EditorLayoutParagraph, EditorState } from '../../core/model.js';
-import { CaretBox, InputBox, RevisionBox, SelectedImageBox, SelectionBox, ImageResizeHandleDirection } from '../editorUiTypes.js';
+import { ImportProgressState } from '../../app/controllers/useEditorDocumentIO.js';
+import { CaretBox, InputBox, LayoutOptionsOverlay, RevisionBox, SelectedImageBox, SelectedTextBoxBox, SelectionBox } from '../editorUiTypes.js';
+import { ResizeHandleDirection } from '../resizeGeometry.js';
 
-type ImportProgress = {
-    phase: "reading-file" | "opening-docx" | "parsing-document" | "parsing-headers-footers" | "applying-editor-state" | "stabilizing-layout" | "done" | "error";
-    progress: number;
-    subProgress?: number;
-};
+type ImportProgress = ImportProgressState;
 export interface OasisEditorEditorLayoutProps {
     measuredBlockHeights?: Accessor<Record<string, number>>;
     measuredParagraphLayouts?: Accessor<Record<string, EditorLayoutParagraph>>;
-    layoutMode?: "fast" | "wordParity";
     viewportHeight?: number | string;
     class?: string;
     style?: JSX.CSSProperties;
     readOnly?: boolean;
+    showHorizontalRuler?: boolean;
 }
 export interface OasisEditorEditorOverlayProps {
     selectionBoxes: Accessor<SelectionBox[]>;
     selectedImageBox: Accessor<SelectedImageBox | null>;
+    selectedTextBoxBox: Accessor<SelectedTextBoxBox | null>;
     caretBox: Accessor<CaretBox>;
     inputBox: Accessor<InputBox>;
     hoveredRevision: Accessor<RevisionBox | null>;
@@ -29,6 +28,7 @@ export interface OasisEditorEditorOverlayProps {
     toolbarHost?: () => ToolbarHost;
     persistenceStatus?: () => string;
     showFloatingTableToolbar?: Accessor<boolean>;
+    layoutOptions?: LayoutOptionsOverlay;
 }
 export interface OasisEditorEditorRefProps {
     onViewportRef?: (element: HTMLDivElement) => void;
@@ -51,7 +51,16 @@ export interface OasisEditorEditorSurfaceHandlers {
     onImageMouseDown: (paragraphId: string, paragraphOffset: number, event: MouseEvent & {
         currentTarget: HTMLElement;
     }) => void;
-    onImageResizeHandleMouseDown: (paragraphId: string, paragraphOffset: number, direction: ImageResizeHandleDirection, event: MouseEvent & {
+    onImageResizeHandleMouseDown: (paragraphId: string, paragraphOffset: number, direction: ResizeHandleDirection, event: MouseEvent & {
+        currentTarget: HTMLElement;
+    }) => void;
+    onTextBoxResizeHandleMouseDown: (paragraphId: string, paragraphOffset: number, direction: ResizeHandleDirection, event: MouseEvent & {
+        currentTarget: HTMLElement;
+    }) => void;
+    onImageRotateHandleMouseDown: (paragraphId: string, paragraphOffset: number, event: MouseEvent & {
+        currentTarget: HTMLElement;
+    }) => void;
+    onTextBoxRotateHandleMouseDown: (paragraphId: string, paragraphOffset: number, event: MouseEvent & {
         currentTarget: HTMLElement;
     }) => void;
     onTableDragHandleMouseDown: (tableId: string, event: MouseEvent) => void;

package/dist/ui/OasisEditorLoading.d.ts

@@ -0,0 +1,25 @@
+import { JSX } from '../solid-js';
+
+export interface OasisEditorLoadingProps {
+    label?: string;
+    class?: string;
+    style?: JSX.CSSProperties | string;
+    /**
+     * `overlay` (default): absolutely fills the already-mounted editor shell.
+     * `fill`: occupies its container in normal flow — used as the download-phase
+     * fallback when no positioned editor shell exists yet.
+     */
+    variant?: "overlay" | "fill";
+    /**
+     * 0–1 for a real/simulated percentage bar; undefined/null for indeterminate.
+     */
+    progress?: number | null;
+}
+/**
+ * Oasis-owned loading state. Lightweight (solid-js plus the inline ~6 KB WebP
+ * brand mark) so it lives in the main chunk and paints from the first JS tick
+ * without pulling the editor/font graph. Reuses the docx-import card styles for
+ * visual consistency. When `progress` is provided, renders a deterministic fill
+ * bar; otherwise animates indeterminate.
+ */
+export declare function OasisEditorLoading(props: OasisEditorLoadingProps): JSX.Element;

package/dist/ui/app/EditorDialogsLayer.d.ts

@@ -1,5 +1,7 @@
 import { ComponentProps } from '../../solid-js';
 import { FontDialog } from '../../../components/Dialogs/FontDialog.js';
+import { ParagraphDialog } from '../../../components/Dialogs/ParagraphDialog.js';
+import { TablePropertiesDialog } from '../../../components/Dialogs/TablePropertiesDialog.js';
 import { FindReplaceDialog } from '../../../components/FindReplace/FindReplaceDialog.js';
 import { ContextMenu } from '../../../components/ContextMenu/ContextMenu.js';
 import { createEditorDialogs } from '../../useEditorDialogs.js';
@@ -15,6 +17,8 @@ export interface EditorDialogsLayerProps {
     applyLinkCommand: (href: string | null) => void;
     applyImageAltCommand: (alt: string) => void;
     applyFontDialogValues: ComponentProps<typeof FontDialog>["onApply"];
+    applyParagraphDialogValues: ComponentProps<typeof ParagraphDialog>["onApply"];
+    applyTablePropertiesDialogValues: ComponentProps<typeof TablePropertiesDialog>["onApply"];
     closeContextMenu: () => void;
 }
 /**

package/dist/ui/app/EditorWorkspace.d.ts

@@ -3,20 +3,26 @@ import { OasisEditorEditor, OasisEditorEditorFileHandlers, OasisEditorEditorInpu
 import { ShellProps } from '../../../shells/DocumentShell.js';
 import { ToolbarHost } from '../../../components/Toolbar/state/createToolbarApi.js';
 import { ToolbarRegistry } from '../../../components/Toolbar/registry/ToolbarRegistry.js';
+import { MenuRegistry } from '../../../components/Menubar/menuRegistry.js';
 import { EditorLayoutParagraph, EditorState } from '../../../../core/model.js';
+import { ToolbarLayoutMode } from '../../../OasisEditorAppProps.js';
+import { OasisEditor } from '../../../../core/plugin.js';
 
 export interface EditorWorkspaceProps {
     useComposedShell: () => boolean;
     shellComponent: () => (props: ShellProps) => ReturnType<typeof OasisEditorEditor>;
     state: Accessor<EditorState>;
     toolbarHost: () => ToolbarHost;
+    runtimeEditor: Accessor<OasisEditor>;
     persistenceStatus: () => string;
     toolbarRegistry: ToolbarRegistry;
+    menuRegistry: MenuRegistry;
     showChrome: () => boolean;
     showTitleBar: () => boolean;
     showMenubar: () => boolean;
     showToolbar: () => boolean;
     showOutline: () => boolean;
+    toolbarLayout: () => ToolbarLayoutMode;
     isReadOnly: () => boolean;
     viewportHeight: () => number | string | undefined;
     measuredBlockHeights: Accessor<Record<string, number>>;

package/dist/ui/app/buildEditorViewProps.d.ts

@@ -1,5 +1,5 @@
 import { Accessor, JSX } from '../../solid-js';
-import { CaretBox, InputBox, RevisionBox, SelectedImageBox, SelectionBox } from '../../../editorUiTypes.js';
+import { CaretBox, InputBox, LayoutOptionsOverlay, RevisionBox, SelectedImageBox, SelectedTextBoxBox, SelectionBox } from '../../../editorUiTypes.js';
 import { OasisEditorEditorFileHandlers, OasisEditorEditorInputHandlers, OasisEditorEditorLayoutProps, OasisEditorEditorOverlayProps, OasisEditorEditorRefProps, OasisEditorEditorSurfaceHandlers } from '../../../OasisEditorEditor.js';
 import { createEditorFocusController } from '../../useEditorFocus.js';
 import { createEditorSurfaceEvents } from '../../../../app/controllers/useEditorSurfaceEvents.js';
@@ -16,12 +16,13 @@ type ImportProgress = NonNullable<ReturnType<NonNullable<OasisEditorEditorOverla
  * by `OasisEditorEditor` and the composed shells.
  */
 export interface EditorViewPropsContext {
-    layoutMode: NonNullable<OasisEditorEditorLayoutProps["layoutMode"]>;
     viewportHeight: number | string | undefined;
     className: string | undefined;
     style: JSX.CSSProperties | undefined;
     selectionBoxes: Accessor<SelectionBox[]>;
     selectedImageBox: Accessor<SelectedImageBox | null>;
+    selectedTextBoxBox: Accessor<SelectedTextBoxBox | null>;
+    layoutOptions: LayoutOptionsOverlay;
     caretBox: Accessor<CaretBox>;
     inputBox: Accessor<InputBox>;
     hoveredRevision: Accessor<RevisionBox | null>;
@@ -29,7 +30,7 @@ export interface EditorViewPropsContext {
     showCaret: Accessor<boolean>;
     importProgress: Accessor<ImportProgress | null>;
     focusController: ReturnType<typeof createEditorFocusController>;
-    handleImportDocx: (file: File | null) => void;
+    handleImportFile: (file: File | null) => void;
     handleInsertImage: (file: File | null) => void;
     surfaceEvents: ReturnType<typeof createEditorSurfaceEvents>;
     tableResize: ReturnType<typeof createEditorTableResize>;
@@ -39,6 +40,9 @@ export interface EditorViewPropsContext {
     onEditorMouseDown: OasisEditorEditorSurfaceHandlers["onEditorMouseDown"];
     handleImageMouseDown: OasisEditorEditorSurfaceHandlers["onImageMouseDown"];
     handleImageResizeHandleMouseDown: OasisEditorEditorSurfaceHandlers["onImageResizeHandleMouseDown"];
+    handleTextBoxResizeHandleMouseDown: OasisEditorEditorSurfaceHandlers["onTextBoxResizeHandleMouseDown"];
+    handleImageRotateHandleMouseDown: OasisEditorEditorSurfaceHandlers["onImageRotateHandleMouseDown"];
+    handleTextBoxRotateHandleMouseDown: OasisEditorEditorSurfaceHandlers["onTextBoxRotateHandleMouseDown"];
     handleEditorContextMenu: (event: MouseEvent) => void;
     textInput: ReturnType<typeof createEditorTextInput>;
     setFocused: (value: boolean) => void;

package/dist/ui/app/createRuntimeCommandHost.d.ts

@@ -11,8 +11,9 @@ interface CreateRuntimeCommandHostOptions {
     runtimePlugins: OasisPlugin[];
     focusEditor: () => void;
     logger: EditorLogger;
-    onReady?: () => void;
+    onReady?: (editor: Editor) => void;
     onSettled?: () => void;
+    onError?: (error: unknown) => void;
 }
 export declare function createRuntimeCommandHost(options: CreateRuntimeCommandHostOptions): {
     runtimeReady: Accessor<boolean>;

package/dist/ui/app/localFontAccess.d.ts

@@ -0,0 +1,33 @@
+export declare function isLocalFontAccessSupported(): boolean;
+/**
+ * Queries the installed font families (deduped, sorted). The first call may
+ * trigger the browser permission prompt; results are cached and pushed into the
+ * precise-font-mode availability set. Returns `[]` when unsupported or denied.
+ */
+export declare function probeLocalFontFamilies(): Promise<string[]>;
+/**
+ * Loads the real, locally-installed font programs for the given document
+ * families and registers them for precise-mode measurement. No-op unless precise
+ * mode is enabled and the Local Font Access API is available (and previously
+ * granted). Returns whether any new face was registered, so the caller can clear
+ * layout caches and re-project only when something actually changed.
+ */
+export declare function loadPreciseFontProgramsForFamilies(families: Iterable<string | null | undefined>): Promise<boolean>;
+/** Whether the browser already granted local-fonts permission (never prompts). */
+export declare function isLocalFontPermissionGranted(): Promise<boolean>;
+/**
+ * Enable precise font mode in response to an explicit user gesture (welcome
+ * dialog / menu). Probes installed fonts — prompting for permission if needed —
+ * and only enables when at least one family is readable. Persists the result.
+ * Returns whether precise mode is now active.
+ */
+export declare function enablePreciseFontMode(): Promise<boolean>;
+/** Disable precise font mode and persist the preference. */
+export declare function disablePreciseFontMode(): void;
+/** Toggle precise font mode; enabling prompts/probes, disabling is immediate. */
+export declare function togglePreciseFontMode(): Promise<boolean>;
+/**
+ * Re-apply a previously stored "on" preference on startup without ever showing
+ * a permission prompt: only proceeds when the browser already granted access.
+ */
+export declare function applyStoredPreciseFontPreference(): Promise<void>;

package/dist/ui/app/useCanvasSurfaceHitResolver.d.ts

@@ -8,9 +8,9 @@ export declare function createCanvasSurfaceHitResolver(deps: {
     viewportRef: Accessor<HTMLElement | null>;
     measuredBlockHeights: Accessor<Record<string, number>>;
     measuredParagraphLayouts: Accessor<Record<string, EditorLayoutParagraph>>;
-    layoutMode: Accessor<"fast" | "wordParity">;
 }): {
-    resolveSurfaceHitAtPoint: (clientX: number, clientY: number, _context?: {
+    resolveSurfaceHitAtPoint: (clientX: number, clientY: number, context?: {
         forDrag?: boolean;
+        pierce?: boolean;
     }) => SurfaceHit | null;
 };

package/dist/ui/app/useEditorContextMenuClipboard.d.ts

@@ -21,6 +21,24 @@ export interface EditorContextMenuClipboardDeps {
     focusInput: () => void;
     promptForLink: () => void;
     openFontDialog: () => void;
+    openParagraphDialog: () => void;
+    table?: {
+        isInsideTable: () => boolean;
+        canMerge: () => boolean;
+        canSplit: () => boolean;
+        canEditColumn: () => boolean;
+        canEditRow: () => boolean;
+        openProperties: () => void;
+        openBordersAndShading: () => void;
+        merge: () => void;
+        split: () => void;
+        insertColumnBefore: () => void;
+        insertColumnAfter: () => void;
+        deleteColumn: () => void;
+        insertRowBefore: () => void;
+        insertRowAfter: () => void;
+        deleteRow: () => void;
+    };
 }
 export declare function createEditorContextMenuClipboard(deps: EditorContextMenuClipboardDeps): {
     buildContextMenuItems: () => ContextMenuItem[];

package/dist/ui/app/useEditorDialogs.d.ts

@@ -1,4 +1,6 @@
 import { FontDialogInitialValues } from '../../../components/Dialogs/FontDialog.js';
+import { ParagraphDialogInitialValues } from '../../../components/Dialogs/ParagraphDialog.js';
+import { TablePropertiesDialogInitialValues } from '../../../components/Dialogs/TablePropertiesDialog.js';
 
 export declare function createEditorDialogs(): {
     linkDialog: import('../../solid-js').Accessor<{
@@ -35,4 +37,20 @@ export declare function createEditorDialogs(): {
         isOpen: boolean;
         initial: FontDialogInitialValues;
     }>;
+    paragraphDialog: import('../../solid-js').Accessor<{
+        isOpen: boolean;
+        initial: ParagraphDialogInitialValues;
+    }>;
+    setParagraphDialog: import('../../solid-js').Setter<{
+        isOpen: boolean;
+        initial: ParagraphDialogInitialValues;
+    }>;
+    tablePropertiesDialog: import('../../solid-js').Accessor<{
+        isOpen: boolean;
+        initial: TablePropertiesDialogInitialValues;
+    }>;
+    setTablePropertiesDialog: import('../../solid-js').Setter<{
+        isOpen: boolean;
+        initial: TablePropertiesDialogInitialValues;
+    }>;
 };

package/dist/ui/app/useEditorRuntimeBootstrap.d.ts

@@ -16,14 +16,17 @@ export interface EditorRuntimeBootstrapContext {
     essentials: EssentialsPluginDeps;
     externalPlugins: RuntimePluginsConfig["externalPlugins"];
     customizeToolbar: RuntimePluginsConfig["customizeToolbar"];
+    customizeMenubar: RuntimePluginsConfig["customizeMenubar"];
     initialDocument: RuntimeCommandHostConfig["initialDocument"];
     focusEditor: RuntimeCommandHostConfig["focusEditor"];
     logger: RuntimeCommandHostConfig["logger"];
     onReady: RuntimeCommandHostConfig["onReady"];
     onSettled: RuntimeCommandHostConfig["onSettled"];
+    onError?: RuntimeCommandHostConfig["onError"];
 }
 export interface EditorRuntimeBootstrap {
     toolbarRegistry: ReturnType<typeof useEditorRuntimePlugins>["toolbarRegistry"];
+    menuRegistry: ReturnType<typeof useEditorRuntimePlugins>["menuRegistry"];
     runtimeReady: RuntimeCommandHost["runtimeReady"];
     runtimeEditor: RuntimeCommandHost["runtimeEditor"];
     commandStateOf: RuntimeCommandHost["commandStateOf"];

package/dist/ui/app/useEditorRuntimePlugins.d.ts

@@ -1,14 +1,17 @@
 import { OasisPlugin } from '../../../../core/plugin.js';
+import { MenuRegistry } from '../../../components/Menubar/menuRegistry.js';
 import { ToolbarRegistry } from '../../../components/Toolbar/registry/ToolbarRegistry.js';
 
 export interface EditorRuntimePluginsOptions {
     essentialsPlugin: OasisPlugin;
     externalPlugins?: OasisPlugin[];
     customizeToolbar?: (registry: ToolbarRegistry) => void;
+    customizeMenubar?: (registry: MenuRegistry) => void;
 }
 export interface EditorRuntimePlugins {
     runtimePlugins: OasisPlugin[];
     toolbarRegistry: ToolbarRegistry;
+    menuRegistry: MenuRegistry;
     dispose: () => void;
 }
 export declare function useEditorRuntimePlugins(options: EditorRuntimePluginsOptions): EditorRuntimePlugins;

package/dist/ui/app/useEditorUiOptions.d.ts

@@ -15,7 +15,7 @@ export declare function createEditorUiOptions(ctx: EditorUiOptionsContext): {
     showMenubar: () => boolean;
     showToolbar: () => boolean;
     showOutline: () => boolean;
-    layoutMode: () => "fast" | "wordParity";
+    toolbarLayout: () => import('../../../OasisEditorAppProps.js').ToolbarLayoutMode;
     isReadOnly: () => boolean;
     useComposedShell: () => boolean;
     loadingOptions: () => OasisEditorLoadingOptions | undefined;

package/dist/ui/app/useParagraphDialogBridge.d.ts

@@ -0,0 +1,29 @@
+import { EditorState } from '../../../../core/model.js';
+import { ParagraphDialogApplyValues, ParagraphDialogInitialValues } from '../../../components/Dialogs/ParagraphDialog.js';
+import { ToolbarStyleState } from '../../../toolbarStyleState.js';
+
+interface ParagraphDialogState {
+    isOpen: boolean;
+    initial: ParagraphDialogInitialValues;
+}
+export interface ParagraphDialogBridgeDeps {
+    toolbarStyleState: () => ToolbarStyleState;
+    isReadOnly: () => boolean;
+    setParagraphDialog: (state: ParagraphDialogState) => void;
+    setContextMenu: (state: {
+        isOpen: boolean;
+        x: number;
+        y: number;
+    }) => void;
+    clearPreferredColumn: () => void;
+    resetTransactionGrouping: () => void;
+    applyTransactionalState: (producer: (current: EditorState) => EditorState, options?: {
+        mergeKey?: string;
+    }) => void;
+    focusInput: () => void;
+}
+export declare function createParagraphDialogBridge(deps: ParagraphDialogBridgeDeps): {
+    openParagraphDialog: () => void;
+    applyParagraphDialogValues: (values: ParagraphDialogApplyValues, original: ParagraphDialogInitialValues) => void;
+};
+export {};

package/dist/ui/app/useTablePropertiesDialogBridge.d.ts

@@ -0,0 +1,30 @@
+import { EditorState } from '../../../../core/model.js';
+import { TablePropertiesDialogApplyValues, TablePropertiesDialogInitialValues } from '../../../components/Dialogs/TablePropertiesDialog.js';
+
+interface TablePropertiesDialogState {
+    isOpen: boolean;
+    initial: TablePropertiesDialogInitialValues;
+}
+interface ContextMenuState {
+    isOpen: boolean;
+    x: number;
+    y: number;
+}
+export interface TablePropertiesDialogBridgeDeps {
+    state: () => EditorState;
+    isReadOnly: () => boolean;
+    setTablePropertiesDialog: (state: TablePropertiesDialogState) => void;
+    setContextMenu: (state: ContextMenuState) => void;
+    clearPreferredColumn: () => void;
+    resetTransactionGrouping: () => void;
+    applyTransactionalState: (producer: (current: EditorState) => EditorState, options?: {
+        mergeKey?: string;
+    }) => void;
+    focusInput: () => void;
+}
+export declare function createTablePropertiesDialogBridge(deps: TablePropertiesDialogBridgeDeps): {
+    isInsideTable: () => boolean;
+    openTablePropertiesDialog: (activeTab?: TablePropertiesDialogInitialValues["activeTab"]) => void;
+    applyTablePropertiesDialogValues: (values: TablePropertiesDialogApplyValues) => void;
+};
+export {};

package/dist/ui/canvas/CanvasHitTestService.d.ts

@@ -11,6 +11,16 @@ export interface SurfaceHitImage {
     width: number;
     height: number;
 }
+export interface SurfaceHitTextBox {
+    paragraphId: string;
+    paragraphOffset: number;
+    startOffset: number;
+    endOffset: number;
+    left: number;
+    top: number;
+    width: number;
+    height: number;
+}
 export interface SurfaceHit {
     zone: EditorEditingZone;
     footnoteId?: string;
@@ -27,11 +37,18 @@ export interface SurfaceHit {
         height: number;
     };
     image?: SurfaceHitImage;
+    textBox?: SurfaceHitTextBox;
 }
 export interface ResolveCanvasHitOptions {
     snapshot: CanvasLayoutSnapshot;
     state: EditorState;
     clientX: number;
     clientY: number;
+    /**
+     * "Pierce" mode (Alt+click): select the floating object directly under the
+     * cursor even when it is painted behind the text (behindDoc). When false,
+     * behind-text objects are skipped so clicks fall through to the text on top.
+     */
+    pierce?: boolean;
 }
 export declare function resolveCanvasSurfaceHitAtPoint(options: ResolveCanvasHitOptions): SurfaceHit | null;

package/dist/ui/canvas/CanvasLayoutSnapshot.d.ts

@@ -1,5 +1,6 @@
 import { EditorEditingZone, EditorLayoutParagraph, EditorParagraphNode, EditorPosition, EditorState } from '../../../../core/model.js';
 import { CanvasUnsupportedReason } from '../../CanvasTableLayout.js';
+import { VerticalRenderMode } from '../../verticalText.js';
 
 export interface CanvasSnapshotSlot {
     offset: number;
@@ -40,6 +41,8 @@ export interface CanvasSnapshotParagraph {
     height: number;
     lines: CanvasSnapshotLine[];
     tableCell?: CanvasSnapshotTableCellInfo;
+    /** Set when the paragraph is painted with a vertical-text transform. */
+    verticalMode?: VerticalRenderMode;
 }
 export interface CanvasSnapshotInlineImage {
     paragraphId: string;
@@ -53,6 +56,57 @@ export interface CanvasSnapshotInlineImage {
     top: number;
     width: number;
     height: number;
+    /** Shape rotation in degrees, when rotated. */
+    rotation?: number;
+}
+export interface CanvasSnapshotFloatingTextBox {
+    paragraphId: string;
+    paragraphIndex: number;
+    zone: EditorEditingZone;
+    footnoteId?: string;
+    pageIndex: number;
+    startOffset: number;
+    endOffset: number;
+    left: number;
+    top: number;
+    width: number;
+    height: number;
+    /** Shape rotation in degrees, when rotated. */
+    rotation?: number;
+    /** True when the object is painted behind the text (`behindDoc`). */
+    behindDoc?: boolean;
+}
+export interface CanvasSnapshotFloatingImage {
+    paragraphId: string;
+    paragraphIndex: number;
+    zone: EditorEditingZone;
+    footnoteId?: string;
+    pageIndex: number;
+    startOffset: number;
+    endOffset: number;
+    left: number;
+    top: number;
+    width: number;
+    height: number;
+    /** Shape rotation in degrees, when rotated. */
+    rotation?: number;
+    /** True when the object is painted behind the text (`behindDoc`). */
+    behindDoc?: boolean;
+}
+export interface CanvasSnapshotInlineTextBox {
+    paragraphId: string;
+    paragraphIndex: number;
+    zone: EditorEditingZone;
+    footnoteId?: string;
+    pageIndex: number;
+    startOffset: number;
+    endOffset: number;
+    left: number;
+    top: number;
+    width: number;
+    height: number;
+    /** Shape rotation in degrees, when rotated. */
+    rotation?: number;
 }
 export interface CanvasSnapshotPage {
     index: number;
@@ -72,6 +126,9 @@ export interface CanvasLayoutSnapshot {
     paragraphs: CanvasSnapshotParagraph[];
     paragraphsById: Map<string, CanvasSnapshotParagraph[]>;
     inlineImages: CanvasSnapshotInlineImage[];
+    floatingImages: CanvasSnapshotFloatingImage[];
+    inlineTextBoxes: CanvasSnapshotInlineTextBox[];
+    floatingTextBoxes: CanvasSnapshotFloatingTextBox[];
     unsupportedRegions: Array<{
         pageIndex: number;
         zone: EditorEditingZone;
@@ -88,6 +145,5 @@ export interface BuildCanvasLayoutSnapshotOptions {
     state: EditorState;
     measuredBlockHeights?: Record<string, number>;
     measuredParagraphLayouts?: Record<string, EditorLayoutParagraph>;
-    layoutMode?: "fast" | "wordParity";
 }
 export declare function buildCanvasLayoutSnapshot(options: BuildCanvasLayoutSnapshotOptions): CanvasLayoutSnapshot | null;

package/dist/ui/canvas/CanvasSelectionGeometry.d.ts

@@ -10,11 +10,27 @@ export interface SelectedImageSelectionBox {
     top: number;
     width: number;
     height: number;
+    /** Shape rotation in degrees (0 when not rotated). */
+    rotation: number;
+}
+export interface SelectedTextBoxSelectionBox {
+    paragraphId: string;
+    startOffset: number;
+    endOffset: number;
+    left: number;
+    top: number;
+    width: number;
+    height: number;
+    /** Shape rotation in degrees (0 when not rotated). */
+    rotation: number;
+    /** True when the selected text box is a floating (anchored) drawing. */
+    floating: boolean;
 }
 export interface CanvasSelectionGeometryResult {
     selectionBoxes: SelectionBox[];
     caretBox: CaretBox;
     inputBox: InputBox;
     selectedImageBox: SelectedImageSelectionBox | null;
+    selectedTextBoxBox: SelectedTextBoxSelectionBox | null;
 }
 export declare function computeCanvasSelectionGeometry(snapshot: CanvasLayoutSnapshot, state: EditorState): CanvasSelectionGeometryResult;

package/dist/ui/canvas/CanvasTableLayout.d.ts

@@ -1,5 +1,6 @@
 import { EditorParagraphNode, EditorPosition, EditorState, EditorTableNode } from '../../../../core/model.js';
 import { projectParagraphLayout } from '../../../../layoutProjection/index.js';
+import { VerticalRenderMode } from '../../verticalText.js';
 
 export type CanvasUnsupportedReason = "unsupported:v-span" | "unsupported:v-merge" | "unsupported:nested-table";
 export interface CanvasTableBorderSpec {
@@ -42,6 +43,8 @@ export interface CanvasTableCellLayoutEntry {
         left: CanvasTableBorderSpec;
     };
     paragraphs: CanvasTableParagraphLayoutEntry[];
+    /** Vertical text flow inside this cell (`horizontal` when not rotated). */
+    verticalMode: VerticalRenderMode;
 }
 export interface CanvasTableLayoutResult {
     tableId: string;
@@ -57,7 +60,6 @@ export declare function buildCanvasTableLayout(options: {
     table: EditorTableNode;
     state: EditorState;
     pageIndex: number;
-    layoutMode: "fast" | "wordParity";
     originX: number;
     originY: number;
     contentWidth: number;

package/dist/ui/canvas/canvasBlockPainter.d.ts

@@ -1,4 +1,4 @@
-import { EditorLayoutBlock, EditorState } from '../../../../core/model.js';
+import { EditorLayoutBlock, EditorPageSettings, EditorState } from '../../../../core/model.js';
 
-export declare function renderBlockList(ctx: CanvasRenderingContext2D, state: EditorState, blocks: EditorLayoutBlock[], originX: number, originY: number, contentWidth: number, pageIndex: number, onUpdate: () => void): void;
+export declare function renderBlockList(ctx: CanvasRenderingContext2D, state: EditorState, blocks: EditorLayoutBlock[], originX: number, originY: number, contentWidth: number, pageIndex: number, onUpdate: () => void, pageSettings?: EditorPageSettings): void;
 export declare function renderFootnoteBlockList(ctx: CanvasRenderingContext2D, state: EditorState, blocks: EditorLayoutBlock[], footnoteReferenceIds: string[], originX: number, originY: number, contentWidth: number, pageIndex: number, onUpdate: () => void): void;