peachsim 0.1.2224 → 0.1.2228

package/src/swift-toolchain.ts

@@ -50,6 +50,42 @@ export interface SwiftHostCompilerPin {
 // advance. an installed CLI adds the compiler its runtime pins
 // (registerSwiftHostCompiler).
 const compilerArchives: Record<string, SwiftHostCompilerPin> = {
+  'swift-6.4.0-RELEASE-custom-fb42d2535739dfd2': {
+    identity: 'fb42d2535739dfd2',
+    archive: 'tar.zst',
+    hosts: {
+      'darwin-arm64': {
+        checksum: '5e417d415ca74a435755e298a1d2d19ec47637fd03479de7a7d958eb382941f1',
+        manifest: 'eb5a0356aebabe89c7b2780f8809e13d6e2ad6f342fed87cf99f9a5834344363',
+      },
+      'linux-arm64': {
+        checksum: '8ac7ad97f3d68bf485423001d1ce3cd92a8d4625313c47c8071867a9aeed3af9',
+        manifest: '6126266dd65b43c43d719e4dc4d33c4ea6a3267f99f34e3638637439a995af2e',
+      },
+      'linux-x64': {
+        checksum: '7d76463079619ba822123d250601bd35f6744ed5f8054a657ce472ce4dac76c8',
+        manifest: 'f1a6c0c61d15eddb2ecfa4c3a72a5154621881ac2f0c413162ff1d0f4343bd0e',
+      },
+    },
+  },
+  'swift-6.4.0-RELEASE-custom-44ecd25f163bb359': {
+    identity: '44ecd25f163bb359',
+    archive: 'tar.zst',
+    hosts: {
+      'darwin-arm64': {
+        checksum: 'd06dda4435f99d8376179cc7a3804907aa7305513135ece6288fd8e6d4695ae6',
+        manifest: 'bc0d8b955f923f096dda2aa8bbb1d56176a73f3d4a4df4cc9a1f59d31417061a',
+      },
+      'linux-x64': {
+        checksum: 'f95b56440693c5de7995f10ea14c57fc7e659a161018a17f17a74b61a98e88a4',
+        manifest: 'c18a60b14d5c89a8b2e1dbb2b4b52342c5fb92c7f3069fdc55c985bce61683a7',
+      },
+      'linux-arm64': {
+        checksum: 'afb74ae60df2b5bd7792bfbcf29bcea03675a5c814b758dd6cb91a760c220cd2',
+        manifest: 'ac037f6b0fdc4a6ae582eebc22bcf811fa2becdc30d083057137fc857f3c456a',
+      },
+    },
+  },
   'swift-6.4.0-RELEASE-custom-11345d60dca47496': {
     identity: '11345d60dca47496',
     archive: 'tar.zst',
@@ -827,7 +863,7 @@ function validateSwiftSdkIdentity(sdk: SwiftWasmSdk): void {
 function swiftSdkBundle(swift: string, id: string, options: string[]): string {
   const configuration = execFileSync(
     swift,
-    ['sdk', 'configure', ...options, '--show-configuration', id, 'wasm32-unknown-wasip1'],
+    ['sdk', 'configure', ...options, '--show-configuration', id, 'wasm64-unknown-wasip1'],
     { encoding: 'utf8', env: swiftEnvironment(), stdio: ['ignore', 'pipe', 'pipe'] },
   )
   const sysroot = /^sdkRootPath: (.+)$/m.exec(configuration)?.[1]?.trim()

package/src/swift-uniform-type-constants.ts

@@ -17,7 +17,7 @@ export function compileUniformTypeConstants(args: {
   execFileSync(
     path.join(args.bin, 'clang'),
     [
-      '--target=wasm32-unknown-wasip1',
+      '--target=wasm64-unknown-wasip1',
       `--sysroot=${args.sysroot}`,
       '-Oz',
       '-g0',

package/src/swift-wasm-prune.ts

@@ -67,7 +67,10 @@ function encodeULEB(val: number): number[] {
   return out
 }
 
-const HAS_ADDEND = new Set([3, 4, 5, 8, 9, 11, 13, 14, 15, 16, 21, 22, 23, 24, 25])
+// llvm's relocTypeHasAddend: memory addresses, function and section offsets.
+const HAS_ADDEND = new Set([3, 4, 5, 8, 9, 11, 14, 15, 16, 17, 21, 22, 23, 25])
+// the 64-bit address, table index and function offset relocations patch eight bytes.
+const WIDE_DATA_RELOCS = new Set([16, 19, 22])
 
 const ROOT_SEG_PREFIXES = [
   '.init_array',
@@ -1254,7 +1257,7 @@ export function pruneSwiftWasmLink(
     } else if (
       !inStartLib &&
       t.endsWith('.a') &&
-      !t.endsWith('libclang_rt.builtins-wasm32.a') &&
+      !t.endsWith('libclang_rt.builtins-wasm64.a') &&
       fs.existsSync(t)
     ) {
       const members = readArMembers(new Uint8Array(fs.readFileSync(t)))
@@ -1841,7 +1844,12 @@ export function pruneSwiftWasmLink(
     }
 
     const keptDataRelocBytes: Uint8Array[] = []
-    const zeroDataRelocOffsets: number[] = []
+    const zeroDataRelocs: { ro: number; width: number }[] = []
+    const zeroDataReloc = (r: { ro: number; rawBytes: Uint8Array }) =>
+      zeroDataRelocs.push({
+        ro: r.ro,
+        width: WIDE_DATA_RELOCS.has(r.rawBytes[0]!) ? 8 : 4,
+      })
     const usedSyms = new Set<number>()
     // a type index relocation carries a type index, not a symbol index
     for (const r of keptCodeRelocs) if (r.rawBytes[0] !== 6) usedSyms.add(r.rs)
@@ -1854,7 +1862,7 @@ export function pruneSwiftWasmLink(
           keptDataRelocBytes.push(r.rawBytes)
           usedSyms.add(r.rs)
         } else if (sName === '__objc_classes') {
-          zeroDataRelocOffsets.push(r.ro)
+          zeroDataReloc(r)
         } else {
           const repl = firstLiveInSpecialSeg.get(r.segIdx)!
           const roBytes = encodeULEB(r.ro)
@@ -1867,13 +1875,13 @@ export function pruneSwiftWasmLink(
       } else if (r.ownerSymIdx !== -1) {
         if (dLive.has(r.ownerSymIdx)) {
           if (obj.isDist && dropsReflection(obj, obj.symNames[r.rs])) {
-            zeroDataRelocOffsets.push(r.ro)
+            zeroDataReloc(r)
           } else {
             keptDataRelocBytes.push(r.rawBytes)
             usedSyms.add(r.rs)
           }
         } else if (sName === '__objc_class_refs') {
-          zeroDataRelocOffsets.push(r.ro)
+          zeroDataReloc(r)
         }
       } else if (sLive[r.segIdx] === 1) {
         if (
@@ -1881,7 +1889,7 @@ export function pruneSwiftWasmLink(
           obj.symNames[r.rs]?.startsWith('l__swift5_reflection_descriptor') &&
           dropsReflection(obj, obj.symNames[r.rs])
         ) {
-          zeroDataRelocOffsets.push(r.ro)
+          zeroDataReloc(r)
         } else {
           keptDataRelocBytes.push(r.rawBytes)
           usedSyms.add(r.rs)
@@ -2096,11 +2104,8 @@ export function pruneSwiftWasmLink(
           outChunks.push(buf.subarray(secStart, end))
         }
       } else {
-        if (id === 11 && zeroDataRelocOffsets.length > 0) {
-          for (const ro of zeroDataRelocOffsets) {
-            buf.fill(0, p + ro, p + ro + 4)
-          }
-        }
+        if (id === 11)
+          for (const { ro, width } of zeroDataRelocs) buf.fill(0, p + ro, p + ro + width)
         outChunks.push(buf.subarray(secStart, end))
       }
       pos = end

package/src/swiftGuestImageContract.ts

@@ -24,8 +24,8 @@ export interface SwiftGuestImageManifest {
   installName: string
   fileType: 'executable' | 'dylib'
   target: {
-    triple: 'wasm32-unknown-wasip1'
-    pointerWidth: 32
+    triple: 'wasm64-unknown-wasip1'
+    pointerWidth: 64
     byteOrder: 'little'
     cpuType: -1
     cpuSubtype: 0
@@ -66,8 +66,8 @@ export function isSwiftGuestImageManifest(
     !text(value.installName) ||
     (value.fileType !== 'executable' && value.fileType !== 'dylib') ||
     !isRecord(value.target) ||
-    value.target.triple !== 'wasm32-unknown-wasip1' ||
-    value.target.pointerWidth !== 32 ||
+    value.target.triple !== 'wasm64-unknown-wasip1' ||
+    value.target.pointerWidth !== 64 ||
     value.target.byteOrder !== 'little' ||
     value.target.cpuType !== -1 ||
     value.target.cpuSubtype !== 0 ||

package/src/swiftNativePinContract.ts

@@ -16,7 +16,7 @@ import {
 import type { SwiftHostCompilerPin } from './swift-toolchain'
 
 export const SWIFT_NATIVE_PIN_PATH = 'node/swift-native.json'
-export const SWIFT_NATIVE_PIN_SCHEMA = 2
+export const SWIFT_NATIVE_PIN_SCHEMA = 3
 
 export interface SwiftNativePin {
   schema: typeof SWIFT_NATIVE_PIN_SCHEMA

package/src/swiftRuntimeProductContract.ts

@@ -46,7 +46,7 @@ export const swiftSdkProductSchema = v.pipe(
   v.object({
     id: v.string(),
     installName: v.string(),
-    target: v.literal('wasm32-unknown-wasip1'),
+    target: v.literal('wasm64-unknown-wasip1'),
     linkNames: v.array(v.string()),
     // absent records declare no framework namespace, even when a library name matches.
     frameworkAliases: v.optional(

package/src/turbo-runtime.lock.json

@@ -1,90 +1,90 @@
 {
   "schema": 2,
   "platform": "ios",
-  "target": "wasm32-unknown-wasip1",
-  "recipe": "704fe0a2e79278bce00a7af1b1dc1846943873c3f54942a174833a515d222b79",
+  "target": "wasm64-unknown-wasip1",
+  "recipe": "34baf639742120cf206d06dd95e4da3444d9f9f377b8db6eafe78417840d79d7",
   "adapter": {
-    "sha256": "0d31912293226deb3354b3b32f2944e9c61c68590e3020d8b5af0c12a6677893"
+    "sha256": "2ba7674c823a6adf902af9ccdd489cfe47d68e9788a7214fe8b83c784fc3fa98"
   },
-  "compiler": "swift-6.4.0-RELEASE-custom-11345d60dca47496",
+  "compiler": "swift-6.4.0-RELEASE-custom-fb42d2535739dfd2",
   "sdk": {
-    "id": "swift-6.4.0-RELEASE_wasm-peach-19471d4b",
-    "checksum": "764c16e7e34156bf90d6c3372a2b77b98b9d8c3470235520d0f9619f90f33456"
+    "id": "swift-6.4.0-RELEASE_wasm-peach-b577231e",
+    "checksum": "9a8f0c694ada318ede49413cd72395e34a7fbb1b9a227b31eff8b05371ffb9aa"
   },
   "framework": {
-    "distribution": "e7ae8fdb51086f73",
-    "wireAbi": "246b8412514b644113e6a26252c8ebd6de49ab4156ac5f5c98bb9e4c2ff2568b"
+    "distribution": "c7825880e72c77d4",
+    "wireAbi": "38eed69f6b7391584112981b7892914e7033d7e0c17c2e8d4a4448030618bd2b"
   },
   "archives": [
     {
       "headers": {
         "reactNativeJsi": "0f8c2defbca69a27a848a81ae72363073bf9602fd316e57a75811be1a0528358"
       },
-      "sha256": "e48499ac95604409b5da4b0f113e8ec3d3e7de9bd170f2f401513c4a45c234dc",
-      "size": 25392
+      "sha256": "675b1c6d919198a3329fa48d9ad74c05c093201fc4abe246436f7f8e1d47887f",
+      "size": 26175
     },
     {
       "headers": {
         "reactNativeJsi": "21a624ea24fd17d56bf26832d496fc1177067f89640414c20e6486c7984dfb0a"
       },
-      "sha256": "bf331e9b3d141240d9fda77dc67e1d4b584513bdc455b0c37ae6aeb1a89038ed",
-      "size": 26137
+      "sha256": "fb2a2b16ef4963022676c04a8acc23a10a3c7de9b1fb2760743a299eb5fb6cda",
+      "size": 26914
     },
     {
       "headers": {
         "reactNativeJsi": "324aefd8591d9ce688bce7589c4c2b516cd33ecb95d35c47239a87a8fcf6a8da"
       },
-      "sha256": "181c4fef940e164d52f0e8a6284990cfa23a19c42afb445f6945cd959f708bf9",
-      "size": 25392
+      "sha256": "3b5f5db71ed80b6c5563332e81edd9d9a7d626740471892e3a3aecf34946df8d",
+      "size": 26167
     },
     {
       "headers": {
         "reactNativeJsi": "33596664ee7d7a6623f0796a6feb429543316c3a41b211150acda6e1d835286c"
       },
-      "sha256": "44ac75e98b6badd32e32556bfd04beab8728bbce58cf32f31528a7e17b6b3665",
-      "size": 25166
+      "sha256": "7577e8dc552780eed3ee136fb7a77e19345199c4d87420b21a444adf647bf2ec",
+      "size": 25957
     },
     {
       "headers": {
         "reactNativeJsi": "66b2cd5a38511195207f6c8a76aba735f9b9cc66a52a0d00780ffe5d331623f7"
       },
-      "sha256": "dab069c53f92c911f1f84c7c037077c6e73df2fbd1673cb9dbbff0c6014fb9ac",
-      "size": 25398
+      "sha256": "1ccfb1335ba66d6f53d27a5a1ee9c223b7d05a9c0abb6eb7dccdc6124245e470",
+      "size": 26172
     },
     {
       "headers": {
         "reactNativeJsi": "96db4e758dd53e9320cef7cad485e00aa06e7a982cefd920f17007de8a5bd9f9"
       },
-      "sha256": "6612544a0287c8cc231436ad31e9a45f4d824fbbc5e7da7460ac11728568c353",
-      "size": 26139
+      "sha256": "15e27e276e9add8769400c323ea880867ebbefd3efb823b203b2eaae0be23fa4",
+      "size": 26913
     },
     {
       "headers": {
         "reactNativeJsi": "aeab590ddd1218df963462242d3954ce467b0fa88f70e91429e4ffc74d230893"
       },
-      "sha256": "c73fb45ff0e2037bf21c6a0e019e80c645ff141e80052b750c7d14570a4f7e72",
-      "size": 26138
+      "sha256": "f0243c32cdbe887ce7672e2abf3338dccbd76c43dfeb8686b7269f0d3272fb88",
+      "size": 26914
     },
     {
       "headers": {
         "reactNativeJsi": "b5fb260522384dd7ab07d740cdc534b529922446fcec798341c7817d9eaa49f4"
       },
-      "sha256": "997372e6c03141640cfc3aab115b8afe9b04f6f6e806721f14f4fc0dc871d271",
-      "size": 25267
+      "sha256": "b107936623043c5cbf4353acbbfadb6426750138304befd9e0fa768d6e256e49",
+      "size": 26046
     },
     {
       "headers": {
         "reactNativeJsi": "c6b391a1e870ccf7cdd534be63582862840f8245b99ebd253317deece1e6ffd5"
       },
-      "sha256": "60f8e1e7da90a20ee5b112b950e264f93329014bfabdcbcd5aa1281945f2725b",
-      "size": 26143
+      "sha256": "3c56322e46544e260cbbc6f90720cb2bdfd5373e744801e55b778113d99e8799",
+      "size": 26912
     },
     {
       "headers": {
         "reactNativeJsi": "c8270f1315745ecc204c4209a4f50f58ff6f14b4a385ad6820a69800270b53c6"
       },
-      "sha256": "47269b8662bf147cbf9ccc011de79f0faffc30aa6b09344ad4f95dbdfae656c9",
-      "size": 25105
+      "sha256": "e96bfa3c28e45bd3d4d64a059449d1960e7136a966d746662834ff3aa2d1ce6b",
+      "size": 25921
     }
   ]
 }

package/src/wasm-narrow-boundary.ts

@@ -0,0 +1,296 @@
+// narrows the host boundary of a linked wasm64 module to 32 bits, so host
+// javascript keeps Number pointers once the memory is lowered. scalar i64 host
+// imports retain their existing BigInt ABI; wasi pointers are already 32-bit
+// in libc. the module's wide imports and exports get private
+// names here, and wasm-merge fuses them with the thunk module that converts.
+
+const I64 = 0x7e
+const VALUE_TYPES = new Map([
+  [0x7f, 'i32'],
+  [I64, 'i64'],
+  [0x7d, 'f32'],
+  [0x7c, 'f64'],
+  [0x7b, 'v128'],
+  [0x70, 'funcref'],
+  [0x6f, 'externref'],
+])
+const GUEST = 'guest'
+const BOUNDARY = 'boundary'
+const WIDE = '$wide.'
+const NARROW = '$narrow.'
+
+type FunctionType = { parameters: number[]; results: number[] }
+
+function encodeNumber(value: number): number[] {
+  const bytes: number[] = []
+  for (let rest = value; ; ) {
+    const byte = rest % 128
+    rest = Math.floor(rest / 128)
+    if (rest === 0) return [...bytes, byte]
+    bytes.push(byte | 128)
+  }
+}
+
+function encodeName(name: string): number[] {
+  const bytes = [...Buffer.from(name)]
+  return [...encodeNumber(bytes.length), ...bytes]
+}
+
+function reader(bytes: Uint8Array, start: number, end: number) {
+  let at = start
+  const number = () => {
+    let value = 0
+    for (let shift = 0; ; shift += 7) {
+      if (at >= end || shift > 63) throw new Error('invalid wasm integer')
+      const byte = bytes[at++]!
+      value += (byte & 127) * 2 ** shift
+      if (!(byte & 128)) return value
+    }
+  }
+  return {
+    number,
+    byte: () => {
+      if (at >= end) throw new Error('truncated wasm section')
+      return bytes[at++]!
+    },
+    name: () => {
+      const length = number()
+      at += length
+      if (at > end) throw new Error('truncated wasm name')
+      return Buffer.from(bytes.subarray(at - length, at)).toString()
+    },
+    position: () => at,
+    done: () => at === end,
+  }
+}
+
+function sections(bytes: Uint8Array): { id: number; start: number; end: number }[] {
+  if (Buffer.from(bytes.subarray(0, 8)).toString('hex') !== '0061736d01000000')
+    throw new Error('not a wasm module')
+  const found: { id: number; start: number; end: number }[] = []
+  for (let at = 8; at < bytes.length; ) {
+    const header = reader(bytes, at, bytes.length)
+    const id = header.byte()
+    const size = header.number()
+    const start = header.position()
+    found.push({ id, start, end: start + size })
+    at = start + size
+  }
+  return found
+}
+
+// replaces whole sections and keeps every other byte.
+function withSections(
+  bytes: Uint8Array,
+  layout: readonly { id: number; start: number; end: number }[],
+  replacements: ReadonlyMap<number, number[]>,
+): Buffer {
+  const parts: Uint8Array[] = [bytes.subarray(0, 8)]
+  let at = 8
+  for (const section of layout) {
+    const body = replacements.get(section.id)
+    parts.push(
+      body
+        ? Uint8Array.from([section.id, ...encodeNumber(body.length), ...body])
+        : bytes.subarray(at, section.end),
+    )
+    at = section.end
+  }
+  return Buffer.concat(parts)
+}
+
+const quoted = (name: string) =>
+  `"${[...Buffer.from(name)].map((byte) => `\\${byte.toString(16).padStart(2, '0')}`).join('')}"`
+
+const signature = (types: readonly number[], keyword: string, narrow: boolean) =>
+  types.length === 0
+    ? ''
+    : ` (${keyword} ${types
+        .map((type) => {
+          const name = VALUE_TYPES.get(narrow && type === I64 ? 0x7f : type)
+          if (!name) throw new Error(`unsupported wasm boundary type ${type}`)
+          return name
+        })
+        .join(' ')})`
+
+const wide = (type: FunctionType) =>
+  type.parameters.includes(I64) || type.results.includes(I64)
+
+/**
+ * the module with its wide imports and exports renamed for the merge, and the
+ * thunk module's text; undefined when the boundary is already narrow.
+ */
+export function narrowWasmBoundary(
+  bytes: Uint8Array,
+): { module: Buffer; thunks: string } | undefined {
+  const layout = sections(bytes)
+  const section = (id: number) => {
+    const found = layout.find((entry) => entry.id === id)
+    return found && reader(bytes, found.start, found.end)
+  }
+
+  const types: FunctionType[] = []
+  const typeSection = section(1)
+  if (typeSection) {
+    for (let count = typeSection.number(); count > 0; count--) {
+      if (typeSection.byte() !== 0x60) throw new Error('unsupported wasm type')
+      const values = () =>
+        Array.from({ length: typeSection.number() }, () => typeSection.byte())
+      types.push({ parameters: values(), results: values() })
+    }
+  }
+  const typeAt = (index: number) => {
+    const type = types[index]
+    if (!type) throw new Error('invalid wasm type index')
+    return type
+  }
+
+  const thunks: string[] = []
+  const functionTypes: FunctionType[] = []
+  const importBody: number[] = []
+  const importSection = section(2)
+  if (importSection) {
+    const count = importSection.number()
+    importBody.push(...encodeNumber(count))
+    for (let index = 0; index < count; index++) {
+      const module = importSection.name()
+      const name = importSection.name()
+      const start = importSection.position()
+      const kind = importSection.byte()
+      const limits = () => {
+        const flags = importSection.number()
+        importSection.number()
+        if (flags & 1) importSection.number()
+      }
+      let type: FunctionType | undefined
+      if (kind === 0) {
+        type = typeAt(importSection.number())
+        functionTypes.push(type)
+      } else if (kind === 1) {
+        importSection.byte()
+        limits()
+      } else if (kind === 2) limits()
+      else if (kind === 3) {
+        importSection.byte()
+        importSection.byte()
+      } else if (kind === 4) {
+        importSection.byte()
+        importSection.number()
+      } else throw new Error('unsupported wasm import')
+      const scalar64 = (parameter: number | null) =>
+        (module === 'wasi_snapshot_preview1' &&
+          (!name.startsWith('peach_') ||
+            (name === 'peach_fs_path_birthtime_set' && parameter === 2))) ||
+        (module === 'peach' && name === 'hw_memsize' && parameter === null) ||
+        (module === 'peach_notify' && name === 'set' && parameter === 1)
+      const parameters = type?.parameters.map((value, index) =>
+        value === I64 && !scalar64(index) ? 0x7f : value,
+      )
+      const results = type?.results.map((value) =>
+        value === I64 && !scalar64(null) ? 0x7f : value,
+      )
+      if (
+        type &&
+        parameters &&
+        results &&
+        (parameters.some((value, index) => value !== type.parameters[index]) ||
+          results.some((value, index) => value !== type.results[index]))
+      ) {
+        if (type.results.length > 1)
+          throw new Error(`import ${module}.${name} returns several values`)
+        const id = thunks.length
+        const call = `(call $host${id}${type.parameters
+          .map((value, at) =>
+            value !== parameters[at]
+              ? ` (i32.wrap_i64 (local.get ${at}))`
+              : ` (local.get ${at})`,
+          )
+          .join('')})`
+        thunks.push(
+          `(import ${quoted(module)} ${quoted(name)} (func $host${id}${signature(parameters, 'param', false)}${signature(results, 'result', false)}))`,
+          `(func (export "${NARROW}${id}")${signature(type.parameters, 'param', false)}${signature(type.results, 'result', false)} ${type.results[0] !== results[0] ? `(i64.extend_i32_u ${call})` : call})`,
+        )
+        importBody.push(...encodeName(BOUNDARY), ...encodeName(`${NARROW}${id}`))
+      } else importBody.push(...encodeName(module), ...encodeName(name))
+      importBody.push(...bytes.subarray(start, importSection.position()))
+    }
+    if (!importSection.done()) throw new Error('invalid wasm imports')
+  }
+
+  const functionSection = section(3)
+  if (functionSection)
+    for (let count = functionSection.number(); count > 0; count--)
+      functionTypes.push(typeAt(functionSection.number()))
+
+  const exportBody: number[] = []
+  const exportSection = section(7)
+  if (exportSection) {
+    const count = exportSection.number()
+    exportBody.push(...encodeNumber(count))
+    for (let index = 0; index < count; index++) {
+      const name = exportSection.name()
+      const kind = exportSection.byte()
+      const target = exportSection.number()
+      const type = kind === 0 ? functionTypes[target] : undefined
+      if (kind === 0 && !type) throw new Error('invalid wasm export')
+      if (type && wide(type)) {
+        if (type.results.length > 1)
+          throw new Error(`export ${name} returns several values`)
+        const id = thunks.length
+        const call = `(call $guest${id}${type.parameters
+          .map((value, at) =>
+            value === I64
+              ? ` (i64.extend_i32_u (local.get ${at}))`
+              : ` (local.get ${at})`,
+          )
+          .join('')})`
+        thunks.push(
+          `(import "${GUEST}" "${WIDE}${id}" (func $guest${id}${signature(type.parameters, 'param', false)}${signature(type.results, 'result', false)}))`,
+          `(func (export ${quoted(name)})${signature(type.parameters, 'param', true)}${signature(type.results, 'result', true)} ${type.results[0] === I64 ? `(i32.wrap_i64 ${call})` : call})`,
+        )
+        exportBody.push(...encodeName(`${WIDE}${id}`))
+      } else exportBody.push(...encodeName(name))
+      exportBody.push(kind, ...encodeNumber(target))
+    }
+    if (!exportSection.done()) throw new Error('invalid wasm exports')
+  }
+
+  if (thunks.length === 0) return undefined
+  // imports precede definitions in the text format.
+  const imports = thunks.filter((line) => line.startsWith('(import'))
+  const functions = thunks.filter((line) => !line.startsWith('(import'))
+  return {
+    module: withSections(
+      bytes,
+      layout,
+      new Map([
+        [2, importBody],
+        [7, exportBody],
+      ]),
+    ),
+    thunks: `(module\n${[...imports, ...functions].join('\n')}\n)\n`,
+  }
+}
+
+export const NARROW_MERGE_NAMES = { guest: GUEST, boundary: BOUNDARY }
+
+/** drops the private names the merge left exported. */
+export function dropBoundaryExports(bytes: Uint8Array): Buffer {
+  const layout = sections(bytes)
+  const found = layout.find((entry) => entry.id === 7)
+  if (!found) throw new Error('merged module has no exports')
+  const exportSection = reader(bytes, found.start, found.end)
+  const kept: number[][] = []
+  for (let count = exportSection.number(); count > 0; count--) {
+    const name = exportSection.name()
+    const kind = exportSection.byte()
+    const target = exportSection.number()
+    if (!name.startsWith(WIDE) && !name.startsWith(NARROW))
+      kept.push([...encodeName(name), kind, ...encodeNumber(target)])
+  }
+  return withSections(
+    bytes,
+    layout,
+    new Map([[7, [...encodeNumber(kept.length), ...kept.flat()]]]),
+  )
+}