peachsim 0.1.1644 → 0.1.1653

package/cli/commands/device.ts

@@ -1,10 +1,9 @@
+import { getCliRuntime } from '../../src/cli-runtime.ts'
 import {
   devices,
-  getDevice,
   listSelectableDeviceModels,
   type DeviceModel,
-} from 'peach-engine/settings/devices'
-import { DUO_REST_PROGRESS, type DuoFoldRest } from 'peach-engine/settings/duo-fold-bus'
+} from '../../src/device-catalog.ts'
 import { SOOTSIM_SHELL_COMMAND_NAME } from '../../src/menu'
 import { peachExit } from '../run-rnx'
 import {
@@ -14,6 +13,7 @@ import {
   parseBridgeCliArgs,
   type ParsedBridgeCliArgs,
 } from '../ws-bridge'
+import type { DuoFoldRest } from '#peach-cli-contract/settings/duo-fold-bus'
 
 interface DeviceCommandOptions {
   port?: number
@@ -48,7 +48,7 @@ examples:
 }
 
 function printDevice(model: DeviceModel) {
-  const spec = getDevice(model)
+  const spec = getCliRuntime().settings_devices.getDevice(model)
   console.log(
     `  ${model.padEnd(14)} ${String(spec.width).padStart(4)}x${String(spec.height).padEnd(4)} pt   ${String(spec.width * spec.scale).padStart(4)}x${String(spec.height * spec.scale).padEnd(4)} px   ${spec.name}`,
   )
@@ -65,7 +65,7 @@ async function readCurrentDevice(
     )) ?? { deviceModel: null }
     const model = typeof settings.deviceModel === 'string' ? settings.deviceModel : null
     if (!model || !(model in devices)) return null
-    const spec = getDevice(
+    const spec = getCliRuntime().settings_devices.getDevice(
       model as DeviceModel,
       settings.posture === 'open' || settings.posture === 'closed'
         ? settings.posture
@@ -88,10 +88,15 @@ async function readCurrentDevice(
 }
 
 function isDuoRest(value: unknown): value is DuoFoldRest {
-  return typeof value === 'string' && value in DUO_REST_PROGRESS
+  return (
+    typeof value === 'string' &&
+    value in getCliRuntime().settings_duo_fold_bus.DUO_REST_PROGRESS
+  )
 }
 
-const DUO_RESTS = Object.keys(DUO_REST_PROGRESS).filter(isDuoRest)
+const DUO_RESTS = Object.keys(
+  getCliRuntime().settings_duo_fold_bus.DUO_REST_PROGRESS,
+).filter(isDuoRest)
 
 type CurrentPostureSnapshot = {
   model: DeviceModel
@@ -165,7 +170,7 @@ export async function runDeviceCommand(args: string[], opts: DeviceCommandOption
         'deviceModel',
         model,
       )
-      const spec = getDevice(model as DeviceModel)
+      const spec = getCliRuntime().settings_devices.getDevice(model as DeviceModel)
       console.log(
         `  ${changed ? 'set' : 'kept'} device: ${model} (${spec.width}x${spec.height} pt, ${spec.width * spec.scale}x${spec.height * spec.scale} px)${changed ? ' — reloading sim' : ''}`,
       )
@@ -228,7 +233,7 @@ export async function runDeviceCommand(args: string[], opts: DeviceCommandOption
           const settled = () => {
             const fold = globalThis.__sootsimDuoFold
             return !!fold && fold.rest === ${JSON.stringify(target)} && !fold.active &&
-              Math.abs(fold.progress - ${DUO_REST_PROGRESS[target]}) < 1e-6
+              Math.abs(fold.progress - ${getCliRuntime().settings_duo_fold_bus.DUO_REST_PROGRESS[target]}) < 1e-6
           }
           const check = () => {
             if (settled()) resolve(true)

package/cli/commands/guest-host.ts

@@ -2,6 +2,7 @@
 // and the teardown of the simulator, driver and bridge their open started.
 import { isLoopbackHost } from '../../src/backend-origin'
 import { clearCurrentSimId, readCurrentSimId } from '../current-sim'
+import { terminateProcessGroup } from '../../src/process-group'
 import { createBridge } from '../ws-bridge'
 import {
   printDriverDiagnosticLogTail,
@@ -74,18 +75,13 @@ export async function closeGuestResources(
       closed = false
     }
   }
-  if (
-    resources.driver?.driverId === 'playwright' &&
-    resources.driver.launched &&
-    resources.driver.pid
-  ) {
+  if (resources.driver?.driverId === 'playwright' && resources.driver.process) {
+    // the host owns a browser tree; wait until it and its descendants are gone.
     try {
-      process.kill(resources.driver.pid, 'SIGTERM')
+      await terminateProcessGroup(resources.driver.process)
     } catch (error) {
-      if (!(error instanceof Error && 'code' in error && error.code === 'ESRCH')) {
-        console.error(String(error))
-        closed = false
-      }
+      console.error(`  ${label} driver cleanup failed: ${String(error)}`)
+      closed = false
     }
   }
   if (resources.bridge && !resources.bridgeReady) resources.bridge.kill('SIGTERM')

package/cli/commands/inspect/core.ts

@@ -15,12 +15,18 @@ import {
   HEADLESS_TENANT_FETCH_HUNG_MARKER,
   readyProbeContentBasis,
   readyProbeIsReady,
+  type DiagnosticsOptions,
+  type DiagnosticsResult,
   type SemanticWaitCondition,
   type SemanticWaitResult,
   type WsBridgeCommand,
 } from '../../../src/bridge-contract'
-import { SEMANTIC_WAIT_MAX_TIMEOUT_MS } from '../../../src/bridge-contract-input'
+import {
+  parseDiagnosticsResult,
+  SEMANTIC_WAIT_MAX_TIMEOUT_MS,
+} from '../../../src/bridge-contract-input'
 export { readyProbeHasContent, readyProbeIsReady } from '../../../src/bridge-contract'
+import type { KeyboardLayoutSnapshot } from '#peach-cli-contract/render-worker/native-ui-protocol'
 import type {
   SimSemanticNode,
   SimSemanticQueryResult,
@@ -36,7 +42,6 @@ import type {
   SootSimTimelineQueryResult,
   SootSimTimelineSummary,
 } from '@peach/globals'
-import type { KeyboardLayoutSnapshot } from 'peach-engine/render-worker/native-ui-protocol'
 
 // resolve a wait's `--max-ms <n>` budget, tolerating the spellings agents and
 // humans actually type (`--maxMs`, `--maxms`, `--max_ms`). `--timeout`, the
@@ -1994,29 +1999,50 @@ export async function inspectScreens(bridge: InspectBridge): Promise<ScreensRepo
 
 // ─── debug channels ───
 
-// the `window.__sootsimDebug` channels the engine instruments. `all` is a
-// meta-target accepted by enable/disable.
-export const DEBUG_CHANNELS = [
-  'portals',
-  'sheets',
-  'layout',
-  'onlayout',
-  'animated',
-  'render',
-  'touch',
-  'yoga',
-] as const
+// remote diagnostics stay on the typed read surface; evaluation retains its
+// separate debug-scope requirement.
+async function inspectCloudDiagnostics(
+  bridge: InspectBridge,
+  diagnostics: DiagnosticsOptions = {},
+): Promise<DiagnosticsResult> {
+  return parseDiagnosticsResult(await bridge.send({ type: 'diagnostics', diagnostics }))
+}
 
-// `debug status` — which debug channels are currently enabled + their counts.
-export async function inspectDebugStatus(bridge: InspectBridge): Promise<unknown> {
+// `debug status` reads the currently enabled debug channels.
+export async function inspectDebugStatus(
+  bridge: InspectBridge,
+  host = false,
+): Promise<unknown> {
+  if (bridge.plane === 'cloud' && !host) {
+    return (await inspectCloudDiagnostics(bridge)).channels
+  }
   return bridge.send({ type: 'evaluate', code: 'window.__sootsimDebug.status()' })
 }
 
 // `debug flags` — the engine's debug feature flags.
-export async function inspectDebugFlags(bridge: InspectBridge): Promise<unknown> {
+export async function inspectDebugFlags(
+  bridge: InspectBridge,
+  host = false,
+): Promise<unknown> {
+  if (bridge.plane === 'cloud' && !host) {
+    const { channels, availableChannels } = await inspectCloudDiagnostics(bridge)
+    return Object.fromEntries(
+      availableChannels.map((channel) => [channel, channels.includes(channel)]),
+    )
+  }
   return bridge.send({ type: 'evaluate', code: 'window.__sootsimDebug.flags()' })
 }
 
+export async function inspectDebugChannels(
+  bridge: InspectBridge,
+  host = false,
+): Promise<unknown> {
+  if (bridge.plane === 'cloud' && !host) {
+    return (await inspectCloudDiagnostics(bridge)).availableChannels
+  }
+  return bridge.send({ type: 'evaluate', code: 'window.__sootsimDebug.channels()' })
+}
+
 // `debug find sheets|portals` — locate all live sheet / portal nodes.
 // routed through the test bridge (not the page __sootsimDebug global) so the
 // walk runs against the worker's live tree — the page-local tree is empty
@@ -2024,7 +2050,11 @@ export async function inspectDebugFlags(bridge: InspectBridge): Promise<unknown>
 export async function inspectDebugFind(
   bridge: InspectBridge,
   target: 'sheets' | 'portals' | 'boundaries',
+  host = false,
 ): Promise<unknown> {
+  if (bridge.plane === 'cloud' && !host) {
+    return (await inspectCloudDiagnostics(bridge, { find: target })).found
+  }
   return bridge.send({
     type: 'evaluate',
     code: `window.__sootsimTest.debugFind(${JSON.stringify(target)})`,
@@ -2060,6 +2090,14 @@ export async function inspectDebugRecent(
   limit = 50,
   host = false,
 ): Promise<unknown> {
+  if (bridge.plane === 'cloud' && !host) {
+    return (
+      await inspectCloudDiagnostics(bridge, {
+        ...(channel && channel !== 'all' ? { recentChannel: channel } : {}),
+        recentLimit: limit,
+      })
+    ).events
+  }
   return callDebugBridge(
     bridge,
     `recent(${channel && channel !== 'all' ? JSON.stringify(channel) : 'undefined'}, ${limit})`,
@@ -2075,6 +2113,11 @@ export async function setDebugChannels(
   channels: string[],
   host = false,
 ): Promise<unknown> {
+  if (bridge.plane === 'cloud' && !host) {
+    return (
+      await inspectCloudDiagnostics(bridge, { channelControl: { action, channels } })
+    ).channels
+  }
   const args =
     channels.length > 0
       ? channels.map((c) => JSON.stringify(c)).join(', ')
@@ -2087,6 +2130,27 @@ export async function setDebugChannels(
   return callDebugBridge(bridge, expression)
 }
 
+export async function toggleDebugChannel(
+  bridge: InspectBridge,
+  channel: string,
+  host = false,
+): Promise<unknown> {
+  if (bridge.plane === 'cloud' && !host) {
+    const { channels } = await inspectCloudDiagnostics(bridge, {
+      channelControl: { action: 'toggle', channels: [channel] },
+    })
+    return channels.includes(channel)
+  }
+  const result = await callDebugBridge(bridge, `toggle(${JSON.stringify(channel)})`, true)
+  if (!host) {
+    await callDebugBridge(
+      bridge,
+      `${result ? 'enable' : 'disable'}(${JSON.stringify(channel)})`,
+    )
+  }
+  return result
+}
+
 // ─── memory ───
 
 export interface ImageLoaderStats {

package/cli/commands/inspect.ts

@@ -3467,13 +3467,17 @@ export async function runInspect(args: string[], opts: InspectOptions) {
         // early in that case instead of waiting the full budget.
         let issuedReload = false
         let inPlaceReload = false
+        // a reload rewrites the sim's running app, so it takes the cli lease
+        // like any other write. a live foreign lease refuses here, before the
+        // sim is touched, and the refusal must not be swallowed by the
+        // reconnect handling below.
+        await evalInBridge(bridge, 'window.__sootsimConsole?.clear()', {
+          acquireLock: true,
+        })
         try {
-          await bridge.send({
-            type: 'evaluate',
-            code: 'window.__sootsimConsole?.clear()',
-          })
           const reloadResult = await bridge.send({
             type: 'evaluate',
+            acquireLock: true,
             code: `;(async () => {
               // in-place guest reload is only valid while the page still runs
               // the engine build the server would serve NOW. the shell dev
@@ -3602,10 +3606,11 @@ export async function runInspect(args: string[], opts: InspectOptions) {
       }
 
       case 'storage-clear': {
-        await clearConsole(bridge)
-        const cleared = await bridge.send({
-          type: 'evaluate',
-          code: resetGuestAppStateEval(true),
+        await evalInBridge(bridge, 'window.__sootsimConsole?.clear()', {
+          acquireLock: true,
+        })
+        const cleared = await evalInBridge(bridge, resetGuestAppStateEval(true), {
+          acquireLock: true,
         })
         if (cleared !== true) {
           if (wantsJson(effectiveArgs)) {

package/cli/commands/kotlin.ts

@@ -1,20 +1,20 @@
 import fs from 'node:fs'
 import http from 'node:http'
 import path from 'node:path'
-import { DEFAULT_DEVICE_BY_PLATFORM, devices } from 'peach-engine/settings/devices'
 import { WebSocket, WebSocketServer } from 'ws'
+import { DEFAULT_DEVICE_BY_PLATFORM, devices } from '../../src/device-catalog.ts'
 import { kotlinGuestBundle } from '../../src/guest-bundle'
 import {
   readAndroidPins,
   readKotlinApp,
   type KotlinAppProject,
 } from '../../src/kotlin-app'
+import { peachKotlinModuleRoot } from '../../src/kotlin-module'
 import {
   KOTLIN_DISCOVERY_PATH,
   KOTLIN_GUEST_PATH,
   type KotlinHostDiscovery,
 } from '../../src/kotlinDiscoveryContract'
-import { peachKotlinModuleRoot } from '../../src/kotlin-module'
 import { PeachExit } from '../run-rnx'
 import { runOpenCommand, type OpenCommandResources } from './control'
 import {

package/cli/commands/maestro-compare.ts

@@ -7,8 +7,8 @@ import { spawn, spawnSync } from 'child_process'
 import * as fs from 'fs'
 import * as os from 'os'
 import * as path from 'path'
-import { devices } from 'peach-engine/settings/devices'
 import { PNG } from 'pngjs'
+import { devices } from '../../src/device-catalog.ts'
 import { rnxHomeDir } from '../../src/home-paths'
 import { parseFlowFile } from '../flow-file'
 import {

package/cli/commands/platform.ts

@@ -1,19 +1,17 @@
+import { createHash } from 'node:crypto'
 // `peach ios` and `peach android` — start a simulator on that platform.
 //
 // the platform picks the device; the command context picks where the sim runs
 // (this machine, a local box, or the `peach remote` namespace). this file resolves
 // the device and hands the rest to the normal open path.
-
-import { createHash } from 'node:crypto'
+import { getCliRuntime } from '../../src/cli-runtime.ts'
 import {
   DEFAULT_DEVICE_BY_PLATFORM,
   devices,
-  getRuntimePlatform,
   listSelectableDeviceModels,
   type DeviceModel,
   type RuntimePlatform,
-} from 'peach-engine/settings/devices'
-import { settingsStore } from 'peach-engine/settings/store'
+} from '../../src/device-catalog.ts'
 import { rnxPublicBrand } from '../../src/public-brand'
 import { UnsupportedRemoteHostError } from '../cloud-client'
 import { rethrowIfExit } from '../run-rnx'
@@ -155,13 +153,17 @@ export async function runPlatformCommand(
       )
       return 1
     }
-    const devicePlatform = getRuntimePlatform(explicitDevice)
+    const devicePlatform =
+      getCliRuntime().settings_devices.getRuntimePlatform(explicitDevice)
     if (devicePlatform !== platform) {
       console.error(
         `  ${rnxPublicBrand.commandName} ${platform}: --device ${explicitDevice} is ` +
           `${PLATFORM_LABEL[devicePlatform]}, not ${PLATFORM_LABEL[platform]}.\n` +
           `  pick one of: ${listSelectableDeviceModels()
-            .filter((model) => getRuntimePlatform(model) === platform)
+            .filter(
+              (model) =>
+                getCliRuntime().settings_devices.getRuntimePlatform(model) === platform,
+            )
             .join(', ')}`,
       )
       return 1
@@ -171,9 +173,11 @@ export async function runPlatformCommand(
     // keep the user's own device when it already belongs to the platform they
     // asked for, so `peach ios` after `peach device set iphone-16` does not
     // silently snap back to the default model.
-    const current = settingsStore.get('deviceModel')
-    if (getRuntimePlatform(current) !== platform) {
-      settingsStore.apply({ deviceModel: DEFAULT_DEVICE_BY_PLATFORM[platform] })
+    const current = getCliRuntime().settings_store.settingsStore.get('deviceModel')
+    if (getCliRuntime().settings_devices.getRuntimePlatform(current) !== platform) {
+      getCliRuntime().settings_store.settingsStore.apply({
+        deviceModel: DEFAULT_DEVICE_BY_PLATFORM[platform],
+      })
       selectedDevice = DEFAULT_DEVICE_BY_PLATFORM[platform]
     } else {
       selectedDevice = current
@@ -235,8 +239,13 @@ export async function runPlatformCommand(
     return 1
   }
 
+  // the open path derives the bundle platform from --device alone, so the
+  // resolved device always travels with it, including the kept or default one.
+  const openArgs = args.includes('--device')
+    ? args
+    : [...args.filter((arg) => arg !== assignedDevice), '--device', selectedDevice]
   const { runOpenCommand } = await import('./control')
-  await runOpenCommand(args, { port: opts.port })
+  await runOpenCommand(openArgs, { port: opts.port })
   return 0
 }
 

package/cli/commands/preview.ts

@@ -5,16 +5,12 @@ import { createRequire } from 'node:module'
 import { createServer } from 'node:net'
 import { tmpdir } from 'node:os'
 import { dirname, join, resolve } from 'node:path'
-import { brotliBundle } from 'peach-engine/preview/compress-node'
-import {
-  runPresignedUpload,
-  type InitRequestBody,
-} from 'peach-engine/preview/presigned-upload'
 import { warmNativeBundle } from '../../../contrast-runner/src/bundleWarm'
 import {
   readPreviewBuildReceipt,
   type PreviewBuildReceipt,
 } from '../../../contrast-runner/src/previewBuildContract'
+import { getCliRuntime } from '../../src/cli-runtime.ts'
 import { isRecord } from '../../src/is-record'
 import { terminateProcessGroup } from '../../src/process-group'
 import { authHeaderValue, cloudAccountIdOrExit, resolveCliAuth } from '../auth'
@@ -23,6 +19,7 @@ import { publishLiveDevStack, type PublishedLiveDevStack } from '../cloud-test-t
 import { openUrl } from '../open-url'
 import { detectProject } from './detect'
 import { resolveDefaultUploadOrigin, resolvePublicPreviewOrigin } from './upload'
+import type { InitRequestBody } from '#peach-cli-contract/preview/presigned-upload'
 
 function takeValue(args: string[], flag: string): string | null {
   const index = args.indexOf(flag)
@@ -80,7 +77,7 @@ export async function runPreview(args: string[]): Promise<number> {
       return 0
     }
     const artifact = await producePreviewArtifact(target)
-    const bundle = brotliBundle(artifact.bytes)
+    const bundle = getCliRuntime().preview_compress_node.brotliBundle(artifact.bytes)
     const initBody: InitRequestBody = {
       kind: 'build',
       buildPlatform: platform,
@@ -98,18 +95,19 @@ export async function runPreview(args: string[]): Promise<number> {
           : { model: 'iphone-16', width: 402, height: 874 },
       files: [],
     }
-    const { finalize } = await runPresignedUpload({
-      originBase: origin,
-      endpoints: {
-        init: '/api/v1/previews',
-        finalize: '/api/v1/previews/finalize',
-      },
-      initBody,
-      bundleBytes: bundle,
-      filesByHash: new Map(),
-      authHeader: authHeaderValue(auth),
-      accountId,
-    })
+    const { finalize } =
+      await getCliRuntime().preview_presigned_upload.runPresignedUpload({
+        originBase: origin,
+        endpoints: {
+          init: '/api/v1/previews',
+          finalize: '/api/v1/previews/finalize',
+        },
+        initBody,
+        bundleBytes: bundle,
+        filesByHash: new Map(),
+        authHeader: authHeaderValue(auth),
+        accountId,
+      })
     const url = finalize.url.startsWith('http')
       ? finalize.url
       : `${publicOrigin}${finalize.url}`

package/cli/commands/runtime.ts

@@ -1,3 +1,4 @@
+import fs from 'fs'
 // peach runtime — manage engine runtimes under ~/.peach/runtimes/.
 //
 // runtimes are versioned tarballs hosted behind the configured CDN origin
@@ -10,10 +11,9 @@
 //
 // the daemon-side state (active runtime) is mirrored in ~/.peach/runtimes/active
 // so the CLI can change it even when the daemon isn't running.
-
-import fs from 'fs'
 import { compareSemver } from '@contrast/runtime-delivery'
 import { WebSocket } from 'ws'
+import { verifyCliCompanion } from '../../src/cli-runtime'
 import {
   ensureRnxHome,
   readActiveRuntime,
@@ -125,6 +125,7 @@ async function runtimeInstall(args: string[], opts: RuntimeOptions) {
 }
 
 async function activateVersion(version: string) {
+  verifyCliCompanion(runtimeDir(version))
   writeActiveRuntime(version)
   console.log(`  active:  ${version}`)
   // a running daemon reads the active file on every new sim and lockfile

package/cli/commands/screenshot-layers.ts

@@ -9,7 +9,7 @@
 
 import { mkdirSync, writeFileSync } from 'fs'
 import { resolve } from 'path'
-import { devices } from 'peach-engine/settings/devices'
+import { devices } from '../../src/device-catalog.ts'
 import { buildResolveRectEval, type SampleRect } from '../browser-evals'
 import { peachExit } from '../run-rnx'
 import { callInBridge, createBridgeFromParsed, parseBridgeCliArgs } from '../ws-bridge'

package/cli/commands/screenshot.ts

@@ -8,9 +8,9 @@
 
 import { mkdirSync } from 'fs'
 import { dirname, resolve } from 'path'
-import { devices, type DeviceModel } from 'peach-engine/settings/devices'
 import { launchReapedChrome } from '../../../../scripts/lib/reap-browser'
 import { DEFAULT_SOOTSIM_BRIDGE_PORT } from '../../src/bridge-constants'
+import { devices, type DeviceModel } from '../../src/device-catalog.ts'
 import { composeFramedScreenshot } from '../../src/screenshots/frame-compose'
 import { buildResolveRectEval, type SampleRect } from '../browser-evals'
 import { createCloudBridgeForParsed } from '../cloud-client'

package/cli/commands/serve.ts

@@ -16,6 +16,7 @@ import {
   ensureRnxHome,
   isDaemonLockfileFresh,
   readDaemonLockfile,
+  rnxHomeDir,
 } from '../../src/home-paths'
 import { SootSimBridgeHost } from '../../src/host/bridge-host'
 import { findMonorepoRoot, resolveDevCheckoutRuntimeRoot } from '../../src/runtime-assets'
@@ -88,7 +89,10 @@ examples:
     console.error(
       `  a peach bridge is already running (pid ${existingLock.pid}, port ${existingLock.bridgePort})`,
     )
-    console.error(`  stop it with 'peach daemon stop' first`)
+    console.error(
+      `  it owns the peach home ${rnxHomeDir()}. use that bridge on port ${existingLock.bridgePort}, or set PEACH_HOME to a separate directory to run your own.`,
+    )
+    console.error(`  stop it with 'peach daemon stop' only if you own it`)
     peachExit(1)
   }
 

package/cli/commands/support.ts

@@ -1,3 +1,4 @@
+import { resolve } from 'node:path'
 // peach support — ask for help, report a problem, and read our replies
 // (plans/peach-cloud/partner-support.md). every item belongs to the account the
 // CLI login names, so `status` lists them without the caller keeping ids.
@@ -6,13 +7,11 @@
 //   peach support report [--app <dir>] [--dry-run] [--yes] "<description>"
 //   peach support status [--id <id>] [--new] [--json]
 //   peach support fund [--amount <usd>]
-
-import { resolve } from 'node:path'
-import { TOPUP_DEFAULT_USD } from 'peach-engine/billing/plans'
 import {
   readSharedDesktopAuthSession,
   writeSharedDesktopAuthSession,
 } from '../../src/auth/shared-session'
+import { getCliRuntime } from '../../src/cli-runtime.ts'
 import { readSharedConfig, writeSharedConfig } from '../../src/home-paths'
 import { openUrl } from '../open-url'
 import { runReportIssue, supportEndpoint, toolchainContext } from './report-issue'
@@ -273,7 +272,8 @@ async function runAsk(args: string[]): Promise<number> {
 // paid, and binds the funded account to this login
 async function runFund(args: string[]): Promise<number> {
   const at = args.indexOf('--amount')
-  const amountUsd = at >= 0 ? Number(args[at + 1]) : TOPUP_DEFAULT_USD
+  const amountUsd =
+    at >= 0 ? Number(args[at + 1]) : getCliRuntime().billing_plans.TOPUP_DEFAULT_USD
   if (!Number.isFinite(amountUsd) || amountUsd <= 0) {
     process.stderr.write(`  --amount takes dollars\n${USAGE}`)
     return 1

package/cli/commands/three-mode.ts

@@ -1,20 +1,16 @@
+import { createHash } from 'node:crypto'
 // peach mode three — toggle the live browser 3d device stage.
 //
 // wraps the existing `toggle-three-mode` shell action so CLI, rail, and
 // menu all use the same plugin-owned state path.
-
-import { createHash } from 'node:crypto'
 import { mkdirSync, readFileSync, readdirSync, unlinkSync, writeFileSync } from 'node:fs'
 import { dirname, extname, resolve } from 'node:path'
-import {
-  collectTimelineAssetRefs,
-  timelineAssetRefOf,
-} from 'peach-engine/screenshots/timeline-assets'
+import { getCliRuntime } from '../../src/cli-runtime.ts'
+import { isRecord } from '../../src/is-record'
 import {
   isThreeModeSetting,
   THREE_MODE_SETTING_IDS,
-} from 'peach-engine/screenshots/tokens'
-import { isRecord } from '../../src/is-record'
+} from '../../src/screenshots/screenshotContract.ts'
 import { peachExit } from '../run-rnx'
 import {
   callInBridgeWrite,
@@ -369,7 +365,9 @@ function readDistinctTimelineAssets(
   baseDirectory: string,
 ): DistinctTimelineAsset[] {
   const byHash = new Map<string, DistinctTimelineAsset>()
-  for (const ref of collectTimelineAssetRefs(value)) {
+  for (const ref of getCliRuntime().screenshots_timeline_assets.collectTimelineAssetRefs(
+    value,
+  )) {
     const assetPath = resolve(baseDirectory, ref.src)
     const bytes = readFileSync(assetPath)
     const hash = createHash('sha256').update(bytes).digest('hex')
@@ -391,20 +389,29 @@ function readDistinctTimelineAssets(
 function rewriteTimelineAssetSrcs(
   value: unknown,
   urlBySrc: Map<string, string>,
+  inWallpaper = false,
 ): unknown {
   if (Array.isArray(value)) {
-    return value.map((entry) => rewriteTimelineAssetSrcs(entry, urlBySrc))
+    return value.map((entry) => rewriteTimelineAssetSrcs(entry, urlBySrc, inWallpaper))
   }
   if (!isRecord(value)) return value
 
   const result: Record<string, unknown> = {}
   for (const [key, entry] of Object.entries(value)) {
-    result[key] = rewriteTimelineAssetSrcs(entry, urlBySrc)
+    result[key] = rewriteTimelineAssetSrcs(
+      entry,
+      urlBySrc,
+      getCliRuntime().screenshots_timeline_assets.isWallpaperChild(key, inWallpaper),
+    )
   }
-  const ref = timelineAssetRefOf(result)
-  if (ref) {
-    const url = urlBySrc.get(ref.src)
-    if (url) result.src = url
+  for (const {
+    field,
+  } of getCliRuntime().screenshots_timeline_assets.timelineAssetFieldsOf(
+    result,
+    inWallpaper,
+  )) {
+    const url = urlBySrc.get(String(result[field]))
+    if (url) result[field] = url
   }
   return result
 }