@devicechain/widgets 0.14.0-0

package/dist/index.js

@@ -0,0 +1,2671 @@
+// src/dashboard-renderer.tsx
+import {
+  activeBreakpoint,
+  defaultHistoryWindow,
+  fetchWidgetHistory,
+  resolveWidgetBox
+} from "@devicechain/dashboards";
+import { useEffect as useEffect7, useState as useState7 } from "react";
+
+// src/frame.tsx
+import { createContext, useContext } from "react";
+
+// src/theme.ts
+function css(name) {
+  return `hsl(var(--${name}))`;
+}
+var FALLBACK = {
+  foreground: "hsl(240 10% 3.9%)",
+  mutedForeground: "hsl(240 3.8% 46.1%)",
+  border: "hsl(240 5.9% 90%)",
+  series: [
+    "hsl(220 70% 50%)",
+    "hsl(160 60% 45%)",
+    "hsl(30 80% 55%)",
+    "hsl(280 65% 60%)",
+    "hsl(340 75% 55%)"
+  ]
+};
+function readVar(style, name, fallback) {
+  const raw = style.getPropertyValue(`--${name}`).trim();
+  return raw ? `hsl(${raw})` : fallback;
+}
+function resolveChartTheme(el) {
+  const style = getComputedStyle(el);
+  return {
+    foreground: readVar(style, "foreground", FALLBACK.foreground),
+    mutedForeground: readVar(style, "muted-foreground", FALLBACK.mutedForeground),
+    border: readVar(style, "border", FALLBACK.border),
+    series: FALLBACK.series.map((fallback, i) => readVar(style, `chart-${i + 1}`, fallback))
+  };
+}
+
+// src/frame.tsx
+import { jsx, jsxs } from "react/jsx-runtime";
+var WidgetSubjectContext = createContext(void 0);
+function WidgetSubjectProvider({
+  label,
+  children
+}) {
+  return /* @__PURE__ */ jsx(WidgetSubjectContext.Provider, { value: label, children });
+}
+var WidgetSelectContext = createContext(void 0);
+function WidgetSelectProvider({
+  select,
+  children
+}) {
+  return /* @__PURE__ */ jsx(WidgetSelectContext.Provider, { value: select, children });
+}
+function useWidgetSelect() {
+  return useContext(WidgetSelectContext);
+}
+var WidgetCandidatesContext = createContext(void 0);
+function WidgetCandidatesProvider({
+  candidates,
+  children
+}) {
+  return /* @__PURE__ */ jsx(WidgetCandidatesContext.Provider, { value: candidates, children });
+}
+function useWidgetCandidates() {
+  return useContext(WidgetCandidatesContext);
+}
+function WidgetFrame({ title, subtitle, children, bodyStyle }) {
+  const subject = useContext(WidgetSubjectContext);
+  const sub = subtitle ?? subject;
+  return /* @__PURE__ */ jsxs(
+    "div",
+    {
+      style: {
+        display: "flex",
+        flexDirection: "column",
+        width: "100%",
+        height: "100%",
+        boxSizing: "border-box",
+        background: css("card"),
+        color: css("card-foreground"),
+        border: `1px solid ${css("border")}`,
+        borderRadius: "var(--radius, 8px)",
+        overflow: "hidden"
+      },
+      children: [
+        title || sub ? /* @__PURE__ */ jsxs(
+          "div",
+          {
+            style: {
+              padding: "8px 12px",
+              borderBottom: `1px solid ${css("border")}`
+            },
+            children: [
+              title ? /* @__PURE__ */ jsx("div", { style: { fontSize: 12, fontWeight: 600, color: css("muted-foreground") }, children: title }) : null,
+              sub ? /* @__PURE__ */ jsx(
+                "div",
+                {
+                  title: sub,
+                  style: {
+                    fontSize: 11,
+                    fontWeight: 400,
+                    color: css("muted-foreground"),
+                    opacity: 0.75,
+                    marginTop: title ? 2 : 0,
+                    whiteSpace: "nowrap",
+                    overflow: "hidden",
+                    textOverflow: "ellipsis"
+                  },
+                  children: sub
+                }
+              ) : null
+            ]
+          }
+        ) : null,
+        /* @__PURE__ */ jsx("div", { style: { flex: 1, minHeight: 0, ...bodyStyle }, children })
+      ]
+    }
+  );
+}
+
+// src/hooks.ts
+import {
+  bindingsWithoutScopedSlots,
+  hasScopedSlots,
+  resolveContextBindings,
+  resolveSlotCandidates
+} from "@devicechain/dashboards";
+import { useEffect, useMemo, useRef, useState, useSyncExternalStore } from "react";
+function useResolvedBindings(definition, base, selection, resolver) {
+  const scoped = useMemo(() => hasScopedSlots(definition), [definition]);
+  const overlaid = useMemo(() => ({ ...base, ...selection }), [base, selection]);
+  const [resolved, setResolved] = useState(() => bindingsWithoutScopedSlots(definition, overlaid));
+  const genRef = useRef(0);
+  useEffect(() => {
+    if (!scoped) {
+      setResolved((prev) => sameBindings(prev, overlaid) ? prev : overlaid);
+      return;
+    }
+    const gen = ++genRef.current;
+    let live = true;
+    resolveContextBindings(definition, base, selection, resolver).then((next) => {
+      if (!live || gen !== genRef.current) return;
+      setResolved((prev) => sameBindings(prev, next) ? prev : next);
+    }).catch(() => {
+    });
+    return () => {
+      live = false;
+    };
+  }, [scoped, definition, base, selection, resolver, overlaid]);
+  return scoped ? resolved : overlaid;
+}
+function sameBindings(a, b) {
+  const ak = Object.keys(a).sort();
+  const bk = Object.keys(b).sort();
+  if (ak.length !== bk.length) return false;
+  for (let i = 0; i < ak.length; i += 1) {
+    if (ak[i] !== bk[i]) return false;
+    if (JSON.stringify(a[ak[i]]) !== JSON.stringify(b[bk[i]])) return false;
+  }
+  return true;
+}
+function useSlotCandidates(definition, bindings, resolver, lister) {
+  const bindingsKey = JSON.stringify(bindings);
+  return useMemo(
+    () => {
+      if (!lister) return void 0;
+      return (slot) => resolveSlotCandidates(definition, slot, bindings, resolver, lister);
+    },
+    // bindings read via bindingsKey (value identity), not reference.
+    // eslint-disable-next-line react-hooks/exhaustive-deps
+    [definition, bindingsKey, resolver, lister]
+  );
+}
+function useCandidates(slot) {
+  const provider = useWidgetCandidates();
+  const wired = !!provider;
+  const [state, setState] = useState(() => ({
+    candidates: [],
+    loading: Boolean(provider && slot),
+    error: null
+  }));
+  const genRef = useRef(0);
+  useEffect(() => {
+    if (!provider || !slot) {
+      setState({ candidates: [], loading: false, error: null });
+      return;
+    }
+    const gen = ++genRef.current;
+    let live = true;
+    setState((prev) => ({ ...prev, loading: true, error: null }));
+    provider(slot).then((candidates) => {
+      if (live && gen === genRef.current) setState({ candidates, loading: false, error: null });
+    }).catch((error) => {
+      if (live && gen === genRef.current) setState({ candidates: [], loading: false, error });
+    });
+    return () => {
+      live = false;
+    };
+  }, [provider, slot]);
+  return { ...state, wired };
+}
+var EMPTY = { latest: {}, samples: [], error: null };
+function latestOf(samples) {
+  const latest = {};
+  for (const s of samples) latest[s.name] = s;
+  return latest;
+}
+function useMeasurementStream(hub, datasource, options = {}) {
+  const windowSize = options.window ?? 300;
+  const initialSamples = options.initialSamples;
+  const [live, setLive] = useState(EMPTY);
+  const key = datasource ? JSON.stringify(datasource) : null;
+  useEffect(() => {
+    setLive(EMPTY);
+    if (!datasource) return;
+    return hub.subscribeWidget(datasource, {
+      next: (sample) => setLive((prev) => {
+        const samples = prev.samples.concat(sample);
+        if (samples.length > windowSize) samples.splice(0, samples.length - windowSize);
+        return { latest: { ...prev.latest, [sample.name]: sample }, samples, error: null };
+      }),
+      error: (err) => setLive((prev) => ({ ...prev, error: err }))
+    });
+  }, [hub, key, windowSize]);
+  return useMemo(() => {
+    if (!initialSamples || initialSamples.length === 0) return live;
+    const merged = initialSamples.concat(live.samples);
+    const samples = merged.length > windowSize ? merged.slice(merged.length - windowSize) : merged;
+    return {
+      latest: { ...latestOf(initialSamples), ...live.latest },
+      samples,
+      error: live.error
+    };
+  }, [initialSamples, live, windowSize]);
+}
+var EMPTY_ALARMS = { alarms: [], total: 0, loading: true, error: null };
+function useAlarmStream(hub, subscription) {
+  const [state, setState] = useState(EMPTY_ALARMS);
+  const key = JSON.stringify(subscription);
+  useEffect(() => {
+    setState(EMPTY_ALARMS);
+    return hub.subscribeAlarms(subscription, {
+      next: (snapshot) => setState({ alarms: snapshot.alarms, total: snapshot.total, loading: false, error: null }),
+      error: (err) => setState((prev) => ({ ...prev, loading: false, error: err }))
+    });
+  }, [hub, key]);
+  return state;
+}
+var EMPTY_COMMANDS = {
+  deviceToken: null,
+  commands: [],
+  total: 0,
+  loading: true,
+  error: null
+};
+function useCommandStream(hub, subscription) {
+  const [state, setState] = useState(EMPTY_COMMANDS);
+  const key = JSON.stringify(subscription);
+  useEffect(() => {
+    setState(EMPTY_COMMANDS);
+    return hub.subscribeCommands(subscription, {
+      next: (snapshot) => setState({
+        deviceToken: snapshot.deviceToken,
+        commands: snapshot.commands,
+        total: snapshot.total,
+        loading: false,
+        error: null
+      }),
+      error: (err) => setState((prev) => ({ ...prev, loading: false, error: err }))
+    });
+  }, [hub, key]);
+  return state;
+}
+var EMPTY_LOCATIONS = {
+  locations: [],
+  deviceTokens: [],
+  forbidden: false,
+  loading: true,
+  error: null
+};
+function useLocationStream(hub, subscription) {
+  const [state, setState] = useState(EMPTY_LOCATIONS);
+  const key = JSON.stringify(subscription);
+  useEffect(() => {
+    setState(EMPTY_LOCATIONS);
+    return hub.subscribeLocations(subscription, {
+      next: (snapshot) => setState(
+        snapshot.kind === "forbidden" ? { locations: [], deviceTokens: [], forbidden: true, loading: false, error: null } : {
+          locations: snapshot.locations,
+          deviceTokens: snapshot.deviceTokens,
+          forbidden: false,
+          loading: false,
+          error: null
+        }
+      ),
+      error: (err) => setState((prev) => ({ ...prev, loading: false, error: err }))
+    });
+  }, [hub, key]);
+  return state;
+}
+var AVAILABILITY_REVALIDATE_MS = 6e4;
+function useDatasourceAvailability(hub, datasource) {
+  const [state, setState] = useState("unknown");
+  const key = datasource ? JSON.stringify(datasource) : null;
+  useEffect(() => {
+    if (!datasource) {
+      setState("available");
+      return;
+    }
+    setState("unknown");
+    let cancelled = false;
+    let timer;
+    const stopTimer = () => {
+      if (timer) {
+        clearInterval(timer);
+        timer = void 0;
+      }
+    };
+    const check = () => {
+      hub.isDatasourceAvailable(datasource).then((ok) => {
+        if (cancelled) return;
+        setState(ok ? "available" : "unavailable");
+        if (ok) stopTimer();
+      }).catch(() => {
+        if (cancelled) return;
+        setState("available");
+        stopTimer();
+      });
+    };
+    check();
+    timer = setInterval(check, AVAILABILITY_REVALIDATE_MS);
+    return () => {
+      cancelled = true;
+      stopTimer();
+    };
+  }, [hub, key]);
+  return state;
+}
+function useElementSize() {
+  const ref = useRef(null);
+  const [size, setSize] = useState({ width: 0, height: 0 });
+  useEffect(() => {
+    const el = ref.current;
+    if (!el || typeof ResizeObserver === "undefined") return;
+    const observer = new ResizeObserver((entries) => {
+      const rect = entries[0]?.contentRect;
+      if (!rect) return;
+      setSize(
+        (prev) => prev.width === rect.width && prev.height === rect.height ? prev : { width: rect.width, height: rect.height }
+      );
+    });
+    observer.observe(el);
+    return () => observer.disconnect();
+  }, []);
+  return [ref, size];
+}
+var sharedTheme = null;
+var themeListeners = /* @__PURE__ */ new Set();
+var themeObserver = null;
+function recomputeTheme() {
+  sharedTheme = resolveChartTheme(document.documentElement);
+}
+function subscribeTheme(listener) {
+  if (!themeObserver) {
+    recomputeTheme();
+    themeObserver = new MutationObserver(() => {
+      recomputeTheme();
+      for (const l of themeListeners) l();
+    });
+    themeObserver.observe(document.documentElement, {
+      attributes: true,
+      attributeFilter: ["class", "style"]
+    });
+  }
+  themeListeners.add(listener);
+  return () => {
+    themeListeners.delete(listener);
+    if (themeListeners.size === 0 && themeObserver) {
+      themeObserver.disconnect();
+      themeObserver = null;
+      sharedTheme = null;
+    }
+  };
+}
+function getThemeSnapshot() {
+  if (!sharedTheme) recomputeTheme();
+  return sharedTheme;
+}
+function useChartTheme() {
+  return useSyncExternalStore(subscribeTheme, getThemeSnapshot, getThemeSnapshot);
+}
+
+// src/widget.ts
+function pickSample(latest, name) {
+  return name ? latest[name] : Object.values(latest)[0];
+}
+function optString(options, key) {
+  const value = options?.[key];
+  return typeof value === "string" ? value : void 0;
+}
+function optNumber(options, key) {
+  const value = options?.[key];
+  return typeof value === "number" && Number.isFinite(value) ? value : void 0;
+}
+function optBoolean(options, key) {
+  return options?.[key] === true;
+}
+function primaryMeasurementName(widget) {
+  const explicit = optString(widget.options, "measurement");
+  if (explicit) return explicit;
+  const ds = widget.datasource;
+  if (ds && ds.measurements.length > 0) return ds.measurements[0];
+  return void 0;
+}
+
+// src/widgets/severity.ts
+var SEVERITY_COLORS = {
+  CRITICAL: "#dc2626",
+  // red-600
+  MAJOR: "#f97316",
+  // orange-500
+  MINOR: "#d97706",
+  // amber-600 (readable as foreground; console uses amber-400 as a fill)
+  WARNING: "#0ea5e9",
+  // sky-500 — cool end of the ramp, matching the console
+  INDETERMINATE: "#64748b"
+  // slate-500
+};
+var SEVERITY_ORDER = {
+  CRITICAL: 0,
+  MAJOR: 1,
+  MINOR: 2,
+  WARNING: 3,
+  INDETERMINATE: 4
+};
+var UNKNOWN_COLOR = "#64748b";
+function severityColor(severity) {
+  return SEVERITY_COLORS[severity] ?? UNKNOWN_COLOR;
+}
+function severityRank(severity) {
+  return SEVERITY_ORDER[severity] ?? 99;
+}
+function severityLabel(severity) {
+  if (!severity) return "";
+  return severity.charAt(0).toUpperCase() + severity.slice(1).toLowerCase();
+}
+function highestSeverity(severities) {
+  let best;
+  for (const s of severities) {
+    if (best === void 0 || severityRank(s) < severityRank(best)) best = s;
+  }
+  return best;
+}
+
+// src/widgets/alarm-count.tsx
+import { jsx as jsx2, jsxs as jsxs2 } from "react/jsx-runtime";
+var clamp = (v, lo, hi) => Math.max(lo, Math.min(hi, v));
+function AlarmCount({ widget, data }) {
+  const [sizeRef, size] = useElementSize();
+  const { total, alarms, loading } = data;
+  const worst = highestSeverity(alarms.map((a) => a.severity));
+  const alerting = total > 0 && worst != null;
+  const color = alerting ? severityColor(worst) : css("muted-foreground");
+  const valueFont = size.height > 0 ? clamp(Math.round(size.height / 2.8), 20, 56) : 40;
+  const display = loading && total === 0 ? "\u2014" : String(total);
+  const unit = total === 1 ? "alarm" : "alarms";
+  const ariaLabel = alerting ? `${total} ${unit}, worst severity ${severityLabel(worst)}` : `${total} ${unit}`;
+  return /* @__PURE__ */ jsx2(WidgetFrame, { title: optString(widget.options, "title"), children: /* @__PURE__ */ jsxs2(
+    "div",
+    {
+      ref: sizeRef,
+      style: {
+        display: "flex",
+        flexDirection: "column",
+        justifyContent: "center",
+        alignItems: "center",
+        height: "100%",
+        padding: "12px 16px",
+        textAlign: "center"
+      },
+      children: [
+        /* @__PURE__ */ jsx2("div", { "aria-label": ariaLabel, style: { fontSize: valueFont, fontWeight: 700, lineHeight: 1, color }, children: display }),
+        /* @__PURE__ */ jsxs2(
+          "div",
+          {
+            style: {
+              fontSize: 11,
+              color: css("muted-foreground"),
+              marginTop: 6,
+              textTransform: "uppercase",
+              letterSpacing: "0.05em"
+            },
+            children: [
+              /* @__PURE__ */ jsx2("span", { children: unit }),
+              alerting ? /* @__PURE__ */ jsx2("span", { children: ` \xB7 worst ${severityLabel(worst)}` }) : null
+            ]
+          }
+        )
+      ]
+    }
+  ) });
+}
+
+// src/widgets/alarm-table.tsx
+import { useState as useState3 } from "react";
+
+// src/flash.tsx
+import { useEffect as useEffect2, useRef as useRef2, useState as useState2 } from "react";
+
+// src/format.ts
+function formatTimestamp(iso) {
+  if (!iso) return "";
+  const date = new Date(iso);
+  return Number.isNaN(date.getTime()) ? iso : date.toLocaleTimeString();
+}
+function formatDateTime(iso) {
+  if (!iso) return "";
+  const date = new Date(iso);
+  return Number.isNaN(date.getTime()) ? iso : date.toLocaleString();
+}
+function formatValue(value, precision) {
+  if (value == null) return "\u2014";
+  if (precision == null) return String(value);
+  const places = Math.min(100, Math.max(0, Math.trunc(precision)));
+  return value.toFixed(places);
+}
+
+// src/flash.tsx
+import { jsx as jsx3 } from "react/jsx-runtime";
+var UP = {
+  fg: "var(--flash-up, hsl(142 72% 40%))",
+  bg: "var(--flash-up-bg, hsl(142 72% 45% / 0.16))"
+};
+var DOWN = {
+  fg: "var(--flash-down, hsl(0 72% 51%))",
+  bg: "var(--flash-down-bg, hsl(0 72% 55% / 0.16))"
+};
+var HOLD_MS = 400;
+var FADE_MS = 600;
+function useFlashOnChange(value, enabled, identity) {
+  const prev = useRef2(value);
+  const prevIdentity = useRef2(identity);
+  const [direction, setDirection] = useState2(null);
+  useEffect2(() => {
+    const before = prev.current;
+    const sameEntity = prevIdentity.current === identity;
+    prev.current = value;
+    prevIdentity.current = identity;
+    if (!enabled || !sameEntity || typeof value !== "number" || typeof before !== "number" || !Number.isFinite(value) || !Number.isFinite(before) || value === before) {
+      setDirection(null);
+      return;
+    }
+    setDirection(value > before ? "up" : "down");
+    const timer = setTimeout(() => setDirection(null), HOLD_MS);
+    return () => clearTimeout(timer);
+  }, [value, enabled, identity]);
+  return enabled ? direction : null;
+}
+function flashTextStyle(direction, fadeMs = FADE_MS) {
+  if (direction) return { color: direction === "up" ? UP.fg : DOWN.fg, transition: "none" };
+  return { transition: `color ${fadeMs}ms ease-out` };
+}
+function flashBackgroundStyle(direction, fadeMs = FADE_MS) {
+  if (direction) {
+    return { backgroundColor: direction === "up" ? UP.bg : DOWN.bg, transition: "none" };
+  }
+  return { transition: `background-color ${fadeMs}ms ease-out` };
+}
+function FlashValue({
+  value,
+  precision,
+  enabled,
+  identity,
+  baseColor = "inherit",
+  style
+}) {
+  const direction = useFlashOnChange(value, enabled, identity);
+  return /* @__PURE__ */ jsx3("span", { style: { color: baseColor, ...style, ...flashTextStyle(direction) }, children: formatValue(value, precision) });
+}
+
+// src/widgets/alarm-table.tsx
+import { Fragment, jsx as jsx4, jsxs as jsxs3 } from "react/jsx-runtime";
+var cell = { padding: "6px 10px", textAlign: "left", whiteSpace: "nowrap" };
+var headCell = {
+  ...cell,
+  position: "sticky",
+  top: 0,
+  background: css("card"),
+  fontSize: 11,
+  fontWeight: 600,
+  textTransform: "uppercase",
+  letterSpacing: "0.04em",
+  color: css("muted-foreground"),
+  borderBottom: `1px solid ${css("border")}`
+};
+function statusLabel(alarm) {
+  if (alarm.state === "CLEARED") return "Cleared";
+  return alarm.acknowledged ? "Acknowledged" : "Active";
+}
+function AlarmTable({ widget, data, actions }) {
+  const { alarms, total, loading } = data;
+  const canAct = actions?.can("alarm:write") ?? false;
+  const columns = canAct ? 8 : 7;
+  const precision = optNumber(widget.options, "precision");
+  const flash = optBoolean(widget.options, "flashOnChange");
+  const select = useWidgetSelect();
+  const selectionTarget = optString(widget.options, "selectionTarget");
+  const drillTo = select && selectionTarget ? { select, slot: selectionTarget } : void 0;
+  return /* @__PURE__ */ jsx4(WidgetFrame, { title: optString(widget.options, "title"), children: /* @__PURE__ */ jsxs3("div", { style: { display: "flex", flexDirection: "column", height: "100%" }, children: [
+    /* @__PURE__ */ jsx4("div", { style: { flex: 1, minHeight: 0, overflow: "auto" }, children: /* @__PURE__ */ jsxs3(
+      "table",
+      {
+        style: {
+          width: "100%",
+          borderCollapse: "collapse",
+          fontSize: 13,
+          color: css("foreground"),
+          fontVariantNumeric: "tabular-nums"
+        },
+        children: [
+          /* @__PURE__ */ jsx4("thead", { children: /* @__PURE__ */ jsxs3("tr", { children: [
+            /* @__PURE__ */ jsx4("th", { style: { ...headCell, width: 4, padding: 0 }, "aria-hidden": "true" }),
+            /* @__PURE__ */ jsx4("th", { scope: "col", style: headCell, children: "Severity" }),
+            /* @__PURE__ */ jsx4("th", { scope: "col", style: headCell, children: "Status" }),
+            /* @__PURE__ */ jsx4("th", { scope: "col", style: headCell, children: "Originator" }),
+            /* @__PURE__ */ jsx4("th", { scope: "col", style: headCell, children: "Alarm" }),
+            /* @__PURE__ */ jsx4("th", { scope: "col", style: { ...headCell, textAlign: "right" }, children: "Value" }),
+            /* @__PURE__ */ jsx4("th", { scope: "col", style: headCell, children: "Raised" }),
+            canAct ? /* @__PURE__ */ jsx4("th", { scope: "col", style: { ...headCell, textAlign: "right" }, children: "Actions" }) : null
+          ] }) }),
+          /* @__PURE__ */ jsx4("tbody", { children: alarms.length === 0 ? /* @__PURE__ */ jsx4("tr", { children: /* @__PURE__ */ jsx4("td", { colSpan: columns, style: { ...cell, textAlign: "center", color: css("muted-foreground") }, children: loading ? "Loading\u2026" : "No alarms" }) }) : alarms.map((alarm) => {
+            const color = severityColor(alarm.severity);
+            return /* @__PURE__ */ jsxs3("tr", { style: { borderBottom: `1px solid ${css("border")}` }, children: [
+              /* @__PURE__ */ jsx4("td", { "aria-hidden": "true", style: { padding: 0, width: 4, background: color } }),
+              /* @__PURE__ */ jsx4("td", { style: cell, children: /* @__PURE__ */ jsxs3("span", { style: { display: "inline-flex", alignItems: "center", gap: 6 }, children: [
+                /* @__PURE__ */ jsx4(
+                  "span",
+                  {
+                    "aria-hidden": "true",
+                    style: { width: 8, height: 8, borderRadius: "50%", background: color, flexShrink: 0 }
+                  }
+                ),
+                severityLabel(alarm.severity)
+              ] }) }),
+              /* @__PURE__ */ jsx4("td", { style: { ...cell, color: css("muted-foreground") }, children: statusLabel(alarm) }),
+              /* @__PURE__ */ jsx4("td", { style: cell, children: /* @__PURE__ */ jsx4(OriginatorCell, { alarm, drillTo }) }),
+              /* @__PURE__ */ jsx4("td", { style: cell, title: alarm.message ?? void 0, children: alarm.alarmKey }),
+              /* @__PURE__ */ jsx4("td", { style: { ...cell, textAlign: "right" }, children: /* @__PURE__ */ jsx4(
+                FlashValue,
+                {
+                  value: alarm.lastValue,
+                  precision,
+                  enabled: flash,
+                  identity: alarm.token
+                }
+              ) }),
+              /* @__PURE__ */ jsx4("td", { style: { ...cell, color: css("muted-foreground") }, children: formatDateTime(alarm.raisedTime) }),
+              canAct ? /* @__PURE__ */ jsx4("td", { style: { ...cell, textAlign: "right" }, children: /* @__PURE__ */ jsx4(AlarmRowActions, { alarm, actions }) }) : null
+            ] }, alarm.token);
+          }) })
+        ]
+      }
+    ) }),
+    total > alarms.length ? /* @__PURE__ */ jsxs3(
+      "div",
+      {
+        style: {
+          padding: "4px 10px",
+          fontSize: 11,
+          color: css("muted-foreground"),
+          borderTop: `1px solid ${css("border")}`
+        },
+        children: [
+          "Showing ",
+          alarms.length,
+          " of ",
+          total
+        ]
+      }
+    ) : null
+  ] }) });
+}
+function OriginatorCell({
+  alarm,
+  drillTo
+}) {
+  if (drillTo && alarm.originatorType === "device" && alarm.originatorToken) {
+    const token = alarm.originatorToken;
+    return /* @__PURE__ */ jsx4(
+      "button",
+      {
+        type: "button",
+        onClick: () => drillTo.select({ slot: drillTo.slot, binding: { kind: "device", deviceToken: token } }),
+        title: `Show ${token} in the linked widgets`,
+        style: {
+          padding: 0,
+          border: "none",
+          background: "none",
+          font: "inherit",
+          color: css("primary"),
+          cursor: "pointer",
+          textDecoration: "underline",
+          textUnderlineOffset: 2
+        },
+        children: token
+      }
+    );
+  }
+  return /* @__PURE__ */ jsx4(Fragment, { children: alarm.originatorToken ?? alarm.originatorType });
+}
+var actionButton = {
+  padding: "2px 8px",
+  fontSize: 12,
+  lineHeight: 1.4,
+  borderRadius: 4,
+  border: `1px solid ${css("border")}`,
+  background: css("card"),
+  color: css("foreground"),
+  cursor: "pointer"
+};
+function AlarmRowActions({ alarm, actions }) {
+  const [pending, setPending] = useState3(null);
+  const [failed, setFailed] = useState3(false);
+  if (alarm.state !== "ACTIVE") {
+    return /* @__PURE__ */ jsx4("span", { style: { color: css("muted-foreground") }, children: "\u2014" });
+  }
+  const run = (kind, op) => {
+    setPending(kind);
+    setFailed(false);
+    let promise;
+    try {
+      promise = op();
+    } catch {
+      setFailed(true);
+      setPending(null);
+      return;
+    }
+    promise.catch(() => setFailed(true)).finally(() => setPending(null));
+  };
+  return /* @__PURE__ */ jsxs3("span", { style: { display: "inline-flex", gap: 6, justifyContent: "flex-end", alignItems: "center" }, children: [
+    failed ? /* @__PURE__ */ jsx4(
+      "span",
+      {
+        role: "img",
+        "aria-label": "Action failed \u2014 retry",
+        title: "Action failed \u2014 retry",
+        style: { color: severityColor("CRITICAL"), fontSize: 12 },
+        children: "\u26A0"
+      }
+    ) : null,
+    !alarm.acknowledged ? /* @__PURE__ */ jsx4(
+      "button",
+      {
+        type: "button",
+        style: { ...actionButton, opacity: pending ? 0.6 : 1 },
+        disabled: pending !== null,
+        "aria-busy": pending === "ack",
+        "aria-label": `Acknowledge alarm ${alarm.alarmKey}`,
+        onClick: () => run("ack", () => actions.acknowledgeAlarm(alarm.token)),
+        children: pending === "ack" ? "\u2026" : "Ack"
+      }
+    ) : null,
+    /* @__PURE__ */ jsx4(
+      "button",
+      {
+        type: "button",
+        style: { ...actionButton, opacity: pending ? 0.6 : 1 },
+        disabled: pending !== null,
+        "aria-busy": pending === "clear",
+        "aria-label": `Clear alarm ${alarm.alarmKey}`,
+        onClick: () => run("clear", () => actions.clearAlarm(alarm.token)),
+        children: pending === "clear" ? "\u2026" : "Clear"
+      }
+    )
+  ] });
+}
+
+// src/widgets/command-button.tsx
+import { useEffect as useEffect3, useMemo as useMemo2, useRef as useRef3, useState as useState4 } from "react";
+
+// src/widgets/command-status.ts
+import { isTerminalCommandStatus } from "@devicechain/dashboards";
+var STATUS_COLORS = {
+  SUCCESSFUL: "#16a34a",
+  // green-600 — acknowledged by the device
+  FAILED: "#dc2626",
+  // red-600
+  TIMEOUT: "#dc2626",
+  // red-600 — never acknowledged in time
+  EXPIRED: "#64748b",
+  // slate-500 — lapsed before it was ever sent
+  CANCELLED: "#7c3aed",
+  // violet-600 — deliberately called off; a decision, not a failure
+  QUEUED: "#0284c7",
+  // sky-600 — in flight
+  SENT: "#0284c7",
+  HELD: "#d97706",
+  // amber-600 — withheld: the device is absent, the command still stands
+  PARKED: "#f59e0b"
+  // amber-500 — published, nobody home; held for the device's return
+};
+var UNKNOWN_COLOR2 = "#64748b";
+function commandStatusColor(status) {
+  return STATUS_COLORS[status] ?? UNKNOWN_COLOR2;
+}
+function isTerminalStatus(status) {
+  return isTerminalCommandStatus(status);
+}
+function commandStatusLabel(status) {
+  if (!status) return "";
+  return status.charAt(0).toUpperCase() + status.slice(1).toLowerCase();
+}
+
+// src/widgets/command-params.ts
+var DATA_TYPES = /* @__PURE__ */ new Set(["DOUBLE", "INT", "BOOLEAN", "STRING"]);
+function parseParameterSchema(schema) {
+  if (!schema) return [];
+  let parsed;
+  try {
+    parsed = JSON.parse(schema);
+  } catch {
+    return [];
+  }
+  if (!Array.isArray(parsed)) return [];
+  const out = [];
+  for (const raw of parsed) {
+    const norm = normalizeParam(raw);
+    if (norm) out.push(norm);
+  }
+  return out;
+}
+function normalizeParam(raw) {
+  if (typeof raw !== "object" || raw === null) return null;
+  const r = raw;
+  if (typeof r.name !== "string") return null;
+  const param = { name: r.name };
+  if (typeof r.description === "string") param.description = r.description;
+  if (r.kind === "OBJECT") param.kind = "OBJECT";
+  else if (r.kind === "SCALAR") param.kind = "SCALAR";
+  if (typeof r.dataType === "string" && DATA_TYPES.has(r.dataType)) {
+    param.dataType = r.dataType;
+  }
+  if (typeof r.unit === "string") param.unit = r.unit;
+  if (r.required === true) param.required = true;
+  if (typeof r.default === "string") param.default = r.default;
+  if (typeof r.minValue === "number" && Number.isFinite(r.minValue)) param.minValue = r.minValue;
+  if (typeof r.maxValue === "number" && Number.isFinite(r.maxValue)) param.maxValue = r.maxValue;
+  if (Array.isArray(r.enum)) {
+    const values = r.enum.filter((v) => typeof v === "string");
+    if (values.length > 0) param.enum = values;
+  }
+  return param;
+}
+function isScalar(param) {
+  return param.kind !== "OBJECT";
+}
+function parseBool(raw) {
+  const s = raw.trim().toLowerCase();
+  return s === "true" || s === "1" || s === "t" || s === "yes" || s === "on";
+}
+function defaultValues(params) {
+  const values = {};
+  for (const p of params) {
+    if (!isScalar(p)) continue;
+    if (p.dataType === "BOOLEAN") values[p.name] = parseBool(p.default ?? "") ? "true" : "false";
+    else if (p.default != null) values[p.name] = p.default;
+  }
+  return values;
+}
+function validateParams(params, values) {
+  const errors = {};
+  for (const p of params) {
+    if (!isScalar(p)) {
+      if (p.required) errors[p.name] = "Structured parameter \u2014 not supported here";
+      continue;
+    }
+    if (p.dataType === "BOOLEAN") continue;
+    const raw = (values[p.name] ?? "").trim();
+    if (raw === "") {
+      if (p.required) errors[p.name] = "Required";
+      continue;
+    }
+    if (p.dataType === "INT" || p.dataType === "DOUBLE") {
+      const n = Number(raw);
+      if (!Number.isFinite(n)) {
+        errors[p.name] = "Must be a number";
+      } else if (p.dataType === "INT" && !Number.isInteger(n)) {
+        errors[p.name] = "Must be a whole number";
+      } else if (p.minValue != null && n < p.minValue) {
+        errors[p.name] = `Must be \u2265 ${p.minValue}`;
+      } else if (p.maxValue != null && n > p.maxValue) {
+        errors[p.name] = `Must be \u2264 ${p.maxValue}`;
+      }
+    }
+  }
+  return errors;
+}
+function buildPayload(params, values) {
+  const payload = {};
+  for (const p of params) {
+    if (!isScalar(p)) continue;
+    const raw = (values[p.name] ?? "").trim();
+    if (p.dataType === "BOOLEAN") {
+      payload[p.name] = parseBool(raw);
+      continue;
+    }
+    if (raw === "") continue;
+    payload[p.name] = coerce(p, raw);
+  }
+  return Object.keys(payload).length === 0 ? void 0 : JSON.stringify(payload);
+}
+function coerce(param, raw) {
+  switch (param.dataType) {
+    case "INT":
+    case "DOUBLE": {
+      const n = Number(raw);
+      return Number.isFinite(n) ? n : raw;
+    }
+    case "BOOLEAN":
+      return parseBool(raw);
+    default:
+      return raw;
+  }
+}
+
+// src/widgets/command-button.tsx
+import { Fragment as Fragment2, jsx as jsx5, jsxs as jsxs4 } from "react/jsx-runtime";
+function CommandButton({ widget, data, actions }) {
+  const commandName = optString(widget.options, "commandName");
+  const commandLabel = optString(widget.options, "commandLabel") ?? commandName;
+  const parameterSchema = optString(widget.options, "parameterSchema") ?? null;
+  const params = useMemo2(() => parseParameterSchema(parameterSchema), [parameterSchema]);
+  const schemaKey = `${commandName ?? ""}::${parameterSchema ?? ""}`;
+  const [values, setValues] = useState4(() => defaultValues(params));
+  const [errors, setErrors] = useState4({});
+  const [pending, setPending] = useState4(false);
+  const [sendError, setSendError] = useState4(null);
+  const [sentToken, setSentToken] = useState4(null);
+  const sendGen = useRef3(0);
+  useEffect3(() => {
+    sendGen.current += 1;
+    setValues(defaultValues(params));
+    setErrors({});
+    setSendError(null);
+    setSentToken(null);
+  }, [schemaKey]);
+  const canWrite = actions?.can("command:write") ?? false;
+  const hasSeam = typeof actions?.sendCommand === "function";
+  const deviceToken = data.deviceToken;
+  const formDisabled = !canWrite || !hasSeam || pending;
+  const canSend = !formDisabled && !!deviceToken && !!commandName;
+  const setField = (name, value) => {
+    setValues((prev) => ({ ...prev, [name]: value }));
+    setErrors((prev) => prev[name] ? { ...prev, [name]: "" } : prev);
+    setSendError(null);
+  };
+  const send = () => {
+    if (!deviceToken || !commandName || !actions?.sendCommand) return;
+    const found = validateParams(params, values);
+    const active = Object.fromEntries(Object.entries(found).filter(([, v]) => v));
+    if (Object.keys(active).length > 0) {
+      setErrors(active);
+      return;
+    }
+    const payload = buildPayload(params, values);
+    const gen = sendGen.current;
+    setPending(true);
+    setSendError(null);
+    let promise;
+    try {
+      promise = actions.sendCommand(deviceToken, commandName, payload);
+    } catch {
+      setSendError(SEND_FAILED);
+      setPending(false);
+      return;
+    }
+    promise.then((dispatch) => {
+      if (gen !== sendGen.current) return;
+      if (dispatch.status === "rejected") {
+        setSendError(dispatch.reason);
+        return;
+      }
+      setSentToken(dispatch.token);
+    }).catch(() => {
+      if (gen === sendGen.current) setSendError(SEND_FAILED);
+    }).finally(() => {
+      if (gen === sendGen.current) setPending(false);
+    });
+  };
+  return /* @__PURE__ */ jsx5(WidgetFrame, { title: optString(widget.options, "title"), children: /* @__PURE__ */ jsx5("div", { style: { display: "flex", flexDirection: "column", height: "100%", gap: 10 }, children: !commandName ? /* @__PURE__ */ jsx5("div", { style: { ...hint, margin: "auto" }, children: "No command configured." }) : /* @__PURE__ */ jsxs4(Fragment2, { children: [
+    /* @__PURE__ */ jsxs4("div", { style: { display: "flex", flexDirection: "column", gap: 8 }, children: [
+      params.map(
+        (param) => isScalar(param) ? /* @__PURE__ */ jsx5(
+          ParamField,
+          {
+            widgetId: widget.id,
+            param,
+            value: values[param.name] ?? "",
+            error: errors[param.name],
+            disabled: formDisabled,
+            onChange: (v) => setField(param.name, v)
+          },
+          param.name
+        ) : (
+          // A structured (OBJECT) parameter isn't form-editable. A REQUIRED one
+          // blocks sending (validateParams flags it); flag that in the note.
+          /* @__PURE__ */ jsxs4("div", { style: { ...hint, color: param.required ? commandStatusColor("FAILED") : css("muted-foreground") }, children: [
+            param.name,
+            ": ",
+            param.required ? "required " : "",
+            "structured parameter \u2014 not supported here."
+          ] }, param.name)
+        )
+      ),
+      /* @__PURE__ */ jsx5(
+        "button",
+        {
+          type: "button",
+          style: { ...sendButton, opacity: canSend ? 1 : 0.55, cursor: canSend ? "pointer" : "not-allowed" },
+          disabled: !canSend,
+          "aria-busy": pending,
+          onClick: send,
+          children: pending ? "Sending\u2026" : `Send ${commandLabel}`
+        }
+      ),
+      !canWrite ? /* @__PURE__ */ jsx5("div", { style: hint, children: "You don\u2019t have permission to issue commands." }) : !hasSeam ? /* @__PURE__ */ jsx5("div", { style: hint, children: "Commands aren\u2019t available in this view." }) : !deviceToken ? /* @__PURE__ */ jsx5("div", { style: hint, children: "No device is selected for this command." }) : null,
+      sendError ? /* @__PURE__ */ jsx5("div", { role: "alert", style: { ...hint, color: commandStatusColor("FAILED") }, children: sendError }) : null
+    ] }),
+    /* @__PURE__ */ jsx5(CommandHistory, { commands: data.commands, sentToken, loading: data.loading, error: data.error })
+  ] }) }) });
+}
+function ParamField({
+  widgetId,
+  param,
+  value,
+  error,
+  disabled,
+  onChange
+}) {
+  const labelId = `cmd-${widgetId}-${param.name}`;
+  const unit = param.unit ? ` (${param.unit})` : "";
+  return /* @__PURE__ */ jsxs4("label", { htmlFor: labelId, style: { display: "flex", flexDirection: "column", gap: 3 }, children: [
+    /* @__PURE__ */ jsxs4("span", { style: { fontSize: 12, color: css("muted-foreground") }, children: [
+      param.name,
+      unit,
+      param.required ? /* @__PURE__ */ jsx5("span", { style: { color: commandStatusColor("FAILED") }, children: " *" }) : null
+    ] }),
+    /* @__PURE__ */ jsx5(ParamInput, { id: labelId, param, value, disabled, onChange }),
+    error ? /* @__PURE__ */ jsx5("span", { style: { fontSize: 11, color: commandStatusColor("FAILED") }, children: error }) : null
+  ] });
+}
+function ParamInput({
+  id,
+  param,
+  value,
+  disabled,
+  onChange
+}) {
+  if (param.enum && param.enum.length > 0) {
+    return /* @__PURE__ */ jsxs4("select", { id, style: inputStyle, value, disabled, onChange: (e) => onChange(e.target.value), children: [
+      !param.required ? /* @__PURE__ */ jsx5("option", { value: "", children: "\u2014" }) : null,
+      param.enum.map((opt) => /* @__PURE__ */ jsx5("option", { value: opt, children: opt }, opt))
+    ] });
+  }
+  if (param.dataType === "BOOLEAN") {
+    return /* @__PURE__ */ jsx5(
+      "input",
+      {
+        id,
+        type: "checkbox",
+        style: { width: 16, height: 16 },
+        checked: parseBool(value),
+        disabled,
+        onChange: (e) => onChange(e.target.checked ? "true" : "false")
+      }
+    );
+  }
+  const numeric = param.dataType === "INT" || param.dataType === "DOUBLE";
+  return /* @__PURE__ */ jsx5(
+    "input",
+    {
+      id,
+      type: numeric ? "number" : "text",
+      style: inputStyle,
+      value,
+      disabled,
+      min: param.minValue ?? void 0,
+      max: param.maxValue ?? void 0,
+      step: param.dataType === "INT" ? 1 : "any",
+      placeholder: param.default ?? void 0,
+      onChange: (e) => onChange(e.target.value)
+    }
+  );
+}
+function CommandHistory({
+  commands,
+  sentToken,
+  loading,
+  error
+}) {
+  const empty = commands.length === 0;
+  return /* @__PURE__ */ jsx5(
+    "div",
+    {
+      style: {
+        flex: 1,
+        minHeight: 0,
+        overflow: "auto",
+        borderTop: `1px solid ${css("border")}`,
+        paddingTop: 6
+      },
+      children: empty ? /* @__PURE__ */ jsx5("div", { style: { ...hint, textAlign: "center", color: error ? commandStatusColor("FAILED") : css("muted-foreground") }, children: error ? "Couldn\u2019t load command history." : loading ? "Loading\u2026" : "No commands issued yet." }) : /* @__PURE__ */ jsx5("ul", { style: { listStyle: "none", margin: 0, padding: 0, display: "flex", flexDirection: "column", gap: 4 }, children: commands.map((command) => /* @__PURE__ */ jsxs4(
+        "li",
+        {
+          style: {
+            display: "flex",
+            alignItems: "center",
+            gap: 8,
+            fontSize: 12,
+            // Highlight the command just issued from this widget.
+            fontWeight: command.token === sentToken ? 600 : 400
+          },
+          children: [
+            /* @__PURE__ */ jsx5(StatusBadge, { status: command.status }),
+            /* @__PURE__ */ jsx5("span", { style: { color: css("foreground"), whiteSpace: "nowrap", overflow: "hidden", textOverflow: "ellipsis" }, children: command.name }),
+            /* @__PURE__ */ jsx5("span", { style: { marginLeft: "auto", color: css("muted-foreground"), whiteSpace: "nowrap" }, children: formatDateTime(command.queuedTime) })
+          ]
+        },
+        command.token
+      )) })
+    }
+  );
+}
+function StatusBadge({ status }) {
+  const color = commandStatusColor(status);
+  return /* @__PURE__ */ jsxs4(
+    "span",
+    {
+      style: {
+        display: "inline-flex",
+        alignItems: "center",
+        gap: 4,
+        flexShrink: 0,
+        fontSize: 11,
+        fontWeight: 600,
+        color
+      },
+      children: [
+        /* @__PURE__ */ jsx5("span", { "aria-hidden": "true", style: { width: 7, height: 7, borderRadius: "50%", background: color } }),
+        commandStatusLabel(status)
+      ]
+    }
+  );
+}
+var hint = { fontSize: 11, color: css("muted-foreground") };
+var SEND_FAILED = "Couldn\u2019t issue the command. Try again.";
+var inputStyle = {
+  width: "100%",
+  boxSizing: "border-box",
+  padding: "4px 8px",
+  fontSize: 13,
+  borderRadius: 4,
+  border: `1px solid ${css("border")}`,
+  background: css("background"),
+  color: css("foreground")
+};
+var sendButton = {
+  padding: "6px 12px",
+  fontSize: 13,
+  fontWeight: 600,
+  borderRadius: 4,
+  border: "none",
+  background: css("primary"),
+  color: css("background"),
+  marginTop: 2
+};
+
+// src/widgets/entity-selector.tsx
+import { useEffect as useEffect4, useState as useState5 } from "react";
+import { Fragment as Fragment3, jsx as jsx6, jsxs as jsxs5 } from "react/jsx-runtime";
+function tokenOf(b) {
+  return b.kind === "device" ? b.deviceToken : b.anchor.targetToken;
+}
+var control = {
+  width: "100%",
+  fontSize: 14,
+  padding: "8px 10px",
+  borderRadius: 6,
+  border: `1px solid ${css("border")}`,
+  background: css("background"),
+  color: css("foreground")
+};
+var hint2 = {
+  fontSize: 12,
+  color: css("muted-foreground")
+};
+function EntitySelector({ widget }) {
+  const select = useWidgetSelect();
+  const target = optString(widget.options, "selectionTarget");
+  const { candidates, loading, error, wired } = useCandidates(target);
+  const title = optString(widget.options, "title");
+  const [pending, setPending] = useState5(null);
+  const selected = candidates.find((c) => c.selected);
+  const selectedToken = selected ? tokenOf(selected.binding) : "";
+  useEffect4(() => {
+    if (pending !== null && (selectedToken === pending || !candidates.some((c) => tokenOf(c.binding) === pending))) {
+      setPending(null);
+    }
+  }, [candidates, selectedToken, pending]);
+  const inert = !select || !target || !wired;
+  const value = pending ?? selectedToken;
+  const onChange = (e) => {
+    const token = e.target.value;
+    if (!token) return;
+    const candidate = candidates.find((c) => tokenOf(c.binding) === token);
+    if (select && target && candidate) {
+      setPending(token);
+      select({ slot: target, binding: candidate.binding });
+    }
+  };
+  return /* @__PURE__ */ jsx6(WidgetFrame, { title, children: /* @__PURE__ */ jsx6("div", { style: { display: "flex", flexDirection: "column", gap: 8, padding: "12px 16px", height: "100%" }, children: inert ? /* @__PURE__ */ jsx6("span", { style: hint2, children: select && target ? "Selection isn\u2019t available here." : select ? "No target slot configured." : "Selection is available on the live dashboard." }) : /* @__PURE__ */ jsxs5(Fragment3, { children: [
+    /* @__PURE__ */ jsxs5(
+      "select",
+      {
+        style: { ...control, opacity: loading ? 0.6 : 1 },
+        value,
+        disabled: candidates.length === 0,
+        onChange,
+        "aria-label": title || `Select ${target}`,
+        children: [
+          /* @__PURE__ */ jsx6("option", { value: "", disabled: true, children: loading ? "Loading\u2026" : candidates.length === 0 ? "No options" : "Select\u2026" }),
+          candidates.map((c) => /* @__PURE__ */ jsx6("option", { value: tokenOf(c.binding), children: c.label }, tokenOf(c.binding)))
+        ]
+      }
+    ),
+    error ? /* @__PURE__ */ jsx6("span", { style: hint2, children: "Couldn\u2019t load options." }) : null
+  ] }) }) });
+}
+
+// src/widgets/gauge.tsx
+import { useMemo as useMemo3 } from "react";
+
+// src/chart-options.ts
+function distinctNames(samples) {
+  const seen = [];
+  for (const s of samples) {
+    if (!seen.includes(s.name)) seen.push(s.name);
+  }
+  return seen;
+}
+var clamp2 = (v, lo, hi) => Math.max(lo, Math.min(hi, v));
+function shortSide(size) {
+  const s = Math.min(size?.width ?? 0, size?.height ?? 0);
+  return s > 0 ? s : 200;
+}
+function buildLineOption(samples, theme, options = {}, size) {
+  const names = options.measurements?.length ? options.measurements : distinctNames(samples);
+  const axisFont = clamp2(Math.round(shortSide(size) / 22), 8, 12);
+  const series = names.map((name, i) => {
+    const color = theme.series[i % theme.series.length];
+    return {
+      name,
+      type: "line",
+      showSymbol: false,
+      lineStyle: { color },
+      itemStyle: { color },
+      data: samples.filter((s) => s.name === name && s.value != null && s.occurredTime != null).map((s) => [s.occurredTime, s.value])
+    };
+  });
+  return {
+    animation: false,
+    textStyle: { color: theme.foreground, fontSize: axisFont },
+    grid: { left: 8, right: 12, top: names.length > 1 ? 28 : 12, bottom: 8, containLabel: true },
+    tooltip: { trigger: "axis" },
+    legend: names.length > 1 ? { textStyle: { color: theme.mutedForeground, fontSize: axisFont }, top: 0 } : void 0,
+    xAxis: {
+      type: "time",
+      axisLine: { lineStyle: { color: theme.border } },
+      axisLabel: { color: theme.mutedForeground, fontSize: axisFont, hideOverlap: true }
+    },
+    yAxis: {
+      type: "value",
+      splitLine: { lineStyle: { color: theme.border } },
+      axisLabel: { color: theme.mutedForeground, fontSize: axisFont }
+    },
+    series
+  };
+}
+function buildGaugeOption(value, theme, options = {}, size) {
+  const min = options.min ?? 0;
+  const max = options.max ?? 100;
+  const accent = theme.series[0];
+  const unitSuffix = options.unit ? ` ${options.unit}` : "";
+  const s = shortSide(size);
+  const arcWidth = clamp2(Math.round(s / 26), 4, 12);
+  const labelFont = clamp2(Math.round(s / 20), 8, 13);
+  const valueFont = clamp2(Math.round(s / 7), 14, 40);
+  return {
+    animation: false,
+    series: [
+      {
+        type: "gauge",
+        min,
+        max,
+        splitNumber: s < 160 ? 4 : 5,
+        // fewer ticks than the default 10 → no cram
+        radius: "95%",
+        center: ["50%", "58%"],
+        progress: { show: true, width: arcWidth, itemStyle: { color: accent } },
+        pointer: { itemStyle: { color: accent }, length: "55%", width: clamp2(Math.round(s / 50), 2, 6) },
+        anchor: { show: false },
+        axisLine: { lineStyle: { width: arcWidth, color: [[1, theme.border]] } },
+        axisTick: { show: false },
+        splitLine: { length: arcWidth, lineStyle: { color: theme.border, width: 1 } },
+        axisLabel: { color: theme.mutedForeground, fontSize: labelFont, distance: arcWidth + 2 },
+        detail: {
+          valueAnimation: false,
+          color: theme.foreground,
+          fontSize: valueFont,
+          offsetCenter: [0, "30%"],
+          formatter: (v) => value == null ? "\u2014" : `${v}${unitSuffix}`
+        },
+        data: [{ value: value ?? min }]
+      }
+    ]
+  };
+}
+
+// src/echart.tsx
+import { GaugeChart, LineChart } from "echarts/charts";
+import { GridComponent, TooltipComponent } from "echarts/components";
+import * as echarts from "echarts/core";
+import { CanvasRenderer } from "echarts/renderers";
+import { useEffect as useEffect5, useRef as useRef4 } from "react";
+import { jsx as jsx7 } from "react/jsx-runtime";
+echarts.use([LineChart, GaugeChart, GridComponent, TooltipComponent, CanvasRenderer]);
+function EChart({ option, className, style }) {
+  const containerRef = useRef4(null);
+  const chartRef = useRef4(null);
+  useEffect5(() => {
+    const el = containerRef.current;
+    if (!el) return;
+    const chart = echarts.init(el);
+    chartRef.current = chart;
+    const observer = new ResizeObserver(() => chart.resize());
+    observer.observe(el);
+    return () => {
+      observer.disconnect();
+      chart.dispose();
+      chartRef.current = null;
+    };
+  }, []);
+  useEffect5(() => {
+    chartRef.current?.setOption(option, { notMerge: true });
+  }, [option]);
+  return /* @__PURE__ */ jsx7("div", { ref: containerRef, className, style: { width: "100%", height: "100%", ...style } });
+}
+
+// src/widgets/gauge.tsx
+import { jsx as jsx8 } from "react/jsx-runtime";
+function Gauge({ widget, data }) {
+  const theme = useChartTheme();
+  const [sizeRef, size] = useElementSize();
+  const name = primaryMeasurementName(widget);
+  const sample = pickSample(data.latest, name);
+  const min = optNumber(widget.options, "min");
+  const max = optNumber(widget.options, "max");
+  const unit = optString(widget.options, "unit");
+  const option = useMemo3(
+    () => buildGaugeOption(sample?.value ?? null, theme, { min, max, unit }, size),
+    [sample?.value, theme, min, max, unit, size.width, size.height]
+  );
+  const flashDirection = useFlashOnChange(
+    sample?.value,
+    optBoolean(widget.options, "flashOnChange"),
+    sample && `${sample.deviceToken}:${sample.name}`
+  );
+  return /* @__PURE__ */ jsx8(WidgetFrame, { title: optString(widget.options, "title") ?? name, children: /* @__PURE__ */ jsx8("div", { ref: sizeRef, style: { width: "100%", height: "100%", ...flashBackgroundStyle(flashDirection) }, children: /* @__PURE__ */ jsx8(EChart, { option }) }) });
+}
+
+// src/widgets/image.tsx
+import { jsx as jsx9 } from "react/jsx-runtime";
+var FITS = /* @__PURE__ */ new Set(["contain", "cover", "fill"]);
+function Image({ widget }) {
+  const url = optString(widget.options, "url");
+  const alt = optString(widget.options, "alt") ?? "";
+  const fitOption = optString(widget.options, "fit");
+  const objectFit = fitOption && FITS.has(fitOption) ? fitOption : "contain";
+  return /* @__PURE__ */ jsx9(WidgetFrame, { title: optString(widget.options, "title"), children: url ? /* @__PURE__ */ jsx9("img", { src: url, alt, style: { width: "100%", height: "100%", objectFit, display: "block" } }) : /* @__PURE__ */ jsx9(
+    "div",
+    {
+      style: {
+        display: "flex",
+        alignItems: "center",
+        justifyContent: "center",
+        height: "100%",
+        color: css("muted-foreground"),
+        fontSize: 13
+      },
+      children: "No image URL"
+    }
+  ) });
+}
+
+// src/widgets/label.tsx
+import { jsx as jsx10 } from "react/jsx-runtime";
+var justify = {
+  left: "flex-start",
+  center: "center",
+  right: "flex-end"
+};
+function Label({ widget }) {
+  const text = optString(widget.options, "text") ?? "";
+  const align = optString(widget.options, "align") ?? "center";
+  const fontSize = optNumber(widget.options, "fontSize") ?? 16;
+  return /* @__PURE__ */ jsx10(WidgetFrame, { title: optString(widget.options, "title"), children: /* @__PURE__ */ jsx10(
+    "div",
+    {
+      style: {
+        display: "flex",
+        alignItems: "center",
+        justifyContent: justify[align] ?? "center",
+        height: "100%",
+        padding: 12
+      },
+      children: /* @__PURE__ */ jsx10(
+        "span",
+        {
+          style: {
+            fontSize,
+            color: css("foreground"),
+            textAlign: align,
+            whiteSpace: "pre-wrap"
+          },
+          children: text
+        }
+      )
+    }
+  ) });
+}
+
+// src/widgets/latest-card.tsx
+import { jsx as jsx11, jsxs as jsxs6 } from "react/jsx-runtime";
+var clamp3 = (v, lo, hi) => Math.max(lo, Math.min(hi, v));
+function LatestCard({ widget, data }) {
+  const [sizeRef, size] = useElementSize();
+  const name = primaryMeasurementName(widget);
+  const sample = pickSample(data.latest, name);
+  const title = optString(widget.options, "title") ?? name;
+  const unit = optString(widget.options, "unit");
+  const precision = optNumber(widget.options, "precision");
+  const display = formatValue(sample?.value, precision);
+  const flashDirection = useFlashOnChange(
+    sample?.value,
+    optBoolean(widget.options, "flashOnChange"),
+    sample && `${sample.deviceToken}:${sample.name}`
+  );
+  const valueFont = size.height > 0 ? clamp3(Math.round(size.height / 3.5), 16, 44) : 32;
+  return /* @__PURE__ */ jsx11(WidgetFrame, { title, children: /* @__PURE__ */ jsxs6(
+    "div",
+    {
+      ref: sizeRef,
+      style: {
+        display: "flex",
+        flexDirection: "column",
+        justifyContent: "center",
+        height: "100%",
+        padding: "12px 16px"
+      },
+      children: [
+        /* @__PURE__ */ jsxs6(
+          "div",
+          {
+            style: {
+              fontSize: valueFont,
+              fontWeight: 600,
+              lineHeight: 1.1,
+              color: css("foreground"),
+              ...flashTextStyle(flashDirection)
+            },
+            children: [
+              display,
+              sample?.value != null && unit ? /* @__PURE__ */ jsx11("span", { style: { fontSize: Math.round(valueFont / 2), color: css("muted-foreground"), marginLeft: 6 }, children: unit }) : null
+            ]
+          }
+        ),
+        sample?.occurredTime ? /* @__PURE__ */ jsx11("div", { style: { fontSize: 11, color: css("muted-foreground"), marginTop: 4 }, children: formatTimestamp(sample.occurredTime) }) : null
+      ]
+    }
+  ) });
+}
+
+// src/widgets/map.tsx
+import { useEffect as useEffect6, useRef as useRef5, useState as useState6 } from "react";
+import { renderableBasemap, resolveBasemap } from "@devicechain/client";
+
+// src/basemap-context.tsx
+import { createContext as createContext2, useContext as useContext2 } from "react";
+import { jsx as jsx12 } from "react/jsx-runtime";
+var TenantBasemapContext = createContext2(null);
+function TenantBasemapProvider({
+  basemap,
+  children
+}) {
+  return /* @__PURE__ */ jsx12(TenantBasemapContext.Provider, { value: basemap, children });
+}
+function useTenantBasemap() {
+  return useContext2(TenantBasemapContext);
+}
+
+// src/map-runtime-context.tsx
+import { createContext as createContext3, useContext as useContext3 } from "react";
+import { jsx as jsx13 } from "react/jsx-runtime";
+var MapRuntimeContext = createContext3(null);
+function MapRuntimeProvider({
+  runtime,
+  children
+}) {
+  return /* @__PURE__ */ jsx13(MapRuntimeContext.Provider, { value: runtime, children });
+}
+function useMapRuntime() {
+  return useContext3(MapRuntimeContext);
+}
+
+// src/widgets/map-geometry.ts
+function placeable(samples) {
+  return samples.filter(
+    (s) => s.latitude != null && s.longitude != null
+  );
+}
+var PANEL_PADDING = 0.1;
+function projectToPanel(positions) {
+  if (positions.length === 0) return [];
+  let minLat = Infinity;
+  let maxLat = -Infinity;
+  let minLon = Infinity;
+  let maxLon = -Infinity;
+  for (const p of positions) {
+    if (p.latitude < minLat) minLat = p.latitude;
+    if (p.latitude > maxLat) maxLat = p.latitude;
+    if (p.longitude < minLon) minLon = p.longitude;
+    if (p.longitude > maxLon) maxLon = p.longitude;
+  }
+  const lonSpan = maxLon - minLon;
+  const latSpan = maxLat - minLat;
+  const scale = 1 - 2 * PANEL_PADDING;
+  return positions.map((p) => ({
+    x: PANEL_PADDING + scale * (lonSpan === 0 ? 0.5 : (p.longitude - minLon) / lonSpan),
+    // maxLat at the TOP: screen y grows downward, latitude grows northward.
+    y: PANEL_PADDING + scale * (latSpan === 0 ? 0.5 : (maxLat - p.latitude) / latSpan)
+  }));
+}
+function formatDegrees(value) {
+  return value.toFixed(6);
+}
+function describePosition(sample) {
+  const parts = [
+    sample.deviceToken,
+    `${formatDegrees(sample.latitude)}, ${formatDegrees(sample.longitude)}`
+  ];
+  if (sample.elevation != null) parts.push(`${sample.elevation} m`);
+  if (sample.accuracy != null) parts.push(`\xB1${sample.accuracy} m`);
+  if (sample.speed != null) parts.push(`${sample.speed} m/s`);
+  if (sample.heading != null) parts.push(`${sample.heading}\xB0`);
+  return parts.join(" \xB7 ");
+}
+function rasterStyleFor(tileUrl, attribution) {
+  return {
+    version: 8,
+    projection: PROJECTION,
+    sources: {
+      basemap: {
+        type: "raster",
+        tiles: [tileUrl],
+        tileSize: 256,
+        ...attribution ? { attribution } : {}
+      }
+    },
+    layers: [{ id: "basemap", type: "raster", source: "basemap" }]
+  };
+}
+var PROJECTION = { type: "mercator" };
+var BUNDLED_BASEMAP_ATTRIBUTION = "Made with Natural Earth";
+var OCEAN = "#0b1220";
+var LAND = "#1e293b";
+var BOUNDARY = "#475569";
+function landStyleFrom(land, boundaries) {
+  return {
+    version: 8,
+    projection: PROJECTION,
+    sources: {
+      land: { type: "geojson", data: land, attribution: BUNDLED_BASEMAP_ATTRIBUTION },
+      boundaries: { type: "geojson", data: boundaries }
+    },
+    layers: [
+      { id: "ocean", type: "background", paint: { "background-color": OCEAN } },
+      { id: "land", type: "fill", source: "land", paint: { "fill-color": LAND } },
+      {
+        id: "boundaries",
+        type: "line",
+        source: "boundaries",
+        paint: { "line-color": BOUNDARY, "line-width": 0.5 }
+      }
+    ]
+  };
+}
+var landStylePromise;
+function loadLandStyle() {
+  if (!landStylePromise) {
+    landStylePromise = import("./chunks/natural-earth-data-VMKQ6LY3.js").then(
+      (mod) => landStyleFrom(mod.NATURAL_EARTH.land, mod.NATURAL_EARTH.boundaries)
+    );
+  }
+  return landStylePromise;
+}
+
+// src/widgets/map.tsx
+import { jsx as jsx14, jsxs as jsxs7 } from "react/jsx-runtime";
+var mapLibrePromise;
+function loadMapLibre(runtime) {
+  if (!mapLibrePromise) {
+    mapLibrePromise = Promise.all([
+      import("maplibre-gl"),
+      Promise.resolve().then(() => runtime.loadStyles?.())
+    ]).then(([mod]) => {
+      mod.setWorkerUrl(runtime.workerUrl);
+      return mod;
+    });
+  }
+  return mapLibrePromise;
+}
+var SINGLE_DEVICE_ZOOM = 14;
+function MapWidget({ widget, data }) {
+  const title = optString(widget.options, "title");
+  const positions = placeable(data.locations);
+  const runtime = useMapRuntime();
+  const basemap = renderableBasemap(
+    resolveBasemap(
+      {
+        tileUrl: optString(widget.options, "tileUrl"),
+        attribution: optString(widget.options, "attribution")
+      },
+      useTenantBasemap()
+    )
+  );
+  if (data.forbidden) {
+    return /* @__PURE__ */ jsx14(WidgetFrame, { title, children: /* @__PURE__ */ jsx14(
+      MapNotice,
+      {
+        glyph: "\u{1F512}",
+        heading: "Location not permitted",
+        detail: "You do not have permission to view device locations."
+      }
+    ) });
+  }
+  if (!runtime) {
+    return /* @__PURE__ */ jsx14(WidgetFrame, { title, children: /* @__PURE__ */ jsx14(
+      MapNotice,
+      {
+        glyph: "\u{1F9E9}",
+        heading: "Map runtime not configured",
+        detail: "This host must install MapRuntimeProvider with its bundler's MapLibre worker URL."
+      }
+    ) });
+  }
+  if (data.loading && positions.length === 0) {
+    return /* @__PURE__ */ jsx14(WidgetFrame, { title, children: /* @__PURE__ */ jsx14(MapNotice, { heading: "Loading\u2026" }) });
+  }
+  if (positions.length === 0) {
+    return /* @__PURE__ */ jsx14(WidgetFrame, { title, children: /* @__PURE__ */ jsx14(
+      MapNotice,
+      {
+        heading: data.deviceTokens.length === 0 ? "No devices selected" : "No positions reported",
+        detail: data.deviceTokens.length === 0 ? "Bind this widget to a device or anchor and select its location series." : "None of the selected devices has reported a position yet."
+      }
+    ) });
+  }
+  return /* @__PURE__ */ jsx14(WidgetFrame, { title, bodyStyle: { padding: 0 }, children: /* @__PURE__ */ jsx14(LiveMap, { basemap, positions, runtime }) });
+}
+function PlainPanel({ positions, note }) {
+  const points = projectToPanel(positions);
+  return /* @__PURE__ */ jsxs7(
+    "div",
+    {
+      "data-testid": "map-plain-panel",
+      style: {
+        position: "relative",
+        width: "100%",
+        height: "100%",
+        overflow: "hidden",
+        background: css("muted")
+      },
+      children: [
+        positions.map((position, i) => /* @__PURE__ */ jsx14(
+          Marker,
+          {
+            position,
+            style: {
+              position: "absolute",
+              left: `${points[i].x * 100}%`,
+              top: `${points[i].y * 100}%`,
+              transform: "translate(-50%, -50%)"
+            }
+          },
+          position.deviceToken
+        )),
+        /* @__PURE__ */ jsx14(
+          "div",
+          {
+            "data-testid": "map-no-tiles-note",
+            style: {
+              position: "absolute",
+              left: 0,
+              right: 0,
+              bottom: 0,
+              padding: "4px 8px",
+              fontSize: 10,
+              lineHeight: 1.3,
+              textAlign: "center",
+              color: css("muted-foreground"),
+              background: css("card"),
+              opacity: 0.9
+            },
+            children: note
+          }
+        )
+      ]
+    }
+  );
+}
+function LiveMap({
+  basemap,
+  positions,
+  runtime
+}) {
+  const containerRef = useRef5(null);
+  const mapRef = useRef5(null);
+  const markersRef = useRef5([]);
+  const [status, setStatus] = useState6("loading");
+  const tileUrl = basemap?.tileUrl ?? null;
+  const attribution = basemap?.attribution ?? null;
+  useEffect6(() => {
+    let cancelled = false;
+    setStatus("loading");
+    Promise.all([
+      loadMapLibre(runtime),
+      tileUrl ? rasterStyleFor(tileUrl, attribution ?? void 0) : loadLandStyle()
+    ]).then(([maplibre, style]) => {
+      const el = containerRef.current;
+      if (cancelled || !el) return;
+      const map = new maplibre.Map({
+        container: el,
+        style,
+        center: [0, 0],
+        zoom: 1
+      });
+      mapRef.current = map;
+      setStatus("ready");
+    }).catch(() => {
+      if (!cancelled) setStatus("unavailable");
+    });
+    return () => {
+      cancelled = true;
+      for (const marker of markersRef.current) marker.remove();
+      markersRef.current = [];
+      mapRef.current?.remove();
+      mapRef.current = null;
+    };
+  }, [tileUrl, attribution, runtime.workerUrl]);
+  useEffect6(() => {
+    const map = mapRef.current;
+    if (status !== "ready" || !map) return;
+    let live = true;
+    loadMapLibre(runtime).then((maplibre) => {
+      if (!live || mapRef.current !== map) return;
+      for (const marker of markersRef.current) marker.remove();
+      markersRef.current = positions.map((position) => {
+        const el = document.createElement("div");
+        el.setAttribute("data-testid", "map-marker");
+        el.setAttribute("data-device", position.deviceToken);
+        el.setAttribute("title", describePosition(position));
+        el.setAttribute("aria-label", describePosition(position));
+        Object.assign(el.style, MARKER_DOT_STYLE);
+        return new maplibre.Marker({ element: el }).setLngLat([position.longitude, position.latitude]).addTo(map);
+      });
+      if (positions.length === 1) {
+        map.jumpTo({ center: [positions[0].longitude, positions[0].latitude], zoom: SINGLE_DEVICE_ZOOM });
+      } else if (positions.length > 1) {
+        const bounds = new maplibre.LngLatBounds();
+        for (const p of positions) bounds.extend([p.longitude, p.latitude]);
+        map.fitBounds(bounds, { padding: 40, animate: false });
+      }
+    });
+    return () => {
+      live = false;
+    };
+  }, [status, positionsKey(positions)]);
+  if (status === "unavailable") {
+    return /* @__PURE__ */ jsx14(
+      PlainPanel,
+      {
+        positions,
+        note: "Map renderer unavailable \u2014 positions are shown without a basemap."
+      }
+    );
+  }
+  return /* @__PURE__ */ jsx14("div", { ref: containerRef, "data-testid": "map-canvas", style: { width: "100%", height: "100%" } });
+}
+function positionsKey(positions) {
+  return positions.map((p) => `${p.deviceToken}:${p.latitude}:${p.longitude}:${p.heading ?? ""}`).join("|");
+}
+var MARKER_DOT_STYLE = {
+  width: "12px",
+  height: "12px",
+  borderRadius: "50%",
+  background: css("primary"),
+  border: `2px solid ${css("card")}`,
+  boxShadow: "0 0 0 1px rgba(0,0,0,0.25)",
+  cursor: "default"
+};
+function Marker({
+  position,
+  style
+}) {
+  const label = describePosition(position);
+  return /* @__PURE__ */ jsx14(
+    "div",
+    {
+      "data-testid": "map-marker",
+      "data-device": position.deviceToken,
+      title: label,
+      "aria-label": label,
+      style: { ...MARKER_DOT_STYLE, ...style }
+    }
+  );
+}
+function MapNotice({ glyph, heading, detail }) {
+  return /* @__PURE__ */ jsxs7(
+    "div",
+    {
+      style: {
+        display: "flex",
+        flexDirection: "column",
+        alignItems: "center",
+        justifyContent: "center",
+        gap: 4,
+        width: "100%",
+        height: "100%",
+        padding: 12,
+        boxSizing: "border-box",
+        textAlign: "center",
+        color: css("muted-foreground")
+      },
+      children: [
+        glyph ? /* @__PURE__ */ jsx14("div", { style: { fontSize: 20, lineHeight: 1 }, "aria-hidden": "true", children: glyph }) : null,
+        /* @__PURE__ */ jsx14("div", { style: { fontSize: 13, fontWeight: 600 }, children: heading }),
+        detail ? /* @__PURE__ */ jsx14("div", { style: { fontSize: 11, opacity: 0.8 }, children: detail }) : null
+      ]
+    }
+  );
+}
+
+// src/widgets/table.tsx
+import { jsx as jsx15, jsxs as jsxs8 } from "react/jsx-runtime";
+var cell2 = { padding: "6px 12px", textAlign: "left" };
+var headCell2 = {
+  ...cell2,
+  fontSize: 11,
+  fontWeight: 600,
+  textTransform: "uppercase",
+  letterSpacing: "0.04em",
+  color: css("muted-foreground"),
+  borderBottom: `1px solid ${css("border")}`
+};
+function Table({ widget, data }) {
+  const rows = Object.values(data.latest).sort((a, b) => a.name.localeCompare(b.name));
+  const precision = optNumber(widget.options, "precision");
+  const flash = optBoolean(widget.options, "flashOnChange");
+  return /* @__PURE__ */ jsx15(WidgetFrame, { title: optString(widget.options, "title"), children: /* @__PURE__ */ jsx15("div", { style: { height: "100%", overflow: "auto" }, children: /* @__PURE__ */ jsxs8("table", { style: { width: "100%", borderCollapse: "collapse", fontSize: 13, color: css("foreground") }, children: [
+    /* @__PURE__ */ jsx15("thead", { children: /* @__PURE__ */ jsxs8("tr", { children: [
+      /* @__PURE__ */ jsx15("th", { style: headCell2, children: "Measurement" }),
+      /* @__PURE__ */ jsx15("th", { style: headCell2, children: "Value" }),
+      /* @__PURE__ */ jsx15("th", { style: headCell2, children: "Time" })
+    ] }) }),
+    /* @__PURE__ */ jsx15("tbody", { children: rows.length === 0 ? /* @__PURE__ */ jsx15("tr", { children: /* @__PURE__ */ jsx15("td", { colSpan: 3, style: { ...cell2, textAlign: "center", color: css("muted-foreground") }, children: "No data yet" }) }) : rows.map((row) => /* @__PURE__ */ jsxs8("tr", { children: [
+      /* @__PURE__ */ jsx15("td", { style: cell2, children: row.name }),
+      /* @__PURE__ */ jsx15("td", { style: { ...cell2, fontVariantNumeric: "tabular-nums" }, children: /* @__PURE__ */ jsx15(
+        FlashValue,
+        {
+          value: row.value,
+          precision,
+          enabled: flash,
+          identity: `${row.deviceToken}:${row.name}`
+        }
+      ) }),
+      /* @__PURE__ */ jsx15("td", { style: { ...cell2, color: css("muted-foreground") }, children: formatTimestamp(row.occurredTime) })
+    ] }, row.name)) })
+  ] }) }) });
+}
+
+// src/widgets/time-series-chart.tsx
+import { useMemo as useMemo4 } from "react";
+import { jsx as jsx16 } from "react/jsx-runtime";
+function TimeSeriesChart({ widget, data }) {
+  const theme = useChartTheme();
+  const [sizeRef, size] = useElementSize();
+  const measurements = widget.datasource?.measurements;
+  const option = useMemo4(
+    () => buildLineOption(data.samples, theme, { measurements }, size),
+    [data.samples, theme, measurements, size.width, size.height]
+  );
+  return /* @__PURE__ */ jsx16(WidgetFrame, { title: optString(widget.options, "title"), children: /* @__PURE__ */ jsx16("div", { ref: sizeRef, style: { width: "100%", height: "100%" }, children: /* @__PURE__ */ jsx16(EChart, { option }) }) });
+}
+
+// src/registry.ts
+var WIDGET_CHANNEL = {
+  "timeseries-chart": "measurement",
+  "latest-card": "measurement",
+  gauge: "measurement",
+  table: "measurement",
+  label: "measurement",
+  image: "measurement",
+  "alarm-table": "alarm",
+  "alarm-count": "alarm",
+  "command-button": "control",
+  "entity-selector": "selection",
+  map: "location"
+};
+var WIDGET_REGISTRY = {
+  "timeseries-chart": TimeSeriesChart,
+  "latest-card": LatestCard,
+  gauge: Gauge,
+  table: Table,
+  label: Label,
+  image: Image
+};
+var ALARM_WIDGET_REGISTRY = {
+  "alarm-table": AlarmTable,
+  "alarm-count": AlarmCount
+};
+var CONTROL_WIDGET_REGISTRY = {
+  "command-button": CommandButton
+};
+var SELECTION_WIDGET_REGISTRY = {
+  "entity-selector": EntitySelector
+};
+var LOCATION_WIDGET_REGISTRY = {
+  map: MapWidget
+};
+var WIDGET_BINDS_DATASOURCE = {
+  "timeseries-chart": true,
+  "latest-card": true,
+  gauge: true,
+  table: true,
+  label: false,
+  image: false,
+  "alarm-table": true,
+  "alarm-count": true,
+  "command-button": true,
+  "entity-selector": false,
+  // A map binds a datasource, and needs it: the selector names both the devices whose
+  // positions to plot and (in its own field) the location series to read.
+  map: true
+};
+
+// src/connected-widget.tsx
+import { jsx as jsx17, jsxs as jsxs9 } from "react/jsx-runtime";
+var DEFAULT_ALARM_ROWS = 50;
+var DEFAULT_COMMAND_ROWS = 20;
+function ConnectedWidget({ widget, hub, actions, initialSamples }) {
+  const availability = useDatasourceAvailability(hub, widget.datasource);
+  if (availability === "unavailable") {
+    return /* @__PURE__ */ jsx17(WidgetUnavailableFrame, { widget });
+  }
+  const channel = WIDGET_CHANNEL[widget.type];
+  if (channel === "alarm") {
+    return /* @__PURE__ */ jsx17(AlarmConnectedWidget, { widget, hub, actions });
+  }
+  if (channel === "control") {
+    return /* @__PURE__ */ jsx17(ControlConnectedWidget, { widget, hub, actions });
+  }
+  if (channel === "selection") {
+    return /* @__PURE__ */ jsx17(SelectionConnectedWidget, { widget });
+  }
+  if (channel === "location") {
+    return /* @__PURE__ */ jsx17(LocationConnectedWidget, { widget, hub });
+  }
+  return /* @__PURE__ */ jsx17(MeasurementConnectedWidget, { widget, hub, initialSamples });
+}
+function SelectionConnectedWidget({ widget }) {
+  const Component = SELECTION_WIDGET_REGISTRY[widget.type];
+  if (!Component) return null;
+  return /* @__PURE__ */ jsx17(Component, { widget, data: null });
+}
+function MeasurementConnectedWidget({ widget, hub, initialSamples }) {
+  const data = useMeasurementStream(hub, widget.datasource, {
+    window: optNumber(widget.options, "window"),
+    initialSamples
+  });
+  if (data.error) return /* @__PURE__ */ jsx17(WidgetErrorFrame, { widget, error: data.error });
+  const Component = WIDGET_REGISTRY[widget.type];
+  if (!Component) return null;
+  return /* @__PURE__ */ jsx17(Component, { widget, data });
+}
+function AlarmConnectedWidget({
+  widget,
+  hub,
+  actions
+}) {
+  const data = useAlarmStream(hub, alarmSubscription(widget));
+  if (data.error && data.alarms.length === 0 && data.total === 0) {
+    return /* @__PURE__ */ jsx17(WidgetErrorFrame, { widget, error: data.error });
+  }
+  const Component = ALARM_WIDGET_REGISTRY[widget.type];
+  if (!Component) return null;
+  return /* @__PURE__ */ jsx17(Component, { widget, data, actions });
+}
+function ControlConnectedWidget({
+  widget,
+  hub,
+  actions
+}) {
+  const data = useCommandStream(hub, commandSubscription(widget));
+  const Component = CONTROL_WIDGET_REGISTRY[widget.type];
+  if (!Component) return null;
+  return /* @__PURE__ */ jsx17(Component, { widget, data, actions });
+}
+function LocationConnectedWidget({
+  widget,
+  hub
+}) {
+  const data = useLocationStream(hub, locationSubscription(widget));
+  if (data.error && data.locations.length === 0) {
+    return /* @__PURE__ */ jsx17(WidgetErrorFrame, { widget, error: data.error });
+  }
+  const Component = LOCATION_WIDGET_REGISTRY[widget.type];
+  if (!Component) return null;
+  return /* @__PURE__ */ jsx17(Component, { widget, data });
+}
+function locationSubscription(widget) {
+  return { datasource: widget.datasource };
+}
+function commandSubscription(widget) {
+  return {
+    datasource: widget.datasource,
+    pageSize: Math.max(1, optNumber(widget.options, "maxRows") ?? DEFAULT_COMMAND_ROWS)
+  };
+}
+function alarmSubscription(widget) {
+  const pageSize = widget.type === "alarm-count" ? DEFAULT_ALARM_ROWS : Math.max(1, optNumber(widget.options, "maxRows") ?? DEFAULT_ALARM_ROWS);
+  return {
+    datasource: widget.datasource,
+    state: optString(widget.options, "state"),
+    severity: optString(widget.options, "severity"),
+    acknowledged: parseAcknowledged(optString(widget.options, "acknowledged")),
+    pageSize
+  };
+}
+function parseAcknowledged(value) {
+  if (value === "true") return true;
+  if (value === "false") return false;
+  return void 0;
+}
+function WidgetUnavailableFrame({ widget }) {
+  return /* @__PURE__ */ jsx17(WidgetFrame, { title: optString(widget.options, "title"), children: /* @__PURE__ */ jsxs9(
+    "div",
+    {
+      style: {
+        display: "flex",
+        flexDirection: "column",
+        alignItems: "center",
+        justifyContent: "center",
+        gap: 4,
+        width: "100%",
+        height: "100%",
+        padding: 12,
+        boxSizing: "border-box",
+        textAlign: "center",
+        color: "hsl(var(--muted-foreground))"
+      },
+      children: [
+        /* @__PURE__ */ jsx17("div", { style: { fontSize: 20, lineHeight: 1 }, "aria-hidden": "true", children: "\u2298" }),
+        /* @__PURE__ */ jsx17("div", { style: { fontSize: 13, fontWeight: 600 }, children: "Device unavailable" }),
+        /* @__PURE__ */ jsx17("div", { style: { fontSize: 11, opacity: 0.8 }, children: "The bound device no longer exists." })
+      ]
+    }
+  ) });
+}
+function WidgetErrorFrame({ widget, error }) {
+  return /* @__PURE__ */ jsx17(WidgetFrame, { title: optString(widget.options, "title"), children: /* @__PURE__ */ jsxs9(
+    "div",
+    {
+      style: {
+        display: "flex",
+        flexDirection: "column",
+        alignItems: "center",
+        justifyContent: "center",
+        gap: 4,
+        width: "100%",
+        height: "100%",
+        padding: 12,
+        boxSizing: "border-box",
+        textAlign: "center",
+        color: "hsl(var(--muted-foreground))"
+      },
+      children: [
+        /* @__PURE__ */ jsx17("div", { style: { fontSize: 20, lineHeight: 1 }, children: "\u26A0" }),
+        /* @__PURE__ */ jsx17("div", { style: { fontSize: 13, fontWeight: 600 }, children: "Data unavailable" }),
+        /* @__PURE__ */ jsx17("div", { style: { fontSize: 11, opacity: 0.8, wordBreak: "break-word" }, children: String(error) })
+      ]
+    }
+  ) });
+}
+
+// src/dashboard-renderer.tsx
+import { jsx as jsx18 } from "react/jsx-runtime";
+function DashboardRenderer({
+  definition,
+  hub,
+  actions,
+  seedHistory = true,
+  bindings,
+  sizing,
+  select,
+  candidates
+}) {
+  const breakpoint = useActiveBreakpoint(definition.canvas.breakpoints);
+  const histories = useWidgetHistories(definition.widgets, seedHistory, bindings);
+  const { grid, background: bg } = definition.canvas;
+  const rowGap = typeof grid.gap === "number" ? grid.gap : grid.gap.row;
+  const colGap = typeof grid.gap === "number" ? grid.gap : grid.gap.col;
+  const effectiveSizing = sizing ?? definition.canvas.sizing;
+  return /* @__PURE__ */ jsx18("div", { style: sizingStyle(effectiveSizing, bg), children: /* @__PURE__ */ jsx18(WidgetSelectProvider, { select, children: /* @__PURE__ */ jsx18(WidgetCandidatesProvider, { candidates, children: /* @__PURE__ */ jsx18(
+    "div",
+    {
+      style: {
+        display: "grid",
+        gridTemplateColumns: `repeat(${grid.columns}, minmax(0, 1fr))`,
+        gridAutoRows: `${grid.rowHeight}px`,
+        columnGap: colGap,
+        rowGap,
+        width: "100%"
+      },
+      children: definition.widgets.map((widget) => {
+        const box = resolveWidgetBox(widget.layout, breakpoint);
+        return /* @__PURE__ */ jsx18("div", { style: gridItemStyle(box, grid.columns), children: /* @__PURE__ */ jsx18(WidgetSubjectProvider, { label: widgetSubjectLabel(widget, definition.slots, bindings), children: /* @__PURE__ */ jsx18(
+          ConnectedWidget,
+          {
+            widget,
+            hub,
+            actions,
+            initialSamples: histories[widget.id]
+          }
+        ) }) }, widget.id);
+      })
+    }
+  ) }) }) });
+}
+function gridItemStyle(box, columns) {
+  const col = Math.min(Math.max(0, box.col), columns - 1);
+  const colSpan = Math.min(Math.max(1, box.colSpan), columns - col);
+  return {
+    gridColumn: `${col + 1} / span ${colSpan}`,
+    gridRow: `${box.row + 1} / span ${box.rowSpan}`,
+    zIndex: box.z,
+    transform: box.offset ? `translate(${box.offset.x}px, ${box.offset.y}px)` : void 0,
+    // Let a grid item shrink below its content's intrinsic size so a wide chart/table
+    // fits its track instead of overflowing it.
+    minWidth: 0,
+    minHeight: 0
+  };
+}
+function sizingStyle(sizing, bg) {
+  const base = {
+    overflow: "auto",
+    backgroundColor: bg?.color ?? void 0,
+    backgroundImage: bg?.imageUrl ? `url(${bg.imageUrl})` : void 0,
+    backgroundSize: "cover"
+  };
+  if (sizing === "fill") return { ...base, width: "100%", height: "100%" };
+  if ("width" in sizing) return { ...base, width: sizing.width, maxWidth: "100%", height: "100%" };
+  return { ...base, width: "100%", height: sizing.height };
+}
+function ownGet(map, key) {
+  return map && Object.prototype.hasOwnProperty.call(map, key) ? map[key] : void 0;
+}
+function widgetSubjectLabel(widget, slots, bindings) {
+  const ds = widget.datasource;
+  if (!ds) return void 0;
+  let binding;
+  if (ds.kind === "device") {
+    binding = ds.deviceToken ? { kind: "device", deviceToken: ds.deviceToken } : void 0;
+  } else if (ds.kind === "anchor") {
+    binding = { kind: "anchor", anchor: ds.anchor };
+  } else if (ds.kind === "slot") {
+    const slot = ownGet(slots, ds.slot);
+    binding = slot?.scope ? ownGet(bindings, ds.slot) : ownGet(bindings, ds.slot) ?? slot?.defaultBinding;
+  }
+  if (binding?.kind === "device") return binding.deviceToken;
+  if (binding?.kind === "anchor") return binding.anchor.targetToken;
+  return void 0;
+}
+function useActiveBreakpoint(breakpoints) {
+  const [width, setWidth] = useState7(
+    () => typeof window === "undefined" ? 0 : window.innerWidth
+  );
+  useEffect7(() => {
+    const onResize = () => setWidth(window.innerWidth);
+    window.addEventListener("resize", onResize);
+    return () => window.removeEventListener("resize", onResize);
+  }, []);
+  return activeBreakpoint(breakpoints, width);
+}
+function useWidgetHistories(widgets, enabled, bindings) {
+  const [histories, setHistories] = useState7({});
+  const bindingsKey = bindings ? JSON.stringify(bindings) : null;
+  useEffect7(() => {
+    if (!enabled) {
+      setHistories({});
+      return;
+    }
+    let cancelled = false;
+    const historyWindow = defaultHistoryWindow();
+    Promise.all(
+      widgets.map(
+        // Only measurement widgets consume a history seed; a non-measurement widget
+        // (alarm, command) reconciles from its own channel, so backfilling it would fire
+        // a wasted (and all-measurements) bucketedMeasurements query it ignores.
+        async (w) => [
+          w.id,
+          WIDGET_CHANNEL[w.type] === "measurement" ? await fetchWidgetHistory(w, historyWindow, bindings) : []
+        ]
+      )
+    ).then((entries) => {
+      if (!cancelled) setHistories(Object.fromEntries(entries));
+    });
+    return () => {
+      cancelled = true;
+    };
+  }, [widgets, enabled, bindingsKey]);
+  return histories;
+}
+
+// src/options.ts
+var TITLE = {
+  kind: "string",
+  doc: "Heading shown in the widget frame. Blank hides the frame heading."
+};
+var TITLE_OR_MEASUREMENT = {
+  kind: "string",
+  doc: "Heading shown in the widget frame. Defaults to the displayed measurement name."
+};
+var PRECISION = {
+  kind: "number",
+  integer: true,
+  min: 0,
+  max: 100,
+  doc: "Decimal places to round displayed values to. Unset shows the raw value."
+};
+var FLASH_ON_CHANGE = {
+  kind: "boolean",
+  doc: "Briefly tint a value green on a rise and red on a fall when it changes."
+};
+var WINDOW = {
+  kind: "number",
+  integer: true,
+  min: 1,
+  doc: "Samples retained across ALL of the widget's measurements before the oldest are dropped. Bounds memory; only the chart draws them. Default 300."
+};
+var UNIT = {
+  kind: "string",
+  doc: "Unit suffix shown beside the value."
+};
+var ALARM_STATE = {
+  kind: "enum",
+  values: ["ACTIVE", "CLEARED"],
+  doc: "Show only alarms in this state. Unset shows every state."
+};
+var ALARM_SEVERITY = {
+  kind: "enum",
+  values: ["CRITICAL", "MAJOR", "MINOR", "WARNING", "INDETERMINATE"],
+  doc: "Show only alarms at this severity. Unset shows every severity."
+};
+var ALARM_ACKNOWLEDGED = {
+  kind: "enum",
+  values: ["true", "false"],
+  doc: "Show only acknowledged ('true') or unacknowledged ('false') alarms. Unset shows both."
+};
+var SELECTION_TARGET = {
+  kind: "string",
+  doc: "Name of the slot this widget re-points when the viewer picks an entity."
+};
+var WIDGET_OPTIONS = {
+  "timeseries-chart": {
+    title: TITLE,
+    window: WINDOW
+  },
+  "latest-card": {
+    title: TITLE_OR_MEASUREMENT,
+    measurement: {
+      kind: "string",
+      doc: "Which measurement to display. Defaults to the first the datasource selects."
+    },
+    unit: UNIT,
+    precision: PRECISION,
+    flashOnChange: FLASH_ON_CHANGE,
+    window: WINDOW
+  },
+  gauge: {
+    title: TITLE_OR_MEASUREMENT,
+    measurement: {
+      kind: "string",
+      doc: "Which measurement to display. Defaults to the first the datasource selects."
+    },
+    min: {
+      kind: "number",
+      doc: "Low end of the gauge scale. Default 0."
+    },
+    max: {
+      kind: "number",
+      doc: "High end of the gauge scale. Default 100."
+    },
+    unit: UNIT,
+    flashOnChange: FLASH_ON_CHANGE,
+    window: WINDOW
+  },
+  table: {
+    title: TITLE,
+    precision: PRECISION,
+    flashOnChange: FLASH_ON_CHANGE,
+    window: WINDOW
+  },
+  // label and image carry no datasource: they sit on the measurement channel only
+  // because that is ConnectedWidget's default branch, and read no stream data at all.
+  label: {
+    title: TITLE,
+    text: {
+      kind: "string",
+      required: true,
+      doc: "The text to show. Rendered as plain text \u2014 markup is never interpreted."
+    },
+    align: {
+      kind: "enum",
+      values: ["left", "center", "right"],
+      doc: "Horizontal alignment of the text. Default center."
+    },
+    fontSize: {
+      kind: "number",
+      min: 1,
+      doc: "Text size in pixels. Default 16."
+    }
+  },
+  image: {
+    title: TITLE,
+    url: {
+      kind: "string",
+      required: true,
+      doc: "Source URL of the image."
+    },
+    alt: {
+      kind: "string",
+      doc: "Alternative text describing the image for assistive technology."
+    },
+    fit: {
+      kind: "enum",
+      values: ["contain", "cover", "fill"],
+      doc: "How the image fills its box. Default contain."
+    }
+  },
+  "alarm-table": {
+    title: TITLE,
+    state: ALARM_STATE,
+    severity: ALARM_SEVERITY,
+    acknowledged: ALARM_ACKNOWLEDGED,
+    maxRows: {
+      kind: "number",
+      integer: true,
+      min: 1,
+      doc: "Alarms loaded into the table. Default 50."
+    },
+    precision: PRECISION,
+    flashOnChange: FLASH_ON_CHANGE,
+    selectionTarget: SELECTION_TARGET
+  },
+  // No maxRows: alarmSubscription() forces the default page size for a count, because the
+  // number it shows is the SERVER total and the page is read only to sample the worst
+  // loaded severity. An authored maxRows here would be read by nothing.
+  "alarm-count": {
+    title: TITLE,
+    state: ALARM_STATE,
+    severity: ALARM_SEVERITY,
+    acknowledged: ALARM_ACKNOWLEDGED
+  },
+  "command-button": {
+    title: TITLE,
+    commandName: {
+      kind: "string",
+      required: true,
+      doc: "Command key issued to the target device. Without it the widget cannot send."
+    },
+    commandLabel: {
+      kind: "string",
+      doc: "Text on the send button. Defaults to the command key."
+    },
+    parameterSchema: {
+      kind: "string",
+      format: "json",
+      doc: "The command's parameter descriptors, baked in as JSON at author time. Drives the typed form."
+    },
+    maxRows: {
+      kind: "number",
+      integer: true,
+      min: 1,
+      doc: "Recent commands shown in the history. Default 20."
+    }
+  },
+  "entity-selector": {
+    title: TITLE,
+    selectionTarget: { ...SELECTION_TARGET, required: true }
+  },
+  // 🔴 tileUrl is NOT `required`, and that is the decision rather than an oversight.
+  // `required` means "absent leaves the widget with nothing to show", and a map without
+  // a basemap still shows every position it was asked to — on a plain panel, saying why
+  // there is no map behind them. Marking it required would report a correctly-rendering
+  // widget as broken on every board that names no provider of its own — which is most
+  // of them, because the usual and recommended answer is to inherit the tenant's
+  // basemap rather than to configure tiles per board.
+  map: {
+    title: TITLE,
+    tileUrl: {
+      kind: "string",
+      doc: "Raster tile URL template, e.g. https://tiles.example.com/{z}/{x}/{y}.png. Leave empty to inherit the tenant's basemap; setting one overrides it for this board only."
+    },
+    attribution: {
+      kind: "string",
+      doc: "Credit line the tile source requires, shown on the map. Set whatever the provider you chose asks for."
+    }
+  }
+};
+var CROSS_FIELD_RULES = {
+  gauge: [
+    (options) => {
+      const min = options.min;
+      const max = options.max;
+      if (typeof min !== "number" || typeof max !== "number") return void 0;
+      if (!Number.isFinite(min) || !Number.isFinite(max)) return void 0;
+      if (max > min) return void 0;
+      return {
+        key: "max",
+        code: "invariant",
+        message: `max (${max}) must be greater than min (${min})`
+      };
+    }
+  ]
+};
+function validateWidgetOptions(widgetType, options) {
+  const specs = WIDGET_OPTIONS[widgetType];
+  const issues = [];
+  const bag = options ?? {};
+  for (const [key, spec] of Object.entries(specs)) {
+    const value = bag[key];
+    if (value === void 0 || spec.required && value === "") {
+      if (spec.required) {
+        issues.push({ widgetType, key, code: "missing", message: `${key} is required but not set` });
+      }
+      continue;
+    }
+    issues.push(...checkValue(widgetType, key, spec, value));
+  }
+  for (const key of Object.keys(bag)) {
+    if (Object.prototype.hasOwnProperty.call(specs, key)) continue;
+    issues.push({
+      widgetType,
+      key,
+      code: "unknown",
+      message: `${key} is not read by a ${widgetType} widget`
+    });
+  }
+  for (const rule of CROSS_FIELD_RULES[widgetType] ?? []) {
+    const issue = rule(bag);
+    if (issue) issues.push({ widgetType, ...issue });
+  }
+  return issues;
+}
+function checkValue(widgetType, key, spec, value) {
+  const issue = (code, message) => [{ widgetType, key, code, message }];
+  switch (spec.kind) {
+    case "string":
+      if (typeof value !== "string") {
+        return issue("type", `${key} must be a string, got ${describe(value)}`);
+      }
+      if (spec.format === "json" && !parsesAsJson(value)) {
+        return issue("json", `${key} must be valid JSON`);
+      }
+      return [];
+    case "number":
+      if (typeof value !== "number" || !Number.isFinite(value)) {
+        return issue("type", `${key} must be a finite number, got ${describe(value)}`);
+      }
+      if (spec.integer && !Number.isInteger(value)) {
+        return issue("range", `${key} must be a whole number, got ${value}`);
+      }
+      if (spec.min !== void 0 && value < spec.min) {
+        return issue("range", `${key} must be at least ${spec.min}, got ${value}`);
+      }
+      if (spec.max !== void 0 && value > spec.max) {
+        return issue("range", `${key} must be at most ${spec.max}, got ${value}`);
+      }
+      return [];
+    case "boolean":
+      if (typeof value !== "boolean") {
+        return issue("type", `${key} must be a boolean, got ${describe(value)}`);
+      }
+      return [];
+    case "enum":
+      if (typeof value !== "string") {
+        return issue("type", `${key} must be a string, got ${describe(value)}`);
+      }
+      if (!spec.values.includes(value)) {
+        return issue("enum", `${key} must be one of ${spec.values.join(", ")}, got ${JSON.stringify(value)}`);
+      }
+      return [];
+  }
+}
+function parsesAsJson(value) {
+  try {
+    JSON.parse(value);
+    return true;
+  } catch {
+    return false;
+  }
+}
+function describe(value) {
+  if (value === null) return "null";
+  if (typeof value === "string") return `string ${JSON.stringify(value)}`;
+  if (Array.isArray(value)) return "an array";
+  return `${typeof value} ${JSON.stringify(value)}`;
+}
+function numberOptionSpec(type, key) {
+  const specs = WIDGET_OPTIONS[type];
+  if (!Object.prototype.hasOwnProperty.call(specs, key)) return void 0;
+  const spec = specs[key];
+  return spec.kind === "number" ? spec : void 0;
+}
+function clampNumberOption(spec, value) {
+  if (!Number.isFinite(value)) return void 0;
+  if (!spec) return value;
+  let next = spec.integer ? Math.trunc(value) : value;
+  if (spec.min !== void 0) next = Math.max(spec.min, next);
+  if (spec.max !== void 0) next = Math.min(spec.max, next);
+  return next;
+}
+function enumOptionValues(type, key) {
+  const specs = WIDGET_OPTIONS[type];
+  if (!Object.prototype.hasOwnProperty.call(specs, key)) return void 0;
+  const spec = specs[key];
+  return spec.kind === "enum" ? spec.values : void 0;
+}
+
+// src/definition-options.ts
+function validateDefinitionOptions(definition) {
+  return definition.widgets.flatMap(
+    (widget) => validateWidgetOptions(widget.type, widget.options).map((issue) => ({ ...issue, widgetId: widget.id }))
+  );
+}
+function stripUnknownOptions(definition) {
+  let changed = false;
+  const widgets = definition.widgets.map((widget) => {
+    const stripped = stripUnknownWidgetOptions(widget);
+    if (stripped !== widget) changed = true;
+    return stripped;
+  });
+  return changed ? { ...definition, widgets } : definition;
+}
+function stripUnknownWidgetOptions(widget) {
+  const bag = widget.options;
+  if (!bag) return widget;
+  const specs = WIDGET_OPTIONS[widget.type];
+  const keys = Object.keys(bag);
+  const kept = keys.filter((key) => Object.prototype.hasOwnProperty.call(specs, key));
+  if (kept.length === keys.length) return widget;
+  const options = {};
+  for (const key of kept) options[key] = bag[key];
+  return { ...widget, options };
+}
+export {
+  ALARM_WIDGET_REGISTRY,
+  AlarmCount,
+  AlarmTable,
+  BUNDLED_BASEMAP_ATTRIBUTION,
+  CONTROL_WIDGET_REGISTRY,
+  CommandButton,
+  ConnectedWidget,
+  DashboardRenderer,
+  EChart,
+  EntitySelector,
+  FlashValue,
+  Gauge,
+  Image,
+  LOCATION_WIDGET_REGISTRY,
+  Label,
+  LatestCard,
+  MapRuntimeProvider,
+  MapWidget,
+  SELECTION_WIDGET_REGISTRY,
+  Table,
+  TenantBasemapProvider,
+  TimeSeriesChart,
+  WIDGET_BINDS_DATASOURCE,
+  WIDGET_CHANNEL,
+  WIDGET_OPTIONS,
+  WIDGET_REGISTRY,
+  WidgetCandidatesProvider,
+  WidgetFrame,
+  WidgetSelectProvider,
+  WidgetSubjectProvider,
+  buildGaugeOption,
+  buildLineOption,
+  buildPayload,
+  clampNumberOption,
+  commandStatusColor,
+  commandStatusLabel,
+  css,
+  defaultValues,
+  describePosition,
+  enumOptionValues,
+  flashBackgroundStyle,
+  flashTextStyle,
+  formatDegrees,
+  highestSeverity,
+  isScalar,
+  isTerminalStatus,
+  landStyleFrom,
+  loadLandStyle,
+  numberOptionSpec,
+  optBoolean,
+  parseParameterSchema,
+  pickSample,
+  placeable,
+  projectToPanel,
+  rasterStyleFor,
+  resolveChartTheme,
+  severityColor,
+  severityLabel,
+  severityRank,
+  stripUnknownOptions,
+  useAlarmStream,
+  useCandidates,
+  useChartTheme,
+  useCommandStream,
+  useDatasourceAvailability,
+  useFlashOnChange,
+  useLocationStream,
+  useMapRuntime,
+  useMeasurementStream,
+  useResolvedBindings,
+  useSlotCandidates,
+  useTenantBasemap,
+  useWidgetCandidates,
+  useWidgetSelect,
+  validateDefinitionOptions,
+  validateParams,
+  validateWidgetOptions,
+  widgetSubjectLabel
+};
+//# sourceMappingURL=index.js.map