pi-supernova 0.8.1 → 0.8.2

package/README.md

@@ -12,7 +12,35 @@ Ordinary JavaScript control flow remains available; the guest command bindings
 are only `read`, `edit`, `write`, and `bash`. Supernova supplies retrieval,
 transactional file operations, batching, bounded results and the grouped nova UI.
 
-## What is new in 0.8.0
+## What is new in 0.8.2
+
+This patch release fixes shell failure handling, cancellation and parallel-batch
+limits, and makes one-call batching guidance explicit.
+
+- **Shell quoting stays intact:** quoted executable paths are no longer unwrapped.
+  Shell syntax errors suggest literal `bash({command,args})` with `data` for
+  embedded scripts, or a quoted heredoc. Commands are not rewritten or retried.
+- **Validation before commit:** invalid timeouts and null-byte
+  arguments are rejected before the shell boundary flushes staged files.
+- **Useful failure output:** long command labels are bounded so the original
+  stderr is not crowded out by a repeated script.
+- **Timeouts retain diagnostics:** the outer program deadline stops the worker
+  and gives pending host calls a bounded drain to retain shell output. Explicit
+  cancellation is reported separately from timeout. The outer `timeoutMs` covers
+  every wait and command, including `sleep`.
+- **Parallel budgets fail honestly:** exceeding the shared output, log or image
+  allowance marks the batch failed and stops queued entries. Already-running
+  entries settle; their results and completed commits remain. Aggregate logs stay
+  capped rather than multiplying the allowance per guest.
+- **Batch known work in one call:** combine independent reads/checks with
+  `Promise.all`, then sequence edits and verification in the same program. Use
+  another invocation when returned evidence is needed for the next decision.
+
+Verified on **macOS / Node 26.7**: 267 package tests (384 repository tests),
+2,328 stress invocations, actual Pi/OMP host checks, lint and both token-budget
+checks. This is not a claim of exhaustive platform or formal mutation testing.
+
+## 0.8.0 features and measurements
 
 - **Shared program source:** top-level `code` or `file` supplies a batch default;
   entries may override it. A shared program is sent once instead of in every entry,
@@ -81,14 +109,12 @@ Local checkout installs are for development, not distribution:
 pi install /path/to/pi-stack/packages/pi-supernova
 ```
 
-Git pushes do not update npm installations. Publish the new npm version first;
-then reinstall it in the host. Reinstall explicitly when an existing version
-range excludes the new minor version (`^0.6.0` excludes `0.7.0`). After 0.7.0 is
-published, pin that release with:
+Git pushes do not update npm installations. Publish the new npm version first,
+then reinstall it in your host. To pin **0.8.2** once it is published:
 
 ```bash
-pi install npm:pi-supernova@0.7.0
-omp install npm:pi-supernova@0.7.0
+pi install npm:pi-supernova@0.8.2
+omp install npm:pi-supernova@0.8.2
 ```
 
 In Pi, `pi list` shows the configured package sources. A local path uses that
@@ -135,6 +161,21 @@ payloads are not repeated in owned direct-execution errors;
 stdout/stderr, exit status and source context remain. Session environment variables are taken
 from the current execution context, not inherited from a different parent session.
 
+Shell strings are executed unchanged, including quoted executable paths. For inline
+Python/Node scripts, prefer literal argv with `data` instead of nested shell quotes:
+
+```json
+{
+  "code": "return await bash({command:\"python3\",args:[\"-c\",data.script]});",
+  "data": {"script": "q = {'name': 'example'}\nprint(f\"{q['name']}\")\n"}
+}
+```
+
+Shell syntax errors keep the original diagnostic and suggest argv or a quoted
+heredoc; commands are never automatically rewritten or retried. Invalid timeouts
+and null-byte arguments fail before flushing staged changes. Failure labels are
+bounded so a large script cannot crowd out its stderr.
+
 Source questions locate a declaration in one command. An exact
 declaration match uses one bounded direct ripgrep search, without a prerequisite
 file listing, persistent index, embeddings or summarization. A transient filename
@@ -349,6 +390,9 @@ Set `parallel: true` with `programs` to run independent entries concurrently
 in submission order. A failed entry does not stop siblings. Two entries writing
 the same file race: the losing commit reports a conflict. Sequential remains the
 default. `parallel` and `mergeData` are invalid on a lone `code` or `file` call.
+Budget overflow marks the batch failed and stops queued entries; already-running
+entries settle and their completed commits remain. Parallel execution does not
+multiply the aggregate output, log, or image allowance.
 
 The outer deadline, host-call budget, log allowance, text budget and image limits
 are shared across the batch. Individual read budgets are not reduced. Every
@@ -380,10 +424,13 @@ For long archive scans, use resumable chunks or a host background-job tool and w
 progress records under `.work`. Shell commands inherit the current program
 `timeoutMs` unless they specify their own; increasing the outer deadline no longer
 leaves a hidden 60-second shell cap. Set the inner `bash` timeout shorter than the
-outer program timeout (for example 10 seconds inside a 20-second program) to retain
-bounded shell diagnostics. A hard guest deadline cannot guarantee pending shell
-output delivery; progress files survive shell execution but staged VFS writes may
-roll back.
+outer program timeout (for example 10 seconds inside a 20-second program). The outer
+deadline covers **all** waits and commands, including `sleep`; a shell's own `timeout`
+command does not extend it. On a deadline or cancellation, the worker stops and
+pending host calls get a bounded 250ms drain to retain owned-shell diagnostics and
+finalize process termination. Non-cooperating host executors may still outlive that
+drain. Cancellation is reported separately from timeout; neither triggers a retry.
+Progress files survive shell execution but staged VFS writes may roll back.
 
 Large returned objects are bounded previews, not retained artifacts. Select fields
 and array windows before returning, rather than parsing a truncated preview.
@@ -432,6 +479,12 @@ continuation handles.
 
 ## Execution and automatic batching
 
+Put already-known independent reads and checks in **one** Supernova program using
+`Promise.all` (or `Promise.allSettled` when failures should remain independent).
+Sequence edits and their known verification in that same program. Start another
+invocation only when the returned evidence is needed to decide what to do next;
+use focused read windows to keep the combined result within its output budget.
+
 Compatible independently started reads coalesce at the worker/host boundary.
 No additional batching command is required. Individual promises preserve their
 values, errors and per-read budgets. File reads have bounded parallelism; writes,

package/docs/CHANGELOG.md

@@ -2,6 +2,31 @@
 
 ## Unreleased
 
+## [0.8.2] - 2026-09-19
+
+### Fixed
+
+- Shell commands preserve quoted executable paths. Parser failures suggest
+  literal argv for embedded scripts or a quoted heredoc, without rewriting or
+  automatically retrying commands.
+- Invalid timeouts and null-byte arguments fail before flushing staged files.
+  Bounded command labels keep long scripts from crowding out diagnostics.
+- Program deadlines retain pending shell output during bounded termination;
+  explicit cancellation is no longer misreported as a timeout.
+- Parallel batches enforce shared output, log and image budgets instead of
+  reporting success after overflow. Queued entries stop, in-flight results and
+  completed commits remain, and aggregate logs stay capped.
+
+### Changed
+
+- Guidance explicitly batches known reads/checks and edits/verification in one
+  invocation, and states that the outer deadline includes all waits and commands.
+
+### Internals
+
+- 267 package tests (384 repository tests), 2,328 stress invocations, actual
+  Pi + OMP host checks, lint and both frozen token gates passed on macOS/Node 26.7.
+
 ## [0.8.1] - 2026-09-19
 
 ### Fixed

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "pi-supernova",
-  "version": "0.8.1",
+  "version": "0.8.2",
   "description": "CodeMode for Pi and OMP: read, edit, write and bash, with transactional files, source views and shared-input program batches.",
   "type": "module",
   "author": "AdityaVG13",

package/src/adapters/bash.js

@@ -1,6 +1,6 @@
 import * as fs from "node:fs/promises";
 import { isString } from "../shared/decode.js";
-import { unwrapIfFullyQuoted } from "../fs/text-ops.js";
+import { normalizeBash } from "../contract/bash.js";
 import { sourceForReferences } from "../fs/source-window.js";
 import { resolveWorkspacePath, runCommand, clearPathCache } from "../fs/workspace.js";
 
@@ -17,7 +17,7 @@ export function createBash(ctx) {
   function bashCommand(params, literal) {
     if (params?.command !== undefined && !isString(params.command)) throw new Error("bash command must be a string");
     if (literal && (!isString(params.command) || params.args.some(arg => !isString(arg)))) throw new Error("bash argv requires a command string and an array of string args");
-    const command = literal ? String(params.command) : unwrapIfFullyQuoted(String(params?.command ?? "").trim());
+    const command = String(params?.command ?? "");
 
     if (!command.trim()) throw new Error("bash requires command");
 
@@ -32,6 +32,7 @@ export function createBash(ctx) {
   }
 
   async function bash(params, signal) {
+      params = normalizeBash(params);
       const cwd = getCwd();
       const { literal, command, argv } = parseBash(params);
       const targetCwd = params?.cwd ? await resolveWorkspacePath(cwd, params.cwd, "bash cwd", true) : cwd;
@@ -49,7 +50,7 @@ export function createBash(ctx) {
         res = await runCommand(argv, {
           cwd: targetCwd,
           env: hooks.commandEnv(),
-          commandLabel: literal ? command : undefined,
+          commandLabel: command,
           timeoutMs: params?.timeoutMs === undefined ? config.timeoutMs : params.timeoutMs,
           signal,
           maxOutputChars: config.maxCallResultChars,
@@ -67,7 +68,12 @@ export function createBash(ctx) {
       const { stdout, stderr } = res;
       let text = combineBashText(stdout, stderr);
 
-      if (res.exitCode !== 0) text += await sourceForReferences(cwd, targetCwd, text, signal, ledger);
+      if (res.exitCode !== 0) {
+        if (!literal && /\bbash: (?:-c: )?line \d+: (?:syntax error|unexpected EOF)/.test(stderr)) {
+          text += '\nhint: Bash could not parse the command. For embedded scripts use literal argv, e.g. bash({command:"python3",args:["-c",data.script]}), or a quoted heredoc for shell pipelines. Do not blindly retry: earlier commands may have run.';
+        }
+        text += await sourceForReferences(cwd, targetCwd, text, signal, ledger);
+      }
 
       return {
         content: [{ type: "text", text }],

package/src/contract/bash.js

@@ -17,7 +17,10 @@ function normalizeArgv(args) {
       throw new Error(`${ARGV_ERROR}; args[${i}] is ${type}; check the supplied data fields and pass each argument as a string`);
     }
   }
-  args.args = args.args.map(String);
+  args.args = args.args.map((arg, i) => {
+    if (arg.includes("\0")) throw new Error(`bash args[${i}] must not contain null bytes`);
+    return String(arg);
+  });
 
   if (process.platform === "win32") {
     delete args._directArgv;
@@ -37,9 +40,17 @@ function assertBashOptions(args) {
 export function normalizeBash(command, opts) {
   const args = isObject(command) ? { ...opts, ...command } : { command, ...opts };
   assertBashOptions(args);
+  if (!isString(args.command) || !args.command.trim()) throw new Error("bash requires a non-empty command string");
+  if (args.command.includes("\0")) throw new Error("bash command must not contain null bytes");
   normalizeArgv(args);
 
   if (args.timeout !== undefined && args.timeoutMs === undefined) args.timeoutMs = args.timeout * 1000;
+  // Reject before the host's external-mutation barrier can flush staged files.
+  if (args.timeoutMs !== undefined) {
+    const timeout = Number(args.timeoutMs);
+    if (!Number.isFinite(timeout) || timeout <= 0) throw new Error("command timeoutMs must be a positive finite number");
+    args.timeoutMs = Math.max(1, Math.min(2_147_483_647, Math.floor(timeout)));
+  }
 
   return args;
 }

package/src/fs/text-ops.js

@@ -81,21 +81,6 @@ export function resultDiff(response) {
   return isObject(details) ? details.diff : undefined;
 }
 
-/** Unwrap a single matching quote pair around the whole string (`'git status'`). */
-export function unwrapIfFullyQuoted(s) {
-  if (s.length < 2) return s;
-  const q = s[0];
-
-  if (q !== "'" && q !== '"') return s;
-
-  if (s[s.length - 1] !== q) return s;
-  const inner = s.slice(1, -1);
-
-  if (inner.includes(q)) return s;
-
-  return inner;
-}
-
 function totalContentLines(text) {
   if (text === "") return 1;
 

package/src/fs/workspace.js

@@ -3,6 +3,7 @@ import * as path from "node:path";
 import { spawn } from "node:child_process";
 import { constants } from "node:os";
 import { isString } from "../shared/decode.js";
+import { truncateChars } from "../output/format.js";
 
 let cachedCwd = null;
 
@@ -211,7 +212,10 @@ function attachCommandIO(state, options, argv, timeoutMs) {
     clearTimeout(state.escalation);
     options.signal?.removeEventListener("abort", onAbort);
   };
-  state.timer = setTimeout(() => terminateCommand(state, new Error("command timed out after " + timeoutMs + "ms: " + (options.commandLabel ?? argv.join(" ")))), timeoutMs);
+  state.timer = setTimeout(() => terminateCommand(state, new Error(
+    "command timed out after " + timeoutMs + "ms: " + truncateChars(options.commandLabel ?? argv.join(" "), 240, "command").text
+    + "\nhint: Increase this bash timeoutMs and the outer supernova timeoutMs, or split the work. Sleeps and every command in a shell chain share the same limit."
+  )), timeoutMs);
   child.stdout.setEncoding("utf8");
   child.stderr.setEncoding("utf8");
   child.stdout.on("data", chunk => { state.stdout = appendCommandOutput(state, state.stdout, chunk); });

package/src/runtime/guest-worker.js

@@ -256,7 +256,7 @@ function formatBashFailure(command, res) {
   const output = String(res.value).trimEnd();
   const suffix = Number.isInteger(exitCode) ? " (exit " + exitCode + ")" : "";
 
-  return "command failed" + suffix + ": " + command + (output ? "\n" + output : "");
+  return "command failed" + suffix + ": " + truncateChars(command, 240, "command").text + (output ? "\n" + output : "");
 }
 
 function markTruncatedOutput(res, text) {

package/src/runtime/program-batch.js

@@ -156,16 +156,35 @@ class ProgramBatch {
     this.collectImages(result, i);
   }
 
+  parallelBudgetStop(settled) {
+    const results = settled.filter(Boolean);
+    let images = 0, bytes = 0, labelChars = 0;
+    for (const [i, result] of settled.entries()) {
+      let imageSeq = 0;
+      for (const block of result?.content ?? []) if (block.type === "image" && isString(block.data)) {
+        images++;
+        bytes += Buffer.byteLength(block.data, "base64");
+        labelChars += ("program " + (i + 1) + " image " + (++imageSeq)).length + 1;
+      }
+    }
+    let kind;
+    if (images > 16 || bytes > 20 * 1024 * 1024) kind = "image";
+    else if (results.some(result => result.details?.returnTruncated) || programBatchText(results, this.programs.length).length + labelChars > this.config.maxReturnChars) kind = "output";
+    else if (results.some(result => result.details?.logTruncated) || results.reduce((n, result) => n + (result.details?.logs?.length ?? 0), 0) > (this.config.maxLogLines ?? 100)) kind = "log";
+    return kind ? "batch " + kind + " budget exceeded; completed commits remain" : "";
+  }
+
   async runParallel() {
     const limit = Math.min(this.programs.length, MAX_PARALLEL_PROGRAMS);
     const settled = Array.from({ length: this.programs.length });
     let next = 0;
 
     await Promise.all(Array.from({length: limit}, async () => {
-      while (next < this.programs.length && !this.combined.aborted && performance.now() < this.deadline) {
+      while (next < this.programs.length && !this.stopped && !this.combined.aborted && performance.now() < this.deadline) {
         const i = next++;
         settled[i] = await this.runOne(this.programs[i], i);
         this.live[i] = [];
+        this.stopped ||= this.parallelBudgetStop(settled);
       }
     }));
 
@@ -174,7 +193,7 @@ class ProgramBatch {
       this.takeSettled(settled[i], i);
     }
 
-    if (settled.includes(undefined) || this.combined.aborted || performance.now() >= this.deadline) this.stopped = "batch deadline or cancellation; earlier commits remain" + this.deadlineNote();
+    if ((!this.stopped && settled.includes(undefined)) || this.combined.aborted || performance.now() >= this.deadline) this.stopped = "batch deadline or cancellation; earlier commits remain" + this.deadlineNote();
   }
 
   sequentialStop(result, i) {
@@ -222,6 +241,8 @@ class ProgramBatch {
     const failed = this.results.filter(result => result.details?.ok === false).length;
     const bounded = this.boundedText(failed);
     const content = [{type:"text",text:bounded.text}];
+    const logs = this.results.flatMap(result => result.details?.logs ?? []);
+    const logLimit = this.config.maxLogLines ?? 100;
     this.images.forEach((image,i) => content.push({type:"text",text:this.imageLabels[i]},image));
 
     // Return a typed stop report instead of throwing away earlier results/images.
@@ -230,7 +251,7 @@ class ProgramBatch {
       programs:this.results,attempted:this.results.length,total:this.programs.length,stopped:this.stopped,parallel:this.parallel,
       result:bounded.truncated ? bounded.text : this.results.map(result=>result.details?.result),
       returnTruncated:bounded.truncated || this.results.some(result=>result.details?.returnTruncated),
-      logTruncated:this.results.some(result=>result.details?.logTruncated),logs:this.results.flatMap(result=>result.details?.logs ?? []),trace:this.trace,mutations:mutationTotals(this.results)}};
+      logTruncated:logs.length > logLimit || this.results.some(result=>result.details?.logTruncated),logs:logs.slice(0,logLimit),trace:this.trace,mutations:mutationTotals(this.results)}};
   }
 
   async run() {

package/src/runtime/reference.js

@@ -1,15 +1,15 @@
 // Standing tool description: sent on every request. No result or history compression.
-export const REFERENCE = `JS body/async arrow with read/write/edit/bash; no fs/import/require. file runs workspace scripts. data holds literal text/scripts/argv (≤48000 serialized JSON chars).
-read(path|paths,offset=1,limit?) → raw text/text[]; directories → entries; images: PNG/JPEG/GIF/WebP (≤16 attachments/20 MiB total).
-Path-only: ≤160 lines AND 8192 characters (UTF-16). Use read(path,{offset:1,limit:80}), about, or complete:true (whole file ≤31744 chars). Large JSONL: bounded parser via bash.
-read({path,json:selector}) → parsed JSON; selectors ".field", ".a[0:3]", ".a.length", quoted keys, true; 16 MiB input, no jq. Oversized → {status:"too_large",keys} (arrays: length); narrow selectors.
+export const REFERENCE = `JS body/async arrow: read/write/edit/bash; no fs/import/require. file: workspace scripts; data: literals (≤48000 JSON chars).
+read(path|paths,offset=1,limit?) → raw text/text[]; directories → entries; images: PNG/JPEG/GIF/WebP (≤16 images/20 MiB).
+Path-only ≤160 lines AND 8192 characters (UTF-16); larger: read(path,{offset:1,limit:80}), about, or complete:true (whole file ≤31744 chars). Large JSONL: bounded bash parser.
+read({path,json:selector}) → parsed JSON: ".field", ".a[0:3]", ".a.length", quoted keys, true; ≤16 MiB, no jq. {status:"too_large",keys|length} → narrow selector.
 read("symbol or question") = read({query,resolve:true}) → view; check status; view.text is a span, not the file.
 read(path,{about}) → windows; read({query,evidence:true}) → ranked evidence; read({path,outline:true}) → declarations.
 write(path,text) replaces unread workspace files; write({path,content,append:true}) appends without reading. After read: edit or replace:true.
-edit(path,oldText,newText) | edit({path,edits:[{oldText,newText}]}) exact unique read text; numbered windows (including misses), checks/references.
-edit(view,text) replaces the span; edit(view,old,new) matches uniquely within it. edit(async()=>{...}) checkpoint merges on success, rolls back/rethrows on failure; catch to recover.
-bash(command,{cwd?,timeoutMs?}) | bash({command,args}) literal argv; bounded output, nonzero throws; inherits program timeout unless overridden.
+edit(path,oldText,newText) | edit({path,edits:[{oldText,newText}]}) unique exact read text; returns numbered windows/checks/references.
+edit(view,text) replaces span; edit(view,old,new) uniquely matches within it. edit(async()=>{...}) checkpoint: merge on success, rollback/rethrow on failure.
+bash(command,{cwd?,timeoutMs?}) | bash({command,args}) literal argv for scripts; bounded output, nonzero throws. Outer timeoutMs caps ALL waits/commands; bash inherits unless overridden.
 Edits stage until success; bash commits first. Array errors abort; Promise.allSettled for optional reads.
-programs:[{code?,file?,data?}] inherits top-level code OR file and data. Entry source overrides; data replaces unless mergeData:true (shallow objects, entry keys win).
-Fresh guests/separate commits; sequential failure stops, prior commits stay. parallel:true for disjoint entries. Batch known work; separate calls only for new decisions.
+programs:[{code?,file?,data?}] inherits code OR file and data. Entries override source/data; mergeData:true shallow-merges objects (entry keys win).
+Fresh guests/separate commits; sequential failure stops, prior commits stay. parallel:true for disjoint entries. Batch known reads/checks (Promise.all) + edits/verification in ONE call; split for new decisions.
 `;

package/src/runtime/runtime.js

@@ -10,7 +10,8 @@ import { errorContext } from "../shared/syntax-context.js";
 
 const WORKER_URL = new URL("./guest-worker.js", import.meta.url);
 
-const ABORT_MESSAGE = "supernova timed out or aborted: pass timeoutMs to allow longer runs, or split the program";
+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_POLL_MS = 50;
 
@@ -281,6 +282,7 @@ class GuestRun {
     this.hostError = undefined;
     this.notifyingHost = false;
     this.aborting = false;
+    this.abortOutcome = undefined;
     this.pending = new Set();
     this.inputController = new AbortController();
     this.rpcCount = 0;
@@ -320,15 +322,18 @@ class GuestRun {
     try { this.nova.cancel?.(); } catch {} finally { this.notifyingHost = false; }
   }
 
-  abort() {
+  abort(timedOut = false) {
     if (this.finished || this.aborting) return;
     this.aborting = true;
+    this.accepting = false;
+    this.abortOutcome = this.fail((timedOut ? TIMEOUT_MESSAGE : ABORT_MESSAGE) + " (ran " + this.wall() + "ms of " + this.timeoutMs + "ms)");
     this.cancelHost();
 
-    try { this.onTimeout?.(); } catch {}
+    if (timedOut) { try { this.onTimeout?.(); } catch {} }
 
-    this.aborting = false;
-    this.finish(this.fail(ABORT_MESSAGE + " (ran " + Math.round(this.wall()) + "ms of " + this.timeoutMs + "ms)"));
+    // Stop the guest immediately, then use the bounded host drain to retain
+    // shell diagnostics and wait for process-tree termination before returning.
+    void this.complete(this.abortOutcome);
   }
 
   postResult(message) {
@@ -365,6 +370,10 @@ class GuestRun {
     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);
   }
 
@@ -448,7 +457,7 @@ class GuestRun {
   }
 
   async attachWorker() {
-    if (this.wall() >= this.timeoutMs) { this.abort(); 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; }
@@ -459,7 +468,7 @@ class GuestRun {
     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(); return false; }
+    if (this.wall() >= this.timeoutMs) { this.abort(true); return false; }
     this.available = available;
 
     return true;
@@ -488,7 +497,7 @@ class GuestRun {
   start() {
     return new Promise((resolve) => {
       this.resolve = resolve;
-      this.timer = setTimeout(() => this.abort(), Math.min(this.timeoutMs, 2147483647));
+      this.timer = setTimeout(() => this.abort(true), Math.min(this.timeoutMs, 2147483647));
       this.memTimer = setInterval(() => {
         const now = rssBytes();