humanish 0.133.0 → 0.133.1

package/CHANGELOG.md

@@ -8,6 +8,17 @@ The Unreleased section holds the full notes for the next version until it is tag
 
 ## Unreleased
 
+## 0.133.1: Hosted runs keep writing run.json past 512 MiB of traces (2026-10-14)
+
+humanish 0.133.1 keeps a hosted run writing run.json once its finished participants' traces
+together pass V8's longest string, 536,870,888 characters. The sandbox id scrub serialized the whole
+bundle into one string on every write, so past that size every write threw and run.json, the trace
+files, review.json and events.ndjson stopped updating. It now scrubs the bundle and each participant
+apart and writes the same bytes. On synthetic runs at a recorded hosted run's density, a snapshot
+write of 10 participants of 10 MiB took 3.8 seconds where it took 4.7, at half the peak memory.
+
+[Release notes](https://github.com/danielgwilson/humanish/releases/tag/v0.133.1)
+
 ## 0.133.0: An OpenAI participant names how long it waits (2026-10-14)
 
 humanish 0.133.0 lets an OpenAI computer-use participant name how long it waits, with a

package/dist/evidence/json-split.d.ts

@@ -0,0 +1,21 @@
+/** The JSON text of a value cut around the elements of one of its arrays. */
+export interface ArraySplit {
+    /** The array's elements, read as JSON.stringify reads them. */
+    readonly elements: readonly Record<string, unknown>[];
+    /** The value's JSON text up to and including the array's `[`. */
+    before(): string;
+    /** The value's JSON text from the array's `]` on. */
+    after(): string;
+}
+/**
+ * The cut of JSON.stringify(value) around the elements of its array `value[key]`, when that text
+ * holds each element's text as JSON.stringify(element) writes it: `value` is a plain object that
+ * has `key` among its own enumerable keys, `value[key]` is a plain array with no holes, and each
+ * element is a plain object. A plain object has Object.prototype or null as its prototype, a plain
+ * array Array.prototype, and neither has a toJSON. Otherwise undefined: the caller needs the whole
+ * text. Getters, proxies and a toJSON that changes `value` while it is serialized are not detected:
+ * the elements are read before anything is serialized. before() and after() serialize the members
+ * on their side of the array when called, so a caller that calls before(), serializes each element
+ * and then calls after() runs every toJSON in the order JSON.stringify(value) runs them.
+ */
+export declare function splitAtArray(value: unknown, key: string): ArraySplit | undefined;

package/dist/evidence/json-split.js

@@ -0,0 +1,57 @@
+// When the JSON text of a value can be worked on one element of an array at a time. A run bundle
+// holds every participant's trace in its `streams` array, and the bundle's whole text can pass
+// V8's longest string, 536,870,888 characters on Node 24.
+//
+// JSON.stringify calls a toJSON with the value's key in its parent, and an element serialized
+// alone gets "" in place of its index. It writes a boxed primitive as the primitive. A plain object
+// or array with no toJSON is written as its own keys or items wherever it sits, and every value
+// inside an element gets the same key alone as inside the whole value.
+import { isRecord } from "../run/type-guards.js";
+/**
+ * The cut of JSON.stringify(value) around the elements of its array `value[key]`, when that text
+ * holds each element's text as JSON.stringify(element) writes it: `value` is a plain object that
+ * has `key` among its own enumerable keys, `value[key]` is a plain array with no holes, and each
+ * element is a plain object. A plain object has Object.prototype or null as its prototype, a plain
+ * array Array.prototype, and neither has a toJSON. Otherwise undefined: the caller needs the whole
+ * text. Getters, proxies and a toJSON that changes `value` while it is serialized are not detected:
+ * the elements are read before anything is serialized. before() and after() serialize the members
+ * on their side of the array when called, so a caller that calls before(), serializes each element
+ * and then calls after() runs every toJSON in the order JSON.stringify(value) runs them.
+ */
+export function splitAtArray(value, key) {
+    // JSON.stringify writes only own enumerable keys.
+    if (!isPlainRecord(value))
+        return undefined;
+    const keys = Object.keys(value);
+    const at = keys.indexOf(key);
+    if (at === -1)
+        return undefined;
+    const array = value[key];
+    if (!isPlainArray(array))
+        return undefined;
+    // JSON.stringify reads the length once and then each index, so a hole reads as undefined and an
+    // own iterator is never called. Array.from would call that iterator, and every skips holes.
+    const elements = [];
+    for (let index = 0, length = array.length; index < length; index += 1)
+        elements.push(array[index]);
+    if (!elements.every(isPlainRecord))
+        return undefined;
+    // fromEntries keeps a key such as __proto__ an own property.
+    const members = (from, to) => Object.fromEntries(keys.slice(from, to).map((name) => [name, value[name]]));
+    return {
+        elements,
+        before: () => JSON.stringify({ ...members(0, at), [key]: [] }).slice(0, -"]}".length),
+        after: () => {
+            const text = JSON.stringify(members(at + 1));
+            return text === "{}" ? "]}" : `],${text.slice(1)}`;
+        },
+    };
+}
+const hasToJson = (value) => typeof value.toJSON === "function";
+function isPlainRecord(value) {
+    if (!isRecord(value) || hasToJson(value))
+        return false;
+    const prototype = Object.getPrototypeOf(value);
+    return prototype === Object.prototype || prototype === null;
+}
+const isPlainArray = (value) => Array.isArray(value) && Object.getPrototypeOf(value) === Array.prototype && !hasToJson(value);

package/dist/evidence/sensitive-json.js

@@ -21,7 +21,7 @@
 // piece up to its first slash or whitespace. A public E2B page after the scheme would need a space
 // or the text's end before the cut, so neither text exempts the URL. The scan holds one piece at a
 // time.
-import { isRecord } from "../run/type-guards.js";
+import { splitAtArray } from "./json-split.js";
 import { containsSandboxUrl, containsSensitive } from "./redaction.js";
 // The sandbox URL's scheme, `https://` or `https:\/\/` as JSON may escape it, at a text's end.
 const SCHEME_AT_END = /https?:\\?\/\\?\/$/i;
@@ -35,14 +35,11 @@ const SLASH_OR_SPACE = /[/\s]/;
  * them.
  */
 export function containsSensitiveJson(value, key) {
-    // JSON.stringify writes only own enumerable keys, and `around` cuts the text at this one.
-    const elements = isPlainRecord(value) && Object.keys(value).includes(key) ? value[key] : undefined;
-    // Array.from reads a hole as undefined, where every would skip it.
-    if (!isPlainRecord(value) ||
-        !isPlainArray(elements) ||
-        !Array.from(elements).every(isPlainRecord))
+    const split = splitAtArray(value, key);
+    if (split === undefined)
         return wholeTextSensitive(value);
-    const [prefix, suffix] = around(value, key);
+    const { elements } = split;
+    const [prefix, suffix] = [split.before(), split.after()];
     if (elements.length === 0)
         return containsSensitive(prefix + suffix);
     // The scheme of a URL no slash or whitespace has followed, from an earlier piece.
@@ -59,26 +56,6 @@ export function containsSensitiveJson(value, key) {
     return false;
 }
 const wholeTextSensitive = (value) => containsSensitive(JSON.stringify(value) ?? "");
-// JSON.stringify calls a toJSON with the value's key in its parent, and an element serialized
-// alone gets "" in place of its index. It writes a boxed primitive as the primitive. A plain object
-// or array with no toJSON is written as its own keys or items wherever it sits.
-const hasToJson = (value) => typeof value.toJSON === "function";
-function isPlainRecord(value) {
-    if (!isRecord(value) || hasToJson(value))
-        return false;
-    const prototype = Object.getPrototypeOf(value);
-    return prototype === Object.prototype || prototype === null;
-}
-const isPlainArray = (value) => Array.isArray(value) && Object.getPrototypeOf(value) === Array.prototype && !hasToJson(value);
-/** The document's text before the first element of `value[key]` and after its last. */
-function around(value, key) {
-    const keys = Object.keys(value);
-    const at = keys.indexOf(key);
-    const entries = (from, to) => Object.fromEntries(keys.slice(from, to).map((name) => [name, value[name]]));
-    const before = JSON.stringify({ ...entries(0, at), [key]: [] });
-    const after = JSON.stringify(entries(at + 1));
-    return [before.slice(0, -"]}".length), after === "{}" ? "]}" : `],${after.slice(1)}`];
-}
 /** `piece` up to and including its first slash or whitespace, or all of it when it has none. */
 function head(piece) {
     const at = piece.search(SLASH_OR_SPACE);

package/dist/run/sandbox-ids.d.ts

@@ -4,7 +4,12 @@ import { type PreparedRunArtifactPaths } from "./paths.js";
 export declare function scrubSandboxIds(text: string, ids: Iterable<string>, label?: (id: string) => string): string;
 /**
  * `value` as it may be written or returned: ids at the sandbox-id keys become the marker and a
- * digest, and any raw id left in free text or a URL becomes its label.
+ * digest, and any raw id left in free text, a key or a URL becomes its label. When no label goes
+ * in, the result is the key-redacted value. Otherwise it is what JSON.parse returns for the
+ * scrubbed JSON text of that value. A run bundle is scrubbed one stream at a time, so no string
+ * holds two streams unless a member outside `streams` holds them too. An id that holds one of
+ * {}[],:"\ makes the scrub work on the whole text, which throws RangeError for a bundle past V8's
+ * longest string. No E2B id holds one.
  */
 export declare function publicSandboxView<T>(value: T, ids: Iterable<string>): T;
 /**

package/dist/run/sandbox-ids.js

@@ -4,6 +4,7 @@
 // so output an agent pastes into an issue never carries an id.
 import { opendir, realpath } from "node:fs/promises";
 import path from "node:path";
+import { splitAtArray } from "../evidence/json-split.js";
 import { readPlainText } from "../evidence/plain-text.js";
 import { collectSandboxIds, redactSandboxIds, sandboxIdDigest, REDACTED_SANDBOX_ID, } from "../evidence/redaction.js";
 import { ContainedReadRefusedError, readContainedRegularFile, refusalText, RUN_ARTIFACT_MAX_BYTES, writeContainedOutputFile, } from "./contained-output.js";
@@ -26,20 +27,79 @@ export function scrubSandboxIds(text, ids, label = sandboxIdLabel) {
     unique.sort((left, right) => right.length - left.length);
     return unique.reduce((current, id) => current.split(id).join(label(id)), text);
 }
+// A run bundle holds every finished participant's trace, and its whole JSON text can pass V8's
+// longest string, 536,870,888 characters on Node 24. publicSandboxView scrubs such a bundle in
+// pieces: the shell, which is the bundle's JSON text with `streams` written as `[]`, and the JSON
+// text of each stream on its own. The pieces give what the whole text gives:
+// - An id that holds none of {}[],:"\ lies inside one token of the whole text. Each cut between
+//   pieces falls between two of the characters {}[], and the placeholder adds only [ and ], so no
+//   occurrence crosses a cut. A replacement leaves those characters in place, so the next id's
+//   occurrences cannot cross one either.
+// - A label holds no quote or backslash, so it never moves the end of a string. A label inside an
+//   escape, a number, true, false or null makes its piece fail to parse, and the whole text fails
+//   the same way.
+// - JSON.stringify writes a stream's members alone as it writes them inside the bundle, since each
+//   gets the same key for its toJSON. Only the stream itself would get "" in place of its index,
+//   and splitAtArray takes no stream with a toJSON. The members before `streams`, each stream and
+//   the members after are serialized in that order, which is the order the whole text runs each
+//   toJSON in.
+// - The parsed shell keeps its keys in the order JSON.parse gives for the whole text, and the
+//   streams go in at the place of `streams`. A key a label went into holds the label's `[`, so no
+//   other key becomes `streams`. An id inside the key `streams` itself takes the whole text.
+// - Once a label goes in, the view is parsed from the scrubbed pieces, as it was from the whole
+//   text. A piece kept as given could run a toJSON or getter again when the view is written.
+// - All of this holds for a bundle that serializing leaves unchanged, as every bundle JSON.parse
+//   returns is. splitAtArray reads the streams before any toJSON runs.
+/** The characters that let an id reach past one token of a JSON text or move where a string ends. */
+const CROSSES_TOKENS = /[{}[\],:"\\]/;
+/** Whether every occurrence of `id` in a bundle's JSON text stays inside one piece. */
+const staysInOnePiece = (id) => id.length === 0 || (!CROSSES_TOKENS.test(id) && !"streams".includes(id));
 /**
  * `value` as it may be written or returned: ids at the sandbox-id keys become the marker and a
- * digest, and any raw id left in free text or a URL becomes its label.
+ * digest, and any raw id left in free text, a key or a URL becomes its label. When no label goes
+ * in, the result is the key-redacted value. Otherwise it is what JSON.parse returns for the
+ * scrubbed JSON text of that value. A run bundle is scrubbed one stream at a time, so no string
+ * holds two streams unless a member outside `streams` holds them too. An id that holds one of
+ * {}[],:"\ makes the scrub work on the whole text, which throws RangeError for a bundle past V8's
+ * longest string. No E2B id holds one.
  */
 export function publicSandboxView(value, ids) {
     const redacted = redactSandboxIds(value);
     const known = [...ids];
     if (known.length === 0)
         return redacted;
-    const text = JSON.stringify(redacted);
+    const split = known.every(staysInOnePiece) ? splitAtArray(redacted, "streams") : undefined;
+    return (split === undefined ? wholeTextView(redacted, known) : streamwiseView(redacted, split, known));
+}
+/** The scrub of `value`'s whole JSON text, parsed back when a label went in. */
+function wholeTextView(value, ids) {
+    const text = JSON.stringify(value);
     if (text === undefined)
-        return redacted;
-    const scrubbed = scrubSandboxIds(text, known);
-    return (scrubbed === text ? redacted : JSON.parse(scrubbed));
+        return value;
+    const scrubbed = scrubSandboxIds(text, ids);
+    return scrubbed === text ? value : JSON.parse(scrubbed);
+}
+/** The bundle's whole-text scrub, built from its shell and each stream scrubbed on its own. */
+function streamwiseView(bundle, split, ids) {
+    const before = split.before();
+    let changed = false;
+    // Each stream is parsed at its turn, even before any label goes in, since a later piece can still
+    // take one and by then the earlier streams' text is gone.
+    const streams = split.elements.map((stream) => {
+        const text = JSON.stringify(stream);
+        const scrubbed = scrubSandboxIds(text, ids);
+        if (scrubbed !== text)
+            changed = true;
+        return JSON.parse(scrubbed);
+    });
+    const shellText = before + split.after();
+    const shell = scrubSandboxIds(shellText, ids);
+    if (!changed && shell === shellText)
+        return bundle;
+    // Assigning to `streams` keeps its place among the keys.
+    const view = JSON.parse(shell);
+    view.streams = streams;
+    return view;
 }
 /** The raw sandbox ids a receipts journal names. */
 function receiptSandboxIds(journal) {

package/dist/study/bundle-estimate.d.ts

@@ -16,10 +16,7 @@ export interface BundleEstimate {
     readonly runFileBytes: number;
     /** The largest participant trace file, which analysis also reads whole. */
     readonly largestTraceBytes: number;
-    /**
-     * Every participant's trace file together, whose items the run writer and the Observer page join
-     * in one string.
-     */
+    /** Every participant's trace file together, whose items the Observer page joins in one string. */
     readonly tracesBytes: number;
     /** observer/index.html, which verify reads whole. */
     readonly observerPageBytes: number;

package/dist/study/bundle-estimate.js

@@ -17,11 +17,11 @@
 // runs measured, so it passes 32 MiB only after run.json passes 16 MiB, and the estimate does not
 // check it.
 // The Observer page and the Observer server join every participant's items in one string before
-// gzip. On a hosted desktop the sandbox id scrub (publicSandboxView) does too, on every write of
-// run.json and on a bundle export of the loaded run, which its 25 MiB default --max-bytes refuses
-// first. V8's longest string is 536,870,888 characters
-// on Node 24. A trace file's bytes are at least the characters of its items as compact JSON, so the
-// estimate compares the traces' bytes and may warn a little early.
+// gzip. A bundle export renders the Observer page, so it fails there too once --max-bytes is
+// raised past its 25 MiB default, which refuses such a run first. Writing run.json joins none: the
+// sandbox id scrub (publicSandboxView) works one participant at a time. V8's longest string is
+// 536,870,888 characters on Node 24. A trace file's bytes are at least the characters of its
+// items as compact JSON, so the estimate compares the traces' bytes and may warn a little early.
 import { constants } from "node:buffer";
 import { EVIDENCE_LIMITS } from "../analysis/analysis-limits.js";
 import { RUN_ARTIFACT_MAX_BYTES } from "../run/contained-output.js";
@@ -206,7 +206,7 @@ export function bundleLimitReason(estimate) {
             : []),
         ...(joined
             ? [
-                `All participants' traces together may grow to about ${mib(estimate.tracesBytes)}, past the ${mib(constants.MAX_STRING_LENGTH)} that fits in one string. On a hosted desktop, writing run.json puts them in one string, and so does a bundle export allowed past its 25 MiB default; the Observer page always does. run.json may then stop updating, that export would fail and the page would not build.`,
+                `All participants' traces together may grow to about ${mib(estimate.tracesBytes)}, past the ${mib(constants.MAX_STRING_LENGTH)} that fits in one string. The Observer page puts all their items in one string, so the page would not build. A bundle export allowed past its 25 MiB default renders that page, so it would fail too.`,
             ]
             : []),
         ...(entries

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "humanish",
-  "version": "0.133.0",
+  "version": "0.133.1",
   "description": "Synthetic user research for apps, CLIs, and agent-facing product flows.",
   "keywords": [
     "cli",