humanish 0.125.0 → 0.127.0

package/dist/observer/run-routes.js

@@ -10,12 +10,13 @@ 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 { displayedTraces, loadStreamTraces } from "../run/stream-trace.js";
+import { displayedTraces, loadStreamTraces, } from "../run/stream-trace.js";
 import { isNodeError, isRecord } from "../run/type-guards.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";
+import { parseFeedCursors, withFeedCursors } from "./feed-cursors.js";
 import { splitObserverData } from "./participant-items.js";
 import { buildObserverData, observerDataFromSaved, recordedStreamEmbed, withObserverEndings, } from "./data.js";
 import { buildArtifactSecurityHeaders } from "./http.js";
@@ -103,14 +104,14 @@ export async function serveRunPath(runRoot, relativePath, response, runtimeStrea
         return;
     }
     if (cleanedRelativePath === "observer/index.html") {
-        const observerData = await observerDataOrReason(runRoot, runtimeStreamUrls);
-        if ("unavailable" in observerData) {
-            writeResponse(response, 404, `Observer data not found: ${observerData.unavailable}`, "text/plain; charset=utf-8");
+        const observed = await observerDataOrReason(runRoot, runtimeStreamUrls);
+        if ("unavailable" in observed) {
+            writeResponse(response, 404, `Observer data not found: ${observed.unavailable}`, "text/plain; charset=utf-8");
             return;
         }
         const analysis = await readObserverAnalysis(runRoot);
         const notes = await readRunNotes(servedNoteFiles(runRoot));
-        writeResponse(response, 200, renderObserverHtml(observerData, {
+        writeResponse(response, 200, renderObserverHtml(observed.data, {
             analysis,
             notes,
             ...(notesToken === undefined ? {} : { notesToken }),
@@ -121,15 +122,17 @@ export async function serveRunPath(runRoot, relativePath, response, runtimeStrea
     // polls observer-feed.json, the same data with the items, so one projection serves each poll.
     if (cleanedRelativePath === "observer/observer-data.json" ||
         cleanedRelativePath === "observer/observer-feed.json") {
-        const observerData = await observerDataOrReason(runRoot, runtimeStreamUrls);
-        if ("unavailable" in observerData) {
-            writeResponse(response, 404, `Observer data not found: ${observerData.unavailable}`, "text/plain; charset=utf-8");
+        const observed = await observerDataOrReason(runRoot, runtimeStreamUrls, cleanedRelativePath === "observer/observer-feed.json"
+            ? requestedCursors(runRoot, request)
+            : undefined);
+        if ("unavailable" in observed) {
+            writeResponse(response, 404, `Observer data not found: ${observed.unavailable}`, "text/plain; charset=utf-8");
             return;
         }
-        const { shell, items } = splitObserverData(observerData);
+        const { shell, items } = splitObserverData(observed.data);
         writeResponse(response, 200, cleanedRelativePath === "observer/observer-data.json"
             ? JSON.stringify(shell, null, 2)
-            : JSON.stringify({ data: shell, items }), "application/json; charset=utf-8");
+            : JSON.stringify({ data: shell, items: withFeedCursors(items, observed.live) }), "application/json; charset=utf-8");
         return;
     }
     if (cleanedRelativePath === "observer/study-analysis.json") {
@@ -163,19 +166,31 @@ export async function serveRunPath(runRoot, relativePath, response, runtimeStrea
         writeResponse(response, 404, "Not found", "text/plain; charset=utf-8");
     }
 }
+/**
+ * The live cursors a feed poll sends in `after`. A root that checks reads against admitted files
+ * and digests gets none: its digest check covers whole files, and it serves only finished runs.
+ */
+function requestedCursors(runRoot, request) {
+    if (runRoot.admitsFile !== undefined ||
+        runRoot.admitsContent !== undefined ||
+        request?.url === undefined)
+        return undefined;
+    return parseFeedCursors(new URL(request.url, "http://observer.invalid").searchParams.get("after"));
+}
 /** The run's trace files, read through its pinned folder. */
 function pinnedTraceReader(runRoot) {
-    return async (relativePath, maxBytes, length) => {
+    return async (relativePath, maxBytes, length, start) => {
         const bytes = await readContainedFile(runRoot, path.join(runRoot.physicalPath, relativePath), {
             maxBytes,
             ...(length === undefined ? {} : { length }),
+            ...(start === undefined ? {} : { start }),
         }).catch(() => null);
         return bytes === null ? { refused: `${relativePath} could not be read` } : { bytes };
     };
 }
 async function readObserverData(runRoot, runtimeStreamUrls = []) {
     const read = await observerDataOrReason(runRoot, runtimeStreamUrls);
-    return "unavailable" in read ? null : read;
+    return "unavailable" in read ? null : read.data;
 }
 /**
  * The run's Observer data, or why there is none. run.json is the source: each trace is loaded
@@ -185,7 +200,7 @@ async function readObserverData(runRoot, runtimeStreamUrls = []) {
  * cannot be read, parsed or used as a bundle (which a browser poll can meet mid-write) gives the
  * reason, a 404 the poller retries, never the saved projection.
  */
-async function observerDataOrReason(runRoot, runtimeStreamUrls) {
+async function observerDataOrReason(runRoot, runtimeStreamUrls, cursors) {
     const record = await readLocalRunStatus(runRoot);
     const runJson = path.join(runRoot.physicalPath, "run.json");
     const bundleBytes = await readContainedFile(runRoot, runJson).catch(() => null);
@@ -194,8 +209,10 @@ async function observerDataOrReason(runRoot, runtimeStreamUrls) {
     // A root admitted for safe serving checks every read against the identity and digest admitted
     // with the run's share_ready verification, so a run.json changed since then is refused, and the
     // saved projection it may serve is the one admitted with the verified run.
-    if (absent || (bundleBytes === null && runRoot.admitsContent !== undefined))
-        return savedObserverData(runRoot, record, runtimeStreamUrls);
+    if (absent || (bundleBytes === null && runRoot.admitsContent !== undefined)) {
+        const saved = await savedObserverData(runRoot, record, runtimeStreamUrls);
+        return "unavailable" in saved ? saved : { data: saved, live: [] };
+    }
     if (bundleBytes === null)
         return { unavailable: "run.json is there but could not be read: it is a link or changed." };
     let stored;
@@ -209,8 +226,12 @@ async function observerDataOrReason(runRoot, runtimeStreamUrls) {
         return { unavailable: "run.json is not a run bundle; it may be mid-write, so try again." };
     }
     try {
-        const bundle = displayedTraces(await loadStreamTraces(pinnedTraceReader(runRoot), stored));
-        return withRuntimeStreamUrls(withLocalRunStatus(record, buildObserverData(bundle, undefined, record), bundle.outcome), runtimeStreamUrls);
+        const loaded = await loadStreamTraces(pinnedTraceReader(runRoot), stored, cursors === undefined ? {} : { liveAfter: (index) => cursors.get(index.path) });
+        const bundle = displayedTraces(loaded);
+        return {
+            data: withRuntimeStreamUrls(withLocalRunStatus(record, buildObserverData(bundle, undefined, record), bundle.outcome), runtimeStreamUrls),
+            live: loaded.live,
+        };
     }
     catch {
         return { unavailable: "run.json could not be shown as a run." };