peachsim 0.1.2224 → 0.1.2228

package/src/swift-compile.ts

@@ -6,6 +6,7 @@ import {
 } from 'node:child_process'
 import { createHash, randomUUID } from 'node:crypto'
 import {
+  chmodSync,
   copyFileSync,
   cpSync,
   existsSync,
@@ -48,6 +49,7 @@ import {
 } from './swift-distribution-contract'
 import { foundationCategoryObjects } from './swift-foundation'
 import { compileGuestLink } from './swift-guest-compile'
+import { CLANG_TARGET_MODULE_WRAPPER } from './swift-guest-source-inputs'
 import {
   brotliCompressQ11,
   brotliCompressQ4,
@@ -140,7 +142,7 @@ import {
   SWIFT_FRAMEWORK_PRODUCT_FILE,
   swiftFrameworkProductSchema,
 } from './swiftRuntimeProductContract'
-import { KEEP_WASM_NAMES, optimizeWasm, WASM_OPTIMIZE_IDENTITY } from './wasm-optimize'
+import { KEEP_WASM_NAMES, lowerWasm, WASM_LOWER_IDENTITY } from './wasm-optimize'
 import { writeBuildFile } from './write-build-file'
 import { writeXcodeHeaderSearch } from './xcode-header-search'
 import type { SwiftImageUpload } from './swift-submit'
@@ -263,7 +265,7 @@ async function runCompiler(
   }
 }
 
-export const WASM_TRIPLE = 'wasm32-unknown-wasip1'
+export const WASM_TRIPLE = 'wasm64-unknown-wasip1'
 
 // swiftpm's step counter, echoed while a build runs; its diagnostics print
 // once, with the failure.
@@ -435,6 +437,26 @@ const clangInterfaceHeader = (header: string): string =>
     .replace(/\b_TtC10Foundation\d+(NS\w+)\b/g, '$1')
     .replace(/\b__attribute__\(\(objc_subclassing_restricted\)\)\s*/g, '')
 
+export function swiftHeaderWithSuperclassImports(
+  header: string,
+  interfaceFor: (name: string) => { file: string; header: string } | null,
+): string {
+  const superclasses = new Set(
+    [...header.matchAll(/@interface\s+\w+\s*:\s*(\w+)/g)].map((match) => match[1]!),
+  )
+  return header.replace(/^@import (\w+);$/gm, (statement, name: string) => {
+    const dependency = interfaceFor(name)
+    if (
+      !dependency ||
+      ![...swiftInterfaceDeclarations(dependency.header)].some((name) =>
+        superclasses.has(name),
+      )
+    )
+      return statement
+    return `${statement}\n#import ${JSON.stringify(dependency.file)}`
+  })
+}
+
 /** the Objective-C protocols and classes a generated interface header defines. */
 export const swiftInterfaceDeclarations = (header: string): Set<string> =>
   new Set([
@@ -906,7 +928,7 @@ export function swiftOptionalFramework(name: string): boolean {
 // an import may carry attributes (`@_exported`, `@preconcurrency`) and a
 // declaration kind (`import struct Nuke.ImageRequest`).
 const SWIFT_IMPORT =
-  /^\s*(?:@\w+(?:\([^)]*\))?\s+)*import\s+(?:(?:typealias|struct|class|enum|protocol|let|var|func)\s+)?([A-Za-z_][A-Za-z0-9_]*)/
+  /^\s*(?:@\w+(?:\([^)]*\))?\s+|(?:public|package|internal|fileprivate|private)\s+)*import\s+(?:(?:typealias|struct|class|enum|protocol|let|var|func)\s+)?([A-Za-z_][A-Za-z0-9_]*)/
 
 // three-valued (kleene) logic shared by the swift and c condition
 // evaluators: an undecided operand only decides when the other forces the
@@ -933,7 +955,7 @@ const kleeneOr = (
       : undefined
 
 // a compilation condition as the wasm compile sees it after the source
-// rewrite below: `os(iOS)` and `os(WASI)` hold, other platforms do not,
+// rewrite below: `os(iOS)` holds, other platforms (WASI too) do not,
 // `canImport` holds for an available module. what the scan cannot know
 // (custom flags, swift versions, features) is undefined, three-valued
 // through `!`, `&&` and `||`.
@@ -956,10 +978,11 @@ function swiftCondition(
     const call = /^(\w+)\s*\(\s*([^,()]*?)\s*(?:,[^()]*)?\)$/.exec(token ?? '')
     if (!call) return undefined
     const [, name, argument] = call
-    if (name === 'os') return argument === 'iOS' || argument === 'WASI'
-    if (name === 'canImport') return available?.has(argument!)
+    if (name === 'os') return argument === 'iOS'
+    if (name === 'canImport')
+      return argument !== 'FoundationNetworking' && available?.has(argument!)
     if (name === 'targetEnvironment') return argument === 'simulator'
-    if (name === 'arch') return argument === 'wasm32'
+    if (name === 'arch') return argument === 'wasm64'
     return undefined
   }
   const both = (): boolean | undefined => {
@@ -1103,7 +1126,7 @@ export function swiftSdkPaths(
       ...options,
       '--show-configuration',
       sdk,
-      'wasm32-unknown-wasip1',
+      'wasm64-unknown-wasip1',
     ],
     { encoding: 'utf8', env: swiftEnvironment(), stdio: ['ignore', 'pipe', 'pipe'] },
   )
@@ -1636,6 +1659,19 @@ export const FOUNDATION_IMPLICIT_MODULES = [
   'PeachFoundationCombine',
   'Darwin',
 ]
+// darwin's Foundation is one module, so `@preconcurrency import Foundation`
+// (or of UIKit or SwiftUI, which re-export it) relaxes Sendable checking for
+// everything it exports. Peach splits that surface across ObjectiveC and the
+// implicit modules, and swift credits a type's import attributes to a direct
+// import of its own module before the first re-exporting import, which is
+// always an implicit one. naming each split module under the same attribute
+// gives the darwin result; the guard keeps host-built macro sources intact.
+const PRECONCURRENCY_FOUNDATION_IMPORT =
+  /^[ \t]*@preconcurrency[ \t]+(?:(?:public|package|internal|fileprivate|private)[ \t]+)?import[ \t]+(?:Foundation|UIKit|SwiftUI)[ \t]*(?:\/\/.*)?$/m
+export function withPreconcurrencyFoundationModules(source: string): string {
+  if (!PRECONCURRENCY_FOUNDATION_IMPORT.test(source)) return source
+  return `${source}${source.endsWith('\n') ? '' : '\n'}#if canImport(PeachObjC)\n${['ObjectiveC', ...FOUNDATION_IMPLICIT_MODULES].map((module) => `@preconcurrency import ${module}\n`).join('')}#endif\n`
+}
 const FOUNDATION_IMPLICIT_FLAGS = FOUNDATION_IMPLICIT_MODULES.map(
   (module) => `, "-Xfrontend", "-import-module", "-Xfrontend", "${module}"`,
 ).join('')
@@ -1689,7 +1725,8 @@ export function swiftArtifactHash(
   if (input.oneModule) hash.update('one-module\n')
   if (KEEP_WASM_NAMES) hash.update('names\n')
   hash.update(swiftModuleDigest(moduleRoot))
-  if (input.optimize) hash.update(`optimize\n${WASM_OPTIMIZE_IDENTITY}\n`)
+  hash.update(`lower\n${WASM_LOWER_IDENTITY}\n`)
+  if (input.optimize) hash.update('optimize\n')
   for (const file of Object.keys(input.files).sort()) {
     hash.update(createHash('sha256').update(file).digest())
     hash.update(createHash('sha256').update(input.files[file]).digest())
@@ -1855,6 +1892,10 @@ function toolsetOrdersLibcxxBeforeDarwinOverlay(options: readonly string[]): boo
   return libcxx >= 0 && overlay > libcxx
 }
 
+// the iOS minimum swiftpm gives a package that declares no iOS platform
+// (swift-package-manager PackageModel Platform.iOS oldestSupportedVersion).
+const SWIFTPM_DEFAULT_IOS_DEPLOYMENT_TARGET = '12.0'
+
 export function emitSwiftPackageManifest(args: {
   /** the build root holding the linker each executable links with. */
   root: string
@@ -2230,7 +2271,8 @@ export function emitSwiftPackageManifest(args: {
         ? `, "-emit-objc-header-path", ${JSON.stringify(path.join(args.headerDirectory, `${target.name}-Swift${args.nativeHeaderDeclarations?.[target.name] ? '.original' : ''}.h`))}`
         : ''
     const clangMode = target.cxxInterop ? '' : ', "-Xcc", "-fno-cxx-modules"'
-    const swiftSettings = `swiftSettings: [.swiftLanguageMode(.v${target.languageMode}),${isolation}${interoperability}${defines}${features}${upcoming} .unsafeFlags(${swiftFlagArray(`["-Osize", "-Xfrontend", "-enable-cross-import-overlays"${overlayFlags}${FOUNDATION_IMPLICIT_FLAGS}${oneModule ? ONE_IMPLICIT_FLAGS : ''}${imports}${nativeImportFlags}${objcFlags}${header}${clangMode}${upstream}]`)})]`
+    const deployment = `, "-Xfrontend", "-peach-ios-deployment-target", "-Xfrontend", ${JSON.stringify(target.iosDeploymentTarget ?? SWIFTPM_DEFAULT_IOS_DEPLOYMENT_TARGET)}`
+    const swiftSettings = `swiftSettings: [.swiftLanguageMode(.v${target.languageMode}),${isolation}${interoperability}${defines}${features}${upcoming} .unsafeFlags(${swiftFlagArray(`["-Osize", "-Xfrontend", "-enable-cross-import-overlays"${overlayFlags}${FOUNDATION_IMPLICIT_FLAGS}${oneModule ? ONE_IMPLICIT_FLAGS : ''}${imports}${nativeImportFlags}${objcFlags}${header}${clangMode}${deployment}${upstream}]`)})]`
     const deps = [
       ...new Set([
         ...(target.dependencies ?? []).flatMap((dependency) =>
@@ -2500,12 +2542,16 @@ export function syncSwiftTree(base: string, files: Map<string, string | Buffer>)
 // every iOS branch of the app would compile out. peach is the iOS simulator,
 // so `targetEnvironment(simulator)` holds too. a condition line names iOS
 // as `true` padded to the same length, so diagnostics keep their columns;
-// os(WASI) still holds for code written for wasm. only `#if` and `#elseif`
-// lines that begin in code change: a line inside a string literal or a block
-// comment is content. the artifact hash stays over the original text.
+// `os(WASI)` is `false` the same way, as on iOS, so a package takes the
+// branch its iOS app runs. only `#if` and `#elseif` lines that begin in code
+// change: a line inside a string literal or a block comment is content. the
+// artifact hash stays over the original text.
 // objective-c syntax is compiled unchanged by the native importer.
 const DIRECTIVE = /^[ \t]*#(?:if|elseif)\b/
 const OS_IOS = /\b(?:os\(\s*iOS\s*\)|targetEnvironment\(\s*simulator\s*\))/g
+// iOS has no FoundationNetworking module; Peach's is imported implicitly
+// and gated packages must take their Apple branch
+const NOT_ON_IOS = /\b(?:os\(\s*WASI\s*\)|canImport\(\s*FoundationNetworking\s*\))/g
 // uikit makes app and scene delegates from their class through the objc
 // runtime; here their protocols require init(), which a non-final class
 // meets only with a required one. a class declaring one of them that is
@@ -2532,19 +2578,17 @@ function compiledSwiftSources(
           )
         })
         const manifest = /(?:^|\/)Package(?:@swift-[\d.]+)?\.swift$/.test(file)
-        return [
-          file,
-          manifest && (!owner || /^Package(?:@swift-[\d.]+)?\.swift$/.test(file))
-            ? source
-            : swiftSourceAsIOS(
-                source,
-                overlayFrameworks,
-                owner?.defines?.includes(SWIFT_XCODE_BUILD_CONDITION) &&
-                  !owner.defines.includes('SWIFT_PACKAGE')
-                  ? false
-                  : undefined,
-              ),
-        ]
+        if (manifest && (!owner || /^Package(?:@swift-[\d.]+)?\.swift$/.test(file)))
+          return [file, source]
+        const ios = swiftSourceAsIOS(
+          source,
+          overlayFrameworks,
+          owner?.defines?.includes(SWIFT_XCODE_BUILD_CONDITION) &&
+            !owner.defines.includes('SWIFT_PACKAGE')
+            ? false
+            : undefined,
+        )
+        return [file, withPreconcurrencyFoundationModules(ios)]
       }),
   )
 }
@@ -3251,21 +3295,26 @@ export function foundationOwnerOf(name: string): string | undefined {
   return undefined
 }
 
-export function swiftSourceAsIOS(
+// dependency sources take the same platform branches as app sources
+function swiftPackageSourceAsIOS(source: string): string {
+  return swiftConditionsAsIOS(source, swiftCodeScan(source).lineStarts)
+}
+
+function swiftConditionsAsIOS(
   source: string,
-  overlayFrameworks: () => ReadonlySet<string>,
+  lineStarts: ReadonlySet<number>,
   swiftPackage?: boolean,
 ): string {
-  const { lineStarts, tokens } = swiftCodeScan(source)
   let offset = 0
-  // equal width, so every token offset still holds
-  const conditioned = source
+  return source
     .split('\n')
     .map((line) => {
       const start = offset
       offset += line.length + 1
       if (!lineStarts.has(start) || !DIRECTIVE.test(line)) return line
-      const platform = line.replace(OS_IOS, (match) => 'true'.padEnd(match.length))
+      const platform = line
+        .replace(OS_IOS, (match) => 'true'.padEnd(match.length))
+        .replace(NOT_ON_IOS, (match) => 'false'.padEnd(match.length))
       // SwiftPM is the backend for Xcode targets, whose original conditions
       // do not include its automatically injected SWIFT_PACKAGE definition.
       return swiftPackage === false
@@ -3273,6 +3322,16 @@ export function swiftSourceAsIOS(
         : platform
     })
     .join('\n')
+}
+
+export function swiftSourceAsIOS(
+  source: string,
+  overlayFrameworks: () => ReadonlySet<string>,
+  swiftPackage?: boolean,
+): string {
+  const { lineStarts, tokens } = swiftCodeScan(source)
+  // equal width, so every token offset still holds
+  const conditioned = swiftConditionsAsIOS(source, lineStarts, swiftPackage)
   let out = ''
   let copied = 0
   const sceneLifecycleBodies = new Set<number>()
@@ -3859,7 +3918,7 @@ function stripCCode(source: string): string {
   return code
 }
 
-// whether the unit's code under wasm32 takes its own return address, which
+// whether the unit's wasm code takes its own return address, which
 // the WebAssembly backend rejects ("hasn't implemented __builtin_return_address"):
 // native machine code the target has no lowering for, like assembly. branches
 // the native architecture macros guard are not wasm code.
@@ -3867,7 +3926,7 @@ const wasmMacroEnvironment: SwiftCMacroEnvironment = {
   ...emptyMacroEnvironment,
   defines: new Map([
     ['__wasm__', '1'],
-    ['__wasm32__', '1'],
+    ['__wasm64__', '1'],
     ['__wasi__', '1'],
   ]),
 }
@@ -5883,8 +5942,17 @@ export function writeSwiftProject(
       }) + moduleFiles,
     )
   }
-  for (const [file, bytes] of Object.entries(input.packageFiles ?? {}))
-    files.set(path.join(layout.root, file), Buffer.from(bytes, 'base64'))
+  for (const [file, bytes] of Object.entries(input.packageFiles ?? {})) {
+    const contents = Buffer.from(bytes, 'base64')
+    files.set(
+      path.join(layout.root, file),
+      file.endsWith('.swift') && !/(?:^|\/)Package(?:@swift-[\d.]+)?\.swift$/.test(file)
+        ? withPreconcurrencyFoundationModules(
+            swiftPackageSourceAsIOS(contents.toString('utf8')),
+          )
+        : contents,
+    )
+  }
   for (const [file, bytes] of Object.entries(input.projectFiles ?? {})) {
     const destination = path.join(layout.root, file)
     if (files.has(destination)) continue
@@ -5904,15 +5972,43 @@ export function writeSwiftProject(
           ]
         : []),
     ]
+    // swiftpm compiles a package's C and Objective-C targets with -fmodules
+    // and -fmodule-name=<target> only on darwin triples, so `@import UIKit`
+    // in an iOS package compiles natively and fails on wasm. the toolset
+    // passes -fmodules; this names the target from the <target>.build
+    // directory swiftpm writes its objects to, so a target's own headers stay
+    // textual as on darwin.
+    const clangWrapper = path.join(layout.root, CLANG_TARGET_MODULE_WRAPPER)
+    files.set(
+      clangWrapper,
+      [
+        '#!/bin/sh',
+        'name=',
+        'prev=',
+        'for arg in "$@"; do',
+        '  if [ "$prev" = -o ]; then name=${arg%/*}; name=${name##*/}; fi',
+        '  prev=$arg',
+        'done',
+        'case $name in',
+        `  *.build) exec '${path.join(nativeToolchain(), 'clang')}' "-fmodule-name=\${name%.build}" "$@" ;;`,
+        `  *) exec '${path.join(nativeToolchain(), 'clang')}' "$@" ;;`,
+        'esac',
+        '',
+      ].join('\n'),
+    )
     files.set(
       path.join(layout.root, '.peach-target-toolset.json'),
       JSON.stringify({
         schemaVersion: '1.0',
+        cCompiler: {
+          extraCLIOptions: [
+            ...nativeToolsetFlags,
+            '-fmodules',
+            `-fmodules-cache-path=${path.join(layout.root, '.build', 'ModuleCache')}`,
+          ],
+        },
         ...(nativeToolsetFlags.length > 0
-          ? {
-              cCompiler: { extraCLIOptions: nativeToolsetFlags },
-              cxxCompiler: { extraCLIOptions: nativeToolsetFlags },
-            }
+          ? { cxxCompiler: { extraCLIOptions: nativeToolsetFlags } }
           : {}),
         swiftCompiler: {
           extraCLIOptions: [
@@ -6004,6 +6100,8 @@ export function writeSwiftProject(
       '// dependency targets emit their native compatibility headers.\n',
     )
   syncSwiftTree(layout.root, files)
+  const clangWrapper = path.join(layout.root, CLANG_TARGET_MODULE_WRAPPER)
+  if (files.has(clangWrapper)) chmodSync(clangWrapper, 0o755)
   // header-consuming units have moved downstream. only the emitted target
   // graph describes which producer builds already emit another header.
   const dependencies = new Map(
@@ -6619,6 +6717,9 @@ async function buildFrameworkProducts(
       'release',
       '-Xswiftc',
       '-Osize',
+      // the release link strips all debug info, so none is generated
+      '-Xswiftc',
+      '-gnone',
       '-Xswiftc',
       '-num-threads',
       '-Xswiftc',
@@ -7262,14 +7363,18 @@ function compileSwiftProjectOnce(
             const projectProcess = options.project
               ? prepareSwiftProjectProcess(root, options.project)
               : undefined
+            // the native build system takes its C compiler from CC, never a toolset
+            const compiler: Record<string, string> = preparation.targetToolset
+              ? { CC: path.join(root, CLANG_TARGET_MODULE_WRAPPER) }
+              : {}
             const appOptions = projectProcess
               ? {
                   ...buildOptions,
                   uid: projectProcess.uid,
                   gid: projectProcess.gid,
-                  confined: projectProcess.env,
+                  confined: { ...projectProcess.env, ...compiler },
                 }
-              : buildOptions
+              : { ...buildOptions, env: { ...buildOptions.env, ...compiler } }
             const unprepared = preparation.targetFailures.map(
               (failure) => `error: target ${failure}`,
             )
@@ -7306,6 +7411,9 @@ function compileSwiftProjectOnce(
                 : []),
               '-c',
               'release',
+              // the link strips debug info, so none is generated (as for the framework)
+              '-Xswiftc',
+              '-gnone',
               '-Xswiftc',
               '-num-threads',
               '-Xswiftc',
@@ -7349,6 +7457,58 @@ function compileSwiftProjectOnce(
             if (existsSync(linked) && statSync(linked).size <= 8)
               rmSync(linked, { force: true })
             report('compiling and linking Swift modules')
+            const frameworkInterfaces = new Map<
+              string,
+              { file: string; header: string } | null
+            >()
+            const frameworkInterface = (
+              name: string,
+            ): { file: string; header: string } | null => {
+              if (frameworkInterfaces.has(name)) return frameworkInterfaces.get(name)!
+              const source = distribution
+                ? path.join(frameworkRoot, 'modules', `${name}-Swift.h`)
+                : path.join(
+                    prebuilt!.modules,
+                    '..',
+                    `${name}.build/include/${name}-Swift.h`,
+                  )
+              if (!existsSync(source)) {
+                frameworkInterfaces.set(name, null)
+                return null
+              }
+              const headers = path.join(
+                swiftSdkPaths(frameworkRoot, options.toolchainBin).darwin,
+                `System/Library/Frameworks/${name}.framework/Headers`,
+              )
+              const declared = new Set<string>()
+              if (existsSync(headers))
+                for (const file of readdirSync(headers, {
+                  recursive: true,
+                  encoding: 'utf8',
+                }))
+                  if (file.endsWith('.h'))
+                    for (const name of swiftInterfaceDeclarations(
+                      readFileSync(path.join(headers, file), 'utf8'),
+                    ))
+                      declared.add(name)
+              const header = withoutSwiftDeclarations(
+                clangInterfaceHeader(readFileSync(source, 'utf8')),
+                declared,
+                `#import <${name}/${name}.h>`,
+              )
+              const value = {
+                file: path.join(root, '.build/peach-framework-objc', `${name}-Swift.h`),
+                header,
+              }
+              frameworkInterfaces.set(name, value)
+              writeBuildFile(
+                value.file,
+                (existsSync(path.join(headers, `${name}.h`))
+                  ? `#import <${name}/${name}.h>\n`
+                  : '') + swiftHeaderWithSuperclassImports(header, frameworkInterface),
+              )
+              return value
+            }
             try {
               // clang consumes the real emitted headers after swift finishes.
               // swiftpm's transitive swift module maps are not C declarations:
@@ -7387,7 +7547,10 @@ function compileSwiftProjectOnce(
                     writeBuildFile(
                       emitted,
                       withoutSwiftDeclarations(
-                        clangInterfaceHeader(readFileSync(original, 'utf8')),
+                        swiftHeaderWithSuperclassImports(
+                          clangInterfaceHeader(readFileSync(original, 'utf8')),
+                          frameworkInterface,
+                        ),
                         new Set(preparation.nativeHeaderDeclarations[producer]),
                         `#import <${producer}/${producer}.h>`,
                       ),
@@ -7522,16 +7685,15 @@ function compileSwiftProjectOnce(
                 output,
                 optimized,
               })
-            else if (input.optimize) await optimizeWasm(output, optimized)
-            const executable = input.optimize ? optimized : output
+            else await lowerWasm(output, optimized, { optimize: input.optimize === true })
             await runCompiler(
               path.join(options.toolchainBin, 'llvm-objcopy'),
-              ['--remove-section=.swift1_autolink_entries', executable],
+              ['--remove-section=.swift1_autolink_entries', optimized],
               buildOptions,
             )
             const artifact = {
               hash,
-              bytes: readFileSync(executable),
+              bytes: readFileSync(optimized),
               icu: await icu,
             }
             if (artifact.bytes.length <= 8)

package/src/swift-compiler-digest.ts

@@ -21,6 +21,8 @@ export const SWIFT_DIGEST_SOURCES = [
   'process-table.ts',
   'swift-link-roots.ts',
   'swift-wasm-prune.ts',
+  'wasm-optimize.ts',
+  'wasm-narrow-boundary.ts',
   'swift-guest-image-ledger.ts',
   'swift-guest-archive.ts',
   'swift-guest-link-plan.ts',

package/src/swift-cxx-standin.ts

@@ -120,7 +120,7 @@ export async function emitCxxStandin(input: CxxInputs): Promise<{
   )
   const flags = [
     '-target',
-    'wasm32-unknown-wasip1',
+    'wasm64-unknown-wasip1',
     '--sysroot',
     input.sysroot,
     ...WASI_EMULATION_FLAGS,

package/src/swift-darwin-records.ts

@@ -1,6 +1,6 @@
 // the darwin record providers (packages/sootsim-swift/Sources/DarwinRecords)
-// compiled for wasm32. they answer darwin's calls over the installed libc, so
-// they compile in its view, with the records' shared sdk tree. the wasm sdk
+// compiled for wasm64. they answer darwin's calls over the installed libc,
+// sysctl uses the client records; libc adapters retain the installed view. the sdk
 // ships them as libDarwinRecords.a for its own clients; a distribution and a
 // source checkout compile them from the same source as their Darwin module and
 // link them ahead of that archive (specs/peach/swift/darwin-libc-providers.md).
@@ -51,7 +51,7 @@ export function compileDarwinRecords(args: {
       execFileSync(
         path.join(args.bin, 'clang'),
         [
-          '--target=wasm32-unknown-wasip1',
+          '--target=wasm64-unknown-wasip1',
           `--sysroot=${args.sysroot}`,
           '-Oz',
           '-g0',
@@ -64,7 +64,7 @@ export function compileDarwinRecords(args: {
           `-ffile-prefix-map=${records}${path.sep}=DarwinRecords/`,
           // apple's headers select on the ios identity original units compile
           // with, and TargetConditionals.h refuses a compiler without it
-          ...(file.endsWith('.m')
+          ...(file === 'sysctl.c' || file.endsWith('.m')
             ? objcSdkIntakeFlags(args.darwin, args.bin, args.minimum)
             : [
                 ...swiftObjCPlatformFlags(args.bin, args.minimum),

package/src/swift-distribution-contract.ts

@@ -26,7 +26,7 @@ export function swiftDistributionHost(
   return SWIFT_DISTRIBUTION_HOSTS.find((candidate) => candidate === host) ?? null
 }
 
-/** the host-independent half: wasm32 modules and their objects. */
+/** the host-independent half: wasm64 modules and their objects. */
 export interface SwiftDistributionWasm extends SwiftWasmSdk {
   /** the digest of the module sources it was built from (swiftModuleDigest). */
   id: string
@@ -34,7 +34,7 @@ export interface SwiftDistributionWasm extends SwiftWasmSdk {
   release: string
   /** the importable Swift modules under modules/. */
   modules: string[]
-  /** the modules' wasm32 objects, relative to the root, in link order. */
+  /** the modules' wasm64 objects, relative to the root, in link order. */
   objects: string[]
   /** linker flags the objects autolink. */
   link: string[]

package/src/swift-distribution.lock.json

@@ -1,10 +1,10 @@
 {
-  "id": "e7ae8fdb51086f73",
-  "release": "swift-6.4.0-RELEASE-custom-11345d60dca47496",
-  "wasmSdkId": "swift-6.4.0-RELEASE_wasm-peach-19471d4b",
-  "wasmSdkUrl": "https://r2.sootsim.com/swift-wasm-sdk/swift-6.4.0-RELEASE_wasm-peach-19471d4b.artifactbundle.tar.gz",
-  "wasmSdkChecksum": "764c16e7e34156bf90d6c3372a2b77b98b9d8c3470235520d0f9619f90f33456",
-  "source": "dbcdd2998c7a523cb5136f3731f6850cfe0bd154",
+  "id": "c7825880e72c77d4",
+  "release": "swift-6.4.0-RELEASE-custom-fb42d2535739dfd2",
+  "wasmSdkId": "swift-6.4.0-RELEASE_wasm-peach-b577231e",
+  "wasmSdkUrl": "https://r2.sootsim.com/swift-wasm-sdk/swift-6.4.0-RELEASE_wasm-peach-b577231e.artifactbundle.tar.gz",
+  "wasmSdkChecksum": "9a8f0c694ada318ede49413cd72395e34a7fbb1b9a227b31eff8b05371ffb9aa",
+  "source": "071342e8371d62d839b1acf0b4462235ed263eae",
   "targets": [
     "ImagePlayground",
     "QuickLookThumbnailing",
@@ -216,6 +216,7 @@
     "deviceModel": ["string"],
     "systemName": ["string"],
     "systemVersion": ["string"],
+    "gameCenterPlayerIDs": ["array"],
     "screenMetrics": ["array"],
     "reservedRegions": ["array"],
     "colorScheme": ["string:light", "string:dark"],
@@ -244,16 +245,16 @@
   },
   "hosts": {
     "darwin-arm64": {
-      "sha256": "8680805789e5212d83e374bea9e4af3e3c7a86011e8ebf4921e76a8eba092761",
-      "size": 103496854
+      "sha256": "f932303a90b0119e4500f2569ed6b6c519430d7fddad998d8555d92493d0f30a",
+      "size": 104821966
     },
     "linux-x64": {
-      "sha256": "9d82820dfdbc857d5127c489b9c704c9e9336fe8b010256cd5b1d24ba956f454",
-      "size": 106214710
+      "sha256": "aed1395ab7cc4c464b2e32fa21096b85f343a9001cdb72e714444f54a5b6f91a",
+      "size": 107541215
     },
     "linux-arm64": {
-      "sha256": "a8e5084e14867ca9245428e51cb9435bc5b34505914fa5855950951d01b6b990",
-      "size": 105708986
+      "sha256": "c45ecac4feab55969b26bbf910258f49c1301552e9c523dd76a14dc7b221266e",
+      "size": 107034390
     }
   }
 }

package/src/swift-guest-compile.ts

@@ -32,7 +32,7 @@ import {
   planGuestSourceLink,
 } from './swift-guest-source-plan'
 import { frameworkRuntimeProductId } from './swift-runtime-products'
-import { optimizeWasm } from './wasm-optimize'
+import { lowerWasm } from './wasm-optimize'
 import type { SwiftSourceLinkGraph } from './swiftContract'
 import type { SwiftGuestImageManifest } from './swiftGuestImageContract'
 
@@ -84,7 +84,7 @@ export async function compileGuestLink(options: {
   }
   const buildVersion = imageBuildVersion(entry.buildVersion)
   const clangOptions = [
-    '--target=wasm32-unknown-wasip1',
+    '--target=wasm64-unknown-wasip1',
     `--sysroot=${options.sysroot}`,
     `-I${path.join(options.moduleRoot, 'include')}`,
   ]
@@ -437,9 +437,10 @@ export async function compileGuestLink(options: {
     },
   })
   if (!reserved || !projectionObject) throw new Error('guest projection was not reserved')
-  await optimizeWasm(options.output, options.optimized, [
-    'duplicate-function-elimination',
-  ])
+  await lowerWasm(options.output, options.optimized, {
+    optimize: true,
+    skipPasses: ['duplicate-function-elimination'],
+  })
   const map = readFileSync(result.mapPath, 'utf8')
   // no linked code reads the image records, so the link dropped them and
   // there is nothing to fill.

package/src/swift-guest-image-ledger.ts

@@ -59,7 +59,7 @@ function readNumber(bytes: Uint8Array, position: number): [number, number] {
   let value = 0
   let shift = 0
   for (;;) {
-    if (position >= bytes.length || shift > 28) throw new Error('invalid wasm integer')
+    if (position >= bytes.length || shift > 63) throw new Error('invalid wasm integer')
     const byte = bytes[position++]!
     value += (byte & 127) * 2 ** shift
     if (!(byte & 128)) return [value, position]
@@ -195,12 +195,12 @@ function rewriteObject(
           if (referenceType !== 0x70 && referenceType !== 0x6f)
             throw new Error('unsupported table type')
           const flags = number()
-          if (flags & ~3) throw new Error('unsupported table limits')
+          if (flags & ~7) throw new Error('unsupported table limits')
           number()
           if (flags & 1) number()
         } else if (kind === 2) {
           const flags = number()
-          if (flags & ~3) throw new Error('unsupported memory limits')
+          if (flags & ~7) throw new Error('unsupported memory limits')
           number()
           if (flags & 1) number()
         } else if (kind === 3) offset += 2
@@ -215,7 +215,7 @@ function rewriteObject(
         if (module === 'env' && names.has(name)) usedSymbols.add(name)
         if (isDlsym || isDlerror) {
           const type = types[functionType]
-          const expected = isDlsym ? '127,127:127' : ':127'
+          const expected = isDlsym ? '126,126:126' : ':126'
           if (
             !type ||
             `${type.parameters.join(',')}:${type.results.join(',')}` !== expected
@@ -598,7 +598,7 @@ export function createGuestImageLedger(input: GuestImageLedgerInput): GuestImage
     })
     .join('')
   const ir = [
-    'target triple = "wasm32-unknown-wasip1"',
+    'target triple = "wasm64-unknown-wasip1"',
     `@.names = private constant [${nameSize} x i8] c"${nameContents}"`,
   ]
   for (const definition of exported.values()) {