pi-supernova 0.5.0 → 0.7.0

package/src/runtime/guest-worker.js

@@ -1,8 +1,28 @@
 import { parentPort } from "node:worker_threads";
 import { AsyncLocalStorage } from "node:async_hooks";
-import { isString, isObject, isFunction, isNumber, toPlain, looksLikePath } from "../shared/decode.js";
+import { register, registerHooks } from "node:module";
+import { isString, isObject, isFunction, toPlain, looksLikePath } from "../shared/decode.js";
 import { truncateChars } from "../output/format.js";
-import { sessionJsonArgs, validateJsonRead } from "../fs/json-read.js";
+import { gatherReadArgs, normalizeRead, decodeReadValue, assertReadPaths } from "../contract/read.js";
+import { classifyEdit } from "../contract/edit.js";
+import { normalizeBash } from "../contract/bash.js";
+import { guestImportMessage, isDeniedGuestImport } from "./guest-deny-imports.js";
+
+if (isFunction(registerHooks)) {
+  registerHooks({
+    resolve(specifier, context, nextResolve) {
+      if (isDeniedGuestImport(specifier)) {
+        const error = new Error(guestImportMessage(specifier));
+        error.code = "ERR_GUEST_IMPORT";
+        throw error;
+      }
+
+      return nextResolve(specifier, context);
+    },
+  });
+} else {
+  register("./guest-deny-imports.js", import.meta.url);
+}
 
 // Guest programs run here, off the host thread. The host can terminate() this
 // worker mid-loop, so a runaway "while (true) {}" or process.exit() in guest
@@ -14,6 +34,10 @@ const PARAMS = ["console", "read", "edit", "write", "bash"];
 
 const BODY_LINE_OFFSET = 2;
 
+const QUERY_URI = /^(agent|artifact):\/\/.*\?/i;
+
+const PER_PATH_HINT = "; use Promise.allSettled(paths.map(path => read(path))) for per-path outcomes";
+
 /** Best-effort guest line:col from an error stack (V8 "<anonymous>:L:C", JSC "eval code").*/
 function guestLocation(err) {
   const stack = String(err?.stack);
@@ -71,16 +95,6 @@ function unwrapRead(res, args) {
   return value;
 }
 
-function unwrapJsonValue(res) {
-  const value = unwrapValue(res);
-
-  try {
-    return JSON.parse(value);
-  } catch {
-    return value;
-  }
-}
-
 /** Keep details/truncated reachable but out of the returned literal unless they carry signal. */
 function leanEnvelope(res) {
   if (!isObject(res)) return res;
@@ -94,248 +108,313 @@ function leanEnvelope(res) {
   return res;
 }
 
-function quoteShellArg(value) {
-  return "'" + String(value).replaceAll("'", "'\\''") + "'";
+function swallow(promise) {
+  promise.catch(() => {});
+
+  return promise;
 }
 
-function buildGuestApi(available, batchRead, runId, _nativeArgv) {
-  const rpc = (method, args) => callRpc(runId, method, args);
-  const availableSet = new Set(available);
-  const checkpointScope = new AsyncLocalStorage();
-  let checkpoint = null;
+function throwReadPathError(target, detail) {
+  throw new Error(`read failed for ${target}: ${detail}${PER_PATH_HINT}`);
+}
 
-  const assertScope = () => {
-    const token = checkpointScope.getStore();
+function isQueryUri(item) {
+  return QUERY_URI.test(item);
+}
 
-    if (token ? token !== checkpoint : checkpoint !== null) throw new Error("await the active edit checkpoint before issuing other commands; completed checkpoints cannot issue commands");
-  };
+function firstItemErrorIndex(res) {
+  return res?.itemErrors?.findIndex(error => error != null) ?? -1;
+}
 
-  const nova = {
-    call: async (name, args) => leanEnvelope(await rpc("call", [name, args])),
-    async callMany(calls) {
-      const wave = await rpc("callMany", [calls]);
-      const results = Array.isArray(wave?.results) ? wave.results : Array.isArray(wave) ? wave : [];
-      Object.defineProperties(results, {
-        mode: { value: wave?.mode, enumerable: false },
-        reason: { value: wave?.reason, enumerable: false },
-        results: { value: results, enumerable: false },
-      });
-
-      return results;
-    },
-    async speculate(fn) {
-      if (checkpoint) throw new Error("edit checkpoints cannot overlap or nest; await the current checkpoint");
-      const token = {};
-      checkpoint = token;
-      let began = false;
+function missingResolvedIndex(values, paths) {
+  return values.findIndex((value, index) => value?.status === "not_found" && looksLikePath(paths[index]));
+}
 
-      try {
-        flushReads();
-        await rpc("speculateBegin", []);
-        began = true;
-        const value = await checkpointScope.run(token, fn);
-        flushReads();
-        await rpc("speculateCommit", []);
+async function rpcReadWave(rpc, wave) {
+  if (wave.length === 1) {
+    const res = leanEnvelope(await rpc("call", ["read", wave[0].args]));
 
-        return { ok: true, committed: true, value };
-      } catch (err) {
-        flushReads();
+    return { values: [unwrapRead(res, wave[0].args)], errors: [] };
+  }
+  const args = { ...wave[0].args, path: wave.map(job => job.args.path), _independent: true };
+  const res = leanEnvelope(await rpc("call", ["read", args]));
+  unwrapRead(res, args);
 
-        if (began) await rpc("speculateRollback", []);
+  return { values: res.items, errors: res.itemErrors ?? [] };
+}
 
-        return { ok: false, committed: false, error: err instanceof Error ? err.message : String(err) };
-      } finally { checkpoint = null; }
-    },
-    surface: async (filePath) => unwrapJsonValue(await rpc("call", ["surface", { path: filePath }])),
-    evidence: async (query, opts) => unwrapJsonValue(await rpc("call", ["evidence", { query, ...opts }])),
-    snap: async (query, targetPath) => unwrapJsonValue(await rpc("call", ["snap", { query, path: targetPath }])),
-    has: (name) => availableSet.has(name),
+function settleReadWave(wave, values, errors) {
+  if (!Array.isArray(values) || values.length !== wave.length) throw new Error("invalid batch read response");
+
+  for (let i = 0; i < wave.length; i++) {
+    if (errors[i]) wave[i].reject(new Error(errors[i]));
+    else wave[i].resolve(values[i]);
+  }
+}
+
+function rejectReadWave(wave, error) {
+  for (const job of wave) job.reject(error);
+}
+
+function dispatchReadWaves(pending, pendingReadWaves, enqueueHost, rpc) {
+  for (let start = 0; start < pending.length; start += 64) {
+    const wave = pending.slice(start, start + 64);
+    const delivery = enqueueHost(() => rpcReadWave(rpc, wave))
+      .then(({ values, errors }) => settleReadWave(wave, values, errors))
+      .catch(error => rejectReadWave(wave, error));
+
+    pendingReadWaves.add(delivery);
+    void delivery.finally(() => pendingReadWaves.delete(delivery));
+  }
+}
+
+function enqueueCompatibleRead(readState, flushReads, args, decode) {
+  const key = JSON.stringify({ ...args, path: undefined });
+
+  if (readState.queued.length && readState.queued[0].key !== key) flushReads();
+
+  const promise = new Promise((resolve, reject) => {
+    readState.queued.push({ args, key, resolve, reject });
+
+    if (readState.queued.length === 1) queueMicrotask(flushReads);
+  }).then(decode);
+
+  return swallow(promise);
+}
+
+async function readManyPaths(readOne, invoke, batchRead, args, paths, decode) {
+  assertReadPaths(paths);
+  const readEach = async () => {
+    const values = await Promise.all(paths.map(item => readOne({ ...args, path: item })));
+    const missing = args.resolve ? missingResolvedIndex(values, paths) : -1;
+
+    if (missing >= 0) throwReadPathError(paths[missing], "not_found");
+
+    return values;
   };
 
-  // Coalesce already-started compatible reads without rewriting JS control flow.
-  let queuedReads = [];
+  const guardedReadEach = () => swallow(readEach());
 
-  function flushReads() {
-    const pending = queuedReads;
-    queuedReads = [];
+  if (!batchRead || args.resolve || paths.some(isQueryUri)) return guardedReadEach();
+  const res = await invoke("read", args);
+  const failed = firstItemErrorIndex(res);
 
-    for (let start = 0; start < pending.length; start += 64) {
-      const wave = pending.slice(start, start + 64);
-      const args = { ...wave[0].args, path: wave.map(job => job.args.path), _independent: true };
+  if (failed >= 0) throwReadPathError(paths[failed], res.itemErrors[failed]);
+  unwrapRead(res, args);
 
-      const run = wave.length === 1
-        ? nova.call("read", wave[0].args).then(res => ({ values: [unwrapRead(res, wave[0].args)], errors: [] }))
-        : nova.call("read", args).then(res => { unwrapRead(res, args);
+  if (Array.isArray(res?.items)) return res.items.map(decode);
 
- return { values: res.items, errors: res.itemErrors ?? [] }; });
+  return guardedReadEach();
+}
 
-      void run.then(({ values, errors }) => {
-        if (!Array.isArray(values) || values.length !== wave.length) throw new Error("invalid batch read response");
+function attachCallManyMeta(wave) {
+  const results = Array.isArray(wave?.results) ? wave.results : Array.isArray(wave) ? wave : [];
+  Object.defineProperties(results, {
+    mode: { value: wave?.mode, enumerable: false },
+    reason: { value: wave?.reason, enumerable: false },
+    results: { value: results, enumerable: false },
+  });
 
-        for (let i = 0; i < wave.length; i++) {
-          const value = values[i];
+  return results;
+}
 
-          if (errors[i]) wave[i].reject(new Error(errors[i]));
-          else wave[i].resolve(value);
-        }
-      }).catch(error => { for (const job of wave) job.reject(error); });
-    }
-  }
+async function runSpeculation(fn, token, checkpointScope, drainReads, enqueueHost, rpc) {
+  let began = false;
 
-  const invoke = (name, args) => { assertScope(); flushReads();
+  try {
+    await drainReads();
+    await enqueueHost(() => rpc("speculateBegin", []));
+    began = true;
+    const value = await checkpointScope.run(token, fn);
+    await drainReads();
+    await enqueueHost(() => rpc("speculateCommit", []));
+
+    return { ok: true, committed: true, value };
+  } catch (err) {
+    await drainReads();
 
- return nova.call(name, args); };
+    if (began) await enqueueHost(() => rpc("speculateRollback", []));
 
-  const readArgs = (p, a, b) => isObject(p) && !Array.isArray(p)
-    ? { ...p, path: p.path ?? p.query }
-    : isObject(a) && !Array.isArray(a) ? { path: p, ...a } : { path: p, offset: a, limit: b };
+    return { ok: false, committed: false, error: err instanceof Error ? err.message : String(err) };
+  }
+}
 
-  const read = async (p, a, b) => {
-    assertScope();
-    const args = sessionJsonArgs(readArgs(p, a, b));
-    if (isString(args.path) && args.resolve === undefined && args.json === undefined && !looksLikePath(args.path) && !/^(?:agent|artifact):\/\//i.test(args.path)) {
-      args.resolve = true;
-    }
-    validateJsonRead(args);
-    const decode = value => args.resolve || args.json !== undefined ? JSON.parse(value) : value;
+function formatBashFailure(command, res) {
+  let exitCode;
 
-    if (args.complete === true && (args.outline || args.evidence || args.about)) throw new Error("complete:true requires a raw file read, not an outline or evidence view");
-    const evidencePath = isObject(p) && !Array.isArray(p) ? p.path : args.about ? p : undefined;
-    p = args.path;
+  try {
+    exitCode = JSON.parse(res.details).exitCode;
+  } catch {}
 
-    if (args.evidence) return unwrapJsonValue(await invoke("evidence", { ...args, path: evidencePath, query: args.about ?? args.query ?? p }));
+  const output = String(res.value).trimEnd();
+  const suffix = Number.isInteger(exitCode) ? " (exit " + exitCode + ")" : "";
 
-    if (args.outline) return unwrapJsonValue(await invoke("surface", args));
+  return "command failed" + suffix + ": " + command + (output ? "\n" + output : "");
+}
 
-    if (Array.isArray(p)) {
-      if (p.length > 64) throw new Error("read accepts at most 64 paths per batch");
+function markTruncatedOutput(res, text) {
+  if (res?.truncated && isString(text) && !text.includes("truncated")) return text + "\n…[output truncated]…";
 
-      for (const item of p) if (!isString(item) || !item.trim()) throw new Error("read paths must be non-empty strings");
-      const readEach = () => Promise.all(p.map(item => read({ ...args, path: item })));
+  return text;
+}
+
+function encodeConsoleArg(a) {
+  if (isString(a)) return a;
+
+  try {
+    const plain = toPlain(a);
+    const encoded = JSON.stringify(plain);
 
-      if (!batchRead || args.resolve || p.some(item => /^(agent|artifact):\/\/.*\?/i.test(item))) return readEach();
-      const res = await invoke("read", args);
-      const failed = res?.itemErrors?.findIndex(error => error != null) ?? -1;
+    return encoded === undefined ? String(plain) : encoded;
+  } catch {
+    return String(a);
+  }
+}
 
-      if (failed >= 0) throw new Error(`read failed for ${p[failed]}: ${res.itemErrors[failed]}; use Promise.allSettled(paths.map(path => read(path))) for per-path outcomes`);
-      unwrapRead(res, args);
+function compileGuest(prepared, data) {
+  const bindings = data === undefined ? PARAMS : [...PARAMS, "data"];
 
-      if (Array.isArray(res?.items)) return res.items.map(decode);
+  return { fn: new AsyncFunction(...bindings, prepared.body), hasReturn: prepared.hasReturn };
+}
 
-      // Captured host executor without batch support: fan out.
-      return readEach();
-    }
+function plainGuestValue(value) {
+  try { return toPlain(value); }
+  catch (err) { return "[unserializable: " + (err?.message || err) + "]"; }
+}
 
-    if (!batchRead) {
-      const res = await invoke("read", args);
-      unwrapRead(res, args);
+function handleRpcResult(msg) {
+  const pending = pendingRpc.get(msg.id);
 
-      return decode(unwrapRead(res, args));
-    }
+  if (!pending) return;
+  pendingRpc.delete(msg.id);
 
-    const key = JSON.stringify({ ...args, path: undefined });
+  if (msg.ok) pending.resolve(msg.value);
+  else pending.reject(new Error(msg.error));
+}
 
-    if (queuedReads.length && queuedReads[0].key !== key) flushReads();
+function buildGuestApi(available, batchRead, runId, _nativeArgv) {
+  const rpc = (method, args) => callRpc(runId, method, args);
+  const checkpointScope = new AsyncLocalStorage();
+  let checkpoint = null;
 
-    return new Promise((resolve, reject) => {
-      queuedReads.push({ args, key, resolve, reject });
+  const assertScope = () => {
+    const token = checkpointScope.getStore();
 
-      if (queuedReads.length === 1) queueMicrotask(flushReads);
-    }).then(decode);
+    if (token ? token !== checkpoint : checkpoint !== null) throw new Error("await the active edit checkpoint before issuing other commands; completed checkpoints cannot issue commands");
   };
 
-  const write = async (p, content) => unwrapValue(await invoke("write", isObject(p) ? p : { path: p, content }));
+  let operationTail = Promise.resolve();
 
-  const viewSpan = (value) => {
-    const start = isNumber(value.start) ? value.start : Array.isArray(value.lines) ? value.lines[0] : value.line;
-    const end = isNumber(value.end) ? value.end : Array.isArray(value.lines) && value.lines.length > 1 ? value.lines[1] : start;
+  const enqueueHost = operation => {
+    const next = operationTail.then(operation);
+    operationTail = next.then(() => {}, () => {});
 
-    if (!isNumber(start) || !isNumber(end) || start < 1 || end < start) return null;
-
-    return { start: Math.floor(start), end: Math.floor(end) };
+    return next;
   };
 
-  const isView = (value) => isObject(value) && !Array.isArray(value) && isString(value.path) && value.path.trim() && isString(value.text) && (value.status === undefined || value.status === "found") && viewSpan(value);
+  const nova = {
+    call(name, args) {
+      assertScope(); flushReads();
 
-  const edit = async (p, oldText, newText) => {
-    if (isFunction(p)) return nova.speculate(p);
-    const usage = 'invalid edit signature; use edit(path,oldText,newText), edit({path,edits:[{oldText,newText}]}), or edit({path,patch:"@@ -1 +1 @@\n-old\n+new\n"})';
+      return swallow(enqueueHost(() => rpc("call", [name, args]).then(leanEnvelope)));
+    },
+    callMany(calls) {
+      assertScope(); flushReads();
 
-    if (isView(p) && isString(oldText) && (newText === undefined || isString(newText))) {
-      if (isNumber(p.nextOffset)) throw new Error("edit view is incomplete");
-      const span = viewSpan(p);
-      const args = { path: p.path, viewStart: span.start, viewEnd: span.end, viewText: p.text, newText: newText === undefined ? oldText : newText };
+      return swallow(enqueueHost(async () => attachCallManyMeta(await rpc("callMany", [calls]))));
+    },
+    async speculate(fn) {
+      if (checkpoint) throw new Error("edit checkpoints cannot overlap or nest; await the current checkpoint");
+      const token = {};
+      checkpoint = token;
 
-      if (newText !== undefined) args.oldText = oldText;
+      try { return await runSpeculation(fn, token, checkpointScope, drainReads, enqueueHost, rpc); }
+      finally { checkpoint = null; }
+    },
+  };
 
-      return unwrapValue(await invoke("edit", args));
-    }
+  // Coalesce already-started compatible reads without rewriting JS control flow.
+  const readState = { queued: [], waves: new Set() };
 
-    if (isObject(p) && (Array.isArray(p) || oldText !== undefined || newText !== undefined)) throw new Error(usage);
+  function flushReads() {
+    const pending = readState.queued;
+    readState.queued = [];
+    dispatchReadWaves(pending, readState.waves, enqueueHost, rpc);
+  }
 
-    if (!isObject(p) && isObject(oldText) && !Array.isArray(oldText)) throw new Error(usage);
-    const args = isObject(p) ? p : Array.isArray(oldText) ? { path: p, edits: oldText } : { path: p, oldText, newText };
+  async function drainReads() {
+    for (;;) {
+      flushReads();
+      const waves = [...readState.waves];
 
-    if (!isString(args.path) || !args.path.trim()) throw new Error(usage);
-    const modes = Number(args.patch !== undefined) + Number(args.edits !== undefined) + Number(args.oldText !== undefined || args.newText !== undefined);
+      if (!waves.length) return;
+      await Promise.allSettled(waves);
+    }
+  }
 
-    if (modes !== 1 || (Array.isArray(oldText) && newText !== undefined)) throw new Error(usage);
+  const invoke = (name, args) => {
+    assertScope(); flushReads();
 
-    if (args.patch !== undefined) {
-      if (!isString(args.patch) || !args.patch.trim()) throw new Error(usage);
-    } else {
-      const edits = args.edits === undefined ? [args] : args.edits;
+    return swallow(nova.call(name, args));
+  };
+
+  const read = async (p, a, b) => {
+    assertScope();
+    const args = normalizeRead(gatherReadArgs(p, a, b));
+    const decode = value => decodeReadValue(args, value);
+    p = args.path;
 
-      if (!Array.isArray(edits) || !edits.length) throw new Error(usage);
+    if (Array.isArray(p)) {
+      const values = await readManyPaths(read, invoke, batchRead, args, p, decode);
+      for (const item of p) if (isString(item)) noteReadPath({ path: item }, values);
 
-      for (const e of edits) if (!isString(e?.oldText) || !e.oldText.length || !isString(e?.newText)) throw new Error(usage + "; replacements require non-empty oldText and string newText");
+      return values;
     }
 
-    return unwrapValue(await invoke(args.patch === undefined ? "edit" : "apply_patch", args));
+    const readValue = !batchRead
+      ? decode(unwrapRead(await invoke("read", args), args))
+      : await enqueueCompatibleRead(readState, flushReads, args, decode);
+    noteReadPath(args, readValue);
+
+    return readValue;
   };
 
-  const bash = async (command, opts) => {
-    const args = isObject(command) ? { ...command } : { command, ...opts };
+  const readFiles = new Set();
 
-    if (args.args !== undefined) {
-      if (!isString(args.command) || !Array.isArray(args.args)) throw new Error("bash argv requires a command string and an array of string args");
+  function noteReadPath(args, value) {
+    if (isString(args.path) && looksLikePath(args.path)) readFiles.add(args.path);
+    if (isObject(value) && isString(value.path) && looksLikePath(value.path)) readFiles.add(value.path);
+  }
 
-      for (let i = 0; i < args.args.length; i++) if (!isString(args.args[i])) throw new Error("bash argv requires a command string and an array of string args");
+  const write = async (p, content) => {
+    const args = isObject(p) ? p : { path: p, content };
 
-      // Literal argv is a Supernova-owned contract. Host bash tools often ignore
-      // `args` and would run only `command` (bare `ssh`). Windows still needs a shell.
-      if (process.platform === "win32") {
-        delete args._directArgv;
-        args.command = [args.command, ...args.args].map(quoteShellArg).join(" ");
-        delete args.args;
-      } else args._directArgv = true;
+    if (args.append !== true && args.replace !== true && isString(args.path) && readFiles.has(args.path)) {
+      throw new Error("file was already read this program; use edit(oldText, newText) or edit(view, ...). write({path,content,replace:true}) replaces anyway");
     }
 
-    command = args.command;
-
-    if (args.timeout !== undefined && args.timeoutMs === undefined) args.timeoutMs = args.timeout * 1000;
-    const res = await invoke("bash", args);
+    return unwrapValue(await invoke("write", args));
+  };
 
-    if (res?.ok === false) {
-      let exitCode;
+  const edit = async (p, oldText, newText) => {
+    const classified = classifyEdit(p, oldText, newText);
 
-      try {
-        exitCode = JSON.parse(res.details).exitCode;
-      } catch {}
+    if (classified.kind === "checkpoint") return nova.speculate(classified.fn);
 
-      const output = String(res.value).trimEnd();
-      const suffix = Number.isInteger(exitCode) ? " (exit " + exitCode + ")" : "";
-      throw new Error("command failed" + suffix + ": " + command + (output ? "\n" + output : ""));
-    }
+    return unwrapValue(await invoke(classified.command, classified.args));
+  };
 
-    let text = unwrapValue(res);
+  const bash = async (command, opts) => {
+    const args = normalizeBash(command, opts);
+    command = args.command;
+    const res = await invoke("bash", args);
 
-    if (res?.truncated && isString(text) && !text.includes("truncated")) text += "\n…[output truncated]…";
+    if (res?.ok === false) throw new Error(formatBashFailure(command, res));
 
-    return text;
+    return markTruncatedOutput(res, unwrapValue(res));
   };
 
-  return { read, write, edit, bash };
+  return { read, write, edit, bash, nova };
 }
 
 function makeConsole(runId, limits) {
@@ -353,19 +432,7 @@ function makeConsole(runId, limits) {
  return; }
 
     count++;
-
-    const line = args
-      .map((a) => {
-        if (isString(a)) return a;
-
-        try {
-          return JSON.stringify(toPlain(a));
-        } catch {
-          return String(a);
-        }
-      })
-      .join(" ");
-
+    const line = args.map(encodeConsoleArg).join(" ");
     const clipped = truncateChars(line, limits.maxLogLineChars, "log");
 
     if (clipped.truncated) markTruncated();
@@ -381,16 +448,55 @@ function postFailure(runId, err, location) {
   post({ op: "error", runId, message, location });
 }
 
+function denyBuiltin(id) {
+  if (isDeniedGuestImport(id)) throw new Error(guestImportMessage(id));
+}
+
+let sealedRealm = false;
+
+function sealGuestRealm() {
+  if (sealedRealm) return;
+  sealedRealm = true;
+  if (isFunction(process.getBuiltinModule)) {
+    const orig = process.getBuiltinModule.bind(process);
+    process.getBuiltinModule = (id) => {
+      denyBuiltin(id);
+
+      return orig(id);
+    };
+  }
+
+  if (isFunction(process.binding)) {
+    process.binding = (id) => {
+      throw new Error(guestImportMessage(String(id)));
+    };
+  }
+
+  if (isFunction(process.dlopen)) {
+    process.dlopen = () => {
+      throw new Error("guest cannot load native modules; use read, edit, write, or bash");
+    };
+  }
+
+  if (isFunction(process.kill)) {
+    // Signals are process-wide: process.kill escapes the worker thread and can
+    // terminate the host, so it stays out of the guest. Stop things with bash.
+    process.kill = () => {
+      throw new Error("process.kill is not available in guest programs; stop processes with bash");
+    };
+  }
+}
+
 async function handleRun(msg) {
   const { runId, prepared, limits, available, batchRead = true } = msg;
   activeRunId = runId;
   runActive = true;
   let compiled;
+  sealGuestRealm();
 
   try {
     // Existing programs may declare their own data variable; bind it only when supplied.
-    const bindings = msg.data === undefined ? PARAMS : [...PARAMS, "data"];
-    compiled = { fn: new AsyncFunction(...bindings, prepared.body), hasReturn: prepared.hasReturn };
+    compiled = compileGuest(prepared, msg.data);
   } catch (err) {
     postFailure(runId, new Error("JavaScript syntax error: " + err.message + "; no commands ran. When passing data, do not redeclare its binding."));
 
@@ -406,14 +512,7 @@ async function handleRun(msg) {
     );
 
     if (runId !== activeRunId) return;
-    let plain;
-
-    try {
-      plain = toPlain(value);
-    } catch (err) {
-      plain = "[unserializable: " + (err?.message || err) + "]";
-    }
-
+    const plain = plainGuestValue(value);
     runActive = false;
     post({ op: "done", runId, value: plain, undefinedReturn: value === undefined && !compiled.hasReturn, hasReturn: compiled.hasReturn });
   } catch (err) {
@@ -426,13 +525,7 @@ parentPort.on("message", (msg) => {
   if (!isObject(msg)) return;
 
   if (msg.op === "rpc:result") {
-    const pending = pendingRpc.get(msg.id);
-
-    if (!pending) return;
-    pendingRpc.delete(msg.id);
-
-    if (msg.ok) pending.resolve(msg.value);
-    else pending.reject(new Error(msg.error));
+    handleRpcResult(msg);
 
     return;
   }