rnxsim 0.1.393 → 0.1.394

package/dist-lib/vite.cjs

@@ -1,4 +1,4 @@
-/*! rnx v0.1.393 | (c) 2026 Tamagui LLC | Proprietary — see LICENSE */
+/*! rnx v0.1.394 | (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.393",
+  "version": "0.1.394",
   "description": "Vite and Metro plugins, testing drivers, and SDK exports for rnx.",
   "author": "Tamagui LLC",
   "license": "SEE LICENSE IN LICENSE",

package/src/bridge-contract-input.ts

@@ -3,6 +3,7 @@
 // WebSocket routes) validates its request bodies here rather than growing a
 // second reader for the same shapes.
 
+import { SIM_LONG_PRESS_MAX_MS } from './bridge-contract'
 import type {
   ResetOptions,
   SemanticWaitOptions,
@@ -130,6 +131,17 @@ export function parsePerformStep(value: unknown, index: number): SimPerformStep
     }
     case 'longPress': {
       const durationMs = optionalNumber(step, 'durationMs', path)
+      if (
+        durationMs !== undefined &&
+        (!Number.isInteger(durationMs) ||
+          durationMs < 1 ||
+          durationMs > SIM_LONG_PRESS_MAX_MS)
+      ) {
+        validationFailure(
+          `${path}.durationMs`,
+          `must be an integer between 1 and ${SIM_LONG_PRESS_MAX_MS}`,
+        )
+      }
       return {
         type,
         x: numberValue(step.x, `${path}.x`),

package/src/bridge-contract.ts

@@ -22,6 +22,7 @@ export type BridgeCommandType =
   | 'settle'
   | 'setAppearance'
   | 'openUrl'
+  | 'memory'
   | 'tap'
   | 'longPress'
   | 'keyboard'
@@ -216,6 +217,12 @@ export interface SemanticReadyProbe {
   suppressedEntryError: string
 }
 
+// react native's own Pressable/Touchable delayLongPress default, and the
+// ceiling any transport accepts for a press-and-hold. a driver that holds
+// longer than this is describing a drag, not a long press.
+export const SIM_LONG_PRESS_DEFAULT_MS = 500
+export const SIM_LONG_PRESS_MAX_MS = 5_000
+
 export const SEMANTIC_READY_CONTENT_NODE_FLOOR = 100
 export const SEMANTIC_READY_NODE_STABLE_MS = 750
 export const SEMANTIC_READY_POLL_MS = 150

package/src/cloud-contract.ts

@@ -1,8 +1,37 @@
+import type { BridgeCommandType } from './bridge-contract'
+
 export const RNX_CLOUD_MAX_ARTIFACT_BYTES = 20 * 1024 * 1024
 export const RNX_CLOUD_DESIGN_PARALLEL_JOB_LIMIT = 16
 export const RNX_CLOUD_DESIGN_MAX_STORAGE_ENTRIES = 256
 export const RNX_CLOUD_DESIGN_MAX_STORAGE_BYTES = 1024 * 1024
 
+export const RNX_CLOUD_COMMAND_TYPES = Object.freeze([
+  'state',
+  'query',
+  'resolve',
+  'perform',
+  'waitFor',
+  'reset',
+  'screenshot',
+  'capture',
+  'captureRegions',
+  'settle',
+  'setAppearance',
+  'openUrl',
+  'tree',
+  'tap',
+  'longPress',
+  'memory',
+]) satisfies readonly BridgeCommandType[]
+
+const RNX_CLOUD_COMMAND_TYPE_SET = new Set<string>(RNX_CLOUD_COMMAND_TYPES)
+
+export function isRnxCloudCommandType(
+  value: string,
+): value is (typeof RNX_CLOUD_COMMAND_TYPES)[number] {
+  return RNX_CLOUD_COMMAND_TYPE_SET.has(value)
+}
+
 export interface RnxCloudClaim {
   id: string
   expiresAt: number

package/src/metro-production-bundle.ts

@@ -49,3 +49,203 @@ export function readRNXMetroModuleIdentity(
   }
   return { source: bundleText.slice(0, footerStart), modulePaths }
 }
+
+// the exact layout Metro's baseJSBundle emits and the rnx runtime contract
+// depends on: a prelude, then one `__d(` or `__r(` statement per line, each
+// running until the next statement starts its own line. one reader owns this
+// recognition so the loader's identity validation, the source-map attribution
+// pass, and the cloud artifact producer cannot drift apart.
+export interface RNXMetroDefine {
+  kind: 'define'
+  moduleId: number
+  start: number
+  end: number
+  lineIndex: number
+  endLineIndex: number
+  /** the factory expression, between `__d(` and the module ID. */
+  factory: { start: number; end: number }
+  /** the dependency array, brackets included. */
+  dependencies: { start: number; end: number }
+}
+
+export interface RNXMetroRun {
+  kind: 'run'
+  start: number
+  end: number
+  lineIndex: number
+  endLineIndex: number
+}
+
+export type RNXMetroStatement = RNXMetroDefine | RNXMetroRun
+
+export interface RNXMetroBundleLayout {
+  /** everything before the first `__d(`/`__r(` line: prelude vars and polyfills. */
+  prelude: string
+  statements: RNXMetroStatement[]
+  /** `__d(` statements whose module ID could not be read. */
+  moduleIdFailures: number
+}
+
+interface DefineTail {
+  moduleId: number
+  factoryEnd: number
+  dependenciesStart: number
+  dependenciesEnd: number
+}
+
+// each `__d(...)` ends with `),<id>,[dep,dep,...]);?`. the dependency array can
+// be hundreds of entries long, so walk back from `end` instead of searching a
+// fixed tail window: skip trailing `;` and whitespace, consume the closing `)`,
+// balance `[...]` to find its opening bracket, then read the integer before it.
+function readDefineTail(source: string, start: number, end: number): DefineTail | null {
+  let cursor = end
+  while (
+    cursor > start &&
+    (source[cursor] === ' ' ||
+      source[cursor] === '\n' ||
+      source[cursor] === '\t' ||
+      source[cursor] === ';')
+  ) {
+    cursor--
+  }
+  if (source[cursor] !== ')') return null
+  cursor--
+  while (cursor > start && /\s/.test(source[cursor])) cursor--
+  if (source[cursor] !== ']') return null
+  const dependenciesEnd = cursor + 1
+  let depth = 1
+  cursor--
+  while (cursor > start && depth > 0) {
+    const character = source[cursor]
+    if (character === ']') depth++
+    else if (character === '[') depth--
+    if (depth === 0) break
+    cursor--
+  }
+  if (depth !== 0) return null
+  const dependenciesStart = cursor
+  let idEnd = cursor - 1
+  while (idEnd > start && /\s/.test(source[idEnd])) idEnd--
+  if (source[idEnd] !== ',') return null
+  // a minifier is free to write the module ID as `1e3` or `0x3e8`, so read the
+  // whole numeric literal rather than a run of decimal digits. the factory
+  // before it always ends in `}` or `)`, which stops this walk immediately.
+  let idStart = idEnd
+  while (idStart > start && /[0-9a-fA-FxX.+\-]/.test(source[idStart - 1])) idStart--
+  const literal = source.slice(idStart, idEnd)
+  if (!/^-?(?:0[xXbBoO][0-9a-fA-F]+|\d+(?:\.\d*)?(?:[eE][+-]?\d+)?)$/.test(literal)) {
+    return null
+  }
+  const moduleId = Number(literal)
+  if (!Number.isSafeInteger(moduleId)) return null
+  let factoryEnd = idStart - 1
+  while (factoryEnd > start && /\s/.test(source[factoryEnd])) factoryEnd--
+  if (source[factoryEnd] !== ',') return null
+  return {
+    moduleId,
+    factoryEnd,
+    dependenciesStart,
+    dependenciesEnd,
+  }
+}
+
+/** reads the canonical Metro production layout from footer-stripped source. */
+export function readRNXMetroBundleLayout(source: string): RNXMetroBundleLayout {
+  const lineOffsets = [0]
+  for (let index = 0; index < source.length; index++) {
+    if (source.charCodeAt(index) === 10) lineOffsets.push(index + 1)
+  }
+
+  const boundaries: number[] = []
+  for (let lineIndex = 0; lineIndex < lineOffsets.length; lineIndex++) {
+    const start = lineOffsets[lineIndex]
+    if (source.startsWith('__d(', start) || source.startsWith('__r(', start)) {
+      boundaries.push(lineIndex)
+    }
+  }
+
+  const statements: RNXMetroStatement[] = []
+  let moduleIdFailures = 0
+  for (let index = 0; index < boundaries.length; index++) {
+    const lineIndex = boundaries[index]
+    const start = lineOffsets[lineIndex]
+    const nextLineIndex = boundaries[index + 1]
+    const endLineIndex =
+      nextLineIndex !== undefined ? nextLineIndex - 1 : lineOffsets.length - 1
+    const end = nextLineIndex !== undefined ? lineOffsets[nextLineIndex] : source.length
+    if (!source.startsWith('__d(', start)) {
+      statements.push({ kind: 'run', start, end, lineIndex, endLineIndex })
+      continue
+    }
+    const tail = readDefineTail(source, start, end - 1)
+    if (!tail) {
+      moduleIdFailures++
+      continue
+    }
+    statements.push({
+      kind: 'define',
+      moduleId: tail.moduleId,
+      start,
+      end,
+      lineIndex,
+      endLineIndex,
+      factory: { start: start + '__d('.length, end: tail.factoryEnd },
+      dependencies: { start: tail.dependenciesStart, end: tail.dependenciesEnd },
+    })
+  }
+
+  return {
+    prelude: source.slice(
+      0,
+      boundaries.length > 0 ? lineOffsets[boundaries[0]] : source.length,
+    ),
+    statements,
+    moduleIdFailures,
+  }
+}
+
+/**
+ * validates the exact identity contract before a loader installs a Metro
+ * factory trap or a producer ships an artifact: every define carries a unique,
+ * readable module ID, and the identity map names those IDs and no others.
+ * serializers that emit another layout need an ingestion adapter that
+ * normalizes them to this format.
+ */
+export function validateRNXMetroModulePaths(
+  source: string,
+  modulePaths: RNXMetroModulePathMap,
+): void {
+  const layout = readRNXMetroBundleLayout(source)
+  if (layout.moduleIdFailures > 0) {
+    throw new Error(
+      `Metro module identity could not read ${layout.moduleIdFailures} module IDs`,
+    )
+  }
+  const definedIds = new Set<number>()
+  for (const statement of layout.statements) {
+    if (statement.kind !== 'define') continue
+    if (definedIds.has(statement.moduleId)) {
+      throw new Error(`Metro module identity has duplicate module ${statement.moduleId}`)
+    }
+    definedIds.add(statement.moduleId)
+    if (!Object.prototype.hasOwnProperty.call(modulePaths, String(statement.moduleId))) {
+      throw new Error(`Metro module identity is missing ${statement.moduleId}`)
+    }
+  }
+  if (definedIds.size === 0) {
+    throw new Error('Metro module identity found no canonical JavaScript modules')
+  }
+
+  for (const [key, modulePath] of Object.entries(modulePaths)) {
+    const moduleId = Number(key)
+    if (!Number.isSafeInteger(moduleId) || String(moduleId) !== key) {
+      throw new Error(`Metro module identity has invalid module ID ${key}`)
+    }
+    if (typeof modulePath !== 'string' || modulePath.length === 0) {
+      throw new Error(`Metro module identity has no path for ${key}`)
+    }
+    if (!definedIds.has(moduleId)) {
+      throw new Error(`Metro module identity has no module ${key}`)
+    }
+  }
+}