@re-cinq/floor-client 0.1.4 → 0.1.6

package/README.md

@@ -54,6 +54,8 @@ There is no idle timeout here on purpose. A caught-up quiet run legitimately say
 
 One caveat for a relay: `visit_opened` and `visit_reported` carry the whole visit, `agentSettings` included — the model, the prompt, the image. Filter those before they reach a browser.
 
+`runs.watchFloor(options)` follows the whole floor instead of one run: `run_started` and `run_changed`, each with a run's id and nothing else. It has no cursor. The floor opens every connection with `resync`, which means "read your list again", so a watch that drops comes back with nothing to remember. It is refused without the service token and comes back from everything else.
+
 ## Testing against it
 
 Both seams are injectable and neither needs a server: `fetchFn` for HTTP, `socketFn` for the live socket. With `backoffMs: () => 0`, the whole reconnect table is unit-testable in milliseconds — see `live.test.ts`.

package/dist/filters.d.ts

@@ -7,6 +7,7 @@ export type RunFilter = OneOf<{
     repo: string;
     subject: string;
     open: boolean;
+    since: string;
 }>;
 export type EventFilter = OneOf<{
     since: string;

package/dist/floor-live.d.ts

@@ -0,0 +1,14 @@
+import type { FloorFrame } from "@re-cinq/floor-contracts";
+import { type LiveReachable, type WatchEnd } from "./live.js";
+export interface FloorWatchOptions {
+    /** False leaves every close to the caller. */
+    reconnect?: boolean;
+    /** Attempt to delay. Return 0 in a test. */
+    backoffMs?: (attempt: number) => number;
+    signal?: AbortSignal;
+}
+export interface FloorWatch extends AsyncIterable<FloorFrame> {
+    readonly ended: Promise<WatchEnd>;
+    stop(): void;
+}
+export declare function watchFloor(floor: LiveReachable, options?: FloorWatchOptions): FloorWatch;

package/dist/floor-live.js

@@ -0,0 +1,8 @@
+import { follow, openFeed } from "./live.js";
+export function watchFloor(floor, options = {}) {
+    const watch = openFeed();
+    options.signal?.addEventListener("abort", () => watch.stop());
+    void follow({ floor, options, watch, urlFor: () => `${floor.url.replace(/^http/, "ws")}/assembly-runs/live` });
+    return watch;
+}
+//# sourceMappingURL=floor-live.js.map

package/dist/index.d.ts

@@ -4,6 +4,7 @@ export { serviceToken, visitToken } from "./tokens.js";
 export { FloorProblem, isFloorProblem } from "./problem.js";
 export { reach, asked, send } from "./send.js";
 export { CLOSE, watchRun } from "./live.js";
+export { watchFloor } from "./floor-live.js";
 export type { FloorAccess, FloorClient, HealthApi, LinesApi, MigrationsApi, SchedulesApi, Version } from "./client.js";
 export type { AppendRecord, GitCredentialOutcome, VisitAccess, VisitClient } from "./visit.js";
 export type { ServiceToken, VisitToken } from "./tokens.js";
@@ -14,5 +15,6 @@ export type { EnqueueEvent, EventsApi, EventsPage } from "./events.js";
 export type { CostsFilter, CostsGroupBy, EventFilter, OneOf, RunFilter } from "./filters.js";
 export type { CostsRowsApi, RunPage, RunsApi, StartRun, StartedRun } from "./runs.js";
 export type { BriefOutcome, RecordsPage, StationRunsApi } from "./station-runs.js";
+export type { FloorWatch, FloorWatchOptions } from "./floor-live.js";
 export type { LiveSocket, RefusalCode, RunWatch, SocketFn, WatchEnd, WatchOptions } from "./live.js";
 export type * from "@re-cinq/floor-contracts";

package/dist/index.js

@@ -5,4 +5,5 @@ export { serviceToken, visitToken } from "./tokens.js";
 export { FloorProblem, isFloorProblem } from "./problem.js";
 export { reach, asked, send } from "./send.js";
 export { CLOSE, watchRun } from "./live.js";
+export { watchFloor } from "./floor-live.js";
 //# sourceMappingURL=index.js.map

package/dist/live.d.ts

@@ -54,4 +54,26 @@ export interface RunWatch extends AsyncIterable<LiveFrame> {
     stop(): void;
 }
 export declare function watchRun(floor: LiveReachable, runId: string, options?: WatchOptions): RunWatch;
+/** What one watch holds while it runs: the frames not yet handed out, the socket, and whether it is over. */
+export interface Feed<Frame> extends AsyncIterable<Frame> {
+    readonly waiting: Frame[];
+    readonly socket: {
+        current: LiveSocket | null;
+    };
+    readonly ended: Promise<WatchEnd>;
+    endedYet(): WatchEnd | null;
+    take(frame: Frame): void;
+    settle(end: WatchEnd): void;
+    stop(): void;
+}
+export declare function openFeed<Frame>(onTake?: (frame: Frame) => void): Feed<Frame>;
+type Reconnecting = Pick<WatchOptions, "reconnect" | "backoffMs">;
+interface Following<Frame> {
+    floor: LiveReachable;
+    options: Reconnecting;
+    watch: Feed<Frame>;
+    /** The address for this attempt: a run's moves with its cursor, the floor's does not. */
+    urlFor(): string;
+}
+export declare function follow<Frame>(following: Following<Frame>): Promise<void>;
 export {};

package/dist/live.js

@@ -4,36 +4,26 @@ const REFUSALS = [CLOSE.badCursor, CLOSE.noServiceToken, CLOSE.noSuchRun, CLOSE.
 const BACKOFF_START_MS = 250;
 const BACKOFF_CAP_MS = 10_000;
 export function watchRun(floor, runId, options = {}) {
-    const watch = openWatch(cursorOf(options.after));
-    options.signal?.addEventListener("abort", () => watch.stop());
-    void follow({ floor, runId, options, watch });
-    return watch;
-}
-function openWatch(from) {
-    const journal = journalFrom(from);
-    const socket = { current: null };
-    const reading = journal.reading;
+    const cursor = { seq: cursorOf(options.after) };
+    const feed = openFeed((frame) => {
+        if (frame.type !== "unsupported")
+            cursor.seq = frame.seq;
+    });
+    options.signal?.addEventListener("abort", () => feed.stop());
+    void follow({ floor, options, watch: feed, urlFor: () => liveUrl(floor.url, runId, cursor.seq) });
     return {
         get seq() {
-            return reading.seq;
-        },
-        waiting: reading.waiting,
-        ended: reading.ended,
-        endedYet: reading.endedYet,
-        settle: reading.settle,
-        take: reading.take,
-        socket,
-        stop: () => {
-            socket.current?.close(CLOSE.settled, "the watcher stopped");
-            reading.settle({ reason: "stopped" });
+            return cursor.seq;
         },
-        [Symbol.asyncIterator]: () => reading[Symbol.asyncIterator](),
+        ended: feed.ended,
+        stop: feed.stop,
+        [Symbol.asyncIterator]: () => feed[Symbol.asyncIterator](),
     };
 }
-/** What has arrived and not yet been handed out, the cursor it moved, and whether the watch is over. */
-function journalFrom(from) {
-    const held = { seq: from, end: null };
+export function openFeed(onTake = () => { }) {
+    const held = { end: null };
     const waiting = [];
+    const socket = { current: null };
     const { sleep, wake } = sleeper();
     const { ended, finish } = promised();
     const settle = (end) => {
@@ -44,22 +34,21 @@ function journalFrom(from) {
         wake();
     };
     return {
-        reading: {
-            get seq() {
-                return held.seq;
-            },
-            waiting,
-            ended,
-            endedYet: () => held.end,
-            settle,
-            take: (frame) => {
-                if (frame.type !== "unsupported")
-                    held.seq = frame.seq;
-                waiting.push(frame);
-                wake();
-            },
-            [Symbol.asyncIterator]: () => handOut(waiting, { endedYet: () => held.end, sleep }),
+        waiting,
+        ended,
+        socket,
+        endedYet: () => held.end,
+        settle,
+        take: (frame) => {
+            onTake(frame);
+            waiting.push(frame);
+            wake();
+        },
+        stop: () => {
+            socket.current?.close(CLOSE.settled, "the watcher stopped");
+            settle({ reason: "stopped" });
         },
+        [Symbol.asyncIterator]: () => handOut(waiting, { endedYet: () => held.end, sleep }),
     };
 }
 /** A reader waiting on the next frame, woken when one arrives or when the watch is over. */
@@ -95,7 +84,7 @@ function handOut(waiting, watch) {
         },
     };
 }
-async function follow(following) {
+export async function follow(following) {
     const { options, watch } = following;
     let attempt = 0;
     while (!watch.endedYet()) {
@@ -120,7 +109,7 @@ function endFor(closed, options) {
 function connected(following) {
     const { floor, watch } = following;
     const open = floor.socketFn ?? defaultSocket;
-    const socket = open(liveUrl(floor.url, following.runId, watch.seq), { headers: { authorization: `Bearer ${floor.token}` } });
+    const socket = open(following.urlFor(), { headers: { authorization: `Bearer ${floor.token}` } });
     watch.socket.current = socket;
     return new Promise((resolve) => {
         socket.onFrame((said) => {

package/dist/runs.d.ts

@@ -1,6 +1,7 @@
 import type { CostsRow, Item, RunView } from "@re-cinq/floor-contracts";
 import type { CostsFilter, CostsGroupBy, RunFilter } from "./filters.js";
 import { type Reachable } from "./send.js";
+import { type FloorWatch, type FloorWatchOptions } from "./floor-live.js";
 import { type RunWatch, type WatchOptions } from "./live.js";
 export interface StartRun {
     repo: string;
@@ -31,6 +32,8 @@ export interface RunsApi {
     cancel(runId: string, reason: string): Promise<RunView>;
     /** Replays the run from `after`, then follows it live. Reconnects from the last seq it handed out. */
     watch(runId: string, options?: WatchOptions): RunWatch;
+    /** Follows the whole floor: which runs start and change, by id. `resync` comes first and after any gap. */
+    watchFloor(options?: FloorWatchOptions): FloorWatch;
 }
 export declare function runsApi(floor: Reachable): RunsApi;
 export interface CostsRowsApi {

package/dist/runs.js

@@ -1,4 +1,5 @@
 import { asked } from "./send.js";
+import { watchFloor } from "./floor-live.js";
 import { watchRun } from "./live.js";
 const HTTP_NOT_FOUND = 404;
 export function runsApi(floor) {
@@ -7,6 +8,7 @@ export function runsApi(floor) {
         get: (runId) => asked(floor, { method: "GET", path: `/assembly-runs/${runId}` }, [HTTP_NOT_FOUND]),
         cancel: async (runId, reason) => (await asked(floor, { method: "POST", path: `/assembly-runs/${runId}/cancel`, body: { reason } })),
         watch: (runId, options) => watchRun(floor, runId, options),
+        watchFloor: (options) => watchFloor(floor, options),
     };
 }
 export function costsApi(floor) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@re-cinq/floor-client",
-  "version": "0.1.4",
+  "version": "0.1.6",
   "description": "The floor over HTTP and its live socket, typed: definitions, runs, visits, blobs, events, schedules and costs, plus a watch that replays a run from a cursor and reconnects without losing a frame.",
   "license": "Apache-2.0",
   "repository": {
@@ -45,7 +45,7 @@
     "typecheck": "tsc --noEmit"
   },
   "dependencies": {
-    "@re-cinq/floor-contracts": "0.1.4"
+    "@re-cinq/floor-contracts": "0.1.6"
   },
   "devDependencies": {
     "@types/node": "^22.20.1",