peachsim 0.1.527

package/src/public-brand.ts

@@ -0,0 +1,9 @@
+const name = 'rnx'
+
+export const rnxPublicBrand = Object.freeze({
+  name,
+  packageName: 'rnxsim',
+  commandName: 'rnx',
+  domain: 'rnxsim.com',
+  origin: 'https://rnxsim.com',
+})

package/src/react-native-host-modules.ts

@@ -0,0 +1,26 @@
+/**
+ * react-native specifiers whose upstream JavaScript must stay in a guest bundle.
+ *
+ * rnx owns the rest of the react-native package through its host-module registry.
+ * these modules instead run against globals installed by the simulator, which
+ * preserves upstream platform, style, event-emitter, and TurboModule behavior.
+ */
+export const REACT_NATIVE_PASSTHROUGH_SPECIFIERS: readonly string[] = [
+  'react-native/Libraries/vendor/emitter',
+  'react-native/Libraries/Components/View/ReactNativeStyleAttributes',
+  'react-native/Libraries/StyleSheet',
+  'react-native/Libraries/Utilities/differ',
+  'react-native/Libraries/Utilities/stringifySafe',
+  'react-native/src/private/assets/AssetRegistry',
+  'react-native/src/private/featureflags',
+  'react-native/Libraries/TurboModule/TurboModuleRegistry',
+  'react-native/Libraries/Utilities/Platform',
+  'react-native/Libraries/Utilities/NativePlatformConstants',
+  'react-native/src/private/specs_DEPRECATED/modules/NativePlatformConstants',
+]
+
+export function isReactNativePassthroughSpecifier(specifier: string): boolean {
+  return REACT_NATIVE_PASSTHROUGH_SPECIFIERS.some(
+    (passthrough) => specifier === passthrough || specifier.startsWith(`${passthrough}/`),
+  )
+}

package/src/render-mode.ts

@@ -0,0 +1,27 @@
+export type RenderMode = 'worker'
+
+// worker rendering is now the only supported mode.
+export function getRenderMode(_searchParams: URLSearchParams): RenderMode {
+  return 'worker'
+}
+
+export function isRenderWorkerMode(_searchParams: URLSearchParams): boolean {
+  return true
+}
+
+export function isRenderMainMode(_searchParams: URLSearchParams): boolean {
+  return false
+}
+
+export function hasRenderWorkerBootstrap(
+  workerModuleBaseUrl: string | null | undefined,
+): boolean {
+  return typeof workerModuleBaseUrl === 'string' && workerModuleBaseUrl.length > 0
+}
+
+export function shouldEnableRenderWorker(
+  _searchParams: URLSearchParams,
+  workerModuleBaseUrl: string | null | undefined,
+): boolean {
+  return hasRenderWorkerBootstrap(workerModuleBaseUrl)
+}

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')
+    },
+  }
+}

package/src/runtime-assets.ts

@@ -0,0 +1,233 @@
+// helpers for serving the installed sootsim engine runtime from framework
+// dev servers. the runtime is managed by `sootsim runtime install` and lives
+// under ~/.rnx/runtimes/<version>.
+
+import fs from 'fs'
+import path from 'path'
+import { fileURLToPath } from 'url'
+import { isValidRuntimeVersion } from '@contrast/runtime-delivery'
+import { readActiveRuntime, runtimeDir } from './home-paths.ts'
+
+export const SOOTSIM_RUNTIME_MISSING_MESSAGE =
+  '[rnx] no engine runtime installed. run `rnx runtime install`'
+
+// --- dev-checkout mode boundary --------------------------------------------
+//
+// there is exactly one rule for which engine gets served: INSIDE the Contrast
+// monorepo dev checkout the fresh dev-stack build (public/sootsim, kept current
+// by `bun dev`'s watch:sootsim) IS the engine; OUTSIDE it (a published CLI in a
+// user's project, or an isolated home) the installed runtime IS. this is a mode
+// boundary, not a preference or a runtime fallback chain — the check is
+// structural (the monorepo layout is present next to this module) and
+// deterministic (the dev build's files exist). it exists because the daemon and
+// the /__soot plugin otherwise serve ~/.rnx/runtimes/<active>, a PUBLISHED
+// runtime that `bun dev` never refreshes, so local engine edits are invisible
+// until a manual publish — the silent trap that cost a full night of
+// already-fixed bugs re-reproducing.
+//
+// the isolated CI headless path (scripts/local-publish-runtime.sh) sets
+// RNX_HOME to a dedicated dir precisely to validate the published-runtime
+// code path; keying off that EXISTING isolation env keeps it (and packaged
+// electron with a custom home) on the installed runtime.
+let _monorepoRootCache: string | null | undefined
+
+function findMonorepoRoot(): string | null {
+  if (_monorepoRootCache !== undefined) return _monorepoRootCache
+  let dir = path.dirname(fileURLToPath(import.meta.url))
+  // walk up until we find the Contrast monorepo: it has packages/sootsim-engine and
+  // a public/sootsim dev-build output slot. bounded by the filesystem root.
+  for (let i = 0; i < 12 && dir !== path.dirname(dir); i++) {
+    if (
+      fs.existsSync(path.join(dir, 'packages/sootsim-engine/package.json')) &&
+      fs.existsSync(path.join(dir, 'public/sootsim'))
+    ) {
+      _monorepoRootCache = dir
+      return dir
+    }
+    dir = path.dirname(dir)
+  }
+  _monorepoRootCache = null
+  return null
+}
+
+/** the fresh dev-stack engine build to serve when running inside the Contrast
+ *  monorepo dev checkout, or null when the installed runtime should serve
+ *  (published CLI, packaged electron, or an isolated RNX_HOME). */
+export function resolveDevCheckoutRuntimeRoot(): string | null {
+  // an explicit home that has a STAGED/active runtime is the isolation the
+  // CI/local-publish path sets up to validate the installed-runtime code path —
+  // honor that staged runtime. an explicit home with NO active runtime is just
+  // an isolated dev daemon (own lockfile, doesn't clobber ~/.rnx), which
+  // still wants the dev build; and the default home (RNX_HOME unset) always
+  // does. keying on "explicit home + a runtime deliberately staged there" keeps
+  // it structural, not a bespoke toggle.
+  if (process.env.RNX_HOME && readActiveRuntime()) return null
+  const root = findMonorepoRoot()
+  if (!root) return null
+  const devBuild = path.join(root, 'public/sootsim')
+  // require the runtime shape the installed runtime also has, so serving it is
+  // a drop-in (index.html shell + engine/ + engine-tenant/worker.js tenant).
+  if (
+    fs.existsSync(path.join(devBuild, 'index.html')) &&
+    fs.existsSync(path.join(devBuild, 'engine/index.html')) &&
+    fs.existsSync(path.join(devBuild, 'engine-tenant/worker.js'))
+  ) {
+    return devBuild
+  }
+  return null
+}
+
+const MIME_TYPES: Record<string, string> = {
+  '.js': 'application/javascript',
+  '.mjs': 'application/javascript',
+  '.css': 'text/css',
+  '.html': 'text/html',
+  '.wasm': 'application/wasm',
+  '.json': 'application/json',
+  '.jpg': 'image/jpeg',
+  '.jpeg': 'image/jpeg',
+  '.png': 'image/png',
+  '.svg': 'image/svg+xml',
+  '.webp': 'image/webp',
+  '.glb': 'model/gltf-binary',
+  '.ttf': 'font/ttf',
+  '.otf': 'font/otf',
+  '.woff': 'font/woff',
+  '.woff2': 'font/woff2',
+  '.mp3': 'audio/mpeg',
+  '.wav': 'audio/wav',
+}
+
+const ROOT_RUNTIME_PATHS = [
+  '/assets/',
+  '/engine/',
+  '/engine-tenant/',
+  '/photos/',
+  '/three-mode/',
+  '/fonts/',
+  '/icons/',
+  '/sounds/',
+  '/spike/',
+  '/test-wallpaper.jpg',
+  '/preview-sw.js',
+  '/sootsim.svg',
+]
+
+export function resolveActiveRuntimeRoot(): string | null {
+  // mode boundary: inside the dev checkout the dev-stack build is the engine.
+  const devRoot = resolveDevCheckoutRuntimeRoot()
+  if (devRoot) return devRoot
+  const active = readActiveRuntime()
+  if (!active) return null
+  const dir = runtimeDir(active)
+  if (!fs.existsSync(path.join(dir, 'index.html'))) return null
+  return dir
+}
+
+const RUNTIME_VERSION_HOSTNAME_SUFFIX = '.runtime.localhost'
+
+export function runtimeVersionHostname(version: string): string {
+  const trimmed = version.trim()
+  if (!isValidRuntimeVersion(trimmed)) {
+    throw new Error(`invalid rnx runtime version: ${version}`)
+  }
+  const encoded = Buffer.from(trimmed, 'utf8').toString('hex')
+  const labels = encoded.match(/.{1,60}/g)
+  if (!labels) throw new Error(`invalid rnx runtime version: ${version}`)
+  return `${labels.join('.')}${RUNTIME_VERSION_HOSTNAME_SUFFIX}`
+}
+
+export function isRuntimeVersionHostname(hostname: string): boolean {
+  return hostname.toLowerCase().endsWith(RUNTIME_VERSION_HOSTNAME_SUFFIX)
+}
+
+export function runtimeVersionFromHostname(hostname: string): string | null {
+  if (!isRuntimeVersionHostname(hostname)) return null
+  const labels = hostname.slice(0, -RUNTIME_VERSION_HOSTNAME_SUFFIX.length).split('.')
+  if (labels.length === 0 || labels.some((label) => !/^[0-9a-f]{1,60}$/i.test(label))) {
+    return null
+  }
+  const encoded = labels.join('')
+  if (encoded.length % 2 !== 0) return null
+  try {
+    const version = Buffer.from(encoded, 'hex').toString('utf8')
+    return isValidRuntimeVersion(version) ? version : null
+  } catch {
+    return null
+  }
+}
+
+export function resolveInstalledRuntimeRoot(version: string): string | null {
+  const dir = runtimeDir(version)
+  if (!fs.existsSync(path.join(dir, 'index.html'))) return null
+  return dir
+}
+
+/** select one immutable installed runtime for a version-owned origin. ordinary
+ *  localhost requests follow the active runtime; a malformed or unavailable
+ *  version origin fails closed instead of borrowing active assets. */
+export function resolveRuntimeRootForHostname(hostname: string): string | null {
+  if (!isRuntimeVersionHostname(hostname)) return resolveActiveRuntimeRoot()
+  const version = runtimeVersionFromHostname(hostname)
+  return version ? resolveInstalledRuntimeRoot(version) : null
+}
+
+export function resolveRuntimeRootForRequestHost(
+  host: string | undefined,
+): string | null {
+  if (!host) return resolveActiveRuntimeRoot()
+  try {
+    return resolveRuntimeRootForHostname(new URL(`http://${host}`).hostname)
+  } catch {
+    return null
+  }
+}
+
+export function isRootRuntimeAssetPath(pathname: string): boolean {
+  return ROOT_RUNTIME_PATHS.some((p) => pathname === p || pathname.startsWith(p))
+}
+
+export function resolveRuntimeFilePath(
+  runtimeRoot: string,
+  pathname: string,
+): string | null {
+  if (!pathname.startsWith('/')) return null
+  if (pathname.includes('\0') || pathname.includes('\\')) return null
+  for (const segment of pathname.split('/')) {
+    if (segment === '..') return null
+  }
+
+  const fullPath = path.resolve(runtimeRoot, pathname.replace(/^\/+/, ''))
+  const rootWithSep = runtimeRoot.endsWith(path.sep)
+    ? runtimeRoot
+    : runtimeRoot + path.sep
+  if (!fullPath.startsWith(rootWithSep) && fullPath !== runtimeRoot) return null
+  if (!fs.existsSync(fullPath) || !fs.statSync(fullPath).isFile()) return null
+  return fullPath
+}
+
+export function serveRuntimeFile(req: any, res: any, fullPath: string) {
+  const ext = path.extname(fullPath)
+  const stat = fs.statSync(fullPath)
+  const lastModified = stat.mtime.toUTCString()
+  res.setHeader('content-type', MIME_TYPES[ext] || 'application/octet-stream')
+  if (/^canvaskit-graphite-pipelines-[0-9a-f]{8}\.bin$/.test(path.basename(fullPath))) {
+    res.setHeader('cache-control', 'public, max-age=31536000, immutable')
+    fs.createReadStream(fullPath).pipe(res)
+    return
+  }
+  // these urls are STABLE across dev rebuilds and runtime version switches
+  // (worker.js, canvaskit-graphite.wasm, the html shells are unhashed), so the
+  // browser must revalidate every load — the old year-long immutable here made every
+  // new tab run a stale cached engine-tenant worker.js against a fresh engine,
+  // which also broke `do reload` ("bridge never reconnected"). no-cache +
+  // last-modified keeps repeat loads cheap 304s on localhost.
+  res.setHeader('cache-control', 'no-cache')
+  res.setHeader('last-modified', lastModified)
+  if (req?.headers?.['if-modified-since'] === lastModified) {
+    res.statusCode = 304
+    res.end()
+    return
+  }
+  fs.createReadStream(fullPath).pipe(res)
+}

package/src/runtime-delivery.ts

@@ -0,0 +1,54 @@
+// rnx's binding of the shared runtime-delivery machinery.
+//
+// the machinery itself (hosted manifest, sha256-verified tarballs, channels,
+// channel resolution, and auto-update) lives in @contrast/runtime-delivery and
+// knows nothing about rnx. this file supplies rnx's identity, public env
+// overrides, and the contrast.dev/runtimes hosting layout.
+//
+// @contrast/runtime-delivery is an internal workspace package that is never
+// published, so both the CLI bundle and dist-lib inline it (see the `alias`
+// entry in scripts/build-cli.ts). pack-smoke fails the build if it ever leaks
+// out as a bare require.
+
+import { createRuntimeDelivery, type RuntimeProduct } from '@contrast/runtime-delivery'
+import {
+  cacheDir,
+  configFilePath,
+  ensureRnxHome,
+  readActiveRuntime,
+  runtimeDir,
+  runtimesDir,
+  writeActiveRuntime,
+} from './home-paths.ts'
+import { rnxPublicBrand } from './public-brand.ts'
+
+export const DEFAULT_RUNTIME_CDN_ORIGIN = 'https://contrast.dev'
+
+/** the official curated changelog and the machine-readable release feed. the
+ *  rnx site is static, so its /api traffic is owned by contrast.dev. */
+export const RNX_CHANGELOG_URL = `${rnxPublicBrand.origin}/changelog`
+export const RNX_CHANGELOG_API_URL = 'https://contrast.dev/api/changelog/sootsim'
+
+export const RNX_RUNTIME_PRODUCT: RuntimeProduct = {
+  id: 'rnx',
+  defaultCdnOrigin: DEFAULT_RUNTIME_CDN_ORIGIN,
+  manifestPath: '/runtimes/manifest.json',
+  tarballPath: (version) => `/runtimes/sootsim-runtime-${version}.tar.gz`,
+  // the engine runtime is a static SPA: shell at the root, engine/ and
+  // engine-tenant/ beneath it. index.html is what the daemon and the
+  // vite/metro plugins serve, so its absence means the tarball is not one.
+  installedMarker: 'index.html',
+  env: {
+    cdnOrigin: 'RNX_CDN_ORIGIN',
+    channel: 'RNX_RUNTIME_CHANNEL',
+  },
+  ensureHome: ensureRnxHome,
+  configFile: configFilePath,
+  runtimesDir,
+  runtimeDir,
+  cacheDir,
+  readActiveRuntime,
+  writeActiveRuntime,
+}
+
+export const rnxRuntime = createRuntimeDelivery(RNX_RUNTIME_PRODUCT)