@effindomv2/fui-as 0.1.36 → 0.1.39

package/src/core/Application.ts

@@ -3,9 +3,11 @@ import { ContextMenuManager } from "./ContextMenuManager";
 import { disposeAllFetchRequests } from "./Fetch";
 import { disposeAllFileRequests } from "./File";
 import { FocusAdornerManager } from "./FocusAdornerManager";
+import { MobileTextSelectionToolbarManager } from "./MobileTextSelectionToolbarManager";
+import { SelectionHandleAdornerManager } from "./SelectionHandleAdornerManager";
 import { ToolTipManager } from "./ToolTipManager";
 import * as ui from "../bindings/ui";
-import { flushCommit, markNeedsCommit, resetCommitState } from "./FrameScheduler";
+import { flushCommit, fireLoadedCallbacks, markNeedsCommit, resetCommitState } from "./FrameScheduler";
 import { HandleValue, Unit } from "./ffi";
 import { Node } from "./Node";
 import { cancelAllTimers } from "./Timers";
@@ -29,12 +31,20 @@ function createEmptyPage(): Node {
   return new FlexBox().width(100.0, Unit.Percent).height(100.0, Unit.Percent);
 }
 
+function disposeAppScopedAsyncWork(): void {
+  disposeAllFetchRequests();
+  disposeAllFileRequests();
+  disposeAllWorkers();
+}
+
 class ApplicationShell extends FlexBox {
   constructor(root: Node) {
     super();
     this.width(100.0, Unit.Percent)
       .height(100.0, Unit.Percent)
       .child(root)
+      .child(SelectionHandleAdornerManager.createDefaultHost())
+      .child(MobileTextSelectionToolbarManager.createDefaultHost())
       .child(FocusAdornerManager.createDefaultHost())
       .child(ContextMenuManager.createDefaultMenu())
       .child(ToolTipManager.createDefaultHost());
@@ -198,10 +208,10 @@ export class Application<TPage> {
     }
 
     cancelAllTimers();
-    disposeAllFetchRequests();
-    disposeAllFileRequests();
-    disposeAllWorkers();
+    disposeAppScopedAsyncWork();
     FocusAdornerManager.clear();
+    SelectionHandleAdornerManager.clear();
+    MobileTextSelectionToolbarManager.clear();
     ToolTipManager.clear();
     resetCommitState();
     ui.reset();
@@ -211,6 +221,7 @@ export class Application<TPage> {
     ui.setRoot(shell.builtHandle);
     mountedShell = shell;
     mountedRoot = root;
+    fireLoadedCallbacks();
     markNeedsCommit();
     return root;
   }
@@ -224,10 +235,10 @@ export class Application<TPage> {
     mountedShell = null;
     mountedRoot = null;
     cancelAllTimers();
-    disposeAllFetchRequests();
-    disposeAllFileRequests();
-    disposeAllWorkers();
+    disposeAppScopedAsyncWork();
     FocusAdornerManager.clear();
+    SelectionHandleAdornerManager.clear();
+    MobileTextSelectionToolbarManager.clear();
     ToolTipManager.clear();
     resetCommitState();
   }
@@ -330,8 +341,7 @@ export function __disposeApp(): void {
     return;
   }
   app.dispose();
-  disposeAllFetchRequests();
-  disposeAllWorkers();
+  disposeAppScopedAsyncWork();
 }
 
 export function __flushRenders(): void {

package/src/core/Bitmap.ts

@@ -1,12 +1,74 @@
 import * as ui from "../bindings/ui";
+import * as ffi from "../core/ffi";
 import { markTextureAssetReady } from "./Assets";
 import { Disposable } from "./Disposable";
 import { allocateDynamicTextureId } from "./DynamicAssetIds";
+import { DrawContext } from "../drawing/DrawContext";
 import { throwObjectDisposed } from "./Errors";
+import { LoadedEventArgs, onLoadedWith } from "./FrameScheduler";
 import { error } from "./Logger";
+import { Node } from "./Node";
+import { FontFace, FontsLoadedEventArgs } from "./Typography";
+import { TextLayout } from "../text/TextLayout";
 
 const FUNCTION_BITMAP_CONSTRUCTOR = "Bitmap.constructor";
 
+export class BitmapTextReadyEventArgs {
+  readonly node: Node;
+
+  constructor(node: Node) {
+    this.node = node;
+  }
+}
+
+export type BitmapTextReadyHandler<Owner> = (owner: Owner, event: BitmapTextReadyEventArgs) => void;
+
+class BitmapTextReadyCallback {
+  constructor(
+    private readonly node: Node,
+    private readonly callback: (event: BitmapTextReadyEventArgs) => void,
+  ) {}
+
+  handleReady(): void {
+    onLoadedWith<BitmapTextReadyCallback>(this, handleBitmapTextLoaded);
+  }
+
+  handleLoaded(): void {
+    Bitmap.prepareText(this.node);
+    this.callback(new BitmapTextReadyEventArgs(this.node));
+  }
+}
+
+class BitmapTextReadyHandlerAction<Owner> {
+  constructor(
+    private readonly node: Node,
+    private readonly owner: Owner,
+    private readonly handler: BitmapTextReadyHandler<Owner>,
+  ) {}
+
+  handleReady(): void {
+    onLoadedWith<BitmapTextReadyHandlerAction<Owner>>(
+      this,
+      (action: BitmapTextReadyHandlerAction<Owner>, _event: LoadedEventArgs): void => {
+        action.handleLoaded();
+      },
+    );
+  }
+
+  handleLoaded(): void {
+    Bitmap.prepareText(this.node);
+    this.handler(this.owner, new BitmapTextReadyEventArgs(this.node));
+  }
+}
+
+function handleBitmapTextReady(callback: BitmapTextReadyCallback): void {
+  callback.handleReady();
+}
+
+function handleBitmapTextLoaded(callback: BitmapTextReadyCallback, _event: LoadedEventArgs): void {
+  callback.handleLoaded();
+}
+
 function throwBitmapError(category: string, message: string): void {
   error(category, message);
   throw new Error(message);
@@ -23,12 +85,20 @@ function validateBitmapDimensions(width: u32, height: u32): u32 {
   return <u32>totalBytes;
 }
 
+const MAX_DIRTY_RECTS: i32 = 16;
+const RECT_STRIDE: i32 = 4;  // x, y, w, h
+
 export class Bitmap implements Disposable {
   readonly width: u32;
   readonly height: u32;
   readonly textureId: u32;
   private pixelBytes: Uint8Array;
+  private offscreenId: u32 = 0;
+  private canvasUsed: bool = false;
+  private drawContext: DrawContext | null = null;
   private disposed: bool = false;
+  private dirtyRects: StaticArray<u32> = new StaticArray<u32>(MAX_DIRTY_RECTS * RECT_STRIDE);
+  private dirtyCount: i32 = 0;
 
   constructor(width: u32, height: u32) {
     const byteLength = validateBitmapDimensions(width, height);
@@ -36,6 +106,7 @@ export class Bitmap implements Disposable {
     this.height = height;
     this.textureId = allocateDynamicTextureId();
     this.pixelBytes = new Uint8Array(<i32>byteLength);
+    this.offscreenId = ffi.fui_canvas_create_offscreen(width, height);
   }
 
   pixels(): Uint8Array {
@@ -48,9 +119,152 @@ export class Bitmap implements Disposable {
     return pixels.length > 0 ? pixels.dataStart : 0;
   }
 
+  /**
+   * Returns a `DrawContext` targeting this bitmap's off‑screen raster
+   * surface.  Drawing commands issued on the context are accumulated on
+   * the off‑screen canvas and uploaded to the GPU texture on the next
+   * `commit()` call.
+   *
+   * The returned `DrawContext` is valid for the lifetime of the `Bitmap`.
+   * Do not store it beyond the `Bitmap`'s disposal.
+   */
+  canvas(): DrawContext {
+    this.ensureNotDisposed("Bitmap.canvas");
+    this.canvasUsed = true;
+    if (this.drawContext !== null) {
+      return this.drawContext!;
+    }
+    const ptr = ffi.fui_canvas_get_offscreen_ptr(this.offscreenId);
+    const context = new DrawContext(ptr);
+    this.drawContext = context;
+    return context;
+  }
+
+  /**
+   * Renders a retained text node into this bitmap's pixel buffer.
+   * Call `Bitmap.prepareText(node)` before the commit that makes the
+   * prepared glyphs visible in core.
+   *
+   * @param node  A built Text or RichText node sized to match this bitmap's dimensions.
+   */
+  render(node: Node, x: f32 = 0.0, y: f32 = 0.0, scale: f32 = 1.0): void {
+    this.ensureNotDisposed("Bitmap.render");
+    const handle = node.builtHandle;
+    if (handle == <u64>0) return;
+    ui.renderNodeToRgba(handle, this.width, this.height, this.pixelPtr(), <u32>this.pixelBytes.length, scale, x, y);
+  }
+
+  renderTextLayout(layout: TextLayout, x: f32 = 0.0, y: f32 = 0.0, scale: f32 = 1.0): void {
+    this.ensureNotDisposed("Bitmap.renderTextLayout");
+    if (!layout.isReady) {
+      error("TextLayout", "Bitmap.renderTextLayout() called before the TextLayout was ready; register onReady/onReadyWith and render after the callback.");
+      return;
+    }
+    this.render(layout._drawNode(), x, y, scale);
+  }
+
+  /** Queue text shaping for a built text node before the next CommitFrame. */
+  static prepareText(node: Node): void {
+    ui.prepareNode(node.builtHandle);
+  }
+
+  onTextReady(node: Node, onReady: (event: BitmapTextReadyEventArgs) => void): this {
+    Bitmap.onTextReady(node, onReady);
+    return this;
+  }
+
+  onTextReadyWith<Owner>(owner: Owner, node: Node, onReady: BitmapTextReadyHandler<Owner>): this {
+    Bitmap.onTextReadyWith<Owner>(owner, node, onReady);
+    return this;
+  }
+
+  static onTextReady(node: Node, onReady: (event: BitmapTextReadyEventArgs) => void): void {
+    const callback = new BitmapTextReadyCallback(node, onReady);
+    FontFace.whenFontsLoadedWith<BitmapTextReadyCallback>(
+      node._requiredFontIds(),
+      callback,
+      handleBitmapTextReady,
+    );
+  }
+
+  static onTextReadyWith<Owner>(owner: Owner, node: Node, onReady: BitmapTextReadyHandler<Owner>): void {
+    const callback = new BitmapTextReadyHandlerAction<Owner>(node, owner, onReady);
+    FontFace.whenFontsLoadedWith<BitmapTextReadyHandlerAction<Owner>>(
+      node._requiredFontIds(),
+      callback,
+      (action: BitmapTextReadyHandlerAction<Owner>, _event: FontsLoadedEventArgs): void => {
+        action.handleReady();
+      },
+    );
+  }
+
+  /**
+   * Mark a rectangular region as dirty. Call one or more times before
+   * commit(). If no dirty rects are registered, commit() uploads the
+   * entire buffer (current behavior, backward‑compatible).
+   *
+   * @param x  Left edge, clamped to [0, width).
+   * @param y  Top edge, clamped to [0, height).
+   * @param w  Width, clamped so x+w ≤ width.
+   * @param h  Height, clamped so y+h ≤ height.
+   */
+  dirtyRect(x: u32, y: u32, w: u32, h: u32): void {
+    if (w == 0 || h == 0) return;
+    if (x >= this.width) return;
+    if (y >= this.height) return;
+    const cx = x;
+    const cy = y;
+    const cw = x + w > this.width ? this.width - x : w;
+    const ch = y + h > this.height ? this.height - y : h;
+    if (this.dirtyCount < MAX_DIRTY_RECTS) {
+      const base = this.dirtyCount * RECT_STRIDE;
+      unchecked(this.dirtyRects[base] = cx);
+      unchecked(this.dirtyRects[base + 1] = cy);
+      unchecked(this.dirtyRects[base + 2] = cw);
+      unchecked(this.dirtyRects[base + 3] = ch);
+      this.dirtyCount++;
+    }
+  }
+
+  clearDirtyRects(): void {
+    this.dirtyCount = 0;
+  }
+
+  hasDirtyRects(): bool {
+    return this.dirtyCount > 0;
+  }
+
   commit(): u32 {
     this.ensureNotDisposed("Bitmap.commit");
-    ui.bitmapCommit(this.textureId, this.pixelBytes, this.width, this.height);
+    if (this.canvasUsed) {
+      if (this.drawContext !== null) {
+        this.drawContext!.flush();
+      }
+      ffi.fui_canvas_read_offscreen_pixels(
+        this.offscreenId, this.pixelBytes.dataStart, this.width, this.height);
+    }
+    if (this.dirtyCount > 0) {
+      for (let i: i32 = 0; i < this.dirtyCount; i++) {
+        const base = i * RECT_STRIDE;
+        const drx = unchecked(this.dirtyRects[base]);
+        const dry = unchecked(this.dirtyRects[base + 1]);
+        const drw = unchecked(this.dirtyRects[base + 2]);
+        const drh = unchecked(this.dirtyRects[base + 3]);
+        const rectBytes = new Uint8Array(<i32>(drw * drh * 4));
+        for (let row: u32 = 0; row < drh; row++) {
+          const srcIdx: i32 = <i32>(dry + row) * <i32>this.width * 4 + <i32>drx * 4;
+          const dstIdx: i32 = <i32>row * <i32>drw * 4;
+          memory.copy(rectBytes.dataStart + dstIdx, this.pixelBytes.dataStart + srcIdx, <i32>(drw * 4));
+        }
+        ffi.fui_bitmap_commit_dirty(
+          this.textureId, rectBytes.dataStart, drw * drh * 4,
+          this.width, this.height, drx, dry, drw, drh,
+        );
+      }
+      this.dirtyCount = 0;
+    } else {
+      ui.bitmapCommit(this.textureId, this.pixelBytes, this.width, this.height);
+    }
     markTextureAssetReady(this.textureId, <f32>this.width, <f32>this.height);
     return this.textureId;
   }
@@ -60,8 +274,12 @@ export class Bitmap implements Disposable {
       return;
     }
     this.disposed = true;
+    if (this.offscreenId !== 0) {
+      ffi.fui_canvas_destroy_offscreen(this.offscreenId);
+    }
     ui.bitmapRelease(this.textureId);
     this.pixelBytes = new Uint8Array(0);
+    this.drawContext = null;
   }
 
   private ensureNotDisposed(functionName: string): void {

package/src/core/ContextMenuManager.ts

@@ -4,6 +4,7 @@ import { ContextMenu, ContextMenuAction, MenuItem } from "../controls/ContextMen
 import { NavLink } from "../controls/NavLink";
 import { TextInputCore } from "../controls/internal/TextInputCore";
 import { EventRouter } from "./EventRouter";
+import { MobileTextSelectionToolbarManager } from "./MobileTextSelectionToolbarManager";
 import { HandleValue, KeyModifier, PointerEventType } from "./ffi";
 import {
   formatPrimaryShortcutLabel,
@@ -13,13 +14,13 @@ import {
   getPlatformFamily,
   PlatformFamily,
 } from "./Platform";
-import { Node } from "./Node";
+import { ContextMenuEventArgs, Node, VisibilityChangedEventArgs } from "./Node";
 import { Image } from "../nodes/Image";
 import { Svg } from "../nodes/Svg";
 import { TextCore } from "../nodes/TextCore";
 
-function handleMenuVisibilityChanged(visible: bool): void {
-  ContextMenuManager.handleMenuVisibilityChanged(visible);
+function handleMenuVisibilityChanged(event: VisibilityChangedEventArgs): void {
+  ContextMenuManager.handleMenuVisibilityChanged(event.visible);
 }
 
 function appendMenuSection(items: Array<MenuItem>, section: Array<MenuItem>): void {
@@ -96,18 +97,93 @@ export class ContextMenuManager {
     if (menu === null) {
       return;
     }
+    const targetNode = EventRouter.getRegisteredNode(handle);
+    if (this.invokeCustomContextMenuHandler(targetNode, x, y)) {
+      return;
+    }
+    const items = this.buildBuiltInItems(handle, x, y, true);
 
-    this.releaseActiveMenuLinkPreview();
+    const navigationItems = new Array<MenuItem>();
+    if (ffi.fui_can_navigate_back()) {
+      navigationItems.push(new MenuItem("Back", ContextMenuAction.NavigateBack, null, 0, resolveHistoryShortcutLabel(false)));
+    }
+    if (ffi.fui_can_navigate_forward()) {
+      navigationItems.push(new MenuItem("Forward", ContextMenuAction.NavigateForward, null, 0, resolveHistoryShortcutLabel(true)));
+    }
+    navigationItems.push(
+      new MenuItem("Reload Page", ContextMenuAction.ReloadPage, null, 0, formatPrimaryShortcutLabel("r")),
+    );
+    appendMenuSection(items, navigationItems);
+    if (items.length == 0) {
+      this.releaseActiveMenuLinkPreview();
+      return;
+    }
+    menu.items(items);
+    menu.showFromContextPointer(null, x, y);
+  }
+
+  static showForLongPress(handle: u64, x: f32, y: f32): bool {
+    const items = this.buildBuiltInItems(handle, x, y, false);
+    if (items.length == 0) {
+      this.releaseActiveMenuLinkPreview();
+      return false;
+    }
+    return MobileTextSelectionToolbarManager.showItemsAt(items, x, y);
+  }
+
+  static canShowForHandle(handle: u64): bool {
     const targetNode = EventRouter.getRegisteredNode(handle);
     let contextNode = targetNode;
     while (contextNode !== null) {
       if (contextNode.isContextMenuDisabled) {
-        return;
+        return false;
+      }
+      contextNode = contextNode.parentNode;
+    }
+    return true;
+  }
+
+  static hideActiveMenu(): void {
+    ContextMenu.hideActiveMenu();
+  }
+
+  static handleMenuVisibilityChanged(visible: bool): void {
+    if (!visible) {
+      this.releaseActiveMenuLinkPreview();
+    }
+  }
+
+  private static resolveActiveMenu(): ContextMenu | null {
+    if (this.menu !== null) {
+      return this.menu;
+    }
+    return this.defaultMenu;
+  }
+
+  private static invokeCustomContextMenuHandler(targetNode: Node | null, x: f32, y: f32): bool {
+    this.releaseActiveMenuLinkPreview();
+    let contextNode = targetNode;
+    while (contextNode !== null) {
+      if (contextNode.isContextMenuDisabled) {
+        return true;
       }
       const handler = contextNode.contextMenuHandler;
       if (handler !== null) {
-        handler(targetNode, x, y);
-        return;
+        handler(new ContextMenuEventArgs(targetNode, x, y));
+        return true;
+      }
+      contextNode = contextNode.parentNode;
+    }
+    return false;
+  }
+
+  private static buildBuiltInItems(handle: u64, x: f32, y: f32, clearSelectionOnBackgroundMiss: bool): Array<MenuItem> {
+    this.releaseActiveMenuLinkPreview();
+    const targetNode = EventRouter.getRegisteredNode(handle);
+    let contextNode = targetNode;
+    while (contextNode !== null) {
+      if (contextNode.isContextMenuDisabled) {
+        return new Array<MenuItem>();
       }
       contextNode = contextNode.parentNode;
     }
@@ -118,8 +194,8 @@ export class ContextMenuManager {
       link.pinPreviewForContextMenu();
       this.activeMenuLink = link;
       const linkItems = new Array<MenuItem>();
-      linkItems.push(new MenuItem("Open Link in New Tab", ContextMenuAction.OpenLinkInNewTab, link.href));
-      linkItems.push(new MenuItem("Open Link", ContextMenuAction.OpenLink, link.href));
+      linkItems.push(new MenuItem("New Tab", ContextMenuAction.OpenLinkInNewTab, link.href));
+      linkItems.push(new MenuItem("Open", ContextMenuAction.OpenLink, link.href));
       appendMenuSection(items, linkItems);
     }
 
@@ -132,50 +208,22 @@ export class ContextMenuManager {
     const imageUrl = this.resolveImageUrl(targetNode, x, y);
     if (imageUrl !== null && imageUrl.length > 0) {
       const imageItems = new Array<MenuItem>();
-      imageItems.push(new MenuItem("Open Image in New Tab", ContextMenuAction.OpenImageInNewTab, imageUrl));
-      imageItems.push(new MenuItem("Open Image", ContextMenuAction.OpenImage, imageUrl));
+      imageItems.push(new MenuItem("New Tab", ContextMenuAction.OpenImageInNewTab, imageUrl));
+      imageItems.push(new MenuItem("Open", ContextMenuAction.OpenImage, imageUrl));
       appendMenuSection(items, imageItems);
     }
 
     if (selectionHit && textTarget === null && this.currentSelectionText.length > 0) {
       const selectionItems = new Array<MenuItem>();
-      selectionItems.push(new MenuItem("Copy", ContextMenuAction.CopyCurrentSelection));
+      selectionItems.push(new MenuItem("Copy", ContextMenuAction.CopyCurrentSelection, this.currentSelectionText));
       appendMenuSection(items, selectionItems);
-    } else if (!selectionHit && textTarget === null && link === null && imageUrl === null) {
+    } else if (clearSelectionOnBackgroundMiss && !selectionHit && textTarget === null && link === null && imageUrl === null) {
       this.currentSelectionText = "";
       this.currentSelectionHandleHints.length = 0;
       ui.clearCurrentSelection();
     }
 
-    const navigationItems = new Array<MenuItem>();
-    if (ffi.fui_can_navigate_back()) {
-      navigationItems.push(new MenuItem("Back", ContextMenuAction.NavigateBack, null, 0, resolveHistoryShortcutLabel(false)));
-    }
-    if (ffi.fui_can_navigate_forward()) {
-      navigationItems.push(new MenuItem("Forward", ContextMenuAction.NavigateForward, null, 0, resolveHistoryShortcutLabel(true)));
-    }
-    navigationItems.push(
-      new MenuItem("Reload Page", ContextMenuAction.ReloadPage, null, 0, formatPrimaryShortcutLabel("r")),
-    );
-    appendMenuSection(items, navigationItems);
-    menu.show(items, x, y);
-  }
-
-  static hideActiveMenu(): void {
-    ContextMenu.hideActiveMenu();
-  }
-
-  static handleMenuVisibilityChanged(visible: bool): void {
-    if (!visible) {
-      this.releaseActiveMenuLinkPreview();
-    }
-  }
-
-  private static resolveActiveMenu(): ContextMenu | null {
-    if (this.menu !== null) {
-      return this.menu;
-    }
-    return this.defaultMenu;
+    return items;
   }
 
   private static resolveNavLink(node: Node | null): NavLink | null {
@@ -227,6 +275,8 @@ export class ContextMenuManager {
 
     const selectionStart = this.resolveSelectionStart(target);
     const selectionEnd = this.resolveSelectionEnd(target);
+    const selectionStartByte = this.resolveSelectionStartByte(target);
+    const selectionEndByte = this.resolveSelectionEndByte(target);
     const content = this.resolveTextContent(target);
     const hasSelection = ui.hasTextSelection(handle) || ffi.fui_has_text_selection_snapshot(handle) || selectionStart != selectionEnd;
     const hasText = content.length > 0;
@@ -243,6 +293,9 @@ export class ContextMenuManager {
           formatUndoShortcutLabel(),
           !ui.canUndoTextEdit(handle),
           handle,
+          0,
+          0,
+          true,
         ),
       );
       items.push(
@@ -254,6 +307,9 @@ export class ContextMenuManager {
           formatRedoShortcutLabel(),
           !ui.canRedoTextEdit(handle),
           handle,
+          0,
+          0,
+          true,
         ),
       );
       items.push(MenuItem.separator());
@@ -266,7 +322,10 @@ export class ContextMenuManager {
           formatPrimaryShortcutLabel("x"),
           !hasSelection,
           handle,
-        ).withSelectionRange(selectionStart, selectionEnd),
+          0,
+          0,
+          true,
+        ).withSelectionRange(selectionStartByte, selectionEndByte),
       );
       items.push(
         new MenuItem(
@@ -277,6 +336,9 @@ export class ContextMenuManager {
           formatPrimaryShortcutLabel("c"),
           !hasSelection,
           handle,
+          0,
+          0,
+          true,
         ),
       );
       items.push(
@@ -288,6 +350,9 @@ export class ContextMenuManager {
           formatPrimaryShortcutLabel("v"),
           false,
           handle,
+          0,
+          0,
+          true,
         ),
       );
       items.push(
@@ -299,6 +364,9 @@ export class ContextMenuManager {
           formatPrimaryShortcutLabel("a"),
           !hasText,
           handle,
+          0,
+          0,
+          true,
         ),
       );
       return items;
@@ -309,7 +377,7 @@ export class ContextMenuManager {
         new MenuItem(
           "Copy",
           ContextMenuAction.CopyCurrentSelection,
-          null,
+          currentSelectionText,
           0,
           formatPrimaryShortcutLabel("c"),
         ),
@@ -368,6 +436,22 @@ export class ContextMenuManager {
     return target.selectionEnd;
   }
 
+  private static resolveSelectionStartByte(target: TextCore): u32 {
+    const parent = target.parentNode;
+    if (parent instanceof TextInputCore) {
+      return changetype<TextInputCore>(parent).selectionStartByteOffset;
+    }
+    return target.selectionStart;
+  }
+
+  private static resolveSelectionEndByte(target: TextCore): u32 {
+    const parent = target.parentNode;
+    if (parent instanceof TextInputCore) {
+      return changetype<TextInputCore>(parent).selectionEndByteOffset;
+    }
+    return target.selectionEnd;
+  }
+
   private static resolveTextContent(target: TextCore): string {
     const parent = target.parentNode;
     if (parent instanceof TextInputCore) {

package/src/core/DebugApi.ts

@@ -1,12 +1,27 @@
 import {
   __fui_on_focus_changed,
   __fui_on_key_event,
-  __fui_on_pointer_event,
+  __fui_on_pointer_event_with_metadata,
   __fui_on_scroll,
 } from "./event_exports";
+import { PointerType } from "./Node";
 
 export function __fui_debug_pointer_event(eventType: u32, handle: u64, x: f32, y: f32, modifiers: u32 = 0): void {
-  __fui_on_pointer_event(eventType, handle, x, y, modifiers);
+  __fui_on_pointer_event_with_metadata(
+    eventType,
+    handle,
+    x,
+    y,
+    modifiers,
+    -1,
+    <u32>PointerType.Mouse,
+    0,
+    0,
+    0.0,
+    0.0,
+    0.0,
+    0,
+  );
 }
 
 export function __fui_debug_focus_changed(handle: u64, focused: bool): void {