peachsim 0.1.570 → 0.1.571

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "peachsim",
-  "version": "0.1.570",
+  "version": "0.1.571",
   "description": "Vite and Metro plugins, testing drivers, and SDK exports for peach.",
   "author": "Tamagui LLC",
   "license": "SEE LICENSE IN LICENSE",
@@ -46,6 +46,20 @@
       "import": "./dist-lib/swift-submit.mjs",
       "default": "./dist-lib/swift-submit.cjs"
     },
+    "./swift-package": {
+      "types": "./src/swift-package.ts",
+      "source": "./src/swift-package.ts",
+      "bun": "./src/swift-package.ts",
+      "import": "./dist-lib/swift-package.mjs",
+      "default": "./dist-lib/swift-package.cjs"
+    },
+    "./swift-compile": {
+      "types": "./src/swift-compile.ts",
+      "source": "./src/swift-compile.ts",
+      "bun": "./src/swift-compile.ts",
+      "import": "./dist-lib/swift-compile.mjs",
+      "default": "./dist-lib/swift-compile.cjs"
+    },
     "./metro": {
       "source": "./src/metro-plugin.ts",
       "default": "./dist-lib/metro.cjs"
@@ -150,6 +164,13 @@
       "import": "./dist-lib/cloud-contract.mjs",
       "default": "./dist-lib/cloud-contract.cjs"
     },
+    "./cloud-test-args": {
+      "types": "./src/cloud-test-args.ts",
+      "source": "./src/cloud-test-args.ts",
+      "bun": "./src/cloud-test-args.ts",
+      "import": "./dist-lib/cloud-test-args.mjs",
+      "default": "./dist-lib/cloud-test-args.cjs"
+    },
     "./cloud": {
       "types": "./src/cloud.ts",
       "source": "./src/cloud.ts",

package/skills/rnx-test/SKILL.md

@@ -238,7 +238,7 @@ upstream detox surface.
 ```js
 // rnx-detox.config.cjs
 module.exports = {
-  preset: 'rnxsim/detox',
+  preset: 'peachsim/detox',
   rootDir: __dirname,
   testMatch: ['<rootDir>/e2e/**/*.test.ts'],
 }
@@ -248,7 +248,7 @@ or, if you already have a jest config, pull in just the module mapper:
 
 ```js
 moduleNameMapper: {
-  '^detox$': require.resolve('rnxsim/detox'),
+  '^detox$': require.resolve('peachsim/detox'),
 }
 ```
 
@@ -294,7 +294,7 @@ rnx detox init                        # scaffold config + e2e/example.test.ts
 - **"no Peach shell reachable"** — start one yourself
   (`rnx open <port>`) or pass `--port <n>`.
 - **"jest cannot find module 'detox'"** — the preset isn't wired. confirm
-  `preset: 'rnxsim/detox'` is in the jest config jest
+  `preset: 'peachsim/detox'` is in the jest config jest
   actually loaded (`--config` overrides package.json).
 - **matchers fail on elements that exist** — canvas has no DOM. use
   `by.id` (testID); `rnx describe` shows what the shell sees.

package/src/cloud-test-args.ts

@@ -0,0 +1,100 @@
+// hosted `rnx test` selection args: the argv slice a cloud submitter
+// forwards and the recorder appends verbatim to its executor invocation.
+//
+// selection only. the flags below choose WHICH tests run; everything
+// about HOW they run (workers, timeouts, shards, devices, environment)
+// stays with the recorder that owns the execution environment, and
+// everything about WHERE they run (app, origin, tunnel) is consumed by
+// the submitter. a flag outside this list never reaches the executor:
+// the submitter warns and the server refuses, so a filter is never
+// silently dropped. pure: the gpu recorder daemon imports this too, so
+// no ~/ aliases, no server-only, no node builtins.
+export const CLOUD_TEST_ARGS_MAX_COUNT = 32
+export const CLOUD_TEST_ARG_MAX_LENGTH = 1000
+export const CLOUD_TEST_ARGS_MAX_BYTES = 16 * 1024
+
+// every flag a hosted job honors from the submitting command line. each
+// takes exactly one value, as a separate token or --flag=value.
+export const CLOUD_TEST_VALUE_FLAGS: readonly string[] = [
+  '-t',
+  '--testNamePattern',
+  '--testPathPattern',
+  '--include-tags',
+  '--exclude-tags',
+  '--grep',
+]
+
+const CLOUD_TEST_VALUE_FLAG_SET = new Set<string>(CLOUD_TEST_VALUE_FLAGS)
+
+export function isCloudTestValueFlag(name: string): boolean {
+  return CLOUD_TEST_VALUE_FLAG_SET.has(name)
+}
+
+export type CloudTestArgsVerdict =
+  | { ok: true; args: string[] }
+  | { ok: false; message: string }
+
+// the submit payload's testArgs field, or null when the submission
+// carries no selection. every violation names the offending arg.
+export function parseCloudTestArgs(value: unknown): CloudTestArgsVerdict {
+  if (value === undefined || value === null) return { ok: true, args: [] }
+  if (!Array.isArray(value)) {
+    return { ok: false, message: 'testArgs must be an array of strings' }
+  }
+  if (value.length > CLOUD_TEST_ARGS_MAX_COUNT) {
+    return {
+      ok: false,
+      message: `testArgs may contain at most ${CLOUD_TEST_ARGS_MAX_COUNT} entries`,
+    }
+  }
+  // utf-8 bytes, not utf-16 code units: the bound names bytes, and a
+  // multibyte pattern must not slip twice its size past the gate.
+  const encoder = new TextEncoder()
+  let bytes = 0
+  const entries: string[] = []
+  for (const entry of value) {
+    if (typeof entry !== 'string' || entry.length === 0) {
+      return { ok: false, message: 'testArgs entries must be non-empty strings' }
+    }
+    if (entry.length > CLOUD_TEST_ARG_MAX_LENGTH || entry.includes('\0')) {
+      return { ok: false, message: `testArgs entry is too long or carries a NUL byte: ${entry.slice(0, 60)}` }
+    }
+    bytes += encoder.encode(entry).length
+    if (bytes > CLOUD_TEST_ARGS_MAX_BYTES) {
+      return {
+        ok: false,
+        message: `testArgs may contain at most ${CLOUD_TEST_ARGS_MAX_BYTES} bytes`,
+      }
+    }
+    entries.push(entry)
+  }
+  const args: string[] = []
+  for (let i = 0; i < entries.length; i++) {
+    const entry = entries[i]
+    if (!entry.startsWith('-')) {
+      return {
+        ok: false,
+        message: `testArgs carries a positional argument (selection flags only): ${entry.slice(0, 60)}`,
+      }
+    }
+    const eq = entry.indexOf('=')
+    const head = eq > 0 ? entry.slice(0, eq) : entry
+    if (!isCloudTestValueFlag(head)) {
+      return { ok: false, message: `testArgs carries an unknown flag: ${head.slice(0, 60)}` }
+    }
+    if (eq > 0) {
+      if (!entry.slice(eq + 1)) {
+        return { ok: false, message: `${head} expects a value` }
+      }
+      args.push(entry)
+      continue
+    }
+    const val = entries[i + 1]
+    if (val === undefined || val.startsWith('-')) {
+      return { ok: false, message: `${head} expects a value` }
+    }
+    args.push(entry, val)
+    i += 1
+  }
+  return { ok: true, args }
+}

package/src/rolldown-plugin-swift.ts

@@ -2,13 +2,14 @@
 // swiftpm package to `/api/swift-compile` and answer every `.swift` import
 // with the module that mounts the published artifact.
 //
-// this is the remote twin of `vite-plugin-swift.ts`. that plugin runs the
-// local toolchain and serves the artifact from dev-server middleware; the
-// native engine is its own rolldown instance with no middleware seam, so
-// this plugin compiles nothing in-process and serves nothing. the artifact
-// url the service answers is absolute (compile-cdn), so there is nothing to
-// serve. same compiler, same store, same hash, same credential as the
-// browser worker — one path, no second toolchain to install for `one dev`.
+// this is the remote twin of `vite-plugin-swift.ts`. that plugin calls the
+// shared project-unit compiler and serves the artifact from dev-server
+// middleware. the native engine is its own rolldown instance with no
+// middleware seam, so this plugin compiles nothing in-process and serves
+// nothing. the artifact url the service answers is absolute (compile-cdn), so
+// there is nothing to serve. same compiler, same store, same hash, same
+// credential as the browser worker — one path, no second toolchain to install
+// for `one dev`.
 //
 // an app registers it through One's native plugin seam, not `config.plugins`
 // (which never reach the native engine):

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