@devicechain/dashboards 0.22.0 → 0.23.0

package/dist/index.js

@@ -1615,6 +1615,19 @@ var DEVICES_FOR_ANCHOR = `
     }
   }
 `;
+var CUSTOMER_DEVICES = `
+  query DashboardCustomerDevices($criteria: CustomerDeviceSearchCriteria!) {
+    customerDevices(criteria: $criteria) {
+      results {
+        token
+        name
+      }
+      pagination {
+        totalRecords
+      }
+    }
+  }
+`;
 var DEVICES_BY_TOKEN = `
   query DashboardDevicesByToken($tokens: [String!]!) {
     devicesByToken(tokens: $tokens) {
@@ -1815,7 +1828,7 @@ var ConnectionTracker = class {
 };
 
 // src/hub.ts
-import { gql as gql2, isForbiddenError, subscribe } from "@devicechain/client";
+import { gql as gql2, isForbiddenError, isScopeUnsupportedError, subscribe } from "@devicechain/client";
 
 // src/internal/alarm-doc.ts
 var ALARMS_QUERY = `
@@ -2069,7 +2082,11 @@ var DashboardHub = class {
       sink.roster(roster);
       for (const member of roster.members) {
         detachers.push(
-          this.attach(member.token, names, { next: (sample) => sink.next(sample), error: (err) => sink.error?.(err) })
+          this.attach(member.token, names, {
+            next: (sample) => sink.next(sample),
+            error: (err) => sink.error?.(err),
+            reconnected: () => sink.reconnected?.()
+          })
         );
       }
     }).catch((err) => {
@@ -2483,6 +2500,19 @@ var DashboardHub = class {
       return true;
     }
   }
+  // isDatasourceSupported reports whether the viewer is offered the binding at all: false only
+  // when resolving an anchor is refused as SCOPE_UNSUPPORTED (an area or asset anchor, for a
+  // customer user). The resolution is the same memoized one the widget's channel makes, so a
+  // supported anchor costs no second read. Every other answer, including a failure, is true.
+  async isDatasourceSupported(datasource) {
+    if (datasource?.kind !== "anchor") return true;
+    try {
+      await this.resolver.devicesForAnchor(datasource.anchor);
+      return true;
+    } catch (err) {
+      return !isScopeUnsupportedError(err);
+    }
+  }
   // availabilityToken returns the single device token whose existence gates a widget's
   // availability, or undefined when there is nothing device-specific to validate (an
   // anchor's membership is self-validating; an unbound slot is a placeholder; a reserved
@@ -2568,14 +2598,18 @@ var DashboardHub = class {
     const open = () => {
       closeSocket = subscribe(EVENT_AREA, MEASUREMENT_STREAM, variables, adapter);
     };
+    const resumed = () => {
+      stream.subscribers.forEach((s) => s.sink.reconnected?.());
+    };
     const adapter = {
       next: (data) => {
         ended = 0;
         this.fanout(deviceToken, data.measurementStream);
       },
-      connected: () => {
+      connected: (wasRetry) => {
         up = true;
         handle.connected();
+        if (wasRetry) resumed();
       },
       closed: () => {
         up = false;
@@ -2593,7 +2627,10 @@ var DashboardHub = class {
       complete: () => {
         if (!operationOpen || !up) return;
         closeSocket?.();
-        reopen = setTimeout(open, Math.min(1e3 * 2 ** ended++, 3e4));
+        reopen = setTimeout(() => {
+          open();
+          resumed();
+        }, Math.min(1e3 * 2 ** ended++, 3e4));
       },
       error: (err) => {
         if (this.streams.get(deviceToken) === stream) this.streams.delete(deviceToken);
@@ -2940,7 +2977,8 @@ var SyntheticDataSource = class {
 };
 
 // src/recording.ts
-var RECORDING_FORMAT_VERSION = 1;
+var RECORDING_FORMAT_VERSION = 2;
+var RECORDING_FORMAT_VERSIONS = [1, 2];
 var RECORDING_KIND = "sitepulse-board-recording";
 var ALARM_STATES = ["ACTIVE", "CLEARED"];
 var ALARM_SEVERITIES = ["CRITICAL", "MAJOR", "MINOR", "WARNING"];
@@ -3076,10 +3114,11 @@ function parseBoardRecording(input) {
   if (root.kind !== RECORDING_KIND) {
     throw new RecordingFormatError("$.kind", `expected ${JSON.stringify(RECORDING_KIND)}`);
   }
-  if (root.formatVersion !== RECORDING_FORMAT_VERSION) {
+  const version = root.formatVersion;
+  if (version !== 1 && version !== 2) {
     throw new RecordingFormatError(
       "$.formatVersion",
-      `unsupported version ${JSON.stringify(root.formatVersion)}; this reader understands ${RECORDING_FORMAT_VERSION}`
+      `unsupported version ${JSON.stringify(root.formatVersion)}; this reader understands ${RECORDING_FORMAT_VERSIONS.join(", ")}`
     );
   }
   const durationMs = num2(root.durationMs, "$.durationMs");
@@ -3107,8 +3146,8 @@ function parseBoardRecording(input) {
     throw new RecordingFormatError("$.devices", "duplicate device id or token");
   }
   const ch = strict(root.channels, "$.channels", ["measurements", "alarms", "locations", "commands"]);
-  if (ch.locations !== false) {
-    throw new RecordingFormatError("$.channels.locations", "this version records no positions; must be false");
+  if (version === 1 && ch.locations !== false) {
+    throw new RecordingFormatError("$.channels.locations", "version 1 records no positions; must be false");
   }
   if (ch.commands !== false) {
     throw new RecordingFormatError("$.channels.commands", "this version records no command data; must be false");
@@ -3116,7 +3155,7 @@ function parseBoardRecording(input) {
   const channels = {
     measurements: column(ch.measurements, "$.channels.measurements", str),
     alarms: bool(ch.alarms, "$.channels.alarms"),
-    locations: false,
+    locations: bool(ch.locations, "$.channels.locations"),
     commands: false
   };
   if (new Set(channels.measurements).size !== channels.measurements.length) {
@@ -3135,8 +3174,9 @@ function parseBoardRecording(input) {
     if (key === "__proto__") throw new RecordingFormatError(`$.sourceHashes.${key}`, "reserved key");
     sourceHashes[key] = matching(sh[key], `$.sourceHashes.${key}`, HEX64, "a lowercase hex SHA-256");
   }
-  const cv = strict(root.converter, "$.converter", ["version"]);
+  const cv = strict(root.converter, "$.converter", ["version"], version >= 2 ? ["name"] : []);
   const converter = { version: num2(cv.version, "$.converter.version") };
+  if (cv.name !== void 0) converter.name = str(cv.name, "$.converter.name");
   let excerpt;
   if (root.excerpt !== void 0) {
     const e = strict(root.excerpt, "$.excerpt", ["fromMs", "toMs"]);
@@ -3158,13 +3198,17 @@ function parseBoardRecording(input) {
     if (i > 0 && c.tMs < chapters[i - 1].tMs) throw new RecordingFormatError(`$.chapters[${i}].tMs`, "chapters must not decrease in time");
   });
   const m = strict(root.measurements, "$.measurements", ["d", "n", "t", "v", "s"]);
-  const t = column(m.t, "$.measurements.t", num2);
-  let prev = lo;
-  t.forEach((x, i) => {
-    if (x < lo || x > hi) throw new RecordingFormatError(`$.measurements.t[${i}]`, `${x} is outside [${lo}, ${hi}]`);
-    if (x < prev) throw new RecordingFormatError(`$.measurements.t[${i}]`, "time column must not decrease");
-    prev = x;
-  });
+  const times = (v, path) => {
+    const col = column(v, path, num2);
+    let prev = lo;
+    col.forEach((x, i) => {
+      if (x < lo || x > hi) throw new RecordingFormatError(`${path}[${i}]`, `${x} is outside [${lo}, ${hi}]`);
+      if (x < prev) throw new RecordingFormatError(`${path}[${i}]`, "time column must not decrease");
+      prev = x;
+    });
+    return col;
+  };
+  const t = times(m.t, "$.measurements.t");
   const index = (name, limit) => (x, p) => {
     const n = num2(x, p);
     if (!Number.isInteger(n) || n < 0 || n >= limit) throw new RecordingFormatError(p, `${name} index out of range`);
@@ -3191,6 +3235,9 @@ function parseBoardRecording(input) {
     const dev = str(o.dev, `${p}.dev`);
     if (!tokens.has(dev)) throw new RecordingFormatError(`${p}.dev`, `device '${dev}' is not in $.devices`);
     if (o.ack !== void 0 && o.ack !== true) throw new RecordingFormatError(`${p}.ack`, "present only when true");
+    if (o.val !== void 0 && (typeof o.val !== "number" || !Number.isFinite(o.val))) {
+      throw new RecordingFormatError(`${p}.val`, "expected a finite number");
+    }
     const out = {
       id,
       dev,
@@ -3201,16 +3248,18 @@ function parseBoardRecording(input) {
       occ: instant(o.occ, `${p}.occ`)
     };
     if (o.ack === true) out.ack = true;
+    if (typeof o.val === "number") out.val = o.val;
     return out;
   };
   const ALARM_KEYS = ["id", "dev", "key", "metric", "state", "sev", "occ"];
+  const ALARM_OPTIONAL = version >= 2 ? ["ack", "val"] : ["ack"];
   const checkTime = (tMs, p) => {
     if (tMs < 0 || tMs > hi) throw new RecordingFormatError(p, `${tMs} is outside [0, ${hi}]`);
     return tMs;
   };
   const snapshots = column(al.snapshots, "$.alarms.snapshots", (x, p) => {
     const o = strict(x, p, ["tMs", "requestedAtMs", "total", "alarms"]);
-    const alarms = column(o.alarms, `${p}.alarms`, (a, ap) => alarm(strict(a, ap, ALARM_KEYS, ["ack"]), ap));
+    const alarms = column(o.alarms, `${p}.alarms`, (a, ap) => alarm(strict(a, ap, ALARM_KEYS, ALARM_OPTIONAL), ap));
     const ids = /* @__PURE__ */ new Set();
     alarms.forEach((a, i) => {
       if (ids.has(a.id)) throw new RecordingFormatError(`${p}.alarms[${i}].id`, `duplicate alarm ${a.id} in one snapshot`);
@@ -3227,7 +3276,7 @@ function parseBoardRecording(input) {
     return { tMs, requestedAtMs, total, alarms };
   });
   const events = column(al.events, "$.alarms.events", (x, p) => {
-    const o = strict(x, p, [...ALARM_KEYS, "tMs"], ["ack"]);
+    const o = strict(x, p, [...ALARM_KEYS, "tMs"], ALARM_OPTIONAL);
     return { ...alarm(o, p), tMs: checkTime(num2(o.tMs, `${p}.tMs`), `${p}.tMs`) };
   });
   for (const [name, list] of [["snapshots", snapshots], ["events", events]]) {
@@ -3250,12 +3299,36 @@ function parseBoardRecording(input) {
   if (!channels.alarms && (snapshots.length > 0 || events.length > 0)) {
     throw new RecordingFormatError("$.alarms", "history present but $.channels.alarms is false");
   }
-  if (!Array.isArray(root.locations) || root.locations.length !== 0) {
-    throw new RecordingFormatError("$.locations", "this version carries no positions; must be an empty array");
+  let locations;
+  if (version === 1) {
+    if (!Array.isArray(root.locations) || root.locations.length !== 0) {
+      throw new RecordingFormatError("$.locations", "version 1 carries no positions; must be an empty array");
+    }
+    locations = { d: [], t: [], lat: [], lon: [], hdg: [], spd: [] };
+  } else {
+    const lc = strict(root.locations, "$.locations", ["d", "t", "lat", "lon", "hdg", "spd"]);
+    const lt = times(lc.t, "$.locations.t");
+    const within = (min, max, what) => (x, p) => {
+      const n = num2(x, p);
+      if (n < min || n > max) throw new RecordingFormatError(p, `${what} ${n} is outside [${min}, ${max}]`);
+      return n;
+    };
+    const optional = (min, max, what) => (x, p) => x === null ? null : within(min, max, what)(x, p);
+    locations = {
+      d: column(lc.d, "$.locations.d", index("device", devices.length), lt.length),
+      t: lt,
+      lat: column(lc.lat, "$.locations.lat", within(-90, 90, "latitude"), lt.length),
+      lon: column(lc.lon, "$.locations.lon", within(-180, 180, "longitude"), lt.length),
+      hdg: column(lc.hdg, "$.locations.hdg", optional(0, 360, "heading"), lt.length),
+      spd: column(lc.spd, "$.locations.spd", optional(0, Number.MAX_VALUE, "speed"), lt.length)
+    };
+    if (!channels.locations && lt.length > 0) {
+      throw new RecordingFormatError("$.locations", "positions present but $.channels.locations is false");
+    }
   }
   const rec = {
     kind: RECORDING_KIND,
-    formatVersion: RECORDING_FORMAT_VERSION,
+    formatVersion: version,
     runId: str(root.runId, "$.runId"),
     startedAtUtc: instant(root.startedAtUtc, "$.startedAtUtc"),
     durationMs,
@@ -3272,7 +3345,7 @@ function parseBoardRecording(input) {
     chapters,
     measurements,
     alarms: { snapshots, events },
-    locations: []
+    locations
   };
   if (excerpt) rec.excerpt = excerpt;
   return rec;
@@ -3436,6 +3509,9 @@ function createRecordedClock(rec, options = {}) {
   const { fromMs, toMs } = recordingBounds(rec);
   return new RecordedClock(toMs, { minMs: fromMs, ticker: options.ticker });
 }
+function retimeShiftMs(rec, cursorMs, nowMs = Date.now()) {
+  return Math.round(nowMs - recordedWallTimeMs(rec, cursorMs));
+}
 function sameAnchor(a, b) {
   return a.relationship === b.relationship && a.targetType === b.targetType && a.targetToken === b.targetToken;
 }
@@ -3475,6 +3551,7 @@ function createRecordedLister(rec, options = {}) {
     return site && site.targetType === kind ? [{ token: site.targetToken, name: null }] : [];
   };
 }
+var loadExtra = () => import("./chunks/recorded-extra-C2BHFOCB.js");
 var indexCache = /* @__PURE__ */ new WeakMap();
 function indexOf(rec) {
   const cached = indexCache.get(rec);
@@ -3506,7 +3583,8 @@ function indexOf(rec) {
 }
 var RecordedDataSource = class {
   // `clock` is the shared replay clock; the view starts at its current time. `options`
-  // names the site anchors this recording's devices belong to (see RecordedSiteOptions).
+  // names the site anchors this recording's devices belong to (see RecordedSiteOptions)
+  // and the time shift, if any (see "Re-timing" above).
   constructor(rec, clock, options = {}) {
     this.subs = /* @__PURE__ */ new Set();
     this.stale = false;
@@ -3514,6 +3592,9 @@ var RecordedDataSource = class {
     this.site = declaredSite(options);
     this.index = indexOf(rec);
     this.cursor = clock.timeMs;
+    const shift = options.timeShiftMs ?? 0;
+    if (!Number.isFinite(shift)) throw new RangeError(`RecordedDataSource: timeShiftMs must be finite, got ${shift}`);
+    this.shiftMs = shift;
     this.startMs = Date.parse(rec.startedAtUtc);
     this.devices = new Set(rec.devices.map((d) => d.token));
     this.unlisten = clock.subscribe((ev) => this.onClock(ev));
@@ -3523,10 +3604,14 @@ var RecordedDataSource = class {
   get isStale() {
     return this.stale;
   }
-  // The recorded instant the view is at: samples are dated by the run, so a time span is measured
-  // from here, not from the wall clock.
+  // The instant the view is at: samples are dated by the run (moved by the shift, if any), so a
+  // time span is measured from here, not from the wall clock.
   now() {
-    return this.startMs + this.cursor;
+    return this.startMs + this.cursor + this.shiftMs;
+  }
+  // The shift every instant is moved by (0 for the run's own times).
+  get timeShiftMs() {
+    return this.shiftMs;
   }
   onClock(ev) {
     if (this.stale) return;
@@ -3540,7 +3625,13 @@ var RecordedDataSource = class {
     for (const sub of [...this.subs]) sub.advance(this.cursor);
   }
   iso(offsetMs) {
-    return new Date(this.startMs + offsetMs).toISOString();
+    return new Date(this.startMs + offsetMs + this.shiftMs).toISOString();
+  }
+  // A recorded instant (an alarm's raise or clear time), moved by the shift. Unshifted, the
+  // recording's own string is kept, digits and all.
+  shifted(instant2) {
+    if (instant2 === null || this.shiftMs === 0) return instant2;
+    return new Date(Date.parse(instant2) + this.shiftMs).toISOString();
   }
   // open tracks a subscription and returns its disposer. `start` runs once, in a
   // microtask, so the disposer is in the caller's hands before anything is emitted (the
@@ -3745,6 +3836,9 @@ var RecordedDataSource = class {
         // Each record's own `ack` decides; acknowledgement is not carried over from an
         // earlier record of the same alarm.
         ack: a.ack === true,
+        // The reading that raised the alarm. A cleared alarm keeps its raise's reading, as the
+        // platform's row does (a resolve carries no value).
+        val: a.val ?? (a.state === "CLEARED" ? prior?.val ?? null : null),
         asOfMs
       });
     };
@@ -3777,7 +3871,10 @@ var RecordedDataSource = class {
       const signature = JSON.stringify([matches.length, page]);
       if (signature === lastSignature || isDisposed()) return;
       lastSignature = signature;
-      const snapshot = { alarms: page.map(toAlarmRow), total: matches.length };
+      const snapshot = {
+        alarms: page.map((a) => toAlarmRow({ ...a, raised: this.shifted(a.raised), cleared: this.shifted(a.cleared) })),
+        total: matches.length
+      };
       sink.next(snapshot);
     };
     return this.open({ start: emit, advance: emit });
@@ -3788,10 +3885,14 @@ var RecordedDataSource = class {
     return this.failLater(new NotInRecordingError("commands"), sink);
   }
   // ── locations ─────────────────────────────────────────────────────────────
-  // This format version records no positions. A selector that names no location series
-  // asks for nothing, and one that resolves to no device has nothing to place: both get the
-  // empty snapshot, as from the hub. Naming a location series for devices that exist is a
-  // request for data the recording does not have, which is an error, never an empty map.
+  // A selector that names no location series asks for nothing, and one that resolves to no
+  // device has nothing to place: both get the empty snapshot, as from the hub. Naming a
+  // location series for devices that exist, on a recording with no positions, is a request
+  // for data the recording does not have, which is an error, never an empty map.
+  //
+  // With positions recorded, each snapshot is every bound device's LAST position at the
+  // cursor, as device-state answers the live map: a device not yet located is absent (the
+  // service's contract), and the snapshot is sent again whenever one of them moves on.
   subscribeLocations(subscription, sink) {
     const ds = subscription.datasource;
     let tokens = [];
@@ -3801,18 +3902,58 @@ var RecordedDataSource = class {
       } catch (err) {
         return this.failLater(err, sink);
       }
-      if (tokens.length > 0) {
+      if (tokens.length > 0 && !this.rec.channels.locations) {
         return this.failLater(new NotInRecordingError("locations", "no positions were recorded"), sink);
       }
     }
+    let extra = null;
+    let lastSignature = null;
+    const emit = (cursor, isDisposed) => {
+      if (!extra) return;
+      const { signature, locations } = extra.lastPositions(this.rec, tokens, cursor, (t) => this.iso(t));
+      if (signature === lastSignature || isDisposed()) return;
+      lastSignature = signature;
+      sink.next({ kind: "positions", deviceTokens: tokens, locations });
+    };
     return this.open({
       start: (_cursor, isDisposed) => {
-        if (!isDisposed()) sink.next({ kind: "positions", deviceTokens: [], locations: [] });
+        if (tokens.length === 0) {
+          if (!isDisposed()) sink.next({ kind: "positions", deviceTokens: [], locations: [] });
+          return;
+        }
+        loadExtra().then(
+          (m) => {
+            extra = m;
+            if (!this.stale) emit(this.cursor, isDisposed);
+          },
+          (err) => {
+            if (!isDisposed()) sink.error?.(err);
+          }
+        );
       },
-      advance: () => {
-      }
+      advance: emit
     });
   }
+  // ── aggregates ────────────────────────────────────────────────────────────
+  // The buckets a stat widget folds into a span's aggregates, computed from the recording's
+  // own rows: every (device, measurement) row whose time falls in the window AND at or
+  // before the cursor (a replay must not know what happens next), grouped into buckets
+  // `intervalSeconds` wide aligned on the epoch like the event store's, each with its exact
+  // count, minimum, maximum and sum. Like the store, a bucket that holds no reading is not
+  // returned. The window is in the source's own (shifted) time and is moved back by the
+  // shift before the rows are read, so a re-timed board aggregates the same rows.
+  async bucketMeasurements(datasource, window2) {
+    const groups = this.resolve(datasource);
+    for (const g of groups) {
+      for (const name of g.names) {
+        if (!this.rec.channels.measurements.includes(name)) {
+          throw new NotInRecordingError("measurements", `no '${name}' series was recorded`);
+        }
+      }
+    }
+    const { foldBuckets } = await loadExtra();
+    return foldBuckets(this.rec, groups, this.index.byDevice, window2, this.startMs + this.shiftMs, this.cursor);
+  }
   // ── availability ──────────────────────────────────────────────────────────
   // A device selector is available iff the run has that device. Anchors, unbound slots and
   // no datasource have a legitimate empty state and are available, as on the hub.
@@ -3841,9 +3982,10 @@ function toAlarmRow(a) {
     // The recording notes THAT an alarm was acknowledged, not when or by whom.
     acknowledgedTime: null,
     acknowledgedBy: null,
-    // The stored alarm's last value is not recorded, and a nearby measurement would
-    // invent the integrator's state. Null renders as an em dash.
-    lastValue: null
+    // The reading that raised it, as the recording holds it (recording.ts: `val`). A recording
+    // without one plays with none; a nearby measurement would invent the integrator's state.
+    // Null renders as an em dash.
+    lastValue: a.val
   };
 }
 
@@ -4575,6 +4717,39 @@ function duplicateWidget(def, id) {
 // src/resolver.ts
 import { gql as gql3 } from "@devicechain/client";
 var ANCHOR_PAGE_SIZE = 500;
+var trueSize = (reported, page) => Math.max(reported ?? page, page);
+function readAnchorPage(anchor) {
+  if (anchor.targetType === "customer") {
+    return gql3("device-management", CUSTOMER_DEVICES, {
+      criteria: {
+        pageNumber: 1,
+        pageSize: ANCHOR_PAGE_SIZE,
+        customer: anchor.targetToken,
+        relationshipType: anchor.relationship
+      }
+    }).then((r) => {
+      const rows = r.customerDevices.results;
+      return {
+        tokens: rows.map((d) => d.token),
+        total: trueSize(r.customerDevices.pagination?.totalRecords, rows.length),
+        names: new Map(rows.map((d) => [d.token, d.name]))
+      };
+    });
+  }
+  return gql3("device-management", DEVICES_FOR_ANCHOR, {
+    criteria: {
+      pageNumber: 1,
+      pageSize: ANCHOR_PAGE_SIZE,
+      sourceType: "device",
+      targetType: anchor.targetType,
+      target: anchor.targetToken,
+      relationshipType: anchor.relationship
+    }
+  }).then((r) => {
+    const tokens = r.entityRelationships.results.map((rel) => rel.source.token);
+    return { tokens, total: trueSize(r.entityRelationships.pagination?.totalRecords, tokens.length) };
+  });
+}
 function createDeviceResolver() {
   const anchorCache = /* @__PURE__ */ new Map();
   const memberCache = /* @__PURE__ */ new Map();
@@ -4586,20 +4761,7 @@ function createDeviceResolver() {
     const key = anchorKey(anchor);
     let pending = anchorCache.get(key);
     if (!pending) {
-      pending = gql3("device-management", DEVICES_FOR_ANCHOR, {
-        criteria: {
-          pageNumber: 1,
-          pageSize: ANCHOR_PAGE_SIZE,
-          sourceType: "device",
-          targetType: anchor.targetType,
-          target: anchor.targetToken,
-          relationshipType: anchor.relationship
-        }
-      }).then((r) => {
-        const tokens = r.entityRelationships.results.map((rel) => rel.source.token);
-        const total = r.entityRelationships.pagination?.totalRecords ?? tokens.length;
-        return { tokens, total: Math.max(total, tokens.length) };
-      }).catch((err) => {
+      pending = readAnchorPage(anchor).catch((err) => {
         anchorCache.delete(key);
         throw err;
       });
@@ -4611,17 +4773,17 @@ function createDeviceResolver() {
     devicesForAnchor(anchor) {
       return anchorPage(anchor).then((page) => page.tokens);
     },
-    // The members of an anchor with their names and the anchor's true size. One relationship page
-    // (shared with devicesForAnchor) plus ONE batched name read, whatever the size of the fleet. A
-    // failed name read is not a failed roster: the tokens still stream, and the widget labels
-    // them by token.
+    // The members of an anchor with their names and the anchor's true size. One page (shared with
+    // devicesForAnchor) plus, when that page carried no names, ONE batched name read, whatever the
+    // size of the fleet. A failed name read is not a failed roster: the tokens still stream, and
+    // the widget labels them by token.
     anchorMembers(anchor) {
       const key = anchorKey(anchor);
       let pending = memberCache.get(key);
       if (!pending) {
-        pending = anchorPage(anchor).then(async ({ tokens, total }) => {
-          const names = /* @__PURE__ */ new Map();
-          if (tokens.length > 0) {
+        pending = anchorPage(anchor).then(async ({ tokens, total, names: listed }) => {
+          const names = listed ?? /* @__PURE__ */ new Map();
+          if (!listed && tokens.length > 0) {
             try {
               const r = await gql3("device-management", DEVICE_NAMES, { tokens });
               for (const d of r.devicesByToken) names.set(d.token, d.name);
@@ -4672,7 +4834,7 @@ function historyWindowFor(spanSeconds, end) {
 function defaultHistoryWindow() {
   return historyWindowFor(DEFAULT_TIME_RANGE_SECONDS, Date.now());
 }
-async function fetchWidgetHistory(widget, window2) {
+async function fetchWidgetHistory(widget, window2, options = {}) {
   const ds = widget.datasource;
   if (!ds || ds.kind !== "device") return [];
   try {
@@ -4700,7 +4862,8 @@ async function fetchWidgetHistory(widget, window2) {
       value: b.avg,
       classifier: null
     })).sort((a, b) => a.occurredTime < b.occurredTime ? -1 : 1);
-  } catch {
+  } catch (err) {
+    if (options.rethrow) throw err;
     return [];
   }
 }
@@ -5457,6 +5620,7 @@ export {
   PUBLISH_BLOCKING_LAYOUT_CODES,
   RECORDED_HISTORY_WINDOW_MS,
   RECORDING_FORMAT_VERSION,
+  RECORDING_FORMAT_VERSIONS,
   RECORDING_KIND,
   RESERVED_PLACEMENT_MODES,
   RecordedClock,
@@ -5581,6 +5745,7 @@ export {
   resolveSlotCandidates,
   resolveWidgetDatasource,
   resumeRange,
+  retimeShiftMs,
   sameBinding,
   sameLabel,
   sealHistory,