peachsim 0.1.2224 → 0.1.2225

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()]]]),
+  )
+}

package/src/wasm-optimize.ts

@@ -1,15 +1,25 @@
-import { existsSync } from 'node:fs'
-import { join } from 'node:path'
+import { execFile } from 'node:child_process'
+import { existsSync, readFileSync, rmSync, writeFileSync } from 'node:fs'
+import { dirname, join } from 'node:path'
+import { promisify } from 'node:util'
 import { installVerifiedTarball } from '@contrast/runtime-delivery'
 import { BINARYEN_VERSION, wasmOpt } from 'wasm-opt'
 import { windowAdmission } from './admitted-mac-build'
 import { rnxHomeDir } from './home-paths'
+import {
+  dropBoundaryExports,
+  NARROW_MERGE_NAMES,
+  narrowWasmBoundary,
+} from './wasm-narrow-boundary'
 
-// packaged native executables, size-optimized. clang's own
-// optimizer pass is off (-O0 on the link) so an edit never pays for it and the
-// artifact never depends on the machine; this runs the pinned Binaryen once per
-// cached artifact instead. the features are the ones the link declares.
+// the linked wasm64 executable, made loadable: its host boundary narrowed to
+// 32 bits and its memory and table lowered to 32-bit addresses, so pointers stay
+// 8 bytes in memory while every browser runs the module. clang's own optimizer
+// pass is off (-O0 on the link) so the artifact never depends on the machine;
+// the pinned Binaryen size-optimizes once per cached artifact instead. the
+// features are the ones the link declares.
 const FEATURES = [
+  'memory64',
   'threads',
   'bulk-memory',
   'bulk-memory-opt',
@@ -25,8 +35,10 @@ const FEATURES = [
 // PEACH_SWIFT_NAMES=1 keeps the name section so a trap stack names its functions.
 export const KEEP_WASM_NAMES = process.env.PEACH_SWIFT_NAMES === '1'
 
+const LOWERING = ['--memory64-lowering', '--table64-lowering']
+
 /** feeds the artifact hash: a new optimizer or flag set is a new artifact. */
-export const WASM_OPTIMIZE_IDENTITY = `wasm-opt ${BINARYEN_VERSION} -Oz ${FEATURES.join(',')}${KEEP_WASM_NAMES ? ' -g' : ''}`
+export const WASM_LOWER_IDENTITY = `binaryen ${BINARYEN_VERSION} narrow ${LOWERING.join(' ')} ${FEATURES.join(',')} unoptimized-names`
 
 // the sha256 of each Binaryen release archive wasm-opt resolves for its own platform
 // keys; update both when the wasm-opt package moves BINARYEN_VERSION.
@@ -61,6 +73,7 @@ const BINARYEN_RELEASES = new Map([
 async function runWasmOpt(
   file: string,
   output: string,
+  optimize: boolean,
   skipPasses: readonly string[],
   binary: string,
 ): Promise<void> {
@@ -73,18 +86,44 @@ async function runWasmOpt(
         ? Math.min(admittedCores, requestedCores)
         : admittedCores,
     )
+  const features = FEATURES.map((feature) => `--enable-${feature}`)
+  // an unoptimized link keeps its name section, as before lowering, so a trap names its function
+  const names = optimize && !KEEP_WASM_NAMES ? [] : ['-g']
+  const narrowed = narrowWasmBoundary(readFileSync(file))
+  const merged = `${output}.narrowed`
+  if (narrowed) {
+    const guest = `${output}.guest`
+    const thunks = `${output}.thunks.wat`
+    writeFileSync(guest, narrowed.module)
+    writeFileSync(thunks, narrowed.thunks)
+    await promisify(execFile)(join(dirname(binary), 'wasm-merge'), [
+      ...features,
+      ...names,
+      guest,
+      NARROW_MERGE_NAMES.guest,
+      thunks,
+      NARROW_MERGE_NAMES.boundary,
+      '-o',
+      merged,
+    ])
+    writeFileSync(merged, dropBoundaryExports(readFileSync(merged)))
+    rmSync(guest)
+    rmSync(thunks)
+  }
   const result = await wasmOpt(
     [
-      '-Oz',
-      ...(KEEP_WASM_NAMES ? ['-g'] : []),
+      ...LOWERING,
+      ...(optimize ? ['-Oz'] : []),
+      ...names,
       ...skipPasses.flatMap((pass) => ['--skip-pass', pass]),
-      ...FEATURES.map((feature) => `--enable-${feature}`),
-      file,
+      ...features,
+      narrowed ? merged : file,
       '-o',
       output,
     ],
     { env: environment },
   )
+  if (narrowed) rmSync(merged)
   if (result.status !== 0)
     throw new Error(`wasm-opt exited ${result.status}: ${result.stderr}`)
 }
@@ -110,10 +149,16 @@ async function installWasmOpt(): Promise<string> {
   return binary
 }
 
-export async function optimizeWasm(
+export async function lowerWasm(
   file: string,
   output: string,
-  skipPasses: readonly string[] = [],
+  options: { optimize: boolean; skipPasses?: readonly string[] },
 ): Promise<void> {
-  await runWasmOpt(file, output, skipPasses, await installWasmOpt())
+  await runWasmOpt(
+    file,
+    output,
+    options.optimize,
+    options.skipPasses ?? [],
+    await installWasmOpt(),
+  )
 }