pi-supernova 0.10.2 → 0.11.0

package/src/runtime/runtime.js

@@ -1,5 +1,7 @@
 import {acquireWorker,killWorker} from './worker-pool.js';
+
 export {warmGuestWorker,stopWarmGuestWorker} from './worker-pool.js';
+
 import {admitGuest,prepareProgram,normalizeGuestLocation} from './program.js';
 
 import { readProgramFile } from "./program-file.js";
@@ -18,7 +20,8 @@ const GUEST_COMMANDS = new Set(["read", "edit", "write", "bash"]);
 // shadow it (redeclaration or TDZ); `supernova` is the tool, not a guest
 // function; `data` can only collide when the call supplied it. Anything
 // else gets no hint.
-function guestMistakeHint(message) {
+function guestMistakeHint(message, kind) {
+  if (kind !== "ReferenceError" && kind !== "SyntaxError") return "";
   const name = /Identifier '([^']+)' has already been declared/.exec(message)?.[1] ?? /Cannot access '([^']+)' before initialization/.exec(message)?.[1];
 
   if (GUEST_COMMANDS.has(name)) return "; `" + name + "` is a supernova command: give your variable another name (e.g. const text = await " + name + "(...))";
@@ -31,6 +34,7 @@ function guestMistakeHint(message) {
 }
 
 const ABORT_MESSAGE = "supernova aborted";
+
 const TIMEOUT_MESSAGE = "supernova timed out: increase the outer timeoutMs (and any shorter bash timeoutMs), or split the program; sleeps count toward the deadline";
 
 const MEMORY_SLACK = 1.5;
@@ -42,7 +46,9 @@ export function formatMemoryAttribution({ limitMb, heapBytes, externalBytes, ms,
   const parts = tracked
     ? [["vfs cache", tracked.vfsCacheBytes], ["index entries", tracked.indexBytes], ["overlays", tracked.overlayBytes]]
     : [];
+
   const where = op ? ` during ${op} (${calls} host calls)` : ` (${calls} host calls)`;
+
   const seen = parts.length
     ? `; supernova-tracked host bytes (not charged to guest): ${parts.map(([name, bytes]) => `${name} ${toMb(Number(bytes) || 0).toFixed(1)}MB`).join(", ")} in ${tracked.overlayFiles ?? 0} overlay files`
     : "";
@@ -54,11 +60,6 @@ let runSeq = 0;
 
 const RPC_METHODS = {
   call: (nova, args, onItem) => nova.call(args[0], args[1], onItem),
-  callMany: async (nova, args) => {
-    const wave = await nova.callMany(args[0]);
-
-    return Array.isArray(wave) ? { results: [...wave], mode: wave.mode, reason: wave.reason } : wave;
-  },
   speculateBegin: (nova) => nova.speculateBegin(),
   speculateCommit: (nova) => nova.speculateCommit(),
   speculateRollback: (nova) => nova.speculateRollback(),
@@ -149,6 +150,7 @@ class GuestRun {
 
     try {
       this.handle.worker.postMessage({ ...message, runId: this.runId });
+
       return true;
     } catch (err) {
       try {
@@ -156,6 +158,7 @@ class GuestRun {
       } catch (error) {
         this.onError(error);
       }
+
       return false;
     }
   }
@@ -163,8 +166,10 @@ class GuestRun {
   deliverReadItem(id, index, value) {
     if (!this.accepting) return Promise.reject(new Error("aborted"));
     const key = id + ":" + index;
+
     return new Promise((resolve,reject) => {
       this.deliveries.set(key,{resolve,reject});
+
       if (!this.postResult({op:"rpc:item",id,index,value})) {
         this.deliveries.delete(key);
         reject(new Error("read result not transferable"));
@@ -175,20 +180,24 @@ class GuestRun {
   onReadAck(msg) {
     const key = msg.id + ":" + msg.index;
     const delivery = this.deliveries.get(key);
+
     if (!delivery) return;
     this.deliveries.delete(key);
+
     if (msg.error) delivery.reject(new Error(msg.error));
     else delivery.resolve();
   }
 
   async drainPending(outcome) {
     if (this.pending.size || !outcome.ok) this.cancelHost();
+
     if (!this.pending.size) return;
     let timer;
 
     try {
       await Promise.race([Promise.allSettled(this.pending), new Promise(resolve => { timer = setTimeout(resolve, 250); })]);
     } finally { clearTimeout(timer); }
+
     if (this.pending.size && outcome.ok) this.hostError ??= "program completed with a host call still running";
   }
 
@@ -201,11 +210,14 @@ class GuestRun {
     this.handle?.worker.off("exit", this.onExit);
     void killWorker(this.handle);
     await this.drainPending(outcome);
+
     if (this.finished) return;
+
     if (this.abortOutcome) {
       const diagnostic = this.hostError && this.hostError !== "aborted" ? "\n" + this.hostError : "";
       outcome = this.fail(this.abortOutcome.error + diagnostic);
     }
+
     this.finish(outcome.ok && this.hostError ? this.fail(this.hostError) : outcome);
   }
 
@@ -223,11 +235,13 @@ class GuestRun {
     const method = Object.hasOwn(RPC_METHODS, msg.method) && RPC_METHODS[msg.method];
     this.rpcCount++;
     this.lastRpcMethod = isString(msg.method) ? msg.method : null;
+
     const work = Promise.resolve().then(() => {
       if (!method) throw new Error("unknown nova method: " + msg.method);
 
       const onItem = msg.streamRead && msg.method === "call" && msg.args?.[0] === "read"
         ? (index,value) => this.deliverReadItem(msg.id,index,value) : undefined;
+
       return method(this.nova, msg.args, onItem);
     });
 
@@ -245,8 +259,10 @@ class GuestRun {
     // A completed guest cannot submit more work while attachments are decoded.
     // The outer timer stays armed; no commit occurs before validation completes.
     this.accepting = false;
+
     try {
       const packed = msg.output ?? packageFinalReturn(msg.value, this.logs, this.config);
+
       if (packed.images?.length) await validateReturnedImages(packed.images,this.inputController.signal);
       void this.complete({ ok: true, result: packed.returnValue, resultText: packed.returnText,
         returnTruncated: packed.returnTruncated, images: packed.images, undefinedReturn: msg.undefinedReturn === true,
@@ -257,18 +273,25 @@ class GuestRun {
   }
 
   guestError(msg) {
-    const location = normalizeGuestLocation(this.prepared.body, msg.location);
+    const location = normalizeGuestLocation(this.code, msg.location, this.prepared);
     const where = location ? " (line " + location.line + ":" + location.col + ")" : "";
-    void this.complete(this.fail(msg.message + where + guestMistakeHint(msg.message)));
+
+    // Native errors may include source lines and carets. Annotate the headline,
+    // never the end of that diagnostic payload.
+    const message = msg.message.replace(/(\r\n|[\n\r\u2028\u2029]|$)/, where + "$1");
+    void this.complete(this.fail(message + guestMistakeHint(msg.message, msg.errorKind)));
   }
 
   onMemory(msg) {
     const { heapUsed, external } = msg;
+
     if (![heapUsed, external].every(bytes => Number.isFinite(bytes) && bytes >= 0)) return;
+
     if (heapUsed + external <= (this.config.maxHeapMb ?? 512) * MEMORY_SLACK * 1048576) return;
     let tracked = null;
 
     try { tracked = isFunction(this.nova?.describeMemory) ? this.nova.describeMemory() : null; } catch {}
+
     // Use the same cancellation/drain path as other failures, not an early
     // finish that can return while a host command is still mutating files.
     void this.complete(this.fail(formatMemoryAttribution({
@@ -296,8 +319,14 @@ class GuestRun {
 
   async loadCode() {
     if (this.file !== undefined) this.code = await readProgramFile(this.file, this.cwd, this.config.maxCodeChars ?? 48000, this.inputController.signal);
+
     if (this.finished) return false;
-    if (!this.code.trim()) { this.finish(this.fail("code must be a non-empty string; no commands ran")); return false; }
+
+    if (!this.code.trim()) {
+      this.finish(this.fail("code must be a non-empty string; no commands ran"));
+
+      return false;
+    }
 
     try { this.prepared = prepareProgram(this.code); }
     catch (error) {
@@ -306,6 +335,7 @@ class GuestRun {
         : " Fix " + this.file + " and re-run.";
 
       this.finish(this.fail("JavaScript syntax error" + (this.file === undefined ? "" : " in " + this.file) + ": " + error.message + "; no commands ran." + guidance + errorContext(this.code, error)));
+
       return false;
     }
 
@@ -313,27 +343,45 @@ class GuestRun {
   }
 
   async attachWorker() {
-    if (this.wall() >= this.timeoutMs) { this.abort(true); return false; }
+    if (this.wall() >= this.timeoutMs) {
+      this.abort(true);
+
+      return false;
+    }
+
     this.handle = acquireWorker(this.config);
     await this.handle.ready;
-    if (this.finished || this.signal?.aborted) { this.abort(); return false; }
-    let available = isFunction(this.nova.names) ? await this.nova.names() : [];
 
-    if (!Array.isArray(available)) available = [];
-    if (this.finished || this.signal?.aborted) { this.abort(); return false; }
+    if (this.finished || this.signal?.aborted) {
+      this.abort();
+
+      return false;
+    }
+
+    if (isFunction(this.nova.names)) await this.nova.names();
+
+    if (this.finished || this.signal?.aborted) {
+      this.abort();
+
+      return false;
+    }
+
     this.handle.worker.on("message", this.onMessage);
     this.handle.worker.on("error", this.onError);
     this.handle.worker.on("exit", this.onExit);
-    if (this.wall() >= this.timeoutMs) { this.abort(true); return false; }
-    this.available = available;
+
+    if (this.wall() >= this.timeoutMs) {
+      this.abort(true);
+
+      return false;
+    }
 
     return true;
   }
 
   postRun() {
-    this.handle.worker.postMessage({ op: "run", runId: this.runId, prepared: this.prepared, data: this.data, available: this.available,
+    this.handle.worker.postMessage({ op: "run", runId: this.runId, prepared: this.prepared, data: this.data,
       batchRead: this.nova.batchRead !== false,
-      nativeArgv: this.nova.nativeArgv === true,
       formatResult:true,
       limits: { maxReturnChars:this.config.maxReturnChars ?? 32000, maxLogLines: this.config.maxLogLines ?? 100, maxLogLineChars: this.config.maxLogLineChars ?? 4096 } });
   }
@@ -341,7 +389,9 @@ class GuestRun {
   async boot() {
     try {
       if (this.signal?.aborted) return this.abort();
+
       if (!await this.loadCode()) return;
+
       if (!await this.attachWorker()) return;
       this.postRun();
     } catch (err) {
@@ -366,6 +416,7 @@ export async function runGuestProgram({ code, file, cwd = process.cwd(), data, n
   const fail = (error) => ({ ok: false, error: truncateChars(String(error), config.maxReturnChars ?? 32000, "error").text, logs: [], logTruncated: false, wallMs: 0 });
 
   if (admitted.error) return fail(admitted.error);
+
   if (signal?.aborted) return fail(ABORT_MESSAGE);
 
   return new GuestRun({

package/src/runtime/worker-pool.js

@@ -4,6 +4,8 @@ const WORKER_URL = new URL("./guest-worker.js", import.meta.url);
 
 let idleWorker = null;
 
+let generation = 0;
+
 function spawnWorker(config) {
   const maxHeapMb = config.maxHeapMb ?? 512;
   // An inline bootstrap accepts inherited --input-type from stdin/eval SDK hosts.
@@ -55,6 +57,7 @@ function killWorker(handle) {
 }
 
 function acquireWorker(config) {
+  const acquiredGeneration = generation;
   const candidate = idleWorker;
   idleWorker = null;
   const reusable = candidate && !candidate.dead && candidate.maxHeapMb === (config.maxHeapMb ?? 512);
@@ -68,7 +71,10 @@ function acquireWorker(config) {
   // so the two constructions never overlap. The finish-time warm usually
   // becomes a no-op, so steady-state spawn count is unchanged.
   if (reusable) warmGuestWorker(config).catch(() => {});
-  else handle.ready.then(() => warmGuestWorker(config).catch(() => {}), () => {});
+  else handle.ready.then(() => {
+    // A cold worker can finish starting after session_shutdown drained the pool.
+    if (generation === acquiredGeneration) return warmGuestWorker(config).catch(() => {});
+  }, () => {});
 
   return handle;
 }
@@ -86,6 +92,9 @@ export function warmGuestWorker(config = {}) {
 }
 
 export function stopWarmGuestWorker() {
+  generation++;
+
   return killWorker(idleWorker);
 }
+
 export { acquireWorker, killWorker };

package/src/shared/decode.js

@@ -26,11 +26,16 @@ export function mapChangedChildren(value, visit, context) {
   if (!array && !isObject(value)) return value;
   let out = value;
 
-  for (const key of childKeys(value)) {
+  // Array indexes can be inherited; holes and non-index properties stay unvisited.
+  const keys = array ? value.keys() : Object.keys(value);
+
+  for (const key of keys) {
+    if (array && !(key in value)) continue;
     const before = value[key];
     const after = visit(before, context, key);
 
     if (Object.is(before, after)) continue;
+
     if (out === value) out = array ? value.slice() : { ...value };
     // Define rather than assign: "__proto__" must remain an ordinary data key.
     Object.defineProperty(out, key, { value: after, enumerable: true, writable: true, configurable: true });
@@ -51,9 +56,11 @@ export function assertModelImageMime(mimeType) {
 /** Node's base64 decoder is permissive; model attachments must not be. */
 export function decodeImageData(data) {
   const bytes = Buffer.from(data,"base64");
+
   if (!data || bytes.toString("base64") !== String(data)) {
     throw new Error("invalid image base64; use canonical padded base64 without a data-URL prefix or extra characters; no image attached");
   }
+
   return bytes;
 }
 
@@ -93,7 +100,7 @@ function plainFromCollection(value, seen, depth) {
   if (value instanceof Map) return plainFromMap(value, seen, depth);
   const out = Object.create(null);
 
-  for (const k of childKeys(value)) out[k] = toPlain(value[k], seen, depth + 1);
+  for (const k of Object.keys(value)) out[k] = toPlain(value[k], seen, depth + 1);
 
   return out;
 }
@@ -177,9 +184,3 @@ export function toPlain(value, seen = new Set(), depth = 0) {
 export function errorMessage(error) {
   return error instanceof Error ? error.message : String(error);
 }
-
-// Arrays visit present indexes (including inherited ones), not extra properties.
-function* childKeys(value) {
-  if (!Array.isArray(value)) { yield* Object.keys(value); return; }
-  for (const key of value.keys()) if (key in value) yield key;
-}

package/src/shared/image-worker.js

@@ -3,22 +3,29 @@
 import sharp from "sharp";
 
 const MAX_PIXELS = 32_000_000;
+
 async function inputBytes() {
   const chunks = [];
   let size = 0;
+
   for await (const chunk of process.stdin) {
     size += chunk.length;
+
     if (size > 20 * 1024 * 1024) throw new Error("encoded image exceeds 20 MiB");
     chunks.push(chunk);
   }
+
   return Buffer.concat(chunks,size);
 }
 
 async function decode() {
   const image = sharp(await inputBytes(),{failOn:"warning",limitInputPixels:MAX_PIXELS,pages:-1}).timeout({seconds:5});
+
   try {
     const meta = await image.metadata();
+
     if ("image/" + meta.format !== process.argv[2]) throw new Error("encoded format does not match declared MIME");
+
     if (meta.width * meta.height > MAX_PIXELS) throw new Error("decoded pixel limit exceeded");
     // Full decode, without resizing or shrinking that could conceal corruption.
     // No decoded pixels cross back into the agent process.

package/src/shared/image.js

@@ -5,16 +5,22 @@ import {assertModelImageMime,decodeImageData,errorMessage} from "./decode.js";
 import {assertPng} from "./png.js";
 
 const MAX_BYTES = 20 * 1024 * 1024;
+
 // Cache only successful content digests, never image bytes or file paths. A file
 // changed in place cannot reuse validation of its old contents.
 const verified = new Set();
+
 const workerPath = fileURLToPath(new URL("./image-worker.js",import.meta.url));
+
 let tail = Promise.resolve();
 
 function matchesSignature(bytes, mime) {
   if (mime === "image/png") return bytes.subarray(0,8).equals(Buffer.from([137,80,78,71,13,10,26,10]));
+
   if (mime === "image/jpeg") return bytes[0] === 255 && bytes[1] === 216 && bytes[2] === 255;
+
   if (mime === "image/gif") return ["GIF87a","GIF89a"].includes(bytes.toString("ascii",0,6));
+
   return bytes.toString("ascii",0,4) === "RIFF" && bytes.toString("ascii",8,12) === "WEBP";
 }
 
@@ -24,29 +30,37 @@ function invalid(mime, label, reason) {
 
 function decodePixels(bytes, mime, signal) {
   signal?.throwIfAborted();
+
   return new Promise((resolve,reject)=>{
     // BUN_BE_BUN lets a compiled OMP executable run its normal Bun runtime,
     // whose module resolver can load native dependencies from this package.
     const child = childProcess.spawn(process.execPath,[workerPath,mime],{
       env:{...process.env,BUN_BE_BUN:"1"},stdio:["pipe","ignore","pipe"],windowsHide:true,
     });
-    let stderr = "", timedOut = false;
+
+    let stderr = "", timedOut = false, processError;
     const abort = ()=>child.kill("SIGKILL");
     const timer = setTimeout(()=>{timedOut=true;abort();},5000);
+
     const finish = error=>{
       clearTimeout(timer);
       signal?.removeEventListener("abort",abort);
+
       if (error) reject(error); else resolve();
     };
+
     child.stderr.on("data",chunk=>{stderr += chunk.toString().slice(0,Math.max(0,2048-stderr.length));});
     child.stdin.on("error",()=>{}); // Early decoder exit may close stdin first.
-    child.once("error",finish);
+    // A failed spawn also closes; other child errors can precede pipe cleanup.
+    // Only close releases the raster slot, and the watchdog remains armed.
+    child.on("error",error=>{processError ??= error;});
     child.once("close",code=>{
       if (signal?.aborted) finish(signal.reason ?? new Error("aborted"));
       else if (timedOut) finish(new Error("image decoding exceeded 5000 ms"));
-      else finish(code === 0 ? undefined : new Error(stderr.trim() || "image decoder exited before validation"));
+      else finish(processError ?? (code === 0 ? undefined : new Error(stderr.trim() || "image decoder exited before validation")));
     });
     signal?.addEventListener("abort",abort,{once:true});
+
     if (signal?.aborted) abort();
     child.stdin.end(bytes);
   });
@@ -55,22 +69,51 @@ function decodePixels(bytes, mime, signal) {
 export async function validateImageBytes(bytes, mime, label = "", signal) {
   signal?.throwIfAborted();
   assertModelImageMime(mime);
+
   if (bytes.length > MAX_BYTES) throw invalid(mime,label,"encoded image exceeds 20 MiB");
+
   if (!matchesSignature(bytes,mime)) throw invalid(mime,label,"signature does not match declared format");
   const key = mime + ":" + createHash("sha256").update(bytes).digest("hex");
-  const work = tail.then(async()=>{
-    signal?.throwIfAborted();
-    if (verified.has(key)) return;
-    if (mime === "image/png") assertPng(bytes,label);
-    try { await decodePixels(bytes,mime,signal); }
-    catch (error) { signal?.throwIfAborted(); throw invalid(mime,label,errorMessage(error)); }
-    verified.add(key);
-    if (verified.size > 16) verified.delete(verified.values().next().value);
+
+  // A verified digest needs no raster allocation and cannot contend with the
+  // decoder. Recheck inside the queue for identical, concurrently admitted bytes.
+  if (verified.has(key)) return;
+
+  return new Promise((resolve,reject) => {
+    let started = false;
+
+    const abort = () => {
+      if (started) return;
+      bytes = undefined;
+      signal.removeEventListener("abort",abort);
+      reject(signal.reason);
+    };
+
+    const work = tail.then(async() => {
+      started = true;
+      signal?.removeEventListener("abort",abort);
+      signal?.throwIfAborted();
+
+      if (verified.has(key)) return;
+
+      if (mime === "image/png") assertPng(bytes,label);
+
+      try { await decodePixels(bytes,mime,signal); }
+      catch (error) { signal?.throwIfAborted(); throw invalid(mime,label,errorMessage(error)); }
+
+      verified.add(key);
+
+      if (verified.size > 16) verified.delete(verified.values().next().value);
+    });
+
+    // Withdrawal settles the caller and releases its bytes, not the active
+    // decoder's slot. Live successors still wait for actual raster cleanup.
+    tail = work.catch(()=>{});
+    work.then(resolve,reject);
+    signal?.addEventListener("abort",abort,{once:true});
+
+    if (signal?.aborted) abort();
   });
-  // Serialize native raster allocations, not normal reads/guests. Failed or
-  // cancelled validation must never poison the next image's queue slot.
-  tail = work.catch(()=>{});
-  await work;
 }
 
 export async function validateReturnedImages(images, signal) {

package/src/shared/png.js

@@ -1,17 +1,22 @@
 import * as zlib from "node:zlib";
 import {isFunction} from "./decode.js";
+
 // Fast container preflight before full decoding. Older Node/Bun versions use the
 // portable CRC fallback instead of requiring node:zlib.crc32.
 const signature = Buffer.from([137,80,78,71,13,10,26,10]);
+
 const crcTable = Uint32Array.from({length:256}, (_, value) => {
   for (let bit = 0; bit < 8; bit++) value = (value >>> 1) ^ ((value & 1) ? 0xedb88320 : 0);
+
   return value >>> 0;
 });
 
 function crc32(bytes) {
   if (isFunction(zlib.crc32)) return zlib.crc32(bytes);
   let crc = 0xffffffff;
+
   for (const byte of bytes) crc = (crc >>> 8) ^ crcTable[(crc ^ byte) & 255];
+
   return (crc ^ 0xffffffff) >>> 0;
 }
 
@@ -23,19 +28,26 @@ function chunkAt(bytes, offset, label) {
   if (bytes.length - offset < 12) invalid("truncated chunk", label);
   const length = bytes.readUInt32BE(offset);
   const type = bytes.toString("ascii",offset+4,offset+8);
+
   if (!/^[A-Za-z]{4}$/.test(type)) invalid("invalid chunk type", label);
   const end = offset + 8 + length;
+
   if (end + 4 > bytes.length) invalid("truncated " + type + " chunk", label);
+
   if (crc32(bytes.subarray(offset+4,end)) !== bytes.readUInt32BE(end)) invalid(type + " checksum mismatch", label);
+
   return {type,length,end:end+4};
 }
 
 function checkHeader(bytes, chunk, offset, label) {
   if (offset !== 8) {
     if (chunk.type === "IHDR") invalid("duplicate IHDR", label);
+
     return;
   }
+
   if (chunk.type !== "IHDR" || chunk.length !== 13) invalid("missing or invalid IHDR", label);
+
   if (!bytes.readUInt32BE(offset+8) || !bytes.readUInt32BE(offset+12)) invalid("empty dimensions", label);
 }
 
@@ -43,15 +55,21 @@ function checkHeader(bytes, chunk, offset, label) {
 export function assertPng(bytes, label = "") {
   if (!bytes.subarray(0,8).equals(signature)) invalid("signature mismatch", label);
   let offset = 8, imageData = false;
+
   while (offset < bytes.length) {
     const chunk = chunkAt(bytes,offset,label);
     checkHeader(bytes,chunk,offset,label);
+
     if (chunk.type === "IDAT") imageData = true;
+
     if (chunk.type === "IEND") {
       if (chunk.length || !imageData || chunk.end !== bytes.length) invalid("invalid IEND or missing IDAT", label);
+
       return;
     }
+
     offset = chunk.end;
   }
+
   invalid("missing IEND", label);
 }

package/src/shared/result.js

@@ -24,24 +24,38 @@ export function resultDiff(response) {
 // Only native adapters can attach this host-local marker. It never crosses RPC;
 // the bridge sends a typed-value flag instead of asking the guest to guess JSON.
 export const READ_VALUE = Symbol("native read value");
+
 export const READ_BYTES = Symbol("native read bytes");
+
 export const READ_PREVIEW = Symbol("native read preview");
-export const MAX_READ_VALUE_BYTES = 64 * 1024 * 1024;
 
-function retainedReadValue(value) {
-  return isString(value) || isObject(value) || Array.isArray(value);
-}
+// Host-only disk-read provenance, not user data or a claim about displayed text.
+export const READ_FILES = Symbol("native disk reads");
 
-function containerBytes(value, pending, seen) {
+export const MAX_READ_VALUE_BYTES = 64 * 1024 * 1024;
+
+function containerBytes(value, pending, seen, remaining) {
   if (seen.has(value)) return 8;
   seen.add(value);
   let bytes = 32;
+
+  if (bytes > remaining) return bytes;
   const array = Array.isArray(value);
-  const keys = array ? value.keys() : Object.keys(value);
-  for (const key of keys) {
+  const keys = array ? null : Object.keys(value);
+
+  for (let i = 0; i < (array ? value.length : keys.length); i++) {
+    const key = array ? i : keys[i];
     bytes += array ? 8 : 24 + 2 * key.length;
-    if (retainedReadValue(value[key])) pending.push(value[key]);
+
+    if (bytes > remaining) break;
+    // Charge scalar strings at their owning edge; only containers need
+    // a deferred visit for alias tracking and child traversal.
+    const item = value[key];
+
+    if (isString(item)) bytes += 2 * item.length;
+    else if (isObject(item) || Array.isArray(item)) pending.push(item);
   }
+
   return bytes;
 }
 
@@ -49,22 +63,28 @@ function containerBytes(value, pending, seen) {
 export function readValueBytes(value, limit = Infinity, seen = new WeakSet()) {
   const pending = [value];
   let bytes = 0;
+
   while (pending.length) {
     const item = pending.pop();
+
     if (isString(item)) bytes += 2*item.length;
-    else if (isObject(item) || Array.isArray(item)) bytes += containerBytes(item,pending,seen);
+    else if (isObject(item) || Array.isArray(item)) bytes += containerBytes(item,pending,seen,limit-bytes);
     else bytes += 8;
+
     if (bytes > limit) throw new Error("read value exceeds " + limit + " bytes of remaining storage budget; select fewer fields or smaller slices");
   }
+
   return bytes;
 }
 
 export function readResult(value, details = {}, preview = isString(value) ? value : "", bytes = readValueBytes(value), render) {
   let content;
+
   // Native consumers retain their text-content API. The bridge/trace use the
   // typed value/preview, so ordinary RPCs never serialize this second copy.
   return {get content() {
     const text = () => render ? render() : isString(value) && !details.json ? value : JSON.stringify(value);
+
     return content ??= [{type:"text",text:text()}];
   }, details, [READ_VALUE]:value, [READ_BYTES]:bytes, [READ_PREVIEW]:preview};
 }
@@ -73,5 +93,6 @@ export function asReadResult(raw) {
   if (Object.hasOwn(raw, READ_VALUE)) return raw;
   const image = raw.content?.find(part => part.type === "image");
   const value = image ?? raw.content?.filter(part => part.type === "text").map(part => part.text).join("\n") ?? "";
+
   return { ...raw, [READ_VALUE]: value, [READ_BYTES]: readValueBytes(value) };
 }

package/src/shared/syntax-context.js

@@ -16,13 +16,19 @@ export function sourceContext(source, line, column, lineBreaks = JS_LINES) {
   if (text === undefined) return "";
   const located = Number.isInteger(column) && column >= 0;
   const position = located ? Math.min(column, text.length) : 0;
+  const {shown,caret} = renderSourceWindow(text, position, located);
+
+  return "\n  " + shown + (caret ? "\n  " + caret : "");
+}
+
+function renderSourceWindow(text, position, located) {
   const start = Math.max(0, Math.min(position - 80, text.length - 160));
   const end = Math.min(text.length, start + 160);
   const prefix = start > 0 ? "…" : "";
   const shown = prefix + displaySource(text.slice(start, end)) + (end < text.length ? "…" : "");
   const caret = located ? " ".repeat(stringWidth(prefix + displaySource(text.slice(start, position)))) + "^" : "";
 
-  return "\n  " + shown + (caret ? "\n  " + caret : "");
+  return {shown,caret};
 }
 
 /** acorn-style error that carries a loc, when it has one. */