peachsim 0.1.1625 → 0.1.1635

package/src/swift-compiler-digest.ts

@@ -0,0 +1,14 @@
+import { createHash } from 'node:crypto'
+import { readFileSync } from 'node:fs'
+import path from 'node:path'
+
+// the lowering and manifest code in swift-compile.ts and its design-time lowering
+// decide the emitted output, so their text addresses every swift artifact. bundled
+// builds cannot read these files at runtime, so build-cli injects this digest.
+export function swiftCompilerSourceDigest(srcDir: string): string {
+  const hash = createHash('sha256')
+  for (const file of ['swift-compile.ts', 'swift-design-time.ts']) {
+    hash.update(readFileSync(path.join(srcDir, file)))
+  }
+  return hash.digest('hex')
+}

package/src/swift-distribution.lock.json

@@ -1,10 +1,10 @@
 {
-  "id": "1fda1fb984f25758",
-  "release": "swift-6.4.0-RELEASE",
-  "wasmSdkId": "swift-6.4.0-RELEASE_wasm-peach-34b989c2",
-  "wasmSdkUrl": "https://r2.sootsim.com/swift-wasm-sdk/swift-6.4.0-RELEASE_wasm-peach-34b989c2.artifactbundle.tar.gz",
-  "wasmSdkChecksum": "1598ac9d063e07b20aa6232acb03c7147c9a94abf989d51f1e55688eb4aba854",
-  "source": "078b4f63d3734871dc1fbea898005e2ef95a73cb",
+  "id": "4fdcd218fa180b52",
+  "release": "swift-6.4.0-RELEASE-custom-91504a66b3f012ac",
+  "wasmSdkId": "swift-6.4.0-RELEASE_wasm-peach-7fd9a101",
+  "wasmSdkUrl": "https://r2.sootsim.com/swift-wasm-sdk/swift-6.4.0-RELEASE_wasm-peach-7fd9a101.artifactbundle.tar.gz",
+  "wasmSdkChecksum": "72f7fec1d090d142d26148d6cc0cd5b1ce78da70bb97bd577dc1482eaf0299b2",
+  "source": "80c26dea3c4bbf0e29458c33a3a0e856b0942564",
   "targets": [
     "System",
     "_LocationEssentials",
@@ -36,12 +36,14 @@
     "FoundationNetworking",
     "DeveloperToolsSupport",
     "SwiftUI",
+    "os_workgroup",
     "Dispatch",
     "DarwinRecords",
     "Darwin",
     "MachO",
     "ObjectiveC",
     "PeachObjC",
+    "UIUtilities",
     "UIKitCore",
     "PeachICU",
     "PeachCMark",
@@ -179,16 +181,16 @@
   },
   "hosts": {
     "darwin-arm64": {
-      "sha256": "6a3b956b13bcc76dbf0b55533088251e2ae29badcd5c8d66394a2459e0942a32",
-      "size": 63180761
+      "sha256": "2b6768539f39bbdc2d77447fc91b00e9a7ee2d9ed732ea10e67a7b05c1c854ea",
+      "size": 69899802
     },
     "linux-x64": {
-      "sha256": "37f26adff0a90c0647065b3c2e70bfdae05c84832b27add00915d441f2f79359",
-      "size": 63183751
+      "sha256": "2d357dc6c24559b1e4f792c4142de2608e2dd91a2b322c74013af31a9346ad6e",
+      "size": 69902826
     },
     "linux-arm64": {
-      "sha256": "e329424d19ede87f4c9257de40f88220cdaff42bd82f1ab47616394ec7f32f35",
-      "size": 63181548
+      "sha256": "fdbdc2b25d102db38da6c00e74c6d198b87537aefe74365ef65793ec6feb3faa",
+      "size": 69900830
     }
   }
 }

package/src/swift-host.ts

@@ -2,7 +2,6 @@ import { createHash } from 'node:crypto'
 // the node host for every Swift preview: package inputs, one compile and
 // immutable artifact addresses. vite and the foreground CLI adapt this host.
 import fs from 'node:fs'
-import os from 'node:os'
 import path from 'node:path'
 import {
   enumerateBundleColors,
@@ -11,8 +10,10 @@ import {
   enumerateBundleResources,
   resolveSwiftImageResourceUrls,
 } from '../../sootsim-swift/src/bundleAssets'
+import { compileStringCatalog } from '../../sootsim-swift/src/stringCatalog'
 import { authHeaderValue, resolveCliAuth } from '../cli/auth'
 import { resolveContrastBackendOrigin } from './backend-origin'
+import { cacheDir } from './home-paths'
 import iosSdk from './ios-sdk-frameworks.json' with { type: 'json' }
 import { swiftBinaryModules } from './swift-binary-modules'
 import {
@@ -39,13 +40,13 @@ import {
 } from './swift-package'
 import { swiftPackageManifest } from './swift-package-manifest'
 import {
-  REMOTE_CHECKOUTS,
+  remoteSwiftCheckouts,
   resolveSwiftPackages,
   type SwiftPackageBinary,
   type SwiftPackageGap,
   type SwiftPackages,
 } from './swift-packages'
-import { readPackageFile } from './swift-source-file'
+import { readPackageFile as readSwiftSourceFile } from './swift-source-file'
 import { readSwiftStandinBehavior } from './swift-standin-config'
 import {
   standinGenerationInputs,
@@ -68,6 +69,7 @@ import {
   MAX_SWIFT_COMPILE_IMAGE_TOTAL_BYTES,
   isSwiftNativeModules,
   compileSwiftProject,
+  DEFAULT_SWIFT_COMPILE_BUILD_MS,
   httpSwiftCompileSubmit,
   swiftNativeEntry,
   type SwiftImageUpload,
@@ -242,6 +244,8 @@ interface XcodeProjectEntry {
   packages?: {
     key: string
     standinKey: string
+    /** generation always uses the original closure, before stand-ins replace targets. */
+    binaries: SwiftPackageBinary[]
     packages: SwiftPackages
     standins: SwiftStandin[]
     /** why a framework the project vendors got no stand-in, by name. */
@@ -324,16 +328,18 @@ function swiftPackages(
   // emitter), so a changed input rebuilds instead of reusing stale output.
   let cached = entry.packages
   if (cached?.key !== key) {
+    const packages = resolveSwiftPackages({
+      rootDir: app.rootDir,
+      resolved: app.packageResolved,
+      products: app.linkedProducts,
+      localDirs: app.localPackageDirs,
+      provided: entry.provided,
+    })
     cached = {
       key,
       standinKey: '',
-      packages: resolveSwiftPackages({
-        rootDir: app.rootDir,
-        resolved: app.packageResolved,
-        products: app.linkedProducts,
-        localDirs: app.localPackageDirs,
-        provided: entry.provided,
-      }),
+      packages,
+      binaries: packages.binaries,
       standins: [],
       projectGaps: new Map(),
     }
@@ -360,10 +366,7 @@ function swiftPackages(
         ]
       : [],
   )
-  const reached = [
-    ...cached.packages.binaries.filter((binary) => binary.reached),
-    ...vendored,
-  ]
+  const reached = [...cached.binaries.filter((binary) => binary.reached), ...vendored]
   if (entry.moduleRoot && entry.provided && reached.length > 0) {
     const resolved = swiftModuleToolchain(entry.moduleRoot)
     const toolchain = {
@@ -385,6 +388,8 @@ function swiftPackages(
         ]),
         binaryGaps: built.gaps,
       })
+      for (const target of new Set(built.standins.map((standin) => standin.target)))
+        console.error(`Peach: target ${target} was replaced with a stand-in`)
       cached.standins = built.standins
       cached.projectGaps = new Map(
         vendored.flatMap(({ target }) => {
@@ -408,14 +413,17 @@ const XCODE_FRAMEWORKS_DIR = '__frameworks__'
 // remote package checkouts compile here: swiftpm owns `.build` in the
 // compile's package root as its scratch directory.
 const XCODE_PACKAGES_DIR = '__packages__'
-const CHECKOUTS_PREFIX = `${REMOTE_CHECKOUTS.split(path.sep).join(path.posix.sep)}/`
 
 // the compile input key of a root-relative path in an xcode layout.
 function xcodeInputKey(layout: XcodeLayout, file: string, relative: string): string {
   const owner = layout.targetDirs.get(file)
   if (owner) return path.posix.join(owner, relative)
-  return relative.startsWith(CHECKOUTS_PREFIX)
-    ? path.posix.join(XCODE_PACKAGES_DIR, relative.slice(CHECKOUTS_PREFIX.length))
+  const checkouts = remoteSwiftCheckouts(layout.app.rootDir)
+  return file.startsWith(`${checkouts}${path.sep}`)
+    ? path.posix.join(
+        XCODE_PACKAGES_DIR,
+        path.relative(checkouts, file).split(path.sep).join('/'),
+      )
     : relative
 }
 
@@ -489,6 +497,7 @@ function xcodeLayout(root: string): XcodeLayout | null {
     targets.push({
       name: standin.module,
       path: path.posix.join(SWIFT_STANDINS_DIR, standin.module),
+      dependencies: standin.dependencies?.map((name) => ({ kind: 'target', name })),
       executable: false,
       resources: false,
       exclude: [],
@@ -500,7 +509,7 @@ function xcodeLayout(root: string): XcodeLayout | null {
   const packageConfiguration = app.configuration === 'Debug' ? 'debug' : 'release'
   for (const target of packages.targets) {
     const relative = path.relative(
-      target.remote ? path.join(root, REMOTE_CHECKOUTS) : root,
+      target.remote ? remoteSwiftCheckouts(root) : root,
       target.dir,
     )
     if (
@@ -524,6 +533,13 @@ function xcodeLayout(root: string): XcodeLayout | null {
           )
           .map((define) => define.name),
       ],
+      linkedLibraries: target.packageLibraries
+        .filter(
+          (library) =>
+            library.configuration === null ||
+            library.configuration === packageConfiguration,
+        )
+        .map((library) => library.name),
     })
     if (target.resources) {
       resourceBundles.push({
@@ -568,14 +584,19 @@ function xcodeManifest(layout: XcodeLayout): string {
       ...(target.mainActorIsolation ? ['.defaultIsolation(MainActor.self)'] : []),
       ...(target.defines ?? []).map((name) => `.define(${JSON.stringify(name)})`),
     ].join(', ')}]`
+  const libraries = (target: SwiftPackageTarget) =>
+    target.linkedLibraries?.length
+      ? `, linkerSettings: [${target.linkedLibraries.map((name) => `.linkedLibrary(${JSON.stringify(name)})`).join(', ')}]`
+      : ''
   return [
     '// swift-tools-version: 6.2',
     'import PackageDescription',
     'let package = Package(name: "app", targets: [',
     `  .executableTarget(name: "${layout.app.moduleName}", path: "${XCODE_APP_DIR}", ${settings(layout.app)}),`,
-    ...layout.targets.map(
-      (target) =>
-        `  .target(name: "${target.name}", dependencies: ${JSON.stringify((target.dependencies ?? []).map((dependency) => dependency.name))}, path: "${target.path}", ${target.exclude.length > 0 ? `exclude: ${JSON.stringify(target.exclude)}, ` : ''}${target.resources ? 'resources: [], ' : ''}${settings(target)}),`,
+    ...layout.targets.map((target) =>
+      target.systemLibrary
+        ? `  .systemLibrary(name: "${target.name}", path: "${target.path}"),`
+        : `  .target(name: "${target.name}", dependencies: ${JSON.stringify((target.dependencies ?? []).map((dependency) => dependency.name))}, path: "${target.path}", ${target.exclude.length > 0 ? `exclude: ${JSON.stringify(target.exclude)}, ` : ''}${target.resources ? 'resources: [], ' : ''}${settings(target)}${libraries(target)}),`,
     ),
     '])',
     '',
@@ -590,6 +611,17 @@ function packageFiles(root: string): string[] {
   return xcode ? xcode.files : sourceTreeFiles(canonicalRoot, canonicalRoot)
 }
 
+// remote dependencies are enumerated from peach's checkout cache, while app
+// inputs retain their selected-project boundary and all symlink checks.
+function readPackageFile(root: string, file: string, maxBytes: number): Buffer {
+  if (xcodeProjects.has(root)) {
+    const checkouts = remoteSwiftCheckouts(root)
+    if (file.startsWith(`${checkouts}${path.sep}`))
+      return readSwiftSourceFile(checkouts, file, maxBytes)
+  }
+  return readSwiftSourceFile(root, file, maxBytes)
+}
+
 // every input file under `dir`, which must stay inside `canonicalRoot`.
 function sourceTreeFiles(dir: string, canonicalRoot: string): string[] {
   const found: string[] = []
@@ -983,6 +1015,13 @@ export function buildSwiftBundleFiles(
       const disk = path.join(packagePath, ...file.split('/'))
       const bytes = readPackageFile(packagePath, disk, limits.resourceBytes)
       addFile(bundlePath === '.' ? base : `${bundlePath}/${base}`, bytes)
+      if (base.endsWith('.xcstrings')) {
+        for (const [name, table] of Object.entries(
+          compileStringCatalog(bytes.toString('utf8'), base.slice(0, -10)),
+        )) {
+          addFile(bundlePath === '.' ? name : `${bundlePath}/${name}`, Buffer.from(table))
+        }
+      }
     }
   }
   return { files, bundles, watched }
@@ -1048,6 +1087,24 @@ export function sourceStamp(
   return hash.digest('hex').slice(0, 16)
 }
 
+// sourceStamp's inputs read by content and relative to the package, so
+// another process's build copy of the same sources stamps the same.
+export function sourceContentStamp(
+  packagePath: string,
+  moduleRootOverride?: string,
+): string {
+  const hash = createHash('sha256')
+  hash.update(JSON.stringify(xcodeProjects.get(packagePath)?.behavior ?? {}))
+  const libraries = projects.get(packagePath)?.libraries
+  if (libraries) hash.update(JSON.stringify(libraries))
+  for (const file of [...new Set(packageFiles(packagePath))].sort()) {
+    hash.update(path.relative(packagePath, file))
+    hash.update(fs.readFileSync(file))
+  }
+  hash.update(moduleStamp(packagePath, moduleRootOverride, false))
+  return hash.digest('hex').slice(0, 16)
+}
+
 // the linked module's part of the source stamp
 function moduleStamp(
   packagePath: string,
@@ -1177,9 +1234,7 @@ function packageSnapshot(project: SwiftProject, entry: string): SwiftPackageSnap
           .relative(project.packagePath, file)
           .split(path.sep)
           .join(path.posix.sep)
-        return layout && file.endsWith('.metal')
-          ? xcodeInputKey(layout, file, relative)
-          : relative
+        return layout ? xcodeInputKey(layout, file, relative) : relative
       }),
     ),
     resources: buildSwiftResourceTable(project, '', files),
@@ -1304,13 +1359,20 @@ async function compile(
       if (process.env.CONTRAST_SWIFT_BUILD_ROOT)
         return process.env.CONTRAST_SWIFT_BUILD_ROOT
       const resolvedPath = path.resolve(packagePath)
+      // units of one app share a root so the module cache stays warm.
+      // peach-expo-swift/<app>/<scope>/<package> shares <app>/<scope>, and
+      // the older <app>/<package> layout shares <app>. the scope is this
+      // process, so two servers do not compile into one tree.
+      const parts = resolvedPath.split(path.sep)
+      const expoAt = parts.lastIndexOf('peach-expo-swift')
+      const scoped = expoAt >= 0 && parts.length >= expoAt + 4
       const buildKeyPath =
-        path.basename(path.dirname(path.dirname(resolvedPath))) === 'peach-expo-swift'
-          ? path.dirname(resolvedPath)
+        expoAt >= 0 && parts.length >= expoAt + 3
+          ? parts.slice(0, scoped ? expoAt + 3 : expoAt + 2).join(path.sep)
           : resolvedPath
       return path.join(
-        os.tmpdir(),
-        'contrast-swift-build',
+        cacheDir(),
+        'swift-builds',
         createHash('sha256')
           .update(`${moduleRoot}\0${buildKeyPath}`)
           .digest('hex')
@@ -1496,7 +1558,7 @@ async function compileRemote(
     hosted?.authorization ?? (auth ? authHeaderValue(auth) : undefined)
   const signal = AbortSignal.any([
     ...(ownerSignal ? [ownerSignal] : []),
-    AbortSignal.timeout(5 * 60_000),
+    AbortSignal.timeout(DEFAULT_SWIFT_COMPILE_BUILD_MS + 60_000),
   ])
   const submit = httpSwiftCompileSubmit({
     endpoint: origin,

package/src/swift-icu.ts

@@ -4,6 +4,7 @@ import { existsSync, readFileSync } from 'node:fs'
 import path from 'node:path'
 import { promisify } from 'node:util'
 import { gzip } from 'node:zlib'
+import { swiftSdkOptions } from './swift-toolchain.ts'
 
 /**
  * the icu common data a swift artifact reserves and its host fills
@@ -49,15 +50,21 @@ function memo<T>(
 
 /** the raw blob, for a harness that fills an artifact in node. */
 export function swiftIcuData(toolchainBin: string, sdk: string): Promise<Buffer> {
-  return memo(raw, `${toolchainBin}\0${sdk}`, () => load(toolchainBin, sdk))
+  return memo(raw, JSON.stringify([toolchainBin, sdk, swiftSdkOptions()]), () =>
+    load(toolchainBin, sdk),
+  )
 }
 
 /** the served form: gzipped and content-addressed. */
 export function swiftIcuAsset(toolchainBin: string, sdk: string): Promise<SwiftIcuAsset> {
-  return memo(assets, `${toolchainBin}\0${sdk}`, async () => {
-    const zipped = await deflate(await swiftIcuData(toolchainBin, sdk))
-    return { sha256: createHash('sha256').update(zipped).digest('hex'), gzip: zipped }
-  })
+  return memo(
+    assets,
+    JSON.stringify([toolchainBin, sdk, swiftSdkOptions()]),
+    async () => {
+      const zipped = await deflate(await swiftIcuData(toolchainBin, sdk))
+      return { sha256: createHash('sha256').update(zipped).digest('hex'), gzip: zipped }
+    },
+  )
 }
 
 async function load(toolchainBin: string, sdk: string): Promise<Buffer> {
@@ -66,12 +73,13 @@ async function load(toolchainBin: string, sdk: string): Promise<Buffer> {
   // missing piece instead of shelling out to sdk configure.
   if (!existsSync(swift))
     throw new Error(`swift-icu: no swift at ${swift} for the ${sdk} SDK's icu data`)
-  const { stdout: listed } = await run(swift, ['sdk', 'list'])
+  const { stdout: listed } = await run(swift, ['sdk', 'list', ...swiftSdkOptions()])
   if (!listed.split('\n').some((line) => line.trim() === sdk))
     throw new Error(`swift-icu: ${sdk} is not installed for ${swift}`)
   const { stdout } = await run(swift, [
     'sdk',
     'configure',
+    ...swiftSdkOptions(),
     '--show-configuration',
     sdk,
     'wasm32-unknown-wasip1',

package/src/swift-objc-sdk.ts

@@ -11,6 +11,129 @@ export const IOS_SDK_TARGET = 'arm64-apple-ios16.0-simulator'
 
 /** the clang headers and module maps, by path under the sdk root. */
 export const IOS_SDK_HEADERS: Record<string, string> = {
+  // darwin pointer and mach port identities used in public native headers.
+  'usr/include/pthread.h': `#pragma once
+struct _opaque_pthread_t;
+typedef struct _opaque_pthread_t *pthread_t;
+`,
+  'usr/include/mach/mach_types.h': `#pragma once
+#include <stdint.h>
+typedef unsigned int natural_t;
+typedef int integer_t;
+typedef int vm_prot_t;
+typedef integer_t cpu_type_t;
+typedef integer_t cpu_subtype_t;
+typedef natural_t *thread_state_t;
+typedef int thread_state_flavor_t;
+typedef natural_t mach_port_t;
+typedef mach_port_t thread_t;
+typedef thread_t thread_act_t;
+typedef thread_act_t *thread_act_array_t;
+typedef natural_t mach_msg_type_number_t;
+`,
+  'usr/include/mach/mach.h': `#pragma once
+#include <mach/mach_types.h>
+`,
+  'usr/include/TargetConditionals.h': `#pragma once
+#define TARGET_OS_IPHONE 1
+#define TARGET_OS_IOS 1
+#define TARGET_OS_SIMULATOR 1
+#define TARGET_OS_OSX 0
+#define TARGET_OS_MAC 1
+#define TARGET_OS_TV 0
+#define TARGET_OS_WATCH 0
+#define TARGET_OS_VISION 0
+#define TARGET_OS_MACCATALYST 0
+#define TARGET_IPHONE_SIMULATOR 1
+#define TARGET_CPU_ARM64 1
+#define TARGET_CPU_X86_64 0
+#define TARGET_RT_64_BIT 1
+`,
+  'usr/include/stdlib.h': `#pragma once
+#include <stddef.h>
+void exit(int) __attribute__((noreturn));
+void abort(void) __attribute__((noreturn));
+void *malloc(size_t);
+void free(void *);
+`,
+  'usr/include/unistd.h': `#pragma once
+#include <stdlib.h>
+void _exit(int) __attribute__((noreturn));
+`,
+  'usr/include/string.h': `#pragma once
+#include <stddef.h>
+size_t strlen(const char *);
+char *strdup(const char *);
+void *memcpy(void *, const void *, size_t);
+void *memset(void *, int, size_t);
+int strcmp(const char *, const char *);
+`,
+  'usr/include/sys/types.h': `#pragma once
+#include <time.h>
+#include <stddef.h>
+typedef long ssize_t;
+`,
+  'usr/include/time.h': `#pragma once
+typedef long time_t;
+`,
+  'usr/include/dlfcn.h': `#pragma once
+typedef struct dl_info {
+  const char *dli_fname;
+  void *dli_fbase;
+  const char *dli_sname;
+  void *dli_saddr;
+} Dl_info;
+`,
+  'usr/include/sys/ucontext.h': `#pragma once
+#include <stdint.h>
+#define _STRUCT_ARM_EXCEPTION_STATE64 struct __darwin_arm_exception_state64
+_STRUCT_ARM_EXCEPTION_STATE64 { uint64_t __far; uint32_t __esr, __exception; };
+#define _STRUCT_ARM_THREAD_STATE64 struct __darwin_arm_thread_state64
+_STRUCT_ARM_THREAD_STATE64 {
+  uint64_t __x[29];
+  uint64_t __fp, __lr, __sp, __pc;
+  uint32_t __cpsr, __pad;
+};
+#define _STRUCT_ARM_NEON_STATE64 struct __darwin_arm_neon_state64
+_STRUCT_ARM_NEON_STATE64 { unsigned __int128 __v[32]; uint32_t __fpsr, __fpcr; };
+#define _STRUCT_MCONTEXT64 struct __darwin_mcontext64
+_STRUCT_MCONTEXT64 {
+  _STRUCT_ARM_EXCEPTION_STATE64 __es;
+  _STRUCT_ARM_THREAD_STATE64 __ss;
+  _STRUCT_ARM_NEON_STATE64 __ns;
+};
+`,
+  'usr/include/mach-o/loader.h': `#pragma once
+#include <stdint.h>
+#include <mach/mach_types.h>
+#define LC_SEGMENT_64 0x19
+struct mach_header_64 {
+  uint32_t magic;
+  int32_t cputype, cpusubtype;
+  uint32_t filetype, ncmds, sizeofcmds, flags, reserved;
+};
+struct segment_command_64 {
+  uint32_t cmd, cmdsize;
+  char segname[16];
+  uint64_t vmaddr, vmsize, fileoff, filesize;
+  int32_t maxprot, initprot;
+  uint32_t nsects, flags;
+};
+struct section_64 {
+  char sectname[16], segname[16];
+  uint64_t addr, size;
+  uint32_t offset, align, reloff, nreloc, flags, reserved1, reserved2, reserved3;
+};
+`,
+  'usr/include/mach-o/nlist.h': `#pragma once
+#include <stdint.h>
+struct nlist_64 {
+  union { uint32_t n_strx; } n_un;
+  uint8_t n_type, n_sect;
+  uint16_t n_desc;
+  uint64_t n_value;
+};
+`,
   'usr/include/module.modulemap': `module ObjectiveC [system] {
   header "objc/NSObject.h"
   export *
@@ -67,6 +190,10 @@ __attribute__((objc_root_class))
 @end
 @interface Protocol : NSObject
 @end
+`,
+  'System/Library/Frameworks/CoreFoundation.framework/Headers/CoreFoundation.h': `#pragma once
+#import <Foundation/Foundation.h>
+typedef const struct __attribute__((objc_bridge(NSString))) __CFString *CFStringRef;
 `,
   'System/Library/Frameworks/CoreGraphics.framework/Headers/CoreGraphics.h': `#pragma once
 #include <stdint.h>
@@ -99,9 +226,15 @@ typedef struct __attribute__((objc_bridge(id))) CGColorSpace *CGColorSpaceRef;
 #include <stddef.h>
 #include <stdbool.h>
 #include <stdarg.h>
+#include <stdlib.h>
+#include <string.h>
+#include <time.h>
+#include <TargetConditionals.h>
 #import <objc/NSObject.h>
 #import <CoreGraphics/CoreGraphics.h>
 
+@class NSException;
+typedef void NSUncaughtExceptionHandler(NSException *exception);
 #define FOUNDATION_EXPORT extern
 #define FOUNDATION_EXTERN extern
 #define FOUNDATION_STATIC_INLINE static inline
@@ -237,16 +370,6 @@ typedef struct __attribute__((objc_bridge(id))) CGColorSpace *CGColorSpaceRef;
 #define CF_IMPLICIT_BRIDGING_DISABLED _Pragma("clang arc_cf_code_audited end")
 #define NS_NONATOMIC_IOSONLY nonatomic
 #define NS_UNAVAILABLE_INIT
-#define TARGET_OS_IPHONE 1
-#define TARGET_OS_IOS 1
-#define TARGET_OS_SIMULATOR 1
-#define TARGET_OS_OSX 0
-#define TARGET_OS_MAC 1
-#define TARGET_OS_TV 0
-#define TARGET_OS_WATCH 0
-#define TARGET_OS_VISION 0
-#define TARGET_OS_MACCATALYST 0
-#define TARGET_IPHONE_SIMULATOR 1
 #define NSIntegerMax LONG_MAX
 #define NSIntegerMin LONG_MIN
 #define NSUIntegerMax ULONG_MAX

package/src/swift-objc-standin.ts

@@ -26,6 +26,7 @@ export interface ObjcSurface {
   module: string
   modulemap: string
   headers: string
+  dependencies?: { module: string; headers: string }[]
 }
 
 export interface ObjcView {
@@ -123,7 +124,7 @@ export function objcView(
   const include = path.join(work, 'include')
   const headersDir = framework
     ? path.join(frameworks, `${surface.module}.framework`, 'Headers')
-    : include
+    : path.join(include, surface.module)
   const originals = new Map(
     headerFiles(surface.headers).map((file) => [
       file,
@@ -143,7 +144,22 @@ export function objcView(
       path.join(frameworks, `${surface.module}.framework`, 'Modules', 'module.modulemap'),
     )
   } else {
-    fs.copyFileSync(surface.modulemap, path.join(include, 'module.modulemap'))
+    fs.copyFileSync(surface.modulemap, path.join(headersDir, 'module.modulemap'))
+  }
+  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 supplied = path.join(dependency.headers, 'module.modulemap')
+    fs.writeFileSync(
+      path.join(dir, 'module.modulemap'),
+      fs.existsSync(supplied)
+        ? fs.readFileSync(supplied, 'utf8')
+        : `module ${dependency.module} { umbrella "." export * }\n`,
+    )
   }
   const stubs = path.join(work, 'stubs')
   const stubIncludes = path.join(work, 'stub-include')
@@ -158,6 +174,12 @@ export function objcView(
     frameworks,
     '-I',
     include,
+    '-I',
+    headersDir,
+    ...(surface.dependencies ?? []).flatMap((dependency) => [
+      '-I',
+      path.join(include, dependency.module),
+    ]),
     '-F',
     stubs,
     '-I',
@@ -300,7 +322,7 @@ 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, 3).join('; ')}`,
+        `its headers do not import as Swift: ${[...new Set(errors.map((match) => match[4]!))].slice(0, 10).join('; ')}`,
       )
     if (missing.size > 0) declareMissing()
   }