sootsim 0.1.140 → 0.1.142

package/dist-lib/skills.cjs

@@ -1,4 +1,4 @@
-/*! sootsim v0.1.140 | (c) 2026 Tamagui LLC | Proprietary — see LICENSE */
+/*! sootsim v0.1.142 | (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;
@@ -9982,7 +9982,7 @@ function hasOwnKeys(value) {
 }
 function hasSootSimConfig(config) {
   if (!config) return false;
-  return hasOwnKeys(config.modules) || hasOwnKeys(config.turboModules) || hasOwnKeys(config.nativeModules) || hasOwnKeys(config.env) || hasOwnKeys(config.settings) || hasOwnKeys(config.initialState);
+  return hasOwnKeys(config.modules) || hasOwnKeys(config.turboModules) || hasOwnKeys(config.nativeModules) || hasOwnKeys(config.env) || hasOwnKeys(config.network?.remap) || hasOwnKeys(config.settings) || hasOwnKeys(config.initialState);
 }
 function applySootSimConfigToUrl(url, config) {
   const parsed = new URL(url);
@@ -15325,10 +15325,6 @@ var init_app_state_reset = __esm({
       ),
     )
   } catch {}
-  try {
-    const names = await caches.keys()
-    await Promise.all(names.map((name) => caches.delete(name)))
-  } catch {}
   try {
     document.cookie.split(';').forEach((cookie) => {
       const name = cookie.split('=')[0]?.trim()
@@ -15465,36 +15461,241 @@ var init_settling = __esm({
   }
 });
 
-// cli/flow-file.ts
-function interpolateFlowEnv(value, scopedVars) {
-  if (typeof value === "string") {
-    return value.replace(/\$\{([A-Za-z_][A-Za-z0-9_]*)\}/g, (_match, name) => {
-      if (scopedVars?.has(name)) return scopedVars.get(name);
-      const resolved = process.env[name];
-      if (resolved === void 0) {
-        throw new Error(`missing environment variable for flow placeholder: ${name}`);
-      }
-      return resolved;
-    });
+// cli/maestro-js.ts
+function executeSyncHttp(url, method, params) {
+  if (params?.multipartForm) {
+    throw new Error("http: multipartForm is not supported by sootsim yet");
   }
-  if (Array.isArray(value)) {
-    return value.map((entry) => interpolateFlowEnv(entry, scopedVars));
+  const childEnv = { ...process.env };
+  for (const key of Object.keys(childEnv)) {
+    if (key.startsWith("BUN_INSPECT") || key === "NODE_OPTIONS") {
+      delete childEnv[key];
+    }
+  }
+  const child = (0, import_child_process6.spawnSync)(process.execPath, ["-e", HTTP_CHILD_SRC], {
+    input: JSON.stringify({ url, method, headers: params?.headers, body: params?.body }),
+    encoding: "utf8",
+    timeout: HTTP_TIMEOUT_MS,
+    maxBuffer: 64 * 1024 * 1024,
+    env: childEnv
+  });
+  if (child.error) {
+    throw new Error(`http ${method} ${url} failed: ${child.error.message}`);
   }
-  if (value && typeof value === "object") {
-    return Object.fromEntries(
-      Object.entries(value).map(([key, entry]) => [
-        key,
-        interpolateFlowEnv(entry, scopedVars)
-      ])
+  let parsed;
+  try {
+    parsed = JSON.parse(child.stdout || "");
+  } catch {
+    throw new Error(
+      `http ${method} ${url} failed: no response (${(child.stderr || "").trim().slice(0, 200)})`
     );
   }
-  return value;
+  const result = parsed;
+  if (result.__error) {
+    throw new Error(`http ${method} ${url} failed: ${result.__error}`);
+  }
+  return result;
 }
-var import_yaml;
-var init_flow_file = __esm({
-  "cli/flow-file.ts"() {
+function stringifyJs(value) {
+  if (value === void 0) return "undefined";
+  if (value === null) return "null";
+  if (typeof value === "object") {
+    try {
+      return JSON.stringify(value);
+    } catch {
+      return String(value);
+    }
+  }
+  return String(value);
+}
+function scriptConditionIsTruthy(value) {
+  if (value === void 0 || value === null) return false;
+  if (typeof value === "boolean") return value;
+  const text = String(value);
+  if (text.trim().length === 0) return false;
+  if (text.toLowerCase() === "false") return false;
+  if (text === "undefined" || text === "null") return false;
+  const num = Number(text);
+  if (!Number.isNaN(num) && num === 0) return false;
+  return true;
+}
+var import_child_process6, vm, HTTP_TIMEOUT_MS, HTTP_CHILD_SRC, TEMPLATE_RE, ESCAPED_TEMPLATE_RE, BARE_IDENTIFIER_RE, MaestroJsContext;
+var init_maestro_js = __esm({
+  "cli/maestro-js.ts"() {
     "use strict";
-    import_yaml = __toESM(require("yaml"), 1);
+    import_child_process6 = require("child_process");
+    vm = __toESM(require("vm"), 1);
+    HTTP_TIMEOUT_MS = 3e5;
+    HTTP_CHILD_SRC = `
+let input = '';
+process.stdin.on('data', (c) => { input += c });
+process.stdin.on('end', async () => {
+  try {
+    const req = JSON.parse(input);
+    const res = await fetch(req.url, {
+      method: req.method,
+      headers: req.headers,
+      body: req.body === undefined || req.body === null ? undefined : req.body,
+    });
+    const body = await res.text();
+    const headers = {};
+    for (const [k, v] of res.headers.entries()) {
+      headers[k] = headers[k] ? headers[k] + ',' + v : v;
+    }
+    process.stdout.write(JSON.stringify({ ok: res.ok, status: res.status, body, headers }));
+  } catch (err) {
+    process.stdout.write(JSON.stringify({ __error: (err && err.message) || String(err) }));
+    process.exitCode = 1;
+  }
+});
+`;
+    TEMPLATE_RE = /(?<!\\)\$\{([^$]*)\}/g;
+    ESCAPED_TEMPLATE_RE = /\\(\$\{[^$]*\})/g;
+    BARE_IDENTIFIER_RE = /^[A-Za-z_$][A-Za-z0-9_$]*$/;
+    MaestroJsContext = class {
+      context;
+      envBinding = /* @__PURE__ */ new Map();
+      envScopeStack = [];
+      // env keys currently materialized as context globals — cleared and re-set
+      // before each evaluation, mirroring upstream syncBindingsToContext.
+      syncedEnvKeys = /* @__PURE__ */ new Set();
+      output = {};
+      maestro;
+      constructor(opts = {}) {
+        this.maestro = { copiedText: null, platform: opts.platform ?? "ios" };
+        const onLog = opts.onLog ?? ((msg) => console.log(`[flow]   js: ${msg}`));
+        const sandbox = {
+          output: this.output,
+          maestro: this.maestro,
+          http: {
+            get: (url, params) => executeSyncHttp(url, "GET", params),
+            post: (url, params) => executeSyncHttp(url, "POST", params),
+            put: (url, params) => executeSyncHttp(url, "PUT", params),
+            delete: (url, params) => executeSyncHttp(url, "DELETE", params),
+            request: (url, params) => executeSyncHttp(url, (params?.method ?? "GET").toUpperCase(), params)
+          },
+          console: {
+            log: (...args) => onLog(args.map((a) => typeof a === "string" ? a : stringifyJs(a)).join(" "))
+          }
+        };
+        this.context = vm.createContext(sandbox);
+        vm.runInContext(
+          `
+      globalThis.__maestroScope = new Proxy(globalThis, {
+        has() { return true },
+        get(target, key) { return target[key] },
+      })
+      function json(text) { return JSON.parse(text) }
+      function relativePoint(x, y) {
+        var xPercent = Math.ceil(x * 100) + '%'
+        var yPercent = Math.ceil(y * 100) + '%'
+        return xPercent + ',' + yPercent
+      }
+      `,
+          this.context
+        );
+        for (const [key, value] of Object.entries(process.env)) {
+          if (value !== void 0) this.envBinding.set(key, value);
+        }
+      }
+      putEnv(key, value) {
+        this.envBinding.set(key, value);
+      }
+      setCopiedText(text) {
+        this.maestro.copiedText = text;
+      }
+      enterEnvScope() {
+        this.envScopeStack.push(new Map(this.envBinding));
+      }
+      leaveEnvScope() {
+        const previous = this.envScopeStack.pop();
+        if (previous) {
+          this.envBinding.clear();
+          for (const [k, v] of previous) this.envBinding.set(k, v);
+        }
+      }
+      // evaluate a JS snippet in the shared context. mirrors upstream
+      // evalWithIIFE: the script is embedded in a template literal and run
+      // through eval inside an IIFE so var/let/const stay scoped to this
+      // evaluation while the last expression's value is returned.
+      evaluate(script, opts = {}) {
+        const env = opts.env;
+        if (env && Object.keys(env).length > 0) {
+          this.enterEnvScope();
+          try {
+            for (const [k, v] of Object.entries(env)) this.envBinding.set(k, v);
+            return this.evalRaw(script);
+          } finally {
+            this.leaveEnvScope();
+          }
+        }
+        return this.evalRaw(script);
+      }
+      evalRaw(script) {
+        this.syncEnvToContext();
+        const escaped = script.replace(/\\/g, "\\\\").replace(/`/g, "\\`").replace(/\$\{/g, "\\${");
+        return vm.runInContext(
+          `(function(){ with(__maestroScope){ return eval(\`${escaped}\`) } })()`,
+          this.context
+        );
+      }
+      syncEnvToContext() {
+        const globals = vm.runInContext("globalThis", this.context);
+        for (const key of this.syncedEnvKeys) {
+          if (!this.envBinding.has(key)) delete globals[key];
+        }
+        this.syncedEnvKeys = /* @__PURE__ */ new Set();
+        for (const [key, value] of this.envBinding) {
+          try {
+            globals[key] = value;
+            this.syncedEnvKeys.add(key);
+          } catch {
+          }
+        }
+      }
+      // upstream Env.kt String.evaluateScripts: replace every unescaped `${expr}`
+      // with the stringified evaluation result, then unescape `\${...}`.
+      evaluateStringTemplate(value) {
+        const replaced = value.replace(TEMPLATE_RE, (_match, expr) => {
+          if (expr.trim().length === 0) return "";
+          const result = this.evaluate(expr);
+          if (result === void 0 && BARE_IDENTIFIER_RE.test(expr.trim())) {
+            throw new Error(`missing variable for flow placeholder: ${expr.trim()}`);
+          }
+          return stringifyJs(result);
+        });
+        return replaced.replace(ESCAPED_TEMPLATE_RE, (_match, inner) => inner);
+      }
+      // walk a parsed step and evaluate every string template. nested command
+      // lists are skipped — each nested command evaluates its own strings when
+      // it executes (matching upstream per-command evaluateScripts timing, and
+      // required for values that change between iterations, e.g. copyTextFrom
+      // inside repeat).
+      interpolateStep(step) {
+        return this.interpolateValue(step, null);
+      }
+      interpolateValue(value, parentKey) {
+        if (typeof value === "string") {
+          if (parentKey === "evalScript") return value;
+          return this.evaluateStringTemplate(value);
+        }
+        if (Array.isArray(value)) {
+          if (parentKey === "commands" || parentKey === "onFlowStart" || parentKey === "onFlowComplete") {
+            return value;
+          }
+          return value.map((entry) => this.interpolateValue(entry, parentKey));
+        }
+        if (value && typeof value === "object") {
+          return Object.fromEntries(
+            Object.entries(value).map(([key, entry]) => [
+              key,
+              this.interpolateValue(entry, key)
+            ])
+          );
+        }
+        return value;
+      }
+    };
   }
 });
 
@@ -15814,19 +16015,11 @@ var init_recording_access = __esm({
 var bridge_flow_runner_exports = {};
 __export(bridge_flow_runner_exports, {
   SootSimBridgeFlowRunner: () => SootSimBridgeFlowRunner,
-  clearFlowScopedVars: () => clearFlowScopedVars,
   normalizeFlowScreenshotSpec: () => normalizeFlowScreenshotSpec,
   parseFlowSteps: () => parseFlowSteps,
   resolveFlowScreenshotPath: () => resolveFlowScreenshotPath,
-  resolveFlowScreenshotPathWithMode: () => resolveFlowScreenshotPathWithMode,
-  setFlowScopedVar: () => setFlowScopedVar
+  resolveFlowScreenshotPathWithMode: () => resolveFlowScreenshotPathWithMode
 });
-function setFlowScopedVar(name, value) {
-  flowScopedVars.set(name, value);
-}
-function clearFlowScopedVars() {
-  flowScopedVars.clear();
-}
 function sleep(ms) {
   return new Promise((resolve6) => setTimeout(resolve6, ms));
 }
@@ -15873,34 +16066,39 @@ function parsePoint(value) {
 function parseFlowSteps(content) {
   const parts = content.split(/^---$/m);
   const candidate = parts.length > 1 ? parts[parts.length - 1] : content;
-  const parsed = interpolateFlowEnv(import_yaml2.default.parse(candidate), flowScopedVars);
+  const parsed = import_yaml.default.parse(candidate);
   return Array.isArray(parsed) ? parsed : [];
 }
-var fs7, path7, import_settings2, import_yaml2, DEFAULT_TIMEOUT, SCREEN_W, SCREEN_H, CLI_PERF_SESSION_GLOBAL, MAESTRO_COPIED_TEXT_KEY, flowScopedVars, SootSimBridgeFlowRunner;
+var fs7, path7, import_settings2, import_yaml, DEFAULT_TIMEOUT, SCREEN_W, SCREEN_H, CLI_PERF_SESSION_GLOBAL, SootSimBridgeFlowRunner;
 var init_bridge_flow_runner = __esm({
   "cli/bridge-flow-runner.ts"() {
     "use strict";
     fs7 = __toESM(require("fs"), 1);
     path7 = __toESM(require("path"), 1);
     import_settings2 = require("sootsim-engine/settings");
-    import_yaml2 = __toESM(require("yaml"), 1);
+    import_yaml = __toESM(require("yaml"), 1);
     init_frame_compose();
     init_app_state_reset();
     init_settling();
-    init_flow_file();
+    init_maestro_js();
     init_recording_access();
     DEFAULT_TIMEOUT = 1e4;
     SCREEN_W = 393;
     SCREEN_H = 852;
     CLI_PERF_SESSION_GLOBAL = "__sootsimCliPerf";
-    MAESTRO_COPIED_TEXT_KEY = "maestroCopiedText";
-    flowScopedVars = /* @__PURE__ */ new Map();
     SootSimBridgeFlowRunner = class {
       constructor(bridge, opts) {
         this.bridge = bridge;
         this.opts = opts;
       }
       stepDelay = 0;
+      // maestro-compatible JS context for the whole flow run (shared with
+      // runFlow sub-flows): `${...}` templates, runScript, evalScript, output,
+      // maestro.copiedText. one per runner = one per flow file, like upstream.
+      js = new MaestroJsContext({
+        platform: "ios",
+        onLog: (msg) => console.log(`[flow]   js: ${msg}`)
+      });
       firstLaunchDone = false;
       profilingEnabled = false;
       recordingEnabled = false;
@@ -16717,15 +16915,12 @@ var init_bridge_flow_runner = __esm({
       }
       async launchApp(opts) {
         await this.refreshSimId();
+        if (opts && typeof opts === "object" && opts.arguments) {
+          console.log("[flow]   launchApp.arguments ignored (sootsim has no native process)");
+        }
         const wantsClear = !!(opts && typeof opts === "object" && opts.clearState);
         if (wantsClear) {
-          await this.evaluate(`(async () => {
-        await (${CLEAR_APP_STATE_EVAL})
-        try {
-          const regs = await navigator.serviceWorker?.getRegistrations?.()
-          await Promise.all((regs || []).map((reg) => reg.unregister()))
-        } catch {}
-      })()`);
+          await this.evaluate(CLEAR_APP_STATE_EVAL, 6e4);
         }
         if (!this.firstLaunchDone && !wantsClear) {
           this.firstLaunchDone = true;
@@ -16900,7 +17095,8 @@ var init_bridge_flow_runner = __esm({
         );
       }
       // maestro copyTextFrom: find an element and capture its text for use in
-      // later steps via ${maestroCopiedText}. the matcher shape matches tapOn.
+      // later steps via ${maestro.copiedText} (upstream form) or the legacy
+      // ${maestroCopiedText}. the matcher shape matches tapOn.
       async copyTextFrom(target) {
         const opts = typeof target === "string" ? { id: target } : target;
         const node = await this.findElement(opts);
@@ -16908,36 +17104,52 @@ var init_bridge_flow_runner = __esm({
           throw new Error(`copyTextFrom: element not found: ${JSON.stringify(opts)}`);
         }
         const captured = node.text ?? node.testID ?? "";
-        flowScopedVars.set(MAESTRO_COPIED_TEXT_KEY, captured);
+        this.js.setCopiedText(captured);
+        this.js.putEnv("maestroCopiedText", captured);
         console.log(`[flow]   copied text: ${JSON.stringify(captured)}`);
       }
-      // maestro evalScript: run arbitrary JS in the page via the bridge's eval
-      // channel. the return value is logged but not stored — use copyTextFrom
-      // (or a side-effect on window) for flows that need to round-trip data.
-      async evalScript(code) {
-        const result = await this.evaluate(`(async () => {
-      try {
-        return { ok: true, value: await (async () => { ${code} })() }
-      } catch (err) {
-        return { ok: false, error: err && err.message ? err.message : String(err) }
-      }
-    })()`);
-        const r = result;
-        if (!r.ok) throw new Error(`evalScript failed: ${r.error}`);
-        if (r.value !== void 0) {
-          console.log(`[flow]   evalScript ->`, r.value);
+      // maestro evalScript: run JS in the flow's shared HOST-side context (the
+      // same engine that owns `output` and env vars) — never in the app page.
+      // the canonical maestro form is `evalScript: ${output.x = 1}`, which is
+      // pure template evaluation. a script with no `${}` at all would be a
+      // silent no-op upstream; we charitably evaluate it as raw JS in the same
+      // context so plain-JS evalScript blocks fail or work loudly.
+      evalScript(code) {
+        const hasTemplate = /(?<!\\)\$\{[^$]*\}/.test(code);
+        const result = hasTemplate ? this.js.evaluateStringTemplate(code) : this.js.evaluate(code);
+        if (result !== void 0 && result !== "") {
+          console.log(`[flow]   evalScript ->`, result);
         }
       }
-      // maestro openLink: navigate the sim to a URL via the bridge's eval
-      // channel. on-device maestro asks the OS to open the link; in sootsim we
-      // just drive window.location so the current app sees the deep link.
+      // maestro runScript: execute a JS file in the shared flow context. env
+      // vars are scoped to the script (upstream runInSubScope=true). paths
+      // resolve relative to the flow file, like runFlow.
+      runScript(target) {
+        const spec = typeof target === "string" ? { file: target } : target;
+        if (!spec.file) throw new Error("runScript requires a file");
+        const scriptPath = path7.resolve(this.opts.flowDir, spec.file);
+        const source = fs7.readFileSync(scriptPath, "utf8");
+        this.js.evaluate(source, { env: spec.env });
+        console.log(`[flow]   runScript: ${spec.file} done`);
+      }
+      // maestro openLink: on-device maestro asks the OS to open the link, and
+      // iOS routes an app-claimed URL into the running app as a Linking 'url'
+      // event. sootsim mirrors that: dispatch through the engine's Linking
+      // emulation so react-navigation useLinking / addEventListener('url')
+      // handlers fire exactly like on a real device. an app that doesn't
+      // handle the link simply ignores it (same as iOS routing to Safari —
+      // the app under test sees nothing).
       async openLink(target) {
         const link = typeof target === "string" ? target : target.link;
         if (!link) throw new Error("openLink: missing link");
-        await this.evaluate(`window.location.href = ${JSON.stringify(link)}`);
+        const result = await this.callTest(
+          "openDeepLink",
+          link
+        );
+        if (!result?.ok) {
+          throw new Error(`openLink failed: ${result?.error || "no test bridge"}`);
+        }
         await sleep(300);
-        await this.refreshSimId();
-        await this.waitForTree(3e4);
       }
       // evaluate a `when:` predicate. returns true if the step should run.
       async evaluateWhen(when) {
@@ -16952,10 +17164,10 @@ var init_bridge_flow_runner = __esm({
           return !el;
         }
         if (when.platform !== void 0) {
-          return when.platform.toLowerCase() === "ios";
+          return when.platform.toLowerCase() === this.js.maestro.platform.toLowerCase();
         }
         if (when.true !== void 0) {
-          return when.true.toLowerCase() !== "false";
+          return scriptConditionIsTruthy(when.true);
         }
         return true;
       }
@@ -16966,9 +17178,26 @@ var init_bridge_flow_runner = __esm({
         const value = entry ? entry[1] : void 0;
         return !!(value && typeof value === "object" && "optional" in value && value.optional);
       }
-      async runStep(step, stepIndex) {
-        const stepName = Object.keys(step).find((k) => k !== "when") || Object.keys(step)[0];
+      async runStep(rawStep, stepIndex) {
+        const stepName = Object.keys(rawStep).find((k) => k !== "when") || Object.keys(rawStep)[0];
         console.log(`[flow] step ${stepIndex + 1}: ${stepName}`);
+        let step;
+        try {
+          step = this.js.interpolateStep(rawStep);
+        } catch (error) {
+          if (this.isOptional(rawStep)) {
+            console.log(
+              `[flow]   (optional, skipped: ${error.message.slice(0, 80)})`
+            );
+            return;
+          }
+          this.lastFailedStep = {
+            index: stepIndex,
+            kind: stepName,
+            target: rawStep[stepName]
+          };
+          throw error;
+        }
         if (step.when) {
           const shouldRun = await this.evaluateWhen(step.when);
           if (!shouldRun) {
@@ -16977,7 +17206,9 @@ var init_bridge_flow_runner = __esm({
           }
         }
         try {
-          const hasExplicitWait = !!(step.extendedWaitUntil || step.waitFor || step.scrollUntilVisible || step.launchApp || step.runFlow);
+          const hasExplicitWait = !!(step.extendedWaitUntil || step.waitFor || step.scrollUntilVisible || step.launchApp || step.runFlow || // runScript http calls are synchronous with a 5-minute upstream
+          // timeout — the 10s watchdog would kill legitimate setup scripts.
+          step.runScript);
           const STEP_WATCHDOG_MS = 1e4;
           const body = this.runStepInner(step);
           if (hasExplicitWait) {
@@ -17073,7 +17304,11 @@ var init_bridge_flow_runner = __esm({
         } else if (typeof step.eraseText === "number") {
           await this.eraseText(step.eraseText);
         } else if (step.repeat) {
-          for (let i = 0; i < step.repeat.times; i++) {
+          const times = Number(step.repeat.times);
+          if (!Number.isFinite(times)) {
+            throw new Error(`repeat.times is not a number: ${step.repeat.times}`);
+          }
+          for (let i = 0; i < times; i++) {
             for (let j = 0; j < step.repeat.commands.length; j++) {
               await this.runStep(step.repeat.commands[j], j);
             }
@@ -17087,26 +17322,59 @@ var init_bridge_flow_runner = __esm({
         } else if (step.copyTextFrom !== void 0) {
           await this.copyTextFrom(step.copyTextFrom);
         } else if (typeof step.evalScript === "string") {
-          await this.evalScript(step.evalScript);
+          this.evalScript(step.evalScript);
+        } else if (step.runScript) {
+          const rs = step.runScript;
+          const innerWhen = typeof rs === "string" ? void 0 : rs.when;
+          if (innerWhen && !await this.evaluateWhen(innerWhen)) {
+            console.log(`[flow]   runScript skipped (when predicate false)`);
+            return;
+          }
+          this.runScript(rs);
         } else if (step.openLink !== void 0) {
           await this.openLink(step.openLink);
         } else if (step.runFlow) {
           const rf = step.runFlow;
           const file = typeof rf === "string" ? rf : rf.file;
+          const commands = typeof rf === "string" ? void 0 : rf.commands;
+          const env = typeof rf === "string" ? void 0 : rf.env;
           const innerWhen = typeof rf === "string" ? void 0 : rf.when;
           if (innerWhen) {
             const shouldRun = await this.evaluateWhen(innerWhen);
             if (!shouldRun) {
-              console.log(`[flow] runFlow skipped (when predicate false): ${file}`);
+              console.log(
+                `[flow] runFlow skipped (when predicate false): ${file ?? "inline commands"}`
+              );
               return;
             }
           }
-          const flowPath = path7.resolve(this.opts.flowDir, file);
-          const flowContent = fs7.readFileSync(flowPath, "utf8");
-          const previousDir = this.opts.flowDir;
-          this.opts.flowDir = path7.dirname(flowPath);
-          await this.runFlow(parseFlowSteps(flowContent));
-          this.opts.flowDir = previousDir;
+          if (!file && !commands) {
+            throw new Error("runFlow requires either file or commands");
+          }
+          this.js.enterEnvScope();
+          try {
+            if (env) {
+              for (const [k, v] of Object.entries(env)) this.js.putEnv(k, v);
+            }
+            if (file) {
+              const flowPath = path7.resolve(this.opts.flowDir, file);
+              const flowContent = fs7.readFileSync(flowPath, "utf8");
+              const previousDir = this.opts.flowDir;
+              this.opts.flowDir = path7.dirname(flowPath);
+              try {
+                await this.runFlow(parseFlowSteps(flowContent));
+              } finally {
+                ;
+                this.opts.flowDir = previousDir;
+              }
+            } else if (commands) {
+              for (let i = 0; i < commands.length; i++) {
+                await this.runStep(commands[i], i);
+              }
+            }
+          } finally {
+            this.js.leaveEnvScope();
+          }
         } else {
           throw new Error(`unsupported flow step: ${JSON.stringify(step)}`);
         }
@@ -17159,7 +17427,7 @@ var init_bridge_flow_runner = __esm({
           const explicitWait = typeof step.wait === "number" ? step.wait : 0;
           const waitForTimeout = typeof step.waitFor?.timeout === "number" ? step.waitFor.timeout : 0;
           const stepCeiling = Math.max(6e4, explicitWait + 15e3, waitForTimeout + 15e3);
-          if (step.runFlow) {
+          if (step.runFlow || step.launchApp) {
             await this.runStep(step, i);
             continue;
           }
@@ -17489,7 +17757,7 @@ var skill5 = {
       async execute(params, context) {
         const fs9 = await import("fs");
         const path9 = await import("path");
-        const yaml3 = await import("yaml");
+        const yaml2 = await import("yaml");
         const { DEFAULT_SOOTSIM_BRIDGE_PORT: DEFAULT_SOOTSIM_BRIDGE_PORT2 } = await Promise.resolve().then(() => (init_bridge_constants(), bridge_constants_exports));
         const { SootSimBridgeHost: SootSimBridgeHost2 } = await Promise.resolve().then(() => (init_bridge_host(), bridge_host_exports));
         const { createBridge: createBridge2 } = await Promise.resolve().then(() => (init_ws_bridge(), ws_bridge_exports));
@@ -17500,7 +17768,7 @@ var skill5 = {
           const flowContent = fs9.readFileSync(params.flowPath, "utf8");
           const fmMatch = flowContent.match(/^---\n([\s\S]*?)\n---\n?/);
           const stepsBody = fmMatch ? flowContent.slice(fmMatch[0].length) : flowContent;
-          const steps = yaml3.parse(stepsBody);
+          const steps = yaml2.parse(stepsBody);
           const beforeIds = new Set(host.listSims().map((sim) => sim.id));
           await host.openUrl(context.url);
           let simId = null;

package/dist-lib/vite.cjs

@@ -1,4 +1,4 @@
-/*! sootsim v0.1.140 | (c) 2026 Tamagui LLC | Proprietary — see LICENSE */
+/*! sootsim v0.1.142 | (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": "sootsim",
-  "version": "0.1.140",
+  "version": "0.1.142",
   "description": "sootsim CLI + vite/metro plugins + skills registry. bridge client for driving the proprietary sootsim-engine over WebSocket.",
   "author": "Tamagui LLC",
   "license": "MIT",

package/src/config.ts

@@ -20,6 +20,15 @@ export interface SootSimConfig<
   turboModules?: Record<string, NativeModuleResolution>
   nativeModules?: Record<string, NativeModuleResolution>
   env?: Record<string, string>
+  // generic per-sim network rewrites for the guest app's runtime fetches.
+  // `remap` keys/values are `host:port` (or bare `host`) — a tenant fetch whose
+  // url matches a key has its host:port swapped for the value before the
+  // request is issued. exists for third-party e2e suites that hardcode a port
+  // (e.g. bluesky's flows type `http://localhost:3000`) which collides with a
+  // host service; map it to the real bound port without editing the app.
+  network?: {
+    remap?: Record<string, string>
+  }
   settings?: Partial<Settings>
   initialState?: {
     authenticated?: boolean
@@ -51,6 +60,7 @@ export function hasSootSimConfig<
     hasOwnKeys(config.turboModules as Record<string, unknown> | undefined) ||
     hasOwnKeys(config.nativeModules as Record<string, unknown> | undefined) ||
     hasOwnKeys(config.env as Record<string, unknown> | undefined) ||
+    hasOwnKeys(config.network?.remap as Record<string, unknown> | undefined) ||
     hasOwnKeys(config.settings as Record<string, unknown> | undefined) ||
     hasOwnKeys(config.initialState as Record<string, unknown> | undefined)
   )
@@ -74,6 +84,9 @@ export function mergeSootSimConfig<
       ...(override.nativeModules || {}),
     },
     env: { ...(base.env || {}), ...(override.env || {}) },
+    network: {
+      remap: { ...(base.network?.remap || {}), ...(override.network?.remap || {}) },
+    },
     settings: {
       ...(base.settings || {}),
       ...(override.settings || {}),