@devicechain/dashboards 0.14.0-0

package/dist/index.js

@@ -0,0 +1,1910 @@
+// src/command-status.ts
+var COMMAND_STATUSES = [
+  // ── Non-terminal ───────────────────────────────────────────────────────
+  // Accepted; awaiting its first dispatch decision. Genuinely transient.
+  "QUEUED",
+  // The platform is deliberately WITHHOLDING dispatch because the device is known
+  // absent. This is where an offline fleet's backlog accumulates — it can sit for days,
+  // and it is the honest answer to "why hasn't my command arrived?".
+  "HELD",
+  // Dispatched toward a device believed reachable; awaiting its response.
+  "SENT",
+  // Published, and it went NOWHERE: the device turned out not to be reachable, so the
+  // transport had nothing to hand it to. The platform still holds the command and will
+  // deliver it when the device next wakes. Distinct from HELD (where dispatch was never
+  // attempted, because the device was already known absent) and from TIMEOUT (where the
+  // command reached a device that then said nothing).
+  "PARKED",
+  // ── Terminal ───────────────────────────────────────────────────────────
+  // The device answered.
+  "SUCCESSFUL",
+  "FAILED",
+  // Dispatched, never answered in time.
+  "TIMEOUT",
+  // The TTL elapsed before it ever went out.
+  "EXPIRED",
+  // An operator or tenant called it off. Distinct from EXPIRED because it is a
+  // different ACTOR, not a different outcome. Cancellation used to write EXPIRED, so
+  // BOTH values appear in real data — historical rows are not backfilled.
+  "CANCELLED"
+];
+var TERMINAL_COMMAND_STATUSES = /* @__PURE__ */ new Set([
+  "SUCCESSFUL",
+  "FAILED",
+  "TIMEOUT",
+  "EXPIRED",
+  "CANCELLED"
+]);
+var CANCELLABLE_COMMAND_STATUSES = /* @__PURE__ */ new Set([
+  "QUEUED",
+  "HELD",
+  "PARKED"
+]);
+function isTerminalCommandStatus(status) {
+  return TERMINAL_COMMAND_STATUSES.has(status);
+}
+function isCancellableCommandStatus(status) {
+  return CANCELLABLE_COMMAND_STATUSES.has(status);
+}
+
+// src/types.ts
+var WIDGET_TYPES = [
+  "timeseries-chart",
+  "latest-card",
+  "gauge",
+  "table",
+  "label",
+  "image",
+  "alarm-table",
+  "alarm-count",
+  "command-button",
+  "entity-selector",
+  "map"
+];
+
+// src/definition.ts
+var BASE_BREAKPOINT = "base";
+var WIDGET_TYPE_SET = new Set(WIDGET_TYPES);
+var DEFAULT_GRID = { columns: 24, gap: 8, rowHeight: 40 };
+var DEFAULT_SIZING = "fill";
+var DashboardDefinitionError = class extends Error {
+  constructor(message) {
+    super(`invalid dashboard definition: ${message}`);
+    this.name = "DashboardDefinitionError";
+  }
+};
+function isRecord(v) {
+  return typeof v === "object" && v !== null && !Array.isArray(v);
+}
+function numberAt(rec, key, fallback) {
+  const v = rec[key];
+  return typeof v === "number" && Number.isFinite(v) ? v : fallback;
+}
+function parseDashboardDefinition(raw) {
+  if (!isRecord(raw)) throw new DashboardDefinitionError("not a JSON object");
+  const widgetsRaw = raw.widgets;
+  if (!Array.isArray(widgetsRaw)) throw new DashboardDefinitionError("widgets must be an array");
+  const def = {
+    schemaVersion: numberAt(raw, "schemaVersion", 1),
+    title: typeof raw.title === "string" ? raw.title : "",
+    canvas: parseCanvas(raw.canvas),
+    widgets: widgetsRaw.map((w, i) => parseWidget(w, i))
+  };
+  const slots = parseSlots(raw.slots);
+  if (slots) def.slots = slots;
+  return def;
+}
+function parseSlots(raw) {
+  if (!isRecord(raw)) return void 0;
+  const slots = {};
+  for (const [name, spec] of Object.entries(raw)) {
+    if (name === "__proto__") continue;
+    if (!isRecord(spec)) continue;
+    const type = spec.type === "anchor" ? "anchor" : "device";
+    const slot = { type };
+    if (typeof spec.label === "string") slot.label = spec.label;
+    const binding = parseSlotBinding(spec.defaultBinding);
+    if (binding) slot.defaultBinding = binding;
+    const scope = parseScope(spec.scope);
+    if (scope) slot.scope = scope;
+    slots[name] = slot;
+  }
+  if (Object.keys(slots).length === 0) return void 0;
+  validateScopes(slots);
+  return slots;
+}
+function parseScope(raw) {
+  if (!isRecord(raw)) return void 0;
+  const parent = typeof raw.parent === "string" ? raw.parent : "";
+  if (!parent) return void 0;
+  return { parent, strategy: raw.strategy === "manual" ? "manual" : "first" };
+}
+function validateScopes(slots) {
+  const drop = [];
+  for (const [name, slot] of Object.entries(slots)) {
+    if (!slot.scope) continue;
+    const parentName = slot.scope.parent;
+    const parent = Object.prototype.hasOwnProperty.call(slots, parentName) ? slots[parentName] : void 0;
+    if (!parent || parent.type !== "anchor" || parentName === name || inScopeCycle(slots, name)) {
+      drop.push(name);
+    }
+  }
+  for (const name of drop) delete slots[name].scope;
+}
+function inScopeCycle(slots, start) {
+  const seen = /* @__PURE__ */ new Set();
+  let cur = start;
+  while (cur) {
+    if (seen.has(cur)) return true;
+    seen.add(cur);
+    const slot = Object.prototype.hasOwnProperty.call(slots, cur) ? slots[cur] : void 0;
+    cur = slot?.scope?.parent;
+  }
+  return false;
+}
+function canScopeSlot(slots, child, parentName) {
+  if (child === parentName) return false;
+  const parent = Object.prototype.hasOwnProperty.call(slots, parentName) ? slots[parentName] : void 0;
+  if (!parent || parent.type !== "anchor") return false;
+  const seen = /* @__PURE__ */ new Set();
+  let cur = parentName;
+  while (cur) {
+    if (cur === child) return false;
+    if (seen.has(cur)) return false;
+    seen.add(cur);
+    const slot = Object.prototype.hasOwnProperty.call(slots, cur) ? slots[cur] : void 0;
+    cur = slot?.scope?.parent;
+  }
+  return true;
+}
+function parseSlotBinding(raw) {
+  if (!isRecord(raw)) return void 0;
+  if (raw.kind === "device") {
+    const token = stringAt(raw, "deviceToken");
+    return token ? { kind: "device", deviceToken: token } : void 0;
+  }
+  if (raw.kind === "anchor") {
+    const anchorRec = isRecord(raw.anchor) ? raw.anchor : {};
+    const targetToken = stringAt(anchorRec, "targetToken");
+    if (!targetToken) return void 0;
+    return {
+      kind: "anchor",
+      anchor: {
+        relationship: stringAt(anchorRec, "relationship"),
+        targetType: stringAt(anchorRec, "targetType"),
+        targetToken
+      }
+    };
+  }
+  return void 0;
+}
+function parseGrid(raw) {
+  const rec = isRecord(raw) ? raw : {};
+  const columns = Math.max(1, Math.round(numberAt(rec, "columns", DEFAULT_GRID.columns)));
+  const rowHeight = Math.max(1, numberAt(rec, "rowHeight", DEFAULT_GRID.rowHeight));
+  let gap = DEFAULT_GRID.gap;
+  if (typeof rec.gap === "number" && Number.isFinite(rec.gap)) {
+    gap = Math.max(0, rec.gap);
+  } else if (isRecord(rec.gap)) {
+    gap = {
+      row: Math.max(0, numberAt(rec.gap, "row", DEFAULT_GRID.gap)),
+      col: Math.max(0, numberAt(rec.gap, "col", DEFAULT_GRID.gap))
+    };
+  }
+  return { columns, gap, rowHeight };
+}
+function parseSizing(raw) {
+  if (isRecord(raw)) {
+    if (typeof raw.width === "number" && Number.isFinite(raw.width)) {
+      return { width: Math.max(1, raw.width) };
+    }
+    if (typeof raw.height === "number" && Number.isFinite(raw.height)) {
+      return { height: Math.max(1, raw.height) };
+    }
+  }
+  return DEFAULT_SIZING;
+}
+function parseCanvas(raw) {
+  const rec = isRecord(raw) ? raw : {};
+  const grid = parseGrid(rec.grid);
+  const sizing = parseSizing(rec.sizing);
+  const bpRec = isRecord(rec.breakpoints) ? rec.breakpoints : {};
+  const breakpoints = {};
+  for (const [name, width] of Object.entries(bpRec)) {
+    if (typeof width === "number" && Number.isFinite(width)) breakpoints[name] = width;
+  }
+  if (!(BASE_BREAKPOINT in breakpoints)) breakpoints[BASE_BREAKPOINT] = 0;
+  const canvas = { grid, sizing, breakpoints };
+  if (isRecord(rec.background)) {
+    const { color, imageUrl } = rec.background;
+    canvas.background = {
+      color: typeof color === "string" ? color : null,
+      imageUrl: typeof imageUrl === "string" ? imageUrl : null
+    };
+  }
+  return canvas;
+}
+function parseWidget(raw, index) {
+  if (!isRecord(raw)) throw new DashboardDefinitionError(`widgets[${index}] is not an object`);
+  const type = raw.type;
+  if (typeof type !== "string" || !WIDGET_TYPE_SET.has(type)) {
+    throw new DashboardDefinitionError(`widgets[${index}] has unknown type ${JSON.stringify(type)}`);
+  }
+  const widget = {
+    id: typeof raw.id === "string" && raw.id.length > 0 ? raw.id : generateWidgetId(),
+    type,
+    layout: parseLayout(raw.layout, index)
+  };
+  const ds = parseDatasource(raw.datasource);
+  if (ds) widget.datasource = ds;
+  if (isRecord(raw.options)) widget.options = raw.options;
+  return widget;
+}
+function stringAt(rec, key) {
+  const v = rec[key];
+  return typeof v === "string" ? v : "";
+}
+function stringArrayAt(rec, key) {
+  const v = rec[key];
+  return Array.isArray(v) ? v.filter((m) => typeof m === "string") : [];
+}
+function parseLocationSelection(raw) {
+  if (!isRecord(raw)) return void 0;
+  return raw.series === "latest" ? { series: "latest" } : void 0;
+}
+function withLocation(selector, raw) {
+  const location = parseLocationSelection(raw.location);
+  return location ? { ...selector, location } : selector;
+}
+function parseDatasource(raw) {
+  if (!isRecord(raw)) return void 0;
+  const kind = raw.kind;
+  if (typeof kind !== "string" || kind.length === 0) return void 0;
+  if (kind === "device") {
+    return withLocation(
+      { kind: "device", deviceToken: stringAt(raw, "deviceToken"), measurements: stringArrayAt(raw, "measurements") },
+      raw
+    );
+  }
+  if (kind === "anchor") {
+    const anchorRec = isRecord(raw.anchor) ? raw.anchor : {};
+    const selector = withLocation(
+      {
+        kind: "anchor",
+        anchor: {
+          relationship: stringAt(anchorRec, "relationship"),
+          // targetType defaults to '' (the config panel constrains it to the union;
+          // a hand-edited/empty value round-trips rather than being silently coerced).
+          targetType: stringAt(anchorRec, "targetType"),
+          targetToken: stringAt(anchorRec, "targetToken")
+        },
+        measurements: stringArrayAt(raw, "measurements")
+      },
+      raw
+    );
+    if (isRecord(raw.aggregation)) {
+      selector.aggregation = raw.aggregation;
+    }
+    return selector;
+  }
+  if (kind === "slot") {
+    return withLocation(
+      { kind: "slot", slot: stringAt(raw, "slot"), measurements: stringArrayAt(raw, "measurements") },
+      raw
+    );
+  }
+  return raw;
+}
+function parseLayout(raw, index) {
+  if (!isRecord(raw)) throw new DashboardDefinitionError(`widgets[${index}].layout is missing`);
+  const layout = {};
+  for (const [bp, box] of Object.entries(raw)) {
+    if (isRecord(box)) layout[bp] = parseBox(box);
+  }
+  if (!(BASE_BREAKPOINT in layout)) {
+    throw new DashboardDefinitionError(`widgets[${index}].layout has no '${BASE_BREAKPOINT}' box`);
+  }
+  return layout;
+}
+function parseBox(rec) {
+  const box = {
+    col: Math.max(0, Math.round(numberAt(rec, "col", 0))),
+    colSpan: Math.max(1, Math.round(numberAt(rec, "colSpan", 1))),
+    row: Math.max(0, Math.round(numberAt(rec, "row", 0))),
+    rowSpan: Math.max(1, Math.round(numberAt(rec, "rowSpan", 1))),
+    // z rounds too: a fractional zIndex is invalid CSS and silently drops to auto,
+    // so keep it an integer like every other box field.
+    z: Math.round(numberAt(rec, "z", 0))
+  };
+  if (isRecord(rec.offset)) {
+    box.offset = { x: numberAt(rec.offset, "x", 0), y: numberAt(rec.offset, "y", 0) };
+  }
+  return box;
+}
+function serializeDefinition(def) {
+  return JSON.stringify(def);
+}
+function isDirty(a, b) {
+  return serializeDefinition(a) !== serializeDefinition(b);
+}
+function resolveWidgetBox(layout, breakpoint) {
+  return layout[breakpoint] ?? layout[BASE_BREAKPOINT];
+}
+function activeBreakpoint(breakpoints, viewportWidth) {
+  let best = BASE_BREAKPOINT;
+  let bestWidth = -1;
+  for (const [name, minWidth] of Object.entries(breakpoints)) {
+    if (viewportWidth >= minWidth && minWidth > bestWidth) {
+      best = name;
+      bestWidth = minWidth;
+    }
+  }
+  return best;
+}
+var idCounter = 0;
+function generateWidgetId() {
+  const c = globalThis.crypto;
+  if (c && typeof c.randomUUID === "function") return `w-${c.randomUUID()}`;
+  idCounter += 1;
+  return `w-${idCounter.toString(36)}`;
+}
+
+// src/bindings.ts
+function effectiveBindings(definition, manifest) {
+  const out = {};
+  for (const [name, slot] of Object.entries(definition.slots ?? {})) {
+    if (slot.defaultBinding) out[name] = slot.defaultBinding;
+  }
+  if (manifest) {
+    for (const [name, binding] of Object.entries(manifest)) out[name] = binding;
+  }
+  return out;
+}
+function parseBindingManifest(raw) {
+  if (typeof raw !== "object" || raw === null || Array.isArray(raw)) {
+    return { bindings: {}, dropped: [] };
+  }
+  const bindings = {};
+  const dropped = [];
+  for (const [slot, spec] of Object.entries(raw)) {
+    if (slot === "__proto__") {
+      dropped.push(slot);
+      continue;
+    }
+    const binding = parseSlotBinding(spec);
+    if (binding) bindings[slot] = binding;
+    else dropped.push(slot);
+  }
+  return { bindings, dropped };
+}
+function stripDefaultBindings(def) {
+  if (!def.slots) return def;
+  const slots = {};
+  for (const [name, slot] of Object.entries(def.slots)) {
+    const { defaultBinding: _drop, ...rest } = slot;
+    slots[name] = rest;
+  }
+  return { ...def, slots };
+}
+
+// src/context.ts
+function ownGet(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;
+}
+function hasScopedSlots(definition) {
+  const slots = definition.slots;
+  if (!slots) return false;
+  for (const name of Object.keys(slots)) if (slots[name]?.scope) return true;
+  return false;
+}
+function bindingsWithoutScopedSlots(definition, map) {
+  const slots = definition.slots;
+  if (!slots) return map;
+  const out = {};
+  for (const name of Object.keys(map)) {
+    if (!ownGet(slots, name)?.scope) setBinding(out, name, map[name]);
+  }
+  return out;
+}
+function applySelection(overlay, target) {
+  return { ...overlay, [target.slot]: target.binding };
+}
+function topoOrder(slots) {
+  const order = [];
+  const done = /* @__PURE__ */ new Set();
+  const visit = (name, stack) => {
+    if (done.has(name) || stack.has(name)) return;
+    const slot = ownGet(slots, name);
+    if (!slot) return;
+    stack.add(name);
+    const parent = slot.scope?.parent;
+    if (parent) visit(parent, stack);
+    stack.delete(name);
+    done.add(name);
+    order.push(name);
+  };
+  for (const name of Object.keys(slots)) visit(name, /* @__PURE__ */ new Set());
+  return order;
+}
+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 scope = slot?.scope;
+    if (!scope) {
+      const sel = ownGet(overlay, name);
+      const b = sel && (!slot || bindingMatchesType(sel, slot.type)) ? sel : ownGet(base, name);
+      if (b) setBinding(out, name, b);
+      continue;
+    }
+    if (slot && slot.type !== "device") continue;
+    const parentBinding = ownGet(out, scope.parent);
+    if (!parentBinding || parentBinding.kind !== "anchor") continue;
+    let members;
+    try {
+      members = [...await resolver.devicesForAnchor(parentBinding.anchor)].sort();
+    } catch {
+      continue;
+    }
+    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);
+      if (pick && pick.kind === "device" && members.includes(pick.deviceToken)) setBinding(out, name, pick);
+    }
+  }
+  for (const name of Object.keys(base)) {
+    if (Object.prototype.hasOwnProperty.call(slots, name) || Object.prototype.hasOwnProperty.call(out, name)) {
+      continue;
+    }
+    const b = ownGet(overlay, name) ?? ownGet(base, name);
+    if (b) setBinding(out, name, b);
+  }
+  return out;
+}
+function bindingMatchesType(binding, type) {
+  return binding.kind === type;
+}
+
+// src/slots.ts
+function slotSelector(slot, measurements, location) {
+  return location ? { kind: "slot", slot, measurements, location } : { kind: "slot", slot, measurements };
+}
+function sameBinding(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") {
+    return a.anchor.relationship === b.anchor.relationship && a.anchor.targetType === b.anchor.targetType && a.anchor.targetToken === b.anchor.targetToken;
+  }
+  return false;
+}
+function bindingLabel(b) {
+  return b.kind === "device" ? b.deviceToken : b.anchor.targetToken;
+}
+function nextSlotName(slots) {
+  let n = 1;
+  while (slots[`slot-${n}`]) n += 1;
+  return `slot-${n}`;
+}
+function bindingOfSelector(ds) {
+  if (ds?.kind === "device") return ds.deviceToken ? { kind: "device", deviceToken: ds.deviceToken } : void 0;
+  if (ds?.kind === "anchor") {
+    return ds.anchor.targetToken ? { kind: "anchor", anchor: ds.anchor } : void 0;
+  }
+  return void 0;
+}
+function findOrAddSlot(slots, binding) {
+  const existing = Object.keys(slots).find((k) => !slots[k].scope && sameBinding(slots[k].defaultBinding, binding));
+  if (existing) return existing;
+  const name = nextSlotName(slots);
+  slots[name] = { type: binding.kind, label: bindingLabel(binding), defaultBinding: binding };
+  return name;
+}
+function migrateToSlots(def) {
+  const slots = { ...def.slots ?? {} };
+  let changed = false;
+  const widgets = def.widgets.map((w) => {
+    const ds = w.datasource;
+    if (ds?.kind === "anchor" && ds.aggregation) return w;
+    const binding = bindingOfSelector(ds);
+    if (!binding || !ds) return w;
+    changed = true;
+    const slot = findOrAddSlot(slots, binding);
+    return { ...w, datasource: slotSelector(slot, ds.measurements, ds.location) };
+  });
+  if (!changed) return def;
+  return { ...def, widgets, slots };
+}
+function bindWidgetSlot(def, widgetId, binding, measurements, location) {
+  const slots = { ...def.slots ?? {} };
+  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 widgets = def.widgets.map(
+    (w) => w.id === widgetId ? { ...w, datasource: slotSelector(slot, measurements, location) } : w
+  );
+  return { ...def, widgets, slots };
+}
+function clearWidgetDatasource(def, widgetId) {
+  const widgets = def.widgets.map((w) => {
+    if (w.id !== widgetId) return w;
+    const { datasource: _drop, ...rest } = w;
+    return rest;
+  });
+  return { ...def, widgets };
+}
+function pruneSlots(def) {
+  if (!def.slots) return def;
+  const defSlots = def.slots;
+  const used = /* @__PURE__ */ new Set();
+  for (const w of def.widgets) {
+    if (w.datasource?.kind === "slot") used.add(w.datasource.slot);
+    const target = w.options?.selectionTarget;
+    if (typeof target === "string" && target.length > 0) used.add(target);
+  }
+  for (const start of [...used]) {
+    let cur = start;
+    const guard = /* @__PURE__ */ new Set();
+    while (cur && Object.prototype.hasOwnProperty.call(defSlots, cur) && !guard.has(cur)) {
+      guard.add(cur);
+      const parent = defSlots[cur].scope?.parent;
+      if (parent) used.add(parent);
+      cur = parent;
+    }
+  }
+  const slots = {};
+  for (const [name, slot] of Object.entries(def.slots)) if (used.has(name)) slots[name] = slot;
+  if (Object.keys(slots).length === 0) {
+    const { slots: _drop, ...rest } = def;
+    return rest;
+  }
+  return { ...def, slots };
+}
+function anchorSlotNames(def) {
+  const slots = def.slots ?? {};
+  return Object.keys(slots).filter((name) => slots[name].type === "anchor");
+}
+function setSlotScope(def, slotName, scope) {
+  if (!def.slots || !Object.prototype.hasOwnProperty.call(def.slots, slotName)) return def;
+  const slots = { ...def.slots };
+  const current = slots[slotName];
+  if (!scope) {
+    if (!current.scope) return def;
+    const { scope: _drop, ...rest } = current;
+    slots[slotName] = rest;
+    return { ...def, slots };
+  }
+  if (!canScopeSlot(slots, slotName, scope.parent)) return def;
+  slots[slotName] = { ...current, scope: { parent: scope.parent, strategy: scope.strategy } };
+  return { ...def, slots };
+}
+function widgetBinding(def, widget) {
+  const ds = widget.datasource;
+  if (ds?.kind === "slot") return def.slots?.[ds.slot]?.defaultBinding;
+  return bindingOfSelector(ds);
+}
+function widgetSlotName(widget) {
+  return widget.datasource?.kind === "slot" ? widget.datasource.slot : void 0;
+}
+function resolveConcrete(def, widget) {
+  const binding = widgetBinding(def, widget);
+  if (!binding) return void 0;
+  const measurements = widget.datasource?.measurements ?? [];
+  const location = widget.datasource?.location;
+  const base = location ? { measurements, location } : { measurements };
+  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
+        }
+      }
+    }
+  }
+`;
+var DEVICES_BY_TOKEN = `
+  query DashboardDevicesByToken($tokens: [String!]!) {
+    devicesByToken(tokens: $tokens) {
+      token
+    }
+  }
+`;
+var LIST_DEVICES = `
+  query DashboardListDevices($criteria: DeviceSearchCriteria!) {
+    devices(criteria: $criteria) {
+      results {
+        token
+        name
+      }
+    }
+  }
+`;
+var LIST_CUSTOMERS = `
+  query DashboardListCustomers($criteria: CustomerSearchCriteria!) {
+    customers(criteria: $criteria) {
+      results {
+        token
+        name
+      }
+    }
+  }
+`;
+var LIST_AREAS = `
+  query DashboardListAreas($criteria: AreaSearchCriteria!) {
+    areas(criteria: $criteria) {
+      results {
+        token
+        name
+      }
+    }
+  }
+`;
+var LIST_ASSETS = `
+  query DashboardListAssets($criteria: AssetSearchCriteria!) {
+    assets(criteria: $criteria) {
+      results {
+        token
+        name
+      }
+    }
+  }
+`;
+var BUCKETED_MEASUREMENTS = `
+  query BucketedMeasurements($criteria: MeasurementAggregationCriteria!) {
+    bucketedMeasurements(criteria: $criteria) {
+      bucketStart
+      name
+      avg
+    }
+  }
+`;
+
+// src/entity-lister.ts
+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);
+    if (!pending) {
+      pending = fetchKind(kind, criteria).catch((err) => {
+        cache.delete(kind);
+        throw err;
+      });
+      cache.set(kind, pending);
+    }
+    return pending;
+  };
+}
+function fetchKind(kind, criteria) {
+  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);
+    case "asset":
+      return gql("device-management", LIST_ASSETS, { criteria }).then((r) => r.assets.results);
+    default:
+      return Promise.resolve([]);
+  }
+}
+
+// src/hub.ts
+import { gql as gql2, isForbiddenError, subscribe } from "@devicechain/client";
+
+// src/internal/alarm-doc.ts
+var ALARMS_QUERY = `
+  query DashboardAlarms($criteria: AlarmSearchCriteria!) {
+    alarms(criteria: $criteria) {
+      results {
+        token
+        originatorType
+        originatorToken
+        alarmKey
+        metricKey
+        state
+        acknowledged
+        severity
+        raisedTime
+        clearedTime
+        acknowledgedTime
+        acknowledgedBy
+        lastValue
+        message
+      }
+      pagination {
+        totalRecords
+      }
+    }
+  }
+`;
+var ALARM_STREAM = `
+  subscription DashboardAlarmStream(
+    $originatorType: String
+    $originator: String
+    $state: String
+    $severity: String
+    $alarmKey: String
+  ) {
+    alarmStream(
+      originatorType: $originatorType
+      originator: $originator
+      state: $state
+      severity: $severity
+      alarmKey: $alarmKey
+    ) {
+      alarmToken
+      eventType
+    }
+  }
+`;
+var ACKNOWLEDGE_ALARM = `
+  mutation DashboardAcknowledgeAlarm($token: String!) {
+    acknowledgeAlarm(token: $token) {
+      token
+    }
+  }
+`;
+var CLEAR_ALARM = `
+  mutation DashboardClearAlarm($token: String!) {
+    clearAlarm(token: $token) {
+      token
+    }
+  }
+`;
+
+// src/internal/command-doc.ts
+var COMMANDS_QUERY = `
+  query DashboardCommands($criteria: CommandSearchCriteria!) {
+    commands(criteria: $criteria) {
+      results {
+        token
+        name
+        status
+        payload
+        responsePayload
+        error
+        queuedTime
+        sentTime
+        respondedTime
+      }
+      pagination {
+        totalRecords
+      }
+    }
+  }
+`;
+var CREATE_COMMAND = `
+  mutation DashboardCreateCommand($request: CommandCreateRequest!) {
+    createCommand(request: $request) {
+      command {
+        token
+        status
+      }
+      rejection {
+        code
+        reason
+      }
+    }
+  }
+`;
+
+// src/internal/location-doc.ts
+var LATEST_LOCATIONS_QUERY = `
+  query DashboardLatestLocations($deviceTokens: [String!]!) {
+    latestLocations(deviceTokens: $deviceTokens) {
+      id
+      deviceToken
+      latitude
+      longitude
+      elevation
+      accuracy
+      speed
+      heading
+      occurredTime
+    }
+  }
+`;
+
+// src/internal/measurement-doc.ts
+var MEASUREMENT_STREAM = `
+  subscription MeasurementStream($deviceToken: String, $name: String) {
+    measurementStream(deviceToken: $deviceToken, name: $name) {
+      id
+      deviceToken
+      eventType
+      occurredTime
+      name
+      value
+      classifier
+    }
+  }
+`;
+
+// src/hub.ts
+var EVENT_AREA = "event-management";
+var DEVICE_AREA = "device-management";
+var COMMAND_AREA = "command-delivery";
+var STATE_AREA = "device-state";
+function randomToken() {
+  const c = globalThis.crypto;
+  if (c && typeof c.randomUUID === "function") return c.randomUUID();
+  return `cmd-${Math.random().toString(16).slice(2)}-${Math.random().toString(16).slice(2)}`;
+}
+var ALARM_RECONCILE_DEBOUNCE_MS = 800;
+var ALARM_POLL_MS = 3e4;
+var COMMAND_POLL_MS = 4e3;
+var LOCATION_POLL_MS = 15e3;
+var DashboardHub = class {
+  constructor(config) {
+    // Per alarm-subscription reconcile triggers — invoked after an ack/clear so the
+    // affected alarm widgets refresh immediately instead of waiting for the poll/stream.
+    this.alarmReconcilers = /* @__PURE__ */ new Set();
+    // Per command-subscription reconcile triggers — invoked after an issue so the command
+    // widgets show the new command immediately instead of waiting for the next poll tick.
+    this.commandReconcilers = /* @__PURE__ */ new Set();
+    // One entry per distinct device token that has at least one subscriber.
+    this.streams = /* @__PURE__ */ new Map();
+    // Live alarm-subscription disposers. The alarm channel isn't ref-counted through
+    // `streams` (it holds a poll/debounce/trigger per subscription, not a shared device
+    // stream), so its disposers are tracked here for disposeAll() to reach — otherwise an
+    // imperative host closing the dashboard would leak every alarm widget's poll + socket.
+    this.alarmDisposers = /* @__PURE__ */ new Set();
+    // Live command-subscription disposers (same rationale as alarmDisposers — the control
+    // channel holds a poll per subscription, not a shared device stream), so disposeAll()
+    // can tear down every command widget's poll.
+    this.commandDisposers = /* @__PURE__ */ new Set();
+    // Live location-subscription disposers (same rationale as alarmDisposers/
+    // commandDisposers — the location channel holds a poll per subscription, not a shared
+    // device stream), so disposeAll() can tear down every map widget's poll.
+    this.locationDisposers = /* @__PURE__ */ new Set();
+    this.resolver = config.resolver;
+    this.bindings = config.bindings ?? {};
+    this.authorities = new Set(config.authorities ?? []);
+  }
+  // setBindings replaces the slot manifest. New subscriptions resolve through it;
+  // callers that need already-open slot streams to re-resolve should re-subscribe
+  // (the console keys the renderer on the manifest to do exactly that).
+  setBindings(bindings) {
+    this.bindings = bindings;
+  }
+  // subscribeWidget binds a widget's datasource to a sink and returns a disposer.
+  // Selector resolution is async (anchor→devices); the disposer is returned
+  // synchronously and cancels a still-pending resolution, so tearing a widget down
+  // before its streams open never attaches a leaked subscriber.
+  subscribeWidget(datasource, sink) {
+    let disposed = false;
+    const detachers = [];
+    const dispose = () => {
+      disposed = true;
+      for (const detach of detachers.splice(0)) detach();
+    };
+    this.resolveDevices(datasource).then((groups) => {
+      if (disposed) return;
+      for (const group of groups) {
+        detachers.push(this.attach(group.deviceToken, group.names, sink));
+      }
+    }).catch((err) => {
+      if (!disposed) sink.error?.(err);
+    });
+    return dispose;
+  }
+  // subscribeAlarms binds an alarm widget's scope+filters to a sink and returns a
+  // disposer. Unlike the measurement channel it is NOT multiplexed — alarm widgets are
+  // few, and each carries its own filter — so every subscription opens its own trigger
+  // stream + reconcile poll (sharing one tenant-wide trigger stream across widgets is a
+  // deferred optimization). Query-then-reconcile: an initial query, then the live
+  // ALARM_STREAM debounced into re-queries, plus a poll backstop and a reconnect
+  // re-query. Scope resolution is async (slot/anchor → devices); the disposer is
+  // returned synchronously and cancels a still-pending resolution.
+  subscribeAlarms(subscription, sink) {
+    let disposed = false;
+    let debounce;
+    let poll;
+    let unsubscribe;
+    let reconciler;
+    let generation = 0;
+    const dispose = () => {
+      disposed = true;
+      if (debounce) clearTimeout(debounce);
+      if (poll) clearInterval(poll);
+      unsubscribe?.();
+      if (reconciler) this.alarmReconcilers.delete(reconciler);
+      this.alarmDisposers.delete(dispose);
+    };
+    this.alarmDisposers.add(dispose);
+    const reconcile = (tokens, tenantWide) => {
+      const gen = ++generation;
+      this.queryAlarms(subscription, tokens, tenantWide).then((snapshot) => {
+        if (!disposed && gen === generation) sink.next(snapshot);
+      }).catch((err) => {
+        if (!disposed && gen === generation) sink.error?.(err);
+      });
+    };
+    this.resolveAlarmScope(subscription.datasource).then((scope) => {
+      if (disposed) return;
+      if (!scope.tenantWide && 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);
+      };
+      const adapter = {
+        next: () => trigger(),
+        connected: (wasRetry) => {
+          if (wasRetry) reconcile(scope.tokens, scope.tenantWide);
+        }
+      };
+      unsubscribe = subscribe(DEVICE_AREA, ALARM_STREAM, {}, adapter);
+      poll = setInterval(() => reconcile(scope.tokens, scope.tenantWide), ALARM_POLL_MS);
+      reconciler = () => reconcile(scope.tokens, scope.tenantWide);
+      this.alarmReconcilers.add(reconciler);
+      reconcile(scope.tokens, scope.tenantWide);
+    }).catch((err) => {
+      if (!disposed) sink.error?.(err);
+    });
+    return dispose;
+  }
+  // resolveAlarmScope turns an alarm widget's scope selector into the originator device
+  // tokens to filter on, or tenant-wide when it carries no datasource. Reuses the same
+  // device/anchor/slot resolution the measurement channel does.
+  async resolveAlarmScope(datasource) {
+    if (!datasource) return { tenantWide: true, tokens: [] };
+    const groups = await this.resolveDevices(datasource);
+    return { tenantWide: false, tokens: groups.map((g) => g.deviceToken) };
+  }
+  // queryAlarms reads the authoritative rows. Tenant-wide is one query; a scoped widget
+  // 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) {
+    const base = {
+      pageNumber: 1,
+      // the alarms query paginates 1-based
+      pageSize: sub.pageSize,
+      state: sub.state ?? null,
+      severity: sub.severity ?? null,
+      acknowledged: sub.acknowledged ?? null
+    };
+    if (tenantWide) {
+      const data = await gql2(DEVICE_AREA, ALARMS_QUERY, {
+        criteria: { ...base, originatorType: null, originator: null }
+      });
+      return { alarms: data.alarms.results, total: data.alarms.pagination.totalRecords };
+    }
+    const pages = await Promise.all(
+      tokens.map(
+        (token) => gql2(DEVICE_AREA, ALARMS_QUERY, {
+          criteria: { ...base, originatorType: "device", originator: token }
+        })
+      )
+    );
+    const byToken = /* @__PURE__ */ new Map();
+    let total = 0;
+    for (const page of pages) {
+      total += page.alarms.pagination.totalRecords;
+      for (const row of page.alarms.results) byToken.set(row.token, row);
+    }
+    const alarms = [...byToken.values()].sort((a, b) => (b.raisedTime ?? "").localeCompare(a.raisedTime ?? "")).slice(0, sub.pageSize);
+    return { alarms, total };
+  }
+  // ── Control channel ──────────────────────────────────────────────────────
+  // subscribeCommands binds a command widget's scope to a sink and returns a disposer.
+  // Poll-only (command-delivery has no subscription): resolve the target device once,
+  // then re-read its recent commands on an interval (and immediately after an issue via
+  // the reconciler). Scope resolution is async; the disposer is returned synchronously
+  // and cancels a still-pending resolution.
+  subscribeCommands(subscription, sink) {
+    let disposed = false;
+    let poll;
+    let reconciler;
+    let deviceToken = null;
+    let generation = 0;
+    const dispose = () => {
+      disposed = true;
+      if (poll) clearInterval(poll);
+      if (reconciler) this.commandReconcilers.delete(reconciler);
+      this.commandDisposers.delete(dispose);
+    };
+    this.commandDisposers.add(dispose);
+    const reconcile = () => {
+      const gen = ++generation;
+      this.queryCommands(subscription, deviceToken).then((snapshot) => {
+        if (!disposed && gen === generation) sink.next(snapshot);
+      }).catch((err) => {
+        if (!disposed && gen === generation) sink.error?.(err);
+      });
+    };
+    this.resolveCommandScope(subscription.datasource).then((token) => {
+      if (disposed) return;
+      deviceToken = token;
+      if (!deviceToken) {
+        sink.next({ deviceToken: null, commands: [], total: 0 });
+        return;
+      }
+      poll = setInterval(reconcile, COMMAND_POLL_MS);
+      reconciler = reconcile;
+      this.commandReconcilers.add(reconciler);
+      reconcile();
+    }).catch((err) => {
+      if (!disposed) sink.error?.(err);
+    });
+    return dispose;
+  }
+  // resolveCommandScope turns a command widget's scope selector into its single target
+  // device token (a command targets one device), or null when it carries no datasource
+  // or resolves to no device. When a selector expands to several devices (an anchor), the
+  // first is the target — the console restricts command widgets to a device scope, so
+  // this is a defensive fallback, not the authoring path.
+  async resolveCommandScope(datasource) {
+    if (!datasource) return null;
+    const groups = await this.resolveDevices(datasource);
+    return groups[0]?.deviceToken ?? null;
+  }
+  // queryCommands reads the recent commands for the target device (newest first, capped
+  // to pageSize) with their live delivery status.
+  async queryCommands(sub, deviceToken) {
+    if (!deviceToken) return { deviceToken: null, commands: [], total: 0 };
+    const data = await gql2(COMMAND_AREA, COMMANDS_QUERY, {
+      criteria: { pageNumber: 1, pageSize: sub.pageSize, deviceToken, status: null }
+    });
+    return {
+      deviceToken,
+      commands: data.commands.results,
+      total: data.commands.pagination.totalRecords
+    };
+  }
+  // ── Location channel ─────────────────────────────────────────────────────
+  // subscribeLocations binds a map widget's selector to a sink and returns a disposer.
+  // Poll-only (device-state has no location subscription): resolve the bound devices
+  // once, then re-read their last-known positions on an interval. Scope resolution is
+  // async; the disposer is returned synchronously and cancels a still-pending
+  // resolution, matching every other channel.
+  subscribeLocations(subscription, sink) {
+    let disposed = false;
+    let poll;
+    let deviceTokens = [];
+    let generation = 0;
+    const dispose = () => {
+      disposed = true;
+      if (poll) clearInterval(poll);
+      this.locationDisposers.delete(dispose);
+    };
+    this.locationDisposers.add(dispose);
+    const reconcile = () => {
+      const gen = ++generation;
+      this.queryLocations(deviceTokens).then((snapshot) => {
+        if (!disposed && gen === generation) sink.next(snapshot);
+      }).catch((err) => {
+        if (!disposed && gen === generation) sink.error?.(err);
+      });
+    };
+    this.resolveLocationScope(subscription.datasource).then((tokens) => {
+      if (disposed) return;
+      deviceTokens = tokens;
+      if (deviceTokens.length === 0) {
+        sink.next({ kind: "positions", deviceTokens: [], locations: [] });
+        return;
+      }
+      poll = setInterval(reconcile, LOCATION_POLL_MS);
+      reconcile();
+    }).catch((err) => {
+      if (!disposed) sink.error?.(err);
+    });
+    return dispose;
+  }
+  // resolveLocationScope turns a map widget's selector into the device tokens whose
+  // positions to read.
+  //
+  // 🔴 It resolves NOTHING unless the selector NAMES A LOCATION SERIES. That is the
+  // point of the separate field: a device selector carrying only `measurements` is a
+  // telemetry binding, and quietly reading its device's position because a map widget
+  // happens to hold it would make the location field decorative — authored or not, the
+  // behaviour would be identical, so nothing would ever hold it. A map bound to a
+  // measurement-only selector shows its empty state, which is the honest answer.
+  async resolveLocationScope(datasource) {
+    if (!datasource?.location) return [];
+    const groups = await this.resolveDevices(datasource);
+    return groups.map((g) => g.deviceToken);
+  }
+  // queryLocations reads the last-known position of each bound device in ONE batch
+  // round trip. A device that has never been located is absent from the result (the
+  // service's contract), so the caller reads "how many are located" from the returned
+  // rows and "how many are bound" from the tokens.
+  async queryLocations(deviceTokens) {
+    if (deviceTokens.length === 0) return { kind: "positions", deviceTokens, locations: [] };
+    try {
+      const data = await gql2(STATE_AREA, LATEST_LOCATIONS_QUERY, { deviceTokens });
+      return { kind: "positions", deviceTokens, locations: data.latestLocations };
+    } catch (err) {
+      if (isForbiddenError(err)) return { kind: "forbidden" };
+      throw err;
+    }
+  }
+  // ── WidgetActions (the write seam) ───────────────────────────────────────
+  // can reports whether the viewer holds an authority ('*' grants all). Drives whether
+  // a widget renders an action control; the server enforces authority regardless.
+  can(authority) {
+    return this.authorities.has("*") || this.authorities.has(authority);
+  }
+  // acknowledgeAlarm / clearAlarm mutate the alarm by token, then nudge every open alarm
+  // widget to reconcile so the change shows at once. The mutation reaches device-management
+  // (the acknowledging identity is taken server-side from the token).
+  async acknowledgeAlarm(alarmToken) {
+    await gql2(DEVICE_AREA, ACKNOWLEDGE_ALARM, { token: alarmToken });
+    this.reconcileAlarms();
+  }
+  async clearAlarm(alarmToken) {
+    await gql2(DEVICE_AREA, CLEAR_ALARM, { token: alarmToken });
+    this.reconcileAlarms();
+  }
+  // sendCommand issues a command to a device, minting the dispatch token here (the
+  // idempotency key + cancel handle), then nudges every open command widget to reconcile
+  // so the new command shows at once. The mutation reaches command-delivery (requires
+  // command:write, enforced server-side regardless of can()).
+  //
+  // A REFUSAL COMES BACK AS A VALUE, not an exception (see CommandDispatch): the server
+  // decided the request and named the reason, so the widget can show it. Nothing was
+  // created in that case, so the open command widgets are NOT reconciled — a re-poll
+  // would only re-render the same history and make a refused send look like it did
+  // something.
+  async sendCommand(deviceToken, name, payload) {
+    const token = randomToken();
+    const result = await gql2(COMMAND_AREA, CREATE_COMMAND, {
+      request: { token, deviceToken, name, payload: payload ?? null }
+    });
+    const rejection = result.createCommand?.rejection;
+    if (rejection) {
+      return { status: "rejected", code: rejection.code, reason: rejection.reason };
+    }
+    if (!result.createCommand?.command) {
+      throw new Error("The command could not be issued: the platform returned no answer for it.");
+    }
+    this.reconcileCommands();
+    return { status: "sent", token };
+  }
+  // reconcileAlarms re-queries every open alarm subscription hub-wide (after a mutation).
+  // Hub-wide is deliberate: one alarm can appear in several widgets (different scopes),
+  // and the acked/cleared row must refresh in all of them; scoping the nudge would need
+  // per-reconciler token knowledge for no real saving. Iterate a copy for safety.
+  reconcileAlarms() {
+    for (const reconcile of [...this.alarmReconcilers]) reconcile();
+  }
+  // reconcileCommands re-polls every open command subscription (after an issue). Iterate
+  // a copy for safety.
+  reconcileCommands() {
+    for (const reconcile of [...this.commandReconcilers]) reconcile();
+  }
+  // disposeAll tears down every upstream stream (e.g. on dashboard close): the
+  // ref-counted measurement device streams AND every alarm/command/location
+  // subscription's poll + trigger. Iterate a copy of the disposer sets since each
+  // removes itself as it runs.
+  disposeAll() {
+    for (const stream of this.streams.values()) stream.unsubscribe();
+    this.streams.clear();
+    for (const dispose of [...this.alarmDisposers]) dispose();
+    this.alarmDisposers.clear();
+    for (const dispose of [...this.commandDisposers]) dispose();
+    this.commandDisposers.clear();
+    for (const dispose of [...this.locationDisposers]) dispose();
+    this.locationDisposers.clear();
+  }
+  // The number of distinct upstream device streams currently open (observability
+  // + test hook — proves multiplexing collapses shared devices to one stream).
+  get openStreamCount() {
+    return this.streams.size;
+  }
+  // isDatasourceAvailable reports whether a widget's bound device still exists. Only a
+  // device selector (or a slot bound to a device) is validated — an anchor, an unbound
+  // slot, or no datasource has a legitimate empty state and is always "available". Fails
+  // open: an existence-check outage returns true (never falsely mark a live device gone).
+  async isDatasourceAvailable(datasource) {
+    const deviceToken = this.availabilityToken(datasource);
+    if (deviceToken === void 0) return true;
+    try {
+      return await this.resolver.deviceExists(deviceToken);
+    } catch {
+      return true;
+    }
+  }
+  // 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
+  // kind isn't resolved yet).
+  availabilityToken(datasource) {
+    if (!datasource) return void 0;
+    if (datasource.kind === "device") return datasource.deviceToken || void 0;
+    if (datasource.kind === "slot") {
+      const binding = Object.prototype.hasOwnProperty.call(this.bindings, datasource.slot) ? this.bindings[datasource.slot] : void 0;
+      return binding && binding.kind === "device" ? binding.deviceToken || void 0 : void 0;
+    }
+    return void 0;
+  }
+  // resolveDevices turns a selector into the devices to stream, each with the
+  // measurement names the widget wants (empty = all). Reserved selector kinds are
+  // rejected here, mirroring the backend (Phase 1 ships device + anchor).
+  async resolveDevices(datasource) {
+    switch (datasource.kind) {
+      case "device":
+        return this.resolveBinding(
+          { kind: "device", deviceToken: datasource.deviceToken },
+          new Set(datasource.measurements)
+        );
+      case "anchor":
+        return this.resolveBinding(
+          { kind: "anchor", anchor: datasource.anchor },
+          new Set(datasource.measurements)
+        );
+      case "slot": {
+        const binding = Object.prototype.hasOwnProperty.call(this.bindings, datasource.slot) ? this.bindings[datasource.slot] : void 0;
+        if (!binding) return [];
+        return this.resolveBinding(binding, new Set(datasource.measurements));
+      }
+      default:
+        throw new Error(
+          `dashboard selector kind '${datasource.kind}' is not supported yet`
+        );
+    }
+  }
+  // resolveBinding turns a concrete entity binding (device or anchor) into the
+  // device streams to open, each carrying the given measurement names. Shared by the
+  // device/anchor selectors and by slot resolution (whose binding is either kind).
+  // A device binding streams its token directly (measurementStream is keyed by token,
+  // per ADR-044); an anchor expands to its member device tokens.
+  async resolveBinding(binding, names) {
+    if (binding.kind === "device") {
+      return [{ deviceToken: binding.deviceToken, names }];
+    }
+    const tokens = await this.resolver.devicesForAnchor(binding.anchor);
+    return tokens.map((deviceToken) => ({ deviceToken, names }));
+  }
+  // attach registers a subscriber on a device's stream (opening the upstream on
+  // the first subscriber) and returns a detacher that drops it and closes the
+  // upstream once the last subscriber leaves.
+  attach(deviceToken, names, sink) {
+    const stream = this.ensureStream(deviceToken);
+    const subscriber = { names, sink };
+    stream.subscribers.add(subscriber);
+    return () => {
+      if (!stream.subscribers.delete(subscriber)) return;
+      if (stream.subscribers.size === 0 && this.streams.get(deviceToken) === stream) {
+        stream.unsubscribe();
+        this.streams.delete(deviceToken);
+      }
+    };
+  }
+  ensureStream(deviceToken) {
+    const existing = this.streams.get(deviceToken);
+    if (existing) return existing;
+    const stream = { subscribers: /* @__PURE__ */ new Set(), unsubscribe: () => {
+    } };
+    this.streams.set(deviceToken, stream);
+    const adapter = {
+      next: (data) => this.fanout(deviceToken, data.measurementStream),
+      error: (err) => {
+        if (this.streams.get(deviceToken) === stream) this.streams.delete(deviceToken);
+        stream.unsubscribe();
+        for (const subscriber of stream.subscribers) subscriber.sink.error?.(err);
+      }
+    };
+    const variables = { deviceToken, name: null };
+    stream.unsubscribe = subscribe(EVENT_AREA, MEASUREMENT_STREAM, variables, adapter);
+    return stream;
+  }
+  fanout(deviceToken, sample) {
+    const stream = this.streams.get(deviceToken);
+    if (!stream) return;
+    for (const subscriber of stream.subscribers) {
+      if (subscriber.names.size === 0 || subscriber.names.has(sample.name)) {
+        subscriber.sink.next(sample);
+      }
+    }
+  }
+};
+
+// src/synthetic.ts
+var SYNTHETIC_GENERATORS = [
+  { value: "sine", label: "Sine wave" },
+  { value: "ramp", label: "Ramp" },
+  { value: "random-walk", label: "Random walk" }
+];
+var DEFAULT_NAME = "value";
+var SYNTHETIC_ALARMS = [
+  { severity: "CRITICAL", state: "ACTIVE", acknowledged: false, alarmKey: "over-temperature", metricKey: "temperature", lastValue: 87.4, originatorToken: "thermostat-01", message: "Temperature above 85\xB0C" },
+  { severity: "MAJOR", state: "ACTIVE", acknowledged: true, alarmKey: "low-battery", metricKey: "battery", lastValue: 12, originatorToken: "sensor-14", message: "Battery below 15%" },
+  { severity: "MINOR", state: "ACTIVE", acknowledged: false, alarmKey: "humidity-high", metricKey: "humidity", lastValue: 78, originatorToken: "sensor-03", message: "Relative humidity above threshold" },
+  { severity: "WARNING", state: "CLEARED", acknowledged: true, alarmKey: "signal-weak", metricKey: "rssi", lastValue: -89, originatorToken: "gateway-02", message: "Weak uplink signal" },
+  { severity: "INDETERMINATE", state: "ACTIVE", acknowledged: false, alarmKey: "self-test", metricKey: "status", lastValue: null, originatorToken: "device-99", message: null }
+];
+var SYNTHETIC_COMMANDS = [
+  { name: "reboot", status: "SENT", payload: '{"delaySeconds":5}', responsePayload: null, error: null, dispatched: true },
+  // Early in the list on purpose: an author can cap the widget's row count, and a
+  // withheld command is the state a preview most needs to show.
+  { name: "self-test", status: "HELD", payload: null, responsePayload: null, error: null, dispatched: false },
+  // The other way a command ends up waiting on an absent device: this one was published
+  // and found nobody there, so it is parked until the device wakes. Included next to HELD
+  // because the two look alike in a list and an author laying out a command-button needs
+  // to see that they are distinguishable. `dispatched` is false, matching the service: it
+  // CLEARS sent_time when it parks a command, because a dispatch that reached nobody sent
+  // nothing. That is also why a parked command is still cancellable — nothing has taken
+  // delivery of it.
+  { name: "sync-clock", status: "PARKED", payload: null, responsePayload: null, error: null, dispatched: false },
+  { name: "set-interval", status: "SUCCESSFUL", payload: '{"seconds":30}', responsePayload: '{"ok":true}', error: null, dispatched: true },
+  { name: "calibrate", status: "QUEUED", payload: null, responsePayload: null, error: null, dispatched: false },
+  { name: "firmware-update", status: "FAILED", payload: '{"version":"2.1.0"}', responsePayload: null, error: "device offline", dispatched: true },
+  { name: "open-valve", status: "CANCELLED", payload: '{"percent":100}', responsePayload: null, error: null, dispatched: false }
+];
+var SYNTHETIC_COMMAND_DEVICE = "synthetic-device";
+var SYNTHETIC_LOCATIONS = [
+  { deviceToken: "sp-dozer-01", latitude: 33.749, longitude: -84.388, elevation: 320.5, accuracy: 4.2, speed: 0, heading: 271.5 },
+  { deviceToken: "sp-excavator-02", latitude: 33.7512, longitude: -84.3858, elevation: 318.1, accuracy: 3.1, speed: 1.4, heading: 88 },
+  { deviceToken: "sp-loader-03", latitude: 33.7468, longitude: -84.3903, elevation: null, accuracy: 9.8, speed: null, heading: null },
+  { deviceToken: "sp-truck-04", latitude: 33.7481, longitude: -84.3841, elevation: 315.9, accuracy: 2.5, speed: 8.3, heading: 12.25 }
+];
+function hashName(name) {
+  let h = 0;
+  for (let i = 0; i < name.length; i++) h = Math.imul(h, 31) + name.charCodeAt(i) | 0;
+  return h >>> 0;
+}
+function clamp(v, min, max) {
+  return v < min ? min : v > max ? max : v;
+}
+var SyntheticDataSource = class {
+  constructor(config = {}) {
+    // Live timers, tracked so disposeAll() can stop every widget's stream at once.
+    this.timers = /* @__PURE__ */ new Set();
+    this.generator = config.generator ?? "sine";
+    this.intervalMs = Math.max(1, config.intervalMs ?? 1e3);
+    this.backfill = Math.max(0, config.backfill ?? 60);
+    this.min = config.min ?? 0;
+    this.max = config.max ?? 100;
+    this.periodMs = Math.max(1, config.periodMs ?? 6e4);
+  }
+  subscribeWidget(datasource, sink) {
+    const names = datasource.measurements.length > 0 ? datasource.measurements : [DEFAULT_NAME];
+    const walk = /* @__PURE__ */ new Map();
+    let seq = 0;
+    const emit = (name, tMs) => {
+      const value = this.valueFor(name, tMs, walk);
+      const s = {
+        id: `syn-${seq++}`,
+        deviceToken: "synthetic",
+        eventType: 0,
+        occurredTime: new Date(tMs).toISOString(),
+        name,
+        value,
+        classifier: null
+      };
+      sink.next(s);
+    };
+    const now = Date.now();
+    for (let i = this.backfill - 1; i >= 0; i--) {
+      const tMs = now - i * this.intervalMs;
+      for (const name of names) emit(name, tMs);
+    }
+    const timer = setInterval(() => {
+      const tMs = Date.now();
+      for (const name of names) emit(name, tMs);
+    }, this.intervalMs);
+    this.timers.add(timer);
+    return () => {
+      if (this.timers.delete(timer)) clearInterval(timer);
+    };
+  }
+  // subscribeAlarms emits a synthetic alarm snapshot for preview. The canonical set is
+  // filtered by the subscription (state/severity/ack) so the preview reflects what the
+  // widget is configured to show; scope (datasource) is ignored — preview never resolves
+  // a device. Re-emits on the same cadence with advancing raised times so the table
+  // looks live. Returns whole snapshots, matching the live hub's contract.
+  subscribeAlarms(subscription, sink) {
+    const matches = SYNTHETIC_ALARMS.filter(
+      (a) => (!subscription.state || a.state === subscription.state) && (!subscription.severity || a.severity === subscription.severity) && (subscription.acknowledged == null || a.acknowledged === subscription.acknowledged)
+    );
+    const emit = () => {
+      const now = Date.now();
+      const rows = matches.map((a, i) => {
+        const raised = new Date(now - i * 45e3).toISOString();
+        return {
+          token: `syn-alarm-${i}`,
+          originatorType: "device",
+          alarmKey: a.alarmKey,
+          metricKey: a.metricKey,
+          state: a.state,
+          acknowledged: a.acknowledged,
+          severity: a.severity,
+          originatorToken: a.originatorToken,
+          lastValue: a.lastValue,
+          message: a.message,
+          raisedTime: raised,
+          clearedTime: a.state === "CLEARED" ? raised : null,
+          acknowledgedTime: a.acknowledged ? raised : null,
+          acknowledgedBy: a.acknowledged ? "preview@devicechain" : null
+        };
+      });
+      sink.next({ alarms: rows.slice(0, subscription.pageSize), total: rows.length });
+    };
+    emit();
+    const timer = setInterval(emit, this.intervalMs);
+    this.timers.add(timer);
+    return () => {
+      if (this.timers.delete(timer)) clearInterval(timer);
+    };
+  }
+  // subscribeCommands emits a synthetic command history for preview so a command-button
+  // shows a populated, lifecycle-varied list (and a bound target device, so its Send
+  // control renders). Re-emits on the same cadence with advancing queued times. Scope
+  // (datasource) is ignored — preview never resolves a device. Returns whole snapshots,
+  // matching the live hub's contract.
+  subscribeCommands(subscription, sink) {
+    const emit = () => {
+      const now = Date.now();
+      const commands = SYNTHETIC_COMMANDS.map((c, i) => {
+        const queued = new Date(now - i * 2e4).toISOString();
+        const answered = c.status === "SUCCESSFUL" || c.status === "FAILED";
+        return {
+          token: `syn-command-${i}`,
+          name: c.name,
+          status: c.status,
+          payload: c.payload,
+          responsePayload: c.responsePayload,
+          error: c.error,
+          queuedTime: queued,
+          // Likewise: only a command that actually reached a device has a sentTime. QUEUED,
+          // HELD and PARKED never did, and neither did the cancelled one (called off while
+          // held).
+          sentTime: c.dispatched ? queued : null,
+          respondedTime: answered ? queued : null
+        };
+      });
+      sink.next({
+        deviceToken: SYNTHETIC_COMMAND_DEVICE,
+        commands: commands.slice(0, subscription.pageSize),
+        total: commands.length
+      });
+    };
+    emit();
+    const timer = setInterval(emit, this.intervalMs);
+    this.timers.add(timer);
+    return () => {
+      if (this.timers.delete(timer)) clearInterval(timer);
+    };
+  }
+  // subscribeLocations emits a synthetic position snapshot for preview so a map shows a
+  // populated, representative fleet before any device has reported one. Scope
+  // (datasource) is ignored — preview never resolves a device — but the LOCATION SERIES
+  // is honored: a selector that names none gets the empty snapshot, exactly as the live
+  // hub gives it, so an author who has not bound the map sees preview agree with
+  // production rather than paper over the omission with fake markers.
+  //
+  // Preview NEVER reports `forbidden`: it reaches no backend, so there is no authority
+  // to be refused, and inventing a permission state would show an author a wall their
+  // viewers may not actually hit.
+  subscribeLocations(subscription, sink) {
+    if (!subscription.datasource?.location) {
+      sink.next({ kind: "positions", deviceTokens: [], locations: [] });
+      return () => {
+      };
+    }
+    const emit = () => {
+      const now = Date.now();
+      const locations = SYNTHETIC_LOCATIONS.map((l, i) => ({
+        id: `syn-location-${i}`,
+        deviceToken: l.deviceToken,
+        latitude: l.latitude,
+        longitude: l.longitude,
+        elevation: l.elevation,
+        accuracy: l.accuracy,
+        speed: l.speed,
+        heading: l.heading,
+        occurredTime: new Date(now - i * 3e4).toISOString()
+      }));
+      sink.next({
+        kind: "positions",
+        deviceTokens: locations.map((l) => l.deviceToken),
+        locations
+      });
+    };
+    emit();
+    const timer = setInterval(emit, this.intervalMs);
+    this.timers.add(timer);
+    return () => {
+      if (this.timers.delete(timer)) clearInterval(timer);
+    };
+  }
+  // isDatasourceAvailable — preview always resolves data (it generates it), so every
+  // datasource is "available"; an author previewing a template never sees the
+  // deleted-device state.
+  async isDatasourceAvailable() {
+    return true;
+  }
+  // ── WidgetActions (preview stubs) ────────────────────────────────────────
+  // Preview shows action controls (so an author sees the real layout), so can() is
+  // always true; the actions themselves are no-ops — preview never mutates the backend.
+  can() {
+    return true;
+  }
+  async acknowledgeAlarm() {
+  }
+  async clearAlarm() {
+  }
+  async sendCommand() {
+    return { status: "sent", token: "syn-dispatch" };
+  }
+  // disposeAll stops every live stream (e.g. when preview is turned off). Individual
+  // widget disposers already clear their own timer; this is the belt-and-braces
+  // teardown for the whole source.
+  disposeAll() {
+    for (const timer of this.timers) clearInterval(timer);
+    this.timers.clear();
+  }
+  valueFor(name, tMs, walk) {
+    const span = this.max - this.min;
+    const phase = hashName(name) % 1e3 / 1e3;
+    switch (this.generator) {
+      case "ramp": {
+        const frac = ((tMs / this.periodMs + phase) % 1 + 1) % 1;
+        return this.min + span * frac;
+      }
+      case "random-walk": {
+        const prev = walk.get(name) ?? this.min + span / 2;
+        const next = clamp(prev + (Math.random() - 0.5) * span * 0.1, this.min, this.max);
+        walk.set(name, next);
+        return next;
+      }
+      case "sine":
+      default: {
+        const angle = 2 * Math.PI * (tMs / this.periodMs + phase);
+        return this.min + span * (0.5 + 0.5 * Math.sin(angle));
+      }
+    }
+  }
+};
+
+// src/editor-model.ts
+function baseBox(widget) {
+  return widget.layout[BASE_BREAKPOINT];
+}
+function setWidgetBox(def, id, box) {
+  return {
+    ...def,
+    widgets: def.widgets.map(
+      (w) => w.id === id ? { ...w, layout: { ...w.layout, [BASE_BREAKPOINT]: box } } : w
+    )
+  };
+}
+function deleteWidget(def, id) {
+  return { ...def, widgets: def.widgets.filter((w) => w.id !== id) };
+}
+function bringToFront(def, id) {
+  const widget = def.widgets.find((w) => w.id === id);
+  if (!widget) return def;
+  const box = baseBox(widget);
+  const maxOther = Math.max(-Infinity, ...def.widgets.filter((w) => w.id !== id).map((w) => baseBox(w).z));
+  if (box.z > maxOther) return def;
+  return setWidgetBox(def, id, { ...box, z: maxOther + 1 });
+}
+function setTitle(def, title) {
+  return { ...def, title };
+}
+function setCanvasGrid(def, patch) {
+  const grid = { ...def.canvas.grid, ...patch };
+  if (patch.columns !== void 0) grid.columns = Math.max(1, Math.round(patch.columns));
+  if (patch.rowHeight !== void 0) grid.rowHeight = Math.max(1, Math.round(patch.rowHeight));
+  const widgets = grid.columns < def.canvas.grid.columns ? def.widgets.map((w) => clampWidgetColumns(w, grid.columns)) : def.widgets;
+  return { ...def, widgets, canvas: { ...def.canvas, grid } };
+}
+function clampWidgetColumns(widget, columns) {
+  const layout = {};
+  for (const [bp, box] of Object.entries(widget.layout)) {
+    const col = Math.min(box.col, columns - 1);
+    layout[bp] = { ...box, col, colSpan: Math.min(box.colSpan, columns - col) };
+  }
+  return { ...widget, layout };
+}
+function setCanvasSizing(def, sizing) {
+  return { ...def, canvas: { ...def.canvas, sizing } };
+}
+function updateWidget(def, id, next) {
+  return { ...def, widgets: def.widgets.map((w) => w.id === id ? next : w) };
+}
+function humanizeType(type) {
+  const words = type.replace(/-/g, " ");
+  return words.charAt(0).toUpperCase() + words.slice(1);
+}
+function defaultOptions(type) {
+  if (type === "label") return { text: "New label" };
+  if (type === "alarm-table" || type === "alarm-count") {
+    return { title: humanizeType(type), state: "ACTIVE" };
+  }
+  return { title: humanizeType(type) };
+}
+function addWidget(def, type) {
+  const maxZ = def.widgets.reduce((m, w) => Math.max(m, baseBox(w).z), 0);
+  const id = generateWidgetId();
+  const box = { col: 0, colSpan: 8, row: 0, rowSpan: 4, z: maxZ + 1 };
+  const widget = {
+    id,
+    type,
+    layout: { [BASE_BREAKPOINT]: box },
+    options: defaultOptions(type)
+  };
+  return { definition: { ...def, widgets: [...def.widgets, widget] }, id };
+}
+function gridBoxToPx(box, geom) {
+  const colStride = geom.colWidth + geom.colGap;
+  const rowStride = geom.rowHeight + geom.rowGap;
+  const dx = box.offset?.x ?? 0;
+  const dy = box.offset?.y ?? 0;
+  return {
+    x: box.col * colStride + dx,
+    y: box.row * rowStride + dy,
+    w: box.colSpan * geom.colWidth + (box.colSpan - 1) * geom.colGap,
+    h: box.rowSpan * geom.rowHeight + (box.rowSpan - 1) * geom.rowGap
+  };
+}
+function pxToGridBox(px, geom, z, offset, columns) {
+  const colStride = Math.max(1, geom.colWidth + geom.colGap);
+  const rowStride = Math.max(1, geom.rowHeight + geom.rowGap);
+  const x = px.x - (offset?.x ?? 0);
+  const y = px.y - (offset?.y ?? 0);
+  let col = Math.max(0, Math.round(x / colStride));
+  let colSpan = Math.max(1, Math.round((px.w + geom.colGap) / colStride));
+  if (columns !== void 0) {
+    col = Math.min(col, columns - 1);
+    colSpan = Math.min(colSpan, columns - col);
+  }
+  const box = {
+    col,
+    colSpan,
+    row: Math.max(0, Math.round(y / rowStride)),
+    rowSpan: Math.max(1, Math.round((px.h + geom.rowGap) / rowStride)),
+    z
+  };
+  if (offset) box.offset = offset;
+  return box;
+}
+
+// src/resolver.ts
+import { gql as gql3 } from "@devicechain/client";
+var ANCHOR_PAGE_SIZE = 500;
+function createDeviceResolver() {
+  const anchorCache = /* @__PURE__ */ new Map();
+  const existsCache = /* @__PURE__ */ new Map();
+  return {
+    devicesForAnchor(anchor) {
+      const key = `${anchor.relationship}|${anchor.targetType}|${anchor.targetToken}`;
+      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) => r.entityRelationships.results.map((rel) => rel.source.token)
+        ).catch((err) => {
+          anchorCache.delete(key);
+          throw err;
+        });
+        anchorCache.set(key, pending);
+      }
+      return pending;
+    },
+    // deviceExists caches only a POSITIVE result (a live device is stable for the
+    // session); a negative and an error both drop the entry so a later check re-queries.
+    // ADR-042 frees a token on delete, so a deleted-then-recreated device must be able to
+    // recover on a long-lived viewer (the availability hook re-checks on a timer while a
+    // widget shows unavailable) rather than staying stuck "gone" for the whole session.
+    // The in-flight promise is still shared, so concurrent checks for one token coalesce.
+    // (Batching distinct tokens into one devicesByToken call is a deferred optimization —
+    // Phase-1 dashboards bind a handful of devices.)
+    deviceExists(deviceToken) {
+      let pending = existsCache.get(deviceToken);
+      if (!pending) {
+        pending = gql3("device-management", DEVICES_BY_TOKEN, { tokens: [deviceToken] }).then((r) => {
+          const exists = r.devicesByToken.some((d) => d.token === deviceToken);
+          if (!exists) existsCache.delete(deviceToken);
+          return exists;
+        }).catch((err) => {
+          existsCache.delete(deviceToken);
+          throw err;
+        });
+        existsCache.set(deviceToken, pending);
+      }
+      return pending;
+    }
+  };
+}
+
+// src/history.ts
+import { gql as gql4 } from "@devicechain/client";
+function defaultHistoryWindow() {
+  const now = Date.now();
+  return {
+    startTime: new Date(now - 60 * 60 * 1e3).toISOString(),
+    endTime: new Date(now).toISOString(),
+    intervalSeconds: 60
+  };
+}
+async function fetchWidgetHistory(widget, window, bindings) {
+  const ds = resolveHistorySelector(widget.datasource, bindings);
+  if (!ds || ds.kind !== "device") return [];
+  try {
+    const deviceToken = ds.deviceToken;
+    const names = ds.measurements.length ? ds.measurements : [void 0];
+    const pages = await Promise.all(
+      names.map(
+        (name) => gql4("event-management", BUCKETED_MEASUREMENTS, {
+          criteria: {
+            deviceToken,
+            name,
+            startTime: window.startTime,
+            endTime: window.endTime,
+            intervalSeconds: window.intervalSeconds
+          }
+        }).then((r) => r.bucketedMeasurements)
+      )
+    );
+    return pages.flat().filter((b) => b.avg != null).map((b) => ({
+      id: `${deviceToken}-${b.name}-${b.bucketStart}`,
+      deviceToken,
+      eventType: 0,
+      occurredTime: b.bucketStart,
+      name: b.name,
+      value: b.avg,
+      classifier: null
+    })).sort((a, b) => a.occurredTime < b.occurredTime ? -1 : 1);
+  } catch {
+    return [];
+  }
+}
+function resolveHistorySelector(ds, bindings) {
+  if (!ds || ds.kind !== "slot") return ds;
+  const binding = bindings && Object.prototype.hasOwnProperty.call(bindings, ds.slot) ? bindings[ds.slot] : void 0;
+  if (binding?.kind === "device") {
+    return { kind: "device", deviceToken: binding.deviceToken, measurements: ds.measurements };
+  }
+  if (binding?.kind === "anchor") {
+    return { kind: "anchor", anchor: binding.anchor, measurements: ds.measurements };
+  }
+  return void 0;
+}
+export {
+  BASE_BREAKPOINT,
+  COMMAND_STATUSES,
+  DashboardDefinitionError,
+  DashboardHub,
+  SYNTHETIC_GENERATORS,
+  SyntheticDataSource,
+  WIDGET_TYPES,
+  activeBreakpoint,
+  addWidget,
+  anchorSlotNames,
+  applySelection,
+  baseBox,
+  bindWidgetSlot,
+  bindingsWithoutScopedSlots,
+  bringToFront,
+  canScopeSlot,
+  clearWidgetDatasource,
+  createDeviceResolver,
+  createEntityLister,
+  defaultHistoryWindow,
+  deleteWidget,
+  effectiveBindings,
+  fetchWidgetHistory,
+  generateWidgetId,
+  gridBoxToPx,
+  hasScopedSlots,
+  isCancellableCommandStatus,
+  isDirty,
+  isTerminalCommandStatus,
+  migrateToSlots,
+  parseBindingManifest,
+  parseDashboardDefinition,
+  parseSlotBinding,
+  pruneSlots,
+  pxToGridBox,
+  resolveConcrete,
+  resolveContextBindings,
+  resolveSlotCandidates,
+  resolveWidgetBox,
+  sameBinding,
+  serializeDefinition,
+  setCanvasGrid,
+  setCanvasSizing,
+  setSlotScope,
+  setTitle,
+  setWidgetBox,
+  stripDefaultBindings,
+  updateWidget,
+  widgetBinding,
+  widgetSlotName
+};
+//# sourceMappingURL=index.js.map