peachsim 0.1.1641 → 0.1.1653

package/src/host/bridge-host.ts

@@ -13,6 +13,7 @@ import {
   SOOTSIM_BRIDGE_SIM_CLOSE_CODE,
   SOOTSIM_BRIDGE_SIM_CLOSE_REASON,
 } from '../bridge-constants.ts'
+import { commandWritesSim, type WsCommand } from '../bridge-contract.ts'
 import { getCliVersion } from '../cli-version.ts'
 import { activeDesktopHostApp } from '../desktop-host-delivery.ts'
 import { handleExpoSwiftRequest } from '../expo-swift-host.ts'
@@ -69,7 +70,6 @@ import {
   handleWebSocketProxyUpgrade,
   rejectUntrustedBridgeUpgrade,
 } from './websocket-proxy.ts'
-import type { WsCommand } from '../bridge-contract.ts'
 
 const SOOTSIM_CROSS_ORIGIN_EMBEDDER_POLICY = 'require-corp'
 
@@ -197,22 +197,6 @@ interface BridgeCliLease {
   ownerSocket?: WebSocket
 }
 
-// interactive commands change app state and must respect the lease.
-// observational/lifecycle commands (evaluate/tree/query/resolve/screenshot/capture/focus/call/close)
-// pass through without taking or checking a lease so cleanup never gets stuck
-// behind a stale cli owner.
-// `call` used to acquire a lease too, but most call paths are queries
-// (`__sootsimTest.findByTestId`, state reads, etc.). the CLI opts write
-// calls into lease acquisition via msg.acquireLock=true.
-const WRITE_COMMAND_TYPES = new Set([
-  'tap',
-  'keyboard',
-  'longPress',
-  'perform',
-  'reset',
-  'camera',
-])
-
 // how long a `close` waits for the sim page to tear itself down before the
 // host disconnects the sim socket. the close code is part of the protocol:
 // browser clients treat it as terminal and skip their normal reconnect loop.
@@ -223,13 +207,6 @@ const FORCE_CLOSE_TERMINATE_MS = 1000
 // type). a duplicate copy used to live here from a concurrent edit and
 // broke the standalone CLI esbuild bundle ("symbol already declared").
 
-function shouldAcquireLease(msg: any): boolean {
-  if (!msg || typeof msg.type !== 'string') return false
-  if (msg.acquireLock === true) return true
-  if (msg.readOnly === true) return false
-  return WRITE_COMMAND_TYPES.has(msg.type)
-}
-
 interface BridgeRestorableSimState {
   recentActions: BridgeRecentAction[]
   lastActiveAt: number
@@ -1075,7 +1052,7 @@ export class SootSimBridgeHost {
             }
 
             const targetSim = await this.waitForSim(msg.simId)
-            if (shouldAcquireLease(msg)) {
+            if (commandWritesSim(msg)) {
               const outcome = this.tryAcquireLease(ws, targetSim)
               if (!outcome.granted) {
                 if (ws.readyState === WebSocket.OPEN) {
@@ -1530,7 +1507,21 @@ export class SootSimBridgeHost {
    *  non-upgrade routes that don't match serve index.html (SPA behavior) so
    *  electron's webContents can navigate freely inside the runtime. */
   private handleHttpRequest(req: IncomingMessage, res: ServerResponse) {
-    if (rejectUntrustedBridgeOrigin(req, res)) return
+    const method = (req.method || 'GET').toUpperCase()
+    let url: URL
+    try {
+      url = new URL(req.url || '/', `http://${req.headers.host || 'localhost'}`)
+    } catch {
+      res.writeHead(400, { 'Content-Type': 'text/plain; charset=utf-8' })
+      res.end('invalid request URL or host')
+      return
+    }
+    const publicEngineFont =
+      (method === 'GET' || method === 'HEAD') &&
+      /^\/(?:runtime\/|sootsim\/)?engine\/fonts\/[^\\]*\.(ttf|otf|woff2?)$/.test(
+        url.pathname,
+      )
+    if (!publicEngineFont && rejectUntrustedBridgeOrigin(req, res)) return
     if (req.url === '/__peach/fetch-transport') {
       res.writeHead(200, {
         'Content-Type': 'application/json',
@@ -1619,16 +1610,6 @@ export class SootSimBridgeHost {
       return
     }
 
-    const method = (req.method || 'GET').toUpperCase()
-    let url: URL
-    try {
-      url = new URL(req.url || '/', `http://${req.headers.host || 'localhost'}`)
-    } catch {
-      res.writeHead(400, { 'Content-Type': 'text/plain; charset=utf-8' })
-      res.end('invalid request URL or host')
-      return
-    }
-
     // /__sootsim/shared-config is the one awaited HTTP write. ordinary
     // settings fan out over WS, but destructive reloads need confirmation
     // that the disk source of truth accepted their final reset first.
@@ -1972,6 +1953,8 @@ export class SootSimBridgeHost {
         res.writeHead(200, {
           'Content-Type': contentType,
           'Cache-Control': 'no-store',
+          // native file documents have an opaque origin when reading public fonts.
+          ...(publicEngineFont ? { 'Access-Control-Allow-Origin': '*' } : {}),
         })
         if (method === 'HEAD') {
           res.end()
@@ -2510,7 +2493,7 @@ export class SootSimBridgeHost {
   // called when the sim reports a real user interaction (pointerdown,
   // keydown, wheel, touch). creates or refreshes a short `user-active` lease
   // that keeps agent writes from trampling a user who is driving the sim.
-  // reads still pass through — shouldAcquireLease only blocks on writes.
+  // reads still pass through — commandWritesSim only blocks on writes.
   private updateUserActivity(sim: BridgeSimConnection) {
     const existing = this.getActiveLease(sim)
     if (existing && existing.kind === 'cli') {

package/src/host/browser-pointer.ts

@@ -0,0 +1,71 @@
+export interface BrowserPointerRequest {
+  phase: 'down' | 'move' | 'up' | 'cancel'
+  x: number
+  y: number
+  pointerId: number
+}
+
+// both browser hosts use chromium input so editable defaults and cross-origin
+// iframe hit testing run in the browser, rather than simulated DOM events.
+export function createBrowserPointerDispatcher(
+  send: (
+    method: 'Input.dispatchTouchEvent',
+    params: {
+      type: 'touchStart' | 'touchMove' | 'touchEnd' | 'touchCancel'
+      touchPoints: Array<{ x: number; y: number; id: number }>
+    },
+  ) => Promise<unknown>,
+) {
+  const points = new Map<number, { x: number; y: number; id: number }>()
+  return async (value: unknown): Promise<void> => {
+    if (!value || typeof value !== 'object') throw new Error('missing browser pointer')
+    const phase = Reflect.get(value, 'phase')
+    const x = Reflect.get(value, 'x')
+    const y = Reflect.get(value, 'y')
+    const pointerId = Reflect.get(value, 'pointerId')
+    if (phase !== 'down' && phase !== 'move' && phase !== 'up' && phase !== 'cancel')
+      throw new Error('invalid browser pointer phase')
+    if (
+      typeof x !== 'number' ||
+      !Number.isFinite(x) ||
+      typeof y !== 'number' ||
+      !Number.isFinite(y)
+    )
+      throw new Error('browser pointer coordinates must be finite')
+    if (
+      typeof pointerId !== 'number' ||
+      !Number.isSafeInteger(pointerId) ||
+      pointerId < 0
+    )
+      throw new Error('browser pointer id must be a nonnegative integer')
+    const request: BrowserPointerRequest = { phase, x, y, pointerId }
+    if (request.phase === 'down') {
+      if (points.has(request.pointerId)) throw new Error('browser pointer already down')
+      points.set(request.pointerId, { x: request.x, y: request.y, id: request.pointerId })
+    } else {
+      // chromium cancels the entire touch stream at once; the caller still
+      // releases each bound pointer while unwinding a multi-touch gesture.
+      if (request.phase === 'cancel' && points.size === 0) return
+      if (!points.has(request.pointerId)) throw new Error('browser pointer is not down')
+      if (request.phase === 'move')
+        points.set(request.pointerId, {
+          x: request.x,
+          y: request.y,
+          id: request.pointerId,
+        })
+      else if (request.phase === 'cancel') points.clear()
+      else points.delete(request.pointerId)
+    }
+    await send('Input.dispatchTouchEvent', {
+      type:
+        request.phase === 'down'
+          ? 'touchStart'
+          : request.phase === 'move'
+            ? 'touchMove'
+            : request.phase === 'up'
+              ? 'touchEnd'
+              : 'touchCancel',
+      touchPoints: [...points.values()],
+    })
+  }
+}

package/src/host/dev-server-package-versions.ts

@@ -0,0 +1,23 @@
+import fs from 'fs'
+import path from 'path'
+import { readInstalledNativePackageVersionsAsync } from '../installed-package-versions.ts'
+import { resolveMetroProjectRoot } from '../metro-project-root.ts'
+import type { PackageVersions } from '../packageVersionsContract'
+
+// a plain Metro or Expo dev server records no installed versions in its
+// bundle. the bridge serving that bundle reads them from the project the
+// server names, the way `peach open` reads its own project. a server that
+// names no project, or one whose project is not on this machine, gets none.
+export async function readDevServerPackageVersions(
+  bundleUrl: URL,
+): Promise<PackageVersions | null> {
+  if (!bundleUrl.pathname.endsWith('.bundle')) return null
+  const projectRoot = await resolveMetroProjectRoot(bundleUrl.href)
+  if (!projectRoot) return null
+  try {
+    await fs.promises.access(path.join(projectRoot, 'package.json'))
+  } catch {
+    return null
+  }
+  return readInstalledNativePackageVersionsAsync(projectRoot)
+}

package/src/host/fetch-proxy-handler.ts

@@ -33,6 +33,8 @@ import {
   isTrustedBridgeRequest,
   normalizeHostname,
 } from '../backend-origin.ts'
+import { PACKAGE_VERSIONS_HEADER } from '../packageVersionsContract'
+import { readDevServerPackageVersions } from './dev-server-package-versions.ts'
 import {
   buildFetchProxyUpstreamHeaders,
   FETCH_PROXY_FAILURE_HEADER,
@@ -218,7 +220,7 @@ export async function handleFetchProxyRequest(
 
   await proxyUpstream(req, res, upstreamUrl, params.has(FETCH_PROXY_FAILURE_PARAM), {
     requestHeaders: (target) => buildFetchProxyHeaders(req.headers, target),
-    respond: (upstream, setCookies) => {
+    respond: async (upstream, setCookies) => {
       for (const [key, value] of Object.entries(upstream.headers)) {
         const lowerKey = key.toLowerCase()
         if (
@@ -240,6 +242,17 @@ export async function handleFetchProxyRequest(
         }
         res.setHeader(key, value)
       }
+      // a bundle whose server records no install gets the one its project holds
+      if (
+        isBundleProxyRequestUrl(req.url) &&
+        req.method === 'GET' &&
+        upstream.statusCode === 200 &&
+        !res.hasHeader(PACKAGE_VERSIONS_HEADER)
+      ) {
+        const packageVersions = await readDevServerPackageVersions(upstreamUrl)
+        if (packageVersions)
+          res.setHeader(PACKAGE_VERSIONS_HEADER, JSON.stringify(packageVersions))
+      }
       applyFetchProxyCors(req, res)
       if (setCookies.length > 0)
         res.setHeader('x-sootsim-set-cookie', setCookies.join(', '))
@@ -345,7 +358,7 @@ async function proxyUpstream(
   reportFailure: boolean,
   route: {
     requestHeaders: (targetUrl: URL) => Record<string, string | string[]>
-    respond: (upstream: IncomingMessage, setCookies: string[]) => void
+    respond: (upstream: IncomingMessage, setCookies: string[]) => void | Promise<void>
   },
 ): Promise<void> {
   const originalMethod = req.method || 'GET'
@@ -444,7 +457,7 @@ async function proxyUpstream(
         redirectLimit: 10,
       }
       res.setHeader(FETCH_PROXY_NATIVE_COOKIE_RESPONSE_HEADER, nativeCookieHopHeader(hop))
-      route.respond(proxyRes, hopCookies)
+      await route.respond(proxyRes, hopCookies)
       if (isNativeCookieRedirect(hop)) res.removeHeader('location')
       res.statusCode = isNativeCookieRedirect(hop) ? 200 : status
       await pipeline(proxyRes, res)
@@ -479,7 +492,7 @@ async function proxyUpstream(
     }
 
     if (redirects > 0) res.setHeader(FETCH_PROXY_RESPONSE_URL_HEADER, targetUrl.href)
-    route.respond(proxyRes, hopCookies)
+    await route.respond(proxyRes, hopCookies)
     res.statusCode = status
     await pipeline(proxyRes, res)
   }

package/src/host/staged-host-files.ts

@@ -51,11 +51,21 @@ export function stageHostBytes(
   origin: string,
   extension = '',
 ): string {
-  const digest = createHash('sha256').update(bytes).digest('hex')
-  extension = extension.toLowerCase()
-  const name = STAGED_NAME.test(digest + extension) ? digest + extension : digest
+  const directory = prepareStagedDirectory()
+  return writeStagedBytes(bytes, origin, extension, directory)
+}
+
+// a resource pack prunes once, rather than scanning the cache for every file.
+export function stageHostByteFiles(
+  files: readonly Uint8Array[],
+  origin: string,
+): string[] {
+  const directory = prepareStagedDirectory()
+  return files.map((bytes) => writeStagedBytes(bytes, origin, '', directory))
+}
+
+function prepareStagedDirectory(): string {
   const directory = stagedDir()
-  const destination = path.join(directory, name)
   fs.mkdirSync(directory, { recursive: true })
   const now = Date.now()
   for (const entry of fs.readdirSync(directory, { withFileTypes: true })) {
@@ -63,6 +73,20 @@ export function stageHostBytes(
     if (entry.isFile() && now - fs.statSync(stale).mtimeMs > STAGED_RETENTION_MS)
       fs.rmSync(stale, { force: true })
   }
+  return directory
+}
+
+function writeStagedBytes(
+  bytes: Uint8Array,
+  origin: string,
+  extension: string,
+  directory: string,
+): string {
+  const digest = createHash('sha256').update(bytes).digest('hex')
+  extension = extension.toLowerCase()
+  const name = STAGED_NAME.test(digest + extension) ? digest + extension : digest
+  const destination = path.join(directory, name)
+  const now = Date.now()
   if (fs.existsSync(destination)) {
     fs.utimesSync(destination, new Date(now), new Date(now))
   } else {

package/src/installed-package-versions.ts

@@ -2,38 +2,144 @@
 // compiles a package's native side from the copy autolinking finds, which is
 // Node resolution from the project root, so that is the copy read here even
 // when the graph also bundles a nested one.
+//
+// each walk yields the file system reads it needs. the sync driver answers
+// them for one-shot callers; the async one for servers that must keep
+// answering other requests while a large workspace is read.
 
 import fs from 'fs'
 import path from 'path'
 import { LAZY_STUB_PATTERNS } from '@peach/compat/lazy-stub-patterns'
 import { NATIVE_RUNTIME_PACKAGE_NAMES } from '@peach/compat/native-package-names'
 import { COMPAT_STUBS } from '@peach/compat/stub-manifest'
-import { extractPackageFromPath } from '../../peach-engine/src/stub-pattern-matcher'
+import { extractPackageFromPath } from './stub-pattern-matcher.ts'
 import type { PackageVersions } from './packageVersionsContract'
 
-function readInstalledPackage(projectRoot: string, name: string) {
-  let dir = projectRoot
-  for (;;) {
-    let manifest: unknown
-    try {
-      manifest = JSON.parse(
-        fs.readFileSync(path.join(dir, 'node_modules', name, 'package.json'), 'utf8'),
-      )
-    } catch (error) {
-      if (!(error instanceof Error && 'code' in error && error.code === 'ENOENT')) {
-        throw error
+type InstalledPackage = { root: string; manifest: object }
+
+type FsStep =
+  | { op: 'exists'; path: string }
+  | { op: 'realpath'; path: string }
+  // the parsed package.json, or null when there is none or it is not an object
+  | { op: 'manifest'; path: string }
+type FsAnswer = boolean | string | object | null
+type FsWalk<T> = Generator<FsStep, T, FsAnswer>
+
+function* exists(target: string): FsWalk<boolean> {
+  return (yield { op: 'exists', path: target }) === true
+}
+
+function* realpath(target: string): FsWalk<string> {
+  const resolved = yield { op: 'realpath', path: target }
+  if (typeof resolved !== 'string') throw new Error(`could not resolve ${target}`)
+  return resolved
+}
+
+function* readManifest(target: string): FsWalk<object | null> {
+  const manifest = yield { op: 'manifest', path: target }
+  return typeof manifest === 'object' ? manifest : null
+}
+
+function parseManifest(source: string): object | null {
+  const manifest: unknown = JSON.parse(source)
+  return typeof manifest === 'object' && manifest !== null ? manifest : null
+}
+
+function isMissing(error: unknown): boolean {
+  return error instanceof Error && 'code' in error && error.code === 'ENOENT'
+}
+
+function answerSync(step: FsStep): FsAnswer {
+  if (step.op === 'exists') return fs.existsSync(step.path)
+  if (step.op === 'realpath') return fs.realpathSync(step.path)
+  try {
+    return parseManifest(fs.readFileSync(step.path, 'utf8'))
+  } catch (error) {
+    if (isMissing(error)) return null
+    throw error
+  }
+}
+
+async function answerAsync(step: FsStep): Promise<FsAnswer> {
+  if (step.op === 'exists')
+    return fs.promises.access(step.path).then(
+      () => true,
+      () => false,
+    )
+  if (step.op === 'realpath') return fs.promises.realpath(step.path)
+  try {
+    return parseManifest(await fs.promises.readFile(step.path, 'utf8'))
+  } catch (error) {
+    if (isMissing(error)) return null
+    throw error
+  }
+}
+
+function runSync<T>(walk: FsWalk<T>): T {
+  for (let step = walk.next(); ; ) {
+    if (step.done) return step.value
+    step = walk.next(answerSync(step.value))
+  }
+}
+
+async function runAsync<T>(walk: FsWalk<T>): Promise<T> {
+  for (let step = walk.next(); ; ) {
+    if (step.done) return step.value
+    step = walk.next(await answerAsync(step.value))
+  }
+}
+
+// Node resolution looks in each ancestor's node_modules, skipping directories
+// that are themselves node_modules. one walk asks the same ancestors for many
+// names, so each directory's node_modules is checked once and each manifest
+// read once.
+function createInstalledPackageReader() {
+  const hasModules = new Map<string, boolean>()
+  const manifests = new Map<string, InstalledPackage | null>()
+  return function* readInstalledPackage(
+    fromDir: string,
+    name: string,
+  ): FsWalk<InstalledPackage | null> {
+    for (let dir = fromDir; ; ) {
+      if (path.basename(dir) !== 'node_modules') {
+        const modules = path.join(dir, 'node_modules')
+        let present = hasModules.get(dir)
+        if (present === undefined) {
+          present = yield* exists(modules)
+          hasModules.set(dir, present)
+        }
+        if (present) {
+          const root = path.join(modules, name)
+          let installed = manifests.get(root)
+          if (installed === undefined) {
+            const manifest = yield* readManifest(path.join(root, 'package.json'))
+            installed = manifest ? { root, manifest } : null
+            manifests.set(root, installed)
+          }
+          if (installed) return installed
+        }
       }
       const parent = path.dirname(dir)
       if (parent === dir) return null
       dir = parent
-      continue
     }
-    return typeof manifest === 'object' && manifest !== null
-      ? { root: path.join(dir, 'node_modules', name), manifest }
-      : null
   }
 }
 
+function* installedVersionsWalk(
+  projectRoot: string,
+  names: Iterable<string>,
+): FsWalk<PackageVersions> {
+  const readInstalledPackage = createInstalledPackageReader()
+  const versions: PackageVersions = {}
+  for (const name of [...names].sort()) {
+    const installed = yield* readInstalledPackage(projectRoot, name)
+    const version = installed && Reflect.get(installed.manifest, 'version')
+    if (typeof version === 'string' && version.length > 0) versions[name] = version
+  }
+  return versions
+}
+
 export function readInstalledPackageVersions(
   projectRoot: string,
   modulePaths: Iterable<string>,
@@ -43,20 +149,14 @@ export function readInstalledPackageVersions(
     const name = extractPackageFromPath(modulePath.replaceAll(path.sep, '/'))
     if (name) names.add(name)
   }
-  const versions: PackageVersions = {}
-  for (const name of [...names].sort()) {
-    const installed = readInstalledPackage(projectRoot, name)
-    const version = installed && Reflect.get(installed.manifest, 'version')
-    if (typeof version === 'string' && version.length > 0) versions[name] = version
-  }
-  return versions
+  return runSync(installedVersionsWalk(projectRoot, names))
 }
 
 // plain expo and one servers need no peach plugin. the launcher reads their
 // installed native packages from the app's dependency graph. an unrelated
 // package hoisted beside a workspace app is resolvable but is not linked.
-export function readInstalledNativePackageVersions(projectRoot: string): PackageVersions {
-  const appRoot = fs.realpathSync(projectRoot)
+function* nativePackageVersionsWalk(projectRoot: string): FsWalk<PackageVersions> {
+  const appRoot = yield* realpath(projectRoot)
   const nativeNames = new Set<string>()
   for (const specifier of [
     'react-native',
@@ -67,17 +167,14 @@ export function readInstalledNativePackageVersions(projectRoot: string): Package
     const name = extractPackageFromPath(`node_modules/${specifier}`)
     if (name) nativeNames.add(name)
   }
-  const manifest: unknown = JSON.parse(
-    fs.readFileSync(path.join(appRoot, 'package.json'), 'utf8'),
-  )
-  if (typeof manifest !== 'object' || manifest === null) {
-    throw new Error('app package.json must contain an object')
-  }
-  const pending = [{ root: appRoot, manifest }]
+  const manifest = yield* readManifest(path.join(appRoot, 'package.json'))
+  if (!manifest) throw new Error('app package.json must contain an object')
+  const readInstalledPackage = createInstalledPackageReader()
+  const pending: InstalledPackage[] = [{ root: appRoot, manifest }]
   const visited = new Set<string>()
   const needed = new Set<string>()
   for (let next = pending.pop(); next; next = pending.pop()) {
-    const root = fs.realpathSync(next.root)
+    const root = yield* realpath(next.root)
     if (visited.has(root)) continue
     visited.add(root)
     const fields = ['dependencies', 'optionalDependencies', 'peerDependencies']
@@ -92,15 +189,22 @@ export function readInstalledNativePackageVersions(projectRoot: string): Package
           if (typeof peer === 'object' && peer !== null && Reflect.get(peer, 'optional'))
             continue
         }
-        const installed = readInstalledPackage(root, name)
+        const installed = yield* readInstalledPackage(root, name)
         if (!installed) continue
         if (nativeNames.has(name)) needed.add(name)
         pending.push(installed)
       }
     }
   }
-  return readInstalledPackageVersions(
-    projectRoot,
-    [...needed].map((specifier) => `node_modules/${specifier}`),
-  )
+  return yield* installedVersionsWalk(projectRoot, needed)
+}
+
+export function readInstalledNativePackageVersions(projectRoot: string): PackageVersions {
+  return runSync(nativePackageVersionsWalk(projectRoot))
+}
+
+export function readInstalledNativePackageVersionsAsync(
+  projectRoot: string,
+): Promise<PackageVersions> {
+  return runAsync(nativePackageVersionsWalk(projectRoot))
 }

package/src/kotlin-host.ts

@@ -325,7 +325,7 @@ function entrySource(ids: string[]): string {
     '@JsExport',
     'fun peachSetAndroidBuildInfo(model: String, release: String) = Build.setDevice(model, release)',
     '',
-    '@OptIn(kotlin.js.ExperimentalJsExport::class, kotlin.js.ExperimentalWasmJsInterop::class, kotlinx.coroutines.DelicateCoroutinesApi::class)',
+    '@OptIn(kotlin.js.ExperimentalJsExport::class, kotlinx.coroutines.DelicateCoroutinesApi::class)',
     '@JsExport',
     'fun peachNativeCall(module: String, method: String, argsJson: String, contractHash: String): Promise<JsAny?> =',
     '    GlobalScope.promise(Dispatchers.Main) {',

package/src/launchMetadataContract.ts

@@ -6,6 +6,7 @@ export const LAUNCH_METADATA_KEYS: readonly string[] = [
   'appFonts',
   'appSplash',
   'appCatalog',
+  'appBundleResources',
   'nativeAppIdentity',
   'nativeFirebase',
   'appManifest',

package/src/menu.ts

@@ -71,7 +71,13 @@ export const SOOTSIM_RENDER_RESOLUTION_LABELS: Record<SootSimRenderResolution, s
 // engine's wireframe store draws. 'wireframe' is the clean structural sketch;
 // the others are its screen-space styles that ship as named effects.
 export type SootSimScreenEffect = 'none' | 'wireframe' | 'blueprint' | 'panel' | 'green'
-export const SOOTSIM_SCREEN_EFFECTS = ['none', 'wireframe', 'blueprint', 'panel', 'green'] as const
+export const SOOTSIM_SCREEN_EFFECTS = [
+  'none',
+  'wireframe',
+  'blueprint',
+  'panel',
+  'green',
+] as const
 
 export function isSootSimScreenEffect(value: unknown): value is SootSimScreenEffect {
   return (
@@ -373,9 +379,9 @@ function deviceMenu(
       },
       { type: 'separator' },
       { label: 'Trigger Screenshot', action: 'screenshot' },
-      // pose controls for the current device: open/close on foldables,
-      // rotate left/right wherever a turn changes geometry, the way ios
-      // simulator holds them (rotate left is cmd+left, rotate right
+      // pose controls for the current device: open/close, book and laptop on
+      // foldables, rotate left/right wherever a turn changes geometry, the way
+      // ios simulator holds them (rotate left is cmd+left, rotate right
       // cmd+right). truthiness, not !== null: a partial state must hide
       // these, never show duo items for the wrong device.
       ...(state.devicePosture || state.canRotate
@@ -390,6 +396,8 @@ function deviceMenu(
                         : 'Open iPhone Duo',
                     action: 'toggle-duo-posture',
                   },
+                  { label: 'Book Pose', action: 'fold-duo-book' },
+                  { label: 'Laptop Pose', action: 'fold-duo-laptop' },
                 ]
               : []),
             ...(state.canRotate

package/src/metro-plugin.ts

@@ -12,10 +12,6 @@ import fs from 'fs'
 import { createRequire } from 'module'
 import { randomUUID } from 'node:crypto'
 import path from 'path'
-import {
-  getRuntimePlatformAdapter,
-  isRuntimePlatform,
-} from '../../peach-engine/src/platform/adapter'
 import { resolveAppProject } from '../cli/app-project'
 import { collectAndroidAutolinkedPackages } from './android-autolinking'
 import { insertAndroidAutolinkingFooter } from './androidAutolinkingContract'
@@ -51,6 +47,10 @@ import {
   serveRuntimeFile,
   SOOTSIM_RUNTIME_MISSING_MESSAGE,
 } from './runtime-assets'
+import {
+  getRuntimePlatformAdapter,
+  isRuntimePlatform,
+} from './runtimePlatformContract.ts'
 
 const prefix = '/__peachsim'
 export { toPeachDevelopmentBundleUrl, toPeachProductionBundleUrl }