peachsim 0.1.1635 → 0.1.1641

package/src/swift-objc-standin.ts

@@ -13,11 +13,12 @@
 // headers import; the stand-in's own typecheck then leaves out whatever peach
 // cannot spell.
 
-import { spawnSync } from 'node:child_process'
+import { execFileSync, spawnSync } from 'node:child_process'
 import { createHash } from 'node:crypto'
 import fs from 'node:fs'
 import path from 'node:path'
 import { IOS_SDK_HEADERS, IOS_SDK_OVERLAYS, IOS_SDK_TARGET } from './swift-objc-sdk'
+import { swiftEnvironment } from './swift-toolchain'
 import type { SymbolGraph } from './swift-standin-emit'
 
 /** a module map and the headers it reaches: a framework's, or a library
@@ -37,6 +38,100 @@ export interface ObjcView {
   imports: string[]
 }
 
+/** bump when importer behavior changes the Swift view independently of SDK headers. */
+export const OBJC_IMPORT_VERSION = '3'
+
+export const NATIVE_GRAPH_SDK_VERSION = '27.1'
+
+const NATIVE_GRAPH_INPUTS = {
+  sdk: NATIVE_GRAPH_SDK_VERSION,
+  settings: 'e68503e5e534e9194af5efe8c636ca8b824e2d8237c5f38ec84aa4d155bc8418',
+  build: 'ff785237ba22f1d8f347a5c4f4c68400a387c6d935ef3a443545a72faef57e70',
+  compiler: 'Apple Swift version 6.4 (swiftlang-6.4.0.34.1 clang-2100.3.34.1)',
+  target: IOS_SDK_TARGET,
+}
+export const NATIVE_GRAPH_ID = createHash('sha256')
+  .update(JSON.stringify(NATIVE_GRAPH_INPUTS))
+  .digest('hex')
+
+/** a mixed framework's swift overlay and underlying clang module load together. */
+export function nativeInterfaceView(
+  surface: ObjcSurface,
+  frameworks: readonly string[],
+  work: string,
+): ObjcView {
+  if (process.platform !== 'darwin')
+    throw new Error('mixed framework declarations require the pinned native iOS SDK')
+  const xcrun = (args: string[]) =>
+    execFileSync('xcrun', args, {
+      encoding: 'utf8',
+      stdio: ['ignore', 'pipe', 'pipe'],
+    }).trim()
+  const sdk = xcrun(['--sdk', 'iphonesimulator', '--show-sdk-path'])
+  const compiler = xcrun(['--find', 'swiftc'])
+  const version = execFileSync(compiler, ['--version'], { encoding: 'utf8' })
+    .trim()
+    .split('\n')[0]
+  const digest = (file: string) =>
+    createHash('sha256')
+      .update(fs.readFileSync(path.join(sdk, file)))
+      .digest('hex')
+  const actual = {
+    sdk: xcrun(['--sdk', 'iphonesimulator', '--show-sdk-version']),
+    compiler: version,
+    settings: digest('SDKSettings.json'),
+    build: digest('System/Library/CoreServices/SystemVersion.plist'),
+  }
+  const mismatches = Object.entries(actual)
+    .filter(([key, value]) => Reflect.get(NATIVE_GRAPH_INPUTS, key) !== value)
+    .map(
+      ([key, value]) =>
+        `${key}: expected ${Reflect.get(NATIVE_GRAPH_INPUTS, key)}, got ${value}`,
+    )
+  if (mismatches.length)
+    throw new Error(
+      `native declaration SDK or compiler differs from ${NATIVE_GRAPH_ID}: ${mismatches.join('; ')}`,
+    )
+  const toolchainBin = path.dirname(compiler)
+  const search = ['-sdk', sdk, ...frameworks.flatMap((dir) => ['-F', dir])]
+  const out = path.join(work, 'native-graphs')
+  fs.mkdirSync(out, { recursive: true })
+  const run = spawnSync(
+    path.join(toolchainBin, 'swift-symbolgraph-extract'),
+    [
+      '-module-name',
+      surface.module,
+      '-target',
+      IOS_SDK_TARGET,
+      ...search,
+      '-minimum-access-level',
+      'public',
+      '-skip-synthesized-members',
+      '-omit-extension-block-symbols',
+      '-output-dir',
+      out,
+    ],
+    { encoding: 'utf8', maxBuffer: 256 * 1024 * 1024 },
+  )
+  if (run.error) throw run.error
+  if (run.status !== 0)
+    throw new Error(
+      `native interface extraction ${run.signal ?? `exit ${run.status}`}: ${run.stderr.trim().slice(-4000)}`,
+    )
+  const graphs = fs
+    .readdirSync(out)
+    .filter((file) => file.endsWith('.symbols.json'))
+    .sort()
+    .map((file): SymbolGraph => JSON.parse(fs.readFileSync(path.join(out, file), 'utf8')))
+  if (graphs.length === 0)
+    throw new Error('native interface extraction returned no graphs')
+  return {
+    graphs,
+    values: enumValues(graphs, surface, true, toolchainBin, search, work),
+    imports: [],
+  }
+}
+
 // the opaque declarations a failed import asks for, by name.
 type Missing = Map<string, 'class' | 'protocol' | 'struct' | 'macro'>
 
@@ -63,7 +158,7 @@ export const IOS_SDK_ID = createHash('sha256')
 
 // the sdk, written once per content under the cache directory so the module
 // cache keyed by its paths stays warm across stand-ins.
-function iosSdk(cacheDir: string): string {
+export function materializeObjcSdk(cacheDir: string): string {
   const sdk = path.join(cacheDir, 'ios-sdk', IOS_SDK_ID)
   if (fs.existsSync(sdk)) return sdk
   fs.mkdirSync(path.dirname(sdk), { recursive: true })
@@ -116,7 +211,7 @@ export function objcView(
     throw new Error(
       `this peach's Swift has no iOS simulator standard library at ${stdlib}`,
     )
-  const sdk = iosSdk(cacheDir)
+  const sdk = materializeObjcSdk(cacheDir)
   // a framework's module map sits in Modules/ beside Headers/; a library
   // slice keeps it among its headers.
   const framework = path.basename(path.dirname(surface.modulemap)) === 'Modules'
@@ -127,13 +222,13 @@ export function objcView(
     : path.join(include, surface.module)
   const originals = new Map(
     headerFiles(surface.headers).map((file) => [
-      file,
+      path.join(headersDir, file),
       fs.readFileSync(path.join(surface.headers, file), 'utf8'),
     ]),
   )
   for (const [file, text] of originals) {
-    fs.mkdirSync(path.dirname(path.join(headersDir, file)), { recursive: true })
-    fs.writeFileSync(path.join(headersDir, file), text)
+    fs.mkdirSync(path.dirname(file), { recursive: true })
+    fs.writeFileSync(file, text)
   }
   if (framework) {
     fs.mkdirSync(path.join(frameworks, `${surface.module}.framework`, 'Modules'), {
@@ -146,12 +241,18 @@ export function objcView(
   } else {
     fs.copyFileSync(surface.modulemap, path.join(headersDir, 'module.modulemap'))
   }
+  // dependency headers take the same learned declarations but never become
+  // the surface's own imports.
+  const dependencyOriginals = new Map<string, string>()
   for (const dependency of surface.dependencies ?? []) {
     const dir = path.join(include, dependency.module)
     fs.mkdirSync(dir, { recursive: true })
     for (const file of headerFiles(dependency.headers)) {
-      fs.mkdirSync(path.dirname(path.join(dir, file)), { recursive: true })
-      fs.copyFileSync(path.join(dependency.headers, file), path.join(dir, file))
+      const destination = path.join(dir, file)
+      const text = fs.readFileSync(path.join(dependency.headers, file), 'utf8')
+      dependencyOriginals.set(destination, text)
+      fs.mkdirSync(path.dirname(destination), { recursive: true })
+      fs.writeFileSync(destination, text)
     }
     const supplied = path.join(dependency.headers, 'module.modulemap')
     fs.writeFileSync(
@@ -168,6 +269,13 @@ export function objcView(
   const search = [
     '-sdk',
     sdk,
+    // keep compiler support headers without importing host platform modules.
+    '-resource-dir',
+    path.join(sdk, 'usr/lib/swift'),
+    '-I',
+    path.resolve(toolchainBin, '../lib/swift/clang/include'),
+    '-I',
+    path.resolve(toolchainBin, '../lib/swift/shims'),
     '-I',
     stdlib,
     '-F',
@@ -237,8 +345,8 @@ export function objcView(
       path.join(root, 'Modules', 'module.modulemap'),
       'framework module PeachMissing {\n  umbrella header "PeachMissing.h"\n  export *\n}\n',
     )
-    for (const [file, text] of originals)
-      fs.writeFileSync(path.join(headersDir, file), `${MISSING_IMPORT}${text}`)
+    for (const [file, text] of [...originals, ...dependencyOriginals])
+      fs.writeFileSync(file, `${MISSING_IMPORT}${text}`)
   }
   // the identifier a diagnostic points at, read from the header as compiled.
   const tokenAt = (file: string, line: number, column: number) => {
@@ -276,11 +384,11 @@ export function objcView(
         '-output-dir',
         out,
       ],
-      { encoding: 'utf8', maxBuffer: 256 * 1024 * 1024 },
+      { encoding: 'utf8', env: swiftEnvironment(), maxBuffer: 256 * 1024 * 1024 },
     )
     if (run.error) throw run.error
     const errors = [
-      ...run.stderr.matchAll(/^(?:(\S+?):(\d+):(\d+): )?(?:fatal )?error: (.*)$/gm),
+      ...run.stderr.matchAll(/^(?:(.+?):(\d+):(\d+): )?(?:fatal )?error: (.*)$/gm),
     ]
     if (errors.length === 0 && run.status === 0) break
     let progress = false
@@ -322,7 +430,11 @@ export function objcView(
     }
     if (!progress || round === ROUNDS)
       throw new Error(
-        `its headers do not import as Swift: ${[...new Set(errors.map((match) => match[4]!))].slice(0, 10).join('; ')}`,
+        `its headers do not import as Swift: ${
+          errors.length > 0
+            ? [...new Set(errors.map((match) => match[4]!))].slice(0, 10).join('; ')
+            : `swift-symbolgraph-extract ${run.signal ?? `exit ${run.status}`}: ${(run.stderr.trim() || run.stdout.trim() || 'no diagnostic').slice(0, 4000)}`
+        }`,
       )
     if (missing.size > 0) declareMissing()
   }
@@ -405,7 +517,7 @@ function enumValues(
       '-ast-dump=json',
       probe,
     ],
-    { encoding: 'utf8', maxBuffer: 1024 * 1024 * 1024 },
+    { encoding: 'utf8', env: swiftEnvironment(), maxBuffer: 1024 * 1024 * 1024 },
   )
   if (run.status !== 0)
     throw new Error(

package/src/swift-package-manifest.ts

@@ -11,7 +11,7 @@ import fs from 'node:fs'
 import path from 'node:path'
 import { cacheDir as peachCacheDir, swiftPackageCacheOptions } from './home-paths'
 import lock from './swift-distribution.lock.json' with { type: 'json' }
-import { swiftToolchainBin } from './swift-toolchain'
+import { swiftEnvironment, swiftToolchainBin } from './swift-toolchain'
 import type { SwiftTargetDependency } from './swift-package'
 
 const TARGET_TYPES = [
@@ -49,6 +49,11 @@ export interface SwiftManifestTarget {
   mainActorIsolation: boolean
   defines: SwiftManifestSetting[]
   libraries: SwiftManifestSetting[]
+  nativeSettings: {
+    tool: 'c' | 'cxx'
+    flags: string[]
+    configuration: 'debug' | 'release' | null
+  }[]
   /** true when the target declares `resources:`. */
   declaresResources: boolean
   /** public header directory relative to the target, as SwiftPM declares it. */
@@ -121,6 +126,7 @@ function dump(dir: string): { key: string; raw: Record<string, Json> } {
       ],
       {
         encoding: 'utf8',
+        env: swiftEnvironment(),
         stdio: ['ignore', 'pipe', 'pipe'],
         maxBuffer: 64 * 1024 * 1024,
       },
@@ -255,9 +261,43 @@ export function swiftPackageManifest(dir: string): SwiftPackageManifest {
     let mainActorIsolation = false
     const defines: SwiftManifestSetting[] = []
     const libraries: SwiftManifestSetting[] = []
+    const nativeSettings: SwiftManifestTarget['nativeSettings'] = []
+    for (const [tool, standard] of [
+      ['c', string(raw.cLanguageStandard)],
+      ['cxx', string(raw.cxxLanguageStandard)],
+    ] satisfies ['c' | 'cxx', string | undefined][]) {
+      if (standard)
+        nativeSettings.push({ tool, flags: [`-std=${standard}`], configuration: null })
+    }
     for (const setting of array(target.settings)) {
       const { kind: rawKind, tool, condition } = record(setting)
       const settingKind = record(rawKind)
+      if ((tool === 'c' || tool === 'cxx') && linksOnIOS(condition, traits)) {
+        const config = string(record(condition).config)
+        const header = string(record(settingKind.headerSearchPath)._0)
+        const definition = string(record(settingKind.define)._0)
+        const value = string(record(settingKind.define)._1)
+        const disabledWarning = string(record(settingKind.disableWarning)._0)
+        const unsafe = record(settingKind.unsafeFlags)._0
+        const flags = header
+          ? ['-I', path.resolve(targetDir, header)]
+          : definition
+            ? [`-D${definition}${value === undefined ? '' : `=${value}`}`]
+            : disabledWarning !== undefined
+              ? [`-Wno-${disabledWarning}`]
+              : Array.isArray(unsafe)
+                ? unsafe.flatMap((flag) => string(flag) ?? [])
+                : null
+        if (!flags)
+          throw new Error(
+            `${name}: unsupported ${tool} compiler setting ${JSON.stringify(rawKind)}`,
+          )
+        nativeSettings.push({
+          tool,
+          flags,
+          configuration: config === 'debug' || config === 'release' ? config : null,
+        })
+      }
       const mode = string(record(settingKind.swiftLanguageMode)._0)
       if (mode)
         languageMode = Math.max(5, Number(/^(\d+)/.exec(mode)?.[1] ?? languageMode))
@@ -299,6 +339,7 @@ export function swiftPackageManifest(dir: string): SwiftPackageManifest {
       mainActorIsolation,
       defines,
       libraries,
+      nativeSettings,
       declaresResources: array(target.resources).length > 0,
       publicHeadersPath: string(target.publicHeadersPath) ?? 'include',
       url: string(target.url) ?? null,

package/src/swift-packages.ts

@@ -106,25 +106,39 @@ interface Pin {
   revision: string
 }
 
-function readPins(resolved: string): Map<string, Pin> {
-  const data: unknown = JSON.parse(fs.readFileSync(resolved, 'utf8'))
-  const pins =
-    data && typeof data === 'object' && 'pins' in data && Array.isArray(data.pins)
-      ? data.pins
-      : null
-  if (!pins)
-    throw new Error(`${resolved} has no pins; resolve packages in a current Xcode`)
+function readPins(resolved: readonly string[]): Map<string, Pin> {
   const out = new Map<string, Pin>()
-  for (const pin of pins) {
-    const identity = pin?.identity
-    const location = pin?.location
-    const revision = pin?.state?.revision
-    if (
-      typeof identity === 'string' &&
-      typeof location === 'string' &&
-      typeof revision === 'string'
-    )
-      out.set(identity, { location, revision })
+  const owners = new Map<string, string>()
+  for (const file of resolved) {
+    const data: unknown = JSON.parse(fs.readFileSync(file, 'utf8'))
+    const pins =
+      data && typeof data === 'object' && 'pins' in data && Array.isArray(data.pins)
+        ? data.pins
+        : null
+    if (!pins) throw new Error(`${file} has no pins; resolve packages in a current Xcode`)
+    for (const pin of pins) {
+      const identity = pin?.identity
+      const location = pin?.location
+      const revision = pin?.state?.revision
+      if (
+        typeof identity === 'string' &&
+        typeof location === 'string' &&
+        typeof revision === 'string'
+      ) {
+        const previous = out.get(identity)
+        const repository = (url: string) => url.replace(/(?:\.git)?\/?$/, '')
+        if (
+          previous &&
+          (previous.revision !== revision ||
+            repository(previous.location) !== repository(location))
+        )
+          throw new Error(
+            `conflicting Package.resolved pins for ${identity}: ${owners.get(identity)} pins ${previous.location} at ${previous.revision}; ${file} pins ${location} at ${revision}`,
+          )
+        out.set(identity, { location, revision })
+        owners.set(identity, file)
+      }
+    }
   }
   return out
 }
@@ -177,8 +191,8 @@ interface LoadedPackage {
  */
 export function resolveSwiftPackages(options: {
   rootDir: string
-  /** the Package.resolved pinning remote revisions, when the app has one. */
-  resolved: string | null
+  /** the selected workspace or local Package.resolved files. */
+  resolved: readonly string[]
   products: readonly SwiftLinkedProduct[]
   /** local package directories the workspace or a project references. */
   localDirs: readonly string[]
@@ -194,7 +208,7 @@ export function resolveSwiftPackages(options: {
     modules: new Map(),
     binaries: [],
   }
-  const pins = resolved ? readPins(resolved) : null
+  const pins = resolved.length > 0 ? readPins(resolved) : null
   const checkouts = remoteSwiftCheckouts(rootDir)
 
   const packages = new Map<string, LoadedPackage | string>()

package/src/swift-root-lock.ts

@@ -0,0 +1,153 @@
+import { execFileSync } from 'node:child_process'
+import { createHash, randomUUID } from 'node:crypto'
+import {
+  linkSync,
+  mkdirSync,
+  readFileSync,
+  renameSync,
+  rmSync,
+  writeFileSync,
+} from 'node:fs'
+import path from 'node:path'
+import { rnxHomeDir } from './home-paths'
+
+const POLL_MS = 250
+
+interface Holder {
+  pid: number
+  start: string | null
+}
+
+// a pid alone is reused; the start time names the process that wrote the lock.
+function processStart(pid: number): string | null {
+  try {
+    return (
+      execFileSync('ps', ['-o', 'lstart=', '-p', String(pid)], {
+        encoding: 'utf8',
+        stdio: ['ignore', 'pipe', 'ignore'],
+      }).trim() || null
+    )
+  } catch {
+    return null
+  }
+}
+
+function parseHolder(text: string): Holder | null {
+  try {
+    const value: unknown = JSON.parse(text)
+    if (
+      value &&
+      typeof value === 'object' &&
+      'pid' in value &&
+      typeof value.pid === 'number' &&
+      'start' in value &&
+      (typeof value.start === 'string' || value.start === null)
+    )
+      return { pid: value.pid, start: value.start }
+  } catch {}
+  return null
+}
+
+function readLock(lock: string): string | null {
+  try {
+    return readFileSync(lock, 'utf8')
+  } catch (error) {
+    if (error instanceof Error && 'code' in error && error.code === 'ENOENT') return null
+    throw error
+  }
+}
+
+function holderAlive(text: string): boolean {
+  const holder = parseHolder(text)
+  if (!holder) return false
+  const start = processStart(holder.pid)
+  return start !== null && start === holder.start
+}
+
+function pause(ms: number, signal?: AbortSignal): Promise<void> {
+  return new Promise((resolve) => {
+    const done = () => {
+      clearTimeout(timer)
+      signal?.removeEventListener('abort', done)
+      resolve()
+    }
+    const timer = setTimeout(done, ms)
+    signal?.addEventListener('abort', done, { once: true })
+  })
+}
+
+/** runs `work` as the only process using a swift build root. the in-process
+ *  queue orders one process's requests; two processes sharing a root each
+ *  rewrite its sources and manifest, and swiftpm's own build lock only orders
+ *  the builds, so a build can compile the other process's sources and then
+ *  read back that process's executable. the lock lives beside the root's
+ *  tree, never inside it: a write sweeps every file of the tree it does not
+ *  name. a lock whose owner process is gone is taken over. */
+export async function withSwiftRootLock<T>(
+  root: string,
+  work: () => Promise<T>,
+  signal?: AbortSignal,
+): Promise<T> {
+  const directory = path.join(rnxHomeDir(), 'cache', 'swift-root-locks')
+  mkdirSync(directory, { recursive: true })
+  const lock = path.join(
+    directory,
+    `${createHash('sha256').update(root).digest('hex').slice(0, 32)}.lock`,
+  )
+  const token = randomUUID()
+  const owner = JSON.stringify({
+    pid: process.pid,
+    start: processStart(process.pid),
+    token,
+  })
+  const pending = `${lock}.${token}`
+  // the owner record is complete before the lock path exists, so a waiter
+  // never reads a half-written lock.
+  writeFileSync(pending, owner)
+  try {
+    for (;;) {
+      signal?.throwIfAborted()
+      try {
+        linkSync(pending, lock)
+        break
+      } catch (error) {
+        if (!(error instanceof Error && 'code' in error && error.code === 'EEXIST'))
+          throw error
+      }
+      const held = readLock(lock)
+      if (held === null) continue
+      if (holderAlive(held)) {
+        await pause(POLL_MS, signal)
+        continue
+      }
+      // take over by moving the dead record aside. a different record in the
+      // moved file means a new owner landed first; put it back.
+      const dead = `${lock}.dead-${token}`
+      try {
+        renameSync(lock, dead)
+      } catch (error) {
+        if (error instanceof Error && 'code' in error && error.code === 'ENOENT') continue
+        throw error
+      }
+      try {
+        if (readLock(dead) !== held) {
+          try {
+            linkSync(dead, lock)
+          } catch (error) {
+            if (!(error instanceof Error && 'code' in error && error.code === 'EEXIST'))
+              throw error
+          }
+        }
+      } finally {
+        rmSync(dead, { force: true })
+      }
+    }
+  } finally {
+    rmSync(pending, { force: true })
+  }
+  try {
+    return await work()
+  } finally {
+    if (readLock(lock) === owner) rmSync(lock, { force: true })
+  }
+}

package/src/swift-standin-emit.ts

@@ -90,7 +90,7 @@ export type StandinResult = {
 }
 
 /** bump when emitted source changes: the stand-in cache keys on it. */
-export const STANDIN_EMIT_VERSION = '10'
+export const STANDIN_EMIT_VERSION = '12'
 
 /** the modules every stand-in source imports. */
 export const STANDIN_IMPORTS = ['Foundation', 'UIKit']
@@ -229,6 +229,11 @@ export function emitSwiftStandin(
       family.has(parts[0]!) && parts[0] !== 'SwiftUICore' ? parts.join('.') : unqualified
     return { name, module, local: false }
   }
+  const nsObject = nameOf('c:objc(cs)NSObject', 'ObjectiveC.NSObject')!.name
+  const nsObjectProtocol = nameOf(
+    'c:objc(pl)NSObject',
+    'ObjectiveC.NSObjectProtocol',
+  )!.name
   for (const graph of graphs)
     for (const edge of graph.relationships) {
       const source = byId.get(edge.source)
@@ -577,7 +582,18 @@ export function emitSwiftStandin(
       const inner = `${indent}  `
       switch (symbol.kind.identifier) {
         case 'swift.typealias': {
-          const { 1: attrs, 2: rest } = LEADING_ATTRS.exec(text(symbol))!
+          // a graph shortens an external alias to its leaf, which can shadow itself.
+          const fragments = (symbol.declarationFragments ?? []).map((fragment) =>
+            fragment.kind === 'typeIdentifier' &&
+            fragment.spelling === leaf(symbol) &&
+            fragment.preciseIdentifier?.startsWith('s:s') &&
+            fragment.preciseIdentifier !== id
+              ? { ...fragment, spelling: `Swift.${fragment.spelling}` }
+              : fragment,
+          )
+          const { 1: attrs, 2: rest } = LEADING_ATTRS.exec(
+            text({ ...symbol, declarationFragments: fragments }),
+          )!
           emit(`${indent}${attrs}public ${rest}`)
           return
         }
@@ -598,7 +614,8 @@ export function emitSwiftStandin(
             ...(conforms.get(id) ?? []).filter(
               (name) =>
                 !ancestors.has(name) &&
-                !(parent && [...KEEP_EXTERNAL.values()].includes(name)),
+                !(parent && [...KEEP_EXTERNAL.values()].includes(name)) &&
+                !(name === nsObjectProtocol && externalRoot(id) === nsObject),
             ),
           ].filter((name, at, all) => all.indexOf(name) === at)
           const parentSymbol = superId.has(id) ? byId.get(superId.get(id)!) : undefined
@@ -719,7 +736,8 @@ export function emitSwiftStandin(
                 synthesizedEquality(member, list))
             )
               continue
-            const value = values.get(member.identifier.precise)
+            const header = values.get(member.identifier.precise)
+            const value = header === undefined ? undefined : atWidth(header, raw)
             if (value !== undefined && member.kind.identifier === 'swift.type.property') {
               emit(
                 `${inner}public static let ${tick(leaf(member))} = ${shape.name}(rawValue: ${value})`,
@@ -739,10 +757,13 @@ export function emitSwiftStandin(
           if (!shape)
             return void skipped.push({ path, reason: `unparsed enum ${text(symbol)}` })
           const members = membersOf(id)
-          const raw = rawType(members)
           const cases = members.filter(
             (member) => member.kind.identifier === 'swift.enum.case',
           )
+          // payload cases use a manual RawRepresentable witness, not a raw enum.
+          const raw = cases.some((member) => text(member).includes('('))
+            ? null
+            : rawType(members)
           const missing = raw
             ? cases.filter((member) => !values.has(member.identifier.precise))
             : []
@@ -754,14 +775,15 @@ export function emitSwiftStandin(
               reason: `no header value for ${missing.map(leaf).join(', ')}`,
             })
           const list = inheritance(id, raw ?? undefined).filter(
-            (name) => name !== 'RawRepresentable',
+            (name) => !raw || name !== 'RawRepresentable',
           )
           emit(
             `${indent}${shape.attrs}public enum ${shape.name}${shape.generics}${list.length ? `: ${list.join(', ')}` : ''}${shape.where} {`,
           )
           const seenValues = new Map<string, string>()
           for (const member of cases) {
-            const value = values.get(member.identifier.precise)
+            const header = values.get(member.identifier.precise)
+            const value = header === undefined ? undefined : atWidth(header, raw)
             // objective-c aliases a value under a second name; swift spells
             // the alias as a static member of the first case.
             if (value !== undefined && seenValues.has(value)) {
@@ -891,6 +913,17 @@ export function emitSwiftStandin(
     const init = members.find((member) => leaf(member) === 'init(rawValue:)')
     return init ? (/rawValue:\s*([^)]+)\)/.exec(text(init))?.[1]?.trim() ?? null) : null
   }
+  // header values are clang's for 64-bit iOS. NSUIntegerMax, NSIntegerMax
+  // and NSIntegerMin are the platform-width type's own extremes, which on
+  // wasm32 are the 32-bit ones.
+  const atWidth = (value: string, raw: string | null) =>
+    (raw === 'UInt' || raw === 'Swift.UInt') && value === '18446744073709551615'
+      ? '4294967295'
+      : (raw === 'Int' || raw === 'Swift.Int') && value === '9223372036854775807'
+        ? '2147483647'
+        : (raw === 'Int' || raw === 'Swift.Int') && value === '-9223372036854775808'
+          ? '-2147483648'
+          : value
 
   const emitGlobal = scoped((symbol: GraphSymbol) => {
     const path = pathOf(symbol)