peachsim 0.1.570 → 0.1.572

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

@@ -1,5 +1,5 @@
 // sootsim plugin for One/Vite — serves the installed sootsim runtime at /__soot/
-// from ~/.rnx/runtimes/<version>. version-owned localhost origins remain
+// from ~/.peach/runtimes/<version>. version-owned localhost origins remain
 // bound to that directory across an active-runtime update.
 //
 // usage in vite.config.ts:
@@ -35,8 +35,8 @@ export interface RnxPluginOptions {
   prefix?: string
   // disable sootsim
   enabled?: boolean
-  // launch the sootsim simulator loading this server's bundle once the dev
-  // server is listening. skipped when CI or RNX_NO_OPEN is set.
+  // launch the peach simulator loading this server's bundle once the dev
+  // server is listening. skipped when CI or PEACH_NO_OPEN is set.
   open?: RnxDesktopOpenOption
 }
 
@@ -96,7 +96,7 @@ export function rnxPlugin(options: RnxPluginOptions = {}): Plugin {
             : DEFAULT_SOOTSIM_BRIDGE_PORT
         // inject the bridge port + a default bundle (only when the URL has none,
         // so the CLI's resolved bundle wins), and PRESERVE the existing query.
-        // preserving the query is essential: `rnx open` stamps the open URL
+        // preserving the query is essential: `peach open` stamps the open URL
         // with `inspectOpen=<token>` and matches the registered sim by that
         // token (waitForSimMatch). the old code forced `?bundle=` only and
         // stripped inspectOpen, so the sim registered but never matched and
@@ -134,7 +134,7 @@ export function rnxPlugin(options: RnxPluginOptions = {}): Plugin {
       // bundle. dev-bundle-resolution's resolvePortViaServerScan fetches
       // `/__server-scan` RELATIVE to the shell origin; when the shell is loaded
       // from this target origin, that hits here. without it the request SPA-
-      // falls-back to 404 and the bundle never resolves (rnx open hangs).
+      // falls-back to 404 and the bundle never resolves (peach open hangs).
       // we describe only this server (the shell drives THIS app) — no localhost-
       // wide scan, so the published plugin pulls in no shell-only scanner
       // internals. shape matches DiscoveredServer enough for the resolver.
@@ -198,7 +198,7 @@ export function rnxPlugin(options: RnxPluginOptions = {}): Plugin {
           }
         }
 
-        // serve the sootsim HTML shell — inject bundle URL + bridge port
+        // serve the peach HTML shell — inject bundle URL + bridge port
         if (pathname === prefix || pathname === prefix + '/') {
           res.setHeader('content-type', 'text/html')
           res.end(buildShellHtml(runtimeRoot))
@@ -230,9 +230,9 @@ export function rnxPlugin(options: RnxPluginOptions = {}): Plugin {
 
       const port = configuredPort
       const sootsimUrl = `http://localhost:${port}${prefix}/`
-      console.log(`[rnx] serving at ${sootsimUrl}`)
+      console.log(`[peach] serving at ${sootsimUrl}`)
 
-      if (appName && !process.env.CI && !process.env.RNX_NO_OPEN) {
+      if (appName && !process.env.CI && !process.env.PEACH_NO_OPEN) {
         server.httpServer?.once('listening', () => {
           const openPort = listeningPort()
           launchRnxDesktop(