peachsim 0.1.2182 → 0.1.2185

package/sdk/ios/usr/lib/swift/ActivityKit.swiftmodule/arm64-apple-ios-simulator.swiftinterface

@@ -0,0 +1,14 @@
+// swift-interface-format-version: 1.0
+// swift-module-flags: -target arm64-apple-ios16.0-simulator -enable-objc-interop -enable-library-evolution -module-name ActivityKit
+@_exported import ActivityKit
+import Foundation
+import Swift
+import _Concurrency
+public protocol ActivityAttributes : Swift.Decodable, Swift.Encodable {
+  associatedtype ContentState : Swift.Decodable, Swift.Encodable, Swift.Hashable
+}
+@available(iOS 16.1, *)
+public struct Activity<Attributes> where Attributes : ActivityKit.ActivityAttributes {
+  public let id: Swift.String
+  public let attributes: Attributes
+}

package/sdk/ios/usr/lib/swift/CoreGraphics.swiftmodule/arm64-apple-ios-simulator.swiftinterface

@@ -6,3 +6,17 @@ import Swift
   public init()
   public init(_ value: Swift.Double)
 }
+extension CoreGraphics.CGPoint {
+  public static let zero: CoreGraphics.CGPoint
+}
+extension CoreGraphics.CGSize {
+  public static let zero: CoreGraphics.CGSize
+}
+extension CoreGraphics.CGVector {
+  public static let zero: CoreGraphics.CGVector
+}
+extension CoreGraphics.CGRect {
+  public static let zero: CoreGraphics.CGRect
+  public static let null: CoreGraphics.CGRect
+  public static let infinite: CoreGraphics.CGRect
+}

package/sdk/ios/usr/lib/swift/Dispatch.swiftmodule/arm64-apple-ios-simulator.swiftinterface

@@ -3,3 +3,6 @@
 @_exported import Dispatch
 import Swift
 @_objcRuntimeName(_TtC8Dispatch17_DispatchWorkItem) public class DispatchWorkItem {}
+extension Dispatch.DispatchQueue {
+  public class var main: Dispatch.DispatchQueue { get }
+}

package/sdk/ios/usr/lib/swift/Foundation.swiftmodule/arm64-apple-ios-simulator.swiftinterface

@@ -5,27 +5,137 @@
 @_exported import CoreGraphics
 import Swift
 import _Concurrency
-public struct URL {}
+public struct URL : Swift.Hashable, Swift.Codable, Swift.Sendable, Swift.CustomStringConvertible {
+  public static func == (a: Foundation.URL, b: Foundation.URL) -> Swift.Bool
+  public func hash(into hasher: inout Swift.Hasher)
+  public func encode(to encoder: any Swift.Encoder) throws
+  public init(from decoder: any Swift.Decoder) throws
+  public var description: Swift.String { get }
+}
 public struct Data {
   public typealias ReadingOptions = Foundation.NSData.ReadingOptions
   public typealias WritingOptions = Foundation.NSData.WritingOptions
   public typealias SearchOptions = Foundation.NSData.SearchOptions
+  public typealias Index = Swift.Int
+}
+public struct Date : Swift.Hashable, Swift.Codable, Swift.Sendable, Swift.Comparable, Swift.CustomStringConvertible {
+  public init()
+  public static var now: Foundation.Date { get }
+  public static let distantPast: Foundation.Date
+  public static let distantFuture: Foundation.Date
+  public static func == (a: Foundation.Date, b: Foundation.Date) -> Swift.Bool
+  public func hash(into hasher: inout Swift.Hasher)
+  public func encode(to encoder: any Swift.Encoder) throws
+  public init(from decoder: any Swift.Decoder) throws
+  public static func < (a: Foundation.Date, b: Foundation.Date) -> Swift.Bool
+  public var description: Swift.String { get }
+}
+public struct DateComponents : Swift.Hashable, Swift.Codable, Swift.Sendable, Swift.CustomStringConvertible {
+  public static func == (a: Foundation.DateComponents, b: Foundation.DateComponents) -> Swift.Bool
+  public func hash(into hasher: inout Swift.Hasher)
+  public func encode(to encoder: any Swift.Encoder) throws
+  public init(from decoder: any Swift.Decoder) throws
+  public var description: Swift.String { get }
+}
+public struct DateInterval : Swift.Hashable, Swift.Codable, Swift.Sendable, Swift.CustomStringConvertible {
+  public static func == (a: Foundation.DateInterval, b: Foundation.DateInterval) -> Swift.Bool
+  public func hash(into hasher: inout Swift.Hasher)
+  public func encode(to encoder: any Swift.Encoder) throws
+  public init(from decoder: any Swift.Decoder) throws
+  public var description: Swift.String { get }
+}
+public struct URLComponents : Swift.Hashable, Swift.Codable, Swift.Sendable, Swift.CustomStringConvertible {
+  public static func == (a: Foundation.URLComponents, b: Foundation.URLComponents) -> Swift.Bool
+  public func hash(into hasher: inout Swift.Hasher)
+  public func encode(to encoder: any Swift.Encoder) throws
+  public init(from decoder: any Swift.Decoder) throws
+  public var description: Swift.String { get }
+}
+public struct URLQueryItem : Swift.Hashable, Swift.Codable, Swift.Sendable, Swift.CustomStringConvertible {
+  public static func == (a: Foundation.URLQueryItem, b: Foundation.URLQueryItem) -> Swift.Bool
+  public func hash(into hasher: inout Swift.Hasher)
+  public func encode(to encoder: any Swift.Encoder) throws
+  public init(from decoder: any Swift.Decoder) throws
+  public var description: Swift.String { get }
+}
+public struct URLRequest : Swift.Hashable, Swift.Codable, Swift.Sendable, Swift.CustomStringConvertible {
+  public static func == (a: Foundation.URLRequest, b: Foundation.URLRequest) -> Swift.Bool
+  public func hash(into hasher: inout Swift.Hasher)
+  public func encode(to encoder: any Swift.Encoder) throws
+  public init(from decoder: any Swift.Decoder) throws
+  public var description: Swift.String { get }
+}
+public struct UUID : Swift.Hashable, Swift.Codable, Swift.Sendable, Swift.CustomStringConvertible {
+  public init()
+  public static func == (a: Foundation.UUID, b: Foundation.UUID) -> Swift.Bool
+  public func hash(into hasher: inout Swift.Hasher)
+  public func encode(to encoder: any Swift.Encoder) throws
+  public init(from decoder: any Swift.Decoder) throws
+  public var description: Swift.String { get }
+}
+public struct IndexPath : Swift.Hashable, Swift.Codable, Swift.Sendable, Swift.Comparable, Swift.CustomStringConvertible {
+  public static func == (a: Foundation.IndexPath, b: Foundation.IndexPath) -> Swift.Bool
+  public func hash(into hasher: inout Swift.Hasher)
+  public func encode(to encoder: any Swift.Encoder) throws
+  public init(from decoder: any Swift.Decoder) throws
+  public static func < (a: Foundation.IndexPath, b: Foundation.IndexPath) -> Swift.Bool
+  public var description: Swift.String { get }
+}
+public struct IndexSet : Swift.Hashable, Swift.Codable, Swift.Sendable, Swift.CustomStringConvertible {
+  public static func == (a: Foundation.IndexSet, b: Foundation.IndexSet) -> Swift.Bool
+  public func hash(into hasher: inout Swift.Hasher)
+  public func encode(to encoder: any Swift.Encoder) throws
+  public init(from decoder: any Swift.Decoder) throws
+  public var description: Swift.String { get }
+}
+public struct CharacterSet : Swift.Hashable, Swift.Codable, Swift.Sendable, Swift.CustomStringConvertible {
+  public static func == (a: Foundation.CharacterSet, b: Foundation.CharacterSet) -> Swift.Bool
+  public func hash(into hasher: inout Swift.Hasher)
+  public func encode(to encoder: any Swift.Encoder) throws
+  public init(from decoder: any Swift.Decoder) throws
+  public var description: Swift.String { get }
+}
+public struct Locale : Swift.Hashable, Swift.Codable, Swift.Sendable, Swift.CustomStringConvertible {
+  public static var current: Foundation.Locale { get }
+  public static func == (a: Foundation.Locale, b: Foundation.Locale) -> Swift.Bool
+  public func hash(into hasher: inout Swift.Hasher)
+  public func encode(to encoder: any Swift.Encoder) throws
+  public init(from decoder: any Swift.Decoder) throws
+  public var description: Swift.String { get }
+}
+public struct TimeZone : Swift.Hashable, Swift.Codable, Swift.Sendable, Swift.CustomStringConvertible {
+  public static var current: Foundation.TimeZone { get }
+  public static func == (a: Foundation.TimeZone, b: Foundation.TimeZone) -> Swift.Bool
+  public func hash(into hasher: inout Swift.Hasher)
+  public func encode(to encoder: any Swift.Encoder) throws
+  public init(from decoder: any Swift.Decoder) throws
+  public var description: Swift.String { get }
+}
+public struct Calendar : Swift.Hashable, Swift.Codable, Swift.Sendable, Swift.CustomStringConvertible {
+  public static var current: Foundation.Calendar { get }
+  public static func == (a: Foundation.Calendar, b: Foundation.Calendar) -> Swift.Bool
+  public func hash(into hasher: inout Swift.Hasher)
+  public func encode(to encoder: any Swift.Encoder) throws
+  public init(from decoder: any Swift.Decoder) throws
+  public var description: Swift.String { get }
+}
+public struct Notification {
+  public struct Name {}
+}
+public struct Decimal : Swift.Hashable, Swift.Codable, Swift.Sendable, Swift.Comparable, Swift.CustomStringConvertible {
+  public static func == (a: Foundation.Decimal, b: Foundation.Decimal) -> Swift.Bool
+  public func hash(into hasher: inout Swift.Hasher)
+  public func encode(to encoder: any Swift.Encoder) throws
+  public init(from decoder: any Swift.Decoder) throws
+  public static func < (a: Foundation.Decimal, b: Foundation.Decimal) -> Swift.Bool
+  public var description: Swift.String { get }
+}
+open class JSONDecoder {
+  public init()
+}
+open class JSONEncoder {
+  public init()
 }
-public struct Date {}
-public struct DateComponents {}
-public struct DateInterval {}
-public struct URLComponents {}
-public struct URLQueryItem {}
-public struct URLRequest {}
-public struct UUID {}
-public struct IndexPath {}
-public struct IndexSet {}
-public struct CharacterSet {}
-public struct Locale {}
-public struct TimeZone {}
-public struct Calendar {}
-public struct Notification {}
-public struct Decimal {}
 public typealias NSErrorPointer = Swift.AutoreleasingUnsafeMutablePointer<Foundation.NSError?>?
 public typealias ErrorPointer = Foundation.NSErrorPointer
 public protocol CustomNSError : Swift.Error {
@@ -33,6 +143,18 @@ public protocol CustomNSError : Swift.Error {
   var errorCode: Swift.Int { get }
   var errorUserInfo: [Swift.String : Any] { get }
 }
+public protocol LocalizedError : Swift.Error {
+  var errorDescription: Swift.String? { get }
+  var failureReason: Swift.String? { get }
+  var recoverySuggestion: Swift.String? { get }
+  var helpAnchor: Swift.String? { get }
+}
+extension Foundation.LocalizedError {
+  public var errorDescription: Swift.String? { get }
+  public var failureReason: Swift.String? { get }
+  public var recoverySuggestion: Swift.String? { get }
+  public var helpAnchor: Swift.String? { get }
+}
 public protocol _ObjectiveCBridgeableError : Swift.Error {
   init?(_bridgedNSError: __shared Foundation.NSError)
 }
@@ -313,6 +435,15 @@ public func _convertErrorToNSError(_ error: any Swift.Error) -> Foundation.NSErr
 public protocol ContiguousBytes {
   func withUnsafeBytes<R>(_ body: (Swift.UnsafeRawBufferPointer) throws -> R) rethrows -> R
 }
+extension Foundation.Data : Swift.RandomAccessCollection, Swift.MutableCollection, Swift.RangeReplaceableCollection {
+  public typealias Element = Swift.UInt8
+  public typealias Indices = Swift.Range<Swift.Int>
+  public init()
+  public var startIndex: Swift.Int { get }
+  public var endIndex: Swift.Int { get }
+  public subscript(position: Swift.Int) -> Swift.UInt8 { get set }
+  public mutating func replaceSubrange<C>(_ subrange: Swift.Range<Swift.Int>, with newElements: C) where C : Swift.Collection, C.Element == Swift.UInt8
+}
 extension Foundation.Data : Swift.Hashable, Swift.Codable, Foundation.ContiguousBytes, Swift.Sendable {
   public static func == (lhs: Foundation.Data, rhs: Foundation.Data) -> Swift.Bool
   public func hash(into hasher: inout Swift.Hasher)

package/sdk/ios/usr/lib/swift/UIKit.swiftmodule/arm64-apple-ios-simulator.swiftinterface

@@ -11,3 +11,8 @@ extension UIKit.UIWindow {
 extension UIKit.UIDevice {
   public typealias BatteryState = UIKit.UIDeviceBatteryState
 }
+extension UIKit.NSLayoutConstraint {
+  public typealias Relation = UIKit.NSLayoutRelation
+  public typealias Attribute = UIKit.NSLayoutAttribute
+  public typealias FormatOptions = UIKit.NSLayoutFormatOptions
+}

package/src/expo-native-workspace.ts

@@ -745,7 +745,8 @@ function initializeWorkspaceGit(root: string, work: string) {
   })
   const tracked = trackedSourceFiles(root, work)
   if (tracked.length > 0)
-    execFileSync('git', ['add', '-f', '--pathspec-from-file=-', '--pathspec-file-nul'], {
+    // update-index takes exact paths; add matches every file against every pathspec, which is quadratic here
+    execFileSync('git', ['update-index', '--add', '-z', '--stdin'], {
       cwd: work,
       env: { ...process.env, ...isolatedGitEnv },
       input: tracked.join('\0'),

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)