peachsim 0.1.2180 → 0.1.2185

package/src/swift-interface-bodies.ts

@@ -0,0 +1,165 @@
+// a swift interface without function bodies. a library-evolution interface
+// keeps the bodies of its inlinable functions and accessors, and compiling it
+// type-checks them against the sdk it is read with. the objective-c intake
+// declares Foundation and CoreGraphics only as far as headers name them, so a
+// body that builds a Date or reads CGRect.zero fails the whole module although
+// no declaration does. an interface prints every non-inlinable function
+// without a body, so dropping the rest leaves the same public surface. a
+// default argument value is a body of its own kind: it type-checks against the
+// same partial sdk, and the symbol graph spells it into the stand-in, so it
+// stays unless the caller finds the interface does not load with it.
+
+const INLINE_ATTRIBUTE =
+  /@(?:inlinable|_alwaysEmitIntoClient|_transparent|inline\(__always\)|_effects\([^()]*\)|_specialize\((?:[^()]|\([^()]*\))*\))\s*/g
+
+const ACCESSOR = /^(?:mutating|nonmutating|async|throws|rethrows|get|set|_modify|_read)$/
+
+type Frame = 'container' | 'accessors' | 'expression'
+
+// the keyword that says what a `{` after this line opens.
+function declarationKind(head: string): 'function' | 'property' | 'container' {
+  const words = head
+    .replace(/@\w+(?:\((?:[^()]|\([^()]*\))*\))?/g, ' ')
+    .match(/[A-Za-z_]\w*/g)
+  for (const word of words ?? []) {
+    if (word === 'func' || word === 'init' || word === 'deinit') return 'function'
+    if (word === 'var' || word === 'let' || word === 'subscript') return 'property'
+    if (
+      word === 'struct' ||
+      word === 'class' ||
+      word === 'enum' ||
+      word === 'protocol' ||
+      word === 'extension' ||
+      word === 'actor' ||
+      word === 'precedencegroup'
+    )
+      return 'container'
+  }
+  return 'container'
+}
+
+/** the index after the string, comment or character literal starting at `i`, or `i`. */
+function skipLiteral(text: string, i: number): number {
+  if (text.startsWith('//', i)) {
+    const end = text.indexOf('\n', i)
+    return end < 0 ? text.length : end
+  }
+  if (text.startsWith('/*', i)) {
+    const end = text.indexOf('*/', i + 2)
+    return end < 0 ? text.length : end + 2
+  }
+  if (text[i] !== '"' && text[i] !== '#') return i
+  let hashes = 0
+  let j = i
+  while (text[j] === '#') {
+    hashes++
+    j++
+  }
+  if (text[j] !== '"') return i
+  const multiline = text.startsWith('"""', j)
+  const open = multiline ? '"""' : '"'
+  j += open.length
+  const close = `${open}${'#'.repeat(hashes)}`
+  const escape = `\\${'#'.repeat(hashes)}`
+  while (j < text.length) {
+    if (text.startsWith(escape, j)) j += escape.length + 1
+    else if (text.startsWith(close, j)) return j + close.length
+    else j++
+  }
+  return text.length
+}
+
+/** the index after the brace block opened at `open`. */
+function skipBlock(text: string, open: number): number {
+  let depth = 0
+  for (let i = open; i < text.length; ) {
+    const after = skipLiteral(text, i)
+    if (after !== i) {
+      i = after
+      continue
+    }
+    if (text[i] === '{') depth++
+    else if (text[i] === '}' && --depth === 0) return i + 1
+    i++
+  }
+  return text.length
+}
+
+/** the index of the `,` or `)` that ends the default argument value starting at `i`. */
+function skipExpression(text: string, start: number): number {
+  let depth = 0
+  for (let i = start; i < text.length; ) {
+    const after = skipLiteral(text, i)
+    if (after !== i) {
+      i = after
+      continue
+    }
+    const char = text[i]!
+    if (char === '(' || char === '[' || char === '{' || char === '<') depth++
+    else if (char === '>' && text[i - 1] !== '-') depth--
+    else if (char === ')' || char === ']' || char === '}') {
+      if (depth === 0) return i
+      depth--
+    } else if (char === ',' && depth === 0) return i
+    i++
+  }
+  return text.length
+}
+
+export function swiftInterfaceWithoutBodies(text: string, keepDefaults = false): string {
+  let out = ''
+  const frames: Frame[] = []
+  let parens = 0
+  let lineStart = 0
+  for (let i = 0; i < text.length; ) {
+    const after = skipLiteral(text, i)
+    if (after !== i) {
+      out += text.slice(i, after)
+      i = after
+      continue
+    }
+    const char = text[i]!
+    if (char === '=' && parens > 0 && text[i - 1] === ' ' && text[i + 1] === ' ') {
+      out = out.trimEnd()
+      i = skipExpression(text, i + 1)
+      continue
+    }
+    if (char === '\n') lineStart = out.length + 1
+    else if (char === '(') parens++
+    else if (char === ')') parens--
+    else if (char === '}') {
+      frames.pop()
+    } else if (char === '{') {
+      const parent = frames.at(-1)
+      const head = out.slice(lineStart)
+      if (parens > 0 || parent === 'expression') frames.push('expression')
+      else if (parent === 'accessors') {
+        // an accessor's body: keep its keyword, drop the attributes that need one
+        out = `${out.slice(0, lineStart)}${head.replace(INLINE_ATTRIBUTE, '')}`.trimEnd()
+        i = skipBlock(text, i)
+        continue
+      } else {
+        const kind = declarationKind(head)
+        const body = text.slice(i + 1, skipBlock(text, i) - 1)
+        if (kind === 'function') {
+          out =
+            `${out.slice(0, lineStart)}${head.replace(INLINE_ATTRIBUTE, '')}`.trimEnd()
+          i = skipBlock(text, i)
+          continue
+        }
+        // `{ get set }` keeps its keywords; `{ get { .. } }` is a property with bodies
+        const bare = body.split(/\s+/).every((word) => word === '' || ACCESSOR.test(word))
+        frames.push(kind === 'property' && !bare ? 'accessors' : 'container')
+        if (kind === 'property' && bare) {
+          out += `{${body}}`
+          i = skipBlock(text, i)
+          frames.pop()
+          continue
+        }
+      }
+    }
+    out += char
+    i++
+  }
+  return out.replace(INLINE_ATTRIBUTE, '')
+}

package/src/swift-objc-standin.ts

@@ -19,6 +19,7 @@ import { createHash } from 'node:crypto'
 import fs from 'node:fs'
 import path from 'node:path'
 import { isRecord } from './is-record'
+import { swiftInterfaceWithoutBodies } from './swift-interface-bodies'
 import { swiftObjCPlatformFlags } from './swift-objc-platform'
 import { IOS_SDK_HEADERS, IOS_SDK_OVERLAYS, IOS_SDK_TARGET } from './swift-objc-sdk'
 import { clangImportNames, moduleMapTokens } from './swift-package'
@@ -460,6 +461,63 @@ function sdkDeclaration(name: string): SdkDeclaration | null {
   return sdkDeclarations.get(name) ?? null
 }
 
+// a swift interface as the intake sdk reads it. the intake reads
+// CoreFoundation's headers textually, so a type the interface qualifies with
+// CoreFoundation lives in CoreGraphics (CGSize, CGFloat) or Foundation, and
+// inlinable bodies would type-check against its partial Foundation, so only
+// the declarations load.
+function intakeInterface(text: string, keepDefaults = false): string {
+  return (
+    swiftInterfaceWithoutBodies(text, keepDefaults)
+      // the intake modules have no clang submodules
+      .replace(/^((?:@_exported[ \t]+)?import[ \t]+)(\w+)\.[\w.]+[ \t]*$/gm, '$1$2')
+      .replace(/\bCoreFoundation\.(?=CG)/g, 'CoreGraphics.')
+      .replace(/\bCoreFoundation\.(?=\w)/g, 'Foundation.')
+      // the intake has no Darwin module; OSStatus is its Int32
+      .replace(/\bDarwin\.OSStatus\b/g, 'Swift.Int32')
+      // Data's base64 option sets live in the swift overlay; the
+      // intake only has their NSData spelling, which Data aliases.
+      .replace(
+        /\bFoundation\.Data\.(?=Base64(?:En|De)codingOptions\b)/g,
+        'Foundation.NSData.',
+      )
+  )
+}
+
+// a vendor framework directory the headers import, its swift interfaces read
+// as the intake reads the surface's own.
+function stageVendorFrameworks(dir: string, stage: string): string {
+  fs.mkdirSync(stage, { recursive: true })
+  for (const entry of fs.readdirSync(dir)) {
+    if (!entry.endsWith('.framework')) continue
+    const source = path.join(dir, entry)
+    const target = path.join(stage, entry)
+    fs.mkdirSync(target, { recursive: true })
+    for (const child of fs.readdirSync(source)) {
+      if (child !== 'Modules') {
+        fs.symlinkSync(path.join(source, child), path.join(target, child))
+        continue
+      }
+      for (const file of fs.readdirSync(path.join(source, child), {
+        recursive: true,
+        encoding: 'utf8',
+      })) {
+        const from = path.join(source, child, file)
+        const to = path.join(target, child, file)
+        if (fs.statSync(from).isDirectory()) {
+          fs.mkdirSync(to, { recursive: true })
+          continue
+        }
+        fs.mkdirSync(path.dirname(to), { recursive: true })
+        if (file.endsWith('.swiftinterface'))
+          fs.writeFileSync(to, intakeInterface(fs.readFileSync(from, 'utf8')))
+        else fs.copyFileSync(from, to)
+      }
+    }
+  }
+  return stage
+}
+
 /** the symbol graphs, enum values and imports of an objective-c module. */
 export function objcView(
   surface: ObjcSurface,
@@ -507,6 +565,7 @@ export function objcView(
     fs.writeFileSync(file, text)
   }
   const interfaceCopies: string[] = []
+  let keepDefaults = true
   if (framework) {
     fs.mkdirSync(path.join(frameworks, `${surface.module}.framework`, 'Modules'), {
       recursive: true,
@@ -541,18 +600,7 @@ export function objcView(
           interfaceCopies.push(path.join(to, name))
           fs.writeFileSync(
             path.join(to, name),
-            fs
-              .readFileSync(path.join(from, name), 'utf8')
-              .replace(/\bCoreFoundation\.(?=CG)/g, 'CoreGraphics.')
-              .replace(/\bCoreFoundation\.(?=\w)/g, 'Foundation.')
-              // the intake has no Darwin module; OSStatus is its Int32
-              .replace(/\bDarwin\.OSStatus\b/g, 'Swift.Int32')
-              // Data's base64 option sets live in the swift overlay; the
-              // intake only has their NSData spelling, which Data aliases.
-              .replace(
-                /\bFoundation\.Data\.(?=Base64(?:En|De)codingOptions\b)/g,
-                'Foundation.NSData.',
-              ),
+            intakeInterface(fs.readFileSync(path.join(from, name), 'utf8'), true),
           )
         }
     }
@@ -619,7 +667,10 @@ export function objcView(
     stubs,
     '-I',
     stubIncludes,
-    ...vendorFrameworks.flatMap((dir) => ['-F', dir]),
+    ...vendorFrameworks.flatMap((dir, index) => [
+      '-F',
+      stageVendorFrameworks(dir, path.join(work, 'vendor-frameworks', String(index))),
+    ]),
   ]
   const missing: Missing = new Map()
   const stubbed = new Set<string>()
@@ -853,6 +904,15 @@ export function objcView(
           )
       }
     }
+    // a default argument value the intake cannot type-check fails the whole
+    // interface, so the declarations load without any
+    if ((!progress || round === ROUNDS) && keepDefaults && interfaceCopies.length > 0) {
+      keepDefaults = false
+      for (const file of interfaceCopies)
+        fs.writeFileSync(file, swiftInterfaceWithoutBodies(fs.readFileSync(file, 'utf8')))
+      writeHeaders()
+      continue
+    }
     if (!progress || round === ROUNDS)
       throw new Error(
         `its headers do not import as Swift: ${

package/src/swift-package.ts

@@ -321,6 +321,32 @@ export function moduleMapName(text: string): string | undefined {
   return index < 0 ? undefined : tokens[index + 1]
 }
 
+// the top-level modules a clang module map declares, each with its own text.
+// a uniffi xcframework ships one map holding a module per generated header.
+export function moduleMapModules(text: string): { name: string; text: string }[] {
+  const modules: { name: string; text: string }[] = []
+  const token = /\/\*[\s\S]*?\*\/|\/\/[^\n]*|"[^"]*"|\{|\}|\bmodule\s+([\w.]+)/g
+  let depth = 0
+  let start = -1
+  let name = ''
+  for (const match of text.matchAll(token)) {
+    if (match[0] === '{') depth++
+    else if (match[0] === '}') {
+      depth--
+      if (depth === 0 && start >= 0) {
+        modules.push({ name, text: text.slice(start, match.index + 1) })
+        start = -1
+      }
+    } else if (match[1] !== undefined && depth === 0) {
+      const before = text.slice(0, match.index).trimEnd()
+      if (/\bextern$/.test(before)) continue
+      start = match.index
+      name = match[1]
+    }
+  }
+  return modules
+}
+
 // swiftpm's module name for a target: its name as a c99 identifier, so
 // target `cmark-gfm` is imported as `cmark_gfm`.
 export function swiftTargetModuleName(name: string): string {

package/src/swift-source-pods.ts

@@ -96,6 +96,7 @@ async function trunkSpecification(
     'specifications',
     `${checksum}.json`,
   )
+  const sha1 = (value: string) => createHash('sha1').update(value).digest('hex')
   let text: string
   if (fs.existsSync(file)) text = fs.readFileSync(file, 'utf8')
   else {
@@ -105,16 +106,38 @@ async function trunkSpecification(
       .slice(0, 3)
       .split('')
       .join('/')
-    const response = await fetch(
-      `https://cdn.cocoapods.org/Specs/${shard}/${root}/${version}/${root}.podspec.json`,
-    )
+    const specPath = `Specs/${shard}/${root}/${version}/${root}.podspec.json`
+    const response = await fetch(`https://cdn.cocoapods.org/${specPath}`)
     if (!response.ok)
       throw new Error(
         `CocoaPods specification ${root} ${version}: HTTP ${response.status}`,
       )
     text = await response.text()
+    // trunk edits a published specification in place (a deprecation adds a
+    // field), so a lock written earlier names an older revision of the file.
+    if (sha1(text) !== checksum) {
+      const history = await fetch(
+        `https://api.github.com/repos/CocoaPods/Specs/commits?path=${specPath}&per_page=100`,
+      )
+      if (!history.ok)
+        throw new Error(`CocoaPods specification ${root} history: HTTP ${history.status}`)
+      const commits: unknown = await history.json()
+      for (const commit of Array.isArray(commits) ? commits : []) {
+        const sha = record(commit) ? commit.sha : undefined
+        if (typeof sha !== 'string') continue
+        const revision = await fetch(
+          `https://raw.githubusercontent.com/CocoaPods/Specs/${sha}/${specPath}`,
+        )
+        if (!revision.ok) continue
+        const revisionText = await revision.text()
+        if (sha1(revisionText) === checksum) {
+          text = revisionText
+          break
+        }
+      }
+    }
   }
-  if (createHash('sha1').update(text).digest('hex') !== checksum)
+  if (sha1(text) !== checksum)
     throw new Error(`${root} podspec checksum differs from ${lockFile}`)
   const spec: unknown = JSON.parse(text)
   if (!record(spec) || spec.name !== root || spec.version !== version)

package/src/swift-standin-emit.ts

@@ -74,7 +74,7 @@ export function restoreSwiftInterfaceSPI(
   for (const line of interfaceText.split('\n')) {
     const enclosing = scopes.at(-1)?.path ?? []
     const declaration =
-      /^\s*(?:@[\w.]+(?:\([^)]*\))?\s+|\w+\s+)*?(class(?!\s+(?:func|var|subscript)\b)|struct|enum|protocol|actor|extension|func|var|let|init|subscript|typealias|case)\b\s*([\w.`]*)/.exec(
+      /^\s*(?:@[\w.]+(?:\([^)]*\))?\s+|\w+\s+)*?(class(?!\s+(?:func|var|subscript)\b)|struct|enum|protocol|actor|extension|func|var|let|init|subscript|typealias|case)\b\s*([/=\-+!*%<>&|^~?]+|[\w.`]*)/.exec(
         line.replace(/::/g, '.'),
       )
     if (declaration) {
@@ -178,6 +178,8 @@ export type StandinOptions = {
   plain?: ReadonlySet<string>
   /** paths whose type the guest cannot represent in objective-c: emitted without @objc */
   unobjc?: ReadonlySet<string>
+  /** class path → objective-c protocols the compiler found its witnesses mismatch (nullability a swift protocol checks); the class drops the conformance */
+  unconformed?: ReadonlyMap<string, ReadonlySet<string>>
   /** paths the compiler says must be marked override */
   forcedOverride?: ReadonlySet<string>
   /** class path → its generic superclass with arguments, from the swiftinterface */
@@ -267,6 +269,25 @@ const KEEP_EXTERNAL = new Map([
   ['s:Se', 'Decodable'],
   ['s:s23CustomStringConvertibleP', 'CustomStringConvertible'],
   ['s:s9CodingKeyP', 'CodingKey'],
+  ['s:SL', 'Comparable'],
+  ['s:ST', 'Sequence'],
+  ['s:St', 'IteratorProtocol'],
+  ['s:Sl', 'Collection'],
+  ['s:SK', 'BidirectionalCollection'],
+  ['s:Sk', 'RandomAccessCollection'],
+  ['s:SM', 'MutableCollection'],
+  ['s:Sm', 'RangeReplaceableCollection'],
+  ['s:s28CustomDebugStringConvertibleP', 'CustomDebugStringConvertible'],
+  ['s:s25LosslessStringConvertibleP', 'LosslessStringConvertible'],
+  ['s:s20TextOutputStreamableP', 'TextOutputStreamable'],
+  ['s:Sx', 'Strideable'],
+  ['s:s18AdditiveArithmeticP', 'AdditiveArithmetic'],
+  ['s:s25ExpressibleByArrayLiteralP', 'ExpressibleByArrayLiteral'],
+  ['s:s30ExpressibleByDictionaryLiteralP', 'ExpressibleByDictionaryLiteral'],
+  ['s:s26ExpressibleByStringLiteralP', 'ExpressibleByStringLiteral'],
+  ['s:s27ExpressibleByIntegerLiteralP', 'ExpressibleByIntegerLiteral'],
+  ['s:s25ExpressibleByFloatLiteralP', 'ExpressibleByFloatLiteral'],
+  ['s:s27ExpressibleByBooleanLiteralP', 'ExpressibleByBooleanLiteral'],
 ])
 const LEADING_ATTRS = /^((?:@\w+(?:\([^)]*\))?\s*|nonisolated\s+)*)(.*)$/s
 
@@ -1488,9 +1509,15 @@ export function emitSwiftStandin(
                 !(
                   parent &&
                   objectConformers.has(id) &&
-                  ['Hashable', 'Equatable', 'CustomStringConvertible'].includes(name)
+                  [
+                    'Hashable',
+                    'Equatable',
+                    'CustomStringConvertible',
+                    'CustomDebugStringConvertible',
+                  ].includes(name)
                 ) &&
-                !(name === nsObjectProtocol && externalRoot(id) === nsObject),
+                !(name === nsObjectProtocol && externalRoot(id) === nsObject) &&
+                !options.unconformed?.get(path)?.has(name),
             ),
           ].filter((name, at, all) => all.indexOf(name) === at)
           const parentSymbol = superId.has(id) ? byId.get(superId.get(id)!) : undefined

package/src/swift-standins.ts

@@ -45,6 +45,7 @@ import {
 } from './swift-objc-standin'
 import {
   clangImportNames,
+  moduleMapModules,
   moduleMapName,
   swiftManifestDeclarations,
   swiftTargetModuleName,
@@ -674,6 +675,22 @@ function cxxOnly(surface: Surface): boolean {
   })
 }
 
+// the surfaces of a library slice's module map, one per module it declares: a
+// uniffi xcframework ships a module per generated header in one map, and an
+// app imports each by name.
+function mapSurfaces(modulemap: string): SliceSurface[] {
+  const text = fs.readFileSync(modulemap, 'utf8')
+  const headers = path.dirname(modulemap)
+  const modules = moduleMapModules(text)
+  if (modules.length <= 1) {
+    const module = moduleMapName(text)
+    return module ? [headerSurface(module, modulemap, headers)] : []
+  }
+  return modules.map((module) =>
+    headerSurface(module.name, generatedModuleMap(`${module.text}\n`, false), headers),
+  )
+}
+
 function simulatorSlice(xcframeworkDir: string): string | null {
   const slice = fs
     .readdirSync(xcframeworkDir)
@@ -762,8 +779,7 @@ function surfaces(
   const headers = path.join(root, 'Headers')
   for (const map of files(headers, (name) => name === 'module.modulemap')) {
     const modulemap = path.join(headers, map)
-    const module = moduleMapName(fs.readFileSync(modulemap, 'utf8'))
-    if (module) found.push(headerSurface(module, modulemap, path.dirname(modulemap)))
+    found.push(...mapSurfaces(modulemap))
   }
   if (found.length === 0 && files(headers, (name) => name.endsWith('.h')).length) {
     const module = swiftTargetModuleName(target)
@@ -964,13 +980,22 @@ export function swiftInterfaceForWasm(text: string, cFlags: readonly string[]):
     ])
     return `${interop} ${xcc.join(' ')}`
   })
-  return retargeted
-    .split('\n')
+  const lines = retargeted.split('\n')
+  // an optional requirement stays @objc, so a type its signature names must be
+  // objective-c representable: an enum it names keeps its own @objc
+  const required = lines.filter((line) => OPTIONAL_REQUIREMENT.test(line)).join('\n')
+  return lines
     .map((line) => {
       // an enum's @objc only bridges it to objective-c, which wasm has no
       // runtime for, and an @objc error enum loses its raw-value Hashable.
-      if (/\benum\s/.test(line) && TYPE_DECLARATION.test(line))
-        return line.replace(/@objc(?:\s*\([^()]*\))?\s+/g, '')
+      if (/\benum\s/.test(line) && TYPE_DECLARATION.test(line)) {
+        const name = /\benum\s+(\w+)/.exec(line)?.[1]
+        return name &&
+          new RegExp(`\\b${name}\\b`).test(required) &&
+          !/\bSwift\.Error\b/.test(line)
+          ? line
+          : line.replace(/@objc(?:\s*\([^()]*\))?\s+/g, '')
+      }
       if (TYPE_DECLARATION.test(line)) return line.replace(/@objcMembers\b/g, '')
       if (OPTIONAL_REQUIREMENT.test(line)) return line
       return line.replace(OBJC_ATTRIBUTE, '')
@@ -1522,6 +1547,18 @@ function graphStandin(
   const plain = new Set<string>()
   const unobjc = new Set<string>()
   const trapped = new Set<string>()
+  const unconformed = new Map<string, Set<string>>()
+  const objcProtocols = new Set(
+    graphs.flatMap((graph) =>
+      graph.symbols
+        .filter(
+          (symbol) =>
+            symbol.kind.identifier === 'swift.protocol' &&
+            symbol.identifier.precise.startsWith('c:'),
+        )
+        .map((symbol) => symbol.pathComponents.join('.')),
+    ),
+  )
   const file = path.join(work, `${module}.swift`)
   // a source target whose implementation compiles keeps inert bodies, and a
   // placeholder sends nothing. a target replaced because assembly cannot
@@ -1540,6 +1577,7 @@ function graphStandin(
       omit,
       plain,
       unobjc,
+      unconformed,
       trapped,
       inert,
       imports: [...(placeholder?.peachImports ?? []), ...imports],
@@ -1589,7 +1627,7 @@ function graphStandin(
         files: { [`${module}.swift`]: source },
         ...(imports.length ? { dependencies: imports } : {}),
       }
-    const before = omit.size + plain.size + unobjc.size + trapped.size
+    const before = omit.size + plain.size + unobjc.size + trapped.size + unconformed.size
     const elsewhere: string[] = []
     for (const match of check.stderr.matchAll(/^(\S+?):(\d+):\d+: error: (.*)$/gm)) {
       const owner = match[1] === file ? owners[Number(match[2]) - 1] : undefined
@@ -1599,6 +1637,15 @@ function graphStandin(
         unobjc.add(owner)
         continue
       }
+      // an objective-c protocol the guest adapts to a swift one checks the
+      // nullability a swift class's exported witness differs in
+      const conformance = /^type '\w+' does not conform to protocol '(\w+)'$/.exec(
+        match[3]!,
+      )?.[1]
+      if (owner && conformance && objcProtocols.has(conformance)) {
+        unconformed.set(owner, new Set([...(unconformed.get(owner) ?? []), conformance]))
+        continue
+      }
       if (owner && swiftPaths.has(owner))
         throw new Error(
           `Swift declaration ${module}.${owner} does not typecheck: ${match[3]}`,
@@ -1615,7 +1662,7 @@ function graphStandin(
       else if (owner) omit.set(owner, `rejected by swiftc: ${match[3]}`)
       else elsewhere.push(match[3]!)
     }
-    if (omit.size + plain.size + unobjc.size + trapped.size === before)
+    if (omit.size + plain.size + unobjc.size + trapped.size + unconformed.size === before)
       throw new Error(
         `its generated source does not typecheck: ${elsewhere.slice(0, 3).join('; ') || check.stderr.trim().slice(0, 400)}`,
       )
@@ -1788,7 +1835,20 @@ function cStandin(
   toolchain: Toolchain,
   work: string,
 ): SwiftStandin {
-  const headers = files(surface.headers, (name) => name.endsWith('.h'))
+  const everyHeader = files(surface.headers, (name) => name.endsWith('.h'))
+  const moduleRoots = moduleMapHeaders(surface.modulemap, everyHeader)
+  // the module's headers and the local headers they include: a map of several modules
+  // (one per uniffi header) gives each its own
+  const headers = [...moduleRoots]
+  for (let at = 0; at < headers.length; at++)
+    for (const [, local] of fs
+      .readFileSync(path.join(surface.headers, headers[at]!), 'utf8')
+      .matchAll(/^\s*#\s*(?:include|import)\s*["<]([^">]+)[">]/gm)) {
+      const file = path.posix.normalize(
+        path.posix.join(path.posix.dirname(headers[at]!), local!),
+      )
+      if (everyHeader.includes(file) && !headers.includes(file)) headers.push(file)
+    }
   const framework = path.basename(path.dirname(surface.modulemap)) === 'Modules'
   const headerDirectory = framework ? `${surface.module}.framework/Headers` : '.'
   const texts = new Map(
@@ -1804,9 +1864,7 @@ function cStandin(
     fs.mkdirSync(path.dirname(path.join(include, file)), { recursive: true })
     fs.writeFileSync(path.join(include, file), text)
   }
-  const roots = moduleMapHeaders(surface.modulemap, headers).map((file) =>
-    path.posix.join(headerDirectory, file),
-  )
+  const roots = moduleRoots.map((file) => path.posix.join(headerDirectory, file))
   const frameworkMap = `${surface.module}.framework/Modules/module.modulemap`
   const modulemap = `module ${surface.module} {\n${roots.map((file) => `  header "${file}"\n`).join('')}  export *\n}\n`
   const probe = path.join(work, 'declarations.c')
@@ -2728,9 +2786,14 @@ async function binaryStandins(
     fs.rmSync(work, { recursive: true, force: true })
     return error instanceof Error ? error.message : String(error)
   }
+  // a framework whose module map names headers it does not ship declares nothing
   const found = all.filter(
     (surface) =>
       !provided.has(surface.module) &&
+      (surface.kind === 'swift' ||
+        surface.kind === 'mixed' ||
+        surface.kind === 'source' ||
+        files(surface.headers, (name) => name.endsWith('.h')).length > 0) &&
       !(binary.cxxHeaders === undefined && cxxOnly(surface)),
   )
   if (found.length === 0) {

package/src/swift-submit.ts

@@ -146,7 +146,8 @@ export const MAX_SWIFT_COMPILE_IMAGE_TOTAL_BYTES = 16 * 1024 * 1024
 // 68: fetch headers replies carry `setCookies`, the response's Set-Cookie list.
 // 69: `peach.icu_item_v1` replaces `icu_data_v1`: the host fills icu's table of
 // contents and places each item's pack the first time icu opens it.
-export const SWIFT_HOST_ABI = 69
+// 70: full Objective-C forwarding uses exact typed IMPs (`peach.imp_forwarder_mint`).
+export const SWIFT_HOST_ABI = 70
 
 export interface SwiftImageUpload {
   /** the raster file picked for the asset (has the extension). */

package/src/wasm-optimize.ts

@@ -2,6 +2,7 @@ import { existsSync } from 'node:fs'
 import { join } from 'node:path'
 import { installVerifiedTarball } from '@contrast/runtime-delivery'
 import { BINARYEN_VERSION, wasmOpt } from 'wasm-opt'
+import { windowAdmission } from './admitted-mac-build'
 import { rnxHomeDir } from './home-paths'
 
 // packaged native executables, size-optimized. clang's own
@@ -60,6 +61,15 @@ async function runWasmOpt(
   skipPasses: readonly string[],
   binary: string,
 ): Promise<void> {
+  const admittedCores = windowAdmission()?.cores ?? Number(process.env.TM_EXEC_CPU_CORES)
+  const requestedCores = Number(process.env.BINARYEN_CORES)
+  const environment: NodeJS.ProcessEnv = { ...process.env, WASM_OPT_PATH: binary }
+  if (Number.isInteger(admittedCores) && admittedCores > 0)
+    environment.BINARYEN_CORES = String(
+      Number.isInteger(requestedCores) && requestedCores > 0
+        ? Math.min(admittedCores, requestedCores)
+        : admittedCores,
+    )
   const result = await wasmOpt(
     [
       '-Oz',
@@ -69,7 +79,7 @@ async function runWasmOpt(
       '-o',
       output,
     ],
-    { env: { ...process.env, WASM_OPT_PATH: binary } },
+    { env: environment },
   )
   if (result.status !== 0)
     throw new Error(`wasm-opt exited ${result.status}: ${result.stderr}`)