@bun-native/cli 0.0.0-stage → 0.33.1

package/src/scripts/native/package-lock.ts

@@ -0,0 +1,220 @@
+import { isDeepStrictEqual } from 'node:util'
+import { packagePath } from './paths.ts'
+
+type LockedPackage = [string, string, Record<string, unknown>, string]
+export type DependencyLock = {
+  lockfileVersion: 2
+  configVersion: 1
+  packages: Record<string, LockedPackage>
+}
+type ArchiveInfo = { dependencies?: Record<string, string>; bin?: Record<string, string> }
+type LocalArchiveLock = {
+  packages: Record<string, [string, ArchiveInfo, string]>
+  overrides: Record<string, string>
+}
+
+/** Pinned Bun text locks use raw tarball paths; file: denotes a folder in this field. */
+export function localArchiveLock(
+  archives: readonly {
+    name: string
+    file: string
+    sha256: string
+    dependencies?: Record<string, string>
+    bin?: Record<string, string>
+  }[]
+): LocalArchiveLock {
+  const packages: LocalArchiveLock['packages'] = Object.create(null)
+  const overrides: Record<string, string> = Object.create(null)
+  for (const archive of archives) {
+    if (
+      !archive.name.startsWith('@bun-native/') ||
+      !packagePath(archive.file) ||
+      !archive.file.endsWith('.tgz') ||
+      !/^[a-f0-9]{64}$/.test(archive.sha256) ||
+      Object.hasOwn(packages, archive.name)
+    )
+      throw new Error(`Invalid or duplicate local archive lock input: ${archive.name}`)
+    const info: ArchiveInfo = {
+      ...(archive.dependencies ? { dependencies: archive.dependencies } : {}),
+      ...(archive.bin ? { bin: archive.bin } : {}),
+    }
+    packages[archive.name] = [
+      `${archive.name}@${archive.file}`,
+      info,
+      `sha256-${Buffer.from(archive.sha256, 'hex').toString('base64')}`,
+    ]
+    overrides[archive.name] = `file:${archive.file}`
+  }
+  return {
+    packages: Object.fromEntries(Object.entries(packages)),
+    overrides: Object.fromEntries(Object.entries(overrides)),
+  }
+}
+
+function record(value: unknown): Record<string, unknown> {
+  if (!value || typeof value !== 'object' || Array.isArray(value))
+    throw new Error('Invalid dependency lock record')
+  return value as Record<string, unknown>
+}
+
+export function lockedPackages(value: unknown, local?: LocalArchiveLock): DependencyLock {
+  const lock = record(value)
+  if (lock['lockfileVersion'] !== 2 || lock['configVersion'] !== 1)
+    throw new Error('Expected the pinned Bun dependency lock format')
+  const supplied = record(lock['packages'])
+  if (local)
+    for (const [name, expected] of Object.entries(local.packages))
+      if (!Object.hasOwn(supplied, name) || !isDeepStrictEqual(supplied[name], expected))
+        throw new Error(`Installed local archive lock differs: ${name}`)
+  const packages: DependencyLock['packages'] = Object.create(null)
+  for (const [key, value] of Object.entries(supplied)) {
+    if (local && Object.hasOwn(local.packages, key)) continue
+    if (!Array.isArray(value) || typeof value[0] !== 'string')
+      throw new Error(`Invalid locked package: ${key}`)
+    if (value[0].includes('@workspace:') || value[0].includes('@file:')) {
+      if (local || !key.startsWith('@bun-native/') || value[0].includes('@file:'))
+        throw new Error(`Unexpected local dependency in lock: ${key}`)
+      continue
+    }
+    if (
+      value.length !== 4 ||
+      value[1] !== '' ||
+      typeof value[3] !== 'string' ||
+      !/^sha512-[A-Za-z0-9+/]+={0,2}$/.test(value[3])
+    )
+      throw new Error(`Expected an integrity-bound registry dependency: ${key}`)
+    packages[key] = [value[0], value[1], record(value[2]), value[3]]
+  }
+  return {
+    lockfileVersion: 2,
+    configVersion: 1,
+    packages: Object.fromEntries(Object.entries(packages)),
+  }
+}
+
+function identity(entry: LockedPackage): { name: string; version: string } {
+  const separator = entry[0].lastIndexOf('@')
+  const name = entry[0].slice(0, separator)
+  const version = entry[0].slice(separator + 1)
+  if (separator <= 0 || !/^\d+\.\d+\.\d+(?:[-+][0-9A-Za-z.-]+)?$/.test(version))
+    throw new Error(`Expected an exact registry version: ${entry[0]}`)
+  return { name, version }
+}
+
+/** Preserve nested resolutions; a global name override would collapse distinct versions. */
+export function dependencyClosure(
+  lock: DependencyLock,
+  roots: Record<string, string>,
+  includeInstalledOptionalPeers = false
+): DependencyLock {
+  const packages: DependencyLock['packages'] = Object.create(null)
+  const pending: string[] = []
+  for (const [name, version] of Object.entries(roots)) {
+    const entry = Object.hasOwn(lock.packages, name) ? lock.packages[name] : undefined
+    if (!entry || identity(entry).name !== name || identity(entry).version !== version)
+      throw new Error(`Source lock does not pin ${name}@${version}`)
+    pending.push(name)
+  }
+  const resolve = (from: string, name: string, required: boolean): string | undefined => {
+    let ancestor = from
+    while (ancestor) {
+      const candidate = `${ancestor}/${name}`
+      if (Object.hasOwn(lock.packages, candidate)) return candidate
+      const current = Object.hasOwn(lock.packages, ancestor) ? lock.packages[ancestor] : undefined
+      if (!current || !ancestor.endsWith(identity(current).name))
+        throw new Error(`Invalid nested dependency locator: ${ancestor}`)
+      ancestor = ancestor.slice(0, -identity(current).name.length).replace(/\/$/, '')
+    }
+    if (Object.hasOwn(lock.packages, name)) return name
+    if (required) throw new Error(`Source lock is missing ${name}, required by ${from}`)
+    return undefined
+  }
+  for (let index = 0; index < pending.length; index += 1) {
+    const key = pending[index]!
+    if (packages[key]) continue
+    const entry = lock.packages[key]!
+    identity(entry)
+    packages[key] = entry
+    const optionalPeers = entry[2]['optionalPeers'] ?? []
+    if (!Array.isArray(optionalPeers) || optionalPeers.some((name) => typeof name !== 'string'))
+      throw new Error(`Invalid optional peer metadata: ${key}`)
+    for (const field of ['dependencies', 'peerDependencies', 'optionalDependencies']) {
+      const dependencies = entry[2][field]
+      if (dependencies === undefined) continue
+      for (const [name, version] of Object.entries(record(dependencies))) {
+        if (typeof version !== 'string') throw new Error(`Invalid ${key} dependency ${name}`)
+        // Optional peer declarations remain byte-identical in the retained
+        // tuple. They do not add an installation root that the source lacked.
+        const optionalPeer = field === 'peerDependencies' && optionalPeers.includes(name)
+        if (optionalPeer && !includeInstalledOptionalPeers) continue
+        const target = resolve(key, name, !optionalPeer && field !== 'optionalDependencies')
+        if (target) pending.push(target)
+      }
+    }
+  }
+  return {
+    lockfileVersion: 2,
+    configVersion: 1,
+    packages: Object.fromEntries(
+      Object.entries(packages).sort(([left], [right]) => (left < right ? -1 : left > right ? 1 : 0))
+    ),
+  }
+}
+
+/** Keep a complete lock graph; Bun rejects missing local roots before installation. */
+export function seedConsumerLock(
+  lock: DependencyLock,
+  manifest: {
+    name: string
+    dependencies: Record<string, string>
+    devDependencies: Record<string, string>
+  },
+  local: LocalArchiveLock = { packages: {}, overrides: {} }
+) {
+  const packages = { ...lock.packages, ...local.packages }
+  for (const name of Object.keys({ ...manifest.dependencies, ...manifest.devDependencies }))
+    if (!Object.hasOwn(packages, name))
+      throw new Error(`Consumer lock is missing a root package: ${name}`)
+  return {
+    lockfileVersion: lock.lockfileVersion,
+    configVersion: lock.configVersion,
+    workspaces: { '': manifest },
+    overrides: local.overrides,
+    packages,
+  }
+}
+
+/** No new tuple, changed version/integrity/edge, or omitted required nested tuple is accepted. */
+export function verifyConsumerLock(
+  value: unknown,
+  expected: DependencyLock,
+  allowAdditional = false,
+  local?: LocalArchiveLock
+): void {
+  // Applications may add unrelated dependencies. The fixed qualification cohort
+  // uses the exact comparison; runtime validation still pins every required tuple.
+  const packages = record(record(value)['packages'])
+  const localRoots = Object.keys(local?.packages ?? {})
+  if (Object.keys(packages).some((key) => localRoots.some((root) => key.startsWith(root + '/'))))
+    throw new Error(
+      'Installed dependency lock introduces a nested locator beneath a required local package'
+    )
+  const supplied = lockedPackages(value, local)
+  const roots = Object.fromEntries(
+    Object.entries(expected.packages)
+      .filter(([key, entry]) => key === identity(entry).name)
+      .map(([key, entry]) => [key, identity(entry).version])
+  )
+  const actual = allowAdditional ? dependencyClosure(supplied, roots, true) : supplied
+  if (!isDeepStrictEqual(actual, expected))
+    throw new Error('Installed dependency lock differs from the supplied pinned package set')
+  if (local) {
+    const overrides = record(record(value)['overrides'])
+    // Selector/parent override forms can affect required packages too. Keep the
+    // complete override map exact, while permitting unrelated registry roots.
+    if (!isDeepStrictEqual(overrides, local.overrides))
+      throw new Error(
+        'Installed local archive overrides differ from the supplied pinned package set'
+      )
+  }
+}

package/src/scripts/native/package-set.ts

@@ -0,0 +1,417 @@
+import { readdir, realpath, stat } from 'node:fs/promises'
+import { dirname, join } from 'node:path'
+import { isDeepStrictEqual } from 'node:util'
+import toolchain from '../../toolchain.json'
+import {
+  dependencyClosure,
+  lockedPackages,
+  localArchiveLock,
+  verifyConsumerLock,
+  type DependencyLock,
+} from './package-lock.ts'
+import { inside, packageArchivePath, packagePath } from './paths.ts'
+import { fileDigest, sha256, type FileDigest } from './artifact.ts'
+import { verifyPackageArchive } from './package-archive.ts'
+
+export const packageNames = [
+  '@bun-native/cli',
+  '@bun-native/core',
+  '@bun-native/protocol',
+  '@bun-native/react',
+  '@bun-native/renderer',
+  '@bun-native/runtime',
+  '@bun-native/solid',
+] as const
+
+export type PackageManifest = {
+  name: string
+  version: string
+  private: true
+  type: 'module'
+  license: 'MIT'
+  files: string[]
+  engines: { bun: string }
+  dependencies?: Record<string, string>
+  exports?: string | Record<string, string>
+  bin?: Record<string, string>
+}
+export type LocalPackage = {
+  manifest: PackageManifest
+  archive: FileDigest & { file: string }
+  files: Record<string, FileDigest>
+}
+export type Consumer = {
+  dependencies: Record<string, string>
+  devDependencies: Record<string, string>
+  lock: DependencyLock
+}
+export type PackageSet = {
+  schemaVersion: 1
+  source: { commit: string; tree: string; files: Record<string, FileDigest> }
+  toolchain: typeof toolchain
+  compiler: { revision: string; os: string; architecture: string; executable: FileDigest }
+  packages: Record<string, LocalPackage>
+  consumers: { solid: Consumer; react: Consumer }
+}
+export type ReadPackageSet = { directory: string; manifest: PackageSet; text: string }
+
+function object(value: unknown): Record<string, unknown> {
+  if (!value || typeof value !== 'object' || Array.isArray(value))
+    throw new Error('Invalid package-set object')
+  return value as Record<string, unknown>
+}
+
+function keys(value: Record<string, unknown>, required: string[], optional: string[] = []): void {
+  if (
+    required.some((key) => !Object.hasOwn(value, key)) ||
+    Object.keys(value).some((key) => !required.includes(key) && !optional.includes(key))
+  )
+    throw new Error('Unexpected or missing package-set fields')
+}
+
+function digest(value: unknown): FileDigest {
+  const fields = object(value)
+  if (
+    !Number.isSafeInteger(fields['bytes']) ||
+    (fields['bytes'] as number) < 0 ||
+    typeof fields['sha256'] !== 'string' ||
+    !/^[a-f0-9]{64}$/.test(fields['sha256'])
+  )
+    throw new Error('Invalid package-set file digest')
+  return { bytes: fields['bytes'] as number, sha256: fields['sha256'] }
+}
+
+function files(value: unknown): Record<string, FileDigest> {
+  const result: Record<string, FileDigest> = Object.create(null)
+  for (const [path, entry] of Object.entries(object(value))) {
+    if (!packagePath(path)) throw new Error(`Invalid package-set file path: ${path}`)
+    keys(object(entry), ['bytes', 'sha256'])
+    result[path] = digest(entry)
+  }
+  return result
+}
+
+function versions(value: unknown): Record<string, string> {
+  const result: Record<string, string> = Object.create(null)
+  for (const [name, version] of Object.entries(object(value))) {
+    if (
+      !/^(?:@[a-z0-9._-]+\/)?[a-z0-9._-]+$/.test(name) ||
+      typeof version !== 'string' ||
+      !/^\d+\.\d+\.\d+(?:[-+][0-9A-Za-z.-]+)?$/.test(version)
+    )
+      throw new Error(`Package-set dependency must have an exact version: ${name}`)
+    result[name] = version
+  }
+  return result
+}
+
+function exportedPaths(value: unknown): string[] {
+  return typeof value === 'string'
+    ? [value]
+    : Object.values(object(value)).map((entry) => {
+        if (typeof entry !== 'string') throw new Error('Invalid package export/bin path')
+        return entry
+      })
+}
+
+function packageManifest(
+  value: unknown,
+  name: string,
+  contents: Record<string, FileDigest>
+): PackageManifest {
+  const manifest = object(value)
+  keys(
+    manifest,
+    ['name', 'version', 'private', 'type', 'license', 'files', 'engines'],
+    ['dependencies', 'exports', 'bin']
+  )
+  if (
+    manifest['name'] !== name ||
+    manifest['private'] !== true ||
+    manifest['type'] !== 'module' ||
+    manifest['license'] !== 'MIT' ||
+    !isDeepStrictEqual(manifest['engines'], { bun: toolchain.bun.version }) ||
+    !Array.isArray(manifest['files']) ||
+    manifest['files'].some((path) => !packageArchivePath(path))
+  )
+    throw new Error(`Invalid materialized package manifest: ${name}`)
+  versions({ [name]: manifest['version'] })
+  if (manifest['dependencies'] !== undefined) versions(manifest['dependencies'])
+  for (const field of ['exports', 'bin']) {
+    if (manifest[field] === undefined) continue
+    for (const exported of exportedPaths(manifest[field])) {
+      const path = exported.replace(/^\.\//, '')
+      if (!packagePath(path) || !Object.hasOwn(contents, path))
+        throw new Error(`Unpackaged ${field} target: ${name} ${exported}`)
+    }
+  }
+  if (
+    !Object.hasOwn(contents, 'LICENSE') ||
+    !Object.hasOwn(contents, 'bun-native-source.json') ||
+    !Object.hasOwn(contents, 'package.json') ||
+    (name === '@bun-native/cli'
+      ? !isDeepStrictEqual(manifest['bin'], { 'bun-native': './src/scripts/native.ts' }) ||
+        manifest['exports'] !== undefined
+      : manifest['exports'] === undefined || manifest['bin'] !== undefined)
+  )
+    throw new Error(`Missing package entry/license/provenance: ${name}`)
+  const text = JSON.stringify(manifest, null, 2) + '\n'
+  if (
+    !isDeepStrictEqual(contents['package.json'], {
+      bytes: Buffer.byteLength(text),
+      sha256: sha256(text),
+    })
+  )
+    throw new Error(`Package manifest digest mismatch: ${name}`)
+  return manifest as PackageManifest
+}
+
+export function requiredPackages(set: PackageSet, framework: 'solid' | 'react'): string[] {
+  const pending = ['@bun-native/cli', '@bun-native/core', `@bun-native/${framework}`]
+  const required = new Set<string>()
+  for (let index = 0; index < pending.length; index += 1) {
+    const name = pending[index]!
+    if (required.has(name)) continue
+    const pkg = set.packages[name]
+    if (!pkg) throw new Error(`Missing local package: ${name}`)
+    required.add(name)
+    for (const [dependency, version] of Object.entries(pkg.manifest.dependencies ?? {})) {
+      if (!dependency.startsWith('@bun-native/')) continue
+      if (set.packages[dependency]?.manifest.version !== version)
+        throw new Error(`Inconsistent internal dependency: ${name} -> ${dependency}`)
+      pending.push(dependency)
+    }
+  }
+  return [...required].sort()
+}
+
+export function consumerArchiveLock(
+  set: PackageSet,
+  framework: 'solid' | 'react',
+  archiveDirectory = 'vendor/bun-native'
+) {
+  return localArchiveLock(
+    requiredPackages(set, framework).map((name) => {
+      const pkg = set.packages[name]!
+      return {
+        name,
+        file: `${archiveDirectory ? archiveDirectory + '/' : ''}${pkg.archive.file}`,
+        sha256: pkg.archive.sha256,
+        ...(pkg.manifest.dependencies ? { dependencies: pkg.manifest.dependencies } : {}),
+        ...(pkg.manifest.bin ? { bin: pkg.manifest.bin } : {}),
+      }
+    })
+  )
+}
+
+/** Validates data only; archives are hashed separately before any destination is written. */
+export function parsePackageSet(value: unknown): PackageSet {
+  const fields = object(value)
+  keys(fields, ['schemaVersion', 'source', 'toolchain', 'compiler', 'packages', 'consumers'])
+  if (fields['schemaVersion'] !== 1 || !isDeepStrictEqual(fields['toolchain'], toolchain))
+    throw new Error('Package set requires the exact pinned Bun Native toolchain')
+  const source = object(fields['source'])
+  keys(source, ['commit', 'tree', 'files'])
+  if (
+    ![source['commit'], source['tree']].every(
+      (value) => typeof value === 'string' && /^[a-f0-9]{40}$/.test(value)
+    )
+  )
+    throw new Error('Package set requires exact source commit and tree identities')
+  files(source['files'])
+  const compiler = object(fields['compiler'])
+  keys(compiler, ['revision', 'os', 'architecture', 'executable'])
+  if (
+    compiler['revision'] !== toolchain.bun.revision ||
+    typeof compiler['os'] !== 'string' ||
+    typeof compiler['architecture'] !== 'string'
+  )
+    throw new Error('Invalid package producer compiler identity')
+  digest(compiler['executable'])
+  const packages = object(fields['packages'])
+  keys(packages, [...packageNames])
+  const archives = new Set<string>()
+  for (const [name, entry] of Object.entries(packages)) {
+    const pkg = object(entry)
+    keys(pkg, ['manifest', 'archive', 'files'])
+    const contents = files(pkg['files'])
+    if (Object.keys(contents).some((path) => !packageArchivePath(path)))
+      throw new Error(`Source archive contains reserved installer metadata: ${name}`)
+    packageManifest(pkg['manifest'], name, contents)
+    const archive = object(pkg['archive'])
+    keys(archive, ['file', 'bytes', 'sha256'])
+    digest(archive)
+    if (
+      !packagePath(archive['file']) ||
+      !/^archives\/[a-z0-9._-]+\.tgz$/.test(archive['file']) ||
+      archives.has(archive['file'])
+    )
+      throw new Error('Package archives must have unique contained relative paths')
+    archives.add(archive['file'])
+  }
+  const consumers = object(fields['consumers'])
+  keys(consumers, ['solid', 'react'])
+  const set = fields as PackageSet
+  for (const framework of ['solid', 'react'] as const) {
+    const consumer = object(consumers[framework])
+    keys(consumer, ['dependencies', 'devDependencies', 'lock'])
+    const runtime = versions(consumer['dependencies'])
+    const development = versions(consumer['devDependencies'])
+    if (
+      !runtime['@bun-native/core'] ||
+      !runtime[`@bun-native/${framework}`] ||
+      !runtime[framework === 'solid' ? 'solid-js' : 'react'] ||
+      !development['@bun-native/cli'] ||
+      !development['@types/bun'] ||
+      (framework === 'react' &&
+        (!development['@types/react'] || !development['@types/react-reconciler']))
+    )
+      throw new Error(`Missing required consumer dependencies for ${framework}`)
+    const dependencies = { ...runtime, ...development }
+    const external: Record<string, string> = Object.create(null)
+    for (const name of requiredPackages(set, framework)) {
+      for (const [dependency, version] of Object.entries(
+        set.packages[name]!.manifest.dependencies ?? {}
+      )) {
+        if (dependencies[dependency] !== undefined && dependencies[dependency] !== version)
+          throw new Error(`Inconsistent consumer dependency: ${dependency}`)
+        dependencies[dependency] = version
+      }
+    }
+    for (const [name, version] of Object.entries(dependencies)) {
+      if (name.startsWith('@bun-native/')) {
+        if (set.packages[name]?.manifest.version !== version)
+          throw new Error(`Unknown local dependency: ${name}`)
+      } else external[name] = version
+    }
+    const lock = lockedPackages(consumer['lock'])
+    if (
+      !isDeepStrictEqual(consumer['lock'], lock) ||
+      !isDeepStrictEqual(lock, dependencyClosure(lock, external))
+    )
+      throw new Error(`Unexpected dependency-lock entries for ${framework}`)
+  }
+  return set
+}
+
+async function containedFile(directory: string, path: string): Promise<string> {
+  const target = await realpath(join(directory, path))
+  if (!inside(directory, target) || !(await stat(target)).isFile())
+    throw new Error(`Package file escapes its owned directory or is not a file: ${path}`)
+  return target
+}
+
+/** Run checks concurrently, but report the first failure in their listed order. */
+async function settledInOrder(tasks: Promise<void>[]): Promise<void> {
+  for (const result of await Promise.allSettled(tasks))
+    if (result.status === 'rejected') throw result.reason
+}
+
+export async function readPackageSet(path: string): Promise<ReadPackageSet> {
+  if (Bun.revision !== toolchain.bun.revision)
+    throw new Error('Use the pinned Bun for this package set')
+  const filename = await realpath(path)
+  const directory = dirname(filename)
+  const text = await Bun.file(filename).text()
+  const manifest = parsePackageSet(JSON.parse(text))
+  if (text !== JSON.stringify(manifest, null, 2) + '\n')
+    throw new Error('Package-set manifest must use its original canonical JSON encoding')
+  await settledInOrder(
+    Object.entries(manifest.packages).map(async ([name, pkg]) => {
+      const file = await containedFile(directory, pkg.archive.file)
+      if (!isDeepStrictEqual(await fileDigest(file), digest(pkg.archive)))
+        throw new Error(`Package archive digest mismatch: ${name}`)
+      await verifyPackageArchive(file, pkg.files)
+    })
+  )
+  return { directory, manifest, text }
+}
+
+/** Validate the installed CLI too, before its lazy compiler/watch modules are imported. */
+export async function verifyInstalledPackages(
+  directory: string,
+  set: PackageSet,
+  framework: 'solid' | 'react',
+  archiveDirectory = 'vendor/bun-native'
+): Promise<void> {
+  let modules: string
+  try {
+    modules = await realpath(join(directory, 'node_modules'))
+  } catch (error) {
+    if (error instanceof Error && 'code' in error && error.code === 'ENOENT')
+      throw new Error(
+        "Standalone dependencies are not installed; follow this project's pinned offline-install instructions"
+      )
+    throw error
+  }
+  if (!inside(directory, modules))
+    throw new Error('Installed packages must belong to this consumer')
+  const required = requiredPackages(set, framework)
+  verifyConsumerLock(
+    Bun.JSONC.parse(await Bun.file(join(directory, 'bun.lock')).text()),
+    set.consumers[framework].lock,
+    true,
+    consumerArchiveLock(set, framework, archiveDirectory)
+  )
+  const locations = new Map<string, string>()
+  for (const name of required) {
+    const pkg = set.packages[name]!
+    const root = await realpath(join(modules, name))
+    if (!inside(modules, root))
+      throw new Error(`Installed package resolves outside this consumer: ${name}`)
+    locations.set(name, root)
+    if (Object.keys(pkg.files).some((path) => !packageArchivePath(path)))
+      throw new Error(`Source archive contains reserved installer metadata: ${name}`)
+    // Pinned Integrity::Display uses unpadded base64 followed by "==" for
+    // SHA-256. This is its 52-byte installer tag, not the canonical lock SRI.
+    const tag = `sha256-${Buffer.from(pkg.archive.sha256, 'hex').toString('base64').replace(/=+$/, '')}==`
+    const installedFiles: Record<string, FileDigest> = {
+      ...pkg.files,
+      '.bun-tag': {
+        bytes: Buffer.byteLength(tag),
+        sha256: sha256(tag),
+      },
+    }
+    const expected = Object.keys(installedFiles).sort()
+    const folders = new Set(
+      expected.flatMap((path) => {
+        const parts = path.split('/')
+        return parts.slice(1).map((_, index) => parts.slice(0, index + 1).join('/'))
+      })
+    )
+    const inventory: string[] = []
+    const visit = async (directory: string, prefix: string): Promise<void> => {
+      for (const entry of await readdir(directory, { withFileTypes: true })) {
+        const path = prefix + entry.name
+        if (entry.isDirectory() && folders.has(path))
+          await visit(join(directory, entry.name), path + '/')
+        else if (entry.isFile() && Object.hasOwn(installedFiles, path)) inventory.push(path)
+        else throw new Error(`Installed package file inventory differs: ${name}/${path}`)
+      }
+    }
+    await visit(root, '')
+    if (!isDeepStrictEqual(inventory.sort(), expected))
+      throw new Error(`Installed package file inventory differs: ${name}`)
+    await settledInOrder(
+      Object.entries(installedFiles).map(async ([path, expected]) => {
+        const file = await containedFile(root, path)
+        if (!isDeepStrictEqual(await fileDigest(file), expected))
+          throw new Error(`Installed package digest mismatch: ${name}/${path}`)
+      })
+    )
+  }
+  for (const name of required) {
+    const root = locations.get(name)!
+    for (const dependency of Object.keys(set.packages[name]!.manifest.dependencies ?? {})) {
+      if (!dependency.startsWith('@bun-native/')) continue
+      const expected = locations.get(dependency)!
+      const resolved = await realpath(Bun.resolveSync(dependency, root))
+      const exported = set.packages[dependency]!.manifest.exports!
+      const entry = typeof exported === 'string' ? exported : exported['.']!
+      if (resolved !== (await realpath(join(expected, entry))))
+        throw new Error(
+          `Installed dependency resolves to a different package: ${name} -> ${dependency}`
+        )
+    }
+  }
+}