rnxsim 0.1.523 → 0.1.525

package/dist-lib/vite.cjs

@@ -1,4 +1,4 @@
-/*! rnx v0.1.523 | (c) 2026 Tamagui LLC | Proprietary — see LICENSE */
+/*! rnx v0.1.525 | (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;
@@ -763,6 +763,93 @@ var import_node_os2 = __toESM(require("node:os"), 1);
 var import_node_path4 = __toESM(require("node:path"), 1);
 var import_node_util = require("node:util");
 
+// ../sootsim-swift/src/bundleAssets.ts
+var RASTER_EXTENSIONS = /* @__PURE__ */ new Set([
+  ".avif",
+  ".bmp",
+  ".gif",
+  ".ico",
+  ".jpeg",
+  ".jpg",
+  ".png",
+  ".webp"
+]);
+function extOf(file) {
+  const dot = file.lastIndexOf(".");
+  return dot < 0 ? "" : file.slice(dot).toLowerCase();
+}
+function baseOf(file) {
+  const slash = file.lastIndexOf("/");
+  return slash < 0 ? file : file.slice(slash + 1);
+}
+function pickImagesetFile(images) {
+  const rasters = images.filter(
+    (image) => typeof image.filename === "string" && RASTER_EXTENSIONS.has(extOf(image.filename))
+  );
+  if (rasters.length === 0) return null;
+  const rank = (scale) => scale === "2x" ? 0 : scale === "3x" ? 1 : scale === "1x" ? 2 : 3;
+  return [...rasters].sort((a, b) => rank(a.scale) - rank(b.scale))[0].filename;
+}
+function imagesetName(contentsPath) {
+  const dir = contentsPath.split("/").slice(0, -1).join("/");
+  const leaf = baseOf(dir);
+  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 enumerateBundleImages(paths, readText) {
+  const table = [];
+  const seen = /* @__PURE__ */ new Set();
+  const catalogs = paths.filter((path7) => baseOf(path7) === "Contents.json");
+  for (const contentsPath of catalogs) {
+    const name = imagesetName(contentsPath);
+    if (name === null || seen.has(name)) continue;
+    let parsed;
+    try {
+      const text = readText(contentsPath);
+      if (text === null) continue;
+      parsed = JSON.parse(text);
+    } catch {
+      continue;
+    }
+    const images = parsed?.images;
+    if (!Array.isArray(images)) continue;
+    const dir = contentsPath.split("/").slice(0, -1).join("/");
+    const file = pickImagesetFile(images);
+    if (file === null || file.includes("/") || file.includes("\\")) continue;
+    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);
+    if (name === "" || seen.has(name)) continue;
+    seen.add(name);
+    table.push({ name, file: path7 });
+  }
+  return table;
+}
+function enumerateBundleJson(paths) {
+  const found = [];
+  const seen = /* @__PURE__ */ new Set();
+  const ordered = [...paths].filter(
+    (path7) => path7.split("/").includes("Resources") && path7.split("/").every((segment) => segment !== "" && segment !== "..") && extOf(path7) === ".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 = {
   release: "swift-6.3-RELEASE",
@@ -778,13 +865,19 @@ var TOOLCHAIN_BIN = import_node_path4.default.join(
 var WASM_SDK = `${toolchain_default.release}_wasm`;
 var WASM_TRIPLE = "wasm32-unknown-wasip1";
 var ARTIFACT_PATH = "/__rnx/swift/";
+var RESOURCE_PATH = "/__rnx/swift-res/";
 var VIRTUAL_PREFIX = "\0rnx-swift:";
 var projects = /* @__PURE__ */ new Map();
 var devServer;
 function projectFor(packagePath) {
   const existing = projects.get(packagePath);
   if (existing) return existing;
-  const created = { packagePath, artifact: null, building: null };
+  const created = {
+    packagePath,
+    artifact: null,
+    building: null,
+    resourceFiles: /* @__PURE__ */ new Map()
+  };
   projects.set(packagePath, created);
   return created;
 }
@@ -803,6 +896,118 @@ function sourceFiles(root) {
   walk(root);
   return found;
 }
+function resourceCandidateFiles(root) {
+  const found = [];
+  const walk = (dir) => {
+    for (const entry of import_node_fs3.default.readdirSync(dir, { withFileTypes: true })) {
+      if (entry.name.startsWith(".") || entry.name === "node_modules" || entry.name === ".build")
+        continue;
+      const full = import_node_path4.default.join(dir, entry.name);
+      if (entry.isDirectory()) {
+        if (full !== root && import_node_fs3.default.existsSync(import_node_path4.default.join(full, "Package.swift"))) continue;
+        walk(full);
+      } else {
+        found.push(full);
+      }
+    }
+  };
+  walk(root);
+  return found;
+}
+var RESOURCE_CONTENT_TYPES = {
+  ".avif": "image/avif",
+  ".bmp": "image/bmp",
+  ".gif": "image/gif",
+  ".ico": "image/x-icon",
+  ".jpeg": "image/jpeg",
+  ".jpg": "image/jpeg",
+  ".png": "image/png",
+  ".webp": "image/webp"
+};
+function buildSwiftResourceTable(project, baseUrl) {
+  const absolute = resourceCandidateFiles(project.packagePath);
+  const relative2 = absolute.map(
+    (file) => import_node_path4.default.relative(project.packagePath, file).split(import_node_path4.default.sep).join(import_node_path4.default.posix.sep)
+  );
+  const byRelative = new Map(absolute.map((file, index) => [relative2[index], file]));
+  const found = enumerateBundleImages(relative2, (candidate) => {
+    const file = byRelative.get(candidate);
+    if (!file || import_node_path4.default.basename(file) !== "Contents.json") return null;
+    try {
+      return import_node_fs3.default.readFileSync(file, "utf8");
+    } catch {
+      return null;
+    }
+  });
+  const table = {};
+  const watched = [];
+  const registered = /* @__PURE__ */ new Map();
+  for (const { name, file } of found) {
+    const disk = byRelative.get(file);
+    if (!disk) continue;
+    let bytes;
+    try {
+      bytes = import_node_fs3.default.readFileSync(disk);
+    } catch {
+      continue;
+    }
+    const hash = (0, import_node_crypto2.createHash)("sha256").update(bytes).digest("hex").slice(0, 16);
+    const ext = import_node_path4.default.posix.extname(file).toLowerCase();
+    table[name] = `${baseUrl}${RESOURCE_PATH}${hash}${ext}`;
+    watched.push(file);
+    const contents = file.replace(/\/[^/]+$/, "/Contents.json");
+    if (byRelative.has(contents)) watched.push(contents);
+    registered.set(`${hash}${ext}`, disk);
+  }
+  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;
+  try {
+    return {
+      bytes: import_node_fs3.default.readFileSync(disk),
+      contentType: RESOURCE_CONTENT_TYPES[import_node_path4.default.extname(disk).toLowerCase()] ?? "application/octet-stream"
+    };
+  } catch {
+    return null;
+  }
+}
 function linkedModuleRoots(packagePath) {
   let manifest;
   try {
@@ -833,11 +1038,14 @@ function entryRootId(packagePath, file) {
   const relative2 = import_node_path4.default.relative(packagePath, file).split(import_node_path4.default.sep).join(import_node_path4.default.posix.sep);
   return `${import_node_path4.default.basename(packagePath)}${import_node_path4.default.posix.sep}${relative2}`;
 }
-function artifactUrl(project, artifact) {
+function serverOrigin() {
   const address = devServer?.httpServer?.address();
   const port = address && typeof address === "object" ? address.port : devServer?.config.server.port;
-  if (!port) throw new Error("the swift artifact url needs the dev server port");
-  return `http://localhost:${port}${ARTIFACT_PATH}${artifact.hash}.wasm`;
+  if (!port) throw new Error("the swift urls need the dev server port");
+  return `http://localhost:${port}`;
+}
+function artifactUrl(project, artifact) {
+  return `${serverOrigin()}${ARTIFACT_PATH}${artifact.hash}.wasm`;
 }
 function builtArtifact(packagePath) {
   const binDir = import_node_path4.default.join(packagePath, ".build", WASM_TRIPLE, "release");
@@ -961,9 +1169,36 @@ function swiftPlugin(options = {}) {
         this.warn(error instanceof Error ? error.message : String(error));
         artifact = project.artifact;
       }
+      let resources = {};
+      try {
+        const built = buildSwiftResourceTable(project, serverOrigin());
+        resources = built.table;
+        for (const watched of built.watched) this.addWatchFile(watched);
+      } catch (error) {
+        this.warn(
+          `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))} })`,
+        `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");
     },
@@ -971,6 +1206,20 @@ function swiftPlugin(options = {}) {
       devServer = server;
       server.middlewares.use((req, res, next) => {
         const url = (req.url ?? "").split("?")[0];
+        if (url.startsWith(RESOURCE_PATH)) {
+          for (const project of projects.values()) {
+            const served = serveSwiftResource(project, url.slice(RESOURCE_PATH.length));
+            if (served) {
+              res.setHeader("access-control-allow-origin", "*");
+              res.setHeader("content-type", served.contentType);
+              res.end(served.bytes);
+              return;
+            }
+          }
+          res.statusCode = 404;
+          res.end("swift resource is stale");
+          return;
+        }
         if (!url.startsWith(ARTIFACT_PATH)) {
           next();
           return;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "rnxsim",
-  "version": "0.1.523",
+  "version": "0.1.525",
   "description": "Vite and Metro plugins, testing drivers, and SDK exports for rnx.",
   "author": "Tamagui LLC",
   "license": "SEE LICENSE IN LICENSE",

package/src/vite-plugin-swift.ts

@@ -16,6 +16,10 @@ import fs from 'node:fs'
 import os from 'node:os'
 import path from 'node:path'
 import { promisify } from 'node:util'
+import {
+  enumerateBundleImages,
+  enumerateBundleJson,
+} from '../../sootsim-swift/src/bundleAssets'
 import toolchain from '../../sootsim-swift/toolchain.json'
 import type { Plugin, ViteDevServer } from 'vite'
 
@@ -33,6 +37,7 @@ const WASM_SDK = `${toolchain.release}_wasm`
 const WASM_TRIPLE = 'wasm32-unknown-wasip1'
 
 const ARTIFACT_PATH = '/__rnx/swift/'
+const RESOURCE_PATH = '/__rnx/swift-res/'
 const VIRTUAL_PREFIX = '\0rnx-swift:'
 
 interface SwiftArtifact {
@@ -49,6 +54,9 @@ interface SwiftProject {
   artifact: SwiftArtifact | null
   // the build in flight and the sources it was started from
   building: { stamp: string; promise: Promise<SwiftArtifact> } | null
+  // content hash to absolute path for this load's bundle images: the served
+  // urls name a hash, never a path, so there is nothing to traverse.
+  resourceFiles: Map<string, string>
 }
 
 // a project is its swiftpm package: the build, the artifact, and the dev
@@ -59,7 +67,12 @@ let devServer: ViteDevServer | undefined
 function projectFor(packagePath: string): SwiftProject {
   const existing = projects.get(packagePath)
   if (existing) return existing
-  const created: SwiftProject = { packagePath, artifact: null, building: null }
+  const created: SwiftProject = {
+    packagePath,
+    artifact: null,
+    building: null,
+    resourceFiles: new Map(),
+  }
   projects.set(packagePath, created)
   return created
 }
@@ -86,6 +99,180 @@ function sourceFiles(root: string): string[] {
   return found
 }
 
+// every file that can carry bundle content: catalogs and flat Resources
+// rasters anywhere under the package. `.build` is skipped where sourceFiles
+// does not need to: a release tree holds tens of thousands of files and no
+// bundle content, and walking it per import would tax every hot reload.
+function resourceCandidateFiles(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(full)
+      }
+    }
+  }
+  walk(root)
+  return found
+}
+
+const RESOURCE_CONTENT_TYPES: Record<string, string> = {
+  '.avif': 'image/avif',
+  '.bmp': 'image/bmp',
+  '.gif': 'image/gif',
+  '.ico': 'image/x-icon',
+  '.jpeg': 'image/jpeg',
+  '.jpg': 'image/jpeg',
+  '.png': 'image/png',
+  '.webp': 'image/webp',
+}
+
+export interface SwiftResourceTable {
+  /** bundle asset name to absolute serving url. */
+  table: Record<string, string>
+  /** project-relative image files this load's table covers (for watching). */
+  watched: string[]
+}
+
+// the producer for the local vehicle: enumerate the package's bundle images
+// through the shared rule both hosts use, hash each raster's bytes into its
+// url (an edited photo moves its url, so no stale paint survives a reload),
+// and register hash to path for the serving middleware below.
+export function buildSwiftResourceTable(
+  project: SwiftProject,
+  baseUrl: string,
+): SwiftResourceTable {
+  const absolute = resourceCandidateFiles(project.packagePath)
+  const relative = absolute.map((file) =>
+    path.relative(project.packagePath, file).split(path.sep).join(path.posix.sep),
+  )
+  const byRelative = new Map(absolute.map((file, index) => [relative[index], file]))
+  const found = enumerateBundleImages(relative, (candidate) => {
+    const file = byRelative.get(candidate)
+    if (!file || path.basename(file) !== 'Contents.json') return null
+    try {
+      return fs.readFileSync(file, 'utf8')
+    } catch {
+      return null
+    }
+  })
+  const table: Record<string, string> = {}
+  const watched: string[] = []
+  const registered = new Map<string, string>()
+  for (const { name, file } of found) {
+    const disk = byRelative.get(file)
+    if (!disk) continue
+    let bytes: Buffer
+    try {
+      bytes = fs.readFileSync(disk)
+    } catch {
+      continue
+    }
+    const hash = createHash('sha256').update(bytes).digest('hex').slice(0, 16)
+    const ext = path.posix.extname(file).toLowerCase()
+    table[name] = `${baseUrl}${RESOURCE_PATH}${hash}${ext}`
+    watched.push(file)
+    // a Contents.json edit (scale swap, file rename) re-resolves the same
+    // way a raster edit does, so the catalog rides the watcher too.
+    const contents = file.replace(/\/[^/]+$/, '/Contents.json')
+    if (byRelative.has(contents)) watched.push(contents)
+    registered.set(`${hash}${ext}`, disk)
+  }
+  project.resourceFiles = registered
+  return { table, watched }
+}
+
+// the /res pack: every Resources/ json in the package, basename-keyed and
+// base64, riding the entry module so the mount serves it without a fetch.
+// the namespace is flat like the bundle the wasm side reads: shallower
+// paths pack first (the Resources root is the bundle root) with a lexical
+// tiebreak, and the first spelling of a basename wins a collision. caps are
+// INFERRED (no app in either rung is near them; landmarkData-scale json is
+// tens of KB): a file past them is skipped and named in `skipped` so the
+// load warns instead of silently serving a partial bundle. binary bytes
+// travel the same map when a port reaches past json; the worker half packs
+// text only until then (see the gaps ledger).
+const BUNDLE_MAX_FILES = 128
+const BUNDLE_MAX_FILE_BYTES = 2 * 1024 * 1024
+const BUNDLE_MAX_TOTAL_BYTES = 8 * 1024 * 1024
+
+export interface SwiftBundlePack {
+  /** basename to base64 bytes for the mount's /res. */
+  files: Record<string, string>
+  /** project-relative json files this load's pack covers (for watching). */
+  watched: string[]
+  /** project-relative files skipped by a cap, for the load warning. */
+  skipped: string[]
+}
+
+export function buildSwiftBundleFiles(packagePath: string): SwiftBundlePack {
+  // resourceCandidateFiles walks every non-ignored file with the nested
+  // package exclusion; the shared enumeration decides namespace, order and
+  // collisions, identically for every host that packs.
+  const relative = resourceCandidateFiles(packagePath).map((file) =>
+    path.relative(packagePath, file).split(path.sep).join(path.posix.sep),
+  )
+  const files: Record<string, string> = {}
+  const watched: string[] = []
+  const skipped: string[] = []
+  let total = 0
+  for (const { base, file } of enumerateBundleJson(relative)) {
+    watched.push(file)
+    let bytes: Buffer
+    try {
+      bytes = fs.readFileSync(path.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 }
+}
+
+// the middleware's lookup, exported for the producer's own proof: a hit is
+// known bytes for a known hash, anything else is null, never a file.
+export function serveSwiftResource(
+  project: SwiftProject,
+  key: string,
+): { bytes: Buffer; contentType: string } | null {
+  const disk = project.resourceFiles.get(key)
+  if (!disk) return null
+  try {
+    return {
+      bytes: fs.readFileSync(disk),
+      contentType:
+        RESOURCE_CONTENT_TYPES[path.extname(disk).toLowerCase()] ??
+        'application/octet-stream',
+    }
+  } catch {
+    return null
+  }
+}
+
 // the SwiftUI module the project links: its manifest names it as a path
 // dependency, and `swift build` compiles it with the project, so an edit
 // there changes the artifact without moving any of the project's own mtimes.
@@ -137,14 +324,18 @@ export function entryRootId(packagePath: string, file: string): string {
   return `${path.basename(packagePath)}${path.posix.sep}${relative}`
 }
 
-// the app fetches the artifact from a worker whose origin is the shell, so the
-// url has to name this dev server rather than resolve relative to the shell.
-function artifactUrl(project: SwiftProject, artifact: SwiftArtifact): string {
+// the app fetches from a worker whose origin is the shell, so urls have to
+// name this dev server rather than resolve relative to the shell.
+function serverOrigin(): string {
   const address = devServer?.httpServer?.address()
   const port =
     address && typeof address === 'object' ? address.port : devServer?.config.server.port
-  if (!port) throw new Error('the swift artifact url needs the dev server port')
-  return `http://localhost:${port}${ARTIFACT_PATH}${artifact.hash}.wasm`
+  if (!port) throw new Error('the swift urls need the dev server port')
+  return `http://localhost:${port}`
+}
+
+function artifactUrl(project: SwiftProject, artifact: SwiftArtifact): string {
+  return `${serverOrigin()}${ARTIFACT_PATH}${artifact.hash}.wasm`
 }
 
 // one executable is the app. a package with several is ambiguous: the host
@@ -332,13 +523,46 @@ export function swiftPlugin(options: SwiftPluginOptions = {}): Plugin {
         this.warn(error instanceof Error ? error.message : String(error))
         artifact = project.artifact
       }
+      // the bundle image table rides the same module: a photo edit moves
+      // its urls without rebuilding the artifact, and the watched files
+      // re-run this load so the mount sees the new table on hot reload.
+      let resources: Record<string, string> = {}
+      try {
+        const built = buildSwiftResourceTable(project, serverOrigin())
+        resources = built.table
+        for (const watched of built.watched) this.addWatchFile(watched)
+      } catch (error) {
+        this.warn(
+          `swift resources for ${packagePath}: ${error instanceof Error ? error.message : String(error)}`,
+        )
+      }
+      // the /res pack rides the same module as bytes: a json edit moves the
+      // pack, the watched files re-run this load, and the mount's
+      // bundleFiles compare treats it as a new app and remounts through it.
+      let bundleFiles: Record<string, string> = {}
+      try {
+        const packed = buildSwiftBundleFiles(packagePath)
+        bundleFiles = packed.files
+        for (const watched of packed.watched) {
+          this.addWatchFile(path.join(packagePath, ...watched.split(path.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)}`,
+        )
+      }
       // 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. the entry is rooted by
       // its package and source path so a hot reload finds the same instance.
       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))} })`,
+        `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')
     },
@@ -348,6 +572,24 @@ export function swiftPlugin(options: SwiftPluginOptions = {}): Plugin {
 
       server.middlewares.use((req, res, next) => {
         const url = (req.url ?? '').split('?')[0]
+        if (url.startsWith(RESOURCE_PATH)) {
+          // hash-addressed: the table this load emitted names these hashes,
+          // so a hit serves known bytes and anything else is a 404, never a
+          // neighboring file. the tenant worker is cross-origin like the
+          // artifact fetch, hence the same cors header.
+          for (const project of projects.values()) {
+            const served = serveSwiftResource(project, url.slice(RESOURCE_PATH.length))
+            if (served) {
+              res.setHeader('access-control-allow-origin', '*')
+              res.setHeader('content-type', served.contentType)
+              res.end(served.bytes)
+              return
+            }
+          }
+          res.statusCode = 404
+          res.end('swift resource is stale')
+          return
+        }
         if (!url.startsWith(ARTIFACT_PATH)) {
           next()
           return