pi-supernova 0.10.1 → 0.11.0

package/src/output/final.js

@@ -9,11 +9,15 @@ function collectImage(input, acc) {
 
   acc.imageCount += 1;
   acc.imageBytes += size;
+
   if (acc.imageCount > 16 || acc.imageBytes > 20 * 1024 * 1024) {
     acc.imageOverflow = true;
+
     return "[image over budget]";
   }
+
   const bytes = decodeImageData(input.data);
+
   if (input.mimeType === "image/png") assertPng(bytes);
   acc.images.push({ type: "image", data: input.data, mimeType: input.mimeType });
 
@@ -23,12 +27,14 @@ function collectImage(input, acc) {
 function displayWeight(value,key) {
   // Count even omitted undefined fields: typed result metadata crosses RPC too.
   const field = isString(key) ? key.length+1 : 0;
+
   return field + (isString(value) ? value.length : 1) + (Array.isArray(value) ? value.length : 0);
 }
 
 function collectImages(input, acc, key) {
   const replaced = collectImage(input, acc);
   acc.displayUnits += displayWeight(replaced ?? input,key);
+
   if (replaced !== null) return replaced;
 
   return mapChangedChildren(input, collectImages, acc);
@@ -51,6 +57,7 @@ function clipLogLine(line, maxLogLineChars) {
 function clipLogs(logs, config) {
   const maxLines = config.maxLogLines ?? 100;
   let logTruncated = logs.length > maxLines;
+
   const clipped = logs.slice(0, maxLines).map(line => {
     const result = clipLogLine(line, config.maxLogLineChars ?? 4096);
     logTruncated ||= result.truncated;
@@ -67,19 +74,25 @@ function isSourceView(value) {
 
 function sourcePreview(value, maxReturn) {
   if (!isSourceView(value)) return null;
+
   if (value.text.length < maxReturn / 2) return null;
+
   if (value.text.length <= maxReturn && formatReturn(value).length <= maxReturn-256) return null;
   const base = {...value,text:"",complete:false,nextOffset:value.lines[0]+1};
   let room = maxReturn - formatReturn(base).length - 512;
+
   while (room > 0) {
     const end = value.text.lastIndexOf("\n",room-1) + 1;
+
     if (!end || end >= value.text.length) return null;
     const text = value.text.slice(0,end);
     const lines = [value.lines[0],value.lines[0]+text.match(/\n/g).length-1];
     const preview = {...base,text,lines,nextOffset:lines[1]+1};
+
     if (formatReturn(preview).length <= maxReturn-256) return preview;
     room = Math.floor(room / 2);
   }
+
   return null;
 }
 
@@ -88,23 +101,30 @@ function presentValue(value, maxReturn, oversized) {
     const bounded = truncateChars(value,maxReturn,"return");
     const result = serializeReturn(value,formatReturn(bounded.text),maxReturn,false);
     result.truncated ||= bounded.truncated;
+
     return result;
   }
+
   if (isStringArray(value) && oversized) {
     return {text:formatBoundedStringArray(value,maxReturn),truncated:true};
   }
+
   if (oversized) return {text:formatBoundedValue(value,maxReturn),truncated:true};
+
   return serializeReturn(value,formatReturn(value),maxReturn,false);
 }
 
 export function packageFinalReturn(value, logs, config) {
   const acc = { images: [], imageCount: 0, imageBytes: 0, imageOverflow: false, displayUnits:0 };
   value = collectImages(value, acc);
+
   if (acc.imageOverflow) {
     throw new Error(`image attachment budget exceeded: ${acc.imageCount} images / ${acc.imageBytes} bytes; limit is 16 images / 20971520 bytes (20 MiB). No images returned; return fewer or smaller images per program`);
   }
+
   const maxReturn = config.maxReturnChars ?? 32000;
   const preview = sourcePreview(value,maxReturn);
+
   if (preview) value = preview;
   const serialized = presentValue(value,maxReturn,!preview && acc.displayUnits>maxReturn);
   const clipped = clipLogs(logs, config);

package/src/output/format.js

@@ -77,9 +77,19 @@ function hasUnpairedSurrogate(text) {
   return SURROGATE_CODE_UNIT.test(text) && UNPAIRED_SURROGATE.test(text);
 }
 
+// Error messages bypass value formatting. Escape, rather than replace, invalid
+// code units before budgeting so provider text remains well-formed and lossless.
+export function escapeUnpairedSurrogates(text) {
+  return hasUnpairedSurrogate(text)
+    ? text.replace(/[\uD800-\uDFFF]/gu, unit => "\\u" + unit.charCodeAt(0).toString(16).padStart(4, "0"))
+    : text;
+}
+
 export function isStringArray(value) {
   if (!Array.isArray(value) || !value.length) return false;
+
   for (const item of value) if (!isString(item)) return false;
+
   return true;
 }
 
@@ -91,6 +101,7 @@ function hasWellFormedStrings(values) {
 
 function boundedStringText(value, limit) {
   const text = truncateChars(value,limit,"return").text;
+
   return hasUnpairedSurrogate(text) ? truncateChars(JSON.stringify(text),limit,"return").text : text;
 }
 
@@ -100,15 +111,18 @@ export function formatBoundedStringArray(values, budget) {
   const header = "strings[" + n + "]\n";
   let remaining = Math.max(0, budget - header.length);
   let out = header;
+
   if (header.length >= budget) return truncateChars(header,budget,"return").text;
   const omitted = count => "…[return truncated; " + count + " string items omitted]…\n";
 
   for (let i = 0; i < n; i++) {
     const itemHeader = "[" + i + "] " + values[i].length + " UTF-16 units\n";
     const footer = i + 1 < n ? omitted(n - i - 1) : "";
+
     if (remaining < itemHeader.length + Math.min(32,values[i].length) + 1 + footer.length) {
       return out + truncateChars(omitted(n - i),remaining,"return").text;
     }
+
     const per = Math.min(remaining - itemHeader.length - 1 - footer.length, Math.max(32, Math.floor(remaining / (n - i)) - itemHeader.length - 1));
     const chunk = itemHeader + boundedStringText(values[i],per) + "\n";
     remaining = Math.max(0, remaining - chunk.length);
@@ -181,12 +195,17 @@ const IDENT_KEY = /^[A-Za-z_$][\w$]*$/;
 const FORMAT_WIDTH = 120;
 
 function formatKey(key) {
+  // Computed spelling retains an own data key instead of setting the prototype.
+  if (key === "__proto__") return '["__proto__"]';
+
   return IDENT_KEY.test(key) ? key : JSON.stringify(key);
 }
 
 function formatPrimitive(value) {
   if (value === undefined) return "undefined";
 
+  if (Object.is(value, -0)) return "-0";
+
   if (Number.isNaN(value) || value === Infinity || value === -Infinity) return String(value);
 
   try { return JSON.stringify(value) ?? String(value); }
@@ -291,6 +310,7 @@ export function formatValue(value, indent = "", width = FORMAT_WIDTH, seen = new
   if (value?.[RAW_TEXT] !== undefined) return value[RAW_TEXT];
 
   if (!isObject(value) && !Array.isArray(value)) return formatPrimitive(value);
+
   if (seen.has(value)) return "[Circular]";
   seen.add(value);
 
@@ -314,65 +334,106 @@ function displayKeys(value) {
 export function displayExceeds(value, budget) {
   const seen = new Set();
   const spend = units => (budget -= units) < 0;
+
   function container(item) {
     if (seen.has(item)) return false;
     seen.add(item);
     const array = Array.isArray(item);
+
     if (array && spend(item.length)) return true;
+
     for (const key of displayKeys(item)) {
       if (!array && spend(key.length+1)) return true;
+
       if (visit(item[key])) return true;
     }
+
     seen.delete(item);
+
     return false;
   }
+
   function visit(item) {
     if (spend(isString(item) ? item.length : 1)) return true;
+
     return isObject(item) || Array.isArray(item) ? container(item) : false;
   }
+
   return visit(value);
 }
 
-/** Display-only prefix; never constructs an oversized JSON/string rendering. */
+function boundedQuotedText(text, budget, label) {
+  if (budget < 2) return "";
+  const end = maxJsonStringPrefix(text, budget);
+
+  if (end === text.length) return JSON.stringify(text);
+  const marker = "…[" + label + " truncated; " + text.length + " UTF-16 units]…";
+  const markerChars = JSON.stringify(marker).length - 2;
+
+  if (markerChars + 2 > budget) return JSON.stringify(text.slice(0, end));
+  const prefix = maxJsonStringPrefix(text, budget - markerChars);
+
+  return JSON.stringify(text.slice(0, prefix) + marker);
+}
+
+/** Fair display-only previews; bounded work, no expansion of full strings. */
 export function formatBoundedValue(value, budget, label = "return") {
-  const footer = "\n…["+label+" truncated]…";
-  const parts = [];
+  const footer = "\n…[" + label + " truncated]…";
+  const limit = charLimit(budget, 32000);
   const seen = new Set();
-  let remaining = Math.max(0,budget-footer.length), stopped = false;
-  const push = text => {
-    if (text.length > remaining) { stopped = true; return false; }
-    remaining -= text.length; parts.push(text); return true;
-  };
-  function quoted(text) {
-    const end = maxJsonStringPrefix(text,remaining);
-    push(JSON.stringify(text.slice(0,end)));
-    if (end < text.length) stopped = true;
-  }
-  function visitChild(item,key,array) {
-    if (!array) { quoted(key); push(":"); }
-    visit(array && item[key] === undefined ? null : item[key]);
-  }
-  function container(item) {
-    if (seen.has(item)) { push('"[Circular]"'); return; }
+
+  function render(item, room, depth) {
+    if (isString(item)) return boundedQuotedText(item, room, label);
+
+    if (!isObject(item) && !Array.isArray(item)) return truncateChars(formatPrimitive(item), room, label).text;
+
+    if (seen.has(item)) return truncateChars('"[Circular]"', room, label).text;
+
+    if (depth >= 32 || room < 4) return truncateChars("…[" + label + " truncated]…", room, label).text;
     seen.add(item);
-    const array = Array.isArray(item);
-    push(array ? "[" : "{");
-    let first = true;
-    for (const key of displayKeys(item)) {
-      if (stopped) break;
-      if (!first) push(",");
-      first = false;
-      visitChild(item,key,array);
+
+    try {
+      return container(item, room, depth);
+    } finally {
+      seen.delete(item);
     }
-    if (!stopped) push(array ? "]" : "}");
-    seen.delete(item);
   }
-  function visit(item) {
-    if (stopped) return;
-    if (isString(item)) quoted(item);
-    else if (isObject(item) || Array.isArray(item)) container(item);
-    else push(formatPrimitive(item));
+
+  function container(item, room, depth) {
+    const array = Array.isArray(item);
+    const keys = displayKeys(item);
+    const count = array ? item.length : keys.length;
+    const parts = [array ? "[" : "{"];
+    let remaining = room - 2;
+    let index = 0;
+
+    for (const key of keys) {
+      const separator = index === 0 ? "" : ",";
+      const heading = array ? "" : boundedQuotedText(key, Math.max(2, Math.floor(remaining / 3)), "key") + ":";
+      const omitted = "…[" + label + " truncated; " + (count - index) + " items omitted]…";
+      const reserve = index + 1 < count ? omitted.length + 1 : 0;
+      const available = remaining - separator.length - heading.length - reserve;
+
+      if (available < 4) {
+        parts.push(truncateChars(omitted, remaining, label).text);
+        break;
+      }
+
+      // Small siblings give unused space back. Large siblings cannot consume
+      // later paths/results; very large collections disclose the omitted count.
+      const share = Math.min(available, Math.max(64, Math.floor(remaining / (count - index)) - heading.length - separator.length));
+      const child = array && item[key] === undefined ? null : item[key];
+      const text = separator + heading + render(child, share, depth + 1);
+
+      parts.push(text);
+      remaining -= text.length;
+      index += 1;
+    }
+
+    parts.push(array ? "]" : "}");
+
+    return parts.join("");
   }
-  visit(value);
-  return truncateChars(parts.join("")+footer,budget,"return").text;
+
+  return render(value, Math.max(0, limit - footer.length), 0) + truncateChars(footer, limit, label).text;
 }

package/src/output/outcome.js

@@ -1,5 +1,5 @@
 import {isString} from '../shared/decode.js';
-import {truncateChars,formatBoundedStringArray,isStringArray} from './format.js';
+import {truncateChars,formatBoundedStringArray,isStringArray,escapeUnpairedSurrogates} from './format.js';
 
 function result(text, details) {
   return { content: [{ type: "text", text }], details };
@@ -11,14 +11,23 @@ function logsBlock(outcome, tail = "") {
   return `\n--- logs${outcome.logTruncated ? " [logs truncated]" : ""}\n${outcome.logs?.join("\n") ?? ""}${tail}`;
 }
 
-function mutationText(outcome) {
+// Printed only when it informs: files committed or rolled back, an uncertain
+// filesystem outcome, or (failures only) shell side effects that survive the
+// rollback. A successful program rolls nothing back, so its shell calls need
+// no warning.
+function mutationText(outcome, failed) {
   const m = outcome.mutations;
 
   if (!m) return "";
-  const external = m.external ? "; external calls attempted=" + m.external + ", their side effects cannot be rolled back" : "";
+  const external = failed && m.external ? "; external calls attempted=" + m.external + ", their side effects cannot be rolled back" : "";
   const uncertain = m.pendingCommits || m.recoveryFailed ? "; filesystem outcome uncertain: inspect disk and any recovery backups before retrying" : "";
 
-  return "\nmutations: committed=" + m.committed + " rolledBack=" + m.rolledBack + " (file versions)" + external + uncertain;
+  if (!m.committed && !m.rolledBack && !external && !uncertain) return "";
+
+  const saved = failed && outcome.savedPaths?.length ? "\nSaved edits: " + truncateChars(JSON.stringify(outcome.savedPaths), 2048, "saved paths").text : "";
+  const retry = failed && m.committed && !uncertain ? saved + "\nDo not repeat saved edits. Retry only failed or not-run work; dependent JavaScript stops at the uncaught error." : saved;
+
+  return "\nmutations: committed=" + (m.committed || 0) + " rolledBack=" + (m.rolledBack || 0) + " (file versions)" + external + uncertain + retry;
 }
 
 function mutationReceipts(trace) {
@@ -39,17 +48,15 @@ function splitTurnHint(outcome) {
 }
 
 function errorText(outcome, call) {
-  return `error #${call} ${outcome.wallMs}ms${outcome.returnTruncated ? " [output truncated]" : ""}${mutationText(outcome)}${splitTurnHint(outcome)}
-error: ${outcome.error}${logsBlock(outcome)}`;
+  return escapeUnpairedSurrogates(`error #${call} ${outcome.wallMs}ms${outcome.returnTruncated ? " [output truncated]" : ""}${mutationText(outcome, true)}${splitTurnHint(outcome)}
+error: ${outcome.error}${logsBlock(outcome)}`);
 }
 
 function successText(outcome, call) {
   const truncated = outcome.returnTruncated ? " [return truncated]" : "";
   const hint = outcome.undefinedReturn ? " (no return statement; add `return` to get a value)" : "";
-  const m = outcome.mutations;
-  const showMutations = m && (m.committed || m.rolledBack || m.external || m.pendingCommits || m.recoveryFailed) ? mutationText(outcome) : "";
 
-  return `ok #${call} ${outcome.wallMs}ms${truncated}${showMutations}${splitTurnHint(outcome)}${logsBlock(outcome, "\n--- result")}\n${outcome.resultText}${hint}`;
+  return `ok #${call} ${outcome.wallMs}ms${truncated}${mutationText(outcome, false)}${splitTurnHint(outcome)}${logsBlock(outcome, "\n--- result")}\n${outcome.resultText}${hint}`;
 }
 
 function fitOutput(outcome, call, limit, format) {
@@ -72,6 +79,14 @@ function fitOutput(outcome, call, limit, format) {
 }
 
 function attachReceipts(outcome, trace) {
+  const saved = new Set();
+
+  for (const row of trace) {
+    if (row.mutationState === "saved" && isString(row.args?.path)) saved.add(row.args.path);
+  }
+
+  outcome.savedPaths = [...saved];
+
   if (outcome.ok && outcome.result === undefined) {
     const receipts = mutationReceipts(trace);
 
@@ -88,4 +103,5 @@ function throwIfFailed(outcome, visible, response) {
   Object.defineProperty(error,"supernovaResult",{value:response});
   throw error;
 }
+
 export { result, errorText, successText, fitOutput, attachReceipts, throwIfFailed };

package/src/runtime/batch-input.js

@@ -2,6 +2,7 @@ import {isObject,isString} from '../shared/decode.js';
 
 function assertProgramEntry(p, defaults = {}) {
   const source = p?.code === undefined && p?.file === undefined ? defaults : p;
+
   if (!objectData(p) || Object.keys(p).some(key => !["code", "file", "data"].includes(key)) || !validProgramSource(source)) {
     throw new Error("each program requires code OR file (own or shared), with optional data; no nested batches or per-entry timeouts; no programs ran");
   }
@@ -30,11 +31,17 @@ function applyBatchDefaults(parsed, mergeData) {
 
 function parseBatchPayload(params, config) {
   assertBatchOptions(params);
-  const defaults = Object.fromEntries(["code", "file", "data"].filter(key => params[key] !== undefined).map(key => [key, params[key]]));
+  const defaults = Object.fromEntries(["code", "file", "data"].flatMap(key => (params[key] !== undefined ? [[key, params[key]]] : [])));
+
   if (defaults.code !== undefined || defaults.file !== undefined) assertProgramEntry(defaults);
+
   for (const p of params.programs) assertProgramEntry(p, defaults);
-  // Validate before serialization and again after snapshotting: toJSON may change an entry.
-  return applyBatchDefaults(snapshotBatch(params, defaults, config), params.mergeData === true);
+
+  // Serialization may change the array itself as well as its entries.
+  const parsed = snapshotBatch(params, defaults, config);
+  assertBatchOptions(parsed);
+
+  return applyBatchDefaults(parsed, params.mergeData === true);
 }
 
 function batchTimeoutMs(params, config) {
@@ -47,22 +54,29 @@ function batchTimeoutMs(params, config) {
 
 function validProgramSource(source) {
   const value = source.code ?? source.file;
+
   return (source.code === undefined) !== (source.file === undefined) && isString(value) && value.trim();
 }
 
 function assertBatchOptions(params) {
   if (!Array.isArray(params.programs) || !params.programs.length || params.programs.length > 32) throw new Error("programs requires 1..32 entries; no programs ran");
+
   if (params.mergeData !== undefined && ![true, false].includes(params.mergeData)) throw new Error("mergeData must be boolean; no programs ran");
 }
 
 function snapshotBatch(params, defaults, config) {
   const hasDefaults = Object.keys(defaults).length > 0;
   let encoded;
+
   try { encoded = JSON.stringify(hasDefaults ? {programs:params.programs,...defaults} : params.programs); }
   catch { throw new Error("programs and defaults must be JSON-serializable; no programs ran"); }
+
   if (encoded.length > (config.maxCodeChars ?? 48000)) throw new Error("programs JSON exceeds the code character budget (including shared code/file/data); no programs ran");
   const parsed = hasDefaults ? JSON.parse(encoded) : {programs:JSON.parse(encoded)};
+
   if (Object.hasOwn(defaults,"data") && !Object.hasOwn(parsed,"data")) throw new Error("data must be JSON-serializable; no programs ran");
+
   return parsed;
 }
+
 export { parseBatchPayload, batchTimeoutMs };

package/src/runtime/guest-api.js

@@ -47,6 +47,14 @@ function leanEnvelope(res) {
   return res;
 }
 
+// RPC and coalesced-read rejection callbacks run outside the awaiting guest's
+// stack. Recreate their error at this async boundary, only on failure, so V8 can
+// retain the guest await frames. Do not capture stacks on successful calls.
+async function withGuestStack(promise) {
+  try { return await promise; }
+  catch (error) { throw new Error(error.message, { cause: error.cause }); }
+}
+
 function swallow(promise) {
   promise.catch(() => {});
 
@@ -192,7 +200,10 @@ function formatBashFailure(command, res) {
 }
 
 function markTruncatedOutput(res, text) {
-  if (res?.truncated && isString(text) && !text.includes("truncated")) return text + "\n…[output truncated]…";
+  // A literal word such as a variable name is not a truncation disclosure.
+  const marker = "…[output truncated]…";
+
+  if (res?.truncated && isString(text) && !text.endsWith(marker)) return text + "\n" + marker;
 
   return text;
 }
@@ -240,7 +251,7 @@ export function buildGuestApi(rpc, batchRead) {
   const invoke = (name, args) => {
     assertScope(); flushReads();
 
-    return swallow(rpc("call", [name, args]).then(leanEnvelope));
+    return swallow(withGuestStack(rpc("call", [name, args]).then(leanEnvelope)));
   };
 
   const read = async (p, a, b) => {
@@ -250,9 +261,13 @@ export function buildGuestApi(rpc, batchRead) {
 
     if (Array.isArray(p)) return await readManyPaths(read, args, p);
 
-    return !batchRead
-      ? unwrapRead(await invoke("read", args), args, noteReadPath)
-      : await enqueueCompatibleRead(readState, flushReads, args);
+    // Preserve streamed-item timing by restoring failures in this existing
+    // async boundary, not through another successful-path Promise hop.
+    try {
+      return !batchRead
+        ? unwrapRead(await invoke("read", args), args, noteReadPath)
+        : await enqueueCompatibleRead(readState, flushReads, args);
+    } catch (error) { throw new Error(error.message, { cause: error.cause }); }
   };
 
   const readFiles = new Set();
@@ -265,8 +280,18 @@ export function buildGuestApi(rpc, batchRead) {
     if (isString(envelope.sourcePath)) readFiles.add(envelope.sourcePath);
   }
 
-  const write = async (p, content) => {
-    const args = isObject(p) ? p : { path: p, content };
+  const write = async (p, content, options) => {
+    if (isObject(p) && (content !== undefined || options !== undefined)) throw new Error("write object form does not accept positional content or options");
+
+    if (options !== undefined && (!isObject(options) || Object.keys(options).some(key => !["append", "replace", "allowReadArtifacts"].includes(key)))) {
+      throw new Error("write options must be an object containing only append, replace, allowReadArtifacts");
+    }
+
+    const args = isObject(p) ? p : { ...options, path: p, content };
+
+    for (const key of ["append", "replace", "allowReadArtifacts"]) {
+      if (args[key] !== undefined && args[key] !== true && args[key] !== false) throw new Error("write " + key + " must be a boolean");
+    }
 
     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");

package/src/runtime/guest-worker.js

@@ -9,6 +9,7 @@ import { truncateChars,formatReturn,displayExceeds,formatBoundedValue } from "..
 import { guestImportMessage, isDeniedGuestImport } from "./guest-deny-imports.js";
 
 const { register, registerHooks } = nodeModule;
+
 // heapUsed/external belong to this worker; rss includes the entire Pi/OMP host.
 const memoryUsage = process.memoryUsage.bind(process);
 
@@ -97,12 +98,16 @@ function encodeConsoleArg(a, limit) {
     const raw = truncateChars(a,limit,"log");
     const encoded = truncateChars(formatReturn(raw.text),limit,"log");
     encoded.truncated ||= raw.truncated;
+
     return encoded;
   }
+
   try {
     const plain = toPlain(a);
+
     if (displayExceeds(plain,limit)) return {text:formatBoundedValue(plain,limit,"log"),truncated:true};
     const encoded = JSON.stringify(plain);
+
     return truncateChars(encoded === undefined ? String(plain) : encoded,limit,"log");
   } catch { return truncateChars(formatReturn(String(a)),limit,"log"); }
 }
@@ -130,10 +135,13 @@ function handleRpcResult(msg) {
 
 function handleReadItem(msg) {
   const pending = pendingRpc.get(msg.id);
+
   if (!pending?.onItem || !runActive || msg.runId !== activeRunId) return;
   let error;
+
   try { pending.onItem(msg.index,msg.value); }
   catch (err) { error = errorMessage(err); pending.reject(err); pendingRpc.delete(msg.id); }
+
   reportMemory(activeRunId);
   post({op:"rpc:ack",id:msg.id,index:msg.index,runId:activeRunId,error});
 }
@@ -154,14 +162,19 @@ function makeConsole(runId, limits) {
 
     count++;
     let line = "", first = true;
+
     for (const arg of args) {
       const room = limits.maxLogLineChars-line.length-(first ? 0 : 1);
+
       if (room <= 0) { markTruncated(); break; }
+
       const encoded = encodeConsoleArg(arg,room);
+
       if (encoded.truncated) markTruncated();
       line += (first ? "" : " ")+encoded.text;
       first = false;
     }
+
     const clipped = truncateChars(line, limits.maxLogLineChars, "log");
 
     if (clipped.truncated) markTruncated();
@@ -171,10 +184,10 @@ function makeConsole(runId, limits) {
   return { log: emit, warn: emit, error: emit, info: emit, debug: emit };
 }
 
-function postFailure(runId, err, location) {
+function postFailure(runId, err, location, errorKind = err?.name) {
   runActive = false;
   const message = errorMessage(err);
-  post({ op: "error", runId, message, location });
+  post({ op: "error", runId, message, location, errorKind });
 }
 
 function denyBuiltin(id) {
@@ -186,6 +199,7 @@ let sealedRealm = false;
 function sealGuestRealm() {
   if (sealedRealm) return;
   sealedRealm = true;
+
   if (isFunction(process.getBuiltinModule)) {
     const orig = process.getBuiltinModule.bind(process);
     process.getBuiltinModule = (id) => {
@@ -227,7 +241,7 @@ async function handleRun(msg) {
     // Existing programs may declare their own data variable; bind it only when supplied.
     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."));
+    postFailure(runId, new Error("JavaScript syntax error: " + err.message + "; no commands ran."), undefined, err.name);
 
     return;
   }
@@ -258,7 +272,11 @@ async function handleRun(msg) {
 parentPort.on("message", (msg) => {
   if (!isObject(msg)) return;
 
-  if (msg.op === "rpc:item") { handleReadItem(msg); return; }
+  if (msg.op === "rpc:item") {
+    handleReadItem(msg);
+
+    return;
+  }
 
   if (msg.op === "rpc:result") {
     handleRpcResult(msg);