peachsim 0.1.899 → 0.1.908

package/README.md

@@ -215,6 +215,14 @@ bridge always addresses the **shell worker**, never an undifferentiated sim.
   own dev server. It is used to build the engine/shell and to load external RN
   apps — it is **not** the published `peachsim/vite` export.
 
+Preview uploads retain one response snapshot in the simulator and transfer
+its base64 bodies in bounded slices, including authenticated API responses.
+The CLI removes that temporary snapshot after transfer. A completed upload
+publishes its trace URL through a fresh bridge connection because compression
+and HTTP upload can outlive the interactive socket's idle lifetime.
+The finished test duration uses the last execution status timestamp; publishing
+the later trace URL notifies viewers without extending that duration.
+
 ## Key components
 
 | component | role | key files |

package/cli/app-fonts.ts

@@ -4,6 +4,7 @@ import { createRequire } from 'node:module'
 import path from 'node:path'
 import {
   expoFontPathsFromPlugins,
+  nativeLinkedFontSpecsFromPaths,
   metroFontSpecsFromPaths,
   type ConfigPluginFontSpec,
 } from 'peach-engine/engine/config-plugin-fonts'
@@ -27,7 +28,14 @@ export function discoverNativeLinkedAppFonts(opts: {
 }): DiscoveredAppFontSpec[] {
   const metroOrigin = loopbackOriginOf(opts.bundleUrl)
   if (!metroOrigin) return []
+  return metroFontSpecsFromPaths(discoverNativeLinkedAppFontPaths(opts), metroOrigin)
+}
 
+function discoverNativeLinkedAppFontPaths(opts: {
+  projectDir: string
+  platform?: string
+  bundleUrl?: string
+}): string[] {
   const project = resolveAppProject(opts.projectDir)
   const selectedAppDir = project?.appDir ?? null
   if (!selectedAppDir) return []
@@ -142,7 +150,7 @@ export function discoverNativeLinkedAppFonts(opts: {
       // the bundle path is the entry relative to metro's root, so a bundle at
       // /apps/app/index.bundle served for /repo/apps/app puts that root at /repo.
       const bundleDir = path.posix
-        .dirname(new URL(opts.bundleUrl).pathname)
+        .dirname(opts.bundleUrl ? new URL(opts.bundleUrl).pathname : '/')
         .replace(/^\/+/, '')
       const appRelativeDir = bundleDir.split('/').join(path.sep)
       const metroRootCandidates = [selectedAppDir]
@@ -258,7 +266,24 @@ export function discoverNativeLinkedAppFonts(opts: {
     } catch {}
   }
 
-  return metroFontSpecsFromPaths(fontPaths, metroOrigin)
+  return [...new Set(fontPaths)]
+}
+
+// prebuilt guests cannot discover files linked into their native binary.
+// carry the same declarations as self-contained asset urls beside their JS.
+export function readNativeLinkedAppFontsWire(opts: {
+  projectDir: string
+  platform?: string
+}): string {
+  if (!resolveAppProject(opts.projectDir)) {
+    throw new Error(`native font project is unavailable: ${opts.projectDir}`)
+  }
+  return encodeAppFontsWire(
+    nativeLinkedFontSpecsFromPaths(discoverNativeLinkedAppFontPaths(opts), (fontPath) => {
+      const bytes = fs.readFileSync(path.resolve(opts.projectDir, fontPath))
+      return `data:${fontContentType(fontPath)};base64,${bytes.toString('base64')}`
+    }),
+  )
 }
 
 // resolve a metro dev server's project root. Expo's middleware advertises it

package/cli/commands/box/bundle-plane.ts

@@ -10,6 +10,7 @@
 
 import {
   PREBUILT_BUNDLE_DEVICE_PATH,
+  prebuiltAppFontsPartPath,
   PREBUILT_BUNDLE_PART_BYTES,
   prebuiltBundlePartPath,
 } from '@peach/box/template'
@@ -19,16 +20,24 @@ export class BundleFilePlane implements ProjectFilePlane {
   private readonly parts = new Map<string, Uint8Array>()
   private readonly entries = new Map<string, ProjectFileMeta>()
 
-  constructor(bundle: Uint8Array, device: string | null) {
+  constructor(bundle: Uint8Array, device: string | null, appFonts = '') {
     if (bundle.byteLength === 0) throw new Error('a Box bundle cannot be empty')
+    if (appFonts)
+      this.recordParts(new TextEncoder().encode(appFonts), prebuiltAppFontsPartPath)
     if (device) this.record(PREBUILT_BUNDLE_DEVICE_PATH, new TextEncoder().encode(device))
+    this.recordParts(bundle, prebuiltBundlePartPath)
+  }
+
+  private recordParts(content: Uint8Array, partPath: (index: number) => string): void {
     for (
       let offset = 0, index = 0;
-      offset < bundle.byteLength;
+      offset < content.byteLength;
       offset += PREBUILT_BUNDLE_PART_BYTES, index++
     ) {
-      const part = bundle.subarray(offset, offset + PREBUILT_BUNDLE_PART_BYTES)
-      this.record(prebuiltBundlePartPath(index), part)
+      this.record(
+        partPath(index),
+        content.subarray(offset, offset + PREBUILT_BUNDLE_PART_BYTES),
+      )
     }
   }
 

package/cli/commands/box.ts

@@ -30,8 +30,10 @@ import {
   heartbeatSession,
   resolveCloudBoxReference,
 } from 'peach-cloud-box/client'
+import { getRuntimePlatform, isDeviceModel } from 'peach-engine/settings/devices'
 import { readDefaultBox, writeDefaultBox } from '../../src/home-paths'
 import { rnxPublicBrand } from '../../src/public-brand'
+import { readNativeLinkedAppFontsWire } from '../app-fonts'
 import { authHeaderOrExit, cloudAccountIdOrExit, type CliAuth } from '../auth'
 import { produceCloudBoxArtifact, type CloudBoxArtifactProduction } from '../cloud-client'
 import { openUrl } from '../open-url'
@@ -523,6 +525,7 @@ function cloudBoxClient(options: {
  */
 export async function createPrebuiltBundleBox(options: {
   bundle: Uint8Array
+  nativeProjectDir?: string
   // the simulator's device model, or null for the Box page's default
   device: string | null
   name: string
@@ -536,7 +539,19 @@ export async function createPrebuiltBundleBox(options: {
     name: options.name,
     stack: prebuiltBundleBoxTemplate.stack,
     template: BOX_TEMPLATES.resolve({ name: prebuiltBundleBoxTemplate.name }).provenance,
-    source: new BundleFilePlane(options.bundle, options.device),
+    source: new BundleFilePlane(
+      options.bundle,
+      options.device,
+      options.nativeProjectDir
+        ? readNativeLinkedAppFontsWire({
+            projectDir: options.nativeProjectDir,
+            platform:
+              options.device && isDeviceModel(options.device)
+                ? getRuntimePlatform(options.device)
+                : 'ios',
+          })
+        : '',
+    ),
     ...(options.secrets ? { secrets: options.secrets } : {}),
   })
 }
@@ -576,6 +591,11 @@ async function runCloudBoxCreate(
   // --bundle IS the template choice: the box runs an app that is already
   // built, so naming a second template would ask for two different boxes.
   const bundlePath = flag(args, 'bundle')
+  const nativeProjectDir = flag(args, 'native-project')
+  if (nativeProjectDir && !bundlePath) {
+    console.error(`  ${peach} box create: --native-project requires --bundle.`)
+    return 1
+  }
   const namedTemplate = flag(args, 'template')
   if (bundlePath && namedTemplate) {
     console.error(
@@ -687,6 +707,7 @@ async function runCloudBoxCreate(
         ? await createPrebuiltBundleBox({
             ...connection,
             bundle: source.bundle,
+            nativeProjectDir,
             device: null,
             name,
             ...(secrets ? { secrets } : {}),

package/cli/commands/control.ts

@@ -241,19 +241,30 @@ export async function ensureBridgeForOpen(
   }
 
   const { executable, prefixArgs } = rnxSelfInvocation()
-  const child = spawn(
-    executable,
-    [...prefixArgs, 'serve', '--quiet', '--port', String(preferredPort)],
-    {
-      detached: true,
-      stdio: 'ignore',
-      // this bridge does not supply the shell, so it needs no runtime updates.
-      env:
-        runtimeSource === 'external'
-          ? { ...process.env, PEACH_UPDATE_CHECK: 'off' }
-          : process.env,
-    },
+  // the bridge outlives open, so it must not hold the command's captured stderr.
+  const bridgeLogPath = path.join(
+    os.tmpdir(),
+    `peach-bridge-${Date.now()}-${process.pid}.log`,
   )
+  const bridgeLogFd = fs.openSync(bridgeLogPath, 'a')
+  let child: ReturnType<typeof spawn>
+  try {
+    child = spawn(
+      executable,
+      [...prefixArgs, 'serve', '--quiet', '--port', String(preferredPort)],
+      {
+        detached: true,
+        stdio: ['ignore', 'ignore', bridgeLogFd],
+        // this bridge does not supply the shell, so it needs no runtime updates.
+        env:
+          runtimeSource === 'external'
+            ? { ...process.env, PEACH_UPDATE_CHECK: 'off' }
+            : process.env,
+      },
+    )
+  } finally {
+    fs.closeSync(bridgeLogFd)
+  }
   if (resources) {
     resources.bridge = child
     resources.port = preferredPort
@@ -298,14 +309,16 @@ export async function ensureBridgeForOpen(
       }
       return selectedPort
     }
-    if (childExit) {
-      throw new Error(`peach bridge exited before becoming ready (exit ${childExit})`)
-    }
+    if (childExit) break
     await sleep(150)
   }
 
+  const reason = childExit
+    ? `peach bridge exited before becoming ready (exit ${childExit})`
+    : `peach bridge did not start within ${Math.round(OPEN_BRIDGE_SPAWN_TIMEOUT_MS / 1000)}s`
+  const bridgeLog = fs.readFileSync(bridgeLogPath, 'utf8').trim().slice(-2000)
   throw new Error(
-    `peach bridge did not start within ${Math.round(OPEN_BRIDGE_SPAWN_TIMEOUT_MS / 1000)}s`,
+    `${reason}${bridgeLog ? `\n${bridgeLog}` : ''}\nbridge log: ${bridgeLogPath}`,
   )
 }
 

package/cli/commands/flow.ts

@@ -955,7 +955,14 @@ flow extension:
       }
       const { runUpload } = await import('./upload')
       lastPreviewUploadResult = await runUpload(uploadArgs, {})
-      await driver.liveStatus?.preview(lastPreviewUploadResult.previewUrl)
+      // upload can outlive the command socket's idle lifetime. publish its
+      // completed trace over a fresh connection to the same bridge world.
+      const resultBridge = createBridgeFromParsed(parsedBridgeArgs)
+      try {
+        await driver.liveStatus?.preview(lastPreviewUploadResult.previewUrl, resultBridge)
+      } finally {
+        resultBridge.close()
+      }
     } catch (err: any) {
       lastPreviewUploadError =
         err instanceof PeachExit && err.reason ? err.reason : String(err?.message || err)

package/cli/commands/platform.ts

@@ -29,7 +29,12 @@ function isDeviceModel(value: string): value is DeviceModel {
 }
 
 // flags this command reads for itself rather than treating as the bundle.
-const REMOTE_VALUE_FLAGS = new Set(['--device', '--name', '--endpoint'])
+const REMOTE_VALUE_FLAGS = new Set([
+  '--device',
+  '--name',
+  '--endpoint',
+  '--native-project',
+])
 
 function remoteInputFromArgs(
   args: string[],
@@ -37,11 +42,13 @@ function remoteInputFromArgs(
 ): {
   bundlePath: string
   name: string | null
+  nativeProjectDir: string | undefined
   reuse: boolean
   fresh: boolean
 } {
   const positional: string[] = []
   let name: string | null = null
+  let nativeProjectDir: string | undefined
   for (let index = 0; index < args.length; index++) {
     const arg = args[index]
     if (arg === '--remote' || arg === '--nano' || arg === '--reuse' || arg === '--new') {
@@ -51,6 +58,7 @@ function remoteInputFromArgs(
       const value = args[++index] ?? null
       if (!value) throw new Error(`peach remote ${platform} ${arg} requires a value`)
       if (arg === '--name') name = value
+      if (arg === '--native-project') nativeProjectDir = value
       continue
     }
     const assigned = arg.match(/^(--[a-z-]+)=(.*)$/)
@@ -59,6 +67,7 @@ function remoteInputFromArgs(
       if (!value)
         throw new Error(`peach remote ${platform} ${assigned[1]} requires a value`)
       if (assigned[1] === '--name') name = value
+      if (assigned[1] === '--native-project') nativeProjectDir = value
       continue
     }
     if (
@@ -88,7 +97,7 @@ function remoteInputFromArgs(
   if (reuse && fresh) {
     throw new Error(`peach remote ${platform} cannot combine --reuse and --new`)
   }
-  return { bundlePath: positional[0], name, reuse, fresh }
+  return { bundlePath: positional[0], name, nativeProjectDir, reuse, fresh }
 }
 
 /**
@@ -242,6 +251,8 @@ async function runRemoteCreate(
   selectedDevice: string,
 ): Promise<number> {
   const input = remoteInputFromArgs(args, platform)
+  if (input.nativeProjectDir)
+    throw new Error('--native-project requires a prebuilt micro Box')
   const [
     { authHeaderOrExit, cloudAccountIdOrExit },
     {
@@ -404,6 +415,7 @@ async function runRemoteBox(
 
   const existingSession = readCloudSession()
   if (
+    !input.nativeProjectDir &&
     existingSession?.service === 'box' &&
     !input.fresh &&
     existingSession.apiOrigin === endpoint &&
@@ -454,6 +466,7 @@ async function runRemoteBox(
   }
   const created = await box.createPrebuiltBundleBox({
     bundle: new Uint8Array(artifact.bytes),
+    nativeProjectDir: input.nativeProjectDir,
     device: selectedDevice,
     name: input.name ?? boxNameForBundle(input.bundlePath),
     endpoint,

package/cli/commands/skills.ts

@@ -137,9 +137,117 @@ function targetFromHome(envName: string, fallbackDir: string): string {
   return path.join(home, 'skills')
 }
 
+function codexTargets(): InstallTarget[] {
+  const homes = new Map<string, string>()
+  const userHome = process.env.HOME || os.homedir()
+
+  // 1. Default CODEX_HOME or ~/.codex
+  const primaryCodexHome = process.env.CODEX_HOME || path.join(userHome, '.codex')
+  homes.set(path.resolve(primaryCodexHome), 'codex')
+
+  // 2. TM_CODEX_HOMES env var
+  const tmCodexHomes = process.env.TM_CODEX_HOMES
+  if (tmCodexHomes) {
+    for (const h of tmCodexHomes.split(path.delimiter)) {
+      if (h.trim()) {
+        const resolved = path.resolve(h.trim())
+        if (!homes.has(resolved)) {
+          homes.set(resolved, path.basename(resolved).replace(/^\./, ''))
+        }
+      }
+    }
+  }
+
+  // 3. Engine configuration from ~/.team-machine/engine.yaml or $TM_HOME/engine.yaml
+  const tmHome = process.env.TM_HOME || path.join(userHome, '.team-machine')
+  const enginePath = path.join(tmHome, 'engine.yaml')
+  if (fs.existsSync(enginePath)) {
+    try {
+      const content = fs.readFileSync(enginePath, 'utf8')
+      let inCodex = false
+      let inAccounts = false
+      let currentAccount = ''
+      for (const line of content.split('\n')) {
+        const indent = line.search(/\S/)
+        const trimmed = line.trim()
+        if (indent === -1) continue
+
+        if (indent === 4) {
+          inCodex = trimmed === 'codex:'
+          inAccounts = false
+          currentAccount = ''
+          continue
+        }
+
+        if (!inCodex) continue
+
+        if (indent === 6 && trimmed === 'accounts:') {
+          inAccounts = true
+          currentAccount = ''
+          continue
+        }
+
+        if (!inAccounts) continue
+
+        if (indent === 8 && trimmed.endsWith(':')) {
+          currentAccount = trimmed.slice(0, -1).trim()
+          continue
+        }
+
+        if (indent >= 10 && currentAccount) {
+          const match = /^home:\s*(.+)$/.exec(trimmed)
+          if (match) {
+            let homeDir = match[1].trim()
+            if (homeDir.startsWith('~')) {
+              homeDir = path.join(userHome, homeDir.slice(1))
+            }
+            const resolved = path.resolve(homeDir)
+            if (!homes.has(resolved)) {
+              homes.set(resolved, `codex-${currentAccount}`)
+            }
+          }
+        }
+      }
+    } catch {
+      // ignore read error
+    }
+  }
+
+  // 4. Native Codex profile directories in home matching .codex-*
+  try {
+    for (const entry of fs.readdirSync(userHome)) {
+      if (entry.startsWith('.codex-')) {
+        const fullPath = path.join(userHome, entry)
+        try {
+          const stat = fs.statSync(fullPath)
+          if (stat.isDirectory()) {
+            const resolved = path.resolve(fullPath)
+            if (!homes.has(resolved)) {
+              homes.set(resolved, entry.replace(/^\./, ''))
+            }
+          }
+        } catch {
+          // ignore
+        }
+      }
+    }
+  } catch {
+    // ignore
+  }
+
+  const targets: InstallTarget[] = []
+  for (const [homePath, label] of homes) {
+    targets.push({
+      label,
+      dir: path.join(homePath, 'skills'),
+    })
+  }
+  return targets
+}
+
 function defaultAgentTargets(): InstallTarget[] {
   return [
-    { label: 'codex', dir: targetFromHome('CODEX_HOME', '.codex') },
+    ...codexTargets(),
     { label: 'claude', dir: targetFromHome('CLAUDE_CONFIG_DIR', '.claude') },
   ]
 }
@@ -162,7 +270,7 @@ export function hasInstalledPeachSkills(): boolean {
 function agentTarget(target: string): InstallTarget[] {
   if (target === 'all') return defaultAgentTargets()
   if (target === 'codex') {
-    return [{ label: 'codex', dir: targetFromHome('CODEX_HOME', '.codex') }]
+    return codexTargets()
   }
   if (target === 'claude') {
     return [{ label: 'claude', dir: targetFromHome('CLAUDE_CONFIG_DIR', '.claude') }]
@@ -289,14 +397,21 @@ function symlinkPointsTo(dest: string, src: string): boolean {
 // holding a byte-identical copy of the skill. only our installer creates
 // those shapes, so replacing them can't lose user work.
 function isOwnLegacyInstall(stat: fs.Stats, dest: string, srcDir: string): boolean {
-  // a dangling link into a removed checkout's skills dir is our own install too
+  // a dangling link into a removed checkout's skills dir or a link into an obsolete worktree is our own install too
   if (stat.isSymbolicLink()) {
-    return (
-      !fs.existsSync(dest) &&
-      fs
-        .readlinkSync(dest)
-        .endsWith(`${path.sep}skills${path.sep}${path.basename(srcDir)}`)
-    )
+    try {
+      const link = fs.readlinkSync(dest)
+      const isPeachSkill = link.endsWith(
+        `${path.sep}skills${path.sep}${path.basename(srcDir)}`,
+      )
+      if (isPeachSkill) {
+        if (!fs.existsSync(dest)) return true
+        if (link.includes(`${path.sep}.worktrees${path.sep}`)) return true
+      }
+    } catch {
+      return false
+    }
+    return false
   }
   if (!stat.isDirectory()) return false
   let entries: string[]
@@ -350,7 +465,7 @@ const LEGACY_BUNDLED_SKILL_DIRS = [
   'sootsim-debug',
   'sootsim-perf',
   'sootsim-test',
-  'peach-visual',
+  'sootsim-visual',
   'rnx-setup',
   'rnx-debug',
   'rnx-perf',

package/cli/commands/upload.ts

@@ -5,7 +5,7 @@
 // uploads are unlisted-public (unguessable id) but require a signed-in
 // desktop session so the share is associated with the user's account.
 
-import { createHash } from 'crypto'
+import { createHash, randomUUID } from 'crypto'
 import { readFileSync } from 'fs'
 import path from 'path'
 import { gzipSync, gunzipSync } from 'zlib'
@@ -609,45 +609,59 @@ export async function runUpload(
           `  ${crossOriginStats.count} recorded cross-origin responses ` +
             `(${(crossOriginStats.totalBytes / 1024).toFixed(1)} KiB)`,
         )
-        // fetch the full records (with bodies). limit to ~20 MiB total —
-        // if we're over, warn and truncate. most dev sessions are well
-        // under this.
-        // also pull bundle-origin-keyed api responses with bodies so the
-        // upload can use them instead of re-fetching from the dev server
-        // (which fails with 401 because the cli has no auth context). main
-        // bundle + static assets stay on the manifest re-fetch path.
-        const dumped = await evalInBridge<{
-          main: RecordedFetch[]
-          worker: RecordedFetch[]
-        }>(
-          bridge,
-          `(async () => {
-            const rec = window.__sootsimPreviewRecorder
-            const workerDump = window.__sootsimDumpWorkerFetchRecorder
-            const bundleUrl = ${JSON.stringify(snapshot.bundleUrl)}
-            await rec?.flush?.()
-            const keep = (r) => {
-              try {
-                const u = new URL(r.url)
-                if (u.origin !== ${JSON.stringify(bundleOrigin)}) return true
-                // bundle-origin api responses came from the rewritten
-                // /__app-api proxy at record time (re-keyed by the
-                // recorder's unwrap step). they need bodies attached the
-                // same way as cross-origin records — direct re-fetch from
-                // the dev server lacks the bundle's session cookies.
-                if (r.url !== bundleUrl && u.pathname.startsWith('/api/')) return true
-                return false
-              } catch { return false }
-            }
-            return {
-              main: rec?.dump ? rec.dump().filter(keep) : [],
-              worker: typeof workerDump === 'function'
-                ? (await workerDump()).filter(keep)
-                : [],
+        // retain the snapshot in the page and pull bodies in bounded slices.
+        // a complete base64 dump can exceed the bridge's 100 mib frame cap.
+        const cacheKey = `__peachCliUploadFetches_${randomUUID()}`
+        try {
+          const entries = await evalInBridge<
+            Array<RecordedEntry & { index: number; bodyBase64Length: number }>
+          >(
+            bridge,
+            `(async () => {
+              const rec = window.__sootsimPreviewRecorder
+              const workerDump = window.__sootsimDumpWorkerFetchRecorder
+              const bundleUrl = ${JSON.stringify(snapshot.bundleUrl)}
+              await rec?.flush?.()
+              const keep = (r) => {
+                try {
+                  const u = new URL(r.url)
+                  if (u.origin !== ${JSON.stringify(bundleOrigin)}) return true
+                  return r.url !== bundleUrl && u.pathname.startsWith('/api/')
+                } catch { return false }
+              }
+              const records = [
+                ...(rec?.dump ? rec.dump().filter(keep) : []),
+                ...(typeof workerDump === 'function'
+                  ? (await workerDump()).filter(keep)
+                  : []),
+              ]
+              window[${JSON.stringify(cacheKey)}] = records
+              return records.map(({ bodyBase64, ...entry }, index) => ({
+                ...entry, index, bodyBase64Length: bodyBase64.length,
+              }))
+            })()`,
+          )
+          const dumped: RecordedFetch[] = []
+          const chunkChars = 1_000_000
+          for (const { index, bodyBase64Length, ...entry } of entries) {
+            let bodyBase64 = ''
+            for (let offset = 0; offset < bodyBase64Length; offset += chunkChars) {
+              const end = Math.min(offset + chunkChars, bodyBase64Length)
+              const chunk = await evalInBridge(
+                bridge,
+                `window[${JSON.stringify(cacheKey)}]?.[${index}]?.bodyBase64.slice(${offset}, ${end})`,
+              )
+              if (typeof chunk !== 'string' || chunk.length !== end - offset) {
+                throw new Error('recorded response snapshot changed during upload')
+              }
+              bodyBase64 += chunk
             }
-          })()`,
-        )
-        recordedFetches = mergeRecordedEntries([...dumped.main, ...dumped.worker])
+            dumped.push({ ...entry, bodyBase64 })
+          }
+          recordedFetches = mergeRecordedEntries(dumped)
+        } finally {
+          await evalInBridge(bridge, `delete window[${JSON.stringify(cacheKey)}]`)
+        }
         if (assetsOnly) {
           const before = recordedFetches.length
           recordedFetches = recordedFetches.filter((r) =>

package/cli/flow-live-status.ts

@@ -47,8 +47,9 @@ export class FlowLiveStatusReporter {
   private async send(
     payload: Record<string, unknown>,
     simId: string | undefined,
+    bridge: WsBridge = this.bridge,
   ): Promise<unknown> {
-    const reply: unknown = await this.bridge.send({
+    const reply: unknown = await bridge.send({
       type: 'flowStatus',
       simId,
       status: { runId: this.runId, flowName: this.flowName, ...payload },
@@ -57,7 +58,10 @@ export class FlowLiveStatusReporter {
     return reply
   }
 
-  private async push(payload: Record<string, unknown>): Promise<unknown> {
+  private async push(
+    payload: Record<string, unknown>,
+    bridge: WsBridge = this.bridge,
+  ): Promise<unknown> {
     if (this.disabled) return undefined
     try {
       const simId = this.getSimId?.()
@@ -75,13 +79,14 @@ export class FlowLiveStatusReporter {
             source: this.flowSource,
           },
           simId,
+          bridge,
         )
         for (const step of this.completedSteps.values()) {
-          await this.send({ phase: 'step', state: 'running', step }, simId)
+          await this.send({ phase: 'step', state: 'running', step }, simId, bridge)
         }
       }
       this.lastSimId = simId
-      return await this.send(payload, simId)
+      return await this.send(payload, simId, bridge)
     } catch (error) {
       this.disabled = true
       console.log(
@@ -165,8 +170,8 @@ export class FlowLiveStatusReporter {
 
   // the finished run's cloud trace url, once --preview has uploaded it. the
   // devtools test pane's Open Trace button opens it.
-  async preview(previewUrl: string): Promise<void> {
-    await this.push({ phase: 'preview', previewUrl })
+  async preview(previewUrl: string, bridge: WsBridge): Promise<void> {
+    await this.push({ phase: 'preview', previewUrl }, bridge)
   }
 
   // park while the devtools pause toggle is on. checked between top-level