peachsim 0.1.1644 → 0.1.1653

package/src/nitro-adapter.ts

@@ -0,0 +1,103 @@
+// the private Nitro adapter archive an installed peach links into every Nitro
+// compile: downloaded from PEACH_SWIFT_ENDPOINT, verified against the lock this
+// build carries, then checked against the app's own original headers and the
+// compiler, SDK and framework the module root compiles with
+// (docs/swift-distribution.md). the adapter source never reaches this machine.
+import fs from 'node:fs'
+import path from 'node:path'
+import { installVerifiedTarball } from '@contrast/runtime-delivery'
+import { rnxHomeDir } from './home-paths'
+import lockJson from './nitro-adapter.lock.json' with { type: 'json' }
+import {
+  headerDigests,
+  NITRO_ADAPTER_MANIFEST,
+  nitroAdapterArchiveKey,
+  parseNitroAdapterLock,
+  verifyInstalledNitroAdapter,
+  type NitroAdapterLock,
+  type NitroAdapterManifest,
+} from './nitroAdapterContract'
+import { NITRO_GUEST_PLATFORM } from './nitroContract'
+import { swiftDistributionAt, swiftModuleSdk, WASM_TRIPLE } from './swift-compile'
+import { SWIFT_ENDPOINT_ENV } from './swift-distribution'
+import type { NitroSourceCollection } from './nitro-source'
+
+/** the verified adapter this build ships, the only lock normal compiles use. */
+export const committedNitroAdapterLock = parseNitroAdapterLock(lockJson)
+
+export interface NitroAdapterArchive {
+  manifest: NitroAdapterManifest
+  /** the static archive, base64, as SwiftCompileInput.libraries carries it. */
+  base64: string
+}
+
+/** rejects a lock built for other guest platform, target, headers, compiler,
+ *  SDK or framework than this app's original headers and the module root
+ *  compiling it. the committed lock is the trust root and pins the whole
+ *  manifest. its wire ABI digest is producer provenance the reviewed lock
+ *  fixes; the consumer cannot recompute it and the framework distribution id
+ *  does not independently bind it. */
+function verifyIdentity(
+  lock: NitroAdapterLock,
+  collection: NitroSourceCollection,
+  moduleRoot: string,
+) {
+  const { nitro, reactNative } = collection
+  const distribution = swiftDistributionAt(moduleRoot)
+  if (!distribution) throw new Error(`${moduleRoot} holds no Swift distribution`)
+  const sdk = swiftModuleSdk(moduleRoot)
+  const headers = headerDigests({
+    nitroModules: nitro.root,
+    reactNative: reactNative.root,
+  })
+  const mismatched = [
+    lock.platform !== NITRO_GUEST_PLATFORM && 'guest platform',
+    lock.target !== WASM_TRIPLE && 'target',
+    lock.headers.reactNativeJsi !== headers.reactNativeJsi && 'React Native JSI headers',
+    lock.headers.nitroModules !== headers.nitroModules && 'Nitro Modules headers',
+    lock.compiler !== distribution.release && 'compiler',
+    (lock.sdk.id !== sdk.wasmSdkId || lock.sdk.checksum !== sdk.wasmSdkChecksum) &&
+      'Swift SDK',
+    lock.framework.distribution !== distribution.id && 'Swift distribution',
+  ].filter((name) => name !== false)
+  if (mismatched.length > 0)
+    throw new Error(
+      `Nitro adapter archive does not match this app and toolchain: ${mismatched.join(', ')}`,
+    )
+}
+
+/** the verified adapter archive for a collection: identity first, then the
+ *  download, whose tarball and unpacked bytes the lock pins. */
+export async function resolveNitroAdapter(
+  collection: NitroSourceCollection,
+  moduleRoot: string,
+  lock: NitroAdapterLock,
+  signal?: AbortSignal,
+): Promise<NitroAdapterArchive> {
+  verifyIdentity(lock, collection, moduleRoot)
+  const endpoint = process.env[SWIFT_ENDPOINT_ENV]?.trim().replace(/\/+$/, '')
+  if (!endpoint)
+    throw new Error(
+      `Nitro compilation needs ${SWIFT_ENDPOINT_ENV} for its adapter archive`,
+    )
+  const dir = path.join(rnxHomeDir(), 'swift', `nitro-adapter-${lock.archive.sha256}`)
+  if (!fs.existsSync(path.join(dir, NITRO_ADAPTER_MANIFEST))) {
+    process.stderr.write(`peach: downloading Nitro adapter ${lock.archive.sha256}…\n`)
+    await installVerifiedTarball({
+      signal,
+      url: `${endpoint}/${nitroAdapterArchiveKey(lock)}`,
+      digest: { algorithm: 'sha256', encoding: 'hex', value: lock.archive.sha256 },
+      destDir: dir,
+      installedMarker: NITRO_ADAPTER_MANIFEST,
+      label: 'Nitro adapter archive',
+      verify: (installed) => {
+        verifyInstalledNitroAdapter(installed, lock)
+      },
+    })
+  }
+  const manifest = verifyInstalledNitroAdapter(dir, lock)
+  return {
+    manifest,
+    base64: fs.readFileSync(path.join(dir, manifest.archive.path)).toString('base64'),
+  }
+}

package/src/nitro-bundle.ts

@@ -1,6 +1,7 @@
 import { compileNitroModule } from './nitro-compile'
+import { discoverNitroProviders } from './nitro-source'
+import { SWIFT_ENDPOINT_ENV, swiftDistributionRoot } from './swift-distribution'
 import { icuUrl } from './swift-host'
-import type { NitroSourceOptions } from './nitro-source'
 import type { NitroCompiledModule } from './nitroContract'
 
 export interface NitroBundle {
@@ -8,14 +9,28 @@ export interface NitroBundle {
   assets: { path: string; bytes: Buffer; contentType: string }[]
 }
 
-// the selected installed package uses the same compiler and asset addresses
-// as local native loads. package javascript is carried verbatim by its bundler.
+// every installed iOS Nitro provider the app declares compiles into one
+// executable with the same compiler and asset addresses as local native loads.
+// package javascript is carried verbatim by its bundler.
 export async function buildNitroBundle(
-  options: NitroSourceOptions & { moduleRoot: string },
-): Promise<NitroBundle> {
-  const { artifact, collection } = await compileNitroModule(options)
-  const implementation = collection.packages[0]
-  if (!implementation) throw new Error('Nitro compilation has no installed package')
+  appRoot: string,
+  moduleRoot?: string,
+): Promise<NitroBundle | null> {
+  const packageRoots = discoverNitroProviders(appRoot)
+  if (packageRoots.length === 0) return null
+  // the adapter archive is built against the published distribution, so Nitro
+  // compiles against it even in a source checkout; the checkout framework has
+  // no manifest for the adapter identity check to bind.
+  const module = moduleRoot ?? (await swiftDistributionRoot())
+  if (!module)
+    throw new Error(
+      `Nitro compilation needs ${SWIFT_ENDPOINT_ENV} for the Swift distribution`,
+    )
+  const { artifact, collection } = await compileNitroModule({
+    appRoot,
+    packageRoots,
+    moduleRoot: module,
+  })
   const assets: NitroBundle['assets'] = [
     {
       path: `__peach/swift/${artifact.hash}.wasm`,
@@ -32,8 +47,7 @@ export async function buildNitroBundle(
   return {
     metadata: {
       platform: 'ios',
-      packageName: implementation.name,
-      packageVersion: implementation.version,
+      packages: collection.providers.map(({ name, version }) => ({ name, version })),
       url: `/__peach/swift/${artifact.hash}.wasm`,
       hash: artifact.hash,
       icuUrl: icuUrl('', artifact),

package/src/nitro-compile.ts

@@ -2,6 +2,11 @@ import { createHash } from 'node:crypto'
 import fs from 'node:fs'
 import os from 'node:os'
 import path from 'node:path'
+import {
+  committedNitroAdapterLock,
+  resolveNitroAdapter,
+  type NitroAdapterArchive,
+} from './nitro-adapter'
 import {
   collectNitroSources,
   type NitroSourceCollection,
@@ -9,59 +14,31 @@ import {
 } from './nitro-source'
 import { syncSwiftTree } from './swift-compile'
 import { artifactFor, projectFor, type SwiftArtifact } from './swift-host'
-import { readPackageFile } from './swift-source-file'
-import { MAX_SWIFT_COMPILE_SOURCE_BYTES } from './swift-submit'
 import type { SwiftCompileInput } from './swift-compile'
 
-// installed implementations, generated registration and the real runtime form
-// one executable. the common Swift compiler owns linking and artifact reuse.
+// every selected installed implementation, its generated registration and the
+// verified adapter archive form one executable. the archive carries the private
+// adapter objects and links into NitroCore; the common Swift compiler owns
+// linking and reuse.
 export function collectNitroCompileInput(
-  options: NitroSourceOptions & { moduleRoot: string },
-): { input: SwiftCompileInput; collection: NitroSourceCollection } {
-  const collection = collectNitroSources(options)
+  collection: NitroSourceCollection,
+  adapter: NitroAdapterArchive,
+): SwiftCompileInput {
   const files = { ...collection.files }
-  const platform = path.join(options.moduleRoot, 'platform/react-native-nitro-modules')
-  const read = (file: string) =>
-    readPackageFile(
-      platform,
-      path.join(platform, file),
-      MAX_SWIFT_COMPILE_SOURCE_BYTES,
-    ).toString('utf8')
-  for (const file of [
-    'platform/ThreadUtils.cpp',
-    'platform/NitroLogger.cpp',
-    'threading/UIThreadDispatcher.cpp',
-    'threading/UIThreadDispatcher.hpp',
-  ]) {
-    files[`Sources/NitroCore/peach/${file}`] = read(file)
-  }
-  files['Sources/NitroCore/include/UIThreadDispatcher.hpp'] =
-    '#include "../peach/threading/UIThreadDispatcher.hpp"\n'
-
-  const runtime = 'PeachNitroRuntime'
-  for (const file of [
-    'ProxyRuntime.cpp',
-    'RuntimeEntry.cpp',
-    'HostImports.hpp',
-    'ProxyRuntime.hpp',
-    'RuntimeEntry.hpp',
-  ]) {
-    const relative = file.endsWith('.hpp') ? `include/${file}` : file
-    files[`Sources/${runtime}/${relative}`] = read(`jsi/${file}`)
-  }
-  files[`Sources/${runtime}/include/PeachNitroEntry.hpp`] =
+  // the archive has no module, so NitroCore's module map declares its entry.
+  files['Sources/NitroCore/include/PeachNitroEntry.hpp'] =
     '#pragma once\nextern "C" void peachNitroInitialize();\n'
-  files[`Sources/${runtime}/include/module.modulemap`] =
-    `module ${runtime} { header "PeachNitroEntry.hpp" export * }\n`
+  const core = files['Sources/NitroCore/include/module.modulemap']
+  if (!core?.endsWith(' export * }\n'))
+    throw new Error('Nitro collection has no NitroCore module map')
+  files['Sources/NitroCore/include/module.modulemap'] =
+    `${core.slice(0, -' export * }\n'.length)} header "PeachNitroEntry.hpp" export * }\n`
 
-  const implementation = collection.targets.find((target) =>
-    collection.registration.header.startsWith(`${target.path}/`),
-  )
-  if (!implementation) throw new Error('Nitro registration has no package target')
   const entry = 'Sources/PeachNitroApp/main.swift'
+  // every provider registers before the one runtime serves guest evaluation.
   files[entry] =
-    `import ${runtime}\nimport ${implementation.name}\n` +
-    `peachNitroInitialize()\n${collection.registration.symbol}()\n`
+    `import NitroCore\n${collection.registrations.map(({ target }) => `import ${target}\n`).join('')}` +
+    `peachNitroInitialize()\n${collection.registrations.map(({ symbol }) => `${symbol}()\n`).join('')}`
   files['Package.swift'] = [
     '// swift-tools-version: 6.2',
     'import PackageDescription',
@@ -70,20 +47,23 @@ export function collectNitroCompileInput(
       (target) =>
         `.target(name: ${JSON.stringify(target.name)}, dependencies: ${JSON.stringify(target.dependencies?.map((dependency) => dependency.name) ?? [])}, path: ${JSON.stringify(target.path)}, ${target.cxxInterop ? 'swiftSettings: [.interoperabilityMode(.Cxx)]' : 'cxxSettings: [.define("DEBUG")]'}),`,
     ),
-    `.target(name: "${runtime}", dependencies: ["JsiBridge", "NitroCore"], cxxSettings: [.define("DEBUG")]),`,
-    `.executableTarget(name: "PeachNitroApp", dependencies: ["${runtime}", "${implementation.name}"], swiftSettings: [.interoperabilityMode(.Cxx)]),`,
+    `.executableTarget(name: "PeachNitroApp", dependencies: ${JSON.stringify(collection.registrations.map(({ target }) => target))}, swiftSettings: [.interoperabilityMode(.Cxx)]),`,
     '], cxxLanguageStandard: .cxx20)',
     '',
   ].join('\n')
-  return { input: { files, entry }, collection }
+  return { files, entry, libraries: { NitroCore: adapter.base64 } }
 }
 
 export async function compileNitroModule(
   options: NitroSourceOptions & { moduleRoot: string },
 ): Promise<{ artifact: SwiftArtifact; collection: NitroSourceCollection }> {
-  const { input, collection } = collectNitroCompileInput(options)
+  const collection = collectNitroSources(options)
+  const input = collectNitroCompileInput(
+    collection,
+    await resolveNitroAdapter(collection, options.moduleRoot, committedNitroAdapterLock),
+  )
   const key = createHash('sha256')
-    .update(fs.realpathSync(options.packageRoot))
+    .update(collection.providers.map(({ root }) => root).join('\0'))
     .update('\0')
     .update(fs.realpathSync(options.moduleRoot))
     .digest('hex')
@@ -97,8 +77,10 @@ export async function compileNitroModule(
       ]),
     ),
   )
+  const project = projectFor(packagePath)
+  project.libraries = input.libraries
   return {
-    artifact: await artifactFor(projectFor(packagePath), input.entry, options.moduleRoot),
+    artifact: await artifactFor(project, input.entry, options.moduleRoot),
     collection,
   }
 }

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
 }