@felipe-software/react-native-gpui 0.0.0-placeholder → 1.0.1

package/dist/window-context.d.ts

@@ -0,0 +1,7 @@
+export type WindowContextValue = {
+    windowId: number;
+    width: number;
+    height: number;
+    focused: boolean;
+};
+export declare const WindowContext: import("react").Context<WindowContextValue | null>;

package/dist/window-host.d.ts

@@ -0,0 +1,41 @@
+import { type Container } from "./reconciler";
+export type WindowKind = "normal" | "dialog" | "popup";
+export type WindowPosition = "center" | "cursor" | {
+    x: number;
+    y: number;
+    relativeTo?: "parent" | "screen" | "cursor";
+};
+export type WindowCloseReason = "system" | "escape" | "blur" | "error";
+export type WindowSpec = {
+    title: string;
+    width: number;
+    height: number;
+    minWidth?: number;
+    minHeight?: number;
+    position: WindowPosition;
+    kind: WindowKind;
+    resizable?: boolean;
+    alwaysOnTop?: boolean;
+    closeOnBlur?: boolean;
+    closeOnEscape?: boolean;
+    testID?: string;
+};
+export type WindowHostEvent = {
+    windowId: number;
+    event: "open" | "resize" | "close" | "focus" | "blur";
+    width?: number;
+    height?: number;
+    reason?: WindowCloseReason;
+};
+export interface WindowHost {
+    readonly windowId: number;
+    readonly container: Container;
+    open(spec: WindowSpec, onEvent: (event: WindowHostEvent) => void): void;
+    update(spec: WindowSpec): void;
+    focus(): void;
+    close(): void;
+    readonly closed: boolean;
+}
+export declare function dispatchWindowEvent(event: WindowHostEvent): void;
+export declare function openWindowIds(): number[];
+export declare function createWindowHost(width: number, height: number): WindowHost;

package/dist/wire-delta.d.ts

@@ -0,0 +1,20 @@
+import type { SerializedNode } from "./runtime";
+export type WireSourceCache = {
+    fileIds: Map<string, number>;
+    announcedIds: Set<number>;
+    nextId: number;
+};
+export declare function createWireSourceCache(): WireSourceCache;
+export declare const sharedWireSources: WireSourceCache;
+export declare function sameTopLevelTree(a: SerializedNode, b: SerializedNode): boolean;
+export type WireDeltaStats = {
+    refs: number;
+    full: number;
+};
+type BigFields = {
+    text?: string;
+    src?: string;
+};
+export type BigFieldCache = Map<number, BigFields>;
+export declare function toWireDelta(node: SerializedNode, sent: WeakSet<SerializedNode>, big: BigFieldCache, stats?: WireDeltaStats, sourceCache?: WireSourceCache): SerializedNode;
+export {};

package/package.json

@@ -1 +1,177 @@
-{"name":"@felipe-software/react-native-gpui","version":"0.0.0-placeholder","description":"Placeholder so npm trusted publishing can be configured. Real releases are published from CI.","license":"MIT","repository":{"type":"git","url":"git+https://github.com/felipe-software/react-native-gpui.git"}}
+{
+    "name": "@felipe-software/react-native-gpui",
+    "version": "1.0.1",
+    "description": "Write React Native components, render them natively with GPUI (Zed's GPU UI framework).",
+    "type": "module",
+    "main": "dist/index.js",
+    "module": "dist/index.js",
+    "types": "dist/index.d.ts",
+    "exports": {
+        ".": {
+            "types": "./dist/index.d.ts",
+            "import": "./dist/index.js"
+        },
+        "./scripts/*": "./scripts/*",
+        "./package.json": "./package.json"
+    },
+    "bin": {
+        "rngpui": "./cli/bin.ts"
+    },
+    "files": [
+        ".reanimated-prebuilt",
+        "cli",
+        "dist",
+        "scripts/bundle-app.mjs",
+        "scripts/conformance-utils.mjs",
+        "scripts/hot-update-alias-plugin.mjs",
+        "scripts/native-package-exports-plugin.mjs",
+        "scripts/pixel.mjs",
+        "scripts/png.mjs",
+        "scripts/react-refresh-swc.mjs",
+        "scripts/reanimated-bun-plugin.mjs",
+        "scripts/service-binary.mjs",
+        "scripts/service-binary.d.mts",
+        "src/reanimated",
+        "src/refresh.ts",
+        "README.md"
+    ],
+    "scripts": {
+        "build": "npm run prebuild:reanimated && npm run build:rust && npm run build:native && npm run build:ts",
+        "build:rust": "node scripts/build-rust.mjs",
+        "build:native": "node scripts/build-native.mjs",
+        "build:clean": "node -e \"require('fs').rmSync('dist',{recursive:true,force:true})\"",
+        "build:types": "tsc --emitDeclarationOnly",
+        "build:bundle": "bun build src/index.ts --outfile dist/index.js --target node --format esm --production --define:__DEV__=false --external react --external react/jsx-runtime --external react/jsx-dev-runtime && bun build src/index.ts --outfile dist/index.development.js --target node --format esm --define:__DEV__=true --define:process.env.NODE_ENV='\"development\"' --external react --external react/jsx-runtime --external react/jsx-dev-runtime && bun scripts/build-ui-runtime.mjs --force",
+        "build:ts": "npm run build:clean && npm run build:types && npm run build:bundle",
+        "typecheck": "tsc --noEmit",
+        "test": "bun run scripts/test-suite.mjs",
+        "test:unit": "bun run scripts/animated-driver-unit.mjs && bun run scripts/keyboard-navigation-unit.mjs && bun run scripts/surfaces-unit.mjs && bun run scripts/native-package-exports-unit.mjs && bun run scripts/wire-delta-unit.mjs && bun run scripts/worklet-runtime-unit.mjs && bun run scripts/appearance-serialize-unit.tsx && bun run scripts/semantic-serialize-unit.tsx && bun run scripts/pixel.test.mjs",
+        "test:animated-driver": "bun run scripts/animated-driver-unit.mjs",
+        "test:keyboard-navigation": "bun run scripts/keyboard-navigation-unit.mjs",
+        "test:surfaces": "bun run scripts/surfaces-unit.mjs",
+        "kitchen": "node scripts/run-example.mjs examples/kitchen-sink.tsx --interactive",
+        "conformance:animation": "node scripts/run-example.mjs examples/animation-conformance.tsx --timeout-ms 8000",
+        "conformance:animation:diff": "bun run scripts/animation-frame-diff.mjs",
+        "conformance:anim-overlay": "node scripts/anim-overlay-conformance.mjs",
+        "conformance:reanimated": "node scripts/reanimated-conformance.mjs",
+        "conformance:reanimated:scroll": "bun run scripts/reanimated-scroll-conformance.ts",
+        "conformance:offthread-stall": "node scripts/offthread-stall-conformance.mjs",
+        "conformance:native-scroll-react-stall": "node scripts/native-scroll-react-stall-conformance.mjs",
+        "conformance:dialog-reanimated": "bun run scripts/dialog-reanimated-conformance.mjs",
+        "conformance:sustained-reanimated": "bun run scripts/sustained-reanimated-conformance.mjs",
+        "prebuild:reanimated": "bun run scripts/prebuild-reanimated.mjs",
+        "conformance:webview:render": "bun run scripts/webview-render-conformance.mjs",
+        "conformance:webview:overlay": "bun run scripts/webview-overlay-conformance.mjs",
+        "conformance:card-corner-shadow": "bun run scripts/card-corner-shadow-conformance.mjs",
+        "conformance:opacity": "bun run scripts/check-opacity-conformance.mjs",
+        "conformance:transform": "bun run scripts/check-transform-conformance.mjs",
+        "conformance:opacity-ramp": "bun run scripts/check-opacity-ramp-conformance.mjs",
+        "conformance:diagnostics": "node scripts/diagnostics-conformance.mjs",
+        "conformance:context-menu": "node scripts/context-menu-conformance.mjs",
+        "conformance:file-picker": "bun run scripts/file-picker-conformance.ts",
+        "conformance:display-none": "bun run scripts/display-none-conformance.ts",
+        "conformance:inspector": "node scripts/inspector-conformance.mjs",
+        "conformance:hit-test": "node scripts/hit-test-conformance.mjs",
+        "conformance:occlusion": "node scripts/overlay-occlusion-conformance.mjs",
+        "conformance:chat-list": "node scripts/chat-list-conformance.mjs",
+        "conformance:multi-window": "node scripts/multi-window-conformance.mjs",
+        "perf:chat-list": "node scripts/chat-list-stress.mjs",
+        "conformance:input": "node scripts/input-conformance-driver.mjs",
+        "conformance:input-runtime": "bun run scripts/input-runtime-conformance.ts",
+        "probe:input-latency": "bun run scripts/input-latency-probe.ts",
+        "conformance:input:manual": "node scripts/run-example.mjs examples/input-conformance.tsx --interactive",
+        "conformance:list-group": "node scripts/list-group-conformance-driver.mjs",
+        "conformance:legend-100k": "bun run scripts/legend-list-100k-conformance.mjs",
+        "conformance:box-model": "RNGPUI_NO_ACTIVATE=1 RNGPUI_TEST_MODE=1 node scripts/run-example.mjs examples/box-model-conformance.tsx --timeout-ms 8000",
+        "conformance:negative-margin": "RNGPUI_NO_ACTIVATE=1 RNGPUI_TEST_MODE=1 node scripts/run-example.mjs examples/negative-margin-conformance.tsx --timeout-ms 8000",
+        "conformance:measure": "RNGPUI_NO_ACTIVATE=1 RNGPUI_TEST_MODE=1 node scripts/run-example.mjs examples/measure-conformance.tsx --timeout-ms 8000",
+        "conformance:native-layout": "RNGPUI_NO_ACTIVATE=1 RNGPUI_TEST_MODE=1 node scripts/run-example.mjs examples/native-layout-conformance.tsx --timeout-ms 8000",
+        "conformance:native-layout-animation": "RNGPUI_NO_ACTIVATE=1 RNGPUI_TEST_MODE=1 node scripts/run-example.mjs examples/native-layout-animation-conformance.tsx --timeout-ms 8000",
+        "conformance:portal": "node scripts/run-example.mjs examples/portal-conformance.tsx --interactive",
+        "conformance:raf-pacing": "RNGPUI_NO_ACTIVATE=1 RNGPUI_TEST_MODE=1 node scripts/run-example.mjs examples/raf-pacing-conformance.tsx --timeout-ms 15000",
+        "conformance:presentation-pacing": "bun run scripts/presentation-pacing-conformance.mjs --require-120hz",
+        "conformance:rounded-overflow": "bun run scripts/rounded-overflow-conformance.mjs",
+        "conformance:text-lines": "bun run scripts/text-lines-conformance.mjs",
+        "pixel-diff": "bun run scripts/pixel-diff.mjs",
+        "pixel-sample": "bun run scripts/pixel-sample.mjs",
+        "png-grid": "bun run scripts/png-grid.mjs",
+        "test:pixel": "bun run scripts/pixel.test.mjs",
+        "superconductor": "node scripts/run-example.mjs examples/superconductor.tsx --interactive",
+        "rngpui": "bun run cli/bin.ts",
+        "conformance:describe": "node scripts/describe-conformance.mjs",
+        "conformance:drive": "node scripts/drive-conformance.mjs",
+        "conformance:scroll-performance": "bun run scripts/scroll-performance-conformance.mjs",
+        "conformance:reload": "node scripts/reload-conformance.mjs",
+        "conformance:hot-reload": "node scripts/hot-reload-conformance.mjs",
+        "conformance:hot-reload-cli": "node scripts/hot-reload-cli-conformance.mjs",
+        "conformance:startup": "node scripts/startup-conformance.mjs",
+        "conformance:local-storage": "node scripts/local-storage-conformance.mjs",
+        "conformance:platform-services": "node scripts/platform-services-conformance.mjs",
+        "conformance:http-cache": "node scripts/http-cache-conformance.mjs",
+        "conformance:animated-image": "node scripts/animated-image-conformance.mjs",
+        "npm:set-version": "node scripts/npm-packages.mjs set-version",
+        "npm:stage-platform": "node scripts/npm-packages.mjs stage-platform",
+        "npm:pack": "node scripts/npm-packages.mjs pack"
+    },
+    "os": [
+        "darwin",
+        "linux"
+    ],
+    "cpu": [
+        "arm64",
+        "x64"
+    ],
+    "keywords": [
+        "react-native",
+        "gpui",
+        "zed",
+        "rust",
+        "desktop",
+        "macos",
+        "linux",
+        "wayland",
+        "x11",
+        "react-reconciler"
+    ],
+    "license": "MIT",
+    "peerDependencies": {
+        "react": ">=19.0.0"
+    },
+    "dependencies": {
+        "@swc/core": "1.15.40",
+        "react-refresh": "0.14.2",
+        "react-reconciler": "^0.31.0"
+    },
+    "devDependencies": {
+        "@babel/core": "^7.26.0",
+        "@babel/plugin-syntax-jsx": "^7.25.9",
+        "@babel/plugin-transform-async-generator-functions": "^7.26.0",
+        "@babel/plugin-transform-flow-strip-types": "^7.26.0",
+        "@babel/preset-typescript": "^7.26.0",
+        "@legendapp/list": "3.3.3",
+        "@types/node": "25.9.1",
+        "@types/react": "^19.0.0",
+        "@types/react-reconciler": "^0.31.0",
+        "esbuild": "^0.25.0",
+        "react": "^19.0.0",
+        "react-native-reanimated": "4.3.0",
+        "react-native-worklets": "0.8.1",
+        "typescript": "^5.7.0"
+    },
+    "repository": {
+        "type": "git",
+        "url": "git+https://github.com/felipe-software/react-native-gpui.git"
+    },
+    "homepage": "https://github.com/felipe-software/react-native-gpui#readme",
+    "bugs": {
+        "url": "https://github.com/felipe-software/react-native-gpui/issues"
+    },
+    "publishConfig": {
+        "access": "public"
+    },
+    "optionalDependencies": {
+        "@felipe-software/react-native-gpui-linux-x64": "1.0.1",
+        "@felipe-software/react-native-gpui-linux-arm64": "1.0.1",
+        "@felipe-software/react-native-gpui-darwin-arm64": "1.0.1"
+    }
+}

package/scripts/bundle-app.mjs

@@ -0,0 +1,88 @@
+// Bundle a single self-contained JS file for the embedded JavaScriptCore runtime (no module
+// system, no Bun/node runtime). React + react-reconciler are bundled IN so the
+// source bundle is self-contained.
+//
+//   bun scripts/bundle-app.mjs [entry] [out.js]
+//
+// Bun is used only as the dev bundler here; the output runs under JavaScriptCore.
+import { dirname, resolve, sep } from 'node:path'
+import { existsSync } from 'node:fs'
+import { spawnSync } from 'node:child_process'
+import { reanimatedBunPlugin } from './reanimated-bun-plugin.mjs'
+import { rngpuiHotUpdateAliasPlugin } from './hot-update-alias-plugin.mjs'
+import { createReactRefreshSwcTransform } from './react-refresh-swc.mjs'
+import { nativePackageExportsPlugin } from './native-package-exports-plugin.mjs'
+import { isRepoCheckout } from './service-binary.mjs'
+
+const root = resolve(import.meta.dirname, '..')
+const args = process.argv.slice(2).filter((a) => !a.startsWith('--'))
+const entry = args[0] ? resolve(args[0]) : resolve(root, 'examples/engine-smoke.tsx')
+const outJs = args[1] ? resolve(args[1]) : '/tmp/rngpui-bundle.js'
+const projectRoot = resolve(process.env.RNGPUI_PROJECT_ROOT || dirname(entry))
+const mode = process.env.NODE_ENV || 'development'
+const hotUpdate = process.env.RNGPUI_HOT_UPDATE === '1'
+const refreshBootstrap = resolve(root, 'src/refresh.ts')
+const refreshTransform = mode === 'development' ? createRefreshTransform() : null
+const libraryEntry = libraryEntryFor(mode)
+
+const result = await Bun.build({
+  entrypoints: [entry],
+  target: 'browser', // neutral: no node/bun builtins, self-contained
+  format: 'iife', // runs as a self-contained script
+  conditions: ['react-native'],
+  define: {
+    'process.env.NODE_ENV': JSON.stringify(mode),
+    __DEV__: mode === 'development' ? 'true' : 'false',
+    'import.meta.url': JSON.stringify('file://' + entry),
+    'process.env.RNGPUI_INPUT_FIXTURE_APPEARANCE': JSON.stringify(
+      process.env.RNGPUI_INPUT_FIXTURE_APPEARANCE || '',
+    ),
+  },
+  plugins: [
+    ...(hotUpdate ? [rngpuiHotUpdateAliasPlugin()] : []),
+    reanimatedBunPlugin({ rngTsRoot: root, resolveRoot: projectRoot, libraryEntry, transformSource: refreshTransform }),
+    nativePackageExportsPlugin({ root: projectRoot, name: 'rngpui native package exports' }),
+  ],
+  sourcemap: 'none',
+  throw: false,
+})
+
+if (!result.success) {
+  console.error('[bundle-app] build failed:')
+  for (const log of result.logs) console.error(log)
+  process.exit(1)
+}
+
+const code = await result.outputs.find((o) => o.kind === 'entry-point').text()
+await Bun.write(outJs, code)
+console.log(`[bundle-app] ${entry}`)
+console.log(`[bundle-app] wrote ${outJs} (${(code.length / 1024).toFixed(0)} KB, NODE_ENV=${mode})`)
+
+// every app bundle needs the worklet/UI runtime bundle staged next to the service
+// binary. mtime-cached, so usually a no-op. Installed packages ship it prebuilt.
+if (isRepoCheckout(root) && !hotUpdate && !entry.endsWith('/reanimated/ui-entry.ts')) {
+  const ui = spawnSync(process.execPath, ['scripts/build-ui-runtime.mjs'], { cwd: root, stdio: 'inherit' })
+  if (ui.status !== 0) {
+    console.error('[bundle-app] build-ui-runtime failed')
+    process.exit(ui.status || 1)
+  }
+}
+
+function libraryEntryFor(bundleMode) {
+  const source = resolve(root, 'src/index.ts')
+  if (existsSync(source)) return source
+  const development = resolve(root, 'dist/index.development.js')
+  if (bundleMode === 'development' && existsSync(development)) return development
+  return resolve(root, 'dist/index.js')
+}
+
+function createRefreshTransform() {
+  const transform = createReactRefreshSwcTransform()
+  return async (source, { filename, isTs, isJsx }) => {
+    if (filename === refreshBootstrap || filename.includes(`${sep}node_modules${sep}`)) return source
+    const code = await transform(source, { filename, isTs, isJsx })
+    if (filename !== entry) return code
+    if (!hotUpdate) return `import ${JSON.stringify(refreshBootstrap)};\n${code}`
+    return `if (globalThis.__rngpuiRefreshReady !== true) throw new Error("RNGPUI Fast Refresh runtime is not installed");\n${code}`
+  }
+}

package/scripts/conformance-utils.mjs

@@ -0,0 +1,293 @@
+import { join, resolve } from "node:path";
+import { homedir, tmpdir } from "node:os";
+import { execFile, execFileSync } from "node:child_process";
+import { existsSync, readFileSync, readdirSync, renameSync, rmSync, writeFileSync } from "node:fs";
+
+export const cuaDriver =
+    process.env.CUA_DRIVER ||
+    (existsSync(join(homedir(), ".local/bin/cua-driver")) ? join(homedir(), ".local/bin/cua-driver") : "cua-driver");
+
+export function conformanceEnv(extra = {}) {
+    return {
+        ...process.env,
+        RNGPUI_NO_ACTIVATE: "1",
+        RNGPUI_TEST_MODE: "1",
+        ...extra,
+    };
+}
+
+export async function waitForServicePid(pidPath, { timeoutMs = 5000, isFixtureExited } = {}) {
+    const deadline = Date.now() + timeoutMs;
+    let last = "";
+    while (Date.now() < deadline) {
+        if (existsSync(pidPath)) {
+            const pid = Number(readFileSync(pidPath, "utf8").trim());
+            if (Number.isFinite(pid) && pid > 0) {
+                try {
+                    process.kill(pid, 0);
+                    return pid;
+                } catch (error) {
+                    last = error instanceof Error ? error.message : String(error);
+                }
+            }
+        }
+        if (isFixtureExited?.()) break;
+        await sleep(25);
+    }
+    throw new Error(`timed out waiting for service pid at ${pidPath}${last ? `: ${last}` : ""}`);
+}
+
+// The budget bounds SILENCE, not wall time. `progress` returns a token (the
+// service log's size) and any change resets the clock, so a fixture merely
+// starved by concurrent work keeps its time while a wedged one still dies
+// promptly. An absolute deadline here is really a claim about how fast the
+// machine is, and it is wrong on a busy one.
+//
+// A fixture that has EXITED is reported as such rather than as a missing window.
+// The old code broke the loop on isFixtureExited and then threw the generic
+// "GPUI window was not found", so a self-terminating example (one that runs its
+// assertions and quits, like box-model-conformance) was indistinguishable from a
+// renderer that could not open a window — and it got read as the latter.
+export async function waitForWindow(match, { timeoutMs = 5000, isFixtureExited, progress } = {}) {
+    let deadline = Date.now() + timeoutMs;
+    let token = progress?.();
+    while (Date.now() < deadline) {
+        const window = listWindows().find(match);
+        if (window) return window;
+        if (isFixtureExited?.()) {
+            throw new Error("the fixture exited before opening a window");
+        }
+        await sleep(50);
+        const next = progress?.();
+        if (next !== token) {
+            token = next;
+            deadline = Date.now() + timeoutMs;
+        }
+    }
+    throw new Error(`GPUI window was not found (no progress for ${timeoutMs}ms)`);
+}
+
+export function linuxWindowRegistryDir() {
+    return join(process.env.XDG_RUNTIME_DIR || tmpdir(), "rngpui-windows");
+}
+
+function listLinuxWindows() {
+    const dir = linuxWindowRegistryDir();
+    if (!existsSync(dir)) return [];
+    return readdirSync(dir)
+        .filter((entry) => entry.endsWith(".json"))
+        .map((entry) => readLiveWindowRecord(join(dir, entry)))
+        .filter(Boolean)
+        .map((window) => ({
+            ...window,
+            bounds: { x: window.x, y: window.y, width: window.width, height: window.height },
+        }));
+}
+
+function readLiveWindowRecord(path) {
+    let record;
+    try {
+        record = JSON.parse(readFileSync(path, "utf8"));
+    } catch {
+        return null;
+    }
+    if (isLiveService(record.pid)) return record;
+    if (!existsSync(`/proc/${record.pid}`)) {
+        rmSync(path, { force: true });
+        rmSync(path.replace(/\.json$/, ".capture"), { force: true });
+    }
+    return null;
+}
+
+function isLiveService(pid) {
+    try {
+        return readFileSync(`/proc/${pid}/comm`, "utf8").trim() === "rngpui-service";
+    } catch {
+        return false;
+    }
+}
+
+export function listWindows() {
+    if (process.platform === "linux") return listLinuxWindows();
+    const swift = `
+import Foundation
+import CoreGraphics
+let list = CGWindowListCopyWindowInfo(.optionAll, kCGNullWindowID) as? [[String: Any]] ?? []
+for window in list {
+    let owner = window[kCGWindowOwnerName as String] as? String ?? ""
+    let title = window[kCGWindowName as String] as? String ?? ""
+    let id = (window[kCGWindowNumber as String] as? NSNumber)?.intValue ?? 0
+    let pid = (window[kCGWindowOwnerPID as String] as? NSNumber)?.intValue ?? 0
+    let layer = (window[kCGWindowLayer as String] as? NSNumber)?.intValue ?? 0
+    let bounds = window[kCGWindowBounds as String] as? [String: Any] ?? [:]
+    let x = (bounds["X"] as? NSNumber)?.doubleValue ?? 0
+    let y = (bounds["Y"] as? NSNumber)?.doubleValue ?? 0
+    let width = (bounds["Width"] as? NSNumber)?.doubleValue ?? 0
+    let height = (bounds["Height"] as? NSNumber)?.doubleValue ?? 0
+    let alpha = (window[kCGWindowAlpha as String] as? NSNumber)?.doubleValue ?? -1
+    print("\\(id)\\t\\(pid)\\t\\(owner)\\t\\(title)\\t\\(layer)\\t\\(x)\\t\\(y)\\t\\(width)\\t\\(height)\\t\\(alpha)")
+}
+`;
+    const raw = execFileSync("swift", ["-e", swift], { encoding: "utf8", stdio: "pipe" });
+    return raw
+        .trim()
+        .split("\n")
+        .filter(Boolean)
+        .map((line) => {
+            const [id, pid, owner, title, layer, x, y, width, height, alpha] = line.split("\t");
+            return {
+                id: Number(id),
+                window_id: Number(id),
+                pid: Number(pid),
+                owner,
+                app_name: owner,
+                title,
+                layer: Number(layer),
+                x: Number(x),
+                y: Number(y),
+                width: Number(width),
+                height: Number(height),
+                alpha: Number(alpha),
+                bounds: {
+                    x: Number(x),
+                    y: Number(y),
+                    width: Number(width),
+                    height: Number(height),
+                },
+            };
+        })
+        .filter(
+            (window) =>
+                Number.isFinite(window.id) &&
+                window.id > 0 &&
+                Number.isFinite(window.pid) &&
+                window.pid > 0 &&
+                Number.isFinite(window.width) &&
+                window.width > 0 &&
+                Number.isFinite(window.height) &&
+                window.height > 0,
+        );
+}
+
+export function captureWindow(window, path) {
+    if (process.platform === "linux") {
+        captureLinuxWindow(window, path);
+        return;
+    }
+    execFileSync(
+        cuaDriver,
+        [
+            "call",
+            "get_window_state",
+            JSON.stringify({
+                pid: window.pid,
+                window_id: window.id ?? window.window_id,
+                capture_mode: "vision",
+                screenshot_out_file: path,
+            }),
+        ],
+        { stdio: "pipe" },
+    );
+    if (!existsSync(path)) throw new Error(`screenshot was not written at ${path}`);
+}
+
+function captureLinuxWindow(window, path) {
+    if (!window.capture) {
+        throw new Error(
+            `rngpui-service pid ${window.pid} cannot capture frames; start it with RNGPUI_FRAME_CAPTURE=1 (test and CLI launches enable it)`,
+        );
+    }
+    const target = resolve(path);
+    rmSync(target, { force: true });
+    const request = window.capture_request ?? join(linuxWindowRegistryDir(), `${window.pid}.capture`);
+    writeFileSync(`${request}.staging`, target);
+    renameSync(`${request}.staging`, request);
+    const deadline = Date.now() + 10_000;
+    while (!existsSync(target)) {
+        if (Date.now() > deadline) throw new Error(`rngpui-service pid ${window.pid} did not write a frame to ${target}`);
+        Atomics.wait(new Int32Array(new SharedArrayBuffer(4)), 0, 0, 25);
+    }
+}
+
+export function frontmostApp() {
+    return frontmostProcess().name;
+}
+
+export function frontmostProcess() {
+    if (process.platform !== "darwin") return { pid: 0, name: "" };
+    const raw = execFileSync(
+        "swift",
+        [
+            "-e",
+            `
+import AppKit
+let app = NSWorkspace.shared.frontmostApplication
+print("\\(app?.processIdentifier ?? 0)\\t\\(app?.localizedName ?? "")")
+`,
+        ],
+        {
+            encoding: "utf8",
+            stdio: "pipe",
+        },
+    ).trim();
+    const [pid, ...nameParts] = raw.split("\t");
+    return { pid: Number(pid), name: nameParts.join("\t") };
+}
+
+export function screenFrames() {
+    if (process.platform !== "darwin") return [];
+    const swift = `
+import AppKit
+for screen in NSScreen.screens {
+    let frame = screen.frame
+    print("\\(frame.origin.x)\\t\\(frame.origin.y)\\t\\(frame.size.width)\\t\\(frame.size.height)")
+}
+`;
+    return execFileSync("swift", ["-e", swift], { encoding: "utf8", stdio: "pipe" })
+        .trim()
+        .split("\n")
+        .filter(Boolean)
+        .map((line) => {
+            const [x, y, width, height] = line.split("\t").map(Number);
+            return { x, y, width, height };
+        });
+}
+
+export function assertWindowOffscreen(window, label = "GPUI test window") {
+    const frames = screenFrames();
+    const visibleFrame = frames.find((frame) => rectsIntersect(window.bounds ?? window, frame));
+    if (!visibleFrame) return;
+    throw new Error(
+        `${label} is on-screen at ${window.x},${window.y} ${window.width}x${window.height}; screen=${visibleFrame.x},${visibleFrame.y} ${visibleFrame.width}x${visibleFrame.height}`,
+    );
+}
+
+function rectsIntersect(a, b) {
+    return a.x < b.x + b.width && a.x + a.width > b.x && a.y < b.y + b.height && a.y + a.height > b.y;
+}
+
+export function execFileText(command, args, options = {}) {
+    return new Promise((resolve, reject) => {
+        const child = execFile(
+            command,
+            args,
+            {
+                encoding: "utf8",
+                cwd: options.cwd,
+                env: options.env,
+            },
+            (error, stdout, stderr) => {
+                if (error && options.reject !== false) {
+                    reject(new Error(`${command} ${args.join(" ")} failed: ${stderr || error.message}`));
+                    return;
+                }
+                resolve({ stdout, stderr, error });
+            },
+        );
+        if (options.input != null) child.stdin?.end(options.input);
+    });
+}
+
+export function sleep(ms) {
+    return new Promise((resolve) => setTimeout(resolve, ms));
+}