@effindomv2/runtime 0.1.0

package/scripts/font_assets.sh

@@ -0,0 +1,52 @@
+#!/usr/bin/env bash
+
+BRIDGE_FONT_SOURCE_DIR="${REPO_ROOT}/v2/fonts"
+BRIDGE_FONT_ASSETS=(
+  "DejaVuSans.ttf"
+  "DejaVuSans-Bold.ttf"
+  "NotoSans-Regular.ttf"
+  "NotoSans-Bold.ttf"
+  "NotoSans-Italic.ttf"
+  "NotoSans-BoldItalic.ttf"
+  "NotoSansMono-Regular.ttf"
+  "NotoSansMono-Bold.ttf"
+  "NotoSansSymbols2-Regular.ttf"
+  "NotoEmoji-Regular.ttf"
+  "NotoColorEmoji.ttf"
+  "NotoSansThai-Regular.ttf"
+  "NotoNaskhArabic-Variable.ttf"
+)
+
+RUNTIME_PACKAGE_FONT_ASSETS=(
+  "NotoSans-Regular.ttf"
+  "NotoSans-Bold.ttf"
+  "NotoSans-Italic.ttf"
+  "NotoSans-BoldItalic.ttf"
+  "NotoSansMono-Regular.ttf"
+  "NotoSansMono-Bold.ttf"
+  "NotoSansSymbols2-Regular.ttf"
+  "NotoEmoji-Regular.ttf"
+  "NotoColorEmoji.ttf"
+)
+
+copy_bridge_font_assets() {
+  local out_dir="$1"
+  local font_asset=""
+  mkdir -p "${out_dir}"
+  for font_asset in "${BRIDGE_FONT_ASSETS[@]}"; do
+    if [ -f "${BRIDGE_FONT_SOURCE_DIR}/${font_asset}" ]; then
+      cp "${BRIDGE_FONT_SOURCE_DIR}/${font_asset}" "${out_dir}/${font_asset}"
+    fi
+  done
+}
+
+copy_runtime_package_font_assets() {
+  local out_dir="$1"
+  local font_asset=""
+  mkdir -p "${out_dir}"
+  for font_asset in "${RUNTIME_PACKAGE_FONT_ASSETS[@]}"; do
+    if [ -f "${BRIDGE_FONT_SOURCE_DIR}/${font_asset}" ]; then
+      cp "${BRIDGE_FONT_SOURCE_DIR}/${font_asset}" "${out_dir}/${font_asset}"
+    fi
+  done
+}

package/scripts/generate_manifest.py

@@ -0,0 +1,121 @@
+#!/usr/bin/env python3
+
+from __future__ import annotations
+
+import json
+import shutil
+import sys
+from pathlib import Path
+
+REPO_ROOT = Path(__file__).resolve().parents[3]
+sys.path.insert(0, str(REPO_ROOT / "scripts"))
+
+from content_hash import short_content_hash, standard_content_hash  # noqa: E402
+
+MANIFEST_FILENAME = "effindom.v2.manifest.json"
+MANIFEST_VERSION = "1.0"
+ARCHITECTURES = ("wasm64-simd", "wasm64", "wasm32-simd", "wasm32")
+BUNDLES = ("core", "ui")
+
+
+def stable_json_bytes(value: object) -> bytes:
+    return json.dumps(value, sort_keys=True, separators=(",", ":")).encode("utf-8")
+
+
+def content_integrity(data: bytes) -> str:
+    return f"sha256-{standard_content_hash(data)}"
+
+
+def stage_versioned_copy(source: Path, runtime_dir: Path, stem: str, suffix: str) -> dict[str, str]:
+    data = source.read_bytes()
+    hashed_name = f"{stem}.{short_content_hash(data)}{suffix}"
+    destination = runtime_dir / hashed_name
+    destination.write_bytes(data)
+    return {
+        "url": f"./runtime/{hashed_name}",
+        "integrity": content_integrity(data),
+    }
+
+
+def stage_bundle(stage_dir: Path, runtime_dir: Path, architecture: str, bundle_name: str) -> dict[str, str]:
+    bundle_dir = stage_dir / architecture
+    js_asset = stage_versioned_copy(
+        bundle_dir / f"{bundle_name}.js",
+        runtime_dir,
+        f"effindom-{bundle_name}-v2.{architecture}",
+        ".js",
+    )
+    wasm_asset = stage_versioned_copy(
+        bundle_dir / f"{bundle_name}.wasm",
+        runtime_dir,
+        f"effindom-{bundle_name}-v2.{architecture}",
+        ".wasm",
+    )
+
+    symbols_source = bundle_dir / f"{bundle_name}.js.symbols"
+    if symbols_source.exists():
+        stage_versioned_copy(
+            symbols_source,
+            runtime_dir,
+            f"effindom-{bundle_name}-v2.{architecture}",
+            ".js.symbols",
+        )
+
+    return {
+        "js": js_asset["url"],
+        "js_integrity": js_asset["integrity"],
+        "wasm": wasm_asset["url"],
+        "wasm_integrity": wasm_asset["integrity"],
+    }
+
+
+def main() -> int:
+    if len(sys.argv) != 4:
+        print(
+            f"Usage: {Path(sys.argv[0]).name} <out-dir> <stage-dir> <icu-source>",
+            file=sys.stderr,
+        )
+        return 1
+
+    out_dir = Path(sys.argv[1]).resolve()
+    stage_dir = Path(sys.argv[2]).resolve()
+    icu_source = Path(sys.argv[3]).resolve()
+    runtime_dir = out_dir / "runtime"
+
+    if runtime_dir.exists():
+        shutil.rmtree(runtime_dir)
+    runtime_dir.mkdir(parents=True, exist_ok=True)
+
+    architectures: dict[str, dict[str, dict[str, str]]] = {}
+    for architecture in ARCHITECTURES:
+        architectures[architecture] = {}
+        for bundle_name in BUNDLES:
+            architectures[architecture][bundle_name] = stage_bundle(stage_dir, runtime_dir, architecture, bundle_name)
+
+    icu_asset = stage_versioned_copy(icu_source, runtime_dir, "icudt_minimal", ".dat")
+    assets = {
+        "icu": {
+            "url": icu_asset["url"],
+            "integrity": icu_asset["integrity"],
+        }
+    }
+
+    manifest_payload = {
+        "architectures": architectures,
+        "assets": assets,
+    }
+    manifest = {
+        "version": MANIFEST_VERSION,
+        "manifest_hash": short_content_hash(stable_json_bytes(manifest_payload)),
+        **manifest_payload,
+    }
+
+    manifest_path = out_dir / MANIFEST_FILENAME
+    manifest_path.write_text(json.dumps(manifest, indent=2) + "\n", encoding="utf-8")
+    print(f"Generated: {manifest_path}")
+    print(json.dumps(manifest, indent=2))
+    return 0
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())

package/scripts/stage_package_assets.sh

@@ -0,0 +1,42 @@
+#!/usr/bin/env bash
+
+set -euo pipefail
+
+REPO_ROOT="$(cd "$(dirname "${BASH_SOURCE[0]}")/../../.." && pwd)"
+PACKAGE_DIR="${REPO_ROOT}/v2/browser-bridge"
+BRIDGE_PUBLIC_DIR="${REPO_ROOT}/public/v2/browser-bridge"
+PACKAGE_DIST_DIR="${PACKAGE_DIR}/dist"
+source "${REPO_ROOT}/v2/browser-bridge/scripts/font_assets.sh"
+
+require_path() {
+  local path="$1"
+  local label="$2"
+  if [ ! -e "${path}" ]; then
+    echo "Missing ${label}: ${path}" >&2
+    echo "Run 'npm run build:v2:browser-bridge' (or at least 'npm run build:v2:browser-bridge-assets') first." >&2
+    exit 1
+  fi
+}
+
+require_path "${BRIDGE_PUBLIC_DIR}/bridge.js" "bridge bundle"
+require_path "${BRIDGE_PUBLIC_DIR}/harness.js" "harness bundle"
+require_path "${BRIDGE_PUBLIC_DIR}/effindom.v2.manifest.json" "runtime manifest"
+require_path "${BRIDGE_PUBLIC_DIR}/runtime" "runtime artifact directory"
+
+rm -rf "${PACKAGE_DIST_DIR}"
+mkdir -p "${PACKAGE_DIST_DIR}"
+
+cp "${BRIDGE_PUBLIC_DIR}/bridge.js" "${PACKAGE_DIST_DIR}/bridge.js"
+cp "${BRIDGE_PUBLIC_DIR}/bridge.js.map" "${PACKAGE_DIST_DIR}/bridge.js.map"
+cp "${BRIDGE_PUBLIC_DIR}/harness.js" "${PACKAGE_DIST_DIR}/harness.js"
+cp "${BRIDGE_PUBLIC_DIR}/harness.js.map" "${PACKAGE_DIST_DIR}/harness.js.map"
+cp "${BRIDGE_PUBLIC_DIR}/effindom.v2.manifest.json" "${PACKAGE_DIST_DIR}/effindom.v2.manifest.json"
+cp "${BRIDGE_PUBLIC_DIR}/index.html" "${PACKAGE_DIST_DIR}/index.html"
+cp -R "${BRIDGE_PUBLIC_DIR}/runtime" "${PACKAGE_DIST_DIR}/runtime"
+
+if [ -f "${BRIDGE_PUBLIC_DIR}/icu-asset.json" ]; then
+  cp "${BRIDGE_PUBLIC_DIR}/icu-asset.json" "${PACKAGE_DIST_DIR}/icu-asset.json"
+fi
+
+rm -rf "${PACKAGE_DIST_DIR}/fonts"
+copy_runtime_package_font_assets "${PACKAGE_DIST_DIR}/fonts"

package/src/bridge/commit-policy.ts

@@ -0,0 +1,10 @@
+import type { BridgeRuntime } from '../core-types';
+
+export function commitIfVisualWork(runtime: BridgeRuntime): boolean {
+  if (!runtime.uiHasPendingVisualWork()) {
+    return false;
+  }
+  runtime.commitFrame();
+  return true;
+}
+

package/src/bridge/events/canvas-geometry.ts

@@ -0,0 +1,78 @@
+const DEFAULT_LOGICAL_WIDTH = 320;
+const DEFAULT_LOGICAL_HEIGHT = 220;
+
+export function ensureCanvasLogicalSize(canvas: HTMLCanvasElement): void {
+  const rect = canvas.getBoundingClientRect();
+  if (rect.width <= 0 || rect.height <= 0) {
+    canvas.style.width = `${String(DEFAULT_LOGICAL_WIDTH)}px`;
+    canvas.style.height = `${String(DEFAULT_LOGICAL_HEIGHT)}px`;
+  }
+}
+
+export function getCanvasSizeSource(canvas: HTMLCanvasElement): HTMLElement | HTMLCanvasElement {
+  const source = canvas.closest('[data-effindom-canvas-size-source]');
+  return source instanceof HTMLElement ? source : canvas;
+}
+
+export function readCanvasLogicalSize(canvas: HTMLCanvasElement): { readonly width: number; readonly height: number } {
+  const sizeSource = getCanvasSizeSource(canvas);
+  if (sizeSource.clientWidth > 0 && sizeSource.clientHeight > 0) {
+    return {
+      width: sizeSource.clientWidth,
+      height: sizeSource.clientHeight,
+    };
+  }
+  const styleWidth = Number.parseFloat(canvas.style.width);
+  const styleHeight = Number.parseFloat(canvas.style.height);
+  if (Number.isFinite(styleWidth) && styleWidth > 0 && Number.isFinite(styleHeight) && styleHeight > 0) {
+    return { width: styleWidth, height: styleHeight };
+  }
+  return {
+    width: canvas.clientWidth || DEFAULT_LOGICAL_WIDTH,
+    height: canvas.clientHeight || DEFAULT_LOGICAL_HEIGHT,
+  };
+}
+
+export function getPointerPosition(
+  canvas: HTMLCanvasElement,
+  event: { readonly clientX: number; readonly clientY: number },
+): { readonly x: number; readonly y: number } {
+  const sizeSource = getCanvasSizeSource(canvas);
+  const rect = sizeSource.getBoundingClientRect();
+  const logicalSize = readCanvasLogicalSize(canvas);
+  const contentLeft = rect.left + sizeSource.clientLeft;
+  const contentTop = rect.top + sizeSource.clientTop;
+  const displayWidth = sizeSource.clientWidth || (rect.width - (sizeSource.clientLeft + sizeSource.clientLeft)) || DEFAULT_LOGICAL_WIDTH;
+  const displayHeight = sizeSource.clientHeight || (rect.height - (sizeSource.clientTop + sizeSource.clientTop)) || DEFAULT_LOGICAL_HEIGHT;
+  const x = displayWidth > 0 ? ((event.clientX - contentLeft) / displayWidth) * logicalSize.width : 0;
+  const y = displayHeight > 0 ? ((event.clientY - contentTop) / displayHeight) * logicalSize.height : 0;
+  return { x, y };
+}
+
+export function isPointerInsideCanvas(
+  canvas: HTMLCanvasElement,
+  event: { readonly clientX: number; readonly clientY: number },
+): boolean {
+  const rect = getCanvasSizeSource(canvas).getBoundingClientRect();
+  return event.clientX >= rect.left &&
+    event.clientX <= rect.right &&
+    event.clientY >= rect.top &&
+    event.clientY <= rect.bottom;
+}
+
+export function normalizeWheelDelta(event: WheelEvent, canvas: HTMLCanvasElement): { readonly x: number; readonly y: number } {
+  let deltaX = event.deltaX;
+  let deltaY = event.deltaY;
+  if (event.deltaMode === WheelEvent.DOM_DELTA_LINE) {
+    deltaX *= 16.0;
+    deltaY *= 16.0;
+  } else if (event.deltaMode === WheelEvent.DOM_DELTA_PAGE) {
+    const logicalSize = readCanvasLogicalSize(canvas);
+    deltaX *= logicalSize.width;
+    deltaY *= logicalSize.height;
+  }
+  if (event.shiftKey && Math.abs(deltaX) < 0.001 && Math.abs(deltaY) > 0.0) {
+    return { x: deltaY, y: 0.0 };
+  }
+  return { x: deltaX, y: deltaY };
+}

package/src/bridge/events/key-router.ts

@@ -0,0 +1,187 @@
+import type { BridgeRuntime } from '../../core-types';
+import type { BridgeInteractionState } from '../local-types';
+import { DesktopFindDialogController } from '../find-dialog';
+import { computeModifiers } from '../utils/encoding';
+import { writeUtf8ToHeap } from '../utils/heap';
+
+const UI_KEY_EVENT_DOWN = 1;
+const UI_KEY_EVENT_UP = 2;
+
+function currentInteractionTimeMs(): bigint {
+  return BigInt(Math.floor(performance.now()));
+}
+
+function isVerticalCanvasNavigationKey(key: string): boolean {
+  return key === 'ArrowUp' ||
+    key === 'ArrowDown' ||
+    key === 'PageUp' ||
+    key === 'PageDown' ||
+    key === 'Home' ||
+    key === 'End';
+}
+
+function isTextNavigationKey(key: string): boolean {
+  return key === 'ArrowLeft' ||
+    key === 'ArrowRight' ||
+    key === 'ArrowUp' ||
+    key === 'ArrowDown' ||
+    key === 'PageUp' ||
+    key === 'PageDown' ||
+    key === 'Home' ||
+    key === 'End';
+}
+
+export function installKeyAndWindowHandlers(
+  runtime: BridgeRuntime,
+  interactionState: BridgeInteractionState,
+  desktopFindDialog: DesktopFindDialogController,
+): () => void {
+  const { ui } = runtime;
+
+  const forwardKeyEvent = (type: number) => (event: KeyboardEvent): void => {
+    if (desktopFindDialog.consumeGlobalKeyEvent(event, type === UI_KEY_EVENT_DOWN ? 'down' : 'up')) {
+      return;
+    }
+    const modifiers = computeModifiers(event);
+    const activeTextHandle = interactionState.getActiveTextHandle();
+    const activeTextEditable = interactionState.getActiveTextEditable();
+    const activeTextMultiline = interactionState.getActiveTextMultiline();
+    const activeTextInputFocused = interactionState.isActiveTextInputFocused();
+    const activeEditableTextOwnsNativeEditingKey =
+      activeTextHandle !== null &&
+      activeTextEditable &&
+      activeTextInputFocused &&
+      !event.ctrlKey &&
+      !event.metaKey &&
+      !event.altKey &&
+      (
+        event.key.length === 1 ||
+        (activeTextMultiline && event.key === 'Enter') ||
+        event.key === 'Backspace' ||
+        event.key === 'Delete'
+      );
+    const activeEditableTextNeedsRuntimeEditingFallback =
+      activeTextHandle !== null &&
+      activeTextEditable &&
+      !activeTextInputFocused &&
+      !event.ctrlKey &&
+      !event.metaKey &&
+      !event.altKey &&
+      (
+        event.key.length === 1 ||
+        (activeTextMultiline && event.key === 'Enter') ||
+        event.key === 'Backspace' ||
+        event.key === 'Delete'
+      );
+    if (activeEditableTextOwnsNativeEditingKey) {
+      if (
+        type === UI_KEY_EVENT_DOWN &&
+        (event.key === 'Backspace' || event.key === 'Delete') &&
+        interactionState.applyActiveTextDeletion(event.key === 'Delete')
+      ) {
+        event.preventDefault();
+      }
+      return;
+    }
+    const activeTextOwnsRuntimeNavigationKey =
+      activeTextHandle !== null &&
+      isTextNavigationKey(event.key);
+    const activeReadonlyTextOwnsRuntimeKey =
+      activeTextHandle !== null &&
+      !activeTextEditable &&
+      (
+        event.key.length === 1 ||
+        event.key === 'Backspace' ||
+        event.key === 'Delete' ||
+        isTextNavigationKey(event.key)
+      );
+    if (
+      activeEditableTextNeedsRuntimeEditingFallback ||
+      activeTextOwnsRuntimeNavigationKey ||
+      activeReadonlyTextOwnsRuntimeKey
+    ) {
+      event.preventDefault();
+    }
+    ui._ui_set_interaction_time(currentInteractionTimeMs());
+    const shouldAlwaysPreventDefault =
+      event.key === 'Tab' ||
+      ((event.ctrlKey || event.metaKey) &&
+        (
+          event.key === 'c' || event.key === 'C' ||
+          event.key === 'a' || event.key === 'A' ||
+          event.key === 'x' || event.key === 'X' ||
+          event.key === 'v' || event.key === 'V' ||
+          event.key === 'z' || event.key === 'Z' ||
+          event.key === 'y' || event.key === 'Y'
+        ));
+    if (shouldAlwaysPreventDefault) {
+      event.preventDefault();
+    }
+    const heapString = writeUtf8ToHeap(ui, event.key);
+    let callbackHandled = false;
+    try {
+      ui._ui_on_key_event(type, heapString.ptr, heapString.len, modifiers);
+      if (
+        !activeEditableTextNeedsRuntimeEditingFallback &&
+        !activeTextOwnsRuntimeNavigationKey &&
+        !activeReadonlyTextOwnsRuntimeKey
+      ) {
+        callbackHandled = window.__effindomCallbacks?.onKeyEventWithKey?.(type, event.key, modifiers) === true;
+      }
+    } finally {
+      heapString.dispose();
+    }
+    if (
+      type === UI_KEY_EVENT_DOWN &&
+      (
+        callbackHandled ||
+        (!event.ctrlKey && !event.altKey && !event.metaKey && isVerticalCanvasNavigationKey(event.key))
+      )
+    ) {
+      event.preventDefault();
+    }
+    runtime.commitFrame();
+    if (interactionState.getActiveTextHandle() !== null && !interactionState.isActiveTextInputFocused()) {
+      interactionState.refocusActiveTextInput();
+    }
+  };
+
+  const handleKeyDown = forwardKeyEvent(UI_KEY_EVENT_DOWN);
+  const handleKeyUp = forwardKeyEvent(UI_KEY_EVENT_UP);
+  const keyListenerCapture = true;
+  const reconcileFindSelection = (): void => {
+    requestAnimationFrame(() => {
+      runtime.syncFindSelection(true);
+    });
+  };
+  const handleWindowBlur = (): void => {
+    if (interactionState.getActiveTextHandle() === null) {
+      reconcileFindSelection();
+      return;
+    }
+    ui._ui_request_focus(0n);
+    runtime.commitFrame();
+    reconcileFindSelection();
+  };
+  const handleWindowFocus = (): void => {
+    reconcileFindSelection();
+  };
+  const handleResize = (): void => {
+    runtime.updateCanvasSize();
+    runtime.commitFrame();
+  };
+
+  window.addEventListener('keydown', handleKeyDown, keyListenerCapture);
+  window.addEventListener('keyup', handleKeyUp, keyListenerCapture);
+  window.addEventListener('blur', handleWindowBlur);
+  window.addEventListener('focus', handleWindowFocus);
+  window.addEventListener('resize', handleResize);
+
+  return () => {
+    window.removeEventListener('keydown', handleKeyDown, keyListenerCapture);
+    window.removeEventListener('keyup', handleKeyUp, keyListenerCapture);
+    window.removeEventListener('blur', handleWindowBlur);
+    window.removeEventListener('focus', handleWindowFocus);
+    window.removeEventListener('resize', handleResize);
+  };
+}