rnxsim 0.1.524 → 0.1.526

package/dist-lib/vite.cjs

@@ -1,4 +1,4 @@
-/*! rnx v0.1.524 | (c) 2026 Tamagui LLC | Proprietary — see LICENSE */
+/*! rnx v0.1.526 | (c) 2026 Tamagui LLC | Proprietary — see LICENSE */
 let __sootsim_import_meta_url = ''; try { __sootsim_import_meta_url = require('url').pathToFileURL(__filename).href; } catch {}
 "use strict";
 var __create = Object.create;
@@ -35,7 +35,8 @@ __export(vite_plugin_one_exports, {
   default: () => vite_plugin_one_default,
   rnxPlugin: () => rnxPlugin,
   sootsimPlugin: () => sootsimPlugin,
-  swiftPlugin: () => swiftPlugin
+  swiftPlugin: () => swiftPlugin,
+  swiftRemotePlugin: () => swiftRemotePlugin
 });
 module.exports = __toCommonJS(vite_plugin_one_exports);
 var import_fs2 = __toESM(require("fs"), 1);
@@ -796,13 +797,13 @@ function imagesetName(contentsPath) {
   if (!leaf.endsWith(".imageset")) return null;
   return leaf.slice(0, -".imageset".length) || null;
 }
-function isFlatResourceImage(path7) {
-  return path7.split("/").includes("Resources") && RASTER_EXTENSIONS.has(extOf(path7));
+function isFlatResourceImage(path8) {
+  return path8.split("/").includes("Resources") && RASTER_EXTENSIONS.has(extOf(path8));
 }
 function enumerateBundleImages(paths, readText) {
   const table = [];
   const seen = /* @__PURE__ */ new Set();
-  const catalogs = paths.filter((path7) => baseOf(path7) === "Contents.json");
+  const catalogs = paths.filter((path8) => baseOf(path8) === "Contents.json");
   for (const contentsPath of catalogs) {
     const name = imagesetName(contentsPath);
     if (name === null || seen.has(name)) continue;
@@ -822,15 +823,33 @@ function enumerateBundleImages(paths, readText) {
     seen.add(name);
     table.push({ name, file: `${dir}/${file}` });
   }
-  for (const path7 of paths) {
-    if (!isFlatResourceImage(path7)) continue;
-    const name = baseOf(path7).slice(0, -extOf(path7).length);
+  for (const path8 of paths) {
+    if (!isFlatResourceImage(path8)) continue;
+    const name = baseOf(path8).slice(0, -extOf(path8).length);
     if (name === "" || seen.has(name)) continue;
     seen.add(name);
-    table.push({ name, file: path7 });
+    table.push({ name, file: path8 });
   }
   return table;
 }
+function enumerateBundleJson(paths) {
+  const found = [];
+  const seen = /* @__PURE__ */ new Set();
+  const ordered = [...paths].filter(
+    (path8) => path8.split("/").includes("Resources") && path8.split("/").every((segment) => segment !== "" && segment !== "..") && extOf(path8) === ".json"
+  ).sort((a, b) => {
+    const aDepth = a.split("/").length;
+    const bDepth = b.split("/").length;
+    return aDepth - bDepth || (a < b ? -1 : a > b ? 1 : 0);
+  });
+  for (const file of ordered) {
+    const base = baseOf(file);
+    if (seen.has(base)) continue;
+    seen.add(base);
+    found.push({ base, file });
+  }
+  return found;
+}
 
 // ../sootsim-swift/toolchain.json
 var toolchain_default = {
@@ -944,6 +963,40 @@ function buildSwiftResourceTable(project, baseUrl) {
   project.resourceFiles = registered;
   return { table, watched };
 }
+var BUNDLE_MAX_FILES = 128;
+var BUNDLE_MAX_FILE_BYTES = 2 * 1024 * 1024;
+var BUNDLE_MAX_TOTAL_BYTES = 8 * 1024 * 1024;
+function buildSwiftBundleFiles(packagePath) {
+  const relative2 = resourceCandidateFiles(packagePath).map(
+    (file) => import_node_path4.default.relative(packagePath, file).split(import_node_path4.default.sep).join(import_node_path4.default.posix.sep)
+  );
+  const files = {};
+  const watched = [];
+  const skipped = [];
+  let total = 0;
+  for (const { base, file } of enumerateBundleJson(relative2)) {
+    watched.push(file);
+    let bytes;
+    try {
+      bytes = import_node_fs3.default.readFileSync(import_node_path4.default.join(packagePath, ...file.split("/")));
+    } catch {
+      continue;
+    }
+    if (bytes.length > BUNDLE_MAX_FILE_BYTES) {
+      skipped.push(`${file} (${bytes.length} bytes past the per-file cap)`);
+      continue;
+    }
+    if (Object.keys(files).length >= BUNDLE_MAX_FILES || total + bytes.length > BUNDLE_MAX_TOTAL_BYTES) {
+      skipped.push(
+        `${file} (pack caps: ${BUNDLE_MAX_FILES} files / ${BUNDLE_MAX_TOTAL_BYTES} bytes)`
+      );
+      continue;
+    }
+    files[base] = bytes.toString("base64");
+    total += bytes.length;
+  }
+  return { files, watched, skipped };
+}
 function serveSwiftResource(project, key) {
   const disk = project.resourceFiles.get(key);
   if (!disk) return null;
@@ -1127,9 +1180,26 @@ function swiftPlugin(options = {}) {
           `swift resources for ${packagePath}: ${error instanceof Error ? error.message : String(error)}`
         );
       }
+      let bundleFiles = {};
+      try {
+        const packed = buildSwiftBundleFiles(packagePath);
+        bundleFiles = packed.files;
+        for (const watched of packed.watched) {
+          this.addWatchFile(import_node_path4.default.join(packagePath, ...watched.split(import_node_path4.default.posix.sep)));
+        }
+        if (packed.skipped.length > 0) {
+          this.warn(
+            `swift bundle files skipped for ${packagePath}: ${packed.skipped.join("; ")}`
+          );
+        }
+      } catch (error) {
+        this.warn(
+          `swift bundle files for ${packagePath}: ${error instanceof Error ? error.message : String(error)}`
+        );
+      }
       return [
         `import { createSwiftEntry } from 'rnxsim/swift'`,
-        `export default createSwiftEntry({ url: ${JSON.stringify(artifactUrl(project, artifact))}, hash: ${JSON.stringify(artifact.hash)}, rootId: ${JSON.stringify(entryRootId(packagePath, file))}, resources: ${JSON.stringify(resources)} })`,
+        `export default createSwiftEntry({ url: ${JSON.stringify(artifactUrl(project, artifact))}, hash: ${JSON.stringify(artifact.hash)}, rootId: ${JSON.stringify(entryRootId(packagePath, file))}, resources: ${JSON.stringify(resources)}, bundleFiles: ${JSON.stringify(bundleFiles)} })`,
         ""
       ].join("\n");
     },
@@ -1171,6 +1241,204 @@ function swiftPlugin(options = {}) {
   };
 }
 
+// src/rolldown-plugin-swift.ts
+var import_node_fs4 = __toESM(require("node:fs"), 1);
+var import_node_path5 = __toESM(require("node:path"), 1);
+
+// src/swift-submit.ts
+var SWIFT_COMPILE_PATH = "/api/swift-compile";
+var POLL_INTERVAL_MS = 1500;
+function httpSwiftCompileSubmit(context) {
+  const { assetReadToken, endpoint } = context;
+  if (!assetReadToken) return void 0;
+  const url = endpoint ? `${endpoint.replace(/\/+$/, "")}${SWIFT_COMPILE_PATH}` : SWIFT_COMPILE_PATH;
+  return async (work) => {
+    let response;
+    try {
+      response = await fetch(url, {
+        method: "POST",
+        headers: { "content-type": "application/json" },
+        body: JSON.stringify({ ...work, token: assetReadToken })
+      });
+    } catch (error) {
+      throw new Error(
+        `contrast-bundler: fetch failed for ${url} while compiling ${work.entry}: ${error instanceof Error ? error.message : String(error)}`,
+        { cause: error }
+      );
+    }
+    if (!response.ok) {
+      const detail = (await response.text()).trim();
+      throw new Error(
+        `contrast-bundler: the swift compile for ${work.entry} answered ${response.status}${detail ? `: ${detail}` : ""}`
+      );
+    }
+    return await response.json();
+  };
+}
+function resolveImageUrls(urls, origin) {
+  const resolved = {};
+  for (const [name, url] of Object.entries(urls)) {
+    resolved[name] = new URL(url, origin).href;
+  }
+  return resolved;
+}
+async function compileSwiftProject(submit, work, origin) {
+  while (true) {
+    const outcome = await submit(work);
+    switch (outcome.status) {
+      case "published":
+        return {
+          url: new URL(outcome.artifactUrl, origin).href,
+          hash: outcome.hash,
+          ...outcome.imageUrls === void 0 ? {} : { imageUrls: resolveImageUrls(outcome.imageUrls, origin) }
+        };
+      case "compiling":
+        await new Promise((resolve2) => setTimeout(resolve2, POLL_INTERVAL_MS));
+        continue;
+      case "refused":
+      case "failed":
+        throw new Error(
+          `contrast-bundler: the swift sources for ${work.entry} cannot be compiled: ${outcome.detail}`
+        );
+    }
+  }
+}
+
+// src/rolldown-plugin-swift.ts
+var VIRTUAL_PREFIX2 = "\0rnx-swift-remote:";
+var projects2 = /* @__PURE__ */ new Map();
+function projectFor2(packagePath) {
+  const existing = projects2.get(packagePath);
+  if (existing) return existing;
+  const created = { packagePath, address: null };
+  projects2.set(packagePath, created);
+  return created;
+}
+function packageFiles(root) {
+  const found = [];
+  const walk = (dir) => {
+    for (const entry of import_node_fs4.default.readdirSync(dir, { withFileTypes: true })) {
+      if (entry.name.startsWith(".") || entry.name === "node_modules" || entry.name === ".build")
+        continue;
+      const full = import_node_path5.default.join(dir, entry.name);
+      if (entry.isDirectory()) {
+        if (full !== root && import_node_fs4.default.existsSync(import_node_path5.default.join(full, "Package.swift"))) continue;
+        walk(full);
+      } else {
+        found.push(import_node_path5.default.relative(root, full).split(import_node_path5.default.sep).join(import_node_path5.default.posix.sep));
+      }
+    }
+  };
+  walk(root);
+  return found;
+}
+function sourceFiles2(packagePath) {
+  const files = {};
+  for (const relative2 of packageFiles(packagePath)) {
+    if (!relative2.endsWith(".swift")) continue;
+    files[relative2] = import_node_fs4.default.readFileSync(
+      import_node_path5.default.join(packagePath, ...relative2.split("/")),
+      "utf8"
+    );
+  }
+  return files;
+}
+function bundlePack(packagePath) {
+  const relative2 = packageFiles(packagePath);
+  const disk = (file) => import_node_path5.default.join(packagePath, ...file.split("/"));
+  const resources = {};
+  const watched = [];
+  for (const { base, file } of enumerateBundleJson(relative2)) {
+    resources[base] = import_node_fs4.default.readFileSync(disk(file)).toString("base64");
+    watched.push(file);
+  }
+  const images = {};
+  const byRelative = new Map(relative2.map((file) => [file, disk(file)]));
+  for (const { name, file } of enumerateBundleImages(relative2, (candidate) => {
+    const absolute = byRelative.get(candidate);
+    if (!absolute || import_node_path5.default.basename(absolute) !== "Contents.json") return null;
+    try {
+      return import_node_fs4.default.readFileSync(absolute, "utf8");
+    } catch {
+      return null;
+    }
+  })) {
+    const absolute = byRelative.get(file);
+    if (!absolute) continue;
+    images[name] = {
+      file: import_node_path5.default.posix.basename(file),
+      data: import_node_fs4.default.readFileSync(absolute).toString("base64")
+    };
+    watched.push(file);
+  }
+  return { resources, images, watched };
+}
+function packageFor2(file, stop) {
+  let dir = import_node_path5.default.dirname(file);
+  for (; ; ) {
+    if (import_node_fs4.default.existsSync(import_node_path5.default.join(dir, "Package.swift"))) return dir;
+    if (stop !== void 0 && dir === stop || import_node_path5.default.dirname(dir) === dir) break;
+    dir = import_node_path5.default.dirname(dir);
+  }
+  throw new Error(
+    `no Package.swift above ${file}; a .swift import needs a swiftpm package like the one in packages/sootsim-swift/example`
+  );
+}
+function swiftRemotePlugin(options) {
+  const submit = httpSwiftCompileSubmit({
+    assetReadToken: options.assetReadToken,
+    endpoint: options.endpoint
+  });
+  if (!submit) {
+    throw new Error(
+      "swiftRemotePlugin needs an assetReadToken: a build without a compile credential cannot compile .swift sources"
+    );
+  }
+  return {
+    name: "rnx-swift-remote",
+    enforce: "pre",
+    async resolveId(source, importer) {
+      if (source.startsWith(VIRTUAL_PREFIX2)) return source;
+      if (!source.endsWith(".swift")) return null;
+      const resolved = await this.resolve(source, importer, { skipSelf: true });
+      if (!resolved) throw new Error(`cannot resolve swift source ${source}`);
+      return VIRTUAL_PREFIX2 + resolved.id;
+    },
+    async load(id) {
+      if (!id.startsWith(VIRTUAL_PREFIX2)) return null;
+      const file = id.slice(VIRTUAL_PREFIX2.length);
+      if (!import_node_fs4.default.existsSync(file)) throw new Error(`swift source ${file} no longer exists`);
+      const packagePath = options.packagePath ?? packageFor2(file);
+      const project = projectFor2(packagePath);
+      const files = sourceFiles2(packagePath);
+      const entry = import_node_path5.default.relative(packagePath, file).split(import_node_path5.default.sep).join(import_node_path5.default.posix.sep);
+      for (const source of Object.keys(files)) {
+        this.addWatchFile(import_node_path5.default.join(packagePath, ...source.split("/")));
+      }
+      const pack = bundlePack(packagePath);
+      for (const watched of pack.watched) {
+        this.addWatchFile(import_node_path5.default.join(packagePath, ...watched.split("/")));
+      }
+      try {
+        project.address = await compileSwiftProject(
+          submit,
+          { files, resources: pack.resources, images: pack.images, entry },
+          options.endpoint
+        );
+      } catch (error) {
+        if (!project.address) throw error;
+        this.warn(error instanceof Error ? error.message : String(error));
+      }
+      const address = project.address;
+      return [
+        `import { createSwiftEntry } from 'rnxsim/swift'`,
+        `export default createSwiftEntry({ url: ${JSON.stringify(address.url)}, hash: ${JSON.stringify(address.hash)}, rootId: ${JSON.stringify(entryRootId(packagePath, file))}, resources: ${JSON.stringify(address.imageUrls ?? {})}, bundleFiles: ${JSON.stringify(pack.resources)} })`,
+        ""
+      ].join("\n");
+    }
+  };
+}
+
 // src/vite-plugin-one.ts
 function rnxPlugin(options = {}) {
   const prefix = options.prefix || "/__soot";
@@ -1318,5 +1586,6 @@ var vite_plugin_one_default = rnxPlugin;
 0 && (module.exports = {
   rnxPlugin,
   sootsimPlugin,
-  swiftPlugin
+  swiftPlugin,
+  swiftRemotePlugin
 });

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "rnxsim",
-  "version": "0.1.524",
+  "version": "0.1.526",
   "description": "Vite and Metro plugins, testing drivers, and SDK exports for rnx.",
   "author": "Tamagui LLC",
   "license": "SEE LICENSE IN LICENSE",
@@ -39,6 +39,13 @@
       "source": "./src/swift.ts",
       "default": "./dist-lib/swift.cjs"
     },
+    "./swift-submit": {
+      "types": "./src/swift-submit.ts",
+      "source": "./src/swift-submit.ts",
+      "bun": "./src/swift-submit.ts",
+      "import": "./dist-lib/swift-submit.mjs",
+      "default": "./dist-lib/swift-submit.cjs"
+    },
     "./metro": {
       "source": "./src/metro-plugin.ts",
       "default": "./dist-lib/metro.cjs"

package/src/rolldown-plugin-swift.ts

@@ -0,0 +1,240 @@
+// `.swift` handling for One's native rolldown engine: submit the owning
+// swiftpm package to `/api/swift-compile` and answer every `.swift` import
+// with the module that mounts the published artifact.
+//
+// this is the remote twin of `vite-plugin-swift.ts`. that plugin runs the
+// local toolchain and serves the artifact from dev-server middleware; the
+// native engine is its own rolldown instance with no middleware seam, so
+// this plugin compiles nothing in-process and serves nothing. the artifact
+// url the service answers is absolute (compile-cdn), so there is nothing to
+// serve. same compiler, same store, same hash, same credential as the
+// browser worker — one path, no second toolchain to install for `one dev`.
+//
+// an app registers it through One's native plugin seam, not `config.plugins`
+// (which never reach the native engine):
+//
+//   // vite.config.ts
+//   export default {
+//     plugins: [one({
+//       native: {
+//         bundler: 'vite',
+//         bundlerOptions: {
+//           plugins: [swiftRemotePlugin({
+//             endpoint: 'https://contrast.dev',
+//             assetReadToken: process.env.CONTRAST_CCDN_KEY,
+//           })],
+//         },
+//       },
+//     })],
+//   }
+//
+// no babel anywhere in this path: resolveId and load only, emitting an ESM
+// module. offline `one dev` fails loud at the submit, the same as a browser
+// build without a credential; the standalone `rnx` CLI keeps the local
+// toolchain plugin for that case.
+
+import fs from 'node:fs'
+import path from 'node:path'
+import {
+  enumerateBundleImages,
+  enumerateBundleJson,
+} from '../../sootsim-swift/src/bundleAssets'
+import { compileSwiftProject, httpSwiftCompileSubmit } from './swift-submit'
+import { entryRootId } from './vite-plugin-swift'
+import type { SwiftModuleAddress } from './swift-submit'
+import type { Plugin } from 'vite'
+
+const VIRTUAL_PREFIX = '\0rnx-swift-remote:'
+
+export interface SwiftRemotePluginOptions {
+  /** origin serving `/api/swift-compile` (the Contrast app). */
+  endpoint: string
+  /** a `ccdn_` API key or dev session token the compile verifier accepts. */
+  assetReadToken: string
+  /**
+   * directory uploaded `.swift` imports resolve under. defaults to the
+   * nearest `Package.swift` above each imported file — the swiftpm package
+   * that owns it — which is the compile unit, exactly like the local host.
+   * an app that keeps sources somewhere else names that package explicitly.
+   */
+  packagePath?: string
+}
+
+interface RemoteProject {
+  packagePath: string
+  address: SwiftModuleAddress | null
+}
+
+// one address per package per process: a failed submit keeps serving the
+// last published artifact (and warns) rather than failing the module, so
+// the edit that fixes the error still has a graph to rebuild.
+const projects = new Map<string, RemoteProject>()
+
+function projectFor(packagePath: string): RemoteProject {
+  const existing = projects.get(packagePath)
+  if (existing) return existing
+  const created: RemoteProject = { packagePath, address: null }
+  projects.set(packagePath, created)
+  return created
+}
+
+// every file under a directory, posix-relative, skipping what can never be
+// a source, a manifest, or bundle content. a nested Package.swift is a
+// separate package with its own compile: its files belong to that unit.
+// `.build` holds tens of thousands of intermediates and no bundle content;
+// walking it per import would tax every reload.
+function packageFiles(root: string): string[] {
+  const found: string[] = []
+  const walk = (dir: string): void => {
+    for (const entry of fs.readdirSync(dir, { withFileTypes: true })) {
+      if (
+        entry.name.startsWith('.') ||
+        entry.name === 'node_modules' ||
+        entry.name === '.build'
+      )
+        continue
+      const full = path.join(dir, entry.name)
+      if (entry.isDirectory()) {
+        if (full !== root && fs.existsSync(path.join(full, 'Package.swift'))) continue
+        walk(full)
+      } else {
+        found.push(path.relative(root, full).split(path.sep).join(path.posix.sep))
+      }
+    }
+  }
+  walk(root)
+  return found
+}
+
+// the file map the service compiles: the package's `.swift` sources plus
+// its root manifest, keyed package-relative. the manifest is partitioning
+// input only — the service emits its own manifest that links every target
+// against its SwiftUI module — so a standard local package travels as is.
+function sourceFiles(packagePath: string): Record<string, string> {
+  const files: Record<string, string> = {}
+  for (const relative of packageFiles(packagePath)) {
+    if (!relative.endsWith('.swift')) continue
+    files[relative] = fs.readFileSync(
+      path.join(packagePath, ...relative.split('/')),
+      'utf8',
+    )
+  }
+  return files
+}
+
+// the bundle pack and the photo uploads, through the shared enumeration
+// both hosts pack with, so the collision winner here is the winner on the
+// local host too. binary bytes straight from disk: this host is node.
+function bundlePack(packagePath: string): {
+  resources: Record<string, string>
+  images: Record<string, { file: string; data: string }>
+  watched: string[]
+} {
+  const relative = packageFiles(packagePath)
+  const disk = (file: string): string => path.join(packagePath, ...file.split('/'))
+  const resources: Record<string, string> = {}
+  const watched: string[] = []
+  for (const { base, file } of enumerateBundleJson(relative)) {
+    resources[base] = fs.readFileSync(disk(file)).toString('base64')
+    watched.push(file)
+  }
+  const images: Record<string, { file: string; data: string }> = {}
+  const byRelative = new Map(relative.map((file) => [file, disk(file)]))
+  for (const { name, file } of enumerateBundleImages(relative, (candidate) => {
+    const absolute = byRelative.get(candidate)
+    if (!absolute || path.basename(absolute) !== 'Contents.json') return null
+    try {
+      return fs.readFileSync(absolute, 'utf8')
+    } catch {
+      return null
+    }
+  })) {
+    const absolute = byRelative.get(file)
+    if (!absolute) continue
+    images[name] = {
+      file: path.posix.basename(file),
+      data: fs.readFileSync(absolute).toString('base64'),
+    }
+    watched.push(file)
+  }
+  return { resources, images, watched }
+}
+
+// the swiftpm package that owns an imported file: the nearest directory at
+// or above the file that holds a Package.swift. a `.swift` file with no
+// package above it (a pod, an xcode target) is refused loud rather than
+// compiled as the wrong unit.
+function packageFor(file: string, stop?: string): string {
+  let dir = path.dirname(file)
+  for (;;) {
+    if (fs.existsSync(path.join(dir, 'Package.swift'))) return dir
+    if ((stop !== undefined && dir === stop) || path.dirname(dir) === dir) break
+    dir = path.dirname(dir)
+  }
+  throw new Error(
+    `no Package.swift above ${file}; a .swift import needs a swiftpm package like the one in packages/sootsim-swift/example`,
+  )
+}
+
+export function swiftRemotePlugin(options: SwiftRemotePluginOptions): Plugin {
+  const submit = httpSwiftCompileSubmit({
+    assetReadToken: options.assetReadToken,
+    endpoint: options.endpoint,
+  })
+  if (!submit) {
+    throw new Error(
+      'swiftRemotePlugin needs an assetReadToken: a build without a compile credential cannot compile .swift sources',
+    )
+  }
+  return {
+    name: 'rnx-swift-remote',
+    enforce: 'pre',
+
+    async resolveId(source, importer) {
+      if (source.startsWith(VIRTUAL_PREFIX)) return source
+      if (!source.endsWith('.swift')) return null
+      const resolved = await this.resolve(source, importer, { skipSelf: true })
+      if (!resolved) throw new Error(`cannot resolve swift source ${source}`)
+      return VIRTUAL_PREFIX + resolved.id
+    },
+
+    async load(id) {
+      if (!id.startsWith(VIRTUAL_PREFIX)) return null
+      const file = id.slice(VIRTUAL_PREFIX.length)
+      if (!fs.existsSync(file)) throw new Error(`swift source ${file} no longer exists`)
+      const packagePath = options.packagePath ?? packageFor(file)
+      const project = projectFor(packagePath)
+      const files = sourceFiles(packagePath)
+      const entry = path.relative(packagePath, file).split(path.sep).join(path.posix.sep)
+      for (const source of Object.keys(files)) {
+        this.addWatchFile(path.join(packagePath, ...source.split('/')))
+      }
+      const pack = bundlePack(packagePath)
+      for (const watched of pack.watched) {
+        this.addWatchFile(path.join(packagePath, ...watched.split('/')))
+      }
+      try {
+        project.address = await compileSwiftProject(
+          submit,
+          { files, resources: pack.resources, images: pack.images, entry },
+          options.endpoint,
+        )
+      } catch (error) {
+        // a compile error must not fail this module: the graph would stop
+        // watching it and the fix would never rebuild. the last published
+        // artifact keeps rendering while the diagnostic is reported here.
+        if (!project.address) throw error
+        this.warn(error instanceof Error ? error.message : String(error))
+      }
+      const address = project.address
+      // every import mounts through the one entry: the artifact answers
+      // whether it is a view or an app root at runtime, so the transform
+      // never re-derives the conformance from source.
+      return [
+        `import { createSwiftEntry } from 'rnxsim/swift'`,
+        `export default createSwiftEntry({ url: ${JSON.stringify(address.url)}, hash: ${JSON.stringify(address.hash)}, rootId: ${JSON.stringify(entryRootId(packagePath, file))}, resources: ${JSON.stringify(address.imageUrls ?? {})}, bundleFiles: ${JSON.stringify(pack.resources)} })`,
+        '',
+      ].join('\n')
+    },
+  }
+}