@volter/supercode-orchestrator 0.5.106 → 0.5.107

package/board/doors.mjs

@@ -64,6 +64,11 @@ export async function machineCall(machine, method, params = {}, { timeoutMs = 60
   }
 }
 
+export async function machineRecordStream(params = {}) {
+  const door = await opened(null);
+  return door.channel.open('machine-record-changes', params);
+}
+
 /** Let go of every held channel (the owner stopping). */
 export async function closeDoors() {
   for (const [key, opening] of [...held]) {

package/board/machine-fleet.mjs

@@ -8,7 +8,9 @@
 // sessions under them not read) or was never read is `unknown` (its runs are kept, as an unread machine's always were), unless its record says it was unlinked from the
 // team: then it is offline. This machine's own record not being given is no reading at all.
 import { noteStep } from '@volter/supercode-harness-sdk/slow-log';
-import { machineCall } from './doors.mjs';
+import { machineCall, machineRecordStream } from './doors.mjs';
+import { RecordView } from './record-view.mjs';
+const recordView = new RecordView(machineRecordStream);
 const DEADLINE_MS = 10_000;
 const within = (promise, ms) => Promise.race([promise, new Promise((_, reject) => setTimeout(() => reject(Object.assign(new Error(`no answer within ${ms} ms`), { code: 'timeout' })), ms).unref?.())]);
 // One machine's reading, from its held record: its panes, what a board launch needs of it, and the session under each
@@ -32,7 +34,15 @@ export async function readMachineFleet(machines, local) {
   const names = [...new Set([local, ...machines])];
   const started = performance.now();
   let held = null, heldError = null;
-  try { held = (await within(machineCall(null, 'harness.v1.machine.records', {}), DEADLINE_MS))?.records ?? {}; }
+  try {
+    try { held = await within(recordView.read(DEADLINE_MS), DEADLINE_MS); }
+    catch (error) {
+      if (!String(error.message).includes('unknown stream machine-record-changes')) throw error;
+      // Supported older daemons have only the snapshot door. A refusal or a
+      // failed current stream never falls back to data of uncertain freshness.
+      held = (await within(machineCall(null, 'harness.v1.machine.records', {}), DEADLINE_MS))?.records ?? {};
+    }
+  }
   catch (error) { heldError = String(error?.message ?? error).slice(0, 300); }
   const rows = names.map((name) => heldError ? { machine: name, error: `this machine's daemon did not give the records it holds: ${heldError}`, code: 'unavailable' } : readOne(name, held[name]));
   noteStep(`fleet reading (${names.length} machine${names.length === 1 ? '' : 's'}, held records)`, performance.now() - started);

package/board/record-view.mjs

@@ -0,0 +1,93 @@
+// Resident local consumer of the daemon's committed record rows. Disconnects
+// preserve the last applied cursor, but held data is stale until caught up.
+export class RecordView {
+  constructor(open) {
+    this.open = open; this.records = {}; this.positions = new Map();
+    this.cursor = null; this.stream = null; this.waiters = new Set();
+    this.ready = false; this.heardAt = 0;
+  }
+  async read(timeoutMs) {
+    const deadline = Date.now() + timeoutMs;
+    if (this.stream && Date.now() - this.heardAt > 45_000) this.stream.close('its record stream went quiet');
+    if (!this.stream && !this.opening) {
+      this.opening = this.open({ after: this.cursor }).then((stream) => {
+        this.stream = stream;
+        this.ready = false;
+        this.heardAt = Date.now();
+        stream.on('data', (frame) => {
+          try { this.apply(frame); }
+          catch (error) { this.fail(error); stream.close(error.message); }
+        });
+        stream.on('close', (reason) => {
+          if (this.stream !== stream) return;
+          this.stream = null; this.ready = false;
+          this.fail(new Error(reason ?? 'the local record stream closed'));
+        });
+      }).finally(() => { this.opening = null; });
+    }
+    if (this.opening) await this.opening;
+    if (this.ready) return this.records;
+    if (!this.stream) throw this.failure ?? new Error('the local record stream ended before its snapshot');
+    return new Promise((resolve, reject) => {
+      const waiter = { resolve, reject };
+      waiter.timer = setTimeout(() => {
+        this.waiters.delete(waiter);
+        reject(new Error('the local record stream did not finish its snapshot or cursor catch-up within its deadline'));
+      }, Math.max(0, deadline - Date.now()));
+      this.waiters.add(waiter);
+    });
+  }
+  fail(error) {
+    this.failure = error;
+    for (const waiter of this.waiters) { clearTimeout(waiter.timer); waiter.reject(error); }
+    this.waiters.clear();
+  }
+  own(key) { return key.role === 'producer' ? key.machine === this.self : key.role === 'holder' && key.machine !== this.self; }
+  apply(frame) {
+    if (frame.type === 'beat') { this.heardAt = Date.now(); return; }
+    if (frame.type === 'snapshot') {
+      this.self = frame.machine; this.records = frame.records; this.positions.clear();
+      for (const [machine, held] of Object.entries(this.records)) this.positions.set(machine, new Map((held.record?.sessions ?? []).map((row, at) => [row.address, at])));
+      this.cursor = frame.cursor; this.ready = true;
+    } else if (frame.type === 'changes') {
+      if (!this.cursor || frame.cursor?.id !== this.cursor.id) throw new Error('record row changes name a different database; a new snapshot is required');
+      const moved = new Set();
+      for (const change of frame.changes ?? []) {
+        if (change.sequence <= this.cursor.sequence || !this.own(change.key)) continue;
+        const { machine, section, key, position } = change.key;
+        if (change.topic === 'record-head') {
+          if (change.operation === 'delete') { delete this.records[machine]; this.positions.delete(machine); continue; }
+          const { record: summary, meta } = change.value;
+          const previous = this.records[machine]?.record;
+          const record = summary == null ? null : { sessions: [], mail: {}, panes: null, capabilities: null, unread: {}, ...previous, ...summary };
+          if (record) { if (!summary.sessions_rows) record.sessions = null; delete record.sessions_rows; }
+          this.records[machine] = { record, stream: machine === this.self ? 'self' : meta?.stream ?? 'closed', since: meta?.since ?? null, why: meta?.why ?? null, received_at: meta?.received_at ?? null };
+        } else if (change.topic === 'record-row') {
+          const held = this.records[machine] ??= { stream: 'closed', record: null };
+          const record = held.record ??= { sessions: [], mail: {}, panes: null, capabilities: null, unread: {} };
+          const deleted = change.operation === 'delete';
+          if (section === 'sessions') {
+            const rows = new Map((record.sessions ?? []).map((row) => [row.address, row]));
+            const positions = this.positions.get(machine) ?? new Map();
+            this.positions.set(machine, positions);
+            if (deleted) { rows.delete(key); positions.delete(key); }
+            else { rows.set(key, change.value); positions.set(key, position); }
+            record.sessions = [...rows.values()]; moved.add(machine);
+          } else if (section === 'mail') {
+            if (deleted) delete record.mail[key]; else record.mail[key] = change.value;
+          } else record[section] = deleted ? null : change.value;
+        }
+      }
+      for (const machine of moved) {
+        const positions = this.positions.get(machine);
+        this.records[machine]?.record?.sessions?.sort((a, b) => (positions.get(a.address) ?? 0) - (positions.get(b.address) ?? 0) || a.address.localeCompare(b.address));
+      }
+      this.cursor = frame.cursor; this.ready = !frame.more;
+    } else throw new Error(`unrecognized record-view frame ${frame.type}`);
+    this.heardAt = Date.now();
+    if (this.ready) {
+      for (const waiter of this.waiters) { clearTimeout(waiter.timer); waiter.resolve(this.records); }
+      this.waiters.clear();
+    }
+  }
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@volter/supercode-orchestrator",
-  "version": "0.5.106",
+  "version": "0.5.107",
   "type": "module",
   "description": "The orchestrator runtime over the Volter Harness ontology: one typed operational model whose folder is its serialization, read and written through the harness orchestration doors (docs/ORCHESTRATOR-IR.md)",
   "exports": {