@geastack/core 0.1.41 → 0.1.43

package/include/platform/esp_now.h

@@ -0,0 +1,113 @@
+#pragma once
+#include <array>
+#include <cstddef>
+#include <cstdint>
+
+namespace gea::platform::espnow {
+struct Datagram {
+  std::array<std::uint8_t, 6> source{};
+  std::array<std::uint8_t, 1470> bytes{};
+  std::size_t size = 0;
+  std::int64_t receivedUs = 0;
+  int rssi = 0;
+  // Raw 32-bit receive clock in microseconds, not the esp_timer epoch. The
+  // SDK qualifies its precision only without modem/light sleep. Zero is a
+  // valid timestamp; absence of RX metadata is represented separately.
+  std::uint32_t radioTimestampUs = 0;
+  bool radioTimestampValid = false;
+};
+struct Statistics {
+  std::uint32_t sent = 0, failed = 0, received = 0, dropped = 0;
+  std::uint32_t maximumSendUs = 0;
+  // Last completed datagram, published before canSend() becomes true. The
+  // single sending task may read these after canSend() for its prior send.
+  std::uint64_t lastSendStartedUs = 0, lastSendCompletedUs = 0;
+  std::uint32_t lastSendRate = 0, lastSendStatus = 0;
+  // Optional diagnostic copy of the SDK callback's 24-byte Action MAC header.
+  // Validity is separate: zero fields are valid values, and Retry=0 does not
+  // prove that the hardware made only one transmission attempt.
+  std::uint16_t lastSendFrameControl = 0, lastSendDuration = 0,
+                lastSendSequenceControl = 0;
+  bool lastSendMacValid = false;
+};
+} // namespace gea::platform::espnow
+extern "C" {
+bool gea_espnow_open(int channel, int rate) __attribute__((weak));
+void gea_espnow_close() __attribute__((weak));
+bool gea_espnow_is_open() __attribute__((weak));
+bool gea_espnow_can_send() __attribute__((weak));
+bool gea_espnow_capture_tx_header(bool enabled) __attribute__((weak));
+bool gea_espnow_set_max_tx_power(int quarterDbm) __attribute__((weak));
+int gea_espnow_get_max_tx_power() __attribute__((weak));
+bool gea_espnow_peer(const std::uint8_t *mac, const std::uint8_t *key)
+    __attribute__((weak));
+int gea_espnow_send(const std::uint8_t *mac, const void *data, std::size_t size)
+    __attribute__((weak));
+bool gea_espnow_receive(gea::platform::espnow::Datagram *)
+    __attribute__((weak));
+void gea_espnow_wake() __attribute__((weak));
+void gea_espnow_wait(unsigned ms) __attribute__((weak));
+void gea_espnow_statistics(gea::platform::espnow::Statistics *)
+    __attribute__((weak));
+}
+namespace gea::platform::espnow {
+class EspNow {
+public:
+  // Channel zero borrows the running Wi-Fi radio without changing its channel.
+  // Otherwise claims an idle radio. Rate is 24/36/54 Mbps (OFDM), 65 (HT20
+  // MCS7), or 115 on ESP32-S31 (HE20 MCS9 short GI, nominal 114.7 Mbps).
+  // Unsupported rates/protocols fail; a borrowed radio is never reconfigured.
+  static bool open(int channel, int rate = 54) {
+    return gea_espnow_open && gea_espnow_open(channel, rate);
+  }
+  static bool isOpen() { return gea_espnow_is_open && gea_espnow_is_open(); }
+  static bool canSend() { return gea_espnow_can_send && gea_espnow_can_send(); }
+  // Native diagnostics only; default off and reset on radio close/open.
+  // Enable only on an owned radio. Copies metadata, never changes the frame.
+  static bool captureTxHeader(bool enabled) {
+    return gea_espnow_capture_tx_header &&
+           gea_espnow_capture_tx_header(enabled);
+  }
+  // Quarter-dBm cap, 8..84. Only an owned radio may be changed; the SDK
+  // quantizes the request. Read back the actual cap, or -1 if unavailable.
+  static bool setMaxTxPower(int quarterDbm) {
+    return gea_espnow_set_max_tx_power &&
+           gea_espnow_set_max_tx_power(quarterDbm);
+  }
+  static int getMaxTxPower() {
+    return gea_espnow_get_max_tx_power ? gea_espnow_get_max_tx_power() : -1;
+  }
+  static void close() {
+    if (gea_espnow_close)
+      gea_espnow_close();
+  }
+  static bool addPeer(const std::uint8_t *mac,
+                      const std::uint8_t *key = nullptr) {
+    return gea_espnow_peer && gea_espnow_peer(mac, key);
+  }
+  // Copies one datagram; length on admission, zero when busy, -1 on error.
+  // MAC completion is NOT an application acknowledgement.
+  static int send(const std::uint8_t *mac, const void *bytes,
+                  std::size_t size) {
+    return gea_espnow_send ? gea_espnow_send(mac, bytes, size) : -1;
+  }
+  static bool receive(Datagram &packet) {
+    return gea_espnow_receive && gea_espnow_receive(&packet);
+  }
+  // One native consumer. Wakes for RX or TX completion; never call from the UI.
+  static void wake() {
+    if (gea_espnow_wake)
+      gea_espnow_wake();
+  }
+  static void wait(unsigned ms) {
+    if (gea_espnow_wait)
+      gea_espnow_wait(ms);
+  }
+  static Statistics statistics() {
+    Statistics s{};
+    if (gea_espnow_statistics)
+      gea_espnow_statistics(&s);
+    return s;
+  }
+};
+} // namespace gea::platform::espnow

package/include/platform/magnetometer.h

@@ -0,0 +1,60 @@
+// SPDX-License-Identifier: Apache-2.0
+#pragma once
+
+#include <cstddef>
+#include <cstdint>
+
+namespace gea::platform::sensors {
+struct MagnetometerReading {
+  // Compensated whole microtesla. BMM150 overflow sentinels are preserved;
+  // saturatedAxes identifies axes that must not be used as field strength.
+  std::int16_t x = 0, y = 0, z = 0;
+  bool valid = false;
+  std::uint8_t saturatedAxes = 0; // X=1, Y=2, Z=4.
+  std::uint64_t timestampUs = 0;
+};
+} // namespace gea::platform::sensors
+
+extern "C" {
+bool gea_magnetometer_open() __attribute__((weak));
+void gea_magnetometer_close() __attribute__((weak));
+unsigned gea_magnetometer_count() __attribute__((weak));
+bool gea_magnetometer_read(unsigned,
+                           gea::platform::sensors::MagnetometerReading *)
+    __attribute__((weak));
+bool gea_magnetometer_read_all(gea::platform::sensors::MagnetometerReading *,
+                               std::size_t) __attribute__((weak));
+}
+
+namespace gea::platform::sensors {
+class Magnetometer {
+public:
+  // Idempotent. No bus or pins are claimed until open is called.
+  static bool open() {
+    return gea_magnetometer_open && gea_magnetometer_open();
+  }
+  static void close() {
+    if (gea_magnetometer_close)
+      gea_magnetometer_close();
+  }
+  static unsigned count() {
+    return gea_magnetometer_count ? gea_magnetometer_count() : 0;
+  }
+  static bool read(unsigned index, MagnetometerReading &sample) {
+    sample = {};
+    return gea_magnetometer_read && gea_magnetometer_read(index, &sample);
+  }
+  // Reads the board's sensors back-to-back under one driver lock, with a
+  // shared completion timestamp. This is not hardware-triggered sampling.
+  // False if capacity is insufficient or any sensor failed; inspect valid
+  // on individual readings. The output is cleared even when unsupported.
+  static bool readAll(MagnetometerReading *samples, std::size_t capacity) {
+    if (!samples)
+      return false;
+    for (std::size_t i = 0; i < capacity; ++i)
+      samples[i] = {};
+    return gea_magnetometer_read_all &&
+           gea_magnetometer_read_all(samples, capacity);
+  }
+};
+} // namespace gea::platform::sensors

package/include/platform/uart.h

@@ -0,0 +1,58 @@
+#pragma once
+
+#include <cstddef>
+#include <cstdint>
+
+// Target-owned implementation. Unsupported platforms report unavailable.
+extern "C" {
+bool gea_uart_open(int port, int tx, int rx, int baud, int rxBytes, int txBytes)
+    __attribute__((weak));
+bool gea_uart_is_open(int port) __attribute__((weak));
+void gea_uart_close(int port) __attribute__((weak));
+int gea_uart_read(int port, void *bytes, std::size_t capacity)
+    __attribute__((weak));
+int gea_uart_write(int port, const void *bytes, std::size_t length)
+    __attribute__((weak));
+int gea_uart_available(int port) __attribute__((weak));
+int gea_uart_writable(int port) __attribute__((weak));
+}
+
+namespace gea::platform::uart {
+struct Config {
+  int tx;
+  int rx;
+  int baudRate;
+  int rxBufferSize = 4096;
+  int txBufferSize = 4096;
+};
+
+class Uart {
+public:
+  static bool open(int port, const Config &config) {
+    return gea_uart_open &&
+           gea_uart_open(port, config.tx, config.rx, config.baudRate,
+                         config.rxBufferSize, config.txBufferSize);
+  }
+  static bool isOpen(int port) {
+    return gea_uart_is_open && gea_uart_is_open(port);
+  }
+  static void close(int port) {
+    if (gea_uart_close)
+      gea_uart_close(port);
+  }
+  // Nonblocking. -1 means unavailable/closed/error; 0 means no progress.
+  static int read(int port, void *bytes, std::size_t capacity) {
+    return gea_uart_read ? gea_uart_read(port, bytes, capacity) : -1;
+  }
+  // Enqueues the complete buffer, or returns 0 if it cannot fit yet.
+  static int write(int port, const void *bytes, std::size_t length) {
+    return gea_uart_write ? gea_uart_write(port, bytes, length) : -1;
+  }
+  static int available(int port) {
+    return gea_uart_available ? gea_uart_available(port) : -1;
+  }
+  static int writable(int port) {
+    return gea_uart_writable ? gea_uart_writable(port) : -1;
+  }
+};
+} // namespace gea::platform::uart

package/include/runtime.h

@@ -67,6 +67,20 @@ public:
 	// calls it, so a target that does not care never sees a difference.
 	static bool boot(const RuntimeOptions &options);
 
+	// Pause UI event/frame callbacks at a safe event-loop boundary. A request
+	// made before boot is retained; uiPaused() becomes true only after boot and
+	// the current callback/frame (including its locks) have returned. Calls do
+	// not wait and may be made from another task. uiPaused() acknowledges the
+	// current request, so callers that need quiescence must wait for it.
+	//
+	// Paused input is discarded and gestures are reset. Resuming requests a fresh
+	// frame. Platform tickers, device control, native services and previously
+	// submitted display DMA keep running; this does not suspend any task. A
+	// headless build has no UI loop, so a pause is acknowledged immediately.
+	static void requestUiPause(bool paused);
+	static bool uiPauseRequested();
+	static bool uiPaused();
+
 	// Hands the runtime a block of internal RAM to hold for the display and free
 	// immediately before Display::init(). For an app whose native boot hook has
 	// a phase that must not see less RAM than it actually has, followed by one

package/index.d.ts

@@ -103,9 +103,20 @@ export interface GeaIntrinsicElements {
   'virtual-list': NativeVirtualListProps
 }
 
+export interface WindowEventListenerOptions {
+  capture?: boolean
+  once?: boolean
+}
+export interface GeaWindowEventMap extends GeaEventMap {
+  blur: Event
+  resize: Event
+}
+/** Native app-window event authority. No global input posting or browser Window privileges. */
 export interface GeaWindow {
   readonly innerWidth: number
   readonly innerHeight: number
+  addEventListener<K extends keyof GeaWindowEventMap>(type: K, listener: (event: GeaWindowEventMap[K]) => void, options?: boolean | WindowEventListenerOptions): void
+  removeEventListener<K extends keyof GeaWindowEventMap>(type: K, listener: (event: GeaWindowEventMap[K]) => void, options?: boolean | WindowEventListenerOptions): void
 }
 
 declare global {
@@ -140,6 +151,10 @@ declare global {
   /** @gea-host-no-property-writes */
   function requestAnimationFrame(callback: (timestampMs: int) => void): number
 
+  // Shares the native Promise-job FIFO; app replacement retires pending jobs.
+  /** @gea-host-no-property-writes */
+  function queueMicrotask(callback: () => void): void
+
   // Native one-shot / repeating timers (gea::host::setTimeout/setInterval,
   // engine/../host/include/host/timers.h), NOT Node's `NodeJS.Timeout` (there is
   // no `dom` or `node` lib here, so without this declaration a `setTimeout`
@@ -339,6 +354,7 @@ export interface DataAttributes {
 }
 
 export interface Event {
+  readonly defaultPrevented: boolean
   readonly type: string
   readonly target: EventTarget
   readonly currentTarget: EventTarget
@@ -354,12 +370,30 @@ export interface EventTarget {
   addEventListener(type: string, listener: (event: Event) => void): void
 }
 
+/** Live child collection; iterable and bracket protocols are not published yet. */
+export interface NodeList {
+  readonly length: number
+  item(index: number): Node | null
+}
+
 export interface Node extends EventTarget {
-  readonly nodeType?: number
+  /** True only for a live allocation in the current mounted document subtree. */
+  readonly isConnected: boolean
+  readonly nodeType: number
+  readonly parentNode: Node | null
+  /** The current first child, including text/comments; null when empty. */
+  readonly firstChild: Node | null
+  readonly childNodes: NodeList
   appendChild(child: Node): void
+  /** Move a live node before a direct child; null appends. Return the inserted node. */
+  insertBefore(child: Node, reference: Node | null): Node
+  /** Detach a direct live child and return that same allocation, without retiring it. */
+  removeChild(child: Node): Node
   remove(): void
 }
 
+export interface FocusOptions { preventScroll?: boolean }
+
 export interface ScrollIntoViewOptions {
   behavior?: 'auto' | 'instant' | 'smooth'
   block?: 'start' | 'center' | 'end' | 'nearest'
@@ -374,6 +408,12 @@ export interface DOMTokenList {
 }
 
 export interface Element extends Node {
+  readonly lastElementChild: Element | null
+  /** Bounded native selector grammar; malformed/unsupported selectors refuse. */
+  matches(selector: string): boolean
+  closest<E extends Element = Element>(selector: string): E | null
+  querySelector(selector: string): Element | null
+  querySelectorAll(selector: string): readonly Element[]
   className?: string
   readonly children: readonly Element[]
   scrollLeft?: number
@@ -395,10 +435,24 @@ export interface Element extends Node {
   // `blur()` clears it again (and does nothing when this element was not the
   // one focused). Backed by `NodeHandle::focus()`/`blur()` over
   // `Tree::setActiveInput` (engine/ui/node.cpp).
-  focus(): void
+  focus(options?: FocusOptions): void
   blur(): void
 }
 
+/** Minimal native text input backed by a live NodeHandle allocation.
+ * Value uses the native value attribute; HTML dirty-value/defaultValue semantics
+ * and checked/type/selection APIs are not declared by this carrier. */
+export interface InputElement extends Element {
+  disabled: boolean
+  value: string
+}
+
+/** Native button attributes backed by the live node allocation. */
+export interface ButtonElement extends Element {
+  disabled: boolean
+  value: string
+}
+
 export interface VirtualListElement extends Element {
   scrollTop: number
   /**
@@ -412,15 +466,22 @@ export interface VirtualListElement extends Element {
 }
 
 export interface Document {
+  addEventListener<K extends keyof GeaEventMap>(type: K, listener: (event: GeaEventMap[K]) => void, options?: boolean | WindowEventListenerOptions): void
+  removeEventListener<K extends keyof GeaEventMap>(type: K, listener: (event: GeaEventMap[K]) => void, options?: boolean | WindowEventListenerOptions): void
   readonly body: Element
+  /** Actual connected native focus, null when no owned responder is focused. */
+  readonly activeElement: Element | null
   getElementById(id: string): Element | null
   querySelector(selector: string): Element | null
   querySelectorAll(selector: string): readonly Element[]
+  createElement(tag: 'input'): InputElement
+  createElement(tag: 'button'): ButtonElement
   createElement(tag: 'audio'): HTMLAudioElement
   createElement(tag: 'video'): HTMLVideoElement
   createElement(tag: 'virtual-list'): VirtualListElement
   createElement(tag: string): Element
   createTextNode(text: string): Node
+  createComment(text: string): Node
   createDocumentFragment(): Node
 }
 
@@ -435,6 +496,10 @@ export interface PointerEvent extends Event {
   // finger is 2, etc. (web convention, mirrored by the device touch runtime).
   // Multi-touch handlers route gestures by this id.
   readonly pointerId: number
+  /** Changed button: primary 0, auxiliary 1, secondary 2; -1 for no known edge. */
+  readonly button: number
+  /** Held-button bitmask for the producing pointer gesture; zero when released/unknown. */
+  readonly buttons: number
   readonly x: number
   readonly y: number
   readonly clientX: number
@@ -502,7 +567,7 @@ export interface RotaryEvent extends Event {
  * `KeyEvent`; `input` carries an `InputEvent`. Both are dispatched off-tree by
  * the runtime (`dispatch_key_input`, and `virtual_keyboard.cpp`'s synthetic
  * pair). Hardware button releases dispatch `keyup` with the same KeyEvent.
- * `pointercancel` remains unsupported by the native event dispatcher.
+ * Native cancellation names its event `pointercancel`; `touchcancel` is a listener alias.
  */
 export interface GeaEventMap {
   click: PressEvent
@@ -512,7 +577,12 @@ export interface GeaEventMap {
   pointerdown: PointerEvent
   pointermove: PointerEvent
   pointerup: PointerEvent
+  pointercancel: PointerEvent
+  touchcancel: PointerEvent
   input: InputEvent
+  focusin: Event
+  focusout: Event
+  change: InputEvent
   keydown: KeyEvent
   keyup: KeyEvent
   rotary: RotaryEvent
@@ -524,6 +594,15 @@ export type PointerEventHandler = (event: PointerEvent) => void
 export type RotaryEventHandler = (event: RotaryEvent) => void
 
 export interface NativeTouchEventAttributes {
+  /** Bare JSX spellings use the same native listener publication as onX. */
+  touchstart?: TouchEventHandler
+  touchend?: TouchEventHandler
+  touchmove?: TouchEventHandler
+  touchcancel?: PointerEventHandler
+  pointerdown?: PointerEventHandler
+  pointermove?: PointerEventHandler
+  pointerup?: PointerEventHandler
+  pointercancel?: PointerEventHandler
   onTouchStart?: TouchEventHandler
   onTouchEnd?: TouchEventHandler
   onTouchMove?: TouchEventHandler
@@ -538,9 +617,18 @@ export interface NativeTouchEventAttributes {
   onPointerDown?: PointerEventHandler
   onPointerMove?: PointerEventHandler
   onPointerUp?: PointerEventHandler
+  onPointerCancel?: PointerEventHandler
 }
 
 export interface NativeEventAttributes extends NativeTouchEventAttributes {
+  click?: PressHandler
+  input?: (event: InputEvent) => void
+  /** Committed user value change; distinct from intermediate input. */
+  change?: (event: InputEvent) => void
+  onChange?: (event: InputEvent) => void
+  keydown?: (event: KeyEvent) => void
+  keyup?: (event: KeyEvent) => void
+  scroll?: (event: Event) => void
   /** Text services and app-owned editors may dispatch input on ordinary views. */
   onInput?: (event: InputEvent) => void
   onClick?: PressHandler
@@ -551,6 +639,7 @@ export interface NativeEventAttributes extends NativeTouchEventAttributes {
 }
 
 export interface InputEventTarget extends Element {
+  disabled: boolean
   value: string
 }
 
@@ -559,9 +648,19 @@ export interface InputEvent {
   currentTarget: InputEventTarget
 }
 
-export interface KeyEvent {
-  keyCode: number
-  which: number
+export interface KeyEvent extends Event {
+  readonly target: Element
+  readonly currentTarget: Element
+  readonly keyCode: number
+  readonly which: number
+  readonly key: string
+  readonly code: string
+  readonly altKey: boolean
+  readonly ctrlKey: boolean
+  readonly metaKey: boolean
+  readonly shiftKey: boolean
+  readonly repeat: boolean
+  readonly isComposing: boolean
 }
 
 export interface ViewProps extends DataAttributes {
@@ -1322,6 +1421,59 @@ export interface GpioController {
 
 export declare const Gpio: GpioController
 
+export interface UartOptions {
+  tx: number
+  rx: number
+  baudRate: number
+  /** Receive/transmit queue bytes. Defaults to 4096 each. */
+  rxBufferSize?: number
+  txBufferSize?: number
+}
+
+/** Hardware UART, 8 data bits, no parity, one stop bit (8N1). */
+export interface UartController {
+  /** Claims a free controller and pins. False on conflict/invalid configuration. */
+  open(port: number, options: UartOptions): boolean
+  isOpen(port: number): boolean
+  close(port: number): void
+  /** Nonblocking read into the supplied view; returns bytes read, or -1 on error. */
+  read(port: number, buffer: Uint8Array): number
+  /** Nonblocking whole-buffer enqueue; 0 means backpressure, -1 means error. */
+  write(port: number, buffer: Uint8Array): number
+  /** Queued readable bytes, or -1 when unavailable. */
+  available(port: number): number
+  /** Writable queue capacity, or -1 when unavailable. */
+  writable(port: number): number
+}
+
+export declare const Uart: UartController
+
+/** ESP-NOW v2 datagrams; addresses are six-byte MACs. Unsupported targets return false/-1. */
+export interface EspNowController {
+  /** Integer quarter-dBm cap, 8..84; fails on closed/borrowed radios. The SDK quantizes it. */
+  setMaxTxPower(quarterDbm: number): boolean
+  /** Actual cap in quarter-dBm, or -1 when unavailable. */
+  getMaxTxPower(): number
+  /**
+   * Channel 0 borrows running Wi-Fi. Other channels claim an idle radio.
+   * Default 54; rates 24/36/54 use OFDM, 65 uses HT20 MCS7.
+   * ESP32-S31 also accepts 115 for HE20 MCS9 short GI (nominal 114.7 Mbps).
+   * Unsupported rates/protocols return false without changing a borrowed radio.
+   */
+  open(channel: number, rateMbps?: number): boolean
+  isOpen(): boolean
+  /** True when the previous radio send has completed. */
+  canSend(): boolean
+  close(): void
+  /** Optional key is a 16-byte LMK; omit only for unencrypted traffic. */
+  addPeer(address: Uint8Array, key?: Uint8Array): boolean
+  /** Whole datagram admission: bytes, 0 when busy, -1 for invalid/unavailable. */
+  send(address: Uint8Array, bytes: Uint8Array): number
+  /** source must be 6 bytes, buffer at least 1470. Returns received length, 0, or -1. */
+  receive(source: Uint8Array, buffer: Uint8Array): number
+}
+export declare const EspNow: EspNowController
+
 export interface LedController {
   // A WS2812/NeoPixel strand on one pin — what "the onboard LED" is on most
   // modern ESP32 modules.
@@ -1523,6 +1675,29 @@ export interface AccelerometerController {
 
 export declare const Accelerometer: AccelerometerController
 
+export interface MagnetometerReading {
+  /** Compensated whole microtesla; saturated axes retain their sensor sentinel. */
+  x: number
+  y: number
+  z: number
+  /** False for an unavailable sensor or failed I2C read. */
+  valid: boolean
+  /** Saturated-axis bits: X=1, Y=2, Z=4. Those values are not field strength. */
+  saturatedAxes: number
+  timestampUs: number
+}
+
+export interface MagnetometerController {
+  /** Initializes the board's sensors. Idempotent; false when unavailable. */
+  open(): boolean
+  close(): void
+  /** Number of board-defined sensors, whether open or closed. */
+  count(): number
+  /** Mosaico indexes: 0=right (0x11), 1=left (0x12). */
+  read(index: number): MagnetometerReading
+}
+export declare const Magnetometer: MagnetometerController
+
 export type CameraFacing = 'front' | 'back' | 'external'
 export type CameraFlashMode = 'off' | 'on' | 'auto' | 'torch'
 
@@ -1787,7 +1962,7 @@ export interface InputElementProps {
   keyup?: (keyCode: number) => void
 }
 
-export interface NativeInputElementProps extends InputElementProps, DataAttributes {
+export interface NativeInputElementProps extends Omit<InputElementProps, 'input' | 'keydown' | 'keyup'>, NativeEventAttributes, DataAttributes {
   id?: string
   ref?: GeaElement | null
 }
@@ -1802,7 +1977,7 @@ export interface TextAreaElementProps {
   onBlur?: () => void
 }
 
-export interface NativeTextAreaElementProps extends TextAreaElementProps, DataAttributes {
+export interface NativeTextAreaElementProps extends TextAreaElementProps, NativeEventAttributes, DataAttributes {
   id?: string
   disabled?: boolean
   readOnly?: boolean

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@geastack/core",
-  "version": "0.1.41",
+  "version": "0.1.43",
   "description": "GeaStack app API, reactivity headers, runtime sources, and type declarations.",
   "license": "Apache-2.0",
   "repository": {
@@ -66,8 +66,11 @@
     "@geajs/core": "1.5.1",
     "@geajs/vite-plugin": "1.5.0",
     "@geastack/compiler": "^1.0.29",
-    "@geastack/geatsc-plugin-gea": "^0.1.22",
+    "@geastack/geatsc-plugin-gea": "0.1.24",
     "opentype.js": "^2.0.0",
     "vite": "^8.0.0"
+  },
+  "devDependencies": {
+    "jsdom": "^26.1.0"
   }
 }