@volter/supercode-orchestrator 0.5.161 → 0.5.162

package/board/record-view.mjs

@@ -1,31 +1,17 @@
 // 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) {
+  constructor(open, { progressMs = 10_000 } = {}) {
     this.open = open; this.records = {}; this.positions = new Map();
     this.cursor = null; this.stream = null; this.waiters = new Set();
+    this.pending = [];
     this.ready = false; this.heardAt = 0;
+    this.progressMs = progressMs; this.progressTimer = null;
   }
   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.stream) await this.connect();
     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) => {
@@ -37,6 +23,44 @@ export class RecordView {
       this.waiters.add(waiter);
     });
   }
+  connect() {
+    if (this.stream) return Promise.resolve();
+    return this.opening ??= Promise.resolve().then(() => this.open({ after: this.cursor })).then((stream) => {
+      this.stream = stream; this.ready = false; this.heardAt = Date.now();
+      stream.on('data', (frame) => {
+        if (this.stream !== stream) return;
+        try { this.apply(frame); }
+        catch (error) { this.fail(error); stream.close(error.message); }
+      });
+      stream.on('receive-progress', ({ bytes, type }) => {
+        if (this.stream !== stream || bytes <= 0 || (type !== 'snapshot' && type !== 'changes')) return;
+        this.heardAt = Date.now(); this.watchProgress();
+      });
+      stream.on('close', (reason) => {
+        if (this.stream !== stream) return;
+        clearTimeout(this.progressTimer); this.progressTimer = null;
+        this.stream = null; this.ready = false; this.pending = [];
+        this.fail(new Error(reason ?? 'the local record stream closed'));
+      });
+      this.watchProgress();
+    }).finally(() => { this.opening = null; });
+  }
+  // Beats prove the door is alive, not that its snapshot or unfinished page is advancing. Record frames and bytes
+  // arriving inside them renew this deadline. Expiry reopens at the applied cursor, never its held prefix.
+  watchProgress() {
+    clearTimeout(this.progressTimer); this.progressTimer = null;
+    if (this.ready || !this.stream) return;
+    const stream = this.stream;
+    this.progressTimer = setTimeout(() => {
+      if (this.stream !== stream) return;
+      this.progressTimer = null; this.stream = null; this.ready = false; this.pending = [];
+      const error = new Error('the local record stream stopped making snapshot or cursor catch-up progress');
+      this.fail(error);
+      try { stream.close(error.message); } catch { /* the failed stream is already detached */ }
+      this.connect().catch((error) => this.fail(error));
+    }, this.progressMs);
+    this.progressTimer.unref?.();
+  }
   fail(error) {
     this.failure = error;
     for (const waiter of this.waiters) { clearTimeout(waiter.timer); waiter.reject(error); }
@@ -46,13 +70,21 @@ export class RecordView {
   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();
+      this.self = frame.machine; this.records = frame.records; this.positions.clear(); this.pending = [];
       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');
+      // Row-sized transport frames belong to one logical page. Neither the applied state nor its resumable cursor
+      // advances until that page's final frame arrives; a disconnect discards the unfinished page.
+      if (frame.partial) {
+        this.ready = false; this.pending.push(...(frame.changes ?? [])); this.heardAt = Date.now();
+        if (frame.changes?.length || !this.progressTimer) this.watchProgress();
+        return;
+      }
+      const changes = this.pending.concat(frame.changes ?? []); this.pending = [];
       const moved = new Set();
-      for (const change of frame.changes ?? []) {
+      for (const change of changes) {
         if (change.sequence <= this.cursor.sequence || !this.own(change.key)) continue;
         const { machine, section, key, position } = change.key;
         if (change.topic === 'record-head') {
@@ -85,6 +117,7 @@ export class RecordView {
       this.cursor = frame.cursor; this.ready = !frame.more;
     } else throw new Error(`unrecognized record-view frame ${frame.type}`);
     this.heardAt = Date.now();
+    this.watchProgress();
     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.161",
+  "version": "0.5.162",
   "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": {
@@ -25,7 +25,7 @@
   },
   "dependencies": {
     "@volter/supercode-harness-sdk": "^0.3.98",
-    "@volter/teams": "0.2.65",
+    "@volter/teams": "0.2.66",
     "@volter/ztrack": "^2.4.23",
     "yaml": "^2.9.0"
   },