@expo/serve-sim 0.2.4 → 0.3.1

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@expo/serve-sim",
-  "version": "0.2.4",
+  "version": "0.3.1",
   "type": "module",
   "author": {
     "name": "Evan Bacon",
@@ -37,6 +37,9 @@
     "dist/middleware.js",
     "dist/middleware.cjs",
     "dist/state.js",
+    "dist/capability-loader/libServeSimCapabilityLoader.dylib",
+    "Sources/ServeSimCapabilityLoader/serve-sim-capability-loader.c",
+    "Sources/ServeSimCapabilityLoader/build.sh",
     "dist/simcam/libSimCameraInjector.dylib",
     "dist/simcam/serve-sim-camera-helper",
     "dist/simax/serve-sim-ax-settings",
@@ -74,6 +77,7 @@
   "scripts": {
     "build": "bun run build.ts",
     "dev": "bun run dev.ts",
+    "test:capability-loader": "Sources/ServeSimCapabilityLoader/tests/run.sh",
     "tart": "bun scripts/tart/cli.ts",
     "tart-test": "bun scripts/tart/cli.ts test",
     "tart-dev": "bun scripts/tart/cli.ts dev"
@@ -83,6 +87,7 @@
     "@types/debug": "^4.1.13",
     "@types/react": "^19.0.0",
     "@types/react-dom": "^19.0.0",
+    "@types/three": "^0.186.0",
     "@types/ws": "^8.18.1",
     "bun-plugin-tailwind": "^0.1.2",
     "commander": "^14.0.1",
@@ -93,6 +98,7 @@
     "react": "^19.0.0",
     "react-dom": "^19.0.0",
     "tailwindcss": "^4.1.7",
+    "three": "^0.186.0",
     "typescript": "^5.7.0",
     "werift": "^0.24.4",
     "zod": "^4.5.4"

package/src/middleware.ts

@@ -39,6 +39,8 @@ import {
   serveDevicePlaceholderAsset,
   type DeviceKitChromeDescriptor,
 } from "./devicekit-chrome";
+import { serveDeviceKitModelAsset } from "./devicekit-model";
+import { validatePanelRoute } from "./panel-route";
 import { createExecWebSocketHandler, type UiRequestHandler } from "./exec-ws";
 import { claimHelperHidSocket, type UpgradeHandlerWebSocket } from "./middleware-utils";
 import { UI_OPTIONS, getUiStatus, normalizeUiValue, setUiOption } from "./ui-settings";
@@ -552,6 +554,7 @@ function helperProxyTarget(rawUrl: string, prefix: string): { device: string | n
     "config",
     "foreground",
     "health",
+    "panel",
     "stream.avcc",
     "stream.mjpeg",
     "webrtc",
@@ -797,6 +800,16 @@ function serveHelperInProcess(
 ): boolean {
   if (!device) return false;
   const endpoint = upstreamPath.split("?")[0];
+  const panelRoute = /^\/panel\/([^/]+)\/(.+)$/.exec(endpoint ?? "");
+  if (panelRoute) {
+    const route = validatePanelRoute(panelRoute[1]!, panelRoute[2]!, req.method);
+    if ("error" in route) {
+      res.writeHead(route.status, { "Content-Type": "application/json" });
+      res.end(JSON.stringify({ error: route.error }));
+      return true;
+    }
+    if (req.method === "OPTIONS") { res.writeHead(204); res.end(); return true; }
+  }
   if (endpoint === "/camera/status") {
     void handleCameraStatus(req, res, device);
     return true;
@@ -810,11 +823,25 @@ function serveHelperInProcess(
     return true;
   }
   let session;
+  if (panelRoute && (panelRoute[2] === "webrtc/stats" || panelRoute[2] === "webrtc/close")) {
+    const live = peekDeviceSession(device);
+    if (!live) {
+      res.writeHead(panelRoute[2] === "webrtc/close" ? 204 : 404);
+      res.end();
+      return true;
+    }
+    void live.handlePanel(req, res, Number(panelRoute[1]), panelRoute[2]!);
+    return true;
+  }
   try {
     session = getDeviceSession(device, initialStreamSettings);
   } catch {
     return false; // not booted / capture unavailable → 404
   }
+  if (panelRoute) {
+    void session.handlePanel(req, res, Number(panelRoute[1]), panelRoute[2]!);
+    return true;
+  }
   switch (endpoint) {
     case "/stream.mjpeg": session.handleMjpeg(req, res); return true;
     case "/stream.avcc": session.handleAvcc(req, res); return true;
@@ -1662,7 +1689,11 @@ export function simMiddleware(options?: SimMiddlewareOptions): SimMiddleware {
     // Gated as a whole rather than per route, so a new route is protected by default.
     if (
       !UNGATED_PATHS.some((path) => url === base + path)
-      && !assertPreviewAccess(req, res, execToken, { required: requirePreviewToken, basePath: base })
+      && !assertPreviewAccess(req, res, execToken, {
+        required: requirePreviewToken,
+        basePath: base,
+        htmlHeaders: framePolicyHeaders,
+      })
     ) {
       return;
     }
@@ -1776,6 +1807,11 @@ export function simMiddleware(options?: SimMiddlewareOptions): SimMiddleware {
       return;
     }
 
+    if (url === base + "/grid/api/devicekit-model") {
+      serveDeviceKitModelAsset(req, res);
+      return;
+    }
+
     // Static simulator metadata. The browser keeps this catalog in memory and
     // receives state/helper changes through the compact status feed below.
     if (url === base + "/grid/api/catalog") {

package/src/native.ts

@@ -16,6 +16,7 @@ import {
   type StreamEncoderSettings,
 } from "./stream-settings";
 import { readSenderStats, type SenderStats } from "./webrtc-sender-stats";
+import type { HingePhysicalOrientation } from "./hinge-control";
 
 const require = createRequire(import.meta.url);
 
@@ -24,6 +25,12 @@ const require = createRequire(import.meta.url);
 // handle is garbage-collected (Swift `deinit`), so there are no explicit
 // destroy/free calls here.
 interface SimHIDHandle {
+  setScreen(screenId: number): Promise<void>;
+  supportsHingeAngle(): Promise<boolean>;
+  hingeState(): Promise<NativeHingeState>;
+  setHingeAngle(angle: number): Promise<boolean>;
+  setHingePose(pose: string): Promise<boolean>;
+  setTableMode(enabled: boolean): Promise<boolean>;
   touch(type: TouchType, x: number, y: number, w: number, hh: number, edge: number): Promise<void>;
   multiTouch(type: TouchType, x1: number, y1: number, x2: number, y2: number, w: number, hh: number): Promise<void>;
   button(button: string): Promise<void>;
@@ -49,7 +56,8 @@ interface SimCaptureHandle {
   handleWebRTCOffer(offerJson: string): Promise<string>;
   closeWebRTCSession(sessionId: string): Promise<void>;
   webRTCSenderStats(sessionId: string): Promise<string>;
-  screenSize(): Promise<{ width: number; height: number }>;
+  screenSize(): Promise<NativeScreenInfo>;
+  subscribeScreenChanges(onChange: () => Promise<void>): Promise<NativeUnsubscribe>;
   stop(): Promise<void>;
   subscribe(codec: number, onFrame: RawFrameCallback): Promise<NativeUnsubscribe>;
 }
@@ -63,6 +71,7 @@ interface NativeAddon {
     maxDimension: number,
     h264Fps: number,
     h264Bitrate: number,
+    screenId?: number,
   ) => SimCaptureHandle;
   axDescribe(udid: string): Promise<string>;
   axFrontmost(udid: string): Promise<string>;
@@ -98,6 +107,21 @@ export type AvccFrame = {
 
 export type NativeCaptureOptions = StreamEncoderSettings;
 
+export type NativeHingeState = {
+  hingeAngle?: number;
+  tableMode?: boolean;
+  physicalOrientation?: HingePhysicalOrientation;
+};
+
+export type NativeScreenInfo = {
+  width: number;
+  height: number;
+  /** Present when CoreSimulator exposes its active screen metadata. */
+  orientation?: "portrait" | "portrait_upside_down" | "landscape_left" | "landscape_right";
+  screenId?: number;
+  chromeIdentifier?: string;
+};
+
 export type NativeUnsubscribe = () => Promise<void>;
 
 export type TouchType = "begin" | "move" | "end";
@@ -144,11 +168,17 @@ function load(): NativeAddon {
  */
 export class NativeHid {
   private readonly handle: SimHIDHandle;
+  private setupFailed = false;
 
   constructor(udid: string) {
     this.handle = new (load().SimHID)(udid);
   }
 
+  /** A failed native setup stays unavailable until this session is recreated. */
+  get inputUnavailable(): boolean {
+    return this.setupFailed;
+  }
+
   // The N-API bindings throw synchronously when a JS value can't be coerced to
   // the native parameter type (e.g. a touch with a non-string `type` →
   // "Could not convert parameter 0 to type String"). HID now runs in-process,
@@ -157,6 +187,7 @@ export class NativeHid {
   // the sim reboots. The spawned helper used to absorb this in its own process;
   // `guard` restores that isolation by swallowing malformed-input errors.
   private async guard<T>(op: string, fn: () => PromiseLike<T>, fallback: T): Promise<T> {
+    if (this.inputUnavailable) return fallback;
     try {
       return await fn();
     } catch (err) {
@@ -169,6 +200,38 @@ export class NativeHid {
     return this.guard("touch", () => this.handle.touch(type, x, y, w, h, edge), undefined);
   }
 
+  async setScreen(screenId: number): Promise<void> {
+    if (this.inputUnavailable) return;
+    try {
+      await this.handle.setScreen(screenId);
+    } catch (err) {
+      // Native setup is cached for this handle; a failed setup cannot recover
+      // until a new session. Keep capture running without calling partial HID state.
+      this.setupFailed = true;
+      console.error("[hid] Input setup failed; streaming will continue without input:", err instanceof Error ? err.message : err);
+    }
+  }
+
+  setHingeAngle(angle: number): Promise<boolean> {
+    return this.guard("setHingeAngle", () => this.handle.setHingeAngle(angle), false);
+  }
+
+  setHingePose(pose: string): Promise<boolean> {
+    return this.guard("setHingePose", () => this.handle.setHingePose(pose), false);
+  }
+
+  setTableMode(enabled: boolean): Promise<boolean> {
+    return this.guard("setTableMode", () => this.handle.setTableMode(enabled), false);
+  }
+
+  supportsHingeAngle(): Promise<boolean> {
+    return this.guard("supportsHingeAngle", () => this.handle.supportsHingeAngle(), false);
+  }
+
+  hingeState(): Promise<NativeHingeState> {
+    return this.guard("hingeState", () => this.handle.hingeState(), {});
+  }
+
   multiTouch(type: TouchType, x1: number, y1: number, x2: number, y2: number, w: number, h: number): Promise<void> {
     return this.guard("multiTouch", () => this.handle.multiTouch(type, x1, y1, x2, y2, w, h), undefined);
   }
@@ -220,7 +283,11 @@ export class NativeHid {
 export class NativeCapture {
   private readonly handle: SimCaptureHandle;
 
-  constructor(udid: string, options: NativeCaptureOptions = DEFAULT_STREAM_ENCODER_SETTINGS) {
+  /** A fixed screen ID captures that panel independently of active-display/input routing. */
+  constructor(udid: string, options: NativeCaptureOptions = DEFAULT_STREAM_ENCODER_SETTINGS, screenId?: number) {
+    if (screenId !== undefined && (!Number.isInteger(screenId) || screenId < 0 || screenId > 0xffff_ffff)) {
+      throw new RangeError("Screen ID must be an unsigned 32-bit integer.");
+    }
     this.handle = new (load().SimCapture)(
       udid,
       options.mjpegFps,
@@ -228,6 +295,7 @@ export class NativeCapture {
       options.maxDimension,
       options.h264Fps,
       options.h264Bitrate,
+      screenId ?? 0,
     );
   }
 
@@ -281,10 +349,14 @@ export class NativeCapture {
     return readSenderStats(JSON.parse(await this.handle.webRTCSenderStats(sessionId ?? "")));
   }
 
-  screenSize(): Promise<{ width: number; height: number }> {
+  screenSize(): Promise<NativeScreenInfo> {
     return this.handle.screenSize();
   }
 
+  subscribeScreenChanges(onChange: () => Promise<void>): Promise<NativeUnsubscribe> {
+    return this.handle.subscribeScreenChanges(onChange);
+  }
+
   /** Halt frame production. Full teardown happens when this object is GC'd. */
   stop(): Promise<void> {
     return this.handle.stop();