peachsim 0.1.1625 → 0.1.1640

package/src/swift-packages.ts

@@ -2,14 +2,16 @@
 // each linked product resolves through swiftpm's own reading of its package
 // (swift-package-manifest.ts) to the source targets that build it; remote
 // packages are fetched at the revision the app's Package.resolved pins, into
-// .build/peach/checkouts under the app's root. swift and c-family source
+// PEACH_HOME/cache/swift-packages, isolated by the app root. swift and c-family source
 // targets use the common compiler backend. objective-c, assembly and binary
 // targets the host built no stand-in for stay missing with their reason;
 // the targets beside them still compile.
 
 import { execFileSync } from 'node:child_process'
+import { createHash } from 'node:crypto'
 import fs from 'node:fs'
 import path from 'node:path'
+import { cacheDir } from './home-paths'
 import {
   swiftImplicitResourcePaths,
   swiftPackageIdentity,
@@ -19,7 +21,7 @@ import {
 import {
   swiftPackageManifest,
   swiftTargetFiles,
-  type SwiftManifestDefine,
+  type SwiftManifestSetting,
   type SwiftPackageManifest,
 } from './swift-package-manifest'
 
@@ -43,7 +45,8 @@ export interface SwiftPackageSourceTarget extends SwiftPackageTarget {
   packageDir: string
   remote: boolean
   /** the conditions its manifest defines, before a build configuration picks them. */
-  packageDefines: SwiftManifestDefine[]
+  packageDefines: SwiftManifestSetting[]
+  packageLibraries: SwiftManifestSetting[]
 }
 
 /** why a product or module does not compile, and where it comes from. */
@@ -74,47 +77,68 @@ export interface SwiftPackageBinary {
   dir: string
   /** a linked product's closure reaches it, so the app links it. */
   reached: boolean
+  /** a source Objective-C target: public headers relative to dir. */
+  publicHeaders?: string
+  /** dependency module public headers, relative to dir. */
+  headerDependencies?: { module: string; path: string }[]
 }
 
-/** where checkouts live, relative to the app's root. */
-export const REMOTE_CHECKOUTS = path.join('.build', 'peach', 'checkouts')
+/** dependency checkouts belong to peach, isolated by the canonical app root. */
+export function remoteSwiftCheckouts(root: string): string {
+  const key = createHash('sha256')
+    .update(fs.realpathSync(root))
+    .digest('hex')
+    .slice(0, 32)
+  fs.mkdirSync(cacheDir(), { recursive: true })
+  return path.join(fs.realpathSync(cacheDir()), 'swift-packages', key, 'checkouts')
+}
 
 // sources requiring an objective-c runtime or assembly lowering.
 const UNSUPPORTED_NATIVE = /\.(m|mm|s|S)$/
 
 const BINARY = 'is a binary framework'
-// of the reasons a target or product cannot compile, a binary framework's
-// leads: no source exists for it, while another target can retain its
-// source-specific reason
-const blocker = (reasons: (string | null)[]): string | null =>
-  reasons.find((reason) => reason?.includes(BINARY)) ??
-  reasons.find((reason) => reason !== null) ??
-  null
+// retain every independent blocker in dependency order. a product can reach
+// several unsupported targets, and fixing one must not reveal a hidden next one.
+const blockers = (reasons: readonly string[][]): string[] => [...new Set(reasons.flat())]
 
 interface Pin {
   location: string
   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
 }
@@ -167,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[]
@@ -184,8 +208,8 @@ export function resolveSwiftPackages(options: {
     modules: new Map(),
     binaries: [],
   }
-  const pins = resolved ? readPins(resolved) : null
-  const checkouts = path.join(rootDir, REMOTE_CHECKOUTS)
+  const pins = resolved.length > 0 ? readPins(resolved) : null
+  const checkouts = remoteSwiftCheckouts(rootDir)
 
   const packages = new Map<string, LoadedPackage | string>()
   // a package by local directory or remote url, or why it cannot load
@@ -205,8 +229,6 @@ export function resolveSwiftPackages(options: {
           : 'no Package.resolved pins it; resolve packages in Xcode once'
       } else {
         fs.mkdirSync(checkouts, { recursive: true })
-        // fetched sources never show up as changes in the app's repository
-        fs.writeFileSync(path.join(path.dirname(checkouts), '.gitignore'), '*\n')
         loaded = {
           source: source.url,
           remote: true,
@@ -219,35 +241,40 @@ export function resolveSwiftPackages(options: {
   }
 
   const targets = new Map<string, SwiftPackageSourceTarget>()
-  // why each target of each package cannot compile, or null once it can
-  const targetOutcomes = new Map<string, string | null>()
-  const resolveTarget = (pkg: LoadedPackage, name: string): string | null => {
+  // every reason each target cannot compile; empty once it can
+  const targetOutcomes = new Map<string, string[]>()
+  const resolveTarget = (pkg: LoadedPackage, name: string): string[] => {
     const key = `${pkg.manifest.dir}\0${name}`
     if (targetOutcomes.has(key)) return targetOutcomes.get(key)!
     // a dependency cycle resolves as compiling; swiftpm rejects real cycles
-    targetOutcomes.set(key, null)
-    const outcome = ((): string | null => {
-      if (provided.has(name)) return null
+    targetOutcomes.set(key, [])
+    const outcome = ((): string[] => {
+      if (provided.has(name)) return []
       const target = pkg.manifest.targets.get(name)
-      if (!target) return `${path.basename(pkg.manifest.dir)} declares no target ${name}`
-      if (target.type === 'binary') {
-        const gap = options.binaryGaps?.get(name)
-        return `${name} ${BINARY}${gap ? `; ${gap}` : ''}`
-      }
-      if (target.type === 'system') return `${name} is a system C library`
-      if (target.type !== 'regular') return `${name} is a ${target.type} target`
-      const files = swiftTargetFiles(pkg.manifest, target)
-      if (files.some((file) => UNSUPPORTED_NATIVE.test(file)))
-        return `${name} is an Objective-C or assembly target`
+      if (!target)
+        return [`${path.basename(pkg.manifest.dir)} declares no target ${name}`]
+      const files =
+        target.type === 'regular' || target.type === 'system'
+          ? swiftTargetFiles(pkg.manifest, target)
+          : []
+      const gap = options.binaryGaps?.get(name)
+      const ownReason =
+        target.type === 'binary'
+          ? `${name} ${BINARY}${gap ? `; ${gap}` : ''}`
+          : target.type !== 'regular' && target.type !== 'system'
+            ? `${name} is a ${target.type} target`
+            : files.some((file) => UNSUPPORTED_NATIVE.test(file))
+              ? `${name} is an Objective-C or assembly target${gap ? `; ${gap}` : ''}`
+              : null
       // every dependency resolves, so a failing one never hides the rest
       // of the closure from the compile or from the report
       const reasons = target.dependencies.map((dependency) => {
         if (dependency.kind === 'target') return resolveTarget(pkg, dependency.name)
         const nested = resolveDependencyProduct(pkg, dependency.package, dependency.name)
-        return nested && `${dependency.name}: ${nested}`
+        return nested.map((reason) => `${dependency.name}: ${reason}`)
       })
-      const blocked = blocker(reasons)
-      if (blocked) return blocked
+      const blocked = blockers([ownReason ? [ownReason] : [], ...reasons])
+      if (blocked.length > 0) return blocked
       const relative = files.map((file) => path.relative(target.dir, file))
       targets.set(`${pkg.manifest.dir}\0${name}`, {
         name,
@@ -257,6 +284,7 @@ export function resolveSwiftPackages(options: {
         packageDir: pkg.manifest.dir,
         remote: pkg.remote,
         packageDefines: target.defines,
+        packageLibraries: target.libraries,
         dependencies: target.dependencies.flatMap((dependency) => {
           if (dependency.kind === 'target') return [dependency]
           if (provided.has(dependency.name)) return []
@@ -265,32 +293,35 @@ export function resolveSwiftPackages(options: {
             source &&
             packages.get('dir' in source ? path.resolve(source.dir) : source.url)
           return nested && typeof nested !== 'string'
-            ? (nested.manifest.products.get(dependency.name) ?? []).map((name): SwiftTargetDependency => ({
-                kind: 'target',
-                name,
-              }))
+            ? (nested.manifest.products.get(dependency.name) ?? []).map(
+                (name): SwiftTargetDependency => ({
+                  kind: 'target',
+                  name,
+                }),
+              )
             : []
         }),
         executable: false,
+        ...(target.type === 'system' ? { systemLibrary: true } : {}),
         languageMode: target.languageMode,
         mainActorIsolation: target.mainActorIsolation,
         resources:
           target.declaresResources || swiftImplicitResourcePaths(relative).length > 0,
       })
-      return null
+      return []
     })()
     targetOutcomes.set(key, outcome)
     return outcome
   }
   // products resolved anywhere in the closure, by package, with why one
   // cannot compile: a wrapper package's product is often the module name
-  const productOutcomes = new Map<string, { pkg: LoadedPackage; reason: string | null }>()
-  const resolveProduct = (pkg: LoadedPackage, product: string): string | null => {
-    if (provided.has(product)) return null
+  const productOutcomes = new Map<string, { pkg: LoadedPackage; reason: string[] }>()
+  const resolveProduct = (pkg: LoadedPackage, product: string): string[] => {
+    if (provided.has(product)) return []
     const roots = pkg.manifest.products.get(product)
     const reason = !roots
-      ? `${path.basename(pkg.manifest.dir)} has no library ${product}`
-      : blocker(roots.map((name) => resolveTarget(pkg, name)))
+      ? [`${path.basename(pkg.manifest.dir)} has no library ${product}`]
+      : blockers(roots.map((name) => resolveTarget(pkg, name)))
     productOutcomes.set(`${pkg.manifest.dir}\0${product}`, { pkg, reason })
     return reason
   }
@@ -299,18 +330,18 @@ export function resolveSwiftPackages(options: {
     pkg: LoadedPackage,
     packageName: string,
     product: string,
-  ): string | null => {
-    if (provided.has(product)) return null
+  ): string[] => {
+    if (provided.has(product)) return []
     const dependency = pkg.manifest.packages.get(packageName)
     if (!dependency)
-      return `${path.basename(pkg.manifest.dir)} names no package ${packageName}`
+      return [`${path.basename(pkg.manifest.dir)} names no package ${packageName}`]
     if ('dir' in dependency) {
       const loaded = load({ kind: 'local', dir: dependency.dir })
-      return typeof loaded === 'string' ? loaded : resolveProduct(loaded, product)
+      return typeof loaded === 'string' ? [loaded] : resolveProduct(loaded, product)
     }
-    if (!options.provided) return null
+    if (!options.provided) return []
     const loaded = load({ kind: 'remote', url: dependency.url })
-    return typeof loaded === 'string' ? loaded : resolveProduct(loaded, product)
+    return typeof loaded === 'string' ? [loaded] : resolveProduct(loaded, product)
   }
 
   const unnamed = () =>
@@ -326,11 +357,11 @@ export function resolveSwiftPackages(options: {
         : load(source)
     const reason =
       pkg === undefined
-        ? 'no package the workspace references vends it'
+        ? ['no package the workspace references vends it']
         : typeof pkg === 'string'
-          ? pkg
+          ? [pkg]
           : resolveProduct(pkg, product)
-    if (reason)
+    if (reason.length > 0)
       result.unavailable.set(product, {
         source:
           source.kind === 'remote'
@@ -340,7 +371,7 @@ export function resolveSwiftPackages(options: {
               : source.kind === 'local'
                 ? source.dir
                 : 'the workspace',
-        reason,
+        reason: reason.join('; '),
       })
   }
 
@@ -352,24 +383,35 @@ export function resolveSwiftPackages(options: {
       if (target.type === 'test' || target.type === 'plugin' || target.type === 'macro')
         continue
       if (target.type === 'executable') continue
-      if (target.type === 'binary')
+      const objc =
+        target.type === 'regular' &&
+        swiftTargetFiles(pkg.manifest, target).some((file) => /\.(m|mm)$/.test(file))
+      if (target.type === 'binary' || objc)
         result.binaries.push({
           target: name,
           source: pkg.source,
           url: target.url,
           checksum: target.checksum,
-          dir: target.dir,
+          dir: objc ? pkg.manifest.dir : target.dir,
           reached: false,
+          ...(objc
+            ? {
+                publicHeaders: path.relative(
+                  pkg.manifest.dir,
+                  path.join(target.dir, target.publicHeadersPath),
+                ),
+              }
+            : {}),
         })
       const reason = resolveTarget(pkg, name)
-      if (reason && !result.modules.has(name))
-        result.modules.set(name, { source: pkg.source, reason })
+      if (reason.length > 0 && !result.modules.has(name))
+        result.modules.set(name, { source: pkg.source, reason: reason.join('; ') })
     }
   }
   for (const [key, { pkg, reason }] of productOutcomes) {
     const product = key.slice(key.indexOf('\0') + 1)
-    if (reason && !result.modules.has(product))
-      result.modules.set(product, { source: pkg.source, reason })
+    if (reason.length > 0 && !result.modules.has(product))
+      result.modules.set(product, { source: pkg.source, reason: reason.join('; ') })
   }
   // what compiles is every buildable target in a linked product's closure,
   // decided per target: a product with one target behind a binary still
@@ -410,6 +452,37 @@ export function resolveSwiftPackages(options: {
     if (pkg && typeof pkg !== 'string')
       binary.reached = reached.has(`${pkg.manifest.dir}\0${binary.target}`)
   }
+  for (const binary of result.binaries) {
+    if (binary.publicHeaders === undefined) continue
+    const pkg = packages.get(binary.source)
+    if (!pkg || typeof pkg === 'string') continue
+    const headers = new Map<string, string>()
+    const visited = new Set<string>()
+    const visit = (owner: LoadedPackage, name: string) => {
+      const key = `${owner.manifest.dir}\0${name}`
+      if (visited.has(key)) return
+      visited.add(key)
+      const target = owner.manifest.targets.get(name)
+      if (!target) return
+      const dir = path.join(target.dir, target.publicHeadersPath)
+      for (const dependency of target.dependencies) {
+        if (dependency.kind === 'target') visit(owner, dependency.name)
+        else {
+          const source = owner.manifest.packages.get(dependency.package)
+          const nested =
+            source &&
+            packages.get('dir' in source ? path.resolve(source.dir) : source.url)
+          if (nested && typeof nested !== 'string')
+            for (const root of nested.manifest.products.get(dependency.name) ?? [])
+              visit(nested, root)
+        }
+      }
+      if (name !== binary.target && fs.existsSync(dir))
+        headers.set(name, path.relative(binary.dir, dir))
+    }
+    visit(pkg, binary.target)
+    binary.headerDependencies = [...headers].map(([module, path]) => ({ module, path }))
+  }
   result.targets = [...targets.entries()]
     .filter(([key]) => reached.has(key))
     .map(([, target]) => target)

package/src/swift-standin-emit.ts

@@ -20,6 +20,7 @@ export type GraphSymbol = {
   pathComponents: string[]
   declarationFragments?: SymbolFragment[]
   accessLevel: string
+  functionSignature?: { returns?: SymbolFragment[] }
   availability?: {
     domain?: string
     isUnconditionallyUnavailable?: boolean
@@ -43,6 +44,8 @@ export type StandinOptions = {
   module: string
   /** where the declarations came from, for the banner: sdk, version, artifact. */
   source: string
+  /** source Objective-C targets keep declarations with inert native bodies. */
+  inert?: boolean
   /** modules the source imports beside Foundation and UIKit. */
   imports?: string[]
   /** precise symbol id → swift literal for enum cases and option values. */
@@ -87,7 +90,7 @@ export type StandinResult = {
 }
 
 /** bump when emitted source changes: the stand-in cache keys on it. */
-export const STANDIN_EMIT_VERSION = '7'
+export const STANDIN_EMIT_VERSION = '12'
 
 /** the modules every stand-in source imports. */
 export const STANDIN_IMPORTS = ['Foundation', 'UIKit']
@@ -226,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)
@@ -331,6 +339,47 @@ export function emitSwiftStandin(
     ])
   }
 
+  // DEGRADED(swift-objc-runtime): source objc targets retain their api with inert native bodies.
+  // return values follow the imported declaration, never the app's call sites.
+  const inertValue = (type: string): string => {
+    const value = type.trim().replace(/!$/, '?')
+    if (value.endsWith('?')) return 'nil'
+    if (value === 'Void' || value === '()') return '()'
+    if (value === 'Bool') return 'false'
+    if (
+      /^(?:U?Int(?:8|16|32|64)?|Float|Double|CGFloat|TimeInterval|NSTimeInterval)$/.test(
+        value,
+      )
+    )
+      return '0'
+    if (value === 'String') return '""'
+    if (value.startsWith('[')) return value.includes(':') ? '[:]' : '[]'
+    if (value === 'Any' || value === 'AnyObject') return 'NSObject()'
+    const typeId = typeByPath.get(value.replace(`${options.module}.`, ''))
+    const symbol = typeId && byId.get(typeId)
+    if (typeId && symbol && symbol.kind.identifier === 'swift.enum') {
+      const first = membersOf(typeId).find(
+        (member) => member.kind.identifier === 'swift.enum.case',
+      )
+      if (first) return `.${leaf(first).replace(/\(.*/, '')}`
+    }
+    return `${value}()`
+  }
+  const inertBody = (symbol: GraphSymbol): string => {
+    const declaration = text(symbol)
+    if (symbol.kind.identifier === 'swift.init') {
+      if (/\bconvenience\b/.test(declaration)) return 'self.init()'
+      const parent = owner.get(symbol.identifier.precise)
+      return parent && superclass.has(parent) ? 'super.init()' : ''
+    }
+    const type =
+      symbol.kind.identifier.includes('property') ||
+      symbol.kind.identifier === 'swift.var'
+        ? /:\s*(.*?)\s*(?:\{|$)/.exec(declaration)?.[1]
+        : symbol.functionSignature?.returns?.map((fragment) => fragment.spelling).join('')
+    return type ? `return ${inertValue(type)}` : ''
+  }
+
   const lines: string[] = []
   const owners: string[] = []
   const omit = options.omit ?? new Map<string, string>()
@@ -426,7 +475,8 @@ export function emitSwiftStandin(
         : /\bResult</.test(core)
           ? measured?.resultBody
           : undefined
-      const body = overloadBody ?? measured?.body ?? trap(path)
+      const body =
+        overloadBody ?? measured?.body ?? (options.inert ? inertBody(member) : trap(path))
       switch (member.kind.identifier) {
         case 'swift.property':
         case 'swift.type.property':
@@ -452,7 +502,7 @@ export function emitSwiftStandin(
             return
           }
           emit(
-            `${head}${computed} { get${effects} { ${body} }${settable && !effects ? ` ${parsed.nonmutating ? 'nonmutating ' : ''}set { ${measured?.set ?? trap(path)} }` : ''} }`,
+            `${head}${computed} { get${effects} { ${body} }${settable && !effects ? ` ${parsed.nonmutating ? 'nonmutating ' : ''}set { ${measured?.set ?? (options.inert ? '' : trap(path))} }` : ''} }`,
           )
           return
         }
@@ -532,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
         }
@@ -553,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
@@ -646,7 +708,7 @@ export function emitSwiftStandin(
             externalRoot(id) !== null
           )
             emit(
-              `${inner}public required init?(coder: NSCoder) { ${trap(`${path}.init(coder:)`)} }`,
+              `${inner}public required init?(coder: NSCoder) { ${options.inert ? 'return nil' : trap(`${path}.init(coder:)`)} }`,
             )
           emit(`${indent}}`)
           return
@@ -674,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})`,
@@ -694,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))
             : []
@@ -709,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)) {
@@ -814,7 +881,7 @@ export function emitSwiftStandin(
       .replace(/^(?:weak |unowned )/, '')
       .replace(/^((?:static )?)let /, '$1var ')
     const witness = `${owner}.${leaf(member)}`
-    const body = trap(witness)
+    const body = options.inert ? inertBody(member) : trap(witness)
     if (
       member.kind.identifier === 'swift.property' ||
       member.kind.identifier === 'swift.type.property'
@@ -846,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)
@@ -872,7 +950,7 @@ export function emitSwiftStandin(
           ? measured?.resultBody
           : undefined
       emit(
-        `${attrs}public ${spelled} { ${overloadBody ?? measured?.body ?? trap(path)} }`,
+        `${attrs}public ${spelled} { ${overloadBody ?? measured?.body ?? (options.inert ? inertBody(symbol) : trap(path))} }`,
       )
     } else if (kind === 'swift.var') {
       const parsed = splitAccessors(text(symbol).replace(/^let /, 'var '))
@@ -882,7 +960,9 @@ export function emitSwiftStandin(
       // as `var` with no setter.
       const measured = behavior.get(path)
       if (measured) used.add(path)
-      emit(`public ${parsed.decl} { ${measured?.body ?? trap(path)} }`)
+      emit(
+        `public ${parsed.decl} { ${measured?.body ?? (options.inert ? inertBody(symbol) : trap(path))} }`,
+      )
     } else skipped.push({ path, reason: `unhandled top-level ${kind}` })
   })
 
@@ -929,8 +1009,9 @@ export function emitSwiftStandin(
   const imports = [...STANDIN_IMPORTS, ...(options.imports ?? [])]
   const banner = [
     `// stand-in for the binary ${options.module} module, generated from ${options.source}.`,
-    `// do not hand-edit: unconfigured bodies trap because the vendor binary cannot run`,
-    `// in peach; app native stubs may supply configured behavior.`,
+    options.inert
+      ? '// generated from public headers; native behavior is inert in peach.'
+      : '// unconfigured bodies trap because the vendor binary cannot run in peach.',
     '',
     ...imports.map((name) => `import ${name}`),
     '',