@geastack/core 0.1.39 → 0.1.41

package/runtime/host.ts

@@ -30,7 +30,11 @@ import type {
   EmbeddedMemoryConfig,
   EmbeddedMemoryStats,
   HttpReply,
-  AudioContext
+  IncomingMessage,
+  HttpModule,
+  HttpServer,
+  AudioContext,
+  WiFiController,
 } from '../index'
 
 // These 17 used to be declared HERE as well as in `../index`, byte for byte.
@@ -56,7 +60,7 @@ export type {
   CameraWhiteBalanceOptions,
   EmbeddedMemoryConfig,
   EmbeddedMemoryStats,
-  HttpReply
+  HttpReply,
 } from '../index'
 
 declare const apps: {
@@ -86,32 +90,16 @@ declare const navigator: {
     getCurrentPosition(
       success: (position: GeolocationPosition) => void,
       error?: (error: GeolocationPositionError) => void,
-      options?: PositionOptions
+      options?: PositionOptions,
     ): void
     watchPosition(
       success: (position: GeolocationPosition) => void,
       error?: (error: GeolocationPositionError) => void,
-      options?: PositionOptions
+      options?: PositionOptions,
     ): number
     clearWatch(id: number): void
   }
-  wifi: {
-    enabled(): boolean
-    setEnabled(enabled: boolean): void
-    connected(): boolean
-    rssi(): number
-    ssid(): string
-    ip(): string
-    mac(): string
-    configure(ssid: string, password: string): void
-    waitForConnection(timeoutMs: number): boolean
-    startScan(): void
-    scanning(): boolean
-    scanCount(): number
-    scanSsidAt(index: number): string
-    scanRssiAt(index: number): number
-    scanSecuredAt(index: number): boolean
-  }
+  wifi: WiFiController
   bluetooth: {
     keyboard: {
       tap(hidCode: number): void
@@ -209,6 +197,7 @@ declare const __gea_Camera: {
   draw(x: number, y: number, destWidth: number, destHeight: number): void
   capture(): number
   captureMirrored(): number
+  captureFrame(): string
   startRecording(path: string, fps: number): boolean
   stopRecording(): number
   isRecording(): boolean
@@ -239,9 +228,11 @@ declare const __gea_Audio: {
   setVolume(volume: number): void
 }
 
-type EmbeddedDisplayOrientation = 'portrait-primary' | 'portrait-secondary' | 'landscape-primary' | 'landscape-secondary'
+type EmbeddedDisplayOrientation =
+  'portrait-primary' | 'portrait-secondary' | 'landscape-primary' | 'landscape-secondary'
 
-type EmbeddedDisplayOrientationSupport = EmbeddedDisplayOrientation | 'portrait' | 'landscape' | 'all'
+type EmbeddedDisplayOrientationSupport =
+  EmbeddedDisplayOrientation | 'portrait' | 'landscape' | 'all'
 
 type EmbeddedDisplayPixelFormat = 'rgb565' | 'rgb888' | 'rgb8888' | 'argb8888'
 
@@ -262,7 +253,9 @@ declare const __gea_Display: {
   getOrientation(): EmbeddedDisplayOrientation
   setOrientation(orientation: EmbeddedDisplayOrientation): void
   getSupportedOrientations(): EmbeddedDisplayOrientationSupport[]
-  setSupportedOrientations(orientations: EmbeddedDisplayOrientationSupport | EmbeddedDisplayOrientationSupport[]): void
+  setSupportedOrientations(
+    orientations: EmbeddedDisplayOrientationSupport | EmbeddedDisplayOrientationSupport[],
+  ): void
   getAutoRotate(): boolean
   setAutoRotate(enabled: boolean): void
   setVSync(on: boolean): void
@@ -375,6 +368,7 @@ declare const __gea_Led: {
   detach(): void
 }
 declare const __gea_Clock: {
+  setEpochMs(timestamp: number): boolean
   // Milliseconds since the Unix epoch from the platform real-time clock
   // (gettimeofday). Reflects a host-set time (GEADEV SETTIME); unlike
   // Date.now() — monotonic on this ESP32 build — it tracks real wall-clock
@@ -384,8 +378,14 @@ declare const __gea_Clock: {
 declare const __gea_Profiler: {
   // Monotonic microseconds from the platform high-resolution timer.
   nowUs(): number
+  // Hardware cycle count on ESP32; nanoseconds on desktop hosts.
+  nowCycles(): number
+}
+declare const __gea_Haptics: {
+  vibrate(durationMs: number, strength: number): boolean
 }
 declare const __gea_Battery: {
+  charging(): boolean
   // Battery charge percentage (0-100) from the platform PMU.
   level(): number
 }
@@ -420,13 +420,13 @@ export const defaults = {}
 export const touch = {
   read(): TouchSample {
     return { touching: false, x: 0, y: 0 }
-  }
+  },
 }
 
 export const Apps = {
   launch(appId: string): number {
     return apps.launch(appId)
-  }
+  },
 }
 
 // Case-variant aliases for host accessors. Keep these lazy: direct top-level
@@ -442,7 +442,7 @@ export const BLE: typeof navigator.bluetooth = {
     },
     up(): void {
       navigator.bluetooth.keyboard.up()
-    }
+    },
   },
   mouse: {
     move(dx: number, dy: number, buttons?: number, wheel?: number): void {
@@ -450,7 +450,7 @@ export const BLE: typeof navigator.bluetooth = {
     },
     click(button: number): void {
       navigator.bluetooth.mouse.click(button)
-    }
+    },
   },
   // BLE-MIDI (MIDI over GATT). `enable()` registers the MIDI service +
   // advertises its UUID; `send()` transmits ONE already-framed BLE-MIDI
@@ -487,7 +487,7 @@ export const BLE: typeof navigator.bluetooth = {
     },
     disconnect(): void {
       navigator.bluetooth.midi.disconnect()
-    }
+    },
   },
   // HID host role: this device is the central; a remote HID peripheral (a
   // keyboard/macro pad like the XPPen ACK05) is the input source. Raw input
@@ -531,7 +531,7 @@ export const BLE: typeof navigator.bluetooth = {
     },
     clearReports(): void {
       navigator.bluetooth.hidHost.clearReports()
-    }
+    },
   },
   // Live connection registry across every concurrent BLE role. kind: 0 =
   // HID central peer (desktop), 1 = MIDI central peer (DAW), 2 = HID
@@ -546,7 +546,7 @@ export const BLE: typeof navigator.bluetooth = {
     },
     nameAt(index: number): string {
       return navigator.bluetooth.connections.nameAt(index)
-    }
+    },
   },
   // Config service (custom GATT). A Web Bluetooth portal live-programs the
   // device: it reads the app's current config blob and, once paired with the
@@ -581,7 +581,7 @@ export const BLE: typeof navigator.bluetooth = {
     // highlight it live. No-op on the device when no portal is subscribed.
     pushActivity(index: number): void {
       navigator.bluetooth.config.pushActivity(index)
-    }
+    },
   },
   enabled(): boolean {
     return navigator.bluetooth.enabled()
@@ -612,10 +612,29 @@ export const BLE: typeof navigator.bluetooth = {
   },
   stopAdvertising(): void {
     navigator.bluetooth.stopAdvertising()
-  }
+  },
 }
 export const bluetooth = BLE
 export const WiFi: typeof navigator.wifi = {
+  accessPointMac(): string {
+    return navigator.wifi.accessPointMac()
+  },
+
+  startCaptivePortal(): boolean {
+    return navigator.wifi.startCaptivePortal()
+  },
+
+  stopCaptivePortal(): void {
+    navigator.wifi.stopCaptivePortal()
+  },
+
+  startAccessPoint(ssid: string, password = ''): boolean {
+    return navigator.wifi.startAccessPoint(ssid, password)
+  },
+
+  stopAccessPoint(): void {
+    navigator.wifi.stopAccessPoint()
+  },
   enabled(): boolean {
     return navigator.wifi.enabled()
   },
@@ -660,39 +679,33 @@ export const WiFi: typeof navigator.wifi = {
   },
   scanSecuredAt(index: number): boolean {
     return navigator.wifi.scanSecuredAt(index)
-  }
+  },
 }
 export const wifi = WiFi
 
 // Device-hosted HTTP server. On hardware, geatsc lowers `http.createServer(...)`
 // to the native esp_http_server facade (packages/core/host/http.cpp); this JS
-// stub is the web/simulator fallback — browsers can't open a listening socket,
-// so it accepts the handler and reports a no-op server (listen() returns false).
-export interface HttpIncomingMessage {
-  method: string
-  url: string
-  path: string
-  query: string
-}
+// fallback reports unsupported use because browsers cannot open a listening socket.
+export type HttpIncomingMessage = IncomingMessage
 export interface HttpServerInstance {
   listen(port: number): boolean
   close(): void
   id(): number
 }
+declare const __gea_http: HttpModule
+
 export const http = {
-  createServer(_handler: (req: HttpIncomingMessage) => HttpReply): HttpServerInstance {
-    return {
-      listen(_port: number): boolean {
-        return false
-      },
-      close(): void {},
-      id(): number {
-        return 0
-      }
+  createServer(handler: (req: HttpIncomingMessage) => HttpReply): HttpServer {
+    if (typeof __gea_http !== 'undefined') {
+      return __gea_http.createServer(handler)
     }
+    throw new Error('HTTP servers are unavailable in this browser runtime')
+  },
+  close(handle: number): void {
+    if (typeof __gea_http !== 'undefined') __gea_http.close(handle)
   },
-  close(_handle: number): void {}
 }
+
 export const Geolocation: typeof navigator.geolocation = {
   hasFix(): boolean {
     return navigator.geolocation.hasFix()
@@ -715,20 +728,20 @@ export const Geolocation: typeof navigator.geolocation = {
   getCurrentPosition(
     success: (position: GeolocationPosition) => void,
     error?: (error: GeolocationPositionError) => void,
-    options?: PositionOptions
+    options?: PositionOptions,
   ): void {
     navigator.geolocation.getCurrentPosition(success, error, options)
   },
   watchPosition(
     success: (position: GeolocationPosition) => void,
     error?: (error: GeolocationPositionError) => void,
-    options?: PositionOptions
+    options?: PositionOptions,
   ): number {
     return navigator.geolocation.watchPosition(success, error, options)
   },
   clearWatch(id: number): void {
     navigator.geolocation.clearWatch(id)
-  }
+  },
 }
 export const geolocation = Geolocation
 // `__gea_Accelerometer` is only injected by the vite plugin when an app actually
@@ -739,7 +752,9 @@ export const geolocation = Geolocation
 // whether or not the global was injected, and apps that do use it still get the
 // real binding.
 export const Accelerometer =
-  typeof __gea_Accelerometer !== 'undefined' ? __gea_Accelerometer : (undefined as unknown as typeof __gea_Accelerometer)
+  typeof __gea_Accelerometer !== 'undefined'
+    ? __gea_Accelerometer
+    : (undefined as unknown as typeof __gea_Accelerometer)
 
 // Remembers the most recent recording sink so stopRecording can report it on
 // the resolved CameraClip (the host only returns a duration).
@@ -797,13 +812,16 @@ export const Camera = {
       orientation: __gea_Camera.orientation,
       dispose(): void {
         image.dispose(id)
-      }
+      },
     }
     return Promise.resolve(photo)
   },
   capturePhoto(options?: CameraCaptureOptions): Promise<CameraPhoto> {
     return this.capture(options)
   },
+  captureFrame(): string {
+    return __gea_Camera.captureFrame()
+  },
   startRecording(options: CameraRecordOptions): Promise<void> {
     cameraRecordingPath = options.path
     __gea_Camera.startRecording(options.path, options.fps ?? 0)
@@ -828,13 +846,26 @@ export const Camera = {
     __gea_Camera.setMirror(mirror)
   },
   setExposure(options: CameraExposureOptions): void {
-    __gea_Camera.setExposure(options.mode ?? 'continuous', options.bias ?? 0, options.iso ?? 0, options.durationMs ?? 0)
+    __gea_Camera.setExposure(
+      options.mode ?? 'continuous',
+      options.bias ?? 0,
+      options.iso ?? 0,
+      options.durationMs ?? 0,
+    )
   },
   setWhiteBalance(options: CameraWhiteBalanceOptions): void {
-    __gea_Camera.setWhiteBalance(options.mode ?? 'auto', options.temperature ?? 0, options.tint ?? 0)
+    __gea_Camera.setWhiteBalance(
+      options.mode ?? 'auto',
+      options.temperature ?? 0,
+      options.tint ?? 0,
+    )
   },
   setFocus(options: CameraFocusOptions): void {
-    __gea_Camera.setFocus(options.mode ?? 'continuous', options.point?.x ?? 0, options.point?.y ?? 0)
+    __gea_Camera.setFocus(
+      options.mode ?? 'continuous',
+      options.point?.x ?? 0,
+      options.point?.y ?? 0,
+    )
   },
   setTorch(mode: 'off' | 'on' | 'auto', level?: number): void {
     __gea_Camera.setTorch(mode, level ?? 0)
@@ -849,11 +880,11 @@ export const Camera = {
     for (let i = 0; i < count; i++) {
       out.push({
         id: __gea_Camera.deviceIdAt(i),
-        facing: __gea_Camera.deviceFacingAt(i) as CameraFacing
+        facing: __gea_Camera.deviceFacingAt(i) as CameraFacing,
       })
     }
     return out
-  }
+  },
 }
 
 // Same guard as Accelerometer above: these embedded host globals are not injected
@@ -861,7 +892,9 @@ export const Camera = {
 // reference ReferenceErrors at module load and blanks the page. `typeof` keeps the
 // real binding on embedded targets where the plugin injects them.
 export const audioContext: AudioContext =
-  typeof __gea_audioContext !== 'undefined' ? __gea_audioContext : (undefined as unknown as AudioContext)
+  typeof __gea_audioContext !== 'undefined'
+    ? __gea_audioContext
+    : (undefined as unknown as AudioContext)
 // Method wrapper, NOT the `typeof … ? … : undefined as …` guard the
 // property-bearing host objects above use. Two reasons. (1) The guard exists
 // only to stop a bare top-level reference from ReferenceError-ing at module
@@ -879,9 +912,12 @@ export const Audio = {
   },
   setVolume(volume: number): void {
     __gea_Audio.setVolume(volume)
-  }
+  },
 }
-export const Display = typeof __gea_Display !== 'undefined' ? __gea_Display : (undefined as unknown as typeof __gea_Display)
+export const Display =
+  typeof __gea_Display !== 'undefined'
+    ? __gea_Display
+    : (undefined as unknown as typeof __gea_Display)
 export const Memory = {
   internalFree(): number {
     return __gea_Memory.internalFree()
@@ -958,7 +994,7 @@ export const Memory = {
       allocationSramBytes: __gea_Memory.allocationSramBytes(),
       allocationPsramBytes: __gea_Memory.allocationPsramBytes(),
       allocationSramPeakBytes: __gea_Memory.allocationSramPeakBytes(),
-      allocationPsramPeakBytes: __gea_Memory.allocationPsramPeakBytes()
+      allocationPsramPeakBytes: __gea_Memory.allocationPsramPeakBytes(),
     }
   },
   config(): EmbeddedMemoryConfig {
@@ -972,14 +1008,14 @@ export const Memory = {
       displayFlushBufferMaxBytes: __gea_Memory.displayFlushBufferMaxBytes(),
       displayFlushRows: __gea_Memory.displayFlushRows(),
       displayFlushDepth: __gea_Memory.displayFlushDepth(),
-      displayFlushBufferBytes: __gea_Memory.displayFlushBufferBytes()
+      displayFlushBufferBytes: __gea_Memory.displayFlushBufferBytes(),
     }
-  }
+  },
 }
 export const Input = {
   consumeBackButton(): boolean {
     return __gea_Input.consumeBackButton()
-  }
+  },
 }
 export const Gpio = {
   configureOutput(pin: number): boolean {
@@ -993,7 +1029,7 @@ export const Gpio = {
   },
   read(pin: number): boolean {
     return __gea_Gpio.read(pin)
-  }
+  },
 }
 export const Led = {
   set(pin: number, r: number, g: number, b: number): boolean {
@@ -1013,12 +1049,16 @@ export const Led = {
   },
   detach(): void {
     __gea_Led.detach()
-  }
+  },
 }
 export const Clock = {
+  setEpochMs(timestamp: number): boolean {
+    return __gea_Clock.setEpochMs(timestamp)
+  },
+
   epochMs(): number {
     return __gea_Clock.epochMs()
-  }
+  },
 }
 // Same method-wrapper reasoning as `Audio` above: the host global is only
 // touched when the method runs, and the conditional form has no plannable
@@ -1028,12 +1068,27 @@ export const Profiler = {
   nowUs(): number {
     if (typeof __gea_Profiler === 'undefined') return Date.now() * 1000
     return __gea_Profiler.nowUs()
-  }
+  },
+
+  nowCycles(): number {
+    // Desktop native hosts also expose nanoseconds instead of CPU cycles.
+    if (typeof __gea_Profiler === 'undefined') return Date.now() * 1000000
+    return __gea_Profiler.nowCycles()
+  },
+}
+export const Haptics = {
+  vibrate(durationMs: number, strength = 100): boolean {
+    return __gea_Haptics.vibrate(durationMs, strength)
+  },
 }
 export const Battery = {
+  charging(): boolean {
+    return __gea_Battery.charging()
+  },
+
   level(): number {
     return __gea_Battery.level()
-  }
+  },
 }
 export const Notify = {
   text(): string {
@@ -1041,12 +1096,12 @@ export const Notify = {
   },
   seq(): number {
     return __gea_Notify.seq()
-  }
+  },
 }
 export const DeviceControl = {
   exec(command: string): string {
     return __gea_DeviceControl.exec(command)
-  }
+  },
 }
 // Method wrapper for the same two reasons as `Audio`/`Profiler` above: a
 // reference inside a method body cannot ReferenceError at module load, and the
@@ -1079,5 +1134,5 @@ export const imageHost = {
   },
   dispose(id: number): void {
     image.dispose(id)
-  }
+  },
 }

package/runtime/images.ts

@@ -20,6 +20,7 @@ declare const image: {
   writeFile(path: string, bytes: Uint8Array): boolean
   // Read a whole file's raw bytes (e.g. a .pmtiles on microSD). Empty when the
   // file is missing or no storage is mounted.
+  removeFile(path: string): boolean
   readFile(path: string): Uint8Array
   // Read a .pmtiles archive flashed into the spare ota_1 partition. Empty when
   // none present (or off-device).
@@ -127,3 +128,7 @@ export function fetchText(url: string): string {
 export function imageFromId(id: number): GeaEmbeddedImage {
   return image.make(id)
 }
+
+export function removeCacheFile(path: string): boolean {
+  return image.removeFile(path)
+}

package/runtime-surface.ts

@@ -70,6 +70,7 @@ export type {
   AudioParam,
   AudioProps,
   BatteryController,
+  HapticsController,
   BluetoothConfig,
   BluetoothConnections,
   BluetoothController,
@@ -181,6 +182,7 @@ export type {
   VirtualListElement,
   WebSocketCloseEvent,
   WebSocketConstructor,
+  WebSocketOptions,
   WebSocketErrorEvent,
   WebSocketInstance,
   WebSocketMessageEvent,

package/runtime.cpp

@@ -88,10 +88,11 @@ void dispatch_rotary_input()
 void dispatch_key_input()
 {
 	auto &tree = gea::embedded::ui::Tree::instance();
-	for (int keyCode = input::consumeKeyDown(); keyCode != 0; keyCode = input::consumeKeyDown()) {
+	input::HardwareKeyEvent key{};
+	while (input::consumeKeyEvent(key)) {
 		events::PointerEvent event{};
-		event.type = events::PointerEventType::KeyDown;
-		event.keyCode = keyCode;
+		event.type = key.pressed ? events::PointerEventType::KeyDown : events::PointerEventType::KeyUp;
+		event.keyCode = key.keyCode;
 		event.bubbles = true;
 		event.cancelable = true;
 
@@ -105,7 +106,8 @@ void dispatch_key_input()
 		}
 		if (!stopped) {
 			event.propagationStopped = false;
-			gea::embedded::ui::dispatchDocumentKeyDown(event);
+			if (key.pressed) gea::embedded::ui::dispatchDocumentKeyDown(event);
+			else gea::embedded::ui::dispatchDocumentKeyUp(event);
 		}
 	}
 }
@@ -196,6 +198,9 @@ void dispatch_event(const events::Event &event, const RuntimeOptions &options)
 		// A finger held still posts no moves, so gestureActiveWithin() lapses to
 		// false after the window and the loop quiesces — no busy-render on a hold.
 		for (;;) {
+#if defined(ESP_PLATFORM) && defined(GEA_NATIVE_DEBUGGER) && GEA_NATIVE_DEBUGGER
+			if (services::FrameScheduler::debuggerFrameRate() > 0) break;
+#endif
 			const bool catchUp = services::FrameScheduler::takeCatchUpRequest();
 			const bool activeDrag =
 				GEA_EMBEDDED_CONTINUOUS_TOUCH_FRAMES &&
@@ -405,6 +410,15 @@ bool Runtime::boot(const RuntimeOptions &options)
 	(void)options;
 	services::RuntimeLog::appStarted(networkReady);
 #else
+#if defined(GEA_EMBEDDED_BOOT_STAGING_RESERVE) && GEA_EMBEDDED_BOOT_STAGING_RESERVE
+	// Opt-in (an app sets GEA_EMBEDDED_BOOT_STAGING_RESERVE=1 in gea.defines).
+	// TS initialization can start flash workers and audio before the event loop
+	// is available to resize staging. Lend surplus DMA staging now, retaining
+	// the panel's minimum pipeline until application and runtime tasks exist.
+	gea::platform::display::Display::reserveInternal(
+	    static_cast<std::size_t>(gea::platform::display::Display::flushBufferBytes()));
+	gea::platform::display::Display::applyPendingInternalReserve();
+#endif
 	if (!services::AppRunner::initApplication(options.width, options.height)) return false;
 	services::HeapProbe::log("runtime:after_app_init");
 	services::StackProbe::logCurrentTask("runtime:after_app_init");
@@ -417,7 +431,11 @@ bool Runtime::boot(const RuntimeOptions &options)
 	services::HeapProbe::log("runtime:after_frame_start");
 	services::StackProbe::logCurrentTask("runtime:after_frame_start");
 	services::HeapTaskSummary::log("runtime:after_frame_start");
-#if GEA_EMBEDDED_WIFI_EARLY_CONNECT
+#if defined(GEA_EMBEDDED_BOOT_STAGING_RESERVE) && GEA_EMBEDDED_BOOT_STAGING_RESERVE
+	// Initialization owns its allocations now. Grow staging into the remaining
+	// heap when the event loop resumes; allocation retains the DMA reserve.
+	gea::platform::display::Display::reserveInternal(0);
+#elif GEA_EMBEDDED_WIFI_EARLY_CONNECT
 	// The early-connect loan protects radio, app, and task initialization.
 	// They now own their allocations; let the frame task grow staging into
 	// the remaining heap instead of retaining the two-row boot floor forever.