rnxsim 0.1.431 → 0.1.433

package/dist-lib/vite.cjs

@@ -1,4 +1,4 @@
-/*! rnx v0.1.431 | (c) 2026 Tamagui LLC | Proprietary — see LICENSE */
+/*! rnx v0.1.433 | (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;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "rnxsim",
-  "version": "0.1.431",
+  "version": "0.1.433",
   "description": "Vite and Metro plugins, testing drivers, and SDK exports for rnx.",
   "author": "Tamagui LLC",
   "license": "SEE LICENSE IN LICENSE",
@@ -234,6 +234,7 @@
     "esbuild": "^0.25.0",
     "jiti": "2.7.0",
     "playwright-core": "1.61.0",
+    "terser": "^5.49.0",
     "ws": "^8.18.0"
   },
   "peerDependencies": {

package/src/auth/shared-session.ts

@@ -22,6 +22,8 @@ export type SharedDesktopAuthUser = {
   email?: string
   image?: string
   githubUsername?: string
+  /** the person's own account; every team they belong to is in `teams` */
+  personalAccountId?: string
   teams?: SharedDesktopAuthTeamSummary[]
   isAdmin?: boolean
 }
@@ -34,6 +36,24 @@ export type SharedDesktopAuthSession = {
   source: 'cli' | 'electron' | 'browser' | 'unknown'
   updatedAt: string
   validatedAt?: string
+  /**
+   * the account this sign-in bills cloud work to. a session token names the
+   * person, not an account, so the CLI chooses one at `rnx login` and names it
+   * on every request that opens a paid session.
+   */
+  accountId?: string
+}
+
+/** the accounts a signed-in person can bill: their own, then their teams. */
+export function sharedDesktopAuthAccounts(
+  user: SharedDesktopAuthUser | null | undefined,
+): { id: string; name: string }[] {
+  return [
+    ...(user?.personalAccountId
+      ? [{ id: user.personalAccountId, name: 'Personal' }]
+      : []),
+    ...(user?.teams ?? []).map((team) => ({ id: team.id, name: team.name })),
+  ]
 }
 
 const SESSION_VERSION = 1 as const
@@ -65,6 +85,10 @@ function normalizeUser(input: unknown): SharedDesktopAuthUser | null {
     image: typeof value.image === 'string' ? value.image : undefined,
     githubUsername:
       typeof value.githubUsername === 'string' ? value.githubUsername : undefined,
+    personalAccountId:
+      typeof value.personalAccountId === 'string' && value.personalAccountId.trim()
+        ? value.personalAccountId.trim()
+        : undefined,
     isAdmin: value.isAdmin === true,
     teams: Array.isArray(value.teams)
       ? value.teams
@@ -108,6 +132,10 @@ function normalizeSession(input: unknown): SharedDesktopAuthSession | null {
     typeof value.validatedAt === 'string' && value.validatedAt
       ? value.validatedAt
       : undefined
+  const accountId =
+    typeof value.accountId === 'string' && value.accountId.trim()
+      ? value.accountId.trim()
+      : undefined
 
   return {
     version: SESSION_VERSION,
@@ -117,6 +145,7 @@ function normalizeSession(input: unknown): SharedDesktopAuthSession | null {
     source,
     updatedAt,
     validatedAt,
+    accountId,
   }
 }
 
@@ -153,6 +182,7 @@ export function writeSharedDesktopAuthSession(
     source: session.source,
     updatedAt: session.updatedAt || new Date().toISOString(),
     validatedAt: session.validatedAt,
+    accountId: session.accountId?.trim() || undefined,
   }
   writeFileSync(filepath, JSON.stringify(normalized, null, 2) + '\n')
   try {
@@ -197,6 +227,7 @@ export async function refreshSharedDesktopAuthSession(
       origin,
       source: current.source,
       validatedAt: new Date().toISOString(),
+      accountId: current.accountId,
     })
   } catch {
     return current

package/src/cloud.ts

@@ -1,30 +1,37 @@
-// typed RNX Cloud nano client for agents. the CLI produces artifact bytes
+// typed Remote Simulators client for agents. the CLI produces artifact bytes
 // (local file or a fetched URL); this module talks to the service in those
 // bytes only. command types and receipts are the same ones the CLI already
 // sends. do not invent a second vocabulary.
+//
+// one call gives you one remote simulator. it runs on a nano box today, which
+// is why the session below carries a box id and the create request asks for a
+// size, but that is the service's business: nothing box-shaped reaches the
+// public surface.
 
 import { isLoopbackHost } from './backend-origin'
+import { isRnxScreenCapture, type RnxScreenCapture } from './capture-contract'
 import {
   isRnxCloudCommandType,
   RNX_CLOUD_COMMAND_TYPES,
   RNX_CLOUD_MAX_ARTIFACT_BYTES,
   type RnxCloudBoxCreateReceipt,
   type RnxCloudClaim,
+  type RnxCloudCreateReceipt,
 } from './cloud-contract'
 import { rnxPublicBrand } from './public-brand'
 
 export { isRnxCloudCommandType, RNX_CLOUD_COMMAND_TYPES, RNX_CLOUD_MAX_ARTIFACT_BYTES }
-export type { RnxCloudBoxCreateReceipt, RnxCloudClaim }
+export type { RnxCloudClaim, RnxCloudCreateReceipt, RnxScreenCapture }
 
 const DEFAULT_DEVICE = 'iphone-16'
 const DEFAULT_WAIT_READY_MS = 20_000
 
-export type NanoCommand = {
+export type RemoteCommand = {
   type: (typeof RNX_CLOUD_COMMAND_TYPES)[number]
   [key: string]: unknown
 }
 
-export interface CreateNanoBoxInput {
+export interface CreateRemoteSimulatorInput {
   artifact: Uint8Array
   authorization: string
   origin?: string
@@ -32,20 +39,33 @@ export interface CreateNanoBoxInput {
   sha256?: string
 }
 
-export interface AddNanoSimulatorInput {
-  device?: string
-  storageFrom?: string | null
+// the simulator-driving verbs. the same vocabulary the CLI drives, one for
+// one: `rnx describe`, `rnx do tap`, `rnx wait selector`.
+export interface RnxCommands {
+  command(
+    command: { type: string; [key: string]: unknown },
+    options?: { timeoutMs?: number },
+  ): Promise<unknown>
+  describe(): Promise<unknown>
+  do(command: { type: string; [key: string]: unknown }): Promise<unknown>
+  wait(
+    condition: 'ready' | { type: 'selector'; selector: string },
+    options?: { maxMs?: number },
+  ): Promise<unknown>
+  // a `data:image/png;base64,` url, assembled by the service from the frame
+  screenshot(options?: { layers?: 'full' | 'tenant' | 'shell' }): Promise<string>
+  capture(): Promise<RnxScreenCapture>
+  reset(): Promise<unknown>
 }
 
-interface NanoSession {
+interface RemoteSimulatorSession {
   origin: string
-  authorization: string
   boxId: string
   boxToken: string
   simId: string
   simulatorToken: string
   claim: RnxCloudClaim
-  artifact: RnxCloudBoxCreateReceipt['artifact']
+  artifact: RnxCloudCreateReceipt['artifact']
 }
 
 function isRecord(value: unknown): value is Record<string, unknown> {
@@ -221,7 +241,7 @@ function readBoxCreate(
   }
 }
 
-function cloudCommand(command: { type: string; [key: string]: unknown }): NanoCommand {
+function cloudCommand(command: { type: string; [key: string]: unknown }): RemoteCommand {
   const clean: Record<string, unknown> = {}
   for (const [key, value] of Object.entries(command)) {
     if (key !== 'id' && key !== 'simId') clean[key] = value
@@ -232,15 +252,50 @@ function cloudCommand(command: { type: string; [key: string]: unknown }): NanoCo
   return { ...clean, type: command.type }
 }
 
-export class NanoBox {
-  private session: NanoSession
+export class RemoteSimulator {
+  private session: RemoteSimulatorSession
 
-  constructor(session: NanoSession) {
-    this.session = session
-  }
+  // driving verbs live here so the client reads the way the CLI does. bound to
+  // this simulator at construction, and every verb reads the session live, so a
+  // confirmed claim reaches commands issued after it.
+  readonly rnx: RnxCommands
 
-  get boxId(): string {
-    return this.session.boxId
+  constructor(session: RemoteSimulatorSession) {
+    this.session = session
+    this.rnx = {
+      command: (command, options) => this.sendCommand(command, options),
+      describe: () => this.sendCommand({ type: 'tree' }),
+      do: (command) => this.sendCommand(command),
+      wait: (condition, options) => {
+        const timeoutMs = options?.maxMs ?? DEFAULT_WAIT_READY_MS
+        const waitCondition = condition === 'ready' ? { type: 'ready' } : condition
+        return this.sendCommand(
+          {
+            type: 'waitFor',
+            waitForOptions: { condition: waitCondition, timeoutMs },
+          },
+          { timeoutMs: timeoutMs + 1_000 },
+        )
+      },
+      screenshot: async (options) => {
+        const result = await this.sendCommand({
+          type: 'screenshot',
+          layers: options?.layers ?? 'tenant',
+        })
+        if (typeof result !== 'string' || !result.startsWith('data:image/')) {
+          throw new Error('RNX Cloud screenshot did not return an image data url')
+        }
+        return result
+      },
+      capture: async () => {
+        const result = await this.sendCommand({ type: 'capture' })
+        if (!isRnxScreenCapture(result)) {
+          throw new Error('RNX Cloud capture returned an invalid screen capture')
+        }
+        return result
+      },
+      reset: () => this.sendCommand({ type: 'reset' }),
+    }
   }
 
   get simId(): string {
@@ -251,20 +306,15 @@ export class NanoBox {
     return this.session.claim
   }
 
-  get receipt(): RnxCloudBoxCreateReceipt {
+  get receipt(): RnxCloudCreateReceipt {
     return {
-      boxId: this.session.boxId,
-      size: 'nano',
+      simId: this.session.simId,
       artifact: this.session.artifact,
-      simulator: {
-        simId: this.session.simId,
-        artifact: this.session.artifact,
-        claim: this.session.claim,
-      },
+      claim: this.session.claim,
     }
   }
 
-  async command(
+  private async sendCommand(
     command: { type: string; [key: string]: unknown },
     options?: { timeoutMs?: number },
   ): Promise<unknown> {
@@ -314,44 +364,6 @@ export class NanoBox {
     return parsed.result
   }
 
-  describe(): Promise<unknown> {
-    return this.command({ type: 'tree' })
-  }
-
-  do(command: { type: string; [key: string]: unknown }): Promise<unknown> {
-    return this.command(command)
-  }
-
-  wait(
-    condition: 'ready' | { type: 'selector'; selector: string },
-    options?: { maxMs?: number },
-  ): Promise<unknown> {
-    const timeoutMs = options?.maxMs ?? DEFAULT_WAIT_READY_MS
-    const waitCondition = condition === 'ready' ? { type: 'ready' } : condition
-    return this.command(
-      {
-        type: 'waitFor',
-        waitForOptions: { condition: waitCondition, timeoutMs },
-      },
-      { timeoutMs: timeoutMs + 1_000 },
-    )
-  }
-
-  screenshot(options?: { layers?: 'full' | 'tenant' | 'shell' }): Promise<unknown> {
-    return this.command({
-      type: 'screenshot',
-      layers: options?.layers ?? 'tenant',
-    })
-  }
-
-  capture(): Promise<unknown> {
-    return this.command({ type: 'capture' })
-  }
-
-  reset(): Promise<unknown> {
-    return this.command({ type: 'reset' })
-  }
-
   async confirm(): Promise<RnxCloudClaim> {
     const response = await fetch(
       `${this.session.origin}/v1/sims/${encodeURIComponent(this.session.simId)}/claim`,
@@ -380,49 +392,6 @@ export class NanoBox {
     return claim
   }
 
-  async addSimulator(input: AddNanoSimulatorInput = {}): Promise<NanoBox> {
-    const device = input.device?.trim() || DEFAULT_DEVICE
-    const response = await fetch(
-      `${this.session.origin}/v1/boxes/${encodeURIComponent(this.session.boxId)}/simulators`,
-      {
-        method: 'POST',
-        headers: {
-          authorization: `Bearer ${this.session.boxToken}`,
-          'x-rnx-account-authorization': this.session.authorization,
-          'content-type': 'application/json',
-        },
-        body: JSON.stringify({
-          device,
-          ...(input.storageFrom === undefined ? {} : { storageFrom: input.storageFrom }),
-        }),
-      },
-    )
-    const text = await response.text()
-    if (!response.ok) throw responseError(response.status, text)
-    let parsed: unknown
-    try {
-      parsed = JSON.parse(text)
-    } catch {
-      throw new Error('RNX Cloud simulator create returned unreadable JSON')
-    }
-    if (!isRecord(parsed) || parsed.boxId !== this.session.boxId) {
-      throw new Error('RNX Cloud simulator create returned an invalid box id')
-    }
-    const simulator = readSimulatorCreate(
-      parsed.simulator,
-      this.session.artifact.id,
-      this.session.artifact.bytes,
-    )
-    const pooled = new NanoBox({
-      ...this.session,
-      simId: simulator.simId,
-      simulatorToken: simulator.token,
-      claim: simulator.claim,
-    })
-    await pooled.confirm()
-    return pooled
-  }
-
   async close(): Promise<void> {
     const response = await fetch(
       `${this.session.origin}/v1/boxes/${encodeURIComponent(this.session.boxId)}`,
@@ -438,7 +407,9 @@ export class NanoBox {
   }
 }
 
-export async function createNanoBox(input: CreateNanoBoxInput): Promise<NanoBox> {
+export async function createRemoteSimulator(
+  input: CreateRemoteSimulatorInput,
+): Promise<RemoteSimulator> {
   if (input.artifact.byteLength > RNX_CLOUD_MAX_ARTIFACT_BYTES) {
     throw new Error(
       `rnx Cloud artifact is ${input.artifact.byteLength} bytes and exceeds the ${RNX_CLOUD_MAX_ARTIFACT_BYTES}-byte limit`,
@@ -484,9 +455,8 @@ export async function createNanoBox(input: CreateNanoBoxInput): Promise<NanoBox>
     throw new Error('RNX Cloud create returned unreadable JSON')
   }
   const created = readBoxCreate(parsed, input.artifact.byteLength, sha256)
-  const box = new NanoBox({
+  const simulator = new RemoteSimulator({
     origin,
-    authorization: input.authorization,
     boxId: created.receipt.boxId,
     boxToken: created.boxToken,
     simId: created.receipt.simulator.simId,
@@ -494,6 +464,6 @@ export async function createNanoBox(input: CreateNanoBoxInput): Promise<NanoBox>
     claim: created.receipt.simulator.claim,
     artifact: created.receipt.artifact,
   })
-  await box.confirm()
-  return box
+  await simulator.confirm()
+  return simulator
 }

package/src/metro-plugin.ts

@@ -1,4 +1,4 @@
-// rnx metro plugin for opt-in dev shell and production bundle annotation.
+// rnx metro plugin for dev shell and bundle module identity annotation.
 // shell assets come from an engine runtime under ~/.rnx/runtimes/, fetched
 // by `rnx runtime install`. ordinary localhost requests
 // follow active; a version-owned localhost origin stays on its exact directory
@@ -6,19 +6,13 @@
 //
 // usage in metro.config.js:
 //   const { withRNX } = require('rnxsim/metro')
-//   module.exports = withRNX(getDefaultConfig(__dirname), { devServer: true })
+//   module.exports = withRNX(getDefaultConfig(__dirname))
 
 import fs from 'fs'
 import { createRequire } from 'module'
 import { randomUUID } from 'node:crypto'
 import path from 'path'
-import {
-  openRnxDesktopWhenMetroIsReady,
-  resolveRnxDesktopAppName,
-  resolveRnxDesktopLaunchTarget,
-  tagRnxBundleForPlugin,
-  type RnxDesktopOpenOption,
-} from './dev-server-open'
+import { tagRnxBundleForPlugin } from './dev-server-open'
 import {
   handleReplacementModuleRequest,
   isReplacementModuleRequestUrl,
@@ -71,26 +65,6 @@ type MetroSerializer = (
   options: MetroSerializerOptions,
 ) => MetroSerializerResult | Promise<MetroSerializerResult>
 
-export interface RNXMetroOptions {
-  bundleUrl?: string
-  devServer?: boolean
-  open?: RnxDesktopOpenOption
-  /**
-   * append the `moduleId -> sourcePath` identity footer to every production
-   * bundle. resolution is untouched, so the annotated artifact is the same
-   * bundle the app ships and rnx can load it directly.
-   */
-  productionBundles?: boolean
-  /**
-   * append the `moduleId -> sourcePath` identity footer to every development
-   * bundle. resolution and transforms stay ordinary, while Metro keeps verbose
-   * module names and its source map.
-   */
-  developmentBundles?: boolean
-}
-
-// the slice of metro's config we touch — keeps `T` open for whatever
-// shape consumers pass while letting us extend `server.enhanceMiddleware`.
 type MetroConfigWithServer = {
   projectRoot?: string
   serializer?: {
@@ -160,7 +134,7 @@ function appendRNXModulePaths(
   const dependencies = graph.dependencies
   const createModuleId = options.createModuleId
   if (!dependencies || !createModuleId) {
-    throw new Error('rnxsim: Metro did not provide the module graph and createModuleId')
+    return result
   }
 
   const modulePaths: Record<string, string> = {}
@@ -208,23 +182,9 @@ function appendRNXModulePaths(
     : { ...result, code: appendRNXMetroModuleIdentityFooter(result.code, identity) }
 }
 
-export function withRNX<T extends Record<string, unknown>>(
-  config: T,
-  options: RNXMetroOptions = {},
-): T {
-  if (
-    !options.devServer &&
-    !options.open &&
-    !options.productionBundles &&
-    !options.developmentBundles
-  ) {
-    return config
-  }
-
+export function withRNX<T extends Record<string, unknown>>(config: T): T {
   const cfgProjectRoot = (config as MetroConfigWithServer).projectRoot || process.cwd()
-  const appName = resolveRnxDesktopAppName(options.open, cfgProjectRoot)
-  const configuredBundleUrl =
-    options.bundleUrl || '/index.bundle?platform=ios&dev=true&hot=true&minify=false'
+  const configuredBundleUrl = '/index.bundle?platform=ios&dev=true&hot=true&minify=false'
 
   const cfgServer = (config as MetroConfigWithServer).server
   const port = resolveMetroPort(cfgServer)
@@ -234,42 +194,29 @@ export function withRNX<T extends Record<string, unknown>>(
     `http://localhost:${port}`,
     metroServerId,
     cfgProjectRoot,
-    appName,
   )
   const cfgSerializer = (config as MetroConfigWithServer).serializer
   const existingEnhance = cfgServer?.enhanceMiddleware
   const existingSerializer = cfgSerializer?.customSerializer
-  let productionConfig: Partial<MetroConfigWithServer> = {}
-
-  if (options.productionBundles || options.developmentBundles) {
-    let defaultSerializer: MetroSerializer | undefined
-
-    productionConfig = {
-      serializer: {
-        ...cfgSerializer,
-        customSerializer: async (
-          entryPoint: string,
-          preModules: readonly unknown[],
-          graph: MetroSerializerGraph,
-          serializerOptions: MetroSerializerOptions,
-        ) => {
-          const serializer =
-            existingSerializer ||
-            (defaultSerializer ||= createMetroDefaultSerializer(cfgProjectRoot))
-          const result = await serializer(
-            entryPoint,
-            preModules,
-            graph,
-            serializerOptions,
-          )
-          const dev = serializerOptions.dev
-          return (dev === false && options.productionBundles === true) ||
-            (dev === true && options.developmentBundles === true)
-            ? appendRNXModulePaths(result, graph, serializerOptions, cfgProjectRoot)
-            : result
-        },
+
+  let defaultSerializer: MetroSerializer | undefined
+
+  const serializerConfig = {
+    serializer: {
+      ...cfgSerializer,
+      customSerializer: async (
+        entryPoint: string,
+        preModules: readonly unknown[],
+        graph: MetroSerializerGraph,
+        serializerOptions: MetroSerializerOptions,
+      ) => {
+        const serializer =
+          existingSerializer ||
+          (defaultSerializer ||= createMetroDefaultSerializer(cfgProjectRoot))
+        const result = await serializer(entryPoint, preModules, graph, serializerOptions)
+        return appendRNXModulePaths(result, graph, serializerOptions, cfgProjectRoot)
       },
-    }
+    },
   }
 
   const serverConfig = {
@@ -305,26 +252,6 @@ export function withRNX<T extends Record<string, unknown>>(
         const url = req.url || ''
         const pathname = url.split('?')[0]
 
-        if (pathname === '/__server-scan') {
-          const absoluteBundleUrl = bundleUrl.startsWith('http')
-            ? bundleUrl
-            : `http://localhost:${port}${bundleUrl}`
-          res.setHeader('content-type', 'application/json')
-          res.end(
-            JSON.stringify([
-              {
-                port,
-                framework: 'metro',
-                rnxServerId: metroServerId,
-                bundleUrl: absoluteBundleUrl,
-                ...(appName ? { projectName: appName } : {}),
-                lastSeen: Date.now(),
-              },
-            ]),
-          )
-          return
-        }
-
         const runtimeRoot = resolveRuntimeRootForRequestHost(req.headers?.host)
 
         if (!runtimeRoot) {
@@ -371,10 +298,10 @@ export function withRNX<T extends Record<string, unknown>>(
           if (!ext) {
             const htmlPath = path.join(runtimeRoot, 'index.html')
             let html = fs.readFileSync(htmlPath, 'utf8')
-            html = html.replace(
-              '</head>',
-              `<script>(function(){var u=new URL(location.href);if(!u.searchParams.has('bundle'))u.searchParams.set('bundle',${JSON.stringify(bundleUrl)});history.replaceState(null,'','${prefix}/'+u.search)})()</script></head>`,
-            )
+            const script = `<script>(function(){var u=new URL(location.href);if(!u.searchParams.has('bundle'))u.searchParams.set('bundle',${JSON.stringify(bundleUrl)});history.replaceState(null,'','${prefix}/'+u.search)})()</script>`
+            html = html.includes('</head>')
+              ? html.replace('</head>', `${script}</head>`)
+              : `${html}${script}`
             res.setHeader('content-type', 'text/html')
             res.end(html)
             return
@@ -391,20 +318,10 @@ export function withRNX<T extends Record<string, unknown>>(
     },
   }
 
-  if (appName && !process.env.CI && !process.env.RNX_NO_OPEN) {
-    void openRnxDesktopWhenMetroIsReady({
-      port,
-      bundleUrl: resolveRnxDesktopLaunchTarget(port, bundleUrl),
-      appName,
-      projectRoot: cfgProjectRoot,
-      serverId: metroServerId,
-    })
-  }
-
   return {
     ...config,
-    ...productionConfig,
-    ...(options.devServer || options.open ? { server: serverConfig } : {}),
+    ...serializerConfig,
+    server: serverConfig,
   } as T
 }
 

package/src/vite-plugin.ts

@@ -493,8 +493,17 @@ export type WorkerBootClosure = {
 }
 
 const ENGINE_WORKER_BOOT_CLOSURES: WorkerBootClosure[] = [
-  { entry: 'src/render-worker/shell-worker-entry.ts', maxBytes: 3_480_000 },
-  { entry: 'src/render-worker/compositor-worker-entry.ts', maxBytes: 1_255_000 },
+  // both caps went up by about half a megabyte for fontkit, which replaced
+  // opentype.js as the app-font parser so woff2 faces (what expo-font ships to
+  // iOS) get real vertical metrics instead of measuring at CanvasKit's rounded
+  // paragraph height. these workers inline their dynamic imports, so all of it
+  // lands in the boot file even though only an app that ships a font evaluates
+  // it. removing it again means the shell and compositor taking the parsed
+  // names and metrics off the wire from the tenant instead of re-parsing the
+  // same bytes in three contexts, behind a static import boundary so the parser
+  // is not reachable from these two entries at all.
+  { entry: 'src/render-worker/shell-worker-entry.ts', maxBytes: 4_020_000 },
+  { entry: 'src/render-worker/compositor-worker-entry.ts', maxBytes: 1_835_000 },
 ]
 
 export function workerBootChunkPlugin(closures: WorkerBootClosure[]): Plugin {