peachsim 0.1.527

package/dist-lib/cloud.cjs

@@ -0,0 +1,670 @@
+/*! rnx v0.1.527 | (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 __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name2 in all)
+    __defProp(target, name2, { get: all[name2], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/cloud.ts
+var cloud_exports = {};
+__export(cloud_exports, {
+  RNX_CLOUD_COMMAND_TYPES: () => RNX_CLOUD_COMMAND_TYPES,
+  RNX_CLOUD_MAX_ARTIFACT_BYTES: () => RNX_CLOUD_MAX_ARTIFACT_BYTES,
+  RNX_CLOUD_SCOPED_TOKEN_PREFIX: () => RNX_CLOUD_SCOPED_TOKEN_PREFIX,
+  RemoteSimulator: () => RemoteSimulator,
+  connect: () => connect,
+  createRemoteSimulator: () => createRemoteSimulator,
+  isRnxCloudCommandScope: () => isRnxCloudCommandScope,
+  isRnxCloudCommandType: () => isRnxCloudCommandType
+});
+module.exports = __toCommonJS(cloud_exports);
+
+// src/backend-origin.ts
+function normalizeHostname(hostname) {
+  return hostname.replace(/^\[|\]$/g, "").toLowerCase();
+}
+function isLoopbackHost(hostname) {
+  const normalized = normalizeHostname(hostname);
+  return normalized === "localhost" || normalized.endsWith(".localhost") || normalized === "0.0.0.0" || normalized === "::1" || /^127(?:\.\d{1,3}){3}$/.test(normalized);
+}
+
+// src/capture-contract.ts
+var RNX_SCREEN_CAPTURE_VERSION = 1;
+function captureRecord(value) {
+  return value !== null && typeof value === "object" && !Array.isArray(value);
+}
+function captureInteger(value) {
+  return typeof value === "number" && Number.isSafeInteger(value);
+}
+function captureNumber(value) {
+  return typeof value === "number" && Number.isFinite(value);
+}
+function captureNullableString(value) {
+  return value === null || typeof value === "string";
+}
+function captureRect(value) {
+  return captureRecord(value) && captureNumber(value.x) && captureNumber(value.y) && captureNumber(value.width) && captureNumber(value.height);
+}
+function captureOptionalString(value) {
+  return value === void 0 || typeof value === "string";
+}
+function captureOptionalNullableString(value) {
+  return value === void 0 || captureNullableString(value);
+}
+function captureFontRegistration(value) {
+  return captureRecord(value) && typeof value.family === "string" && value.family.length > 0 && captureOptionalString(value.url) && captureOptionalString(value.sourceLabel) && captureOptionalNullableString(value.parsedFamily) && captureOptionalNullableString(value.parsedPostScript) && captureOptionalNullableString(value.fullName);
+}
+function capturePoint(value) {
+  return captureRecord(value) && captureNumber(value.x) && captureNumber(value.y);
+}
+function captureNode(value) {
+  if (!captureRecord(value) || !captureInteger(value.nodeId) || !(value.parentNodeId === null || captureInteger(value.parentNodeId)) || !Array.isArray(value.childNodeIds) || !value.childNodeIds.every(captureInteger) || !captureInteger(value.paintIndex) || typeof value.type !== "string" || !captureNullableString(value.id) || !captureNullableString(value.testID) || !captureNullableString(value.text) || !captureInteger(value.childCount) || !captureRecord(value.accessibility) || !captureRecord(value.interaction) || !captureRecord(value.layout) || !captureRecord(value.style) || !captureRecord(value.source) || !captureRecord(value.props) || !captureRecord(value.inspection)) {
+    return false;
+  }
+  const accessibility = value.accessibility;
+  if (typeof accessibility.accessible !== "boolean" || !captureNullableString(accessibility.label) || !captureNullableString(accessibility.role) || !captureNullableString(accessibility.hint) || !(accessibility.liveRegion === null || accessibility.liveRegion === "none" || accessibility.liveRegion === "polite" || accessibility.liveRegion === "assertive") || !(accessibility.state === null || captureRecord(accessibility.state)) || !(accessibility.value === null || captureRecord(accessibility.value))) {
+    return false;
+  }
+  const interaction = value.interaction;
+  if (typeof interaction.pressed !== "boolean" || typeof interaction.pressable !== "boolean" || typeof interaction.textInput !== "boolean" || !(interaction.textSelection === null || captureRecord(interaction.textSelection)) || typeof interaction.secureTextEntry !== "boolean" || !captureNullableString(interaction.placeholder) || !capturePoint(interaction.scrollOffset) || !(interaction.zoomScale === null || captureNumber(interaction.zoomScale)) || typeof interaction.nativePinchEnabled !== "boolean" || !(interaction.contentOffsetProp === null || captureRecord(interaction.contentOffsetProp)) || !(interaction.strokeDashoffsetProp === null || captureNumber(interaction.strokeDashoffsetProp))) {
+    return false;
+  }
+  const layout = value.layout;
+  if (!captureRect(layout.local) || !(layout.frame === null || captureRect(layout.frame)) || !capturePoint(layout.absolutePosition) || !(layout.visibleFrame === null || captureRect(layout.visibleFrame))) {
+    return false;
+  }
+  const style = value.style;
+  return captureRecord(style.resolved) && captureRecord(style.authored) && captureRecord(style.computed) && captureRecord(style.tokenBindings) && (value.textLines === void 0 || Array.isArray(value.textLines));
+}
+function isRnxScreenCapture(value) {
+  if (!captureRecord(value) || value.contractVersion !== RNX_SCREEN_CAPTURE_VERSION || !captureInteger(value.capturedAt) || !captureRecord(value.tree) || !(value.fonts === void 0 || Array.isArray(value.fonts) && value.fonts.length <= 200 && value.fonts.every(captureFontRegistration)) || !(value.visual === void 0 || captureRecord(value.visual))) {
+    return false;
+  }
+  const tree = value.tree;
+  const visual = value.visual;
+  return captureRecord(tree.viewport) && captureInteger(tree.viewport.width) && tree.viewport.width > 0 && captureInteger(tree.viewport.height) && tree.viewport.height > 0 && captureInteger(tree.rootNodeId) && (tree.commitRevision === void 0 || captureInteger(tree.commitRevision)) && Array.isArray(tree.nodes) && tree.nodes.every(captureNode) && (visual === void 0 || visual.kind === "png" && (visual.producer === "headless-cpu-app-surface" || visual.producer === "browser-compositor-app-surface") && typeof visual.dataUri === "string" && visual.dataUri.startsWith("data:image/png;base64,") && captureInteger(visual.pixelWidth) && visual.pixelWidth > 0 && captureInteger(visual.pixelHeight) && visual.pixelHeight > 0);
+}
+
+// src/cloud-contract.ts
+var RNX_CLOUD_MAX_ARTIFACT_BYTES = 20 * 1024 * 1024;
+var RNX_CLOUD_DESIGN_MAX_STORAGE_BYTES = 1024 * 1024;
+var RNX_CLOUD_COMMAND_SCOPE_SET = /* @__PURE__ */ new Set([
+  "read",
+  "drive",
+  "reset",
+  "media",
+  "debug",
+  "watch"
+]);
+function isRnxCloudCommandScope(value) {
+  return RNX_CLOUD_COMMAND_SCOPE_SET.has(value);
+}
+var RNX_CLOUD_SCOPED_TOKEN_PREFIX = "sk_rnx_sim_";
+var RNX_CLOUD_COMMAND_SCOPES = {
+  state: "read",
+  tree: "read",
+  query: "read",
+  resolve: "read",
+  screenshot: "read",
+  capture: "read",
+  captureRegions: "read",
+  memory: "read",
+  diagnostics: "read",
+  storageSnapshot: "read",
+  perform: "drive",
+  waitFor: "drive",
+  tap: "drive",
+  longPress: "drive",
+  settle: "drive",
+  openUrl: "drive",
+  setAppearance: "drive",
+  keyboard: "drive",
+  focus: "drive",
+  flowStatus: "drive",
+  reset: "reset",
+  camera: "media",
+  // string evaluation and arbitrary bridge calls are maestro's boundary: the
+  // customer sdk never carries this scope, and the service grants it only to
+  // the account api key caller. close rides along, since ending the page ends
+  // the sim and belongs to the sim's owner rather than any driver.
+  evaluate: "debug",
+  call: "debug",
+  close: "debug"
+};
+function scopeTableKeys() {
+  return Object.keys(RNX_CLOUD_COMMAND_SCOPES).filter(
+    (key) => Object.prototype.hasOwnProperty.call(RNX_CLOUD_COMMAND_SCOPES, key)
+  );
+}
+var RNX_CLOUD_COMMAND_TYPES = Object.freeze(scopeTableKeys());
+var RNX_CLOUD_COMMAND_TYPE_SET = new Set(RNX_CLOUD_COMMAND_TYPES);
+function isRnxCloudCommandType(value) {
+  return RNX_CLOUD_COMMAND_TYPE_SET.has(value);
+}
+function rnxCloudCommandScope(type) {
+  return RNX_CLOUD_COMMAND_SCOPES[type];
+}
+var RNX_CLOUD_TOKEN_SCOPES = Object.freeze([
+  "read",
+  "drive",
+  "reset",
+  "media"
+]);
+var RNX_CLOUD_ALL_COMMAND_SCOPES = Object.freeze(["read", "drive", "reset", "media", "debug"]);
+function rnxCloudScopesAllowCommand(scopes, type) {
+  return scopes.includes(RNX_CLOUD_COMMAND_SCOPES[type]);
+}
+
+// src/public-brand.ts
+var name = "rnx";
+var rnxPublicBrand = Object.freeze({
+  name,
+  packageName: "rnxsim",
+  commandName: "rnx",
+  domain: "rnxsim.com",
+  origin: "https://rnxsim.com"
+});
+
+// src/cloud.ts
+var DEFAULT_DEVICE = "iphone-16";
+var DEFAULT_WAIT_READY_MS = 2e4;
+var CLOUD_MAX_RETRIES = 2;
+var CLOUD_NEVER_RETRY_CODES = /* @__PURE__ */ new Set(["concurrency_limit", "early_access"]);
+function isRecord(value) {
+  return value !== null && typeof value === "object" && !Array.isArray(value);
+}
+function normalizeCloudOrigin(source) {
+  let parsed;
+  try {
+    parsed = new URL(source);
+  } catch {
+    throw new Error(`invalid RNX Cloud origin: ${source}`);
+  }
+  if (parsed.protocol !== "https:" && parsed.protocol !== "http:" || parsed.username || parsed.password || parsed.pathname !== "/" || parsed.search || parsed.hash) {
+    throw new Error(`RNX Cloud origin must be an HTTP(S) origin: ${source}`);
+  }
+  if (parsed.protocol === "http:" && !isLoopbackHost(parsed.hostname)) {
+    throw new Error(`RNX Cloud origin requires HTTPS outside loopback: ${source}`);
+  }
+  return parsed.origin;
+}
+function resolveOrigin(value) {
+  const configured = value?.trim() || process.env.RNX_CLOUD_ORIGIN?.trim();
+  return normalizeCloudOrigin(configured || rnxPublicBrand.origin);
+}
+function responseError(status, text) {
+  if (text) {
+    try {
+      const parsed = JSON.parse(text);
+      const error = isRecord(parsed) ? parsed.error : null;
+      if (isRecord(error) && typeof error.message === "string") {
+        return new Error(`RNX Cloud request failed (${status}): ${error.message}`);
+      }
+    } catch {
+    }
+  }
+  return new Error(
+    `RNX Cloud request failed (${status})${text.trim() ? `: ${text.trim()}` : ""}`
+  );
+}
+function readCloudErrorCode(text) {
+  let parsed;
+  try {
+    parsed = JSON.parse(text);
+  } catch {
+    return null;
+  }
+  if (!isRecord(parsed)) return null;
+  if (typeof parsed.error === "string") return parsed.error;
+  if (isRecord(parsed.error) && typeof parsed.error.code === "string") {
+    return parsed.error.code;
+  }
+  return null;
+}
+function readRetryAfterMs(response, text) {
+  const header = response.headers.get("retry-after");
+  if (header !== null) {
+    const seconds = Number(header.trim());
+    if (Number.isFinite(seconds) && seconds >= 0) return seconds * 1e3;
+  }
+  let parsed;
+  try {
+    parsed = JSON.parse(text);
+  } catch {
+    return null;
+  }
+  if (isRecord(parsed) && typeof parsed.retryAfterMs === "number" && Number.isFinite(parsed.retryAfterMs) && parsed.retryAfterMs >= 0) {
+    return parsed.retryAfterMs;
+  }
+  return null;
+}
+function sleep(ms) {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}
+async function fetchWithCloudRetry(url, init, options) {
+  let attempt = 0;
+  for (; ; ) {
+    const response = await fetch(
+      url,
+      options?.timeoutMs === void 0 ? init : { ...init, signal: AbortSignal.timeout(options.timeoutMs) }
+    );
+    if (response.ok) return response;
+    const retryableStatus = response.status === 429 || response.status >= 500;
+    if (!retryableStatus || attempt >= CLOUD_MAX_RETRIES) return response;
+    const text = await response.text();
+    const code = readCloudErrorCode(text);
+    const retryable = response.status >= 500 ? !(code !== null && CLOUD_NEVER_RETRY_CODES.has(code)) : code === "rate_limited";
+    if (!retryable) {
+      return new Response(text, { status: response.status, headers: response.headers });
+    }
+    if (response.status === 429) {
+      await sleep(readRetryAfterMs(response, text) ?? 1e3);
+    }
+    attempt += 1;
+  }
+}
+function copyArrayBuffer(bytes) {
+  const copy = new ArrayBuffer(bytes.byteLength);
+  new Uint8Array(copy).set(bytes);
+  return copy;
+}
+async function sha256Hex(bytes) {
+  const digest = await globalThis.crypto.subtle.digest("SHA-256", copyArrayBuffer(bytes));
+  const view = new Uint8Array(digest);
+  let hex = "";
+  for (const byte of view) hex += byte.toString(16).padStart(2, "0");
+  return hex;
+}
+function readJsArtifact(bytes) {
+  let source;
+  try {
+    source = new TextDecoder("utf-8", { fatal: true }).decode(bytes);
+  } catch {
+    throw new Error("rnx Cloud artifact must be valid UTF-8 JavaScript, not bytecode");
+  }
+  if (source.includes("\0") || !source.includes("__d(") || !source.includes("__r(")) {
+    throw new Error("rnx Cloud artifact must be a Metro JavaScript bundle");
+  }
+  return source;
+}
+function readClaim(value) {
+  if (!isRecord(value) || typeof value.id !== "string" || !value.id || typeof value.expiresAt !== "number") {
+    throw new Error("RNX Cloud returned an invalid claim");
+  }
+  return { id: value.id, expiresAt: value.expiresAt };
+}
+function artifactDigestId(sha256) {
+  return `sha256:${sha256}`;
+}
+function readArtifact(value, expectedId, expectedBytes) {
+  if (!isRecord(value) || value.id !== expectedId || typeof value.bytes !== "number" || !Number.isInteger(value.bytes) || value.bytes !== expectedBytes) {
+    throw new Error("RNX Cloud returned an invalid artifact receipt");
+  }
+  return { id: expectedId, bytes: expectedBytes };
+}
+function readSimulatorCreate(value, expectedId, expectedBytes) {
+  if (!isRecord(value)) throw new Error("RNX Cloud create returned an invalid simulator");
+  const claim = readClaim(value.claim);
+  if (typeof value.simId !== "string" || !value.simId || typeof value.token !== "string") {
+    throw new Error("RNX Cloud create returned an invalid simulator");
+  }
+  return {
+    simId: value.simId,
+    token: value.token,
+    claim,
+    artifact: readArtifact(value.artifact, expectedId, expectedBytes)
+  };
+}
+function readBoxCreate(value, expectedBytes, expectedSha256) {
+  const artifactId = artifactDigestId(expectedSha256);
+  if (!isRecord(value)) throw new Error("RNX Cloud create returned invalid JSON");
+  const simulator = readSimulatorCreate(value.simulator, artifactId, expectedBytes);
+  if (typeof value.boxId !== "string" || !value.boxId || value.size !== "nano" || typeof value.token !== "string" || !value.token) {
+    throw new Error("RNX Cloud create returned an invalid box receipt");
+  }
+  return {
+    receipt: {
+      boxId: value.boxId,
+      size: "nano",
+      artifact: readArtifact(value.artifact, artifactId, expectedBytes),
+      simulator: {
+        simId: simulator.simId,
+        artifact: simulator.artifact,
+        claim: simulator.claim
+      }
+    },
+    boxToken: value.token,
+    simulatorToken: simulator.token
+  };
+}
+function cloudCommand(command, scopes) {
+  const clean = {};
+  for (const [key, value] of Object.entries(command)) {
+    if (key !== "id" && key !== "simId") clean[key] = value;
+  }
+  if (!isRnxCloudCommandType(command.type)) {
+    throw new Error(`RNX Cloud does not support bridge command type ${command.type}`);
+  }
+  if (!rnxCloudScopesAllowCommand(scopes, command.type)) {
+    throw new Error(
+      `RNX Cloud command ${command.type} requires the ${rnxCloudCommandScope(command.type)} scope`
+    );
+  }
+  return { ...clean, type: command.type };
+}
+var RemoteSimulator = class {
+  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.
+  rnx;
+  constructor(session) {
+    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 + 1e3 }
+        );
+      },
+      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: (options) => {
+        if (options?.strategy !== void 0 && options.strategy !== "data" && options.strategy !== "full") {
+          throw new Error("RNX Cloud reset strategy must be data or full");
+        }
+        if (options?.from !== void 0 && (typeof options.from !== "string" || options.from.length === 0)) {
+          throw new Error("RNX Cloud reset from must name a simulator");
+        }
+        return this.sendCommand(
+          options === void 0 ? { type: "reset" } : {
+            type: "reset",
+            resetOptions: {
+              ...options.strategy === void 0 ? {} : { strategy: options.strategy },
+              ...options.from === void 0 ? {} : { from: options.from }
+            }
+          }
+        );
+      },
+      state: (options) => this.sendCommand(
+        options === void 0 ? { type: "state" } : { type: "state", stateOptions: options }
+      )
+    };
+  }
+  get simId() {
+    return this.session.simId;
+  }
+  get claim() {
+    return this.session.claim;
+  }
+  get scopes() {
+    return this.session.scopes;
+  }
+  get receipt() {
+    if (!this.session.claim) {
+      throw new Error("this simulator was attached with connect() and holds no claim");
+    }
+    return {
+      simId: this.session.simId,
+      artifact: this.session.artifact,
+      claim: this.session.claim
+    };
+  }
+  async sendCommand(command, options) {
+    const body = {
+      id: globalThis.crypto.randomUUID(),
+      // a scoped token drives without a claim: the service checks the token
+      // instead. a full token still joins the claim it names here.
+      claimId: this.session.claim?.id ?? "",
+      command: cloudCommand(command, this.session.scopes)
+    };
+    let response;
+    try {
+      response = await fetchWithCloudRetry(
+        `${this.session.origin}/v1/sims/${encodeURIComponent(this.session.simId)}/commands`,
+        {
+          method: "POST",
+          headers: {
+            authorization: `Bearer ${this.session.simulatorToken}`,
+            "content-type": "application/json"
+          },
+          body: JSON.stringify(body)
+        },
+        options?.timeoutMs === void 0 ? void 0 : { timeoutMs: options.timeoutMs }
+      );
+    } catch (error) {
+      throw new Error(
+        `could not reach RNX Cloud at ${this.session.origin}: ${error instanceof Error ? error.message : String(error)}`
+      );
+    }
+    const text = await response.text();
+    if (!response.ok) throw responseError(response.status, text);
+    let parsed;
+    try {
+      parsed = JSON.parse(text);
+    } catch {
+      throw new Error("RNX Cloud command returned unreadable JSON");
+    }
+    if (!isRecord(parsed) || parsed.id !== body.id) {
+      throw new Error("RNX Cloud command returned an invalid command receipt");
+    }
+    if (typeof parsed.error === "string" && parsed.error) throw new Error(parsed.error);
+    if (!Object.hasOwn(parsed, "result")) {
+      throw new Error("RNX Cloud command receipt has no result");
+    }
+    return parsed.result;
+  }
+  async confirm() {
+    if (!this.session.claim) {
+      throw new Error("this simulator was attached with connect() and holds no claim");
+    }
+    const claimId = this.session.claim.id;
+    const response = await fetchWithCloudRetry(
+      `${this.session.origin}/v1/sims/${encodeURIComponent(this.session.simId)}/claim`,
+      {
+        method: "POST",
+        headers: {
+          authorization: `Bearer ${this.session.simulatorToken}`,
+          "content-type": "application/json"
+        },
+        body: JSON.stringify({ claimId })
+      }
+    );
+    const text = await response.text();
+    if (!response.ok) throw responseError(response.status, text);
+    let parsed;
+    try {
+      parsed = JSON.parse(text);
+    } catch {
+      throw new Error("RNX Cloud claim returned unreadable JSON");
+    }
+    const claim = readClaim(isRecord(parsed) ? parsed.claim : null);
+    if (claim.id !== claimId) {
+      throw new Error("RNX Cloud confirmation replaced the initial claim");
+    }
+    this.session = { ...this.session, claim };
+    return claim;
+  }
+  async close() {
+    const target = this.session.boxId !== null && this.session.boxToken !== null ? {
+      url: `${this.session.origin}/v1/boxes/${encodeURIComponent(this.session.boxId)}`,
+      authorization: `Bearer ${this.session.boxToken}`
+    } : {
+      url: `${this.session.origin}/v1/sims/${encodeURIComponent(this.session.simId)}`,
+      authorization: `Bearer ${this.session.simulatorToken}`
+    };
+    const response = await fetchWithCloudRetry(target.url, {
+      method: "DELETE",
+      headers: { authorization: target.authorization }
+    });
+    const text = await response.text();
+    if (!response.ok && response.status !== 404) {
+      throw responseError(response.status, text);
+    }
+  }
+};
+async function createRemoteSimulator(input) {
+  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`
+    );
+  }
+  if (input.artifact.byteLength <= 0) {
+    throw new Error("rnx Cloud artifact is empty");
+  }
+  readJsArtifact(input.artifact);
+  const origin = resolveOrigin(input.origin);
+  const sha256 = await sha256Hex(input.artifact);
+  if (input.sha256 && input.sha256 !== sha256) {
+    throw new Error("rnx Cloud artifact sha256 does not match the provided digest");
+  }
+  const device = input.device?.trim() || DEFAULT_DEVICE;
+  let response;
+  try {
+    response = await fetchWithCloudRetry(`${origin}/v1/boxes`, {
+      method: "POST",
+      headers: {
+        authorization: input.authorization,
+        "content-type": "application/javascript",
+        "x-rnx-box-size": "nano",
+        "x-rnx-artifact-sha256": sha256,
+        "x-rnx-platform": "ios",
+        "x-rnx-device": device
+      },
+      body: copyArrayBuffer(input.artifact)
+    });
+  } catch (error) {
+    throw new Error(
+      `could not reach RNX Cloud at ${origin}: ${error instanceof Error ? error.message : String(error)}`
+    );
+  }
+  const responseText = await response.text();
+  if (!response.ok) throw responseError(response.status, responseText);
+  let parsed;
+  try {
+    parsed = JSON.parse(responseText);
+  } catch {
+    throw new Error("RNX Cloud create returned unreadable JSON");
+  }
+  const created = readBoxCreate(parsed, input.artifact.byteLength, sha256);
+  const simulator = new RemoteSimulator({
+    origin,
+    boxId: created.receipt.boxId,
+    boxToken: created.boxToken,
+    simId: created.receipt.simulator.simId,
+    simulatorToken: created.simulatorToken,
+    claim: created.receipt.simulator.claim,
+    artifact: created.receipt.artifact,
+    scopes: RNX_CLOUD_TOKEN_SCOPES
+  });
+  await simulator.confirm();
+  return simulator;
+}
+function readSimArtifact(value) {
+  if (!isRecord(value) || typeof value.sha256 !== "string" || !/^[a-f0-9]{64}$/.test(value.sha256) || typeof value.bytes !== "number" || !Number.isInteger(value.bytes) || value.bytes <= 0) {
+    throw new Error("RNX Cloud returned an invalid simulator artifact");
+  }
+  return { id: `sha256:${value.sha256}`, bytes: value.bytes };
+}
+function readConnectClaim(value) {
+  if (value === null) return null;
+  return readClaim(value);
+}
+function readConnectScopes(value, token) {
+  if (!token.startsWith(RNX_CLOUD_SCOPED_TOKEN_PREFIX)) return RNX_CLOUD_TOKEN_SCOPES;
+  if (!isRecord(value) || typeof value.id !== "string" || !value.id || !Array.isArray(value.scopes) || value.scopes.length === 0 || !value.scopes.every(
+    (scope) => typeof scope === "string" && isRnxCloudCommandScope(scope)
+  ) || typeof value.expiresAt !== "number") {
+    throw new Error("RNX Cloud returned an invalid scoped token");
+  }
+  return Object.freeze([...value.scopes]);
+}
+async function connect(input) {
+  if (!input.id) throw new Error("RNX Cloud connect needs a simulator id");
+  if (!input.token) throw new Error("RNX Cloud connect needs a token");
+  const origin = resolveOrigin(input.origin);
+  let response;
+  try {
+    response = await fetchWithCloudRetry(
+      `${origin}/v1/sims/${encodeURIComponent(input.id)}`,
+      { headers: { authorization: `Bearer ${input.token}` } }
+    );
+  } catch (error) {
+    throw new Error(
+      `could not reach RNX Cloud at ${origin}: ${error instanceof Error ? error.message : String(error)}`
+    );
+  }
+  const text = await response.text();
+  if (!response.ok) throw responseError(response.status, text);
+  let parsed;
+  try {
+    parsed = JSON.parse(text);
+  } catch {
+    throw new Error("RNX Cloud connect returned unreadable JSON");
+  }
+  if (!isRecord(parsed) || !isRecord(parsed.sim)) {
+    throw new Error("RNX Cloud connect returned an invalid simulator");
+  }
+  const sim = parsed.sim;
+  if (typeof sim.simId !== "string" || !sim.simId) {
+    throw new Error("RNX Cloud connect returned an invalid simulator");
+  }
+  return new RemoteSimulator({
+    origin,
+    boxId: null,
+    boxToken: null,
+    simId: sim.simId,
+    simulatorToken: input.token,
+    claim: readConnectClaim(sim.claim ?? null),
+    artifact: readSimArtifact(sim.artifact),
+    scopes: readConnectScopes(isRecord(parsed) ? parsed.token : null, input.token)
+  });
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  RNX_CLOUD_COMMAND_TYPES,
+  RNX_CLOUD_MAX_ARTIFACT_BYTES,
+  RNX_CLOUD_SCOPED_TOKEN_PREFIX,
+  RemoteSimulator,
+  connect,
+  createRemoteSimulator,
+  isRnxCloudCommandScope,
+  isRnxCloudCommandType
+});