humanish 0.114.0 → 0.116.0

package/dist/observer/pinned-files.js

@@ -5,6 +5,7 @@ import { createHash } from "node:crypto";
 import { constants as fsConstants } from "node:fs";
 import { lstat, open, realpath } from "node:fs/promises";
 import path from "node:path";
+import { readOpenedAtMost } from "../run/contained-output.js";
 import { isPathInside, isSafeRunIdSegment } from "../run/paths.js";
 /**
  * The file's bytes, or null when it cannot be read under the root's checks. With `maxBytes`, a
@@ -18,7 +19,9 @@ export async function readContainedFile(root, filePathInput, options = {}) {
     try {
         const body = options.maxBytes === undefined
             ? await opened.handle.readFile()
-            : await readAtMost(opened.handle, opened.size, options.maxBytes);
+            : opened.size > options.maxBytes
+                ? null
+                : await readOpenedAtMost(opened.handle, options.maxBytes);
         if (body === null)
             return null;
         // A write that landed during the read changed the file's mtime and ctime.
@@ -79,24 +82,6 @@ export async function openContainedFile(root, filePathInput) {
         return null;
     }
 }
-/** At most `maxBytes` from the start of an opened file, or null when it holds more. */
-async function readAtMost(handle, size, maxBytes) {
-    if (size > maxBytes)
-        return null;
-    const chunks = [];
-    let total = 0;
-    for (;;) {
-        const chunk = Buffer.alloc(Math.min(64 * 1024, maxBytes + 1 - total));
-        const { bytesRead } = await handle.read(chunk, 0, chunk.length, total);
-        if (bytesRead === 0)
-            return Buffer.concat(chunks, total);
-        total += bytesRead;
-        // The file grew past the limit after it was opened.
-        if (total > maxBytes)
-            return null;
-        chunks.push(chunk.subarray(0, bytesRead));
-    }
-}
 /** The sha256 of an opened file, read by position so the handle's own offset is untouched. */
 export async function sha256OfOpenedFile(handle) {
     const hash = createHash("sha256");

package/dist/observer/render.js

@@ -11,15 +11,16 @@ 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 } from "../run/locate.js";
-import { readRunNotes } from "../run/notes.js";
+import { loadRunBundlePrepared, 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";
 import { renderObserverHtml } from "./artifact.js";
 import { buildObserverData } from "./data.js";
 import { buildServeSecurityHeaders, hostAllowed, parsePublicOrigin } from "./http.js";
 import { listenOnLoopback } from "./listen.js";
-import { createNotesWriter, NOTES_PATH } from "./notes-route.js";
+import { NOTES_PATH } from "../run/note-shape.js";
+import { createNotesWriter } from "./notes-route.js";
 import { pinDirectChildDirectory, pinDirectory, readContainedFile, } from "./pinned-files.js";
 import { buildHistoryIndex, matchRunRoute, serveRunPath, writeResponse, } from "./run-routes.js";
 import { cli } from "../cli/invocation.js";
@@ -105,8 +106,9 @@ export async function renderObserver(cwdInput, runInput, options = {}) {
     };
     // A run.json without an outcome is in progress, interrupted, or older than the field: its
     // status.json says which, and holds an older run's ok.
+    // A status.json it refuses says nothing, as a missing one does: the bundle's own facts show.
     const statusRecord = loaded.bundle.outcome === undefined
-        ? await readRunJsonIfExists(preparedRunPaths, RUN_STATUS_FILE)
+        ? runJsonValue(await readRunJsonIfExists(preparedRunPaths, RUN_STATUS_FILE))
         : undefined;
     const observerData = buildObserverData(loaded.bundle, undefined, statusRecord);
     observerData.publicSafety.share = {

package/dist/observer/run-routes.js

@@ -9,7 +9,7 @@ import { listRuns } from "../run/stored-runs.js";
 import { readAnalysisAccounting } from "../run/costs.js";
 import { bindExistingRunArtifactPaths, isPathInside, isSafeRunIdSegment, } from "../run/paths.js";
 import { isRunOutcome } from "../run/bundle-shape.js";
-import { decodeRunNote, listNoteEntries, MAX_NOTE_FILE_BYTES, noteListing, RUN_NOTES_DIR, runNoteFile, } from "../run/note-files.js";
+import { MAX_NOTE_FILE_BYTES, readRunNotes, RUN_NOTES_DIR, } from "../run/note-files.js";
 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";
@@ -59,33 +59,18 @@ async function readServedAnalysisSpend(runRoot) {
     }
 }
 /**
- * The run's reviewer notes as served: notes/ listed, and each note file read within
- * MAX_NOTE_FILE_BYTES through the root's checks, so a --safe root's admission and hash checks
- * apply to every note. A file that is not a readable note of the run is skipped and counted.
+ * The run's note files as served: each read through the root's checks, so a --safe root's
+ * admission and hash checks apply to every note.
  */
-async function readServedNotes(runRoot) {
-    const runId = path.basename(runRoot.physicalPath);
-    let listing;
-    try {
-        await assertPinnedDirectory(runRoot);
-        listing = await listNoteEntries(path.join(runRoot.physicalPath, RUN_NOTES_DIR));
-    }
-    catch {
-        return { runId, notes: [], skipped: [`${RUN_NOTES_DIR} is not a plain folder.`] };
-    }
-    if (listing === null)
-        return { runId, notes: [], skipped: [] };
-    const { ids, skipped } = noteListing(listing);
-    const notes = [];
-    for (const id of ids) {
-        const bytes = await readContainedFile(runRoot, path.join(runRoot.physicalPath, runNoteFile(id)), { maxBytes: MAX_NOTE_FILE_BYTES });
-        const note = bytes === null ? null : decodeRunNote(bytes, runId, id);
-        if (note === null)
-            skipped.push(`${runNoteFile(id)} was skipped.`);
-        else
-            notes.push(note);
-    }
-    return { runId, notes, skipped };
+function servedNoteFiles(runRoot) {
+    return {
+        runId: path.basename(runRoot.physicalPath),
+        async directory() {
+            await assertPinnedDirectory(runRoot);
+            return runRoot.physicalPath;
+        },
+        read: (relativePath, maxBytes) => readContainedFile(runRoot, path.join(runRoot.physicalPath, relativePath), { maxBytes }),
+    };
 }
 /**
  * internal: consumed by src/observer/serve.ts. `notesToken` goes into the run's Observer page so
@@ -120,7 +105,7 @@ export async function serveRunPath(runRoot, relativePath, response, runtimeStrea
             return;
         }
         const analysis = await readObserverAnalysis(runRoot);
-        const notes = await readServedNotes(runRoot);
+        const notes = await readRunNotes(servedNoteFiles(runRoot));
         writeResponse(response, 200, renderObserverHtml(observerData, {
             analysis,
             notes,

package/dist/observer/serve.js

@@ -3,7 +3,8 @@ import { runNotFoundMessage } from "../run/run-not-found.js";
 import { createServer } from "node:http";
 import path from "node:path";
 import { pinDirectChildDirectory, pinDirectory } from "./pinned-files.js";
-import { createNotesWriter, NOTES_PATH } from "./notes-route.js";
+import { NOTES_PATH } from "../run/note-shape.js";
+import { createNotesWriter } from "./notes-route.js";
 import { renderObserver } from "./render.js";
 import { buildHistoryIndex, matchRunRoute, servedRunPaths, serveRunPath } from "./run-routes.js";
 import { hashRunInventory, inventoryRoot, readRunInventory, } from "./run-inventory.js";