simframe 0.1.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Sadjad Asadi
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,236 @@
+# simframe
+
+[![ci](https://github.com/lvlrSajjad/simframe/actions/workflows/ci.yml/badge.svg)](https://github.com/lvlrSajjad/simframe/actions/workflows/ci.yml)
+[![npm](https://img.shields.io/npm/v/simframe.svg)](https://www.npmjs.com/package/simframe)
+[![license](https://img.shields.io/npm/l/simframe.svg)](./LICENSE)
+
+**Always-warm iOS Simulator frames for coding agents.**
+
+[Website](https://lvlrsajjad.github.io/simframe/) · [npm](https://www.npmjs.com/package/simframe)
+
+An agent that drives the iOS Simulator spends most of its time waiting on
+screenshots. Every "let me check the screen" is a fresh `simctl io screenshot`:
+a process spawn, a framebuffer grab, a file write, an image encode. On this
+machine that is ~130 ms of pure blocking latency, paid again on every look — and
+the agent pays it *twice* whenever it screenshots too early, sees a
+mid-animation frame, and has to look again.
+
+simframe removes the wait from the request path. A tiny background loop keeps
+the newest frame of your simulator permanently warm on disk, so when the agent
+asks what's on screen it gets an answer in **~20 ms** instead of ~130 ms — and
+can ask "did anything change?" for **~2 ms and no image at all**.
+
+```
+                    without simframe                  with simframe
+agent asks    ──►  spawn simctl ──► grab ──► encode ──► image      ~130-400 ms
+agent asks    ──►  read the frame that is already there ──► image   ~20 ms
+agent polls   ──►  read 300 bytes of JSON ──► text                  ~2 ms
+```
+
+## Why this makes an agent faster
+
+Speed is not only latency. It is also *how many* round trips a question takes
+and how many tokens each one costs.
+
+| Question the agent has | Before | With simframe |
+| --- | --- | --- |
+| "What's on screen?" | screenshot, ~130-400 ms, full image every time | `sim_look`, ~20 ms, warm frame |
+| "Has it finished loading yet?" | screenshot in a loop, an image per attempt | `sim_state`, ~2 ms, **text only** |
+| "Did my tap do anything?" | screenshot, compare by eye | `sim_state` — a stable screen hash plus an ASCII map of which regions moved |
+| "Wait for the animation to end" | sleep, screenshot, hope, repeat | `sim_wait` — blocks until the screen actually settles, then returns the frame |
+| "What did that transition look like?" | 5 screenshots, 5 round trips, 5 images | `sim_strip` — the last N buffered frames tiled into **one** image, looking backwards in time |
+
+The change map is the part that pays for itself. A screen hash and a
+4×8 movement grid cost a couple of hundred bytes, so an agent can poll freely
+and only spend image tokens when there is genuinely something new to look at:
+
+```
+$ simframe state
+iPhone 17 Pro  frame #3  age 124ms  322x700
+hash 007cfefefefefefefefefefefefefe00  diff 0.15453  stable 0ms
+@@@@
+###*
++*#*
+:.#*
+..#*
+..#*
+..#*
+@@@@      ← a screen sliding in from the right, mid-transition
+```
+
+## Install
+
+```bash
+npm install -g simframe
+simframe doctor
+```
+
+`doctor` verifies Xcode's command line tools, `sips`, a booted simulator, and
+an actual round-trip capture.
+
+### Claude Code
+
+```bash
+claude mcp add simframe -- npx -y simframe mcp
+```
+
+### Any other MCP client
+
+```json
+{
+  "mcpServers": {
+    "simframe": {
+      "command": "npx",
+      "args": ["-y", "simframe", "mcp"]
+    }
+  }
+}
+```
+
+Nothing else to set up. Capture starts on the first tool call, targets the
+booted simulator, and stops itself 15 minutes after the last request.
+
+## MCP tools
+
+| Tool | What it does |
+| --- | --- |
+| `sim_look` | The newest buffered frame as an image, no capture wait. `detail`: `low` (~420 px) / `normal` (~700 px, default) / `high` (~1100 px) / `full` (native). |
+| `sim_state` | Text only: screen hash, how long the screen has been still, change since the previous frame, and the region movement map. |
+| `sim_wait` | Blocks until the screen settles (`mode: "stable"`) or moves away from what it shows now (`mode: "change"`), then returns the frame. |
+| `sim_strip` | The last N buffered frames tiled into one image, oldest first, with millisecond offsets. |
+| `sim_capture` | `status` / `start` / `stop` for the background loops. Rarely needed. |
+| `sim_devices` | Booted simulators simframe can capture. |
+
+Every tool takes an optional `device` (UDID or a substring of the name) and
+defaults to the booted simulator.
+
+## CLI
+
+The same capabilities without an agent, useful for debugging and scripts:
+
+```bash
+simframe start                 # start the capture loop
+simframe state                 # metadata + change map
+simframe frame --out=now.png   # newest frame, --detail=low|normal|high|full
+simframe wait --stable-ms=700  # block until the screen settles
+simframe wait --change         # block until the screen changes
+simframe strip --count=6       # contact sheet of recent frames
+simframe status                # what is running, and how fresh
+simframe stop --all
+simframe devices --all
+simframe doctor
+```
+
+## How it works
+
+```
+┌──────────────────────────── background, one per simulator ───┐
+│  xcrun simctl io screenshot  ──►  sips -Z  ──►  decode PNG   │
+│         ~130 ms                    ~30 ms        ~6 ms       │
+│                          │                                   │
+│              rename into ~/.simframe/<udid>/                  │
+│              latest.png · ring/<seq>.png · state.json         │
+└───────────────────────────────────────────────────────────────┘
+                           │  a rename is atomic
+┌──────────────────────────▼────────────────────────────────────┐
+│  MCP server / CLI: stat + read. No simctl in the request path.│
+└───────────────────────────────────────────────────────────────┘
+```
+
+A few decisions worth knowing about:
+
+- **Files are the IPC.** The loop renames completed frames into place and
+  readers just read them. A rename is atomic, so a reader can never see a
+  half-written frame, and there is no socket, port or protocol to get wrong.
+- **Zero image dependencies.** Resizing uses `sips`, which ships with macOS.
+  PNG encode/decode and all frame comparison are a few hundred lines of plain
+  JavaScript over `node:zlib`. The only runtime dependency is the MCP SDK.
+- **It backs off when nothing is happening.** 4 fps while the screen is moving,
+  1.5 fps once it has been still for 2.5 s, snapping back instantly on change.
+  Measured on an M-series Mac: **1.1 % CPU idle, 3.1 % active.**
+- **Comparison is done on a small grayscale grid,** which is why "did anything
+  change?" costs microseconds. The screen hash is a 128-bit mean-threshold
+  hash: the same screen always produces the same hash, even though the JPEG and
+  PNG bytes coming out of `simctl` are not stable frame to frame.
+- **One writer per device.** Ownership is recorded in `meta.json`; a second loop
+  refuses to start, and a loop that has been superseded retires itself. Two
+  loops would otherwise overwrite and prune each other's frames.
+- **Capture is independent of the Simulator window.** `simctl` reads the
+  framebuffer, so frames keep flowing while the window is hidden, behind other
+  windows, or on another Space.
+
+## Measured
+
+iPhone 17 Pro, iOS 26.5, Apple Silicon, default settings:
+
+| | |
+| --- | --- |
+| Warm frame read (`sim_look`) | ~20 ms |
+| State check (`sim_state`) | ~2 ms |
+| Contact sheet (`sim_strip`, 5 frames) | ~30 ms |
+| Cold start (first frame after boot) | ~400 ms, once |
+| Frame age when read | ≤ ~250 ms active, ≤ ~670 ms idle |
+| Raw `simctl io screenshot` for comparison | ~130 ms, on every single look |
+| CPU | 1.1 % idle, 3.1 % active |
+| Disk | ~2 MB per device (24-frame ring) |
+
+Image sizes are chosen for token cost as much as legibility: at `detail: normal`
+a frame is ~322×700, roughly a third of the pixels — and so roughly a third of
+the image tokens — of a native-resolution screenshot, while the status bar stays
+readable. `sim_state` sends no image at all.
+
+## Requirements
+
+- macOS with Xcode command line tools (`xcrun simctl`)
+- Node.js ≥ 18.17
+- A booted iOS Simulator
+
+## Limitations
+
+- Simulators only. `simctl` cannot capture a physical device.
+- simframe **reads** the screen; it does not tap, swipe or type. It is meant to
+  sit alongside whatever already drives input, replacing only the screenshot.
+- Capture tops out near 6 fps, because `simctl io screenshot` costs ~130 ms.
+  Fast animations are sampled, not recorded.
+
+## Roadmap
+
+- A higher-frame-rate backend via `simctl io recordVideo` piped through ffmpeg,
+  used automatically when ffmpeg is present.
+- Optional accessibility-tree text alongside the frame, so an agent can read
+  labels without spending image tokens.
+- Fusing input with settle-and-look, so tap → wait → see is one round trip
+  rather than three.
+
+## Releasing
+
+`npm version <patch|minor|major>` does not update `server.json`, so bump both,
+then push the tag:
+
+```bash
+npm version minor --no-git-tag-version      # bumps package.json
+$EDITOR server.json                         # match "version" and packages[0].version
+git commit -am "Release v0.2.0" && git tag v0.2.0
+git push && git push --tags
+```
+
+The `release` workflow then verifies that the tag, `package.json` and
+`server.json` all agree, validates `server.json` against the live registry, and
+publishes to npm and to the MCP Registry. It needs an npm automation token in
+the `NPM_TOKEN` repository secret; the MCP Registry needs no secret, because it
+trusts the workflow's GitHub OIDC identity.
+
+To publish by hand instead:
+
+```bash
+npm publish --access public
+
+curl -fsSL https://github.com/modelcontextprotocol/registry/releases/latest/download/mcp-publisher_darwin_arm64.tar.gz | tar -xz mcp-publisher
+./mcp-publisher validate
+./mcp-publisher login github
+./mcp-publisher publish
+```
+
+## License
+
+MIT

package/package.json

@@ -0,0 +1,54 @@
+{
+  "name": "simframe",
+  "version": "0.1.0",
+  "mcpName": "io.github.lvlrSajjad/simframe",
+  "description": "Always-warm iOS Simulator frames: agents read the screen in ~20ms instead of waiting on screenshots. MCP server + CLI.",
+  "keywords": [
+    "ios",
+    "simulator",
+    "mcp",
+    "model-context-protocol",
+    "claude",
+    "claude-code",
+    "screenshot",
+    "xcode",
+    "simctl",
+    "agent"
+  ],
+  "homepage": "https://github.com/lvlrSajjad/simframe#readme",
+  "bugs": {
+    "url": "https://github.com/lvlrSajjad/simframe/issues"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/lvlrSajjad/simframe.git"
+  },
+  "license": "MIT",
+  "author": "Sadjad Asadi (https://github.com/lvlrSajjad)",
+  "type": "module",
+  "os": [
+    "darwin"
+  ],
+  "engines": {
+    "node": ">=18.17"
+  },
+  "bin": {
+    "simframe": "src/cli.js"
+  },
+  "exports": {
+    ".": "./src/index.js"
+  },
+  "files": [
+    "src",
+    "README.md",
+    "LICENSE"
+  ],
+  "scripts": {
+    "test": "node --test test/unit.test.mjs",
+    "mcp": "node src/cli.js mcp",
+    "smoke": "node scripts/smoke.mjs"
+  },
+  "dependencies": {
+    "@modelcontextprotocol/sdk": "^1.0.0"
+  }
+}

package/src/analyze.js

@@ -0,0 +1,65 @@
+// Frame comparison. Everything here works on a small grayscale grid, so a
+// "did anything change?" question costs microseconds and no image tokens.
+import { grayGrid } from './png.js';
+
+export const HASH_COLS = 8;
+export const HASH_ROWS = 16;
+export const REGION_COLS = 4;
+export const REGION_ROWS = 8;
+
+/** A 128-bit mean-threshold hash, rendered as hex. Same screen => same hash. */
+export function frameHash(bmp) {
+  const { gray } = grayGrid(bmp, HASH_COLS, HASH_ROWS);
+  let mean = 0;
+  for (const v of gray) mean += v;
+  mean /= gray.length;
+  let hex = '';
+  for (let i = 0; i < gray.length; i += 4) {
+    let nibble = 0;
+    for (let b = 0; b < 4; b++) if (gray[i + b] > mean) nibble |= 1 << b;
+    hex += nibble.toString(16);
+  }
+  return hex;
+}
+
+/** Coarse per-region change, 0-100, laid out row-major over REGION_COLS x REGION_ROWS. */
+export function regionSignature(bmp) {
+  return Array.from(grayGrid(bmp, REGION_COLS, REGION_ROWS).gray);
+}
+
+/** Mean absolute difference of two region signatures, as a 0-1 fraction. */
+export function signatureDiff(a, b) {
+  if (!a || !b || a.length !== b.length) return 1;
+  let sum = 0;
+  for (let i = 0; i < a.length; i++) sum += Math.abs(a[i] - b[i]);
+  return sum / a.length / 255;
+}
+
+/** Per-region change fractions, so callers can tell a toast from a screen push. */
+export function regionDeltas(a, b) {
+  if (!a || !b || a.length !== b.length) return a ? a.map(() => 1) : [];
+  return a.map((v, i) => Math.abs(v - b[i]) / 255);
+}
+
+const RAMP = ['.', ':', '+', '*', '#', '@'];
+// Screen changes span orders of magnitude — a moving caret is ~0.3%, a screen
+// push is ~30% — so the ramp is bucketed logarithmically rather than linearly.
+const RAMP_STOPS = [0.002, 0.01, 0.03, 0.08, 0.2];
+
+export function rampLevel(delta) {
+  let level = 0;
+  for (const stop of RAMP_STOPS) if (delta >= stop) level++;
+  return level;
+}
+
+/** Render region deltas as a tiny ASCII map: readable in text, ~40 tokens. */
+export function regionMap(deltas, cols = REGION_COLS) {
+  if (!deltas.length) return '';
+  const lines = [];
+  for (let r = 0; r < deltas.length / cols; r++) {
+    let line = '';
+    for (let c = 0; c < cols; c++) line += RAMP[rampLevel(deltas[r * cols + c] ?? 0)];
+    lines.push(line);
+  }
+  return lines.join('\n');
+}

package/src/cli.js

@@ -0,0 +1,253 @@
+#!/usr/bin/env node
+import fs from 'node:fs';
+import path from 'node:path';
+import { runDaemon, DEFAULTS } from './daemon.js';
+import { bootedDevices, listDevices, resolveDevice } from './simctl.js';
+import * as api from './index.js';
+import * as store from './store.js';
+
+const USAGE = `simframe — always-warm iOS Simulator frames
+
+  simframe mcp                       run the MCP server on stdio (for agents)
+  simframe start   [device]          start the capture loop in the background
+  simframe stop    [device|--all]    stop the capture loop
+  simframe status  [device]          show daemon and newest-frame status
+  simframe frame   [device]          write the newest frame to a file
+  simframe state   [device]          print frame metadata and the change map
+  simframe wait    [device]          wait for the screen to settle
+  simframe strip   [device]          write a contact sheet of recent frames
+  simframe devices                   list simulators
+  simframe doctor                    check that this machine can capture
+
+Options
+  --device=<udid|name>   simulator to target (default: the booted one)
+  --out=<file>           output path for frame/strip
+  --detail=low|normal|high|full   or --detail=<max pixels>
+  --fps=<n>              capture rate while the screen is moving (default ${DEFAULTS.fps})
+  --count=<n>            frames in a strip (default 5)
+  --stable-ms=<n>        settle window for wait (default 600)
+  --timeout-ms=<n>       give up after this long (default 8000)
+  --json                 machine-readable output
+`;
+
+function parseArgs(argv) {
+  const flags = {};
+  const positional = [];
+  for (const arg of argv) {
+    if (arg.startsWith('--')) {
+      const [key, value] = arg.slice(2).split('=');
+      const camel = key.replace(/-([a-z])/g, (_, c) => c.toUpperCase());
+      flags[camel] = value === undefined ? true : value;
+    } else {
+      positional.push(arg);
+    }
+  }
+  return { flags, positional };
+}
+
+const num = (v, fallback) => (v == null ? fallback : Number(v));
+
+async function main() {
+  const [command, ...rest] = process.argv.slice(2);
+  const { flags, positional } = parseArgs(rest);
+  const device = flags.device || positional[0];
+  const options = {};
+  if (flags.fps) options.fps = num(flags.fps);
+  if (flags.maxDim) options.maxDim = num(flags.maxDim);
+  if (flags.ringSize) options.ringSize = num(flags.ringSize);
+
+  switch (command) {
+    case undefined:
+    case '-h':
+    case '--help':
+    case 'help':
+      process.stdout.write(USAGE);
+      return;
+
+    case '--version':
+    case 'version': {
+      const pkg = JSON.parse(fs.readFileSync(new URL('../package.json', import.meta.url), 'utf8'));
+      console.log(pkg.version);
+      return;
+    }
+
+    case 'mcp': {
+      const { serve } = await import('./mcp.js');
+      await serve({ device, options });
+      return;
+    }
+
+    // Internal: the detached capture process.
+    case 'daemon': {
+      const resolved = await resolveDevice(device);
+      await runDaemon(resolved, options);
+      return;
+    }
+
+    case 'start': {
+      const { device: dev, state, started } = await api.ensureDaemon(device, options);
+      console.log(
+        `${started ? 'started' : 'already running'} — ${dev.name} (${dev.runtime}) frame #${state.seq} ${state.width}x${state.height}`,
+      );
+      return;
+    }
+
+    case 'stop': {
+      const targets = flags.all
+        ? fs.existsSync(store.ROOT)
+          ? fs.readdirSync(store.ROOT)
+          : []
+        : [(await resolveDevice(device)).udid];
+      let stopped = 0;
+      for (const udid of targets) if (api.stopDaemon(udid)) stopped++;
+      console.log(`stopped ${stopped} daemon${stopped === 1 ? '' : 's'}`);
+      return;
+    }
+
+    case 'status': {
+      const udids = device
+        ? [(await resolveDevice(device)).udid]
+        : fs.existsSync(store.ROOT)
+          ? fs.readdirSync(store.ROOT)
+          : [];
+      const rows = udids.map((udid) => {
+        const { meta, pid, alive, stale } = api.daemonStatus(udid);
+        const state = store.readJson(store.paths(udid).state);
+        return {
+          udid,
+          device: meta?.device?.name ?? '?',
+          pid,
+          running: alive || stale,
+          stale,
+          seq: state?.seq ?? null,
+          ageMs: state ? Date.now() - state.capturedAt : null,
+          size: state ? `${state.width}x${state.height}` : null,
+          stableForMs: state?.stableForMs ?? null,
+        };
+      });
+      if (flags.json) {
+        console.log(JSON.stringify(rows, null, 2));
+      } else if (!rows.length) {
+        console.log('no simframe daemons have run yet');
+      } else {
+        for (const r of rows) {
+          console.log(
+            `${r.running ? '●' : '○'} ${r.device.padEnd(18)} pid=${r.pid ?? '-'} frame=#${r.seq ?? '-'} age=${r.ageMs ?? '-'}ms ${r.size ?? ''} stable=${r.stableForMs ?? '-'}ms`,
+          );
+        }
+      }
+      return;
+    }
+
+    case 'frame': {
+      const res = await api.getFrame(device, { detail: flags.detail ?? 'normal', options });
+      const out = flags.out || path.join(process.cwd(), 'simframe.png');
+      fs.writeFileSync(out, res.png);
+      console.log(`${out} — ${res.width}x${res.height}, ${res.ageMs}ms old, frame #${res.state.seq}`);
+      return;
+    }
+
+    case 'state': {
+      const res = await api.getState(device, { options });
+      if (flags.json) {
+        console.log(JSON.stringify({ ...res.state, ageMs: res.ageMs }, null, 2));
+      } else {
+        const s = res.state;
+        console.log(
+          `${res.device.name}  frame #${s.seq}  age ${res.ageMs}ms  ${s.width}x${s.height}\n` +
+            `hash ${s.hash}  diff ${s.diff}  stable ${s.stableForMs}ms\n${res.map}`,
+        );
+      }
+      return;
+    }
+
+    case 'wait': {
+      const res = await api.waitFor(device, {
+        mode: flags.mode || (flags.change ? 'change' : 'stable'),
+        stableMs: num(flags.stableMs, 600),
+        timeoutMs: num(flags.timeoutMs, 8000),
+        options,
+      });
+      console.log(
+        `${res.satisfied ? 'settled' : 'timed out'} after ${res.waitedMs}ms — frame #${res.state.seq}, stable ${res.state.stableForMs}ms`,
+      );
+      process.exitCode = res.satisfied ? 0 : 1;
+      return;
+    }
+
+    case 'strip': {
+      const res = await api.getStrip(device, {
+        count: num(flags.count, 5),
+        spanMs: flags.spanMs ? num(flags.spanMs) : undefined,
+        options,
+      });
+      const out = flags.out || path.join(process.cwd(), 'simframe-strip.png');
+      fs.writeFileSync(out, res.png);
+      console.log(
+        `${out} — ${res.frames.length} frames over ${res.spanMs}ms (${res.width}x${res.height})`,
+      );
+      return;
+    }
+
+    case 'devices': {
+      const all = await listDevices();
+      const shown = flags.all ? all : all.filter((d) => d.state === 'Booted');
+      if (flags.json) {
+        console.log(JSON.stringify(shown, null, 2));
+      } else if (!shown.length) {
+        console.log('no booted simulators (pass --all to list every device)');
+      } else {
+        for (const d of shown) console.log(`${d.state === 'Booted' ? '●' : '○'} ${d.name}  ${d.runtime}  ${d.udid}`);
+      }
+      return;
+    }
+
+    case 'doctor': {
+      await doctor();
+      return;
+    }
+
+    default:
+      process.stderr.write(`unknown command "${command}"\n\n${USAGE}`);
+      process.exitCode = 2;
+  }
+}
+
+async function doctor() {
+  const checks = [];
+  const add = (name, ok, detail) => checks.push({ name, ok, detail });
+
+  add('node', true, process.version);
+  try {
+    const { execFileSync } = await import('node:child_process');
+    add('xcrun', true, execFileSync('xcrun', ['--version'], { encoding: 'utf8' }).trim().split('\n')[0]);
+  } catch (err) {
+    add('xcrun', false, err.message);
+  }
+  try {
+    const { execFileSync } = await import('node:child_process');
+    execFileSync('sips', ['--version'], { encoding: 'utf8', stdio: 'pipe' });
+    add('sips', true, 'available');
+  } catch (err) {
+    add('sips', false, err.message);
+  }
+  try {
+    const booted = await bootedDevices();
+    add('booted simulator', booted.length > 0, booted.map((d) => `${d.name} (${d.runtime})`).join(', ') || 'none');
+    if (booted.length) {
+      const t0 = Date.now();
+      const res = await api.getFrame(booted[0].udid);
+      add('capture', true, `frame #${res.state.seq} ${res.width}x${res.height} in ${Date.now() - t0}ms (age ${res.ageMs}ms)`);
+    }
+  } catch (err) {
+    add('capture', false, err.message);
+  }
+
+  for (const c of checks) console.log(`${c.ok ? 'ok  ' : 'FAIL'} ${c.name.padEnd(18)} ${c.detail}`);
+  process.exitCode = checks.every((c) => c.ok) ? 0 : 1;
+}
+
+main().catch((err) => {
+  process.stderr.write(`simframe: ${err.message}\n`);
+  process.exitCode = 1;
+});