peachsim 0.1.1641 → 0.1.1653

package/src/nitro-source.ts

@@ -7,7 +7,7 @@ import { MAX_SWIFT_COMPILE_SOURCE_BYTES } from './swift-submit'
 import type { SwiftCompileInput } from './swift-compile'
 import type { SwiftPackageTarget } from './swift-package'
 
-export type NitroSourceOptions = { packageRoot: string } & (
+export type NitroSourceOptions = { packageRoots: string[] } & (
   | { appRoot: string; dependencyRoots?: never }
   | {
       appRoot?: never
@@ -15,13 +15,19 @@ export type NitroSourceOptions = { packageRoot: string } & (
     }
 )
 
+type NitroPackage = { name: string; version: string; root: string }
+
 /** source fragments for the common Swift host; its caller owns the executable,
- * platform bindings and invocation of the generated registration function. */
+ * platform bindings and invocation of each generated registration function.
+ * every provider shares one Nitro core and one JSI. */
 export interface NitroSourceCollection {
   files: SwiftCompileInput['files']
   targets: SwiftPackageTarget[]
-  registration: { symbol: string; header: string }
-  packages: { name: string; version: string; root: string }[]
+  /** one per provider, sorted by package name; `target` holds its header. */
+  registrations: { symbol: string; header: string; target: string }[]
+  providers: NitroPackage[]
+  nitro: NitroPackage
+  reactNative: NitroPackage
   sources: { file: string; source: string; sha256: string }[]
   /** generated include paths pointing at one unchanged original input. */
   aliases: Record<string, string>
@@ -41,7 +47,7 @@ function readJson(root: string, relative: string): unknown {
   )
 }
 
-function packageInfo(root: string): NitroSourceCollection['packages'][number] {
+function packageInfo(root: string): NitroPackage {
   root = fs.realpathSync(root)
   const value = readJson(root, 'package.json')
   if (
@@ -119,11 +125,69 @@ function registrations(root: string) {
   return { namespace, swiftModule, classes }
 }
 
+/** the installed packages react native's iOS autolinking would link into the
+ * app that ship a generated Nitro iOS initializer: the app's own declared
+ * dependencies, resolved from its directory. Android-only packages ship none. */
+export function discoverNitroProviders(appRoot: string): string[] {
+  appRoot = fs.realpathSync(appRoot)
+  const manifest = readJson(appRoot, 'package.json')
+  if (!object(manifest)) throw new Error(`${appRoot}: package.json is not an object`)
+  const declared = new Set<string>()
+  for (const field of ['dependencies', 'devDependencies']) {
+    const value = manifest[field]
+    if (object(value)) for (const name of Object.keys(value)) declared.add(name)
+  }
+  const roots: string[] = []
+  for (const name of [...declared].sort()) {
+    for (let directory = appRoot; ; directory = path.dirname(directory)) {
+      const root = path.join(directory, 'node_modules', name)
+      if (fs.existsSync(path.join(root, 'package.json'))) {
+        const generated = path.join(root, 'nitrogen/generated/ios')
+        if (
+          fs.existsSync(generated) &&
+          fs.readdirSync(generated).some((file) => file.endsWith('Autolinking.mm'))
+        )
+          roots.push(root)
+        break
+      }
+      if (path.dirname(directory) === directory) break
+    }
+  }
+  return roots
+}
+
 /** collect installed native bodies, generated bridges, Nitro core and RN's
  * JSI without reading or rewriting package JavaScript. */
 export function collectNitroSources(options: NitroSourceOptions): NitroSourceCollection {
-  const module = packageInfo(options.packageRoot)
-  const config = registrations(module.root)
+  if (options.packageRoots.length === 0)
+    throw new Error('Nitro compilation needs at least one installed provider')
+  const providers = options.packageRoots
+    .map(packageInfo)
+    .sort((a, b) => a.name.localeCompare(b.name))
+  for (const [index, provider] of providers.entries())
+    if (providers.findIndex(({ name }) => name === provider.name) !== index)
+      throw new Error(`duplicate Nitro provider package ${provider.name}`)
+  const configs = providers.map((provider) => registrations(provider.root))
+  const names = new Map<string, string>()
+  for (const [index, config] of configs.entries())
+    for (const { name } of config.classes) {
+      const owner = names.get(name)
+      if (owner !== undefined)
+        throw new Error(
+          `Nitro HybridObject ${name} is registered by ${owner} and ${providers[index]!.name}`,
+        )
+      names.set(name, providers[index]!.name)
+    }
+  const swiftModules = new Map<string, string>()
+  for (const [index, config] of configs.entries()) {
+    if (config.swiftModule === null) continue
+    const owner = swiftModules.get(config.swiftModule)
+    if (owner !== undefined)
+      throw new Error(
+        `Nitro Swift module ${config.swiftModule} is declared by ${owner} and ${providers[index]!.name}`,
+      )
+    swiftModules.set(config.swiftModule, providers[index]!.name)
+  }
   let roots: NonNullable<NitroSourceOptions['dependencyRoots']>
   if (options.dependencyRoots !== undefined) {
     roots = options.dependencyRoots
@@ -143,7 +207,8 @@ export function collectNitroSources(options: NitroSourceOptions): NitroSourceCol
   if (nitro.name !== 'react-native-nitro-modules' || reactNative.name !== 'react-native')
     throw new Error('Nitro source dependency roots must identify Nitro Modules and RN')
 
-  const targetName = `NitroPackage_${createHash('sha256').update(module.name).digest('hex').slice(0, 16)}`
+  const providerTarget = (provider: NitroPackage) =>
+    `NitroPackage_${createHash('sha256').update(provider.name).digest('hex').slice(0, 16)}`
   const coreTarget = 'NitroCore'
   const jsiTarget = 'JsiBridge'
   const targetPath = (name: string) => `Sources/${name}`
@@ -164,13 +229,18 @@ export function collectNitroSources(options: NitroSourceOptions): NitroSourceCol
     targets: [
       target(jsiTarget, []),
       target(coreTarget, [jsiTarget]),
-      target(targetName, [coreTarget, jsiTarget]),
+      ...providers.map((provider) =>
+        target(providerTarget(provider), [coreTarget, jsiTarget]),
+      ),
     ],
-    registration: {
-      symbol: `peach_register_${targetName}`,
-      header: `${targetPath(targetName)}/include/PeachNitroRegistration.hpp`,
-    },
-    packages: [module, nitro, reactNative],
+    registrations: providers.map((provider) => ({
+      symbol: `peach_register_${providerTarget(provider)}`,
+      header: `${targetPath(providerTarget(provider))}/include/PeachNitroRegistration.hpp`,
+      target: providerTarget(provider),
+    })),
+    providers,
+    nitro,
+    reactNative,
     sources: [],
     aliases: {},
   }
@@ -271,20 +341,8 @@ export function collectNitroSources(options: NitroSourceOptions): NitroSourceCol
     (file) => (file.endsWith('.h') && file !== 'JSIDynamic.h') || file === 'jsi.cpp',
   )
   collect(nitro.root, 'cpp', coreTarget, 'NitroModules', new Set(['views']))
-  const implementationHeaders = fs.existsSync(path.join(module.root, 'cpp'))
-    ? collect(module.root, 'cpp', targetName, null)
-    : new Map<string, string>()
-  collect(module.root, 'nitrogen/generated/shared/c++', targetName, null)
-  for (const entry of config.classes)
-    if (
-      entry.language === 'c++' &&
-      !implementationHeaders.has(`${entry.implementation}.hpp`)
-    )
-      throw new Error(
-        `${module.root}: missing C++ implementation header ${entry.implementation}.hpp`,
-      )
 
-  if (config.swiftModule) {
+  if (swiftModules.size > 0) {
     for (const directory of ['ios/core', 'ios/utils'])
       collect(
         nitro.root,
@@ -296,9 +354,7 @@ export function collectNitroSources(options: NitroSourceOptions): NitroSourceCol
       )
     const nitroSwift = target('NitroModules', [coreTarget, jsiTarget])
     nitroSwift.cxxInterop = true
-    const packageSwift = target(config.swiftModule, [targetName, 'NitroModules'])
-    packageSwift.cxxInterop = true
-    result.targets.push(nitroSwift, packageSwift)
+    result.targets.push(nitroSwift)
     for (const directory of ['ios/core', 'ios/utils', 'ios/views'])
       collect(
         nitro.root,
@@ -313,29 +369,52 @@ export function collectNitroSources(options: NitroSourceOptions): NitroSourceCol
       `${targetPath('NitroModules')}/PeachNitroExports.swift`,
       `@_exported import ${coreTarget}\n`,
     )
-    collect(
-      module.root,
-      'ios',
-      config.swiftModule,
-      null,
-      new Set(['Tests']),
-      () => true,
-      /\.swift$/,
-    )
-    collect(
-      module.root,
-      'nitrogen/generated/ios',
-      config.swiftModule,
-      null,
-      new Set(),
-      () => true,
-      /\.swift$/,
-    )
-    collect(module.root, 'nitrogen/generated/ios', targetName, null)
-    add(
-      `${targetPath(config.swiftModule)}/PeachNitroExports.swift`,
-      `@_exported import ${targetName}\n`,
-    )
+  }
+
+  for (const [index, module] of providers.entries()) {
+    const config = configs[index]!
+    const targetName = providerTarget(module)
+    const implementationHeaders = fs.existsSync(path.join(module.root, 'cpp'))
+      ? collect(module.root, 'cpp', targetName, null)
+      : new Map<string, string>()
+    collect(module.root, 'nitrogen/generated/shared/c++', targetName, null)
+    for (const entry of config.classes)
+      if (
+        entry.language === 'c++' &&
+        !implementationHeaders.has(`${entry.implementation}.hpp`)
+      )
+        throw new Error(
+          `${module.root}: missing C++ implementation header ${entry.implementation}.hpp`,
+        )
+
+    if (config.swiftModule) {
+      const packageSwift = target(config.swiftModule, [targetName, 'NitroModules'])
+      packageSwift.cxxInterop = true
+      result.targets.push(packageSwift)
+      collect(
+        module.root,
+        'ios',
+        config.swiftModule,
+        null,
+        new Set(['Tests']),
+        () => true,
+        /\.swift$/,
+      )
+      collect(
+        module.root,
+        'nitrogen/generated/ios',
+        config.swiftModule,
+        null,
+        new Set(),
+        () => true,
+        /\.swift$/,
+      )
+      collect(module.root, 'nitrogen/generated/ios', targetName, null)
+      add(
+        `${targetPath(config.swiftModule)}/PeachNitroExports.swift`,
+        `@_exported import ${targetName}\n`,
+      )
+    }
   }
 
   // explicit module maps avoid importing every RN view or private JSI header.
@@ -345,50 +424,52 @@ export function collectNitroSources(options: NitroSourceOptions): NitroSourceCol
   )
   add(
     `${targetPath(coreTarget)}/include/module.modulemap`,
-    `module ${coreTarget} { header "NitroModules/InstallNitro.hpp"${config.swiftModule ? ['ArrayBufferHolder.hpp', 'AnyMapUtils.hpp', 'PromiseHolder.hpp', 'Result.hpp', 'RuntimeError.hpp', 'DateToChronoDate.hpp'].map((header) => ` header "NitroModules/${header}"`).join('') : ''} export * }\n`,
-  )
-  add(
-    result.registration.header,
-    `#pragma once\nextern "C" void ${result.registration.symbol}();\n`,
+    `module ${coreTarget} { header "NitroModules/InstallNitro.hpp"${swiftModules.size > 0 ? ['ArrayBufferHolder.hpp', 'AnyMapUtils.hpp', 'PromiseHolder.hpp', 'Result.hpp', 'RuntimeError.hpp', 'DateToChronoDate.hpp'].map((header) => ` header "NitroModules/${header}"`).join('') : ''} export * }\n`,
   )
-  add(
-    `${targetPath(targetName)}/include/module.modulemap`,
-    `module ${targetName} { header "PeachNitroRegistration.hpp"${config.swiftModule ? ` header "${config.swiftModule}-Swift-Cxx-Bridge.hpp"` : ''} export * }\n`,
-  )
-  add(
-    `${targetPath(targetName)}/PeachNitroRegistration.cpp`,
-    [
-      '#include "PeachNitroRegistration.hpp"',
-      '#include <NitroModules/HybridObjectRegistry.hpp>',
-      '#include <memory>',
-      '#include <type_traits>',
-      ...(config.swiftModule
-        ? [`#include "${config.swiftModule}-Swift-Cxx-Umbrella.hpp"`]
-        : []),
-      ...[
-        ...new Set(
-          config.classes
-            .filter((entry) => entry.language === 'c++')
-            .map(({ implementation }) => implementation),
-        ),
-      ].map((implementation) => `#include "${implementation}.hpp"`),
-      `extern "C" void ${result.registration.symbol}() {`,
-      ...config.classes.flatMap((entry) => [
-        ...(entry.language === 'c++'
-          ? [
-              `  static_assert(std::is_default_constructible_v<${config.namespace}::${entry.implementation}>);`,
-            ]
+  for (const [index, module] of providers.entries()) {
+    const config = configs[index]!
+    const targetName = providerTarget(module)
+    const registration = result.registrations[index]!
+    add(registration.header, `#pragma once\nextern "C" void ${registration.symbol}();\n`)
+    add(
+      `${targetPath(targetName)}/include/module.modulemap`,
+      `module ${targetName} { header "PeachNitroRegistration.hpp"${config.swiftModule ? ` header "${config.swiftModule}-Swift-Cxx-Bridge.hpp"` : ''} export * }\n`,
+    )
+    add(
+      `${targetPath(targetName)}/PeachNitroRegistration.cpp`,
+      [
+        '#include "PeachNitroRegistration.hpp"',
+        '#include <NitroModules/HybridObjectRegistry.hpp>',
+        '#include <memory>',
+        '#include <type_traits>',
+        ...(config.swiftModule
+          ? [`#include "${config.swiftModule}-Swift-Cxx-Umbrella.hpp"`]
           : []),
-        '  margelo::nitro::HybridObjectRegistry::registerHybridObjectConstructor(',
-        `    ${JSON.stringify(entry.name)}, []() -> std::shared_ptr<margelo::nitro::HybridObject> {`,
-        entry.language === 'swift'
-          ? `      return ${config.swiftModule}::${config.swiftModule}Autolinking::create${entry.name}();`
-          : `      return std::make_shared<${config.namespace}::${entry.implementation}>();`,
-        '    });',
-      ]),
-      '}',
-      '',
-    ].join('\n'),
-  )
+        ...[
+          ...new Set(
+            config.classes
+              .filter((entry) => entry.language === 'c++')
+              .map(({ implementation }) => implementation),
+          ),
+        ].map((implementation) => `#include "${implementation}.hpp"`),
+        `extern "C" void ${registration.symbol}() {`,
+        ...config.classes.flatMap((entry) => [
+          ...(entry.language === 'c++'
+            ? [
+                `  static_assert(std::is_default_constructible_v<${config.namespace}::${entry.implementation}>);`,
+              ]
+            : []),
+          '  margelo::nitro::HybridObjectRegistry::registerHybridObjectConstructor(',
+          `    ${JSON.stringify(entry.name)}, []() -> std::shared_ptr<margelo::nitro::HybridObject> {`,
+          entry.language === 'swift'
+            ? `      return ${config.swiftModule}::${config.swiftModule}Autolinking::create${entry.name}();`
+            : `      return std::make_shared<${config.namespace}::${entry.implementation}>();`,
+          '    });',
+        ]),
+        '}',
+        '',
+      ].join('\n'),
+    )
+  }
   return result
 }

package/src/nitroAdapterContract.ts

@@ -0,0 +1,217 @@
+// the prebuilt Nitro adapter archive's shapes and identity rules, shared by its
+// builder (packages/sootsim-swift/scripts/build-nitro-adapter-archive.ts), its
+// publisher (scripts/ops/nitro-adapter-publish.ts) and the installed CLI that
+// downloads and verifies it. nothing here reads adapter sources: an installed
+// CLI carries this file and checks an archive against the lock it was built with.
+import { createHash } from 'node:crypto'
+import { readdirSync, readFileSync } from 'node:fs'
+import path from 'node:path'
+import { isRecord } from './is-record'
+
+/** the file at the root of an unpacked adapter, and its install marker. */
+export const NITRO_ADAPTER_MANIFEST = 'manifest.json'
+export const NITRO_ADAPTER_ARCHIVE = 'libPeachNitroAdapter.a'
+
+// header staging the collector exposes: JSI without the dynamic and test
+// pieces, and Nitro's cpp tree without views, copied to bare and nested names.
+export const HEADER_STAGE = {
+  jsi: {
+    from: 'ReactCommon/jsi/jsi',
+    skip: ['test'],
+    keep: '\\.h$',
+    exclude: 'JSIDynamic.h',
+    to: 'jsi',
+  },
+  nitro: {
+    from: 'cpp',
+    skip: ['views'],
+    keep: '\\.(?:h|hpp|hxx|inl)$',
+    to: ['core', 'core/NitroModules'],
+  },
+}
+
+export interface NitroAdapterRoots {
+  nitroModules: string
+  reactNative: string
+}
+
+/** what the installed CLI needs to trust an archive; no private provenance. */
+export interface NitroAdapterManifest {
+  schema: 1
+  /** the guest platform the producer built for; every consumer matches it against the lock or its own recomputed identity. */
+  platform: string
+  target: string
+  recipe: string
+  adapter: { sha256: string }
+  headers: { reactNativeJsi: string; nitroModules: string }
+  compiler: string
+  sdk: { id: string; checksum: string }
+  framework: { distribution: string; wireAbi: string }
+  archive: { path: string; size: number; sha256: string }
+}
+
+/** the published tarball one CLI build installs, committed beside swift-distribution.lock.json. */
+export interface NitroAdapterLock extends Omit<NitroAdapterManifest, 'archive'> {
+  /** the downloaded .tar.gz, which installVerifiedTarball checks. */
+  archive: { sha256: string; size: number }
+}
+
+export const sha256Hex = (data: Uint8Array | string) =>
+  createHash('sha256').update(data).digest('hex')
+
+export function digest(entries: Record<string, string>) {
+  const hash = createHash('sha256')
+  for (const key of Object.keys(entries).sort()) hash.update(`${key}\0${entries[key]}\n`)
+  return hash.digest('hex')
+}
+
+function headerFiles(base: string, directory: string, skip: string[], keep: RegExp) {
+  const files: string[] = []
+  const walk = (relative: string) => {
+    for (const entry of readdirSync(path.join(base, relative), { withFileTypes: true })) {
+      if (entry.name.startsWith('.') || skip.includes(entry.name)) continue
+      const next = path.posix.join(relative, entry.name)
+      if (entry.isDirectory()) walk(next)
+      else if (keep.test(entry.name)) files.push(next)
+    }
+  }
+  walk(directory)
+  return files.sort()
+}
+
+/** the original header closures the collector exposes, with per-file hashes. */
+export function headerClosure(roots: NitroAdapterRoots) {
+  const { jsi: j, nitro: n } = HEADER_STAGE
+  const jsiFiles = headerFiles(
+    roots.reactNative,
+    j.from,
+    j.skip,
+    new RegExp(j.keep),
+  ).filter((file) => !file.endsWith(`/${j.exclude}`))
+  const nitroFiles = headerFiles(roots.nitroModules, n.from, n.skip, new RegExp(n.keep))
+  const hashes = (base: string, files: string[]) =>
+    Object.fromEntries(
+      files.map((file) => [file, sha256Hex(readFileSync(path.join(base, file)))]),
+    )
+  return {
+    jsi: hashes(roots.reactNative, jsiFiles),
+    nitro: hashes(roots.nitroModules, nitroFiles),
+    nitroFiles,
+    jsiFiles,
+  }
+}
+
+/** the digests an app's original React Native and Nitro headers must match. */
+export function headerDigests(roots: NitroAdapterRoots) {
+  const closure = headerClosure(roots)
+  return { reactNativeJsi: digest(closure.jsi), nitroModules: digest(closure.nitro) }
+}
+
+const hex64 = (value: unknown): value is string =>
+  typeof value === 'string' && /^[a-f0-9]{64}$/.test(value)
+
+function text(value: unknown, what: string): string {
+  if (typeof value !== 'string' || !value)
+    throw new Error(`invalid Nitro adapter ${what}`)
+  return value
+}
+
+function digestField(value: unknown, what: string): string {
+  if (!hex64(value)) throw new Error(`invalid Nitro adapter ${what}`)
+  return value
+}
+
+function identity(value: unknown) {
+  if (!isRecord(value) || value.schema !== 1)
+    throw new Error('invalid Nitro adapter manifest')
+  const { adapter, headers, sdk, framework } = value
+  if (!isRecord(adapter) || !isRecord(headers) || !isRecord(sdk) || !isRecord(framework))
+    throw new Error('invalid Nitro adapter manifest')
+  return {
+    schema: 1 as const,
+    platform: text(value.platform, 'platform'),
+    target: text(value.target, 'target'),
+    recipe: digestField(value.recipe, 'recipe'),
+    adapter: { sha256: digestField(adapter.sha256, 'adapter digest') },
+    headers: {
+      reactNativeJsi: digestField(headers.reactNativeJsi, 'JSI header digest'),
+      nitroModules: digestField(headers.nitroModules, 'Nitro header digest'),
+    },
+    compiler: text(value.compiler, 'compiler'),
+    sdk: {
+      id: text(sdk.id, 'sdk id'),
+      checksum: digestField(sdk.checksum, 'sdk checksum'),
+    },
+    framework: {
+      distribution: text(framework.distribution, 'distribution'),
+      wireAbi: digestField(framework.wireAbi, 'wire abi'),
+    },
+  }
+}
+
+/** keeps only the public fields, so a producer's private provenance never
+ *  reaches a packed manifest. */
+export function parseNitroAdapterManifest(value: unknown): NitroAdapterManifest {
+  const archive = isRecord(value) ? value.archive : undefined
+  if (
+    !isRecord(archive) ||
+    typeof archive.path !== 'string' ||
+    archive.path !== NITRO_ADAPTER_ARCHIVE ||
+    typeof archive.size !== 'number'
+  )
+    throw new Error('invalid Nitro adapter archive record')
+  return {
+    ...identity(value),
+    archive: {
+      path: archive.path,
+      size: archive.size,
+      sha256: digestField(archive.sha256, 'archive digest'),
+    },
+  }
+}
+
+export function parseNitroAdapterLock(value: unknown): NitroAdapterLock {
+  const archive = isRecord(value) ? value.archive : undefined
+  if (!isRecord(archive) || typeof archive.size !== 'number')
+    throw new Error('invalid Nitro adapter lock archive')
+  return {
+    ...identity(value),
+    archive: {
+      sha256: digestField(archive.sha256, 'lock archive digest'),
+      size: archive.size,
+    },
+  }
+}
+
+/** the lock one published manifest and its tarball produce. */
+export function nitroAdapterLock(
+  manifest: NitroAdapterManifest,
+  tarball: { sha256: string; size: number },
+): NitroAdapterLock {
+  const { archive: _library, ...rest } = manifest
+  return { ...rest, archive: tarball }
+}
+
+/** the tarball's path under PEACH_SWIFT_ENDPOINT: content addressed, so immutable. */
+export function nitroAdapterArchiveKey(lock: NitroAdapterLock): string {
+  return `nitro-adapter/${lock.archive.sha256}.tar.gz`
+}
+
+/** throws unless an unpacked adapter is the one the lock pins and its library
+ *  bytes are the ones its manifest records. needs no adapter source. */
+export function verifyInstalledNitroAdapter(
+  directory: string,
+  lock: NitroAdapterLock,
+): NitroAdapterManifest {
+  const manifest = parseNitroAdapterManifest(
+    JSON.parse(readFileSync(path.join(directory, NITRO_ADAPTER_MANIFEST), 'utf8')),
+  )
+  const { archive, ...recorded } = manifest
+  const { archive: _tarball, ...pinned } = lock
+  if (JSON.stringify(recorded) !== JSON.stringify(pinned))
+    throw new Error('Nitro adapter manifest does not match the lock this build carries')
+  const bytes = readFileSync(path.join(directory, archive.path))
+  if (bytes.length !== archive.size || sha256Hex(bytes) !== archive.sha256)
+    throw new Error('Nitro adapter library does not match its manifest')
+  return manifest
+}

package/src/nitroContract.ts

@@ -3,33 +3,46 @@ import {
   readBundleMetadataFooter,
 } from './bundleGlobalFooter'
 
+/** the guest platform every Nitro compile targets. */
+export const NITRO_GUEST_PLATFORM = 'ios'
+
 export interface NitroCompiledModule {
-  platform: 'ios'
-  packageName: string
-  packageVersion: string
+  platform: typeof NITRO_GUEST_PLATFORM
+  /** the original providers this one executable registers, by package name. */
+  packages: { name: string; version: string }[]
   url: string
   hash: string
   icuUrl: string
 }
 
+function readNitroPackage(
+  value: unknown,
+): NitroCompiledModule['packages'][number] | null {
+  if (typeof value !== 'object' || value === null) return null
+  const name = Reflect.get(value, 'name')
+  const version = Reflect.get(value, 'version')
+  return typeof name === 'string' && name && typeof version === 'string' && version
+    ? { name, version }
+    : null
+}
+
 export function readNitroMetadata(value: unknown): NitroCompiledModule | null {
   if (value === null || value === undefined) return null
   if (
     typeof value !== 'object' ||
     Array.isArray(value) ||
-    Reflect.get(value, 'platform') !== 'ios'
+    Reflect.get(value, 'platform') !== NITRO_GUEST_PLATFORM
   )
     throw new Error('invalid Nitro compilation metadata')
-  const packageName = Reflect.get(value, 'packageName')
-  const packageVersion = Reflect.get(value, 'packageVersion')
+  const listed = Reflect.get(value, 'packages')
+  const packages = Array.isArray(listed) ? listed.map(readNitroPackage) : []
   const url = Reflect.get(value, 'url')
   const hash = Reflect.get(value, 'hash')
   const icuUrl = Reflect.get(value, 'icuUrl')
   if (
-    typeof packageName !== 'string' ||
-    !packageName ||
-    typeof packageVersion !== 'string' ||
-    !packageVersion ||
+    packages.length === 0 ||
+    !packages.every((entry) => entry !== null) ||
+    new Set(packages.map(({ name }) => name)).size !== packages.length ||
     typeof url !== 'string' ||
     !url ||
     typeof hash !== 'string' ||
@@ -38,7 +51,7 @@ export function readNitroMetadata(value: unknown): NitroCompiledModule | null {
     !icuUrl
   )
     throw new Error('invalid Nitro compilation metadata')
-  return { platform: 'ios', packageName, packageVersion, url, hash, icuUrl }
+  return { platform: 'ios', packages, url, hash, icuUrl }
 }
 
 export function readNitroFooter(source: string): NitroCompiledModule | null {