humanish 0.134.0 → 0.136.0

package/dist/evidence/encoded-text.js

@@ -5,7 +5,7 @@
 import { isUtf8 } from "node:buffer";
 import { createHash } from "node:crypto";
 import { readPlainText } from "./plain-text.js";
-import { containsSensitive } from "./redaction.js";
+import { containsSensitive, REDACTION_MARKERS, redactText } from "./redaction.js";
 // HTML5 named references that stand for printable ASCII. Letters and digits have only numeric
 // references, which decodeEscapes handles.
 const ASCII_ENTITIES = new Map([
@@ -97,37 +97,71 @@ function decodePercentBytes(run) {
 export function decodeEscapes(text) {
     return decodeWith(text, decodePercentBytes);
 }
-/** The readings a scan matches, with the two that scanEncodedText also searches for runs. */
+/** The readings a scan matches, with the three that scanEncodedText also searches for runs. */
 function readings(text) {
-    const decoded = decodeEscapes(text);
+    // Decoding references with the other escapes joins a letter reference to the escaped key after
+    // it, `A\u0073k-` to `Ask-`, where a pattern's word boundary fails. With references left as
+    // written, the `;` before the key keeps that boundary. A key that ends in a reference before an
+    // escaped letter, `l\u0041`, keeps the boundary after it when only references are decoded.
+    // The reading with references left as written is also read with transfer escapes expanded, as
+    // the decoded one is, for a key that a quoted-printable soft break splits.
+    const unescaped = decodeCodeEscapes(text, decodePercentBytes);
+    const decoded = decodeReferences(unescaped);
     // The UTF-8 reading differs only where a percent escape holds a byte of 0x80 or more, which
     // decodeEscapes writes as a character from U+0080 to U+00FF. Testing the decoded text also
     // catches a `%` that a `\u0025` wrote.
     const utf8 = HIGH_BYTE.test(decoded) ? decodeWith(text, decodePercentRun) : decoded;
     const expanded = decodeTransferEscapes(decoded);
+    // Without references in the text, or without code escapes, each of these two readings is one
+    // already decoded above, so it reuses that string. On a real 2 MiB Observer page, decoding both
+    // again took 12 ms of the 60 that readingsOf took.
+    const unescapedExpanded = unescaped === decoded ? expanded : decodeTransferEscapes(unescaped);
+    const referencesDecoded = text === unescaped ? decoded : decodeReferences(text);
     const recovered = [text, decoded].filter((reading) => HIGH_BYTE.test(reading));
     return {
+        all: [
+            ...new Set([
+                text,
+                decoded,
+                utf8,
+                expanded,
+                ...recovered.map(latin1RunsAsUtf8),
+                unescaped,
+                unescapedExpanded,
+                referencesDecoded,
+            ]),
+        ],
         decoded,
         expanded,
-        all: [...new Set([text, decoded, utf8, expanded, ...recovered.map(latin1RunsAsUtf8)])],
+        unescapedExpanded,
     };
 }
 /**
  * Every reading of the text a scan matches, each once: as written, decodeEscapes, with percent
- * escapes read as UTF-8, decodeEscapes with transfer escapes expanded, and the text as written and
+ * escapes read as UTF-8, decodeEscapes with transfer escapes expanded, the text as written and
  * decoded with each run of U+0080 to U+00FF characters read as UTF-8 bytes, which undoes text that
- * a reader already decoded one byte per character. Either percent reading can split a value that
- * the other keeps whole, as `%E2%80%80` (U+2000, a space, in UTF-8) does.
+ * a reader already decoded one byte per character, decodeEscapes with HTML references left as
+ * written and that reading with transfer escapes expanded, and the text with only HTML references
+ * decoded. Either percent reading can split a value that the other keeps whole, as `%E2%80%80`
+ * (U+2000, a space, in UTF-8) does.
  */
 export function readingsOf(text) {
     return readings(text).all;
 }
 function decodeWith(text, percent) {
+    return decodeReferences(decodeCodeEscapes(text, percent));
+}
+/** JSON and JS string escapes, then percent-encoding. */
+function decodeCodeEscapes(text, percent) {
     return text
         .replace(/\\u([0-9a-f]{4})/gi, (match, hex) => codePoint(Number.parseInt(hex, 16), match))
         .replace(/\\x([0-9a-f]{2})/gi, (match, hex) => codePoint(Number.parseInt(hex, 16), match))
         .replace(/\\\//g, "/")
-        .replace(/(?:%[0-9a-f]{2})+/gi, percent)
+        .replace(/(?:%[0-9a-f]{2})+/gi, percent);
+}
+/** HTML character references: numeric ones and the ASCII_ENTITIES names. */
+function decodeReferences(text) {
+    return text
         .replace(/&#x([0-9a-f]{1,6});?/gi, (match, hex) => codePoint(Number.parseInt(hex, 16), match))
         .replace(/&#(\d{1,7});?/g, (match, digits) => codePoint(Number.parseInt(digits, 10), match))
         .replace(/&([a-z]+);/gi, namedReference);
@@ -144,6 +178,8 @@ const BASE64_RUN = /[A-Za-z0-9+/]{16}[A-Za-z0-9+/]*={0,2}/g;
 const BASE64URL_RUN = /[A-Za-z0-9_-]{16}[A-Za-z0-9_-]*={0,2}/g;
 // Hex-encoded text, at least sixteen bytes of it.
 const HEX_RUN = /[0-9a-f]{32}[0-9a-f]*/gi;
+// The base64, URL-safe base64 or hex run right after a `;`, such as the one that ends a reference.
+const RUN_AFTER_SEMICOLON = /;([A-Za-z0-9+/_-]{16}[A-Za-z0-9+/_-]*={0,2})/g;
 // A base64 run that decodes to bytes that are neither text nor an archive is unreadable only past
 // this length. Across 173 real run folders surveyed on 2026-10-01, the longest such run outside
 // observer/index.html was a 69-character URL path in a terminal log; base64 of a 94-byte payload,
@@ -293,6 +329,18 @@ function inspectDecoded(bytes, run, options, depth) {
             options.allowOpaqueBase64 !== true,
     };
 }
+/** The base64 and URL-safe base64 runs in a reading, each with its bytes. */
+function base64Runs(reading) {
+    const runs = [];
+    for (const [match] of reading.matchAll(BASE64_RUN))
+        // Hex digests and ids decode to noise; scanEncodedText's hex pass reads hex as hex.
+        if (!/^[0-9a-f]+$/i.test(match.replace(/=+$/, "")))
+            runs.push({ run: match, bytes: Buffer.from(match, "base64") });
+    for (const [match] of reading.matchAll(BASE64URL_RUN))
+        if (/[-_]/.test(match))
+            runs.push({ run: match, bytes: Buffer.from(match, "base64url") });
+    return runs;
+}
 /**
  * Scans text for secrets in each of its readingsOf, and inside each base64 (standard, URL-safe or
  * line-wrapped) and hex run. A run that decodes to text is scanned in
@@ -301,31 +349,31 @@ function inspectDecoded(bytes, run, options, depth) {
  */
 export function scanEncodedText(text, options = {}, depth = 0) {
     const matches = matcherOf(options);
-    const { decoded, expanded, all } = readings(text);
+    const { all, decoded, expanded, unescapedExpanded } = readings(text);
     if (all.some(matches))
         return SENSITIVE;
-    const runs = [];
+    const runs = base64Runs(expanded);
     // A piece or a run decoded from a slash only adds findings; its bytes are not judged opaque.
     const slashStarts = [];
-    for (const [match] of expanded.matchAll(BASE64_RUN)) {
-        // Hex digests and ids decode to noise; the hex pass below reads hex as hex.
-        if (/^[0-9a-f]+$/i.test(match.replace(/=+$/, "")))
-            continue;
-        runs.push({ run: match, bytes: Buffer.from(match, "base64") });
-        if (match.length > MAX_SLASH_START_RUN)
+    for (const { run } of runs) {
+        if (run.length > MAX_SLASH_START_RUN)
             continue;
-        for (const piece of match.split("/"))
-            if (piece.length >= 16 && piece.length < match.length)
+        for (const piece of run.split("/"))
+            if (piece.length >= 16 && piece.length < run.length)
                 slashStarts.push(Buffer.from(piece, "base64"));
-        for (let slash = match.indexOf("/"); slash !== -1 && slash < SLASH_START_SPAN && match.length - slash > 16; slash = match.indexOf("/", slash + 1))
-            slashStarts.push(Buffer.from(match.slice(slash + 1), "base64"));
-    }
-    for (const [match] of expanded.matchAll(BASE64URL_RUN)) {
-        if (/[-_]/.test(match))
-            runs.push({ run: match, bytes: Buffer.from(match, "base64url") });
+        for (let slash = run.indexOf("/"); slash !== -1 && slash < SLASH_START_SPAN && run.length - slash > 16; slash = run.indexOf("/", slash + 1))
+            slashStarts.push(Buffer.from(run.slice(slash + 1), "base64"));
     }
     for (const run of wrappedBase64Runs(expanded))
         runs.push({ run, bytes: Buffer.from(run, "base64") });
+    // A decoded reference right before a run joins its character to the run, which shifts every
+    // base64 quartet and hex pair in it. The run after each `;` with references left as written
+    // adds findings, as a slash start does.
+    const runsAfterSemicolons = unescapedExpanded === expanded
+        ? []
+        : [...unescapedExpanded.matchAll(RUN_AFTER_SEMICOLON)].map(([, run]) => run);
+    for (const { bytes } of runsAfterSemicolons.flatMap(base64Runs))
+        slashStarts.push(bytes);
     let opaque = false;
     for (const { run, bytes } of runs) {
         const result = inspectDecoded(bytes, run, options, depth);
@@ -341,6 +389,7 @@ export function scanEncodedText(text, options = {}, depth = 0) {
     const hexRuns = new Set([
         ...[...expanded.matchAll(HEX_RUN)].map(([match]) => match),
         ...(expanded === decoded ? [] : [...decoded.matchAll(HEX_RUN)].map(([match]) => match)),
+        ...runsAfterSemicolons.flatMap((run) => [...run.matchAll(HEX_RUN)].map(([match]) => match)),
     ]);
     for (const match of hexRuns) {
         const plain = readPlainText(Buffer.from(match, "hex"));
@@ -349,10 +398,24 @@ export function scanEncodedText(text, options = {}, depth = 0) {
     }
     return { sensitive: false, opaque };
 }
+/**
+ * redactText, then each whitespace-separated piece that scanEncodedText reads as sensitive replaced
+ * by the secret marker, so a key written in base64 or percent-encoded goes as a literal one does.
+ * When the pieces read clean one at a time but the text still reads sensitive, as `Bearer` before a
+ * percent-encoded token does, the whole text becomes the marker. For study text the run records and
+ * the instructions composed from it: on 32 KiB of prose it took 3 ms, and 34 ms with a key in it.
+ */
+export function redactEncodedText(text) {
+    const literal = redactText(text);
+    if (!scanEncodedText(literal).sensitive)
+        return literal;
+    const pieces = literal.replace(/\S+/g, (piece) => scanEncodedText(piece).sensitive ? REDACTION_MARKERS.secret : piece);
+    return scanEncodedText(pieces).sensitive ? REDACTION_MARKERS.secret : pieces;
+}
 // Bump when scanEncodedText, decodeEscapes or the sensitive patterns change what they return. The
 // cache lives in one process, so the version guards results across a hot reload or a test that
 // swaps the scanner.
-const ENCODED_SCAN_VERSION = 5;
+const ENCODED_SCAN_VERSION = 6;
 // Distinct files one process verifies in a burst (a run's files, a serve library's runs).
 const SCAN_CACHE_LIMIT = 256;
 const scanCache = new Map();

package/dist/evidence/image.d.ts

@@ -20,5 +20,5 @@ export declare function pngDecodeRefusal(bytes: Buffer): string | null;
  * were downscaled, and any other chunk is a place to carry bytes no one reviews.
  */
 export declare function isRedactedFrameShape(bytes: Buffer): boolean;
-export declare function screenshotEvidenceError(relativePath: string, bytes: Buffer): string | null;
-export declare function assertScreenshotEvidence(relativePath: string, bytes: Buffer): void;
+export declare function screenshotEvidenceError(relativePath: string, bytes: Buffer): Promise<string | null>;
+export declare function assertScreenshotEvidence(relativePath: string, bytes: Buffer): Promise<void>;

package/dist/evidence/image.js

@@ -1,4 +1,4 @@
-import { crc32, inflateSync } from "node:zlib";
+import { crc32, createInflate } from "node:zlib";
 import { PNG } from "pngjs";
 const PNG_SIGNATURE = Buffer.from([0x89, 0x50, 0x4e, 0x47, 0x0d, 0x0a, 0x1a, 0x0a]);
 const PNG_IHDR_LENGTH = 13;
@@ -128,7 +128,7 @@ export function isRedactedFrameShape(bytes) {
         last.end === bytes.length &&
         bytes.readUInt32BE(16) <= SCREENSHOT_MAX_WIDTH_CAP);
 }
-export function screenshotEvidenceError(relativePath, bytes) {
+export async function screenshotEvidenceError(relativePath, bytes) {
     const extension = relativePath.toLowerCase().split(".").pop() ?? "";
     if (extension !== "png") {
         return `unsupported screenshot extension .${extension || "unknown"}; only decoded PNG evidence is supported`;
@@ -146,7 +146,7 @@ export function screenshotEvidenceError(relativePath, bytes) {
     if (chunks?.some((chunk) => chunk.type === "IEND" && chunk.end - chunk.start !== 12)) {
         return "PNG IEND chunk must be empty";
     }
-    return chunks === null || !pngStructureHolds(bytes, chunks)
+    return chunks === null || !(await pngStructureHolds(bytes, chunks))
         ? "could not decode PNG evidence"
         : null;
 }
@@ -164,14 +164,14 @@ const PNG_MIN_CHUNK_BYTES = { gAMA: 4 };
 /**
  * Whether a PNG that passed pngDecodeRefusal decodes, read from its structure: the file ends at an
  * empty IEND, every chunk's CRC matches, IHDR comes once with fields PNG defines, the image data is
- * one run of IDAT chunks, and it inflates, with zlib's native code, to exactly the
- * bytes its rows need with nothing after the stream, each row starting with a filter type from 0
- * to 4. For an image without a palette that is all a decode establishes, at about an eighth of
- * the time of pngjs, which unfilters every pixel in JavaScript; a run holds a screenshot for each
- * turn. A palette image is also decoded, since each pixel must index a palette that comes before
- * the image data; in any other image a palette chunk is only a suggestion, wherever it is.
+ * one run of IDAT chunks, and it inflates (inflatesToRows) to exactly the bytes its rows need with
+ * nothing after the stream, each row starting with a filter type from 0 to 4. For an image without
+ * a palette that is all a decode establishes, at about an eighth of the time of pngjs, which
+ * unfilters every pixel in JavaScript; a run holds a screenshot for each turn. A palette image is
+ * also decoded, since each pixel must index a palette that comes before the image data; in any
+ * other image a palette chunk is only a suggestion, wherever it is.
  */
-function pngStructureHolds(bytes, chunks) {
+async function pngStructureHolds(bytes, chunks) {
     const last = chunks.at(-1);
     if (last?.type !== "IEND" || last.end !== bytes.length)
         return false;
@@ -200,29 +200,44 @@ function pngStructureHolds(bytes, chunks) {
         return false;
     const rowBytes = 1 + Math.ceil(rowBits / 8);
     const data = Buffer.concat(idats.map((chunk) => bytes.subarray(chunk.start + 8, chunk.end - 4)));
-    let rows;
-    try {
-        // A stream that would inflate past the rows the image needs stops there, so a small file
-        // cannot claim gigabytes.
-        const options = {
-            maxOutputLength: rowBytes * height,
-            info: true,
-        };
-        const inflated = inflateSync(data, options);
-        if (inflated.engine.bytesWritten !== data.length)
-            return false;
-        rows = inflated.buffer;
-    }
-    catch {
-        return false;
-    }
-    if (rows.length !== rowBytes * height)
+    if (!(await inflatesToRows(data, rowBytes, height)))
         return false;
-    for (let row = 0; row < rows.length; row += rowBytes)
-        if (rows[row] > 4)
-            return false;
     return colorType !== 3 || pngDecodes(bytes);
 }
+// The most inflated bytes one check holds at once. Checks overlap on the thread pool, so rows held
+// whole add up across them. A process running 8 checks of 5000x5000 RGBA frames peaked at 832 MB
+// resident with each frame's rows held whole and at 202 MB checked 1 MiB at a time.
+const INFLATE_CHUNK_BYTES = 1024 * 1024;
+/**
+ * Whether `data` inflates to exactly `rows` rows of `rowBytes` bytes, each starting with a filter
+ * type from 0 to 4, with nothing after the stream. zlib inflates on libuv's thread pool, so checks
+ * of several frames overlap. A stream that would inflate past the rows stops there, so a small
+ * file cannot claim gigabytes.
+ */
+function inflatesToRows(data, rowBytes, rows) {
+    const total = rowBytes * rows;
+    return new Promise((resolve) => {
+        const inflate = createInflate({
+            chunkSize: Math.max(64, Math.min(total, INFLATE_CHUNK_BYTES)),
+        });
+        let seen = 0;
+        inflate.on("data", (chunk) => {
+            let filtersHold = true;
+            // The first row that starts in this chunk, then each row after it.
+            for (let at = (rowBytes - (seen % rowBytes)) % rowBytes; at < chunk.length; at += rowBytes)
+                if (chunk[at] > 4)
+                    filtersHold = false;
+            seen += chunk.length;
+            if (!filtersHold || seen > total) {
+                inflate.destroy();
+                resolve(false);
+            }
+        });
+        inflate.on("error", () => resolve(false));
+        inflate.on("end", () => resolve(seen === total && inflate.bytesWritten === data.length));
+        inflate.end(data);
+    });
+}
 function pngDecodes(bytes) {
     try {
         PNG.sync.read(bytes, { checkCRC: true });
@@ -232,8 +247,8 @@ function pngDecodes(bytes) {
         return false;
     }
 }
-export function assertScreenshotEvidence(relativePath, bytes) {
-    const error = screenshotEvidenceError(relativePath, bytes);
+export async function assertScreenshotEvidence(relativePath, bytes) {
+    const error = await screenshotEvidenceError(relativePath, bytes);
     if (error) {
         throw new Error(`Invalid screenshot evidence ${relativePath}: ${error}`);
     }

package/dist/observer/data.d.ts

@@ -1,7 +1,8 @@
+import type { ActorTrace } from "../actors/contract.js";
 import { type ActorEnding } from "../actors/stop-cause.js";
-import type { RunBundle, RunCostSummary, RunEvent, RunSimulation } from "../run/bundle.js";
+import type { DisplayedRunBundle, RunBundle, RunCostSummary, RunEvent, RunSimulation } from "../run/bundle.js";
 import { type RunDisplay } from "../run/display.js";
-import type { RunStream, RunStreamKind, StoredRunStream } from "../run/streams.js";
+import type { RunStream, RunStreamKind, StoredRunStream, WithoutRequestLists } from "../run/streams.js";
 /**
  * The Observer's data. From v2 observer-data.json leaves out each participant's items, and from v3
  * each participant's per-request lists (REQUEST_LISTS in src/run/stream-trace.ts), which no part
@@ -97,6 +98,9 @@ export interface ObserverData {
     };
 }
 export interface ObserverStream extends StoredRunStream {
+    /** The loaded actor, with its items and without its per-request lists, as is the live actor. */
+    actor?: WithoutRequestLists<ActorTrace>;
+    liveActor?: WithoutRequestLists<NonNullable<RunStream["liveActor"]>>;
     /** Only the attached server may grant provider-origin access for a live desktop iframe. */
     embed?: NonNullable<RunStream["embed"]> & {
         runtimeDesktop?: true;
@@ -127,7 +131,7 @@ interface ObserverLaneGroup {
  * bundle with no outcome in run.json: a run in progress, interrupted, or recorded before run.json
  * carried its outcome.
  */
-export declare function buildObserverData(bundle: RunBundle, generatedAt?: string, statusRecord?: unknown): ObserverData;
+export declare function buildObserverData(bundle: DisplayedRunBundle, generatedAt?: string, statusRecord?: unknown): ObserverData;
 /**
  * A saved Observer projection as this version reads it, as v3 and unchecked as before. An
  * observer-data.json written before v2 holds every participant's items, and its per-request lists,

package/dist/observer/page-data.d.ts

@@ -1,5 +1,11 @@
+import type { LiveItemsRead } from "../run/stream-trace.js";
 import type { ObserverData } from "./data.js";
 /** The page's data elements for `data`, in place of the built page's data slot. */
 export declare function observerDataElements(data: ObserverData): string;
+/**
+ * observer-feed.json's body: observer-data.json's content and the items packed as the page packs
+ * them, with each running participant's cursor from `live` on its entry.
+ */
+export declare function observerFeedBody(data: ObserverData, live?: readonly LiveItemsRead[]): Promise<string>;
 /** JSON that stays inert inside a script element: no `</script>` breakout, no HTML entities. */
 export declare function escapeJsonScript(value: unknown): string;

package/dist/observer/page-data.js

@@ -1,15 +1,42 @@
-// How an Observer page carries a run's data: observer-data.json's content as JSON, and every
-// participant's trace items gzip-compressed in base64, which a file:// page decodes without a
-// fetch. The items are most of a long run's bytes and compress about eight times.
-import { gzipSync } from "node:zlib";
-import { splitObserverData } from "./participant-items.js";
+// How an Observer page and the served feed carry a run's data: observer-data.json's content as
+// JSON, and each participant's trace items gzip-compressed in base64 on their own, which a file://
+// page decodes without a fetch. The items are most of a long run's bytes and compress about eight
+// times. Packing one participant at a time keeps every string under V8's longest string
+// (536,870,888 characters) while each participant's trace stays under the 32 MiB read limit.
+import { promisify } from "node:util";
+import { constants, gzip, gzipSync } from "node:zlib";
+import { withFeedCursors } from "./feed-cursors.js";
+import { splitObserverData, } from "./participant-items.js";
 /** The page's data elements for `data`, in place of the built page's data slot. */
 export function observerDataElements(data) {
     const { shell, items } = splitObserverData(data);
-    const packed = gzipSync(JSON.stringify(items)).toString("base64");
     return (`<script id="observer-data" type="application/json">${escapeJsonScript(shell)}</script>` +
-        `<script id="observer-items" type="application/octet-stream" data-encoding="gzip">${packed}</script>`);
+        `<script id="observer-items" type="application/json">${escapeJsonScript(packObserverItems(items))}</script>`);
 }
+const gzipOnThreadPool = promisify(gzip);
+/**
+ * observer-feed.json's body: observer-data.json's content and the items packed as the page packs
+ * them, with each running participant's cursor from `live` on its entry.
+ */
+export async function observerFeedBody(data, live = []) {
+    const { shell, items } = splitObserverData(data);
+    const cursored = withFeedCursors(items, live);
+    // Each open page polls every 5 seconds and gets every finished participant's items again, so the
+    // server compresses them on the thread pool and answers other requests meanwhile. Level 1 took
+    // half the time of the default on 30 MiB of items, for 13 percent more bytes. One participant
+    // at a time, so a poll holds one participant's JSON text at once.
+    const streams = [];
+    for (const [id, entry] of Object.entries(cursored.streams)) {
+        const packed = await gzipOnThreadPool(entryText(id, entry), { level: constants.Z_BEST_SPEED });
+        streams.push(packed.toString("base64"));
+    }
+    return JSON.stringify({ data: shell, items: { ...cursored, streams } });
+}
+function packObserverItems(items) {
+    const streams = Object.entries(items.streams).map(([id, entry]) => gzipSync(entryText(id, entry)).toString("base64"));
+    return { ...items, streams };
+}
+const entryText = (id, entry) => JSON.stringify({ id, ...entry });
 /** JSON that stays inert inside a script element: no `</script>` breakout, no HTML entities. */
 export function escapeJsonScript(value) {
     return JSON.stringify(value)

package/dist/observer/participant-items.d.ts

@@ -1,6 +1,6 @@
 import type { ActorTraceItem } from "../actors/contract.js";
 import type { ObserverData, ObserverStream } from "./data.js";
-export declare const OBSERVER_ITEMS_SCHEMA = "humanish.observer-items.v1";
+export declare const OBSERVER_ITEMS_SCHEMA = "humanish.observer-items.v2";
 /** A stream's actor and live actor, each without its items. */
 type ObserverShellStream = Omit<ObserverStream, "actor" | "liveActor"> & {
     actor?: Omit<NonNullable<ObserverStream["actor"]>, "items">;
@@ -32,6 +32,20 @@ export interface ObserverItems {
         liveAfter?: string;
     }>;
 }
+/**
+ * ObserverItems as the page and the feed carry them: each stream's entry with its stream id, as
+ * gzip-compressed JSON in base64, so no string holds two participants' items. The id goes inside
+ * the entry because the public-safety scan reads the page's plain text: there, `GITHUB_TOKEN`
+ * before a long base64 value reads as a credential, and `https://` with a later id shaped like an
+ * address at an E2B host reads as one E2B URL across the base64 between them.
+ */
+export interface PackedObserverItems extends Omit<ObserverItems, "streams"> {
+    streams: string[];
+}
+/** A packed entry once decoded: the stream's entry with its stream id. */
+export type PackedObserverEntry = ObserverItems["streams"][string] & {
+    id: string;
+};
 /** The data as observer-data.json and the page's items carry it. */
 export declare function splitObserverData(data: ObserverData): {
     shell: ObserverShell;

package/dist/observer/participant-items.js

@@ -1,9 +1,10 @@
 // The Observer's data in two parts: observer-data.json, the run and every participant without
 // their trace items, and the items themselves. A participant working for hours records thousands
 // of items, so the items are most of the bytes; apart, the saved observer-data.json stays small
-// enough to verify, and the page carries the items compressed. The Observer bundles this module,
-// so it imports types only (docs/decisions/0002-observer-is-one-self-contained-file.md).
-export const OBSERVER_ITEMS_SCHEMA = "humanish.observer-items.v1";
+// enough to verify, and the page and the feed carry each participant's items compressed on their
+// own. The Observer bundles this module, so it imports types only
+// (docs/decisions/0002-observer-is-one-self-contained-file.md).
+export const OBSERVER_ITEMS_SCHEMA = "humanish.observer-items.v2";
 /** The data as observer-data.json and the page's items carry it. */
 export function splitObserverData(data) {
     // No prototype, so a stream id such as `__proto__` is an entry like any other.

package/dist/observer/render.js

@@ -11,7 +11,7 @@ import { projectShareCheckedAnalysis } from "../analysis/sharing.js";
 import { loadAnalysis } from "../analysis/load.js";
 import { physicalCwdOf, runIdOf, bindExistingRunArtifactPaths, isSafeRunIdSegment, resolveLatestRunDirectory, validatePreparedRunArtifactPaths, } from "../run/paths.js";
 import { writeContainedOutputFile } from "../run/contained-output.js";
-import { loadRunBundlePrepared, readRunJsonIfExists, runJsonValue } from "../run/locate.js";
+import { loadDisplayedRunBundle, readRunJsonIfExists, runJsonValue } from "../run/locate.js";
 import { readRunNotes } from "../run/note-files.js";
 import { RUN_STATUS_FILE } from "../run/status.js";
 import { verifyRunPrepared } from "../verify/verify.js";
@@ -91,9 +91,7 @@ export async function renderObserver(cwdInput, runInput, options = {}) {
             : "HUMANISH_INVALID_RUN_BUNDLE", verified.error?.message ?? "Run bundle failed verification.");
     }
     // Verify passes a trace past the read limit, so its participant shows without its items.
-    const loaded = await loadRunBundlePrepared(selectedPhysicalCwd, preparedRunPaths, {
-        display: true,
-    });
+    const loaded = await loadDisplayedRunBundle(selectedPhysicalCwd, preparedRunPaths);
     await validatePreparedRunArtifactPaths(preparedRunPaths);
     if (!loaded)
         return runNotFound(cwd, runInput);

package/dist/observer/run-routes.js

@@ -17,7 +17,8 @@ import { MAX_NOTE_FILE_BYTES, readRunNotes, RUN_NOTES_DIR, } from "../run/note-f
 import { analysisCostOf, runCost, runCostLabel } from "../run/run-cost.js";
 import { RUN_STATUS_FILE, RUN_STATUS_STALE_MS, isRunStatusRecord, } from "../run/status.js";
 import { renderObserverHtml } from "./artifact.js";
-import { parseFeedCursors, withFeedCursors } from "./feed-cursors.js";
+import { parseFeedCursors } from "./feed-cursors.js";
+import { observerFeedBody } from "./page-data.js";
 import { splitObserverData } from "./participant-items.js";
 import { buildObserverData, observerDataFromSaved, recordedStreamEmbed, withObserverEndings, } from "./data.js";
 import { buildArtifactSecurityHeaders } from "./http.js";
@@ -130,10 +131,9 @@ export async function serveRunPath(runRoot, relativePath, response, runtimeStrea
             writeResponse(response, 404, `Observer data not found: ${observed.unavailable}`, "text/plain; charset=utf-8");
             return;
         }
-        const { shell, items } = splitObserverData(observed.data);
         writeResponse(response, 200, cleanedRelativePath === "observer/observer-data.json"
-            ? JSON.stringify(shell, null, 2)
-            : JSON.stringify({ data: shell, items: withFeedCursors(items, observed.live) }), "application/json; charset=utf-8");
+            ? JSON.stringify(splitObserverData(observed.data).shell, null, 2)
+            : await observerFeedBody(observed.data, observed.live), "application/json; charset=utf-8");
         return;
     }
     if (cleanedRelativePath === "observer/study-analysis.json") {