reasonix 0.44.2-rc.4 → 0.45.0

package/dist/cli/{chunk-DFP43NI5.js → chunk-KQBNRLFZ.js}

@@ -72,9 +72,8 @@ import {
 import {
   KeystrokeProvider,
   SingleSelect,
-  sanitizePasteText,
   useKeystroke
-} from "./chunk-MRHHQJAQ.js";
+} from "./chunk-IBJIK2DD.js";
 import {
   COLOR,
   GLYPH,
@@ -44791,174 +44790,25 @@ function cancelAllPromptInputs() {
 // src/cli/ui/scene/trace.ts
 import { appendFileSync, closeSync, openSync } from "fs";
 
-// src/cli/ui/scene/renderer-process.ts
-import { spawn } from "child_process";
-function spawnRenderer(opts) {
-  const command = opts.command;
-  const baseArgs = [];
-  const [cmd, ...rest] = command;
-  baseArgs.push(...rest);
-  if (opts.integrated) {
-    baseArgs.push("--integrated");
-  }
-  if (!cmd) {
-    throw new Error("spawnRenderer: empty command");
-  }
-  const stderrStdio = opts.integrated ? "pipe" : "inherit";
-  const child = spawn(cmd, baseArgs, {
-    cwd: opts.cwd,
-    env: opts.env ?? process.env,
-    stdio: ["pipe", "inherit", stderrStdio]
-  });
-  child.on("error", (err) => {
-    process.stderr.write(`[spawnRenderer] child error: ${err.message}
-`);
-  });
-  let exited = false;
-  let aliveMs = 0;
-  const spawnedAt = Date.now();
-  const exitPromise = new Promise((resolve3) => {
-    child.once("exit", (code, signal) => {
-      exited = true;
-      aliveMs = Date.now() - spawnedAt;
-      process.stderr.write(
-        `[spawnRenderer] child exit: code=${code} signal=${signal} aliveMs=${aliveMs}
-`
-      );
-      resolve3(code);
-      if (opts.integrated && opts.onEvent && aliveMs >= 1500) {
-        try {
-          opts.onEvent({ event: "exit" });
-        } catch {
-        }
-      }
-    });
-  });
-  child.stdin?.on("error", () => {
-    exited = true;
-  });
-  if (opts.integrated && opts.onEvent && child.stderr) {
-    let buf = "";
-    child.stderr.setEncoding("utf8");
-    child.stderr.on("data", (chunk) => {
-      buf += chunk;
-      for (; ; ) {
-        const nl = buf.indexOf("\n");
-        if (nl === -1) break;
-        const line = buf.slice(0, nl).trim();
-        buf = buf.slice(nl + 1);
-        if (line.length === 0) continue;
-        try {
-          const parsed = JSON.parse(line);
-          if (parsed && typeof parsed.event === "string") {
-            opts.onEvent?.(parsed);
-            continue;
-          }
-        } catch {
-        }
-        process.stderr.write(`[rust-stderr] ${line}
-`);
-      }
-    });
-  }
-  return {
-    emit(message) {
-      if (exited) return;
-      const stdin = child.stdin;
-      if (!stdin || stdin.destroyed || !stdin.writable) return;
-      stdin.write(`${JSON.stringify(message)}
-`);
-    },
-    close() {
-      const stdin = child.stdin;
-      if (stdin && !stdin.destroyed && stdin.writable) {
-        stdin.end();
-      }
-      return exitPromise;
-    }
-  };
-}
-
-// src/cli/ui/scene/renderer-resolver.ts
-import { execSync } from "child_process";
+// src/cli/ui/scene/renderer.ts
 import { existsSync as existsSync2 } from "fs";
 import { createRequire } from "module";
 import { dirname as dirname3, join as join3 } from "path";
 import { fileURLToPath } from "url";
-var cached;
-function resolveRenderer() {
-  if (cached) return cached;
-  cached = resolveRendererWith(defaultIO());
-  return cached;
-}
-function resolveRendererWith(io) {
-  const base = pickBase(io);
-  const renderEnv = io.envCmd("REASONIX_RENDER_CMD");
-  const inputEnv = io.envCmd("REASONIX_INPUT_CMD");
-  if (!renderEnv && !inputEnv) return base;
-  return {
-    command: renderEnv ?? base.command,
-    inputCommand: inputEnv ?? base.inputCommand,
-    source: base.source ?? "env-cmd"
-  };
-}
-function pickBase(io) {
-  const binEnv = io.envBin();
-  if (binEnv && io.hasFile(binEnv)) return fromBinary(binEnv, "env-bin");
-  const optional = io.resolveOptionalDep(io.platform, process.arch);
-  if (optional) return fromBinary(optional, "optional-dep");
-  const sourceRoot = io.findReasonixSourceTree();
-  if (sourceRoot) {
-    const binName = io.platform === "win32" ? "reasonix-render.exe" : "reasonix-render";
-    const release2 = join3(sourceRoot, "target", "release", binName);
-    if (io.hasFile(release2)) return fromBinary(release2, "prebuilt-release");
-    const debug = join3(sourceRoot, "target", "debug", binName);
-    if (io.hasFile(debug)) return fromBinary(debug, "prebuilt-debug");
-    if (io.hasCargo()) return fromCargo();
-  }
-  return { command: [], inputCommand: [], source: null };
-}
-function fromBinary(bin, source) {
-  return { command: [bin], inputCommand: [bin, "--emit-input"], source };
-}
-function fromCargo() {
-  const cmd = ["cargo", "run", "--quiet", "--bin", "reasonix-render"];
-  return { command: cmd, inputCommand: [...cmd, "--", "--emit-input"], source: "cargo" };
-}
-function defaultIO() {
-  return {
-    envCmd: parseEnvCmd,
-    envBin: () => process.env.REASONIX_RENDER_BIN,
-    hasFile: existsSync2,
-    resolveOptionalDep: locateOptionalDepBinary,
-    findReasonixSourceTree: detectReasonixSourceTree,
-    hasCargo: detectCargo,
-    platform: process.platform
-  };
-}
-function parseEnvCmd(name) {
-  const raw = process.env[name];
-  if (!raw || raw.length === 0) return void 0;
-  try {
-    const parsed = JSON.parse(raw);
-    if (Array.isArray(parsed) && parsed.every((p) => typeof p === "string")) return parsed;
-  } catch {
-  }
-  return void 0;
-}
-function locateOptionalDepBinary(platform2, arch) {
-  const pkg = `@reasonix/render-${platform2}-${arch}`;
-  try {
-    const require_ = createRequire(import.meta.url);
-    const pkgJson = require_.resolve(`${pkg}/package.json`);
-    const binName = platform2 === "win32" ? "reasonix-render.exe" : "reasonix-render";
-    const binPath = join3(dirname3(pkgJson), "bin", binName);
-    return existsSync2(binPath) ? binPath : void 0;
-  } catch {
-    return void 0;
-  }
+var TRIPLES = {
+  "win32-x64": "win32-x64-msvc",
+  "win32-arm64": "win32-arm64-msvc",
+  "darwin-arm64": "darwin-arm64",
+  "darwin-x64": "darwin-x64",
+  "linux-x64": "linux-x64-gnu",
+  "linux-arm64": "linux-arm64-gnu"
+};
+var requireCJS = createRequire(import.meta.url);
+var cachedBinding = null;
+function tripleFor(platform2, arch) {
+  return TRIPLES[`${platform2}-${arch}`] ?? null;
 }
-function detectReasonixSourceTree() {
+function findDevTree() {
   let dir = dirname3(fileURLToPath(import.meta.url));
   for (let i = 0; i < 12; i++) {
     if (existsSync2(join3(dir, "crates", "reasonix-render", "Cargo.toml"))) return dir;
@@ -44966,27 +44816,78 @@ function detectReasonixSourceTree() {
     if (parent === dir) break;
     dir = parent;
   }
-  return void 0;
+  return null;
 }
-function detectCargo() {
+function loadBinding() {
+  if (cachedBinding) return cachedBinding;
+  const { platform: platform2, arch } = process;
+  const triple = tripleFor(platform2, arch);
+  if (!triple) {
+    throw new Error(
+      `reasonix-render: unsupported platform ${platform2}-${arch}. Supported: ${Object.keys(TRIPLES).join(", ")}.`
+    );
+  }
+  const devTree = findDevTree();
+  if (devTree) {
+    const devNode = join3(devTree, "crates", "reasonix-render", `reasonix-render.${triple}.node`);
+    if (existsSync2(devNode)) {
+      cachedBinding = requireCJS(devNode);
+      return cachedBinding;
+    }
+  }
+  const pkg = `@reasonix/render-${platform2}-${arch}`;
   try {
-    execSync("cargo --version", { stdio: "ignore" });
+    cachedBinding = requireCJS(pkg);
+    return cachedBinding;
+  } catch (err) {
+    const reason = err instanceof Error ? err.message : String(err);
+    throw new Error(
+      `reasonix-render: no native binding found for ${platform2}-${arch}. Tried dev tree + ${pkg}. Run \`npm run build:rust\` for source builds, or reinstall reasonix so npm fetches the optional dep. (${reason})`
+    );
+  }
+}
+function isRendererAvailable() {
+  try {
+    loadBinding();
     return true;
   } catch {
     return false;
   }
 }
+function createRenderer(opts = {}) {
+  const binding = loadBinding();
+  const handle = binding.createRenderer((eventJson) => {
+    if (!opts.onEvent) return;
+    try {
+      const parsed = JSON.parse(eventJson);
+      if (parsed && typeof parsed.event === "string") opts.onEvent(parsed);
+    } catch {
+    }
+  });
+  let closed = false;
+  return {
+    emit(message) {
+      if (closed) return;
+      handle.emit(JSON.stringify(message));
+    },
+    async close() {
+      if (closed) return;
+      closed = true;
+      handle.close();
+    }
+  };
+}
 
 // src/cli/ui/scene/trace.ts
 var FILE_VAR = "REASONIX_SCENE_TRACE";
 var RENDERER_VAR = "REASONIX_RENDERER";
-var INTEGRATED_VAR = "REASONIX_RENDERER_INTEGRATED";
 var integratedHandler = null;
 function setIntegratedEventHandler(handler) {
   integratedHandler = handler;
 }
 function isIntegratedRendererRequested() {
-  return process.env[RENDERER_VAR] !== "node" && process.env[INTEGRATED_VAR] !== "0";
+  if (process.env[RENDERER_VAR] === "node") return false;
+  return isRendererAvailable();
 }
 var state = { mode: "off", opened: false, path: null, child: null };
 function isSceneTraceEnabled() {
@@ -44999,10 +44900,8 @@ function emitSceneMessage(message) {
     case "off":
       return;
     case "file":
-      if (state.path) {
-        appendFileSync(state.path, `${JSON.stringify(message)}
+      if (state.path) appendFileSync(state.path, `${JSON.stringify(message)}
 `);
-      }
       return;
     case "child":
       state.child?.emit(message);
@@ -45011,10 +44910,6 @@ function emitSceneMessage(message) {
 }
 function ensureSceneTraceReady() {
   ensureInitialized();
-  if (state.mode === "child" && state.child) {
-    state.child.emit({ type: "trace" });
-    process.stderr.write("[trace] seed frame written\n");
-  }
 }
 function ensureInitialized() {
   if (state.opened) return;
@@ -45027,24 +44922,11 @@ function ensureInitialized() {
     return;
   }
   if (process.env[RENDERER_VAR] === "node") return;
-  const { command, source } = resolveRenderer();
-  process.stderr.write(`[trace] resolver source=${source} command=${JSON.stringify(command)}
-`);
-  if (source === null || command.length === 0) {
-    process.stderr.write(
-      "\u25B2 trace.ts: resolveRenderer() returned no usable command \u2014 scene trace stays off. Check optional-dep install (`ls node_modules/@reasonix/render-*`) or set REASONIX_RENDER_BIN.\n"
-    );
-    return;
-  }
-  const integrated = process.env[INTEGRATED_VAR] !== "0";
-  process.stderr.write(`[trace] spawning rust child (integrated=${integrated})
-`);
+  if (!isRendererAvailable()) return;
+  const opts = {};
+  if (integratedHandler) opts.onEvent = integratedHandler;
   state.mode = "child";
-  state.child = spawnRenderer({
-    command,
-    integrated,
-    onEvent: integrated && integratedHandler ? integratedHandler : void 0
-  });
+  state.child = createRenderer(opts);
 }
 function truncate(path) {
   const fd = openSync(path, "w");
@@ -45824,7 +45706,7 @@ function recordSlashUse(name) {
 }
 
 // src/cli/edit/external-editor.ts
-import { spawn as spawn2 } from "child_process";
+import { spawn } from "child_process";
 import { mkdtempSync, readFileSync as readFileSync4, rmSync, writeFileSync as writeFileSync4 } from "fs";
 import { tmpdir } from "os";
 import { join as join5 } from "path";
@@ -45866,7 +45748,7 @@ async function openInExternalEditor(initial2) {
 }
 function spawnEditor(editor, path) {
   return new Promise((resolve3, reject) => {
-    const child = spawn2(`${editor} "${path}"`, {
+    const child = spawn(`${editor} "${path}"`, {
       shell: true,
       stdio: "inherit"
     });
@@ -46205,14 +46087,14 @@ function ViewportBudgetProvider({
   initialRows
 }) {
   const { stdout } = use_stdout_default();
-  const [state2, dispatch2] = (0, import_react7.useReducer)(reducer, void 0, () => ({
+  const [state2, dispatch] = (0, import_react7.useReducer)(reducer, void 0, () => ({
     claims: /* @__PURE__ */ new Map(),
     totalRows: initialRows ?? stdout?.rows ?? 40
   }));
   (0, import_react7.useEffect)(() => {
     if (initialRows !== void 0) return void 0;
     if (!stdout) return void 0;
-    const onResize = () => dispatch2({ type: "resize", rows: stdout.rows ?? 40 });
+    const onResize = () => dispatch({ type: "resize", rows: stdout.rows ?? 40 });
     onResize();
     stdout.on("resize", onResize);
     return () => {
@@ -46231,7 +46113,7 @@ function ViewportBudgetProvider({
       totalRows: state2.totalRows,
       allocations,
       claims: state2.claims,
-      dispatch: dispatch2
+      dispatch
     }),
     [state2.totalRows, allocations, state2.claims]
   );
@@ -46239,14 +46121,14 @@ function ViewportBudgetProvider({
 }
 function useReserveRows(zone, spec) {
   const ctx = (0, import_react7.useContext)(BudgetContext);
-  const dispatch2 = ctx?.dispatch;
+  const dispatch = ctx?.dispatch;
   (0, import_react7.useEffect)(() => {
-    if (!dispatch2) return void 0;
-    dispatch2({ type: "claim", zone, spec: { min: spec.min, max: spec.max } });
+    if (!dispatch) return void 0;
+    dispatch({ type: "claim", zone, spec: { min: spec.min, max: spec.max } });
     return () => {
-      dispatch2({ type: "release", zone });
+      dispatch({ type: "release", zone });
     };
-  }, [dispatch2, zone, spec.min, spec.max]);
+  }, [dispatch, zone, spec.min, spec.max]);
   if (!ctx) return Number.isFinite(spec.max) ? spec.max : 40;
   const allocated = ctx.allocations.get(zone);
   if (allocated !== void 0) return allocated;
@@ -53802,17 +53684,17 @@ function formatTok(n) {
   return String(n);
 }
 function useScrollback() {
-  const dispatch2 = useDispatch();
+  const dispatch = useDispatch();
   return (0, import_react46.useMemo)(
     () => ({
       pushUser(text) {
         const id = nextId2("u");
-        dispatch2({ type: "user.submit", text });
+        dispatch({ type: "user.submit", text });
         return id;
       },
       pushWarning(title2, message) {
         const id = nextId2("warn");
-        dispatch2({
+        dispatch({
           type: "live.show",
           id,
           ts: Date.now(),
@@ -53825,7 +53707,7 @@ function useScrollback() {
       },
       pushError(title2, message, stack) {
         const id = nextId2("err");
-        dispatch2({
+        dispatch({
           type: "live.show",
           id,
           ts: Date.now(),
@@ -53839,7 +53721,7 @@ ${stack}` : message
       },
       pushInfo(text, tone = "info") {
         const id = nextId2("info");
-        dispatch2({
+        dispatch({
           type: "live.show",
           id,
           ts: Date.now(),
@@ -53851,7 +53733,7 @@ ${stack}` : message
       },
       pushTip({ topic, sections, footer, oneTime = true }) {
         const id = nextId2("tip");
-        dispatch2({
+        dispatch({
           type: "tip.show",
           id,
           ts: Date.now(),
@@ -53872,7 +53754,7 @@ ${stack}` : message
         const tone = pct >= 95 ? "err" : "warn";
         const used = formatTok(usedTokens);
         const max = formatTok(ctxMax);
-        dispatch2({
+        dispatch({
           type: "live.show",
           id: nextId2("ctxp"),
           ts: Date.now(),
@@ -53885,7 +53767,7 @@ ${stack}` : message
       pushStepProgress(stepIndex, total, title2, elapsedMs) {
         const id = nextId2("step");
         const meta = elapsedMs !== void 0 ? `${(elapsedMs / 1e3).toFixed(1)}s \xB7 done` : "done";
-        dispatch2({
+        dispatch({
           type: "live.show",
           id,
           ts: Date.now(),
@@ -53898,7 +53780,7 @@ ${stack}` : message
       },
       pushPlanAnnounce(text) {
         const id = nextId2("plan");
-        dispatch2({
+        dispatch({
           type: "live.show",
           id,
           ts: Date.now(),
@@ -53911,12 +53793,12 @@ ${stack}` : message
       },
       showDoctor(checks) {
         const id = nextId2("doc");
-        dispatch2({ type: "doctor.show", id, checks: [...checks] });
+        dispatch({ type: "doctor.show", id, checks: [...checks] });
         return id;
       },
       showUsageVerbose(args) {
         const id = nextId2("cost");
-        dispatch2({
+        dispatch({
           type: "usage.show",
           id,
           turn: args.turn,
@@ -53937,49 +53819,49 @@ ${stack}` : message
       },
       showPlan({ title: title2, steps, variant }) {
         const id = nextId2("plan");
-        dispatch2({ type: "plan.show", id, title: title2, steps, variant });
+        dispatch({ type: "plan.show", id, title: title2, steps, variant });
         return id;
       },
       completePlanStep(stepId) {
-        dispatch2({ type: "plan.step.complete", stepId });
+        dispatch({ type: "plan.step.complete", stepId });
       },
       showCtx(args) {
         const id = nextId2("ctx");
-        dispatch2({ type: "ctx.show", id, ...args, topTools: [...args.topTools] });
+        dispatch({ type: "ctx.show", id, ...args, topTools: [...args.topTools] });
         return id;
       },
       startReasoning(model2) {
         const id = nextId2("r");
-        dispatch2({ type: "reasoning.start", id, ...model2 ? { model: model2 } : {} });
+        dispatch({ type: "reasoning.start", id, ...model2 ? { model: model2 } : {} });
         return id;
       },
       appendReasoning(id, chunk) {
-        if (chunk.length > 0) dispatch2({ type: "reasoning.chunk", id, text: chunk });
+        if (chunk.length > 0) dispatch({ type: "reasoning.chunk", id, text: chunk });
       },
       endReasoning(id, paragraphs, tokens, aborted) {
-        dispatch2({ type: "reasoning.end", id, paragraphs, tokens, aborted });
+        dispatch({ type: "reasoning.end", id, paragraphs, tokens, aborted });
       },
       startStreaming(model2) {
         const id = nextId2("s");
-        dispatch2({ type: "streaming.start", id, ...model2 ? { model: model2 } : {} });
+        dispatch({ type: "streaming.start", id, ...model2 ? { model: model2 } : {} });
         return id;
       },
       appendStreaming(id, chunk) {
-        if (chunk.length > 0) dispatch2({ type: "streaming.chunk", id, text: chunk });
+        if (chunk.length > 0) dispatch({ type: "streaming.chunk", id, text: chunk });
       },
       endStreaming(id, aborted) {
-        dispatch2({ type: "streaming.end", id, aborted });
+        dispatch({ type: "streaming.end", id, aborted });
       },
       startTool(name, args, presetId) {
         const id = presetId ?? nextId2("tool");
-        dispatch2({ type: "tool.start", id, name, args });
+        dispatch({ type: "tool.start", id, name, args });
         return id;
       },
       appendToolOutput(id, chunk) {
-        if (chunk.length > 0) dispatch2({ type: "tool.chunk", id, text: chunk });
+        if (chunk.length > 0) dispatch({ type: "tool.chunk", id, text: chunk });
       },
       endTool(id, info) {
-        dispatch2({
+        dispatch({
           type: "tool.end",
           id,
           output: info.output,
@@ -53989,18 +53871,18 @@ ${stack}` : message
         });
       },
       retryTool(id, attempt, max) {
-        dispatch2({ type: "tool.retry", id, attempt, max });
+        dispatch({ type: "tool.retry", id, attempt, max });
       },
       thinking() {
         const id = nextId2("think");
-        dispatch2({ type: "turn.thinking" });
+        dispatch({ type: "turn.thinking" });
         return id;
       },
       abortTurn() {
-        dispatch2({ type: "turn.abort" });
+        dispatch({ type: "turn.abort" });
       },
       endTurn(usage, extras) {
-        dispatch2({
+        dispatch({
           type: "turn.end",
           usage,
           promptCap: extras?.promptCap,
@@ -54009,10 +53891,10 @@ ${stack}` : message
         });
       },
       reset() {
-        dispatch2({ type: "session.reset" });
+        dispatch({ type: "session.reset" });
       }
     }),
-    [dispatch2]
+    [dispatch]
   );
 }
 
@@ -56275,7 +56157,7 @@ function bodyColor(toast, now) {
 }
 function ToastRail() {
   const toasts = useAgentState((s) => s.toasts);
-  const dispatch2 = useDispatch();
+  const dispatch = useDispatch();
   useSlowTick();
   const { stdout } = use_stdout_default();
   const cols = stdout?.columns ?? 80;
@@ -56285,12 +56167,12 @@ function ToastRail() {
     const timers = [];
     for (const t2 of toasts) {
       const remaining = Math.max(0, t2.ttlMs - (Date.now() - t2.bornAt));
-      timers.push(setTimeout(() => dispatch2({ type: "toast.hide", id: t2.id }), remaining));
+      timers.push(setTimeout(() => dispatch({ type: "toast.hide", id: t2.id }), remaining));
     }
     return () => {
       for (const id of timers) clearTimeout(id);
     };
-  }, [toasts, dispatch2]);
+  }, [toasts, dispatch]);
   const visible = toasts.filter((t2) => now - t2.bornAt < t2.ttlMs);
   if (visible.length === 0) return null;
   return /* @__PURE__ */ import_react82.default.createElement(Box_default, { flexDirection: "column" }, visible.map((t2) => {
@@ -56574,7 +56456,7 @@ function replaceMcpServerSummary(servers, target, updated) {
 }
 
 // src/cli/ui/open-url.ts
-import { spawn as spawn3 } from "child_process";
+import { spawn as spawn2 } from "child_process";
 import { platform } from "os";
 function openUrl(url) {
   if (process.env.CI) return { opened: false, reason: "ci" };
@@ -56593,7 +56475,7 @@ function openUrl(url) {
     args = [url];
   }
   try {
-    const child = spawn3(cmd, args, { detached: true, stdio: "ignore" });
+    const child = spawn2(cmd, args, { detached: true, stdio: "ignore" });
     child.unref();
     return { opened: true };
   } catch {
@@ -63413,122 +63295,6 @@ async function drainTtyResponses(timeoutMs = 50) {
   });
 }
 
-// src/cli/ui/scene/input-source.ts
-import { spawn as spawn4 } from "child_process";
-function spawnInputSource(opts) {
-  const command = opts.command;
-  const [cmd, ...args] = command;
-  if (!cmd) {
-    throw new Error("spawnInputSource: empty command");
-  }
-  const child = spawn4(cmd, args, {
-    cwd: opts.cwd,
-    env: opts.env ?? process.env,
-    stdio: ["ignore", "pipe", "inherit"]
-  });
-  const buses = { keys: /* @__PURE__ */ new Set(), pastes: /* @__PURE__ */ new Set(), mice: /* @__PURE__ */ new Set() };
-  let buf = "";
-  child.stdout?.setEncoding("utf8");
-  child.stdout?.on("data", (chunk) => {
-    buf += chunk;
-    let nl = buf.indexOf("\n");
-    while (nl >= 0) {
-      const line = buf.slice(0, nl);
-      buf = buf.slice(nl + 1);
-      dispatch(line, buses);
-      nl = buf.indexOf("\n");
-    }
-  });
-  child.stdout?.on("end", () => {
-    if (buf.length > 0) {
-      dispatch(buf, buses);
-      buf = "";
-    }
-  });
-  const exitPromise = new Promise((resolve3) => {
-    child.once("exit", (code) => resolve3(code));
-  });
-  return {
-    onKey(handler) {
-      buses.keys.add(handler);
-      return () => {
-        buses.keys.delete(handler);
-      };
-    },
-    onPaste(handler) {
-      buses.pastes.add(handler);
-      return () => {
-        buses.pastes.delete(handler);
-      };
-    },
-    onMouse(handler) {
-      buses.mice.add(handler);
-      return () => {
-        buses.mice.delete(handler);
-      };
-    },
-    async close() {
-      if (child.exitCode === null && !child.killed) {
-        child.kill("SIGINT");
-      }
-      return exitPromise;
-    },
-    wait() {
-      return exitPromise;
-    }
-  };
-}
-function dispatch(line, buses) {
-  if (line.trim().length === 0) return;
-  let parsed;
-  try {
-    parsed = JSON.parse(line);
-  } catch {
-    return;
-  }
-  if (isKeyEvent(parsed)) {
-    for (const handler of buses.keys) handler(parsed);
-    return;
-  }
-  if (isPasteEvent(parsed)) {
-    for (const handler of buses.pastes) handler(parsed);
-    return;
-  }
-  if (isMouseEvent(parsed)) {
-    for (const handler of buses.mice) handler(parsed);
-    return;
-  }
-}
-function isKeyEvent(value) {
-  if (typeof value !== "object" || value === null) return false;
-  const obj = value;
-  if (obj.event !== "key" || typeof obj.code !== "string") return false;
-  if (obj.char !== void 0 && typeof obj.char !== "string") return false;
-  if (obj.modifiers !== void 0 && !Array.isArray(obj.modifiers)) return false;
-  return true;
-}
-function isPasteEvent(value) {
-  if (typeof value !== "object" || value === null) return false;
-  const obj = value;
-  return obj.event === "paste" && typeof obj.text === "string";
-}
-var MOUSE_KINDS = /* @__PURE__ */ new Set([
-  "click",
-  "drag",
-  "release",
-  "scroll-up",
-  "scroll-down"
-]);
-function isMouseEvent(value) {
-  if (typeof value !== "object" || value === null) return false;
-  const obj = value;
-  if (obj.event !== "mouse") return false;
-  if (typeof obj.kind !== "string" || !MOUSE_KINDS.has(obj.kind)) return false;
-  if (typeof obj.row !== "number" || typeof obj.col !== "number") return false;
-  if (obj.modifiers !== void 0 && !Array.isArray(obj.modifiers)) return false;
-  return true;
-}
-
 // src/cli/ui/scene/input-adapter.ts
 var nullKeystrokeReader = {
   start() {
@@ -63538,115 +63304,6 @@ var nullKeystrokeReader = {
     };
   }
 };
-function createRustKeystrokeReader(opts) {
-  const source = spawnInputSource(opts);
-  const handlers19 = /* @__PURE__ */ new Set();
-  source.onKey((rust) => {
-    const ev = translate(rust);
-    if (!ev) return;
-    for (const h of handlers19) h(ev);
-  });
-  source.onPaste((rust) => {
-    const ev = translatePaste(rust);
-    for (const h of handlers19) h(ev);
-  });
-  source.onMouse((rust) => {
-    const ev = translateMouse(rust);
-    for (const h of handlers19) h(ev);
-  });
-  return {
-    start() {
-    },
-    subscribe(handler) {
-      handlers19.add(handler);
-      return () => {
-        handlers19.delete(handler);
-      };
-    },
-    close() {
-      return source.close();
-    },
-    wait() {
-      return source.wait();
-    }
-  };
-}
-function translate(rust) {
-  const mods = new Set(rust.modifiers ?? []);
-  const ctrl = mods.has("ctrl");
-  const shift = mods.has("shift");
-  const alt = mods.has("alt");
-  switch (rust.code) {
-    case "Char": {
-      if (rust.char === void 0) return null;
-      const ev = { input: rust.char };
-      if (ctrl) ev.ctrl = true;
-      if (alt) ev.meta = true;
-      if (shift) ev.shift = true;
-      return ev;
-    }
-    case "Enter":
-      return withMods({ input: "", return: true }, ctrl, shift, alt);
-    case "Esc":
-      return { input: "", escape: true };
-    case "Up":
-      return { input: "", upArrow: true };
-    case "Down":
-      return { input: "", downArrow: true };
-    case "Left":
-      return { input: "", leftArrow: true };
-    case "Right":
-      return { input: "", rightArrow: true };
-    case "Backspace":
-      return { input: "", backspace: true };
-    case "Tab":
-      return withMods({ input: "", tab: true }, ctrl, shift, alt);
-    case "BackTab":
-      return { input: "", tab: true, shift: true };
-    case "Home":
-      return { input: "", home: true };
-    case "End":
-      return { input: "", end: true };
-    case "PageUp":
-      return { input: "", pageUp: true };
-    case "PageDown":
-      return { input: "", pageDown: true };
-    case "Delete":
-      return { input: "", delete: true };
-    default:
-      return null;
-  }
-}
-function withMods(ev, ctrl, shift, alt) {
-  if (ctrl) ev.ctrl = true;
-  if (shift) ev.shift = true;
-  if (alt) ev.meta = true;
-  return ev;
-}
-function translatePaste(rust) {
-  return { input: sanitizePasteText(rust.text), paste: true };
-}
-function translateMouse(rust) {
-  const ev = { input: "", mouseRow: rust.row, mouseCol: rust.col };
-  switch (rust.kind) {
-    case "click":
-      ev.mouseClick = true;
-      break;
-    case "drag":
-      ev.mouseDrag = true;
-      break;
-    case "release":
-      ev.mouseRelease = true;
-      break;
-    case "scroll-up":
-      ev.mouseScrollUp = true;
-      break;
-    case "scroll-down":
-      ev.mouseScrollDown = true;
-      break;
-  }
-  return ev;
-}
 
 // src/cli/ui/scene/null-stdin.ts
 import { Readable } from "stream";
@@ -63893,27 +63550,21 @@ async function chatCommand(opts) {
 `);
     }
   }
-  let rustRendererActive = process.env.REASONIX_RENDERER !== "node";
-  let resolved = rustRendererActive ? resolveRenderer() : void 0;
-  if (rustRendererActive && (!resolved || resolved.source === null)) {
+  let rustRendererActive = isIntegratedRendererRequested();
+  if (process.env.REASONIX_RENDERER !== "node" && !rustRendererActive) {
     process.stderr.write(
-      `\u25B2 Rust renderer binary not found \u2014 falling back to the Node/Ink TUI.
-  Install @reasonix/render-${process.platform}-${process.arch}, set REASONIX_RENDER_BIN to a built binary, or run from source with cargo on PATH.
+      `\u25B2 Rust renderer native binding not loadable for ${process.platform}-${process.arch} \u2014 falling back to the Node/Ink TUI.
+  Run \`npm run build:rust\` for a source build, or reinstall reasonix to fetch the optional dep.
 `
     );
     process.env.REASONIX_RENDERER = "node";
     rustRendererActive = false;
-    resolved = void 0;
   }
-  const rustIntegrated = rustRendererActive && isIntegratedRendererRequested();
   const inkStdout = rustRendererActive ? makeNullStdout() : void 0;
   const inkStdin = rustRendererActive ? makeNullStdin() : void 0;
-  const rustInputChild = rustRendererActive && !rustIntegrated && resolved ? createRustKeystrokeReader({ command: resolved.inputCommand }) : void 0;
-  const keystrokeReader = rustIntegrated ? nullKeystrokeReader : rustInputChild;
+  const keystrokeReader = rustRendererActive ? nullKeystrokeReader : void 0;
   const stderrRestore = rustRendererActive ? redirectStderrToLogFile() : void 0;
-  const rustKeepAlive = rustRendererActive ? setInterval(() => {
-  }, 2147483647) : void 0;
-  if (rustIntegrated) {
+  if (rustRendererActive) {
     setIntegratedEventHandler((event) => {
       if (event.event === "submit") {
         qqSubmitRef.current?.(event.text);
@@ -63985,10 +63636,8 @@ async function chatCommand(opts) {
   try {
     await waitUntilExit();
   } finally {
-    if (rustKeepAlive) clearInterval(rustKeepAlive);
     await runtime.closeAll();
     qqChannel?.stop();
-    if (rustInputChild) await rustInputChild.close();
     if (stderrRestore) stderrRestore();
     await drainTtyResponses();
   }
@@ -63997,4 +63646,4 @@ async function chatCommand(opts) {
 export {
   chatCommand
 };
-//# sourceMappingURL=chunk-DFP43NI5.js.map
+//# sourceMappingURL=chunk-KQBNRLFZ.js.map