peachsim 0.1.1635 → 0.1.1640

package/cli/commands/inspect.ts

@@ -1,6 +1,7 @@
 // peach inspect — dump node tree, accessibility info, query nodes
 // connects to the peach WS bridge (no Playwright)
 
+import { Script } from 'node:vm'
 import { getCliInspectVerbMeta } from '@peach/skills/cli'
 import { renderCliCommandHelp, renderCliGroupHelp } from '@peach/skills/cli/renderers'
 import { DEFAULT_SOOTSIM_BRIDGE_PORT } from '../../src/bridge-constants'
@@ -194,6 +195,8 @@ async function performSingleStep(
   }
 }
 
+// runs after a command already spent its whole budget, so an explicit --timeout
+// must not make the liveness check wait that long a second time
 async function probeSimResponsive(bridge: WsBridge): Promise<boolean> {
   try {
     await bridge.send({ type: 'evaluate', code: '1' }, { timeoutMs: 3000 })
@@ -210,6 +213,18 @@ async function reportMissingTarget(
   verb: 'tap' | 'double-tap' | 'long-press',
   target: { mode: 'testid' | 'text'; value: string },
 ): Promise<void> {
+  if (target.mode === 'testid') {
+    // the tree can hold the id while the engine has no point to press: the node
+    // is not painted yet, or was replaced since the query. say so, so the
+    // suggestion list never names the id that was just reported missing.
+    const exact = await inspectFind(bridge, { testId: target.value }).catch(() => null)
+    if (exact?.result) {
+      console.error(
+        `  found ${target.value} in the tree but it has no tap target yet; it may be unpainted, hidden or covered: wait for it with peach wait selector ${target.value}`,
+      )
+      return
+    }
+  }
   console.error(`  not found: ${target.value}`)
   if (target.mode !== 'testid') return
   const byText = await inspectFind(bridge, { text: target.value }).catch(() => null)
@@ -858,11 +873,10 @@ async function waitForKeyboardVisible(
 }
 
 /**
- * keys for a CPU simulator. it has no keyboard bridge to probe and refuses the
- * `keyboard` command, so its `perform` presses each character against
- * whatever holds focus and fails the batch when nothing does.
+ * dispatch through the shared input executor, which checks the requested
+ * node identity before targeted typing and carries refusals out of the CLI.
  */
-async function performCloudKeys(
+async function performKeys(
   bridge: WsBridge,
   steps: Array<Extract<PerformStep, { type: 'type' | 'typeInto' | 'key' }>>,
   actionLabel: string,
@@ -2462,7 +2476,7 @@ export async function runInspect(args: string[], opts: InspectOptions) {
             console.error('  type-into requires a resolved text input node identity')
             peachExit(1)
           }
-          const typed = await performCloudKeys(
+          const typed = await performKeys(
             bridge,
             [{ type: 'typeInto', text, nodeId }],
             'type-into',
@@ -2500,6 +2514,7 @@ export async function runInspect(args: string[], opts: InspectOptions) {
             return {
               cx: n.absolutePosition.x + (n.layout.width || 0) / 2,
               cy: n.absolutePosition.y + (n.layout.height || 0) / 2,
+              nodeId: n.nodeId,
               id: n.id,
               testID: n.testID,
               type: n.type,
@@ -2514,7 +2529,13 @@ export async function runInspect(args: string[], opts: InspectOptions) {
           peachExit(1)
         }
         if (!tiPayload.isTextInput) {
-          console.error(`  warning: ${targetId} is not a text input (isTextInput: false)`)
+          console.error(`  ${targetId} is not a text input (isTextInput: false)`)
+          peachExit(1)
+        }
+        const nodeId: unknown = tiPayload.nodeId
+        if (typeof nodeId !== 'number' || !Number.isSafeInteger(nodeId) || nodeId === 0) {
+          console.error('  type-into requires a resolved text input node identity')
+          peachExit(1)
         }
         // step 2: tap to focus
         const tapResult = await bridge.send({
@@ -2522,12 +2543,17 @@ export async function runInspect(args: string[], opts: InspectOptions) {
           x: tiPayload.cx,
           y: tiPayload.cy,
           target: {
+            nodeId,
             id: tiPayload.id ?? targetId,
             testID: tiPayload.testID ?? targetId,
             text: null,
             type: tiPayload.type ?? null,
           },
         })
+        if (!isTapSuccess(tapResult)) {
+          console.error(`  type-into could not tap ${targetId}`)
+          peachExit(1)
+        }
         const targetSecureTextEntry = tiPayload.secureTextEntry === true
         const keyboardState = await waitForKeyboardVisible(bridge, 1000, {
           targetId,
@@ -2558,38 +2584,26 @@ export async function runInspect(args: string[], opts: InspectOptions) {
             peachExit(1)
           }
         }
-        // step 3: clear existing text then type through the visible keyboard.
-        // count the field's value, masked while secure. the node's described
-        // text is its placeholder while empty, and the keyboard spec's text
-        // follows only predictive candidates.
-        const drawnCharacters = async () => {
-          const count: unknown = await bridge.send({
-            type: 'evaluate',
-            code: `(async () => {
-              const text = await window.__sootsimTest?.getTextInputValue(${tiArg})
-              return text ? [...new Intl.Segmenter().segment(text)].length : 0
-            })()`,
-          })
-          if (typeof count !== 'number') {
-            console.error(`  could not read the current text of ${targetId}`)
-            peachExit(1)
-          }
-          return count
-        }
-        const existingCharacters = await drawnCharacters()
-        for (let i = 0; i < existingCharacters; i++) {
-          await bridge.send({ type: 'keyboard', action: 'press', text: 'delete' })
-        }
-        // backspace clears only what precedes the caret the tap placed
-        if (existingCharacters > 0 && (await drawnCharacters()) > 0) {
-          console.error(
-            `  type-into could not clear ${targetId}: text remains after the caret the tap placed`,
-          )
+        // type at the live selection through the same guarded operation as
+        // chained and cloud typing; clearing first changes controlled values.
+        const typed = await performKeys(
+          bridge,
+          [{ type: 'typeInto', text, nodeId }],
+          'type-into',
+        )
+        const receipt: unknown = typed.steps[0]?.value
+        if (
+          !receipt ||
+          typeof receipt !== 'object' ||
+          typeof Reflect.get(receipt, 'secureTextEntry') !== 'boolean'
+        ) {
+          console.error('  type-into did not return its matched input secure state')
           peachExit(1)
         }
-        await bridge.send({ type: 'keyboard', action: 'type', text })
         const secureTextEntry =
-          targetSecureTextEntry || isSecureKeyboardState(keyboardState as any)
+          targetSecureTextEntry ||
+          Reflect.get(receipt, 'secureTextEntry') === true ||
+          isSecureKeyboardState(keyboardState as any)
         const outputText = secureTextEntry
           ? SECURE_TEXT_REDACTION
           : redactTextForKeyboardState(text, keyboardState as any)
@@ -2629,7 +2643,7 @@ export async function runInspect(args: string[], opts: InspectOptions) {
           peachExit(1)
         }
         if (bridge.plane === 'cloud') {
-          await performCloudKeys(bridge, [{ type: 'type', text }], 'type')
+          await performKeys(bridge, [{ type: 'type', text }], 'type')
           await recordInspectAction(
             'inspect type',
             { inputText: text },
@@ -2663,7 +2677,7 @@ export async function runInspect(args: string[], opts: InspectOptions) {
           peachExit(1)
         }
         if (bridge.plane === 'cloud') {
-          await performCloudKeys(bridge, [{ type: 'key', key: name }], 'key')
+          await performKeys(bridge, [{ type: 'key', key: name }], 'key')
         } else {
           await requireVisualKeyboard(bridge, 'key')
           await bridge.send({ type: 'keyboard', action: 'press', text: name })
@@ -2680,7 +2694,7 @@ export async function runInspect(args: string[], opts: InspectOptions) {
           peachExit(1)
         }
         if (bridge.plane === 'cloud') {
-          await performCloudKeys(
+          await performKeys(
             bridge,
             keys.map((key) => ({ type: 'key' as const, key })),
             'key-sequence',
@@ -3717,13 +3731,17 @@ export async function runInspect(args: string[], opts: InspectOptions) {
         // wrap in async to support await in worker mode. no identifier
         // rewriting — the snippet runs verbatim so tokens like `root`,
         // `debug`, `test` refer to whatever the user actually typed.
-        // multi-statement snippets need a block body: the bare expression
-        // form terminates at the first `;` (Unexpected token).
+        // compile without executing to distinguish expressions from statements;
+        // punctuation inside callbacks, literals and comments is not a separator.
         let expandedCode = code
         if (!expandedCode.startsWith('(async')) {
-          expandedCode = /[;\n]/.test(expandedCode)
-            ? `(async () => { ${expandedCode} })()`
-            : `(async () => ${expandedCode})()`
+          expandedCode = `(async () => (\n${code}\n))()`
+          try {
+            new Script(expandedCode)
+          } catch (error) {
+            if (!(error instanceof SyntaxError)) throw error
+            expandedCode = `(async () => {\n${code}\n})()`
+          }
         }
         const result = await bridge.send({ type: 'evaluate', code: expandedCode })
         printJson(result)
@@ -3959,11 +3977,11 @@ export async function runInspect(args: string[], opts: InspectOptions) {
           case 'start': {
             const result = await bridge.send({
               type: 'evaluate',
-              code: `(() => {
+              code: `(async () => {
                 if (!window.__sootsimShellPerf) {
                   return { error: 'shell frame profile unavailable (__sootsimShellPerf missing on the page)' }
                 }
-                window.__sootsimShellPerf.start()
+                await window.__sootsimShellPerf.start()
                 return { started: true }
               })()`,
             })
@@ -4038,7 +4056,7 @@ export async function runInspect(args: string[], opts: InspectOptions) {
                 if (!window.__sootsimShellPerf) {
                   return { error: 'shell frame profile unavailable (__sootsimShellPerf missing on the page)' }
                 }
-                window.__sootsimShellPerf.start()
+                await window.__sootsimShellPerf.start()
                 // give a frame for profiling to engage before the event
                 await new Promise(r => requestAnimationFrame(() => r(undefined)))
                 window.dispatchEvent(new Event('${eventName}'))
@@ -4626,7 +4644,7 @@ export async function runInspect(args: string[], opts: InspectOptions) {
     // re-incurs the full per-command timeout. three sequential probes turn a
     // single 15s timeout into ~60s of apparent hang (QA F19-1). there is
     // nothing useful to fetch from a sim that just timed out, so skip them.
-    const timedOut = /^command timed out after (\d+)s$/.exec(message)
+    const timedOut = /^command timed out after (\d+(?:\.\d+)?)s$/.exec(message)
     // a disconnected bridge is genuinely gone; recover is right and probing
     // it would just re-incur a full timeout. no bridge at all means there is
     // no sim to recover, only one to open.

package/cli/commands/preview.ts

@@ -88,7 +88,7 @@ export async function runPreview(args: string[]): Promise<number> {
       bundleSizeBytes: artifact.bytes.byteLength,
       bundleContentType: 'application/javascript',
       bundleEncoding: 'br',
-      bundleMinified: true,
+      bundleMinified: artifact.minified,
       bundleOrigin: null,
       entry: null,
       isTransformed: false,

package/cli/commands/record.ts

@@ -76,18 +76,41 @@ const STORE_RECORD_START_TIMEOUT_MS = 90_000
 // (bitmap-capture.ts), so recovery is simply to retry.
 const CAPTURE_STEP_ENCODE_BUDGET_MS = 30_000
 
+// waits out a recording's duration as an in-flight bridge command. the host
+// closes a cli socket that sends nothing for 60s, but never one with a command
+// awaiting its sim, so a client-side sleep through a long capture dropped the
+// connection before the encode/flush step could use it.
+async function holdCapture(bridge: WsBridge, durationMs: number) {
+  await bridge.send(
+    { type: 'evaluate', code: `new Promise((r) => setTimeout(r, ${durationMs}))` },
+    { timeoutMs: durationMs + CAPTURE_STEP_ENCODE_BUDGET_MS },
+  )
+}
+
+// an explicit --timeout is the step's budget. a step that records for the
+// whole duration (a gif) gets that duration on top of it.
+function captureStepTimeoutMs(
+  parsed: ParsedBridgeCliArgs,
+  durationMs: number,
+  spansCapture: boolean,
+): number {
+  if (!parsed.explicitTimeout)
+    return Math.max(20_000, durationMs + CAPTURE_STEP_ENCODE_BUDGET_MS)
+  return spansCapture ? durationMs + parsed.commandTimeoutMs : parsed.commandTimeoutMs
+}
+
 async function evalCaptureStep<T>(
   bridge: WsBridge,
   code: string,
   step: string,
   durationMs: number,
+  timeoutMs: number,
 ): Promise<T> {
-  const timeoutMs = Math.max(20_000, durationMs + CAPTURE_STEP_ENCODE_BUDGET_MS)
   try {
     return (await bridge.send({ type: 'evaluate', code }, { timeoutMs })) as T
   } catch (err) {
     const msg = err instanceof Error ? err.message : String(err)
-    if (/^command timed out after \d+s$/.test(msg)) {
+    if (/^command timed out after \d+(?:\.\d+)?s$/.test(msg)) {
       console.error(
         `  ${step} stalled — the render host did not finish within ` +
           `${Math.round(timeoutMs / 1000)}s; it is likely contended or wedged.\n` +
@@ -242,6 +265,8 @@ export async function runRecord(args: string[], opts: RecordOptions) {
 
   const parsed = parseBridgeCliArgs(args, {
     port: opts.port,
+    // an explicit --timeout wins over the default
+    commandTimeoutMs: 60_000,
     stripBooleanFlags: ['--no-shell', '--shell-only', '--open', '--lockstep'],
     stripValueFlags: [
       '--mode',
@@ -356,7 +381,7 @@ export async function runRecord(args: string[], opts: RecordOptions) {
       originOverride,
       allowGitHubAuth: true,
     })
-    const bridge = createBridgeFromParsed({ ...parsed, commandTimeoutMs: 60_000 })
+    const bridge = createBridgeFromParsed(parsed)
     try {
       await assertStoreBridgesAvailable(bridge)
       await assertGuestBundleLoaded(bridge, mode)
@@ -376,7 +401,7 @@ export async function runRecord(args: string[], opts: RecordOptions) {
         peachExit(1)
       }
       console.log(`  recording ${mode} for ${durationSec}s`)
-      await new Promise((r) => setTimeout(r, durationMs))
+      await holdCapture(bridge, durationMs)
       await evalStoreStop(bridge)
       const result = await pollStoreUpload(bridge)
       handleStoreUploadResult(result, openAfter, mode)
@@ -398,7 +423,7 @@ export async function runRecord(args: string[], opts: RecordOptions) {
     )
   }
 
-  const bridge = createBridgeFromParsed({ ...parsed, commandTimeoutMs: 60_000 })
+  const bridge = createBridgeFromParsed(parsed)
   try {
     await assertRecorderAvailable(bridge)
     await assertTabVisibleForCapture(bridge)
@@ -434,7 +459,7 @@ export async function runRecord(args: string[], opts: RecordOptions) {
         console.error(`  frame capture start failed: ${start.error ?? 'unknown error'}`)
         peachExit(1)
       }
-      await new Promise((r) => setTimeout(r, durationMs))
+      await holdCapture(bridge, durationMs)
       const deadline = Date.now() + Math.max(5_000, durationMs)
       // frames come back a few at a time: one message holding every base64 png
       // exceeds the bridge socket's message cap and closes it.
@@ -490,6 +515,7 @@ export async function runRecord(args: string[], opts: RecordOptions) {
         }${layers ? `, layers: ${JSON.stringify(layers)}` : ''} })`,
         'gif encode',
         durationMs,
+        captureStepTimeoutMs(parsed, durationMs, true),
       )
       if (!result) {
         console.error('  gif capture returned no frames')
@@ -523,6 +549,7 @@ export async function runRecord(args: string[], opts: RecordOptions) {
         `window.__sootsimRecorder.start(${JSON.stringify(startOpts)})`,
         `${format} start`,
         durationMs,
+        captureStepTimeoutMs(parsed, durationMs, false),
       )
     if (!startResult.ok) {
       console.error(`  start failed: ${startResult.error ?? 'unknown error'}`)
@@ -543,7 +570,7 @@ export async function runRecord(args: string[], opts: RecordOptions) {
     }
 
     console.log(`  recording ${format} for ${durationSec}s → ${out}`)
-    await new Promise((r) => setTimeout(r, durationMs))
+    await holdCapture(bridge, durationMs)
 
     const stopResult: {
       ok: boolean
@@ -557,6 +584,7 @@ export async function runRecord(args: string[], opts: RecordOptions) {
       `window.__sootsimRecorder.stop()`,
       `${format} encode/flush`,
       durationMs,
+      captureStepTimeoutMs(parsed, durationMs, false),
     )
     if (!stopResult.ok) {
       console.error(`  stop failed: ${stopResult.error ?? 'unknown error'}`)
@@ -590,11 +618,11 @@ async function probeSim(bridge: WsBridge, code: string): Promise<boolean> {
   try {
     return await bridge.send(
       { type: 'evaluate', code },
-      { timeoutMs: SIM_PROBE_TIMEOUT_MS },
+      { defaultTimeoutMs: SIM_PROBE_TIMEOUT_MS },
     )
   } catch (err) {
     const msg = err instanceof Error ? err.message : String(err)
-    if (/^command timed out after \d+s$/.test(msg)) {
+    if (/^command timed out after \d+(?:\.\d+)?s$/.test(msg)) {
       console.error(
         '  sim did not respond — it is connected to the bridge but has not\n' +
           '  loaded an app (or its page is unresponsive). run `peach list`\n' +
@@ -786,7 +814,7 @@ async function refuseLiveRecording(parsed: ParsedBridgeCliArgs) {
     ...parsed,
     simId: existing.simId ?? parsed.simId,
     simIdSource: existing.simId ? 'saved' : parsed.simIdSource,
-    commandTimeoutMs: 8_000,
+    commandTimeoutMs: parsed.explicitTimeout ? parsed.commandTimeoutMs : 8_000,
   })
   try {
     const sims = await bridge.listSims()
@@ -808,8 +836,12 @@ async function refuseLiveRecording(parsed: ParsedBridgeCliArgs) {
 }
 
 async function recordStart(args: string[], opts: RecordOptions) {
+  const mode = parseMode(valueOf(args, '--mode'))
   const parsed = parseBridgeCliArgs(args, {
     port: opts.port,
+    // an explicit --timeout wins over the per-mode default
+    commandTimeoutMs:
+      mode === 'live' || mode === 'combined' ? STORE_RECORD_START_TIMEOUT_MS : 15_000,
     stripBooleanFlags: ['--no-shell', '--shell-only', '--lockstep'],
     stripValueFlags: [
       '--mode',
@@ -823,7 +855,6 @@ async function recordStart(args: string[], opts: RecordOptions) {
     ],
   })
   await refuseLiveRecording(parsed)
-  const mode = parseMode(valueOf(args, '--mode'))
   const layers: 'tenant' | 'shell' | undefined = args.includes('--shell-only')
     ? 'shell'
     : args.includes('--no-shell')
@@ -840,11 +871,19 @@ async function recordStart(args: string[], opts: RecordOptions) {
   const fps = Number(valueOf(args, '--fps') ?? '30')
   const repoScope = readRepoScope(args)
 
-  const bridge = createBridgeFromParsed({
-    ...parsed,
-    commandTimeoutMs:
-      mode === 'live' || mode === 'combined' ? STORE_RECORD_START_TIMEOUT_MS : 15_000,
-  })
+  // the session is recorded before the engine is asked to start, so a start
+  // that times out on this side while the engine records stays stoppable. a
+  // refusal clears it.
+  const session: RecordingState = {
+    simId: parsed.simId ?? null,
+    mode,
+    format,
+    fps,
+    layers,
+    startedAt: new Date().toISOString(),
+  }
+
+  const bridge = createBridgeFromParsed(parsed)
   try {
     if (mode === 'live' || mode === 'combined') {
       // live mode captures events only — --no-shell / --shell-only have no
@@ -869,6 +908,7 @@ async function recordStart(args: string[], opts: RecordOptions) {
       await assertGuestBundleLoaded(bridge, mode)
       if (mode === 'combined') await assertTabVisibleForCapture(bridge)
       await injectPreviewSessionAuth(bridge, valueOf(args, '--origin'), repoScope)
+      writeRecordingState(session)
       const started = await evalStoreStart(
         bridge,
         mode,
@@ -876,6 +916,7 @@ async function recordStart(args: string[], opts: RecordOptions) {
         mode === 'combined' ? layers : undefined,
       )
       if (!started.ok) {
+        clearRecordingState()
         console.error(
           `  start failed: recording store refused to start (${mode})` +
             (started.error ? `: ${started.error}` : ''),
@@ -898,23 +939,17 @@ async function recordStart(args: string[], opts: RecordOptions) {
       } = { format, fps }
       if (layers) startOpts.layers = layers
       if (lockstep) startOpts.lockstep = true
+      writeRecordingState(session)
       const result: { ok: boolean; error?: string } = await bridge.send({
         type: 'evaluate',
         code: `window.__sootsimRecorder.start(${JSON.stringify(startOpts)})`,
       })
       if (!result.ok) {
+        clearRecordingState()
         console.error(`  start failed: ${result.error ?? 'unknown error'}`)
         peachExit(1)
       }
     }
-    writeRecordingState({
-      simId: parsed.simId ?? null,
-      mode,
-      format,
-      fps,
-      layers,
-      startedAt: new Date().toISOString(),
-    })
     if (mode === 'video') {
       console.log(
         `  recording ${format} @ ${fps}fps${layers ? ` (${layers})` : ''} — run \`peach record stop --output <path>\` when done`,
@@ -936,7 +971,7 @@ async function recordPreludeStart(args: string[], opts: RecordOptions) {
     stripValueFlags: ['--origin'],
   })
   await refuseLiveRecording(parsed)
-  const bridge = createBridgeFromParsed({ ...parsed, commandTimeoutMs: 15_000 })
+  const bridge = createBridgeFromParsed(parsed)
   try {
     await assertStoreBridgesAvailable(bridge)
     await assertTabVisibleForCapture(bridge)
@@ -1069,8 +1104,8 @@ async function recordStatus(args: string[], opts: RecordOptions) {
   }
   // no `record start` session — but an atomic run or the rail button may
   // still be recording. ask the engine before claiming nothing is happening.
-  const parsed = parseBridgeCliArgs(args, { port: opts.port })
-  const bridge = createBridgeFromParsed({ ...parsed, commandTimeoutMs: 8_000 })
+  const parsed = parseBridgeCliArgs(args, { port: opts.port, commandTimeoutMs: 8_000 })
+  const bridge = createBridgeFromParsed(parsed)
   try {
     const engineState = await probeEngineRecordingState(bridge)
     if (
@@ -1111,11 +1146,11 @@ async function recordCancel(args: string[], opts: RecordOptions) {
   if (!state) {
     // no `record start` session to cancel — but check the engine so we
     // don't falsely claim nothing is happening while an atomic run records.
-    const probeParsed = parseBridgeCliArgs(args, { port: opts.port })
-    const probeBridge = createBridgeFromParsed({
-      ...probeParsed,
+    const probeParsed = parseBridgeCliArgs(args, {
+      port: opts.port,
       commandTimeoutMs: 8_000,
     })
+    const probeBridge = createBridgeFromParsed(probeParsed)
     try {
       const engineState = await probeEngineRecordingState(probeBridge)
       if (
@@ -1152,18 +1187,14 @@ async function recordCancel(args: string[], opts: RecordOptions) {
     }
     return
   }
-  const parsed = parseBridgeCliArgs(args, { port: opts.port })
+  const parsed = parseBridgeCliArgs(args, { port: opts.port, commandTimeoutMs: 15_000 })
   noteSimMismatch(parsed.simId, state)
   // the recorder (and its buffered blob) lives in the page of the sim the
   // recording was *started* on — `state.simId` wins over the requested
   // --sim, otherwise cancel would stop an idle recorder on the wrong sim
   // and leave the real recording running (F11-1).
   const simId = state.simId ?? parsed.simId ?? undefined
-  const bridge = createBridgeFromParsed({
-    ...parsed,
-    simId,
-    commandTimeoutMs: 15_000,
-  })
+  const bridge = createBridgeFromParsed({ ...parsed, simId })
   try {
     if (state.mode === 'live' || state.mode === 'combined') {
       await bridge.send({
@@ -1194,6 +1225,9 @@ async function recordStop(args: string[], opts: RecordOptions) {
 
   const parsed = parseBridgeCliArgs(args, {
     port: opts.port,
+    // an explicit --timeout wins over the per-mode default
+    commandTimeoutMs:
+      state.mode === 'live' || state.mode === 'combined' ? UPLOAD_TIMEOUT_MS : 60_000,
     stripBooleanFlags: ['--open'],
     stripValueFlags: ['--output'],
   })
@@ -1204,15 +1238,17 @@ async function recordStop(args: string[], opts: RecordOptions) {
   const simId = state.simId ?? parsed.simId ?? undefined
   const openAfter = args.includes('--open')
 
-  const bridge = createBridgeFromParsed({
-    ...parsed,
-    simId,
-    commandTimeoutMs:
-      state.mode === 'live' || state.mode === 'combined' ? UPLOAD_TIMEOUT_MS : 60_000,
-  })
+  const bridge = createBridgeFromParsed({ ...parsed, simId })
   try {
     if (state.mode === 'live' || state.mode === 'combined') {
-      await evalStoreStop(bridge)
+      if (!(await evalStoreStop(bridge))) {
+        clearRecordingState()
+        console.error(
+          `  stop failed: the ${state.mode} start still in flight never began a take, so there is nothing to upload.\n` +
+            '  run `peach record start` again.',
+        )
+        peachExit(1)
+      }
       const result = await pollStoreUpload(bridge)
       clearRecordingState()
       handleStoreUploadResult(result, openAfter, state.mode)
@@ -1235,7 +1271,17 @@ async function recordStop(args: string[], opts: RecordOptions) {
     })
     if (!stopResult.ok) {
       console.error(`  stop failed: ${stopResult.error ?? 'unknown error'}`)
-      clearRecordingState()
+      // a start that timed out on the client can still be on its way to the
+      // engine. keep the state so a later stop finds the recording instead of
+      // leaving it running with nothing to stop it.
+      if (stopResult.error === 'not recording') {
+        console.error(
+          '  the start may not have reached the engine yet. retry `peach record stop`,\n' +
+            '  or run `peach record cancel` to give up on it.',
+        )
+      } else {
+        clearRecordingState()
+      }
       peachExit(1)
     }
     if (!stopResult.size) {
@@ -1396,11 +1442,15 @@ async function evalStoreStart(
   return { ok: false, error: error ?? null }
 }
 
-async function evalStoreStop(bridge: WsBridge): Promise<void> {
-  await bridge.send({
+// the engine stop waits for a start still in flight. false means that start
+// never began a take, so no upload will come and the store's last one belongs
+// to an earlier take.
+async function evalStoreStop(bridge: WsBridge): Promise<boolean> {
+  const stopped: boolean | null = await bridge.send({
     type: 'evaluate',
-    code: `void window.SootSim.bridges.stopRecording()`,
+    code: `window.SootSim.bridges.stopRecording()`,
   })
+  return stopped !== false
 }
 
 interface StoreUploadResult {

package/cli/commands/swift.ts

@@ -5,6 +5,7 @@ import { WebSocket, WebSocketServer } from 'ws'
 import { resolveContrastBackendOrigin } from '../../src/backend-origin'
 import { produceConfiguredBundle } from '../../src/configured-bundle-producer'
 import { swiftGuestBundle } from '../../src/guest-bundle'
+import { insertNativeAppIdentityFooter } from '../../src/native-app-identity'
 import {
   resolveSwiftModule,
   SWIFT_ENDPOINT_ENV,
@@ -168,7 +169,9 @@ export async function runSwift(
   const packageName = path.basename(packagePath)
   const appInfo = host.swiftProjectAppInfo(packagePath)
   const guestSource = swiftGuestBundle(packageName)
-  let guest = guestSource
+  const withIdentity = (source: string) =>
+    appInfo.identity ? insertNativeAppIdentityFooter(source, appInfo.identity) : source
+  let guest = withIdentity(guestSource)
   const controller = new AbortController()
   const resources: OpenCommandResources = {}
   let metadata: (SwiftEntryModuleArgs & { hmrPath: string }) | null = null
@@ -192,7 +195,9 @@ export async function runSwift(
         try {
           const config = await loadRNXAppConfig(appProject)
           host.configureSwiftStandinBehavior(packagePath, config)
-          guest = await produceConfiguredBundle(guestSource, config, new Set())
+          guest = withIdentity(
+            await produceConfiguredBundle(guestSource, config, new Set()),
+          )
           const next = await host.swiftPackageMetadata(
             packagePath,
             packageName,
@@ -348,7 +353,8 @@ export async function runSwift(
     console.log(`  Swift preview host: ${origin}`)
     await refresh()
     controller.signal.throwIfAborted()
-    if (!metadata || compileError) throw new Error(compileError)
+    // refresh already printed the error
+    if (!metadata || compileError) throw new Error('Swift compilation failed, see above')
     if (opts.device) openArgs.push('--device', opts.device)
     if (opts.driver) openArgs.push('--driver', opts.driver)
     if (opts.headless) openArgs.push('--headless')