@devicechain/dashboards 0.26.0 → 0.27.0

package/dist/index.js

@@ -845,12 +845,21 @@ function parseSlots(raw) {
     if (binding) slot.defaultBinding = binding;
     const scope = parseScope(spec.scope);
     if (scope) slot.scope = scope;
+    const candidates = parseCandidates(spec.candidates);
+    if (candidates) slot.candidates = candidates;
     slots[name] = slot;
   }
   if (Object.keys(slots).length === 0) return void 0;
   validateScopes(slots);
   return slots;
 }
+function parseCandidates(raw) {
+  if (!isRecord(raw)) return void 0;
+  const token = (v) => typeof v === "string" && v ? v : void 0;
+  const areaType = token(raw.areaType);
+  const assetType = token(raw.assetType);
+  return areaType || assetType ? { areaType, assetType } : void 0;
+}
 function parseScope(raw) {
   if (!isRecord(raw)) return void 0;
   const parent = typeof raw.parent === "string" ? raw.parent : "";
@@ -1371,10 +1380,78 @@ function resolveWidgetDatasource(datasource, bindings) {
   return { kind: "unbound", ...series };
 }
 
-// src/context.ts
+// src/candidates.ts
 function ownGet(map, key) {
   return map && Object.prototype.hasOwnProperty.call(map, key) ? map[key] : void 0;
 }
+function sameBinding(a, b) {
+  if (!a) return false;
+  if (a.kind === "device" && b.kind === "device") return a.deviceToken === b.deviceToken;
+  if (a.kind === "anchor" && b.kind === "anchor") return a.anchor.targetToken === b.anchor.targetToken;
+  return false;
+}
+var listEntities = (lister, kind, typeToken) => lister(kind, typeToken);
+function slotTypeFilter(def, targetType) {
+  return targetType === "customer" ? void 0 : def.candidates?.[targetType === "area" ? "areaType" : "assetType"];
+}
+async function resolveSlotCandidates(definition, slot, bindings, resolver, lister) {
+  const slots = definition.slots ?? {};
+  const def = ownGet(slots, slot);
+  if (!def) return [];
+  const current = ownGet(bindings, slot);
+  const mark = (binding, label) => ({
+    binding,
+    label,
+    selected: sameBinding(current, binding)
+  });
+  if (def.scope) {
+    if (def.scope.strategy === "first") return [];
+    const parentBinding = ownGet(bindings, def.scope.parent);
+    if (!parentBinding || parentBinding.kind !== "anchor") return [];
+    let members;
+    try {
+      members = [...await resolver.devicesForAnchor(parentBinding.anchor)].sort();
+    } catch {
+      return [];
+    }
+    return members.map((token) => mark({ kind: "device", deviceToken: token }, token));
+  }
+  if (def.type === "device") {
+    let rows2;
+    try {
+      rows2 = await lister("device");
+    } catch {
+      return [];
+    }
+    return rows2.map((r) => mark({ kind: "device", deviceToken: r.token }, r.name || r.token));
+  }
+  const template = current?.kind === "anchor" ? current.anchor : def.defaultBinding?.kind === "anchor" ? def.defaultBinding.anchor : void 0;
+  if (!template) return [];
+  let rows;
+  try {
+    rows = await listEntities(lister, template.targetType, slotTypeFilter(def, template.targetType));
+  } catch {
+    return [];
+  }
+  return rows.map(
+    (r) => mark(
+      {
+        kind: "anchor",
+        anchor: {
+          relationship: template.relationship,
+          targetType: template.targetType,
+          targetToken: r.token
+        }
+      },
+      r.name || r.token
+    )
+  );
+}
+
+// src/context.ts
+function ownGet2(map, key) {
+  return map && Object.prototype.hasOwnProperty.call(map, key) ? map[key] : void 0;
+}
 function setBinding(map, key, value) {
   if (key === "__proto__") return;
   map[key] = value;
@@ -1390,7 +1467,7 @@ function bindingsWithoutScopedSlots(definition, map) {
   if (!slots) return map;
   const out = {};
   for (const name of Object.keys(map)) {
-    if (!ownGet(slots, name)?.scope) setBinding(out, name, map[name]);
+    if (!ownGet2(slots, name)?.scope) setBinding(out, name, map[name]);
   }
   return out;
 }
@@ -1402,7 +1479,7 @@ function topoOrder(slots) {
   const done = /* @__PURE__ */ new Set();
   const visit = (name, stack) => {
     if (done.has(name) || stack.has(name)) return;
-    const slot = ownGet(slots, name);
+    const slot = ownGet2(slots, name);
     if (!slot) return;
     stack.add(name);
     const parent = slot.scope?.parent;
@@ -1418,16 +1495,16 @@ async function resolveContextBindings(definition, base, overlay, resolver) {
   const slots = definition.slots ?? {};
   const out = {};
   for (const name of topoOrder(slots)) {
-    const slot = ownGet(slots, name);
+    const slot = ownGet2(slots, name);
     const scope = slot?.scope;
     if (!scope) {
-      const sel = ownGet(overlay, name);
-      const b = sel && (!slot || bindingMatchesType(sel, slot.type)) ? sel : ownGet(base, name);
+      const sel = ownGet2(overlay, name);
+      const b = sel && (!slot || bindingMatchesType(sel, slot.type)) ? sel : ownGet2(base, name);
       if (b) setBinding(out, name, b);
       continue;
     }
     if (slot && slot.type !== "device") continue;
-    const parentBinding = ownGet(out, scope.parent);
+    const parentBinding = ownGet2(out, scope.parent);
     if (!parentBinding || parentBinding.kind !== "anchor") continue;
     let members;
     try {
@@ -1438,7 +1515,7 @@ async function resolveContextBindings(definition, base, overlay, resolver) {
     if (scope.strategy === "first") {
       if (members.length > 0) setBinding(out, name, { kind: "device", deviceToken: members[0] });
     } else {
-      const pick = ownGet(overlay, name) ?? ownGet(base, name);
+      const pick = ownGet2(overlay, name) ?? ownGet2(base, name);
       if (pick && pick.kind === "device" && members.includes(pick.deviceToken)) setBinding(out, name, pick);
     }
   }
@@ -1446,7 +1523,7 @@ async function resolveContextBindings(definition, base, overlay, resolver) {
     if (Object.prototype.hasOwnProperty.call(slots, name) || Object.prototype.hasOwnProperty.call(out, name)) {
       continue;
     }
-    const b = ownGet(overlay, name) ?? ownGet(base, name);
+    const b = ownGet2(overlay, name) ?? ownGet2(base, name);
     if (b) setBinding(out, name, b);
   }
   return out;
@@ -1455,6 +1532,36 @@ function bindingMatchesType(binding, type) {
   return binding.kind === type;
 }
 
+// src/viewer-bindings.ts
+var ownGet3 = (map, key) => Object.prototype.hasOwnProperty.call(map, key) ? map[key] : void 0;
+function hasRootAnchorSlots(definition) {
+  return Object.values(definition.slots ?? {}).some((s) => s.type === "anchor" && !s.scope);
+}
+async function resolveViewerBindings(definition, base, overlay, resolver, lister) {
+  const slots = definition.slots ?? {};
+  let corrected = { ...overlay };
+  if (lister) {
+    for (const name of Object.keys(slots)) {
+      const slot = slots[name];
+      if (slot.type !== "anchor" || slot.scope) continue;
+      const picked = ownGet3(overlay, name);
+      const binding = picked?.kind === "anchor" ? picked : ownGet3(base, name);
+      if (binding?.kind !== "anchor") continue;
+      const { targetType, targetToken } = binding.anchor;
+      let rows;
+      try {
+        rows = await listEntities(lister, targetType, slotTypeFilter(slot, targetType));
+      } catch {
+        continue;
+      }
+      if (rows.length > 0 && !rows.some((r) => r.token === targetToken)) {
+        corrected = { ...corrected, [name]: { kind: "anchor", anchor: { ...binding.anchor, targetToken: rows[0].token } } };
+      }
+    }
+  }
+  return resolveContextBindings(definition, base, corrected, resolver);
+}
+
 // src/deep-link.ts
 import { isValidToken } from "@devicechain/client";
 var BIND_PARAM_PREFIX = "bind.";
@@ -1534,7 +1641,7 @@ function bindParamsOf(search) {
 function slotSelector(slot, measurements, location) {
   return location ? { kind: "slot", slot, measurements, location } : { kind: "slot", slot, measurements };
 }
-function sameBinding(a, b) {
+function sameBinding2(a, b) {
   if (!a || !b) return a === b;
   if (a.kind === "device" && b.kind === "device") return a.deviceToken === b.deviceToken;
   if (a.kind === "anchor" && b.kind === "anchor") {
@@ -1558,7 +1665,7 @@ function bindingOfSelector(ds) {
   return void 0;
 }
 function findOrAddSlot(slots, binding) {
-  const existing = Object.keys(slots).find((k) => !slots[k].scope && sameBinding(slots[k].defaultBinding, binding));
+  const existing = Object.keys(slots).find((k) => !slots[k].scope && sameBinding2(slots[k].defaultBinding, binding));
   if (existing) return existing;
   const name = nextSlotName(slots);
   slots[name] = { type: binding.kind, label: bindingLabel(binding), defaultBinding: binding };
@@ -1584,7 +1691,7 @@ function bindWidgetSlot(def, widgetId, binding, measurements, location) {
   const current = def.widgets.find((w) => w.id === widgetId)?.datasource;
   const currentSlot = current?.kind === "slot" ? current.slot : void 0;
   const currentDef = currentSlot ? slots[currentSlot] : void 0;
-  const slot = currentSlot && currentDef && (currentDef.scope || sameBinding(currentDef.defaultBinding, binding)) ? currentSlot : findOrAddSlot(slots, binding);
+  const slot = currentSlot && currentDef && (currentDef.scope || sameBinding2(currentDef.defaultBinding, binding)) ? currentSlot : findOrAddSlot(slots, binding);
   const widgets = def.widgets.map(
     (w) => (
       // A placeholder for an unknown widget type binds nothing this build can see, so it is
@@ -1660,6 +1767,17 @@ function setSlotScope(def, slotName, scope) {
   slots[slotName] = { ...current, scope: { parent: scope.parent, strategy: scope.strategy } };
   return { ...def, slots };
 }
+function setSlotCandidates(def, slotName, candidates) {
+  if (!def.slots || !Object.prototype.hasOwnProperty.call(def.slots, slotName)) return def;
+  const current = def.slots[slotName];
+  if (current.type !== "anchor" || current.scope) return def;
+  const next = {};
+  if (candidates?.areaType) next.areaType = candidates.areaType;
+  if (candidates?.assetType) next.assetType = candidates.assetType;
+  const { candidates: _drop, ...rest } = current;
+  const slot = next.areaType || next.assetType ? { ...rest, candidates: next } : rest;
+  return { ...def, slots: { ...def.slots, [slotName]: slot } };
+}
 function widgetBinding(def, widget) {
   const ds = widget.datasource;
   if (ds?.kind === "slot") return def.slots?.[ds.slot]?.defaultBinding;
@@ -1682,88 +1800,10 @@ function resolveConcrete(def, widget) {
   return binding.kind === "device" ? { kind: "device", deviceToken: binding.deviceToken, ...base } : { kind: "anchor", anchor: binding.anchor, ...base };
 }
 
-// src/candidates.ts
-function ownGet2(map, key) {
-  return map && Object.prototype.hasOwnProperty.call(map, key) ? map[key] : void 0;
-}
-function sameBinding2(a, b) {
-  if (!a) return false;
-  if (a.kind === "device" && b.kind === "device") return a.deviceToken === b.deviceToken;
-  if (a.kind === "anchor" && b.kind === "anchor") return a.anchor.targetToken === b.anchor.targetToken;
-  return false;
-}
-async function resolveSlotCandidates(definition, slot, bindings, resolver, lister) {
-  const slots = definition.slots ?? {};
-  const def = ownGet2(slots, slot);
-  if (!def) return [];
-  const current = ownGet2(bindings, slot);
-  const mark = (binding, label) => ({
-    binding,
-    label,
-    selected: sameBinding2(current, binding)
-  });
-  if (def.scope) {
-    if (def.scope.strategy === "first") return [];
-    const parentBinding = ownGet2(bindings, def.scope.parent);
-    if (!parentBinding || parentBinding.kind !== "anchor") return [];
-    let members;
-    try {
-      members = [...await resolver.devicesForAnchor(parentBinding.anchor)].sort();
-    } catch {
-      return [];
-    }
-    return members.map((token) => mark({ kind: "device", deviceToken: token }, token));
-  }
-  if (def.type === "device") {
-    let rows2;
-    try {
-      rows2 = await lister("device");
-    } catch {
-      return [];
-    }
-    return rows2.map((r) => mark({ kind: "device", deviceToken: r.token }, r.name || r.token));
-  }
-  const template = current?.kind === "anchor" ? current.anchor : def.defaultBinding?.kind === "anchor" ? def.defaultBinding.anchor : void 0;
-  if (!template) return [];
-  let rows;
-  try {
-    rows = await lister(template.targetType);
-  } catch {
-    return [];
-  }
-  return rows.map(
-    (r) => mark(
-      {
-        kind: "anchor",
-        anchor: {
-          relationship: template.relationship,
-          targetType: template.targetType,
-          targetToken: r.token
-        }
-      },
-      r.name || r.token
-    )
-  );
-}
-
 // src/entity-lister.ts
 import { gql } from "@devicechain/client";
 
 // src/queries.ts
-var DEVICES_FOR_ANCHOR = `
-  query DevicesForAnchor($criteria: EntityRelationshipSearchCriteria!) {
-    entityRelationships(criteria: $criteria) {
-      results {
-        source {
-          token
-        }
-      }
-      pagination {
-        totalRecords
-      }
-    }
-  }
-`;
 var CUSTOMER_DEVICES = `
   query DashboardCustomerDevices($criteria: CustomerDeviceSearchCriteria!) {
     customerDevices(criteria: $criteria) {
@@ -1780,6 +1820,7 @@ var CUSTOMER_DEVICES = `
     }
   }
 `;
+var ANCHOR_DEVICES = "query DashboardAnchorDevices($criteria: AnchorDeviceSearchCriteria!){anchorDevices(criteria:$criteria){results{token name deviceType{token}}pagination{totalRecords}}}";
 var DEVICES_BY_TOKEN = `
   query DashboardDevicesByToken($tokens: [String!]!) {
     devicesByToken(tokens: $tokens) {
@@ -1871,28 +1912,29 @@ var LIST_PAGE_SIZE = 500;
 function createEntityLister() {
   const cache = /* @__PURE__ */ new Map();
   const criteria = { pageNumber: 1, pageSize: LIST_PAGE_SIZE };
-  return (kind) => {
-    let pending = cache.get(kind);
+  return (kind, typeToken) => {
+    const key = `${kind}|${typeToken}`;
+    let pending = cache.get(key);
     if (!pending) {
-      pending = fetchKind(kind, criteria).catch((err) => {
-        cache.delete(kind);
+      pending = fetchKind(kind, criteria, typeToken).catch((err) => {
+        cache.delete(key);
         throw err;
       });
-      cache.set(kind, pending);
+      cache.set(key, pending);
     }
     return pending;
   };
 }
-function fetchKind(kind, criteria) {
+function fetchKind(kind, criteria, typeToken) {
   switch (kind) {
     case "device":
       return gql("device-management", LIST_DEVICES, { criteria }).then((r) => r.devices.results);
     case "customer":
       return gql("device-management", LIST_CUSTOMERS, { criteria }).then((r) => r.customers.results);
     case "area":
-      return gql("device-management", LIST_AREAS, { criteria }).then((r) => r.areas.results);
+      return gql("device-management", LIST_AREAS, { criteria: { ...criteria, areaTypeToken: typeToken } }).then((r) => r.areas.results);
     case "asset":
-      return gql("device-management", LIST_ASSETS, { criteria }).then((r) => r.assets.results);
+      return gql("device-management", LIST_ASSETS, { criteria: { ...criteria, assetTypeToken: typeToken } }).then((r) => r.assets.results);
     default:
       return Promise.resolve([]);
   }
@@ -2090,6 +2132,7 @@ var ALARM_STREAM = `
     $state: String
     $severity: String
     $alarmKey: String
+    $anchor: AlarmAnchor
   ) {
     alarmStream(
       originatorType: $originatorType
@@ -2097,6 +2140,7 @@ var ALARM_STREAM = `
       state: $state
       severity: $severity
       alarmKey: $alarmKey
+      anchor: $anchor
     ) {
       alarmToken
       eventType
@@ -2243,6 +2287,7 @@ var COMMAND_POLL_MS = 4e3;
 var LOCATION_POLL_MS = 15e3;
 var PRESENCE_POLL_MS = 15e3;
 var PRESENCE_CHUNK = 1e3;
+var STAMPED = /* @__PURE__ */ new Set(["customer", "area", "asset"]);
 var DashboardHub = class {
   constructor(config) {
     // Per alarm-subscription reconcile triggers — invoked after an ack/clear so the
@@ -2469,9 +2514,9 @@ var DashboardHub = class {
       this.alarmDisposers.delete(dispose);
     };
     this.alarmDisposers.add(dispose);
-    const reconcile = (tokens, tenantWide) => {
+    const reconcile = (scope) => {
       const gen = ++generation;
-      this.queryAlarms(subscription, tokens, tenantWide).then((snapshot) => {
+      this.queryAlarms(subscription, scope).then((snapshot) => {
         if (!disposed && gen === generation) sink.next(snapshot);
       }).catch((err) => {
         if (!disposed && gen === generation) sink.error?.(err);
@@ -2479,32 +2524,32 @@ var DashboardHub = class {
     };
     this.resolveAlarmScope(subscription.datasource).then((scope) => {
       if (disposed) return;
-      if (!scope.tenantWide && scope.tokens.length === 0) {
+      if (!scope.tenantWide && !scope.anchor && scope.tokens.length === 0) {
         sink.next({ alarms: [], total: 0 });
         return;
       }
       const trigger = () => {
         if (debounce) clearTimeout(debounce);
-        debounce = setTimeout(() => reconcile(scope.tokens, scope.tenantWide), ALARM_RECONCILE_DEBOUNCE_MS);
+        debounce = setTimeout(() => reconcile(scope), ALARM_RECONCILE_DEBOUNCE_MS);
       };
       const handle = this.connection.register();
       const adapter = {
         next: () => trigger(),
         connected: (wasRetry) => {
           handle.connected();
-          if (wasRetry) reconcile(scope.tokens, scope.tenantWide);
+          if (wasRetry) reconcile(scope);
         },
         closed: () => handle.closed()
       };
-      const closeSocket = subscribe(DEVICE_AREA, ALARM_STREAM, {}, adapter);
+      const closeSocket = subscribe(DEVICE_AREA, ALARM_STREAM, { anchor: scope.anchor }, adapter);
       unsubscribe = () => {
         handle.release();
         closeSocket();
       };
-      poll = setInterval(() => reconcile(scope.tokens, scope.tenantWide), ALARM_POLL_MS);
-      reconciler = () => reconcile(scope.tokens, scope.tenantWide);
+      poll = setInterval(() => reconcile(scope), ALARM_POLL_MS);
+      reconciler = () => reconcile(scope);
       this.alarmReconcilers.add(reconciler);
-      reconcile(scope.tokens, scope.tenantWide);
+      reconcile(scope);
     }).catch((err) => {
       if (!disposed) sink.error?.(err);
     });
@@ -2518,6 +2563,9 @@ var DashboardHub = class {
   // it resolves to zero devices like any other empty scope.
   async resolveAlarmScope(datasource) {
     if (!datasource) return { tenantWide: true, tokens: [] };
+    if (datasource.kind === "anchor" && datasource.anchor.relationship === "assigned" && STAMPED.has(datasource.anchor.targetType)) {
+      return { tenantWide: false, tokens: [], anchor: { type: datasource.anchor.targetType, token: datasource.anchor.targetToken } };
+    }
     const groups = await this.resolveDevices(datasource);
     return { tenantWide: false, tokens: groups.map((g) => g.deviceToken) };
   }
@@ -2525,13 +2573,13 @@ var DashboardHub = class {
   // runs one query per originator device (the alarms query filters a single originator)
   // and merges — deduped by token, newest first, capped to pageSize; total is the sum of
   // per-originator match counts.
-  async queryAlarms(sub, tokens, tenantWide) {
+  async queryAlarms(sub, { tenantWide, tokens, anchor }) {
     const filters = {
       state: sub.state ?? null,
       severity: sub.severity ?? null,
       acknowledged: sub.acknowledged ?? null
     };
-    const originators = tenantWide ? [{ originatorType: null, originator: null }] : tokens.map((token) => ({ originatorType: "device", originator: token }));
+    const originators = tenantWide || anchor ? [{ originatorType: null, originator: null, anchor }] : tokens.map((token) => ({ originatorType: "device", originator: token }));
     if (sub.countBySeverity) {
       const pages2 = await Promise.all(
         originators.map(
@@ -2889,9 +2937,9 @@ var DashboardHub = class {
     }
   }
   // 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.
+  // when resolving an anchor is refused as SCOPE_UNSUPPORTED (an anchor the platform still
+  // declines for a customer user; areas and assets are answered through anchorDevices). 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 {
@@ -3576,7 +3624,7 @@ function parseBoardRecording(input) {
       "alarms",
       "locations"
     ],
-    ["excerpt", "declaredMetrics"]
+    ["excerpt", "declaredMetrics", "anchors"]
   );
   if (root.kind !== RECORDING_KIND) {
     throw new RecordingFormatError("$.kind", `expected ${JSON.stringify(RECORDING_KIND)}`);
@@ -3628,6 +3676,33 @@ function parseBoardRecording(input) {
       declaredMetrics[kind] = names;
     }
   }
+  let anchors;
+  if (root.anchors !== void 0) {
+    if (version === 1) throw new RecordingFormatError("$.anchors", "version 1 carries no anchors");
+    const listed = column(root.anchors, "$.anchors", (x, p) => {
+      const o = strict(x, p, ["relationship", "targetType", "targetToken", "devices"]);
+      const members = column(o.devices, `${p}.devices`, str);
+      if (members.length === 0) throw new RecordingFormatError(`${p}.devices`, "has no member; leave the anchor out instead");
+      if (new Set(members).size !== members.length) throw new RecordingFormatError(`${p}.devices`, "duplicate member");
+      for (const m2 of members) {
+        if (!tokens.has(m2)) throw new RecordingFormatError(`${p}.devices`, `'${m2}' is not a device of the run`);
+      }
+      return {
+        relationship: str(o.relationship, `${p}.relationship`),
+        targetType: oneOf2(o.targetType, `${p}.targetType`, ["customer", "area", "asset"]),
+        targetToken: str(o.targetToken, `${p}.targetToken`),
+        devices: members
+      };
+    });
+    if (listed.length === 0) throw new RecordingFormatError("$.anchors", "declares nothing; leave it out instead");
+    const seen = /* @__PURE__ */ new Set();
+    listed.forEach((a, i) => {
+      const key = `${a.relationship}\0${a.targetType}\0${a.targetToken}`;
+      if (seen.has(key)) throw new RecordingFormatError(`$.anchors[${i}]`, "the same anchor is declared twice");
+      seen.add(key);
+    });
+    anchors = listed;
+  }
   const ch = strict(root.channels, "$.channels", ["measurements", "alarms", "locations", "commands"]);
   if (version === 1 && ch.locations !== false) {
     throw new RecordingFormatError("$.channels.locations", "version 1 records no positions; must be false");
@@ -3832,6 +3907,7 @@ function parseBoardRecording(input) {
   };
   if (excerpt) rec.excerpt = excerpt;
   if (declaredMetrics) rec.declaredMetrics = declaredMetrics;
+  if (anchors) rec.anchors = anchors;
   return rec;
 }
 
@@ -3999,7 +4075,8 @@ function retimeShiftMs(rec, cursorMs, nowMs = Date.now()) {
 function sameAnchor(a, b) {
   return a.relationship === b.relationship && a.targetType === b.targetType && a.targetToken === b.targetToken;
 }
-function declaredSite(options) {
+function declaredSite(options, rec) {
+  if (rec?.anchors) return null;
   const anchors = options.siteAnchors;
   if (anchors === void 0) return null;
   if (anchors.length !== 1) {
@@ -4012,7 +4089,17 @@ function declaredSite(options) {
   }
   return anchors[0];
 }
+function recordedMembers(rec, anchor) {
+  if (!rec.anchors) return null;
+  const hit = rec.anchors.find((a) => sameAnchor(a, anchor));
+  if (!hit) {
+    throw new Error(`anchor ${anchor.targetType} '${anchor.targetToken}' (${anchor.relationship}) is not in this recording`);
+  }
+  return hit.devices;
+}
 function anchorMembers(rec, site, anchor) {
+  const own2 = recordedMembers(rec, anchor);
+  if (own2) return own2;
   if (!site || !sameAnchor(site, anchor)) {
     throw new Error(
       `anchor ${anchor.targetType} '${anchor.targetToken}' (${anchor.relationship}) is not in this recording`
@@ -4022,16 +4109,17 @@ function anchorMembers(rec, site, anchor) {
 }
 function createRecordedResolver(rec, options = {}) {
   const devices = new Set(rec.devices.map((d) => d.token));
-  const site = declaredSite(options);
+  const site = declaredSite(options, rec);
   return {
     devicesForAnchor: async (anchor) => anchorMembers(rec, site, anchor),
     deviceExists: async (token) => devices.has(token)
   };
 }
 function createRecordedLister(rec, options = {}) {
-  const site = declaredSite(options);
+  const site = declaredSite(options, rec);
   return async (kind) => {
     if (kind === "device") return rec.devices.map((d) => ({ token: d.token, name: null }));
+    if (rec.anchors) return rec.anchors.filter((a) => a.targetType === kind).map((a) => ({ token: a.targetToken, name: null }));
     return site && site.targetType === kind ? [{ token: site.targetToken, name: null }] : [];
   };
 }
@@ -4073,7 +4161,7 @@ var RecordedDataSource = class {
     this.subs = /* @__PURE__ */ new Set();
     this.stale = false;
     this.rec = rec;
-    this.site = declaredSite(options);
+    this.site = declaredSite(options, rec);
     this.index = indexOf(rec);
     this.cursor = clock.timeMs;
     const shift = options.timeShiftMs ?? 0;
@@ -5169,7 +5257,7 @@ function pasteWidgets(def, clip, at) {
     if (known) return known;
     const source = own(clip.slots, from);
     const target = own(slots, from);
-    const keep = sameTenant && target !== void 0 && source !== void 0 && target.type === source.type && (sameBoard || sameBinding(target.defaultBinding, source.defaultBinding));
+    const keep = sameTenant && target !== void 0 && source !== void 0 && target.type === source.type && (sameBoard || sameBinding2(target.defaultBinding, source.defaultBinding));
     let result;
     if (keep) result = { slot: from };
     else {
@@ -5231,7 +5319,7 @@ function duplicateWidget(def, id) {
 }
 
 // src/resolver.ts
-import { gql as gql3 } from "@devicechain/client";
+import { gql as gql3, isScopeUnsupportedError as isScopeUnsupportedError2 } from "@devicechain/client";
 var ANCHOR_PAGE_SIZE = 500;
 var DECLARED_BATCH_SIZE = 100;
 var trueSize = (reported, page) => Math.max(reported ?? page, page);
@@ -5254,18 +5342,29 @@ function readAnchorPage(anchor) {
       };
     });
   }
-  return gql3("device-management", DEVICES_FOR_ANCHOR, {
+  return readAreaOrAssetPage(anchor);
+}
+function readAreaOrAssetPage(anchor) {
+  const read = (relationshipType) => gql3("device-management", ANCHOR_DEVICES, {
     criteria: {
       pageNumber: 1,
       pageSize: ANCHOR_PAGE_SIZE,
-      sourceType: "device",
       targetType: anchor.targetType,
       target: anchor.targetToken,
-      relationshipType: anchor.relationship
+      relationshipType
     }
+  });
+  return read(anchor.relationship).catch((err) => {
+    if (!isScopeUnsupportedError2(err)) throw err;
+    return read();
   }).then((r) => {
-    const tokens = r.entityRelationships.results.map((rel) => rel.source.token);
-    return { tokens, total: trueSize(r.entityRelationships.pagination?.totalRecords, tokens.length) };
+    const rows = r.anchorDevices.results;
+    return {
+      tokens: rows.map((d) => d.token),
+      total: trueSize(r.anchorDevices.pagination?.totalRecords, rows.length),
+      names: new Map(rows.map((d) => [d.token, d.name])),
+      types: new Map(rows.map((d) => [d.token, d.deviceType?.token ?? null]))
+    };
   });
 }
 function createDeviceResolver() {
@@ -5293,29 +5392,16 @@ 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 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.
+    // The members of an anchor with their names and the anchor's true size: ONE page, shared with
+    // devicesForAnchor, which carries every member's name and device type.
     anchorMembers(anchor) {
       const key = anchorKey(anchor);
       let pending = memberCache.get(key);
       if (!pending) {
-        pending = anchorPage(anchor).then(async ({ tokens, total, names: listed, types: listedTypes }) => {
-          const names = listed ?? /* @__PURE__ */ new Map();
-          const types = listedTypes ?? /* @__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);
-                types.set(d.token, d.deviceType?.token ?? null);
-              }
-            } catch {
-            }
-          }
-          return { members: tokens.map((token) => ({ token, name: names.get(token) ?? null, deviceType: types.get(token) ?? null })), total };
-        }).catch((err) => {
+        pending = anchorPage(anchor).then(({ tokens, total, names, types }) => ({
+          members: tokens.map((token) => ({ token, name: names.get(token) ?? null, deviceType: types.get(token) ?? null })),
+          total
+        })).catch((err) => {
           memberCache.delete(key);
           throw err;
         });
@@ -6294,6 +6380,7 @@ export {
   gridPlacementToPx,
   gridRect,
   gutterPx,
+  hasRootAnchorSlots,
   hasScopedSlots,
   historyWindowFor,
   initialTimeRange,
@@ -6353,10 +6440,11 @@ export {
   resolveFrame,
   resolvePlacement,
   resolveSlotCandidates,
+  resolveViewerBindings,
   resolveWidgetDatasource,
   resumeRange,
   retimeShiftMs,
-  sameBinding,
+  sameBinding2 as sameBinding,
   sameLabel,
   sealHistory,
   seedBucketCount,
@@ -6369,6 +6457,7 @@ export {
   setCanvasSizing,
   setRelativeAnchor,
   setRelativeOffset,
+  setSlotCandidates,
   setSlotScope,
   setTitle,
   setWidgetPlacement,