@goliapkg/smix 0.1.0

package/src/SimRuntime.ts

@@ -0,0 +1,145 @@
+// v7.5 c1 — SmixSimRuntime interface + MockSimRuntime impl.
+//
+// Mirror Swift v7.2 + Kotlin v7.4 SimRuntime architecture. TS SDK
+// is HTTP-runner-friendly (per R-7.5-B decision):
+//   - HttpSimRuntime (real, lives in src/HttpRunner.ts, v7.5 c3):
+//     wraps smix-runner HTTP server via fetch (cross-platform iOS+Android).
+//   - MockSimRuntime (here): in-memory tree + event log for unit tests.
+//
+// Per iron rule §9 #13: this module ships only to test targets.
+
+import type { A11yNode } from './A11yNode.js'
+
+export type KeyName = 'return' | 'delete' | 'space' | 'tab' | 'escape' | 'enter'
+export type SwipeDirection = 'up' | 'down' | 'left' | 'right'
+
+/** Low-level emulator runtime — captures + injects events. */
+export interface SmixSimRuntime {
+  launch(bundleId: string): Promise<void>
+  terminate(bundleId: string): Promise<void>
+  snapshotTree(): Promise<A11yNode>
+  synthesizeTap(x: number, y: number): Promise<void>
+  sendString(text: string): Promise<void>
+  pressKey(key: KeyName): Promise<void>
+  swipe(direction: SwipeDirection): Promise<void>
+  screenshot(): Promise<Uint8Array>
+  systemPopups(): Promise<A11yNode[]>
+  openUrl(url: string): Promise<void>
+  launchFresh(opts: {
+    bundleId: string
+    clearState: boolean
+    clearKeychain: boolean
+    appPath?: string | undefined
+  }): Promise<void>
+  launchFromPath(appPath: string): Promise<void>
+  synthesizeTapAtNormalized(nx: number, ny: number): Promise<void>
+}
+
+export interface LaunchFreshCall {
+  bundleId: string
+  clearState: boolean
+  clearKeychain: boolean
+  appPath: string | undefined
+}
+
+const EMPTY_DEFAULT: A11yNode = {
+  rawType: 'other',
+  bounds: { x: 0, y: 0, w: 393, h: 852 },
+  enabled: true,
+  visible: true,
+  children: [],
+}
+
+/**
+ * In-memory mock runtime — used by vitest unit tests for deterministic
+ * wire verification without booting an emulator.
+ */
+export class MockSimRuntime implements SmixSimRuntime {
+  snapshotResult: A11yNode = EMPTY_DEFAULT
+  readonly tapCalls: { x: number; y: number }[] = []
+  readonly launchCalls: string[] = []
+  readonly terminateCalls: string[] = []
+  readonly sendStringCalls: string[] = []
+  readonly pressKeyCalls: KeyName[] = []
+  readonly swipeCalls: SwipeDirection[] = []
+  screenshotCalls = 0
+  screenshotResult: Uint8Array = new Uint8Array(0)
+  systemPopupsResult: A11yNode[] = []
+  readonly openUrlCalls: string[] = []
+  readonly launchFreshCalls: LaunchFreshCall[] = []
+  readonly launchFromPathCalls: string[] = []
+  readonly tapAtNormalizedCalls: { nx: number; ny: number }[] = []
+
+  /** Hook invoked just before [snapshotTree] returns. Mirrors Swift/Kotlin. */
+  afterSnapshot: ((callIndex: number) => void) | null = null
+  private snapshotCallCount = 0
+
+  constructor(opts: { snapshotResult?: A11yNode } = {}) {
+    if (opts.snapshotResult !== undefined) this.snapshotResult = opts.snapshotResult
+  }
+
+  async launch(bundleId: string): Promise<void> {
+    this.launchCalls.push(bundleId)
+  }
+
+  async terminate(bundleId: string): Promise<void> {
+    this.terminateCalls.push(bundleId)
+  }
+
+  async snapshotTree(): Promise<A11yNode> {
+    const idx = this.snapshotCallCount++
+    this.afterSnapshot?.(idx)
+    return this.snapshotResult
+  }
+
+  async synthesizeTap(x: number, y: number): Promise<void> {
+    this.tapCalls.push({ x, y })
+  }
+
+  async sendString(text: string): Promise<void> {
+    this.sendStringCalls.push(text)
+  }
+
+  async pressKey(key: KeyName): Promise<void> {
+    this.pressKeyCalls.push(key)
+  }
+
+  async swipe(direction: SwipeDirection): Promise<void> {
+    this.swipeCalls.push(direction)
+  }
+
+  async screenshot(): Promise<Uint8Array> {
+    this.screenshotCalls++
+    return this.screenshotResult
+  }
+
+  async systemPopups(): Promise<A11yNode[]> {
+    return this.systemPopupsResult
+  }
+
+  async openUrl(url: string): Promise<void> {
+    this.openUrlCalls.push(url)
+  }
+
+  async launchFresh(opts: {
+    bundleId: string
+    clearState: boolean
+    clearKeychain: boolean
+    appPath?: string | undefined
+  }): Promise<void> {
+    this.launchFreshCalls.push({
+      bundleId: opts.bundleId,
+      clearState: opts.clearState,
+      clearKeychain: opts.clearKeychain,
+      appPath: opts.appPath,
+    })
+  }
+
+  async launchFromPath(appPath: string): Promise<void> {
+    this.launchFromPathCalls.push(appPath)
+  }
+
+  async synthesizeTapAtNormalized(nx: number, ny: number): Promise<void> {
+    this.tapAtNormalizedCalls.push({ nx, ny })
+  }
+}

package/src/Smix.ts

@@ -0,0 +1,49 @@
+// v7.5 c1 — Smix top-level entry. Mirror Kotlin / Swift Smix.launchApp.
+//
+// Per R-7.5-B HTTP-runtime decision, the default SelectorResolver for
+// production points at the smix-runner HTTP server (lands v7.5 c3 in
+// src/HttpRunner.ts). For c1 MVP, callers must pass an explicit
+// SelectorResolver (e.g. MockSelectorResolver in tests; HttpSelectorResolver
+// in c3 production).
+
+import { App } from './App.js'
+import { SmixNotImplementedError } from './Locator.js'
+import type { LabelsResolver, SelectorResolver } from './SelectorResolver.js'
+import type { SmixSimRuntime } from './SimRuntime.js'
+
+export type AppTarget =
+  | { kind: 'bundleId'; value: string }
+  | { kind: 'appPath'; path: string }
+
+export const bundleId = (value: string): AppTarget => ({ kind: 'bundleId', value })
+export const appPath = (path: string): AppTarget => ({ kind: 'appPath', path })
+
+/**
+ * Top-level entry. Launches the target app via [runtime] and returns
+ * an [App] handle wired with the given [resolver] for selector queries.
+ */
+export const Smix = {
+  async launchApp(
+    target: AppTarget,
+    runtime: SmixSimRuntime,
+    resolver: SelectorResolver,
+    labelsResolver?: LabelsResolver,
+  ): Promise<App> {
+    switch (target.kind) {
+      case 'bundleId': {
+        await runtime.launch(target.value)
+        return labelsResolver !== undefined
+          ? new App(target.value, runtime, resolver, labelsResolver)
+          : new App(target.value, runtime, resolver)
+      }
+      case 'appPath': {
+        await runtime.launchFromPath(target.path)
+        return labelsResolver !== undefined
+          ? new App(target.path, runtime, resolver, labelsResolver)
+          : new App(target.path, runtime, resolver)
+      }
+    }
+  },
+} as const
+
+export { SmixNotImplementedError }

package/src/__tests__/AppFullApi.test.ts

@@ -0,0 +1,168 @@
+// v7.5 c3 — App act/sense full API wire tests, mirror Kotlin
+// AppActSenseExtMockTest + AppFillPressKeyMockTest + Swift v7.2 c1/c2/c5.
+
+import { describe, expect, test } from 'vitest'
+import {
+  bundleId,
+  ExpectationFailure,
+  literal,
+  MockSelectorResolver,
+  MockSimRuntime,
+  Selector,
+  Smix,
+  type A11yNode,
+} from '../index.js'
+
+describe('App.fill / pressKey', () => {
+  test('fill = tap-to-focus + sendString', async () => {
+    const field: A11yNode = {
+      rawType: 'textField',
+      identifier: 'input-username',
+      label: 'Username',
+      bounds: { x: 50, y: 200, w: 200, h: 40 },
+      enabled: true,
+      visible: true,
+    }
+    const tree: A11yNode = {
+      rawType: 'other',
+      bounds: { x: 0, y: 0, w: 393, h: 852 },
+      visible: true,
+      children: [field],
+    }
+    const runtime = new MockSimRuntime({ snapshotResult: tree })
+    const resolver = new MockSelectorResolver()
+    resolver.registerHit('{"id":"input-username"}', 'input-username')
+    const app = await Smix.launchApp(bundleId('dev.smix.fixture'), runtime, resolver.resolve)
+
+    await app.fill(Selector.id('input-username'), 'alice')
+
+    expect(runtime.tapCalls.length).toBe(1)
+    expect(runtime.tapCalls[0]?.x).toBeCloseTo(150, 1)
+    expect(runtime.tapCalls[0]?.y).toBeCloseTo(220, 1)
+    expect(runtime.sendStringCalls).toEqual(['alice'])
+  })
+
+  test('pressKey delegates to runtime', async () => {
+    const runtime = new MockSimRuntime()
+    const app = await Smix.launchApp(bundleId('dev.smix.fixture'), runtime, new MockSelectorResolver().resolve)
+    await app.pressKey('return')
+    await app.pressKey('delete')
+    expect(runtime.pressKeyCalls).toEqual(['return', 'delete'])
+  })
+
+  test('fill failure surfaces ExpectationFailure (no sendString fired)', async () => {
+    const runtime = new MockSimRuntime()
+    const app = await Smix.launchApp(bundleId('dev.smix.fixture'), runtime, new MockSelectorResolver().resolve)
+    await expect(app.fill(Selector.id('missing'), 'text')).rejects.toBeInstanceOf(ExpectationFailure)
+    expect(runtime.sendStringCalls).toEqual([])
+  })
+})
+
+describe('App.swipe / screenshot / systemPopups / openUrl', () => {
+  test('swipe delegates with 4 directions', async () => {
+    const runtime = new MockSimRuntime()
+    const app = await Smix.launchApp(bundleId('dev.smix.fixture'), runtime, new MockSelectorResolver().resolve)
+    await app.swipe('down')
+    await app.swipe('up')
+    await app.swipe('left')
+    await app.swipe('right')
+    expect(runtime.swipeCalls).toEqual(['down', 'up', 'left', 'right'])
+  })
+
+  test('screenshot returns runtime bytes', async () => {
+    const expected = new Uint8Array([0x89, 0x50, 0x4e, 0x47])
+    const runtime = new MockSimRuntime()
+    runtime.screenshotResult = expected
+    const app = await Smix.launchApp(bundleId('dev.smix.fixture'), runtime, new MockSelectorResolver().resolve)
+    const out = await app.screenshot()
+    expect(out).toEqual(expected)
+    expect(runtime.screenshotCalls).toBe(1)
+  })
+
+  test('systemPopups returns runtime list', async () => {
+    const alert: A11yNode = {
+      rawType: 'alert',
+      identifier: 'alert-permission',
+      bounds: { x: 0, y: 0, w: 200, h: 100 },
+    }
+    const runtime = new MockSimRuntime()
+    runtime.systemPopupsResult = [alert]
+    const app = await Smix.launchApp(bundleId('dev.smix.fixture'), runtime, new MockSelectorResolver().resolve)
+    const popups = await app.systemPopups()
+    expect(popups.length).toBe(1)
+    expect(popups[0]?.identifier).toBe('alert-permission')
+  })
+
+  test('openUrl forwards to runtime', async () => {
+    const runtime = new MockSimRuntime()
+    const app = await Smix.launchApp(bundleId('dev.smix.fixture'), runtime, new MockSelectorResolver().resolve)
+    await app.openUrl('smix://deep/link?id=42')
+    expect(runtime.openUrlCalls).toEqual(['smix://deep/link?id=42'])
+  })
+})
+
+describe('App.launchFresh', () => {
+  test('clearState + clearKeychain', async () => {
+    const runtime = new MockSimRuntime()
+    const app = await Smix.launchApp(bundleId('dev.smix.fixture'), runtime, new MockSelectorResolver().resolve)
+    await app.launchFresh({ clearState: true, clearKeychain: true })
+    expect(runtime.launchFreshCalls.length).toBe(1)
+    const call = runtime.launchFreshCalls[0]!
+    expect(call.bundleId).toBe('dev.smix.fixture')
+    expect(call.clearState).toBe(true)
+    expect(call.clearKeychain).toBe(true)
+    expect(call.appPath).toBeUndefined()
+  })
+
+  test('with appPath override', async () => {
+    const runtime = new MockSimRuntime()
+    const app = await Smix.launchApp(bundleId('dev.smix.fixture'), runtime, new MockSelectorResolver().resolve)
+    await app.launchFresh({ appPath: '/tmp/Reinstall.apk' })
+    expect(runtime.launchFreshCalls[0]?.appPath).toBe('/tmp/Reinstall.apk')
+  })
+
+  test('defaults are false', async () => {
+    const runtime = new MockSimRuntime()
+    const app = await Smix.launchApp(bundleId('dev.smix.fixture'), runtime, new MockSelectorResolver().resolve)
+    await app.launchFresh()
+    const call = runtime.launchFreshCalls[0]!
+    expect(call.clearState).toBe(false)
+    expect(call.clearKeychain).toBe(false)
+  })
+})
+
+describe('App.tapAtCoord', () => {
+  test('valid range', async () => {
+    const runtime = new MockSimRuntime()
+    const app = await Smix.launchApp(bundleId('dev.smix.fixture'), runtime, new MockSelectorResolver().resolve)
+    await app.tapAtCoord(0.5, 0.5)
+    expect(runtime.tapAtNormalizedCalls.length).toBe(1)
+    expect(runtime.tapAtNormalizedCalls[0]).toEqual({ nx: 0.5, ny: 0.5 })
+  })
+
+  test('edge values 0,0 and 1,1', async () => {
+    const runtime = new MockSimRuntime()
+    const app = await Smix.launchApp(bundleId('dev.smix.fixture'), runtime, new MockSelectorResolver().resolve)
+    await app.tapAtCoord(0, 0)
+    await app.tapAtCoord(1, 1)
+    expect(runtime.tapAtNormalizedCalls.length).toBe(2)
+  })
+
+  test('out of range nx throws wrongState', async () => {
+    const runtime = new MockSimRuntime()
+    const app = await Smix.launchApp(bundleId('dev.smix.fixture'), runtime, new MockSelectorResolver().resolve)
+    await expect(app.tapAtCoord(1.5, 0.5)).rejects.toMatchObject({
+      name: 'ExpectationFailure',
+      code: 'wrongState',
+    })
+    expect(runtime.tapAtNormalizedCalls).toEqual([])
+  })
+
+  test('negative ny throws wrongState', async () => {
+    const runtime = new MockSimRuntime()
+    const app = await Smix.launchApp(bundleId('dev.smix.fixture'), runtime, new MockSelectorResolver().resolve)
+    await expect(app.tapAtCoord(0.5, -0.1)).rejects.toMatchObject({
+      code: 'wrongState',
+    })
+  })
+})

package/src/__tests__/AppTapMock.test.ts

@@ -0,0 +1,122 @@
+// v7.5 c1 — App.tap mock-based unit tests.
+//
+// Mirror Kotlin AppTapMockTest + Swift AppTapMockTests. Verifies wire
+// pipeline (snapshot → SelectorResolver → tap synthesize) end-to-end
+// against MockSimRuntime + MockSelectorResolver.
+
+import { describe, expect, test } from 'vitest'
+import {
+  bundleId,
+  ExpectationFailure,
+  literal,
+  MockSelectorResolver,
+  MockSimRuntime,
+  Selector,
+  Smix,
+  type A11yNode,
+} from '../index.js'
+
+describe('App.tap notFound path', () => {
+  test('empty resolver result yields notFound', async () => {
+    const runtime = new MockSimRuntime()
+    const resolver = new MockSelectorResolver()
+    const app = await Smix.launchApp(bundleId('dev.smix.fixture'), runtime, resolver.resolve)
+    await expect(app.tap(Selector.id('btn-missing'))).rejects.toMatchObject({
+      name: 'ExpectationFailure',
+      code: 'notFound',
+    })
+  })
+})
+
+describe('App.tap hit path', () => {
+  test('id hit synthesizes at bounds center', async () => {
+    const button: A11yNode = {
+      rawType: 'button',
+      identifier: 'btn-login',
+      label: 'Sign In',
+      bounds: { x: 100, y: 200, w: 80, h: 40 },
+      enabled: true,
+      visible: true,
+    }
+    const root: A11yNode = {
+      rawType: 'other',
+      bounds: { x: 0, y: 0, w: 393, h: 852 },
+      enabled: true,
+      visible: true,
+      children: [button],
+    }
+    const runtime = new MockSimRuntime({ snapshotResult: root })
+    const resolver = new MockSelectorResolver()
+    resolver.registerHit('{"id":"btn-login"}', 'btn-login')
+    const app = await Smix.launchApp(bundleId('dev.smix.fixture'), runtime, resolver.resolve)
+
+    await app.tap(Selector.id('btn-login'))
+
+    expect(runtime.tapCalls.length).toBe(1)
+    expect(runtime.tapCalls[0]?.x).toBeCloseTo(140, 1)
+    expect(runtime.tapCalls[0]?.y).toBeCloseTo(220, 1)
+  })
+
+  test('label hit synthesizes at center', async () => {
+    const button: A11yNode = {
+      rawType: 'button',
+      identifier: 'btn-foo',
+      label: 'Submit',
+      bounds: { x: 50, y: 600, w: 100, h: 50 },
+      visible: true,
+    }
+    const root: A11yNode = {
+      rawType: 'other',
+      bounds: { x: 0, y: 0, w: 393, h: 852 },
+      visible: true,
+      children: [button],
+    }
+    const runtime = new MockSimRuntime({ snapshotResult: root })
+    const resolver = new MockSelectorResolver()
+    resolver.registerHit('{"label":"Submit"}', 'btn-foo')
+    const app = await Smix.launchApp(bundleId('dev.smix.fixture'), runtime, resolver.resolve)
+
+    await app.tap(Selector.label('Submit'))
+    expect(runtime.tapCalls.length).toBe(1)
+    expect(runtime.tapCalls[0]?.x).toBeCloseTo(100, 1)
+  })
+})
+
+describe('App.tap passes correct selectorJson', () => {
+  test('Rust-compatible untagged shape', async () => {
+    const root: A11yNode = {
+      rawType: 'other',
+      bounds: { x: 0, y: 0, w: 393, h: 852 },
+      visible: true,
+      children: [],
+    }
+    const runtime = new MockSimRuntime({ snapshotResult: root })
+    const resolver = new MockSelectorResolver()
+    const app = await Smix.launchApp(bundleId('dev.smix.fixture'), runtime, resolver.resolve)
+
+    await expect(app.tap(Selector.id('btn-x'))).rejects.toBeInstanceOf(ExpectationFailure)
+
+    expect(resolver.calls.length).toBe(1)
+    expect(resolver.calls[0]?.selectorJson).toBe('{"id":"btn-x"}')
+  })
+})
+
+describe('App.tap resolver error surfaces as ExpectationFailure', () => {
+  test('throws unknown when resolver raises', async () => {
+    const root: A11yNode = {
+      rawType: 'other',
+      bounds: { x: 0, y: 0, w: 393, h: 852 },
+      visible: true,
+      children: [],
+    }
+    const runtime = new MockSimRuntime({ snapshotResult: root })
+    const resolver = new MockSelectorResolver()
+    resolver.throwOnNext = new Error('simulated FFI parse error')
+    const app = await Smix.launchApp(bundleId('dev.smix.fixture'), runtime, resolver.resolve)
+
+    await expect(app.tap(Selector.id('anything'))).rejects.toMatchObject({
+      name: 'ExpectationFailure',
+      code: 'unknown',
+    })
+  })
+})

package/src/__tests__/HttpRunner.test.ts

@@ -0,0 +1,121 @@
+// v7.7 c1 — HttpSimRuntime fetch wire integration tests via injected mock.
+//
+// Verifies:
+//   - resolver POSTs to /select/resolve with treeJson + selectorJson + decodes ids
+//   - labelsResolver POSTs to /select/resolve-labels + decodes labels
+//   - resolveCount POSTs to /select/resolve-count + decodes count
+//   - Wire body shape matches Rust `{treeJson, selectorJson}` contract
+//   - Errors propagate cleanly
+
+import { describe, expect, test } from 'vitest'
+import { HttpSimRuntime, type HttpFetch } from '../HttpRunner.js'
+
+type CapturedRequest = {
+  url: string
+  body: string
+}
+
+/** Build a mock fetch that captures requests and returns a stub JSON body. */
+function mockFetch(stub: unknown, captured: CapturedRequest[]): HttpFetch {
+  return async (url, init) => {
+    captured.push({ url, body: init.body })
+    return {
+      ok: true,
+      status: 200,
+      json: async () => stub,
+      text: async () => JSON.stringify(stub),
+    }
+  }
+}
+
+function failingFetch(): HttpFetch {
+  return async (url) => ({
+    ok: false,
+    status: 500,
+    json: async () => ({}),
+    text: async () => `server error at ${url}`,
+  })
+}
+
+describe('HttpSimRuntime.resolver', () => {
+  test('POSTs to /select/resolve with treeJson + selectorJson', async () => {
+    const captured: CapturedRequest[] = []
+    const runtime = new HttpSimRuntime('http://localhost:14101', mockFetch({ ids: ['btn-a', 'btn-b'] }, captured))
+
+    const ids = await runtime.resolver('{"rawType":"other"}', '{"id":"btn"}')
+
+    expect(ids).toEqual(['btn-a', 'btn-b'])
+    expect(captured.length).toBe(1)
+    expect(captured[0]?.url).toBe('http://localhost:14101/select/resolve')
+    expect(JSON.parse(captured[0]?.body ?? '')).toEqual({
+      treeJson: '{"rawType":"other"}',
+      selectorJson: '{"id":"btn"}',
+    })
+  })
+
+  test('throws on 500', async () => {
+    const runtime = new HttpSimRuntime('http://localhost:14101', failingFetch())
+    await expect(runtime.resolver('{}', '{}')).rejects.toMatchObject({
+      message: expect.stringContaining('HTTP 500'),
+    })
+  })
+})
+
+describe('HttpSimRuntime.labelsResolver (v7.7 c1)', () => {
+  test('POSTs to /select/resolve-labels with treeJson + selectorJson', async () => {
+    const captured: CapturedRequest[] = []
+    const runtime = new HttpSimRuntime(
+      'http://localhost:14101',
+      mockFetch({ labels: ['Item 1', 'Item 2', 'Item 3'] }, captured),
+    )
+
+    const labels = await runtime.labelsResolver('{"rawType":"other"}', '{"label":"Item"}')
+
+    expect(labels).toEqual(['Item 1', 'Item 2', 'Item 3'])
+    expect(captured[0]?.url).toBe('http://localhost:14101/select/resolve-labels')
+    expect(JSON.parse(captured[0]?.body ?? '')).toEqual({
+      treeJson: '{"rawType":"other"}',
+      selectorJson: '{"label":"Item"}',
+    })
+  })
+})
+
+describe('HttpSimRuntime.resolveCount (v7.7 c1)', () => {
+  test('POSTs to /select/resolve-count and decodes count', async () => {
+    const captured: CapturedRequest[] = []
+    const runtime = new HttpSimRuntime(
+      'http://localhost:14101',
+      mockFetch({ count: 7 }, captured),
+    )
+
+    const n = await runtime.resolveCount('{}', '{"role":"button"}')
+
+    expect(n).toBe(7)
+    expect(captured[0]?.url).toBe('http://localhost:14101/select/resolve-count')
+  })
+})
+
+describe('HttpSimRuntime runtime methods wire shape', () => {
+  test('synthesizeTap → POST /input/tap with {x,y}', async () => {
+    const captured: CapturedRequest[] = []
+    const runtime = new HttpSimRuntime('http://localhost:14101', mockFetch({}, captured))
+    await runtime.synthesizeTap(140.5, 220.0)
+    expect(captured[0]?.url).toBe('http://localhost:14101/input/tap')
+    expect(JSON.parse(captured[0]?.body ?? '')).toEqual({ x: 140.5, y: 220.0 })
+  })
+
+  test('launch → POST /sim/launch with {bundleId}', async () => {
+    const captured: CapturedRequest[] = []
+    const runtime = new HttpSimRuntime('http://localhost:14101', mockFetch({}, captured))
+    await runtime.launch('dev.smix.MyApp')
+    expect(captured[0]?.url).toBe('http://localhost:14101/sim/launch')
+    expect(JSON.parse(captured[0]?.body ?? '')).toEqual({ bundleId: 'dev.smix.MyApp' })
+  })
+
+  test('synthesizeTapAtNormalized → POST /input/tap-normalized', async () => {
+    const captured: CapturedRequest[] = []
+    const runtime = new HttpSimRuntime('http://localhost:14101', mockFetch({}, captured))
+    await runtime.synthesizeTapAtNormalized(0.5, 0.5)
+    expect(captured[0]?.url).toBe('http://localhost:14101/input/tap-normalized')
+  })
+})