peachsim 0.1.527 → 0.1.571

package/src/screenshots/frame-compose.ts

@@ -5,12 +5,13 @@ import {
   LEGACY_HOME_BUTTON_SIZE,
   LEGACY_SIDE_BEZEL,
   LEGACY_TOP_BEZEL,
-  HINGE_BARREL_BACKGROUND,
-  HINGE_BARREL_SHADOW,
-  HOUSING_RAIL_COLOR,
-  HOUSING_RAIL_OUTLINE,
   SIDE_BUTTON_RESERVE,
-} from 'sootsim-engine/ios/chrome-metrics'
+} from 'peach-engine/ios/chrome-metrics'
+import {
+  housingLayerHtml,
+  resolveHousingArt,
+  type HousingLayer,
+} from 'peach-engine/ios/duo-housing'
 import {
   cornerRadii,
   formatCornerRadii,
@@ -18,7 +19,7 @@ import {
   resolveDeviceFrameGeometry,
   type CornerRadii,
   type DeviceModel,
-} from 'sootsim-engine/settings'
+} from 'peach-engine/settings'
 import { launchReapedChrome } from '../../../../scripts/lib/reap-browser'
 
 const METALLIC_RING_SHADOW =
@@ -56,8 +57,8 @@ export interface FramedScreenshotLayout {
   logicalScreenTop: number
   logicalScreenRadius: CornerRadii
   logicalFrameRadius: CornerRadii
-  // light rail around a black glass ring; null draws one black body
-  housing: ReturnType<typeof resolveDeviceFrameGeometry>['housing']
+  // folding body art, painted before the screen; null draws one black body
+  housingLayers: HousingLayer[] | null
   frameBackground: string
   frameOutline: string
   metallicRingShadow: string | null
@@ -87,7 +88,9 @@ export function getFramedScreenshotLayout(model: DeviceModel): FramedScreenshotL
   const logicalScreenWidth = spec.width
   const logicalScreenHeight = spec.height
   const modernGeometry = resolveDeviceFrameGeometry(spec)
-  const housing = isLegacyHardware ? null : modernGeometry.housing
+  const housingLayers = isLegacyHardware
+    ? null
+    : resolveHousingArt(spec.posture ?? 'closed', modernGeometry)
   const logicalFrameWidth = isLegacyHardware
     ? spec.width + LEGACY_SIDE_BEZEL * 2
     : modernGeometry.frameWidth
@@ -148,18 +151,20 @@ export function getFramedScreenshotLayout(model: DeviceModel): FramedScreenshotL
     logicalScreenTop,
     logicalScreenRadius: isLegacyHardware ? cornerRadii(0) : modernGeometry.screenRadius,
     logicalFrameRadius,
-    housing,
+    housingLayers,
+    // the housing paints its own body layer, shadow included: its frame box is
+    // wider than the body, because the hinge barrel protrudes past the spine.
     frameBackground: isLegacyHardware
       ? 'linear-gradient(180deg, #1b1c20 0%, #0f1012 42%, #050608 100%)'
-      : housing
-        ? HOUSING_RAIL_COLOR
+      : housingLayers
+        ? 'transparent'
         : '#000000',
     frameOutline: isLegacyHardware
       ? '0 0 0 1px #1f2125'
-      : housing
-        ? HOUSING_RAIL_OUTLINE
+      : housingLayers
+        ? 'none'
         : '0 0 0 1px #333',
-    metallicRingShadow: isLegacyHardware || housing ? null : METALLIC_RING_SHADOW,
+    metallicRingShadow: isLegacyHardware || housingLayers ? null : METALLIC_RING_SHADOW,
     buttons,
     legacyHomeButton: isLegacyHardware
       ? {
@@ -230,46 +235,9 @@ function renderFrameHtml(
     `
     : ''
 
-  // black glass ring inside the rail, then the hinge barrel over the leading
-  // rail. the ring carries no z-index so the screen div after it paints on top.
-  const housingHtml = layout.housing
-    ? `
-      <div
-        aria-hidden="true"
-        style="
-          position:absolute;
-          top:${layout.housing.rail.top}px;
-          right:${layout.housing.rail.right}px;
-          bottom:${layout.housing.rail.bottom}px;
-          left:${layout.housing.rail.left}px;
-          border-radius:${formatCornerRadii(layout.housing.glassRadius)};
-          background:#000000;
-          pointer-events:none;
-        "
-      ></div>
-      ${
-        layout.housing.hingeBarrel
-          ? `
-      <div
-        aria-hidden="true"
-        style="
-          position:absolute;
-          top:${layout.housing.hingeBarrel.endInset}px;
-          bottom:${layout.housing.hingeBarrel.endInset}px;
-          left:0;
-          width:${layout.housing.hingeBarrel.width}px;
-          border-radius:${layout.housing.hingeBarrel.width / 2}px 0 0 ${layout.housing.hingeBarrel.width / 2}px;
-          background:${HINGE_BARREL_BACKGROUND};
-          box-shadow:${HINGE_BARREL_SHADOW};
-          pointer-events:none;
-          z-index:11;
-        "
-      ></div>
-      `
-          : ''
-      }
-    `
-    : ''
+  // the folding body's rail, glass ring, corner art, and hinge barrel. no
+  // z-index, so the screen div after it paints on top.
+  const housingHtml = (layout.housingLayers ?? []).map(housingLayerHtml).join('')
 
   const legacyHomeButtonHtml = layout.legacyHomeButton
     ? `
@@ -390,7 +358,7 @@ function renderFrameHtml(
           left:${layout.logicalFrameLeft}px;
           width:${layout.logicalFrameWidth}px;
           height:${layout.logicalFrameHeight}px;
-            border-radius:${formatCornerRadii(layout.logicalFrameRadius)};
+            border-radius:${layout.housingLayers ? '0' : formatCornerRadii(layout.logicalFrameRadius)};
             box-sizing:border-box;
             overflow:visible;
             background:${layout.frameBackground};

package/src/screenshots/org-deck.ts

@@ -6,7 +6,7 @@
 // colors. 3d scenes don't translate to the cli's 2d composer, so only copy and
 // colors carry over (the 3d hero look stays the in-browser screenshot mode).
 
-import { resolveBgColorValue } from 'sootsim-engine/screenshots/tokens'
+import { resolveBgColorValue } from 'peach-engine/screenshots/tokens'
 import type { BackgroundSpec } from './registry'
 import type { NormalizedScreenshotsPlan } from './schema'
 

package/src/screenshots/registry.ts

@@ -6,7 +6,7 @@
 // this module re-exports those tokens plus the composer-specific
 // `FrameComposeSpec` shape.
 
-import type { DeviceModel } from 'sootsim-engine/settings'
+import type { DeviceModel } from 'peach-engine/settings'
 
 export {
   BACKGROUND_PRESETS,
@@ -19,7 +19,7 @@ export {
   cloneBackgroundSpec,
   resolveBackgroundPreset,
   resolveCanvasPreset,
-} from 'sootsim-engine/screenshots/tokens'
+} from 'peach-engine/screenshots/tokens'
 
 export type {
   BackgroundPresetName,
@@ -30,9 +30,9 @@ export type {
   PosePresetName,
   ScreenshotCanvasName,
   TextPresetName,
-} from 'sootsim-engine/screenshots/tokens'
+} from 'peach-engine/screenshots/tokens'
 
-import type { FrameShadowSpec, PosePresetName } from 'sootsim-engine/screenshots/tokens'
+import type { FrameShadowSpec, PosePresetName } from 'peach-engine/screenshots/tokens'
 
 export interface FrameComposeSpec {
   show: boolean

package/src/screenshots/schema.ts

@@ -1,6 +1,6 @@
 import { readFileSync } from 'fs'
 import path from 'path'
-import { devices, type DeviceModel } from 'sootsim-engine/settings'
+import { devices, type DeviceModel } from 'peach-engine/settings'
 import yaml from 'yaml'
 import {
   cloneBackgroundSpec,

package/src/sdk.ts

@@ -1,9 +1,9 @@
-// rnxsim/sdk — the scriptable sim-driving surface.
+// peachsim/sdk — the scriptable sim-driving surface.
 //
 // exports the SimClient class plus the transport-agnostic inspect verbs it is
 // built from. this entry MUST stay browser-safe (Contrast's in-browser agent
 // imports it against an in-process preview bridge), so the node-only ws
-// `connect()` lives on the ROOT `rnxsim` entry, not here.
+// `connect()` lives on the ROOT `peachsim` entry, not here.
 
 export * from './sim-client'
 export * from '../cli/commands/inspect/core'

package/src/settings-bundle.ts

@@ -1,7 +1,7 @@
 import { readFile, readdir, stat } from 'node:fs/promises'
 import { join } from 'node:path'
 import { parsePlistSource } from './plist.ts'
-import type { AppPreferenceValue, AppSettingsSpecifier } from '@rnx/globals'
+import type { AppPreferenceValue, AppSettingsSpecifier } from '@peach/globals'
 
 const MAX_PLIST_BYTES = 1_048_576
 const MAX_CHILD_DEPTH = 8

package/src/sim-client.ts

@@ -60,6 +60,7 @@ import type {
   SimSemanticResolveSelector,
   SimStateOptions,
   SimStateResult,
+  WsBridgeCommand,
 } from './bridge-contract'
 
 // ---------------------------------------------------------------------------
@@ -250,10 +251,7 @@ export class SimClient implements WsBridge, InspectBridge {
 
   // --- transport (WsBridge/InspectBridge) ---
 
-  send(
-    cmd: { type: string; [k: string]: any },
-    opts?: { timeoutMs?: number },
-  ): Promise<any> {
+  send(cmd: WsBridgeCommand, opts?: { timeoutMs?: number }): Promise<any> {
     if (this.closed) {
       return Promise.reject(new SimConnectError('sim client is closed'))
     }

package/src/skills/builtin/compat-check.ts

@@ -22,7 +22,7 @@ export const skill: RNXSkill = {
         const fs = await import('node:fs')
         const path = await import('node:path')
         const { COMPAT_RESULT_CAVEAT, formatPackageStatus, formatScanCounts, scanDeps } =
-          await import('../../../../compat/src/web.ts')
+          await import('../../../../peach-compat/src/web.ts')
 
         const packagePath = path.join(context.projectDir, 'package.json')
         if (!fs.existsSync(packagePath)) {

package/src/swift-compile.ts

@@ -0,0 +1,359 @@
+import { execFile } from 'node:child_process'
+import { createHash } from 'node:crypto'
+import {
+  existsSync,
+  mkdirSync,
+  readFileSync,
+  readdirSync,
+  realpathSync,
+  rmSync,
+  statSync,
+  writeFileSync,
+} from 'node:fs'
+import path from 'node:path'
+import { promisify } from 'node:util'
+import { swiftManifestTargets, type SwiftPackageTarget } from './swift-package'
+import type { SwiftImageUpload } from './swift-submit'
+
+const run = promisify(execFile)
+const WASM_TRIPLE = 'wasm32-unknown-wasip1'
+
+export interface SwiftCompileInput {
+  files: Record<string, string>
+  resources?: Record<string, string>
+  images?: Record<string, SwiftImageUpload>
+  entry: string
+}
+
+export interface SwiftCompileOptions {
+  buildRoot: string
+  moduleRoot: string
+  release: string
+  toolchainBin: string
+  timeoutMs?: number
+}
+
+export interface SwiftCompileArtifact {
+  hash: string
+  bytes: Buffer
+}
+
+export interface SwiftProjectLayout {
+  root: string
+  sources: string
+  multi: boolean
+}
+
+export function swiftModuleInputFiles(root: string): string[] {
+  const files: string[] = ['Package.swift', 'scripts/contrast-app-Package.swift']
+  const walk = (dir: string) => {
+    for (const entry of readdirSync(path.join(root, dir), { withFileTypes: true })) {
+      const relative = `${dir}/${entry.name}`
+      if (entry.isDirectory()) walk(relative)
+      else if (entry.name.endsWith('.swift')) files.push(relative)
+    }
+  }
+  walk('Sources')
+  return files.sort()
+}
+
+const linkedModuleDigests = new Map<string, { stamp: string; digest: Buffer }>()
+
+export function clearLinkedModuleDigests(root?: string): void {
+  if (root === undefined) linkedModuleDigests.clear()
+  else linkedModuleDigests.delete(root)
+}
+
+function linkedModuleDigest(root: string): Buffer {
+  const files = swiftModuleInputFiles(root)
+  const stampHash = createHash('sha256')
+  for (const file of files) {
+    const stat = statSync(path.join(root, file), { bigint: true })
+    stampHash.update(file)
+    stampHash.update(
+      `${stat.dev}:${stat.ino}:${stat.size}:${stat.mtimeNs}:${stat.ctimeNs}\n`,
+    )
+  }
+  const stamp = stampHash.digest('hex')
+  const cached = linkedModuleDigests.get(root)
+  if (cached?.stamp === stamp) return cached.digest
+  const hash = createHash('sha256')
+  for (const file of files) {
+    hash.update(createHash('sha256').update(file).digest())
+    hash.update(
+      createHash('sha256')
+        .update(readFileSync(path.join(root, file)))
+        .digest(),
+    )
+  }
+  const digest = hash.digest()
+  linkedModuleDigests.set(root, { stamp, digest })
+  return digest
+}
+
+export function compileTargets(input: SwiftCompileInput): SwiftPackageTarget[] {
+  const manifest = input.files['Package.swift']
+  return manifest === undefined ? [] : swiftManifestTargets(manifest)
+}
+
+function swiftSiblingDependencies(
+  files: Record<string, string>,
+  targets: SwiftPackageTarget[],
+): Map<string, string[]> {
+  const names = new Set(targets.map((target) => target.name))
+  const siblings = new Map<string, string[]>()
+  for (const target of targets) {
+    const prefix = `${target.path}/`
+    const deps = new Set<string>()
+    for (const [file, contents] of Object.entries(files)) {
+      if (file === 'Package.swift' || !file.startsWith(prefix)) continue
+      for (const match of contents.matchAll(/^\s*import\s+([A-Za-z_][A-Za-z0-9_]*)/gm)) {
+        if (names.has(match[1]) && match[1] !== target.name) deps.add(match[1])
+      }
+    }
+    siblings.set(target.name, [...deps].sort())
+  }
+  return siblings
+}
+
+/** bump with any change to the emitted multi-target manifest text. */
+export const MULTI_MANIFEST_VERSION = 1
+
+export function swiftArtifactHash(
+  input: SwiftCompileInput,
+  release: string,
+  moduleRoot: string,
+): string {
+  const hash = createHash('sha256')
+  hash.update(`swift-compile/v1\n${release}\n`)
+  hash.update(linkedModuleDigest(moduleRoot))
+  for (const file of Object.keys(input.files).sort()) {
+    hash.update(createHash('sha256').update(file).digest())
+    hash.update(createHash('sha256').update(input.files[file]).digest())
+  }
+  for (const base of Object.keys(input.resources ?? {}).sort()) {
+    hash.update(createHash('sha256').update(base).digest())
+    hash.update(
+      createHash('sha256')
+        .update(input.resources?.[base] ?? '')
+        .digest(),
+    )
+  }
+  for (const name of Object.keys(input.images ?? {}).sort()) {
+    const image = input.images?.[name]
+    if (!image) continue
+    hash.update(createHash('sha256').update(name).digest())
+    hash.update(createHash('sha256').update(image.file).digest())
+    hash.update(createHash('sha256').update(image.data).digest())
+  }
+  const targets = compileTargets(input)
+  if (targets.length > 0) {
+    hash.update(`swift-multi/v${MULTI_MANIFEST_VERSION}\n`)
+    hash.update(
+      JSON.stringify({
+        targets,
+        siblings: [...swiftSiblingDependencies(input.files, targets)].sort((a, b) =>
+          String(a) < String(b) ? -1 : String(a) > String(b) ? 1 : 0,
+        ),
+      }),
+    )
+  }
+  return hash.digest('hex')
+}
+
+export function emitSwiftPackageManifest(args: {
+  targets: SwiftPackageTarget[]
+  siblings: Map<string, string[]>
+  moduleRoot: string
+}): string {
+  const { targets, siblings, moduleRoot } = args
+  const executable = targets.find((target) => target.executable)
+  if (!executable) throw new Error('swift-compile: no executable target to emit')
+  const swiftSettings =
+    'swiftSettings: [.swiftLanguageMode(.v5), .unsafeFlags(["-Osize"])]'
+  const stanza = (target: SwiftPackageTarget): string => {
+    const deps = [
+      '.product(name: "SwiftUI", package: "sootsim-swift")',
+      ...(siblings.get(target.name) ?? []).map((sibling) => `"${sibling}"`),
+    ].join(', ')
+    const kind = target.executable ? '.executableTarget' : '.target'
+    const link = target.executable
+      ? `,
+      linkerSettings: [
+        .unsafeFlags([
+          "-Xclang-linker", "-mexec-model=reactor",
+          "-Xlinker", "--export-if-defined=__main_argc_argv",
+        ]),
+        .unsafeFlags(["-Xlinker", "--strip-all"], .when(configuration: .release)),
+      ]`
+      : ''
+    return [
+      `    ${kind}(`,
+      `      name: "${target.name}",`,
+      `      dependencies: [${deps}],`,
+      `      path: "${target.path}",`,
+      `      ${swiftSettings}${link}`,
+      `    ),`,
+    ].join('\n')
+  }
+  return [
+    '// swift-tools-version: 6.0',
+    'import PackageDescription',
+    '',
+    '// generated by swift-compile from the project package partition.',
+    'let package = Package(',
+    '  name: "app",',
+    `  products: [.executable(name: "${executable.name}", targets: ["${executable.name}"])],`,
+    `  dependencies: [.package(path: "${moduleRoot}")],`,
+    '  targets: [',
+    ...targets.map(stanza),
+    '  ]',
+    ')',
+    '',
+  ].join('\n')
+}
+
+export function writeSwiftProject(
+  layout: SwiftProjectLayout,
+  input: SwiftCompileInput,
+  moduleRoot: string,
+): void {
+  const targets = compileTargets(input)
+  if (targets.length === 0) {
+    rmSync(layout.sources, { recursive: true, force: true })
+    for (const [file, contents] of Object.entries(input.files)) {
+      const target = path.join(layout.sources, file)
+      mkdirSync(path.dirname(target), { recursive: true })
+      writeFileSync(target, contents, 'utf8')
+    }
+    const manifest = readFileSync(
+      path.join(moduleRoot, 'scripts/contrast-app-Package.swift'),
+      'utf8',
+    ).replaceAll('__SOOTSIM_SWIFT_PACKAGE__', moduleRoot)
+    writeFileSync(path.join(layout.root, 'Package.swift'), manifest, 'utf8')
+    return
+  }
+  mkdirSync(layout.root, { recursive: true })
+  for (const child of readdirSync(layout.root)) {
+    if (child === '.build') continue
+    rmSync(path.join(layout.root, child), { recursive: true, force: true })
+  }
+  for (const [file, contents] of Object.entries(input.files)) {
+    if (file === 'Package.swift') continue
+    const target = path.join(layout.root, file)
+    mkdirSync(path.dirname(target), { recursive: true })
+    writeFileSync(target, contents, 'utf8')
+  }
+  writeFileSync(
+    path.join(layout.root, 'Package.swift'),
+    emitSwiftPackageManifest({
+      targets,
+      siblings: swiftSiblingDependencies(input.files, targets),
+      moduleRoot,
+    }),
+    'utf8',
+  )
+}
+
+function streamText(value: unknown): string {
+  if (typeof value === 'string') return value.trim()
+  if (Buffer.isBuffer(value)) return value.toString('utf8').trim()
+  return ''
+}
+
+function outputOf(error: unknown): string {
+  if (error && typeof error === 'object') {
+    const streams = [
+      streamText(Reflect.get(error, 'stdout')),
+      streamText(Reflect.get(error, 'stderr')),
+    ].filter(Boolean)
+    if (streams.length > 0) return streams.join('\n')
+  }
+  return error instanceof Error ? error.message : String(error)
+}
+
+function builtArtifact(layout: SwiftProjectLayout): string {
+  const binDir = path.join(layout.root, '.build', WASM_TRIPLE, 'release')
+  const artifacts = existsSync(binDir)
+    ? readdirSync(binDir)
+        .filter((name) => name.endsWith('.wasm'))
+        .sort()
+    : []
+  if (artifacts.length !== 1) {
+    throw new Error(
+      `swift-compile: the build produced ${artifacts.length} wasm artifacts; exactly one executable is the app`,
+    )
+  }
+  return path.join(binDir, artifacts[0])
+}
+
+function projectDiagnostic(output: string, layout: SwiftProjectLayout): string {
+  const base = layout.multi ? layout.root : layout.sources
+  const prefix = `${base}${path.sep}`
+  return output
+    .split('\n')
+    .map((line) => (line.startsWith(prefix) ? line.slice(prefix.length) : line))
+    .join('\n')
+    .trim()
+}
+
+const ROOT_LOCKS = Symbol.for('peachsim.swiftCompile.rootLocks')
+const host = globalThis as typeof globalThis & {
+  [ROOT_LOCKS]?: Map<string, Promise<unknown>>
+}
+const rootLocks = (host[ROOT_LOCKS] ??= new Map())
+
+function serialize<T>(root: string, work: () => Promise<T>): Promise<T> {
+  const current = rootLocks.get(root) ?? Promise.resolve()
+  const next = current.then(work, work)
+  rootLocks.set(
+    root,
+    next.catch(() => {}),
+  )
+  return next
+}
+
+/** the one local compiler used by the route host and Vite host. */
+export function compileSwiftProjectUnit(
+  input: SwiftCompileInput,
+  options: SwiftCompileOptions,
+): Promise<SwiftCompileArtifact> {
+  mkdirSync(options.buildRoot, { recursive: true })
+  const root = realpathSync(options.buildRoot)
+  const moduleRoot = path.resolve(options.moduleRoot)
+  const layout: SwiftProjectLayout = {
+    root,
+    sources: path.join(root, 'Sources', 'App'),
+    multi: compileTargets(input).length > 0,
+  }
+  const hash = swiftArtifactHash(input, options.release, moduleRoot)
+  return serialize(root, async () => {
+    writeSwiftProject(layout, input, moduleRoot)
+    const swift = path.join(options.toolchainBin, 'swift')
+    if (!existsSync(swift)) {
+      throw new Error(
+        `swift-compile: no swift.org toolchain at ${options.toolchainBin}; install ${options.release} and its matching wasm sdk`,
+      )
+    }
+    try {
+      await run(
+        swift,
+        [
+          'build',
+          '--package-path',
+          root,
+          '--swift-sdk',
+          `${options.release}_wasm`,
+          '-c',
+          'release',
+          '-Xswiftc',
+          '-Osize',
+        ],
+        { maxBuffer: 64 * 1024 * 1024, timeout: options.timeoutMs },
+      )
+    } catch (error) {
+      throw new Error(projectDiagnostic(outputOf(error), layout), { cause: error })
+    }
+    return { hash, bytes: readFileSync(builtArtifact(layout)) }
+  })
+}

package/src/swift-package.ts

@@ -0,0 +1,69 @@
+/** one SwiftPM target a sent root manifest declares. */
+export interface SwiftPackageTarget {
+  /** the target name, as `import <name>` spells it. */
+  name: string
+  /** project-relative directory holding the target's sources. */
+  path: string
+  /** true for `.executableTarget`: the one that links the wasm artifact. */
+  executable: boolean
+}
+
+/** whether a project-relative key is a SwiftPM manifest, not a source. */
+export function isSwiftManifestFile(file: string): boolean {
+  const segments = file.split('/')
+  return segments[segments.length - 1] === 'Package.swift'
+}
+
+/**
+ * the library and executable targets a sent root manifest declares, in order.
+ *
+ * A manifest is Swift code, not data, so this is a scanner, not a parser:
+ * each `.target(` / `.executableTarget(` call is matched to its balanced
+ * close paren (string-aware, so a paren inside a literal cannot end it
+ * early), and `name:` / `path:` are read from the call's own depth only, so
+ * a nested `.product(name: "SwiftUI", ...)` inside dependencies never wins.
+ */
+export function swiftManifestTargets(manifest: string): SwiftPackageTarget[] {
+  const code = manifest.replace(/\/\*[\s\S]*?\*\//g, '').replace(/\/\/[^\n]*/g, '')
+  const targets: SwiftPackageTarget[] = []
+  const pattern = /\.(executableTarget|target)\s*\(/g
+  let match: RegExpExecArray | null
+  while ((match = pattern.exec(code)) !== null) {
+    const executable = match[1] === 'executableTarget'
+    let depth = 1
+    let i = pattern.lastIndex
+    let inString = false
+    let escaped = false
+    let flat = ''
+    while (i < code.length && depth > 0) {
+      const ch = code[i]
+      if (inString) {
+        if (escaped) escaped = false
+        else if (ch === '\\') escaped = true
+        else if (ch === '"') inString = false
+        if (depth === 1) flat += ch
+      } else if (ch === '"') {
+        inString = true
+        if (depth === 1) flat += ch
+      } else if (ch === '(') {
+        depth++
+        if (depth === 1) flat += ch
+      } else if (ch === ')') {
+        depth--
+        if (depth >= 1) flat += ch
+      } else if (depth === 1) {
+        flat += ch
+      }
+      i++
+    }
+    const name = /\bname\s*:\s*"([^"]+)"/.exec(flat)?.[1]
+    if (!name) continue
+    const rawPath = /\bpath\s*:\s*"([^"]*)"/.exec(flat)?.[1]
+    const targetPath =
+      rawPath == null || rawPath === ''
+        ? `Sources/${name}`
+        : rawPath.replace(/^\.\//, '').replace(/\/+$/, '')
+    targets.push({ name, path: targetPath, executable })
+  }
+  return targets
+}

package/src/swift-submit.ts

@@ -7,8 +7,9 @@
  * its own origin's `/api/swift-compile`), the node bundle builder used by
  * the test-drive CLI and the deploy publisher (posts an absolute endpoint),
  * and the One/rolldown `.swift` transform (same, with a `ccdn_` credential).
- * A caller never compiles in-process: the container is the one compiler, and
- * no bundler is that instance.
+ * Remote callers never compile in-process: the container is the compiler for
+ * this path. The local Vite host uses the same project-unit compiler directly
+ * and does not pass through this HTTP adapter.
  *
  * It lives here (rather than in the app's `src/bundler/`) because the One
  * transform ships in this package and cannot import app code; the app's own

package/src/vite-plugin-one.ts

@@ -3,7 +3,7 @@
 // bound to that directory across an active-runtime update.
 //
 // usage in vite.config.ts:
-//   import { rnxPlugin } from 'rnxsim/vite'
+//   import { rnxPlugin } from 'peachsim/vite'
 //   export default { plugins: [one(), rnxPlugin()] }
 
 import fs from 'fs'