@bun-native/cli 0.0.0-stage → 0.33.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Bunly contributors
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -1,3 +1,5 @@
-# Temporary Holding Version
+# @bun-native/cli
 
-This version is a temporary placeholder for this package. An operational version to replace this has been submitted for review and is awaiting a staged release.
+Create, check, run and AOT-build Bun Native desktop applications.
+
+Part of [Bun Native](https://github.com/0xPlayerOne/bun-native), an experimental developer preview. Version 0.33.0 was built from [fa8bef754122](https://github.com/0xPlayerOne/bun-native/tree/fa8bef754122621d4235eb06e30bb1085b4f7b1e) and published from GitHub Actions with npm provenance. Use the Bun revision pinned in that commit's toolchain.json. Start with the [getting-started guide](https://github.com/0xPlayerOne/bun-native/blob/fa8bef754122621d4235eb06e30bb1085b4f7b1e/docs/getting-started.md); `bun-native host install` fetches the matching release host. The license notice is in LICENSE.

package/bun-native-source.json

@@ -0,0 +1,131 @@
+{
+  "schemaVersion": 1,
+  "commit": "fa8bef754122621d4235eb06e30bb1085b4f7b1e",
+  "tree": "f805e2eb19a4e10fc29d1dc827cf5bc617b5773b",
+  "files": {
+    "package.json": {
+      "bytes": 2164,
+      "sha256": "db50b6f81f25c113a46f8c9b038bc548a92effaeb4ad9562e5e95044baa7b66f"
+    },
+    ".oxfmtrc.json": {
+      "bytes": 402,
+      "sha256": "ead97e1ad225cb7b960d838c1a8130b98c88940634c366b45e622e0da586e8be"
+    },
+    ".oxlintrc.json": {
+      "bytes": 297,
+      "sha256": "25e27847d6fd50c27314506d50c83a68764489b84bf91f9c35dceb937134e882"
+    },
+    "experiments/aot-gpui/compile.ts": {
+      "bytes": 1661,
+      "sha256": "832cec3a32205995551dd270fdda0fd4bd26f0dfdf5b11d65457c73b88ec2b8f"
+    },
+    "experiments/aot-gpui/inspect-runtime.ts": {
+      "bytes": 12491,
+      "sha256": "071d377315ba801faad088a2dcf0140598536d38c7112139fd927a649a1ea285"
+    },
+    "experiments/aot-gpui/inspect.ts": {
+      "bytes": 2383,
+      "sha256": "f80f7ec7e8a070f6e9d8478380d193a0120f9b89dedd88422c7f7fd6b3490d48"
+    },
+    "scripts/native.ts": {
+      "bytes": 9688,
+      "sha256": "2290cf2b6508cc8a08c044ff363edc4a6b9b53b5a69169773d14807c3d4ed6c6"
+    },
+    "scripts/native/artifact.ts": {
+      "bytes": 1131,
+      "sha256": "e0496b30b935f02efb8297b41fd2e7ad310fc58d8a6056c3bd4b0d8c142044c1"
+    },
+    "scripts/native/build.ts": {
+      "bytes": 10234,
+      "sha256": "a72c2639c1a5dd4d31eb48cea48c0a010e71b0ea7794ba1eace2d5f35f7677d1"
+    },
+    "scripts/native/doctor.ts": {
+      "bytes": 2610,
+      "sha256": "ca2f57dacf6c929bb336324fc71228c03557b3c38ab9f5f8b77da86cb5048f7c"
+    },
+    "scripts/native/host-download.ts": {
+      "bytes": 6430,
+      "sha256": "d27ef6968d506ad8adc0b850a1283fe8c41487d9009dd690e75ad5ad379cdc44"
+    },
+    "scripts/native/host-header.ts": {
+      "bytes": 1248,
+      "sha256": "67e7cdeff0a9d16449c5ab1d5d6cdbbb5cc8881cf20591183f60a2f419ee5103"
+    },
+    "scripts/native/host.ts": {
+      "bytes": 990,
+      "sha256": "5e790bbf787bc22e37aecf031520942d96677717b201fd9889ddcb8eaa2715e1"
+    },
+    "scripts/native/inputs.ts": {
+      "bytes": 2839,
+      "sha256": "3e98bf1a0208104cc2c18235cfe84fbde719e5e6cf5fc8a4181c3fa69772ce94"
+    },
+    "scripts/native/lint.ts": {
+      "bytes": 1819,
+      "sha256": "eaedd87b266d54722c22a4a5b9ddc5606c96cedeb20d21ea9d2381ed5aaadd33"
+    },
+    "scripts/native/package-archive.ts": {
+      "bytes": 4945,
+      "sha256": "249cda6f7edf4eade989c324e473826899bcc0062cdf9cafde76b0d1c074247e"
+    },
+    "scripts/native/package-lock.ts": {
+      "bytes": 9244,
+      "sha256": "ad8f2b73ca5b88075b503a18c2f0405f13ec60a6c1d9a9d172056d707c0b5e10"
+    },
+    "scripts/native/package-set.ts": {
+      "bytes": 16263,
+      "sha256": "b7207b884b90303a0d44dc9a181617c03e24683850fc17a6db802fc740f0a26a"
+    },
+    "scripts/native/paths.ts": {
+      "bytes": 806,
+      "sha256": "6ccf669071878d65dbe4686e9b8585bbb217b4a9cd834f7c1866c9448c0c9a55"
+    },
+    "scripts/native/project.ts": {
+      "bytes": 11175,
+      "sha256": "c62044f4e0baa004bba1bd27a0ae3a53beb6aa02d558e356464c39fc471b0c61"
+    },
+    "scripts/native/quality.ts": {
+      "bytes": 2380,
+      "sha256": "5d2c68657e9a85db9e654b1be6ffc437bcd4fdc623854a98eda5f9da842e38cc"
+    },
+    "scripts/native/session.ts": {
+      "bytes": 9635,
+      "sha256": "def47965ad2d36d95e0f9a5b1f778443e5d811e8a82b9fb094e4ee79916eb26f"
+    },
+    "scripts/native/standalone.ts": {
+      "bytes": 6195,
+      "sha256": "c464f48f3c054dbbb057e621b1f4b55e2679b797bca3282561eed39cfe510f6f"
+    },
+    "scripts/native/watch.ts": {
+      "bytes": 3793,
+      "sha256": "b5d7f98516135ae1577823ccd6d4647f53d84df7a0f1fa68d4cad5a2c62cdd0f"
+    },
+    "scripts/solid-build.ts": {
+      "bytes": 1615,
+      "sha256": "5f263562cc299642e2971cce1dd913533ff092bc5543abd11d07048e8b3e5908"
+    },
+    "scripts/solid/transform.ts": {
+      "bytes": 642,
+      "sha256": "281fdbd71b10e613d9080e0494320161e51cfaf9a1c7b9966707eba0dd24ef1c"
+    },
+    "toolchain.json": {
+      "bytes": 3012,
+      "sha256": "00c3f707aae8abe9ca75cd2e162f5e1c7c34362a03675da39afead60d856066a"
+    },
+    "tsconfig.json": {
+      "bytes": 1104,
+      "sha256": "8d8121ab905345fe75ff994fc40706f683dfc120699ca48269e85b90a82197a7"
+    },
+    "LICENSE": {
+      "bytes": 1075,
+      "sha256": "86673fb485f12fa9aaa3941dfccc9f69a7f8322f8141d0d5c73db4323de10ac5"
+    }
+  },
+  "toolchain": {
+    "bytes": 3012,
+    "sha256": "00c3f707aae8abe9ca75cd2e162f5e1c7c34362a03675da39afead60d856066a"
+  },
+  "dependencyLock": {
+    "bytes": 28357,
+    "sha256": "65e3dbd01be4a1889367690faf1a9c3f08fb31d22dbd273d9bb9f39dd6baa6fb"
+  }
+}

package/package.json

@@ -1,6 +1,35 @@
 {
   "name": "@bun-native/cli",
-  "version": "0.0.0-stage",
-  "stub": true,
-  "description": "Temporary package placeholder for staged publishing"
-}
+  "version": "0.33.0",
+  "type": "module",
+  "license": "MIT",
+  "files": [
+    "src",
+    "LICENSE",
+    "README.md",
+    "bun-native-source.json"
+  ],
+  "engines": {
+    "bun": "1.4.4-canary.1"
+  },
+  "bin": {
+    "bun-native": "./src/scripts/native.ts"
+  },
+  "description": "Create, check, run and AOT-build Bun Native desktop applications.",
+  "dependencies": {
+    "@babel/core": "7.29.7",
+    "babel-preset-solid": "1.9.16",
+    "oxlint": "1.92.0"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/0xPlayerOne/bun-native.git",
+    "directory": "scripts"
+  },
+  "homepage": "https://github.com/0xPlayerOne/bun-native#readme",
+  "bugs": "https://github.com/0xPlayerOne/bun-native/issues",
+  "publishConfig": {
+    "access": "public",
+    "provenance": true
+  }
+}

package/src/.oxfmtrc.json

@@ -0,0 +1,20 @@
+{
+  "semi": false,
+  "singleQuote": true,
+  "trailingComma": "es5",
+  "printWidth": 100,
+  "ignorePatterns": [
+    "CHANGELOG.md",
+    ".github/.code-foundry",
+    ".github/actions/",
+    "node_modules/**",
+    "native/target/**",
+    "dist/**",
+    ".bun-native/**"
+  ],
+  "tabWidth": 2,
+  "endOfLine": "lf",
+  "sortImports": false,
+  "sortPackageJson": false,
+  "embeddedLanguageFormatting": "off"
+}

package/src/.oxlintrc.json

@@ -0,0 +1,12 @@
+{
+  "$schema": "./node_modules/oxlint/configuration_schema.json",
+  "categories": {
+    "correctness": "error",
+    "suspicious": "off"
+  },
+  "ignorePatterns": ["node_modules/**", "packages/*/dist/**", "examples/*/dist/**"],
+  "rules": {
+    "no-debugger": "error",
+    "no-console": "off"
+  }
+}

package/src/experiments/aot-gpui/compile.ts

@@ -0,0 +1,41 @@
+import { writeFileSync } from 'node:fs'
+import { dirname, join } from 'node:path'
+import { inspectBunExecutable } from './inspect'
+import { inspectBunRuntime } from './inspect-runtime'
+import toolchain from '../../toolchain.json'
+
+/** Shared real AOT compiler and executable checks for fixtures and application tooling. */
+export function compileApplication(input: string, output: string, cwd: string, trim = false) {
+  if (Bun.revision !== toolchain.bun.revision) throw new Error('Use the pinned Bun AOT compiler')
+  const compileCommand = [
+    process.execPath,
+    '--no-install',
+    'compile',
+    '--no-script',
+    '--production',
+    ...(trim ? ['--trim'] : []),
+    '--explain=json',
+    input,
+    '--outfile',
+    output,
+  ]
+  const start = performance.now()
+  const result = Bun.spawnSync(compileCommand, {
+    cwd,
+    stdout: 'pipe',
+    stderr: 'pipe',
+    timeout: 120_000,
+  })
+  writeFileSync(join(dirname(output), 'compile-aot.stdout.log'), result.stdout)
+  writeFileSync(join(dirname(output), 'compile-aot.stderr.log'), result.stderr)
+  if (result.exitCode !== 0)
+    throw new Error(`compile-aot failed (${result.exitCode}): ${result.stderr}`)
+  const buildMs = performance.now() - start
+  const inspection = inspectBunExecutable(output)
+  if (!inspection.hasCompiledProgram)
+    throw new Error('Compiler output has no compiled-program record')
+  const runtimeFeatures = inspectBunRuntime(output)
+  if (runtimeFeatures.jit === 'present' || runtimeFeatures.jitRemovedRanges.count === 0)
+    throw new Error('Compiler output does not record removal of the JIT compiler')
+  return { compileCommand, buildMs, inspection, runtimeFeatures }
+}

package/src/experiments/aot-gpui/inspect-runtime.ts

@@ -0,0 +1,303 @@
+import { readFileSync } from 'node:fs'
+
+// Pinned Bun da867c60: src/trim/removable_features/state.rs and
+// scripts/build/trim/features.ts. engine.def assigns JIT=0, Interpreter=1,
+// ImageCompiler=3. Executable layouts follow src/exe_format/{elf,macho,pe}.rs.
+// Named, file-backed sections locate records; a magic-byte search is not proof.
+const stateSize = 536
+const removalOffset = 24
+const featureCount = 512
+const states = ['present', 'unused', 'requested'] as const
+
+type Section = {
+  name: string
+  address: bigint
+  offset: bigint
+  size: bigint
+  mapped: boolean
+  mappedSize: bigint
+  readOnlyData: boolean
+}
+
+function bounded(bytes: Buffer, offset: bigint, length: bigint): number {
+  if (offset < 0n || length < 0n || offset + length > BigInt(bytes.length))
+    throw new Error('Executable range extends outside the file')
+  return Number(offset)
+}
+
+function elfSections(bytes: Buffer): Section[] {
+  if (
+    bytes.length < 64 ||
+    bytes.readUInt32LE(0) !== 0x464c457f ||
+    bytes[4] !== 2 ||
+    bytes[5] !== 1 ||
+    bytes[6] !== 1 ||
+    ![2, 3].includes(bytes.readUInt16LE(16)) ||
+    bytes.readUInt32LE(20) !== 1 ||
+    bytes.readUInt16LE(52) !== 64 ||
+    bytes.readUInt16LE(58) !== 64
+  )
+    throw new Error('Runtime feature inspection requires a little-endian ELF64 executable')
+  const count = bytes.readUInt16LE(60)
+  const namesIndex = bytes.readUInt16LE(62)
+  if (count === 0 || namesIndex === 0 || namesIndex >= count)
+    throw new Error('Missing or unsupported ELF section table')
+  const table = bounded(bytes, bytes.readBigUInt64LE(40), BigInt(count * 64))
+  const raw = Array.from({ length: count }, (_, index) => {
+    const offset = table + index * 64
+    return {
+      nameOffset: bytes.readUInt32LE(offset),
+      type: bytes.readUInt32LE(offset + 4),
+      flags: bytes.readBigUInt64LE(offset + 8),
+      address: bytes.readBigUInt64LE(offset + 16),
+      offset: bytes.readBigUInt64LE(offset + 24),
+      size: bytes.readBigUInt64LE(offset + 32),
+    }
+  })
+  const names = raw[namesIndex]
+  if (!names || names.type !== 3) throw new Error('Invalid ELF section-name table')
+  const namesStart = bounded(bytes, names.offset, names.size)
+  const nameBytes = bytes.subarray(namesStart, namesStart + Number(names.size))
+  return raw.map((section) => {
+    if (BigInt(section.nameOffset) >= names.size)
+      throw new Error('ELF section name is outside the string table')
+    const end = nameBytes.indexOf(0, section.nameOffset)
+    if (end < section.nameOffset) throw new Error('Unterminated ELF section name')
+    return {
+      ...section,
+      name: nameBytes.toString('utf8', section.nameOffset, end),
+      mapped: (section.flags & 2n) !== 0n,
+      mappedSize: section.size,
+      readOnlyData: section.type === 1 && (section.flags & 3n) === 2n,
+    }
+  })
+}
+
+function fixedName(bytes: Buffer, offset: number, length: number): string {
+  const name = bytes.subarray(offset, offset + length)
+  const end = name.indexOf(0)
+  // Node's ASCII decoder clears the high bit and would alias malformed names.
+  return name.toString('latin1', 0, end < 0 ? length : end)
+}
+
+function segmentMatches(owner: string, declared: string): boolean {
+  if (owner === declared) return true
+  // Pinned Bun macho_ranges.rs splits trimmed segments into NAME, NAME.1, ...
+  // and retains the original section.segname. Match its bounded name rewrite.
+  const suffix = owner.match(/\.[1-9][0-9]*$/)?.[0]
+  return suffix !== undefined && owner === declared.slice(0, 16 - suffix.length) + suffix
+}
+
+function machoSections(bytes: Buffer): Section[] {
+  if (
+    bytes.length < 32 ||
+    ![0x01000007, 0x0100000c].includes(bytes.readUInt32LE(4)) ||
+    bytes.readUInt32LE(12) !== 2
+  )
+    throw new Error('Runtime feature inspection requires a thin Mach-O64 executable')
+  const count = bytes.readUInt32LE(16)
+  const length = bytes.readUInt32LE(20)
+  const end = bounded(bytes, 32n, BigInt(length)) + length
+  if (count === 0 || count > length / 8) throw new Error('Invalid Mach-O load-command count')
+  const sections: Section[] = []
+  let command = 32
+  for (let index = 0; index < count; index++) {
+    if (command + 8 > end) throw new Error('Truncated Mach-O load command')
+    const kind = bytes.readUInt32LE(command)
+    const size = bytes.readUInt32LE(command + 4)
+    if (size < 8 || size % 8 !== 0 || command + size > end)
+      throw new Error('Invalid Mach-O load-command size')
+    if (kind === 0x19) {
+      if (size < 72) throw new Error('Truncated Mach-O segment')
+      const name = fixedName(bytes, command + 8, 16)
+      const address = bytes.readBigUInt64LE(command + 24)
+      const virtualSize = bytes.readBigUInt64LE(command + 32)
+      const offset = bytes.readBigUInt64LE(command + 40)
+      const fileSize = bytes.readBigUInt64LE(command + 48)
+      const protection = bytes.readUInt32LE(command + 60)
+      const sectionCount = bytes.readUInt32LE(command + 64)
+      if (size !== 72 + sectionCount * 80 || address + virtualSize > 0xffffffffffffffffn)
+        throw new Error('Invalid Mach-O segment layout')
+      bounded(bytes, offset, fileSize)
+      for (let sectionIndex = 0; sectionIndex < sectionCount; sectionIndex++) {
+        const header = command + 72 + sectionIndex * 80
+        const sectionName = fixedName(bytes, header, 16)
+        const segmentName = fixedName(bytes, header + 16, 16)
+        const sectionAddress = bytes.readBigUInt64LE(header + 32)
+        const sectionSize = bytes.readBigUInt64LE(header + 40)
+        const sectionOffset = BigInt(bytes.readUInt32LE(header + 48))
+        const kind = bytes.readUInt32LE(header + 64) & 0xff
+        const fileBacked = ![1, 0xc, 0x12].includes(kind)
+        if (
+          !segmentMatches(name, segmentName) ||
+          sectionAddress < address ||
+          sectionAddress + sectionSize > address + virtualSize ||
+          (fileBacked &&
+            (sectionOffset < offset ||
+              sectionOffset + sectionSize > offset + fileSize ||
+              sectionAddress - address !== sectionOffset - offset))
+        )
+          throw new Error('Invalid Mach-O section mapping')
+        sections.push({
+          name: `${segmentName},${sectionName}`,
+          address: sectionAddress,
+          offset: sectionOffset,
+          size: sectionSize,
+          mapped: true,
+          mappedSize: sectionSize,
+          readOnlyData: kind === 0 && (protection & 3) === 1,
+        })
+      }
+    }
+    command += size
+  }
+  if (command !== end) throw new Error('Mach-O load commands do not fill their declared table')
+  return sections
+}
+
+function peSections(bytes: Buffer): Section[] {
+  if (bytes.length < 64) throw new Error('Truncated PE DOS header')
+  const header = bounded(bytes, BigInt(bytes.readUInt32LE(60)), 24n)
+  const optionalSize = bytes.readUInt16LE(header + 20)
+  const count = bytes.readUInt16LE(header + 6)
+  if (
+    bytes.readUInt32LE(header) !== 0x4550 ||
+    ![0x8664, 0xaa64].includes(bytes.readUInt16LE(header + 4)) ||
+    (bytes.readUInt16LE(header + 22) & 0x2002) !== 2 ||
+    optionalSize < 112 ||
+    count === 0 ||
+    count > 96
+  )
+    throw new Error('Runtime feature inspection requires a PE32+ executable')
+  const optional = bounded(bytes, BigInt(header + 24), BigInt(optionalSize))
+  if (bytes.readUInt16LE(optional) !== 0x20b)
+    throw new Error('Runtime feature inspection requires a PE32+ optional header')
+  const imageBase = bytes.readBigUInt64LE(optional + 24)
+  const table = bounded(bytes, BigInt(optional + optionalSize), BigInt(count * 40))
+  return Array.from({ length: count }, (_, index) => {
+    const section = table + index * 40
+    const size = bytes.readUInt32LE(section + 8)
+    const address = imageBase + BigInt(bytes.readUInt32LE(section + 12))
+    const fileSize = bytes.readUInt32LE(section + 16)
+    const offset = BigInt(bytes.readUInt32LE(section + 20))
+    const flags = bytes.readUInt32LE(section + 36)
+    bounded(bytes, offset, BigInt(fileSize))
+    if (address + BigInt(Math.max(size, fileSize)) > 0xffffffffffffffffn)
+      throw new Error('Invalid PE section address')
+    return {
+      name: fixedName(bytes, section, 8),
+      address,
+      offset,
+      size: BigInt(size),
+      mapped: true,
+      mappedSize: BigInt(Math.max(size, fileSize)),
+      readOnlyData: (flags & 0xc0000040) === 0x40000040 && size <= fileSize,
+    }
+  })
+}
+
+function imageSections(bytes: Buffer) {
+  const magic = bytes.length >= 4 ? bytes.readUInt32LE(0) : 0
+  if (magic === 0x464c457f)
+    return { format: 'elf64-le' as const, name: '.bun_features', table: elfSections(bytes) }
+  if (magic === 0xfeedfacf)
+    return {
+      format: 'macho64-le' as const,
+      name: '__TEXT,__bun_features',
+      table: machoSections(bytes),
+    }
+  if (bytes.length >= 2 && bytes.readUInt16LE(0) === 0x5a4d)
+    return { format: 'pe32+-le' as const, name: '.bunfeat', table: peSections(bytes) }
+  throw new Error('Runtime feature inspection requires an ELF64, Mach-O64 or PE32+ executable')
+}
+
+function overlappingMappings(table: Section[], start: bigint, length: bigint): Section[] {
+  return table.filter(
+    (entry) =>
+      entry.mapped && entry.address < start + length && start < entry.address + entry.mappedSize
+  )
+}
+
+export function inspectBunRuntime(path: string) {
+  const bytes = readFileSync(path)
+  const { format, name, table } = imageSections(bytes)
+  const candidates = table.filter((section) => section.name === name)
+  const section = candidates[0]
+  if (candidates.length !== 1 || !section) throw new Error(`Expected exactly one ${name} section`)
+  if (
+    !section.readOnlyData ||
+    section.size !== BigInt(stateSize) ||
+    section.address % 8n !== 0n ||
+    section.offset % 8n !== 0n
+  )
+    throw new Error(`Invalid ${name} section layout`)
+  if (overlappingMappings(table, section.address, section.size).length !== 1)
+    throw new Error('Ambiguous Bun runtime feature mapping')
+  const offset = bounded(bytes, section.offset, section.size)
+  const state = bytes.subarray(offset, offset + stateSize)
+  if (!state.subarray(0, 8).equals(Buffer.from('BUNFEAT\0')))
+    throw new Error('Invalid Bun runtime feature magic')
+  const trimmed = state.readUInt32LE(8)
+  const rangeCount = state.readUInt32LE(12)
+  const rangeOffset = state.readBigInt64LE(16)
+  if (
+    trimmed > 1 ||
+    rangeCount > 32768 ||
+    rangeOffset % 8n !== 0n ||
+    (rangeCount === 0 && rangeOffset !== 0n) ||
+    state.subarray(removalOffset).some((value) => value > 2)
+  )
+    throw new Error('Invalid Bun runtime feature state')
+
+  let jitRangeCount = 0
+  let jitRangeBytes = 0
+  if (rangeCount > 0) {
+    const start = section.address + rangeOffset
+    const length = BigInt(rangeCount * 16)
+    // Check every mapped alias before testing permissions. Filtering writable
+    // mappings first could falsely qualify an ambiguous table as read-only.
+    const ranges = overlappingMappings(table, start, length)
+    const rangeSection = ranges[0]
+    if (
+      ranges.length !== 1 ||
+      !rangeSection ||
+      !rangeSection.readOnlyData ||
+      rangeSection.address > start ||
+      start + length > rangeSection.address + rangeSection.size
+    )
+      throw new Error('Missing or ambiguous Bun removed-range table')
+    bounded(bytes, rangeSection.offset, rangeSection.size)
+    const rangeStart = bounded(bytes, rangeSection.offset + start - rangeSection.address, length)
+    let previousEnd = 0n
+    for (let index = 0; index < rangeCount; index++) {
+      const record = rangeStart + index * 16
+      const address = section.address + bytes.readBigInt64LE(record)
+      const size = bytes.readUInt32LE(record + 8)
+      const feature = bytes.readUInt16LE(record + 12)
+      if (
+        address < previousEnd ||
+        address + BigInt(size) > 0xffffffffffffffffn ||
+        size === 0 ||
+        feature >= featureCount ||
+        bytes.readUInt16LE(record + 14) !== 0
+      )
+        throw new Error('Invalid Bun removed-range record')
+      previousEnd = address + BigInt(size)
+      if (feature === 0) {
+        jitRangeCount++
+        jitRangeBytes += size
+      }
+    }
+  }
+  return {
+    format,
+    section: { name: section.name, offset, bytes: stateSize },
+    rawRecordHex: state.toString('hex'),
+    trimmedProgramFeatures: trimmed === 1,
+    removedRangeCount: rangeCount,
+    jit: states[state[removalOffset]!]!,
+    interpreter: states[state[removalOffset + 1]!]!,
+    imageCompiler: states[state[removalOffset + 3]!]!,
+    jitRemovedRanges: { count: jitRangeCount, virtualBytes: jitRangeBytes },
+  }
+}

package/src/experiments/aot-gpui/inspect.ts

@@ -0,0 +1,65 @@
+import { readFileSync } from 'node:fs'
+
+// Layout is pinned to Bun da867c60: src/standalone_graph/StandaloneModuleGraph.rs
+// Offsets is repr(C), 32 bytes on all six supported 64-bit targets. A .bun_aot
+// section also exists in JIT executables; the actual module graph flag matters.
+const trailer = Buffer.from('\n---- Bun! ----\n')
+const offsetsSize = 32
+const moduleRecordSize = 52
+const compiledProgramFlag = 1 << 14
+
+export function inspectBunExecutable(path: string): {
+  format: 'elf' | 'macho' | 'pe'
+  payloadOffset: number
+  payloadBytes: number
+  flags: number
+  hasCompiledProgram: boolean
+} {
+  const bytes = readFileSync(path)
+  const magic = bytes.length >= 4 ? bytes.readUInt32LE(0) : 0
+  const format =
+    magic === 0x464c457f
+      ? 'elf'
+      : magic === 0xfeedfacf
+        ? 'macho'
+        : bytes.subarray(0, 2).toString() === 'MZ'
+          ? 'pe'
+          : undefined
+  if (!format) throw new Error('Unsupported executable format')
+
+  let trailerOffset = bytes.lastIndexOf(trailer)
+  while (trailerOffset >= offsetsSize + 8) {
+    const offsets = trailerOffset - offsetsSize
+    const count64 = bytes.readBigUInt64LE(offsets)
+    if (count64 <= BigInt(offsets - 8)) {
+      const count = Number(count64)
+      const payloadOffset = offsets - count
+      const payloadBytes = count + offsetsSize + trailer.length
+      const modulesOffset = bytes.readUInt32LE(offsets + 8)
+      const modulesLength = bytes.readUInt32LE(offsets + 12)
+      const entryPoint = bytes.readUInt32LE(offsets + 16)
+      const argvOffset = bytes.readUInt32LE(offsets + 20)
+      const argvLength = bytes.readUInt32LE(offsets + 24)
+      const flags = bytes.readUInt32LE(offsets + 28)
+      if (
+        bytes.readBigUInt64LE(payloadOffset - 8) === BigInt(payloadBytes) &&
+        modulesLength > 0 &&
+        modulesLength % moduleRecordSize === 0 &&
+        modulesOffset + modulesLength <= count &&
+        entryPoint < modulesLength / moduleRecordSize &&
+        argvOffset + argvLength <= count &&
+        (flags & ~0x7fff) === 0
+      ) {
+        return {
+          format,
+          payloadOffset,
+          payloadBytes,
+          flags,
+          hasCompiledProgram: (flags & compiledProgramFlag) !== 0,
+        }
+      }
+    }
+    trailerOffset = bytes.lastIndexOf(trailer, trailerOffset - 1)
+  }
+  throw new Error('No valid pinned Bun standalone module graph found')
+}

package/src/scripts/native/artifact.ts

@@ -0,0 +1,32 @@
+import { createHash } from 'node:crypto'
+import { open, readFile, stat } from 'node:fs/promises'
+
+export type FileDigest = { bytes: number; sha256: string }
+
+// Source files and manifests are read whole; compilers and host binaries are
+// hashed through one reused buffer so memory stays bounded.
+const WHOLE_FILE_BYTES = 4 * 1024 * 1024
+const CHUNK_BYTES = 1024 * 1024
+
+export async function fileDigest(path: string): Promise<FileDigest> {
+  const hash = createHash('sha256')
+  // The size only picks a strategy; both read to EOF and count what they read.
+  if ((await stat(path)).size <= WHOLE_FILE_BYTES) {
+    const data = await readFile(path)
+    return { bytes: data.length, sha256: hash.update(data).digest('hex') }
+  }
+  let bytes = 0
+  const file = await open(path, 'r')
+  try {
+    const buffer = Buffer.allocUnsafe(CHUNK_BYTES)
+    for (;;) {
+      const { bytesRead } = await file.read(buffer, 0, CHUNK_BYTES, null)
+      if (bytesRead === 0) break
+      hash.update(buffer.subarray(0, bytesRead))
+      bytes += bytesRead
+    }
+  } finally {
+    await file.close()
+  }
+  return { bytes, sha256: hash.digest('hex') }
+}