camstack 1.2.187 → 1.2.188

package/dist/{launcher-RCLUYTAW.js → launcher-FYTHPW44.js}

@@ -24024,9 +24024,9 @@ var require_zod = __commonJS({
   }
 });
 
-// ../system/dist/dist-BkNfEJKa.js
-var require_dist_BkNfEJKa = __commonJS({
-  "../system/dist/dist-BkNfEJKa.js"(exports) {
+// ../system/dist/dist-Ct88catN.js
+var require_dist_Ct88catN = __commonJS({
+  "../system/dist/dist-Ct88catN.js"(exports) {
     "use strict";
     var zod = require_zod();
     __require("crypto");
@@ -27460,6 +27460,7 @@ var require_dist_BkNfEJKa = __commonJS({
       field: zod.z.string().min(1),
       on: zod.z.literal("advance")
     });
+    var HISTORY_DEFAULT_MIN_INTERVAL_MS = 1e4;
     function resolveCapMount(def) {
       if (def.mount) return def.mount;
       if (def.deviceNative === true) return { kind: "device-native" };
@@ -98797,7 +98798,284 @@ var require_dist_BkNfEJKa = __commonJS({
       durability: "session",
       volatileFields: []
     };
-    DeviceType.Camera;
+    var HISTORY_CATALOG = {
+      "air-quality-sensor": {
+        "co2Ppm": {
+          kind: "gauge",
+          unit: "ppm",
+          deadband: 5
+        },
+        "vocPpb": {
+          kind: "gauge",
+          unit: "ppb",
+          deadband: 5
+        },
+        "pm25": {
+          kind: "gauge",
+          unit: "ug/m3",
+          deadband: 1
+        },
+        "pm10": {
+          kind: "gauge",
+          unit: "ug/m3",
+          deadband: 1
+        },
+        "aqi": {
+          kind: "gauge",
+          unit: "count",
+          deadband: 1
+        }
+      },
+      "ambient-light-sensor": { "lux": {
+        kind: "gauge",
+        unit: "lx",
+        deadbandPct: 10,
+        minIntervalMs: 6e4
+      } },
+      "battery": { "percentage": {
+        kind: "gauge",
+        unit: "%"
+      } },
+      "binary": { "on": { kind: "boolean" } },
+      "brightness": { "percentage": {
+        kind: "gauge",
+        unit: "%",
+        minIntervalMs: 0
+      } },
+      "carbon-monoxide": { "detected": { kind: "boolean" } },
+      "climate-control": {
+        "currentTemp": {
+          kind: "gauge",
+          unit: "\xB0C",
+          deadband: 0.1
+        },
+        "currentHumidity": {
+          kind: "gauge",
+          unit: "%",
+          deadband: 0.5
+        },
+        "target": {
+          kind: "gauge",
+          unit: "\xB0C",
+          minIntervalMs: 0
+        },
+        "targetHigh": {
+          kind: "gauge",
+          unit: "\xB0C",
+          minIntervalMs: 0
+        },
+        "targetLow": {
+          kind: "gauge",
+          unit: "\xB0C",
+          minIntervalMs: 0
+        }
+      },
+      "contact": { "entryOpen": { kind: "boolean" } },
+      "cover": { "position": {
+        kind: "gauge",
+        unit: "%",
+        minIntervalMs: 0
+      } },
+      "device-status": { "online": { kind: "boolean" } },
+      "dishwasher": { "progressPercent": {
+        kind: "gauge",
+        unit: "%",
+        deadband: 2
+      } },
+      "fan-control": {
+        "percentage": {
+          kind: "gauge",
+          unit: "%",
+          minIntervalMs: 0
+        },
+        "oscillating": { kind: "boolean" }
+      },
+      "flood": { "flooded": { kind: "boolean" } },
+      "gas": { "detected": { kind: "boolean" } },
+      "heating-valve": { "position": {
+        kind: "gauge",
+        unit: "%",
+        deadband: 1
+      } },
+      "humidifier": {
+        "currentHumidity": {
+          kind: "gauge",
+          unit: "%",
+          deadband: 0.5
+        },
+        "on": { kind: "boolean" }
+      },
+      "humidity-sensor": { "percent": {
+        kind: "gauge",
+        unit: "%",
+        deadband: 0.5
+      } },
+      "lawn-mower-control": { "batteryLevel": {
+        kind: "gauge",
+        unit: "%",
+        deadband: 2
+      } },
+      "motion": { "detected": {
+        kind: "boolean",
+        excludeDeviceTypes: [DeviceType.Camera]
+      } },
+      "network-link": {
+        "signalPercent": {
+          kind: "gauge",
+          unit: "%",
+          deadband: 3,
+          minIntervalMs: 6e4
+        },
+        "rssiDbm": {
+          kind: "gauge",
+          unit: "dBm",
+          deadband: 2,
+          minIntervalMs: 6e4
+        }
+      },
+      "numeric-sensor": { "value": {
+        kind: "gauge",
+        unitFrom: "unit",
+        minIntervalMs: 3e4
+      } },
+      "pet-feeder": {
+        "foodLevel": { kind: "gauge" },
+        "food1": { kind: "gauge" },
+        "food2": { kind: "gauge" },
+        "batteryPower": {
+          kind: "gauge",
+          unit: "%",
+          deadband: 2
+        },
+        "desiccantLeftDays": {
+          kind: "gauge",
+          unit: "days"
+        }
+      },
+      "power-meter": {
+        "watts": {
+          kind: "gauge",
+          unit: "W",
+          deadband: 1,
+          minIntervalMs: 3e4
+        },
+        "kwhTotal": {
+          kind: "counter",
+          unit: "kWh",
+          deadband: 0.01,
+          minIntervalMs: 6e4
+        },
+        "volts": {
+          kind: "gauge",
+          unit: "V",
+          deadband: 1,
+          minIntervalMs: 3e4
+        },
+        "amps": {
+          kind: "gauge",
+          unit: "A",
+          deadband: 0.05,
+          minIntervalMs: 3e4
+        },
+        "va": {
+          kind: "gauge",
+          unit: "VA",
+          deadband: 1,
+          minIntervalMs: 3e4
+        },
+        "powerFactor": {
+          kind: "gauge",
+          unit: "ratio",
+          deadband: 0.01,
+          minIntervalMs: 6e4
+        }
+      },
+      "presence": { "batteryPercent": {
+        kind: "gauge",
+        unit: "%",
+        deadband: 1
+      } },
+      "pressure-sensor": { "hpa": {
+        kind: "gauge",
+        unit: "hPa",
+        deadband: 0.1
+      } },
+      "smoke": { "detected": { kind: "boolean" } },
+      "switch": { "on": { kind: "boolean" } },
+      "tamper": { "tampered": { kind: "boolean" } },
+      "temperature-sensor": { "celsius": {
+        kind: "gauge",
+        unit: "\xB0C",
+        deadband: 0.1
+      } },
+      "vacuum-control": {
+        "batteryLevel": {
+          kind: "gauge",
+          unit: "%",
+          deadband: 2
+        },
+        "cleanWater.level": {
+          kind: "gauge",
+          unit: "%",
+          deadband: 2
+        },
+        "dirtyWater.level": {
+          kind: "gauge",
+          unit: "%",
+          deadband: 2
+        },
+        "detergent.level": {
+          kind: "gauge",
+          unit: "%",
+          deadband: 2
+        },
+        "dustBin.level": {
+          kind: "gauge",
+          unit: "%",
+          deadband: 2
+        }
+      },
+      "valve": { "position": {
+        kind: "gauge",
+        unit: "%",
+        minIntervalMs: 0
+      } },
+      "vibration": { "detected": { kind: "boolean" } },
+      "water-heater": {
+        "currentTemp": {
+          kind: "gauge",
+          unit: "\xB0C",
+          deadband: 0.5
+        },
+        "targetTemp": {
+          kind: "gauge",
+          unit: "\xB0C",
+          minIntervalMs: 0
+        }
+      },
+      "weather": {
+        "temperature": {
+          kind: "gauge",
+          unitFrom: "temperatureUnit",
+          deadband: 0.2
+        },
+        "humidity": {
+          kind: "gauge",
+          unit: "%",
+          deadband: 1
+        },
+        "pressure": {
+          kind: "gauge",
+          unitFrom: "pressureUnit",
+          deadband: 0.5
+        },
+        "windSpeed": {
+          kind: "gauge",
+          unitFrom: "windSpeedUnit",
+          deadband: 0.5
+        }
+      }
+    };
     var G711_SCALE_CORRECTION_DB = {
       PCMU: 20 * Math.log10(4),
       PCMA: 20 * Math.log10(8)
@@ -99724,6 +100002,70 @@ var require_dist_BkNfEJKa = __commonJS({
       }
       return out;
     }
+    var REMOVAL_RECONCILE_INTERVAL_MS = 360 * 60 * 1e3;
+    async function reconcileRemovedDevices(opts) {
+      const now = opts.now ?? (() => Date.now());
+      const api = opts.api;
+      if (api === void 0) {
+        opts.logger.warn("device removal reconcile skipped \u2014 no device-manager api");
+        return {
+          read: false,
+          applied: 0,
+          failed: 0
+        };
+      }
+      let tombstones;
+      try {
+        tombstones = await api.deviceManager.listDeletedSince.query({ sinceMs: now() - DEVICE_TOMBSTONE_RETENTION_MS });
+      } catch (err) {
+        opts.logger.warn("device removal reconcile skipped \u2014 tombstones unreadable, nothing deleted", { meta: { error: errMsg(err) } });
+        return {
+          read: false,
+          applied: 0,
+          failed: 0
+        };
+      }
+      let applied = 0;
+      let failed = 0;
+      for (const tombstone of tombstones) try {
+        const result = await opts.remove(tombstone);
+        applied += 1;
+        if (Object.values(result.counts).reduce((sum, n) => sum + n, 0) > 0) opts.logger.info("device removal reconcile cleaned a missed deletion", {
+          tags: { deviceId: tombstone.deviceId },
+          meta: {
+            counts: result.counts,
+            deletedAt: tombstone.deletedAt
+          }
+        });
+      } catch (err) {
+        failed += 1;
+        opts.logger.warn("device removal reconcile failed for a device \u2014 retried next pass", {
+          tags: { deviceId: tombstone.deviceId },
+          meta: { error: errMsg(err) }
+        });
+      }
+      return {
+        read: true,
+        applied,
+        failed
+      };
+    }
+    function armRemovalReconcile(opts) {
+      let running = false;
+      const pass = () => {
+        if (running) return;
+        running = true;
+        reconcileRemovedDevices(opts).catch((err) => {
+          opts.logger.warn("device removal reconcile pass crashed", { meta: { error: errMsg(err) } });
+        }).finally(() => {
+          running = false;
+        });
+      };
+      pass();
+      const timer = setInterval(pass, REMOVAL_RECONCILE_INTERVAL_MS);
+      timer.unref?.();
+      return () => clearInterval(timer);
+    }
     Object.defineProperty(exports, "AGENT_MDNS_SERVICE_TYPE", {
       enumerable: true,
       get: function() {
@@ -100024,6 +100366,18 @@ var require_dist_BkNfEJKa = __commonJS({
         return ForeignSecretMarkerError;
       }
     });
+    Object.defineProperty(exports, "HISTORY_CATALOG", {
+      enumerable: true,
+      get: function() {
+        return HISTORY_CATALOG;
+      }
+    });
+    Object.defineProperty(exports, "HISTORY_DEFAULT_MIN_INTERVAL_MS", {
+      enumerable: true,
+      get: function() {
+        return HISTORY_DEFAULT_MIN_INTERVAL_MS;
+      }
+    });
     Object.defineProperty(exports, "HUB_MDNS_SERVICE_TYPE", {
       enumerable: true,
       get: function() {
@@ -100330,6 +100684,12 @@ var require_dist_BkNfEJKa = __commonJS({
         return alertsCapability;
       }
     });
+    Object.defineProperty(exports, "armRemovalReconcile", {
+      enumerable: true,
+      get: function() {
+        return armRemovalReconcile;
+      }
+    });
     Object.defineProperty(exports, "asJsonObject", {
       enumerable: true,
       get: function() {
@@ -100648,12 +101008,24 @@ var require_dist_BkNfEJKa = __commonJS({
         return deviceExtensionCapability;
       }
     });
+    Object.defineProperty(exports, "deviceHistoryCapability", {
+      enumerable: true,
+      get: function() {
+        return deviceHistoryCapability;
+      }
+    });
     Object.defineProperty(exports, "deviceManagerCapability", {
       enumerable: true,
       get: function() {
         return deviceManagerCapability;
       }
     });
+    Object.defineProperty(exports, "deviceRemovalHookCapability", {
+      enumerable: true,
+      get: function() {
+        return deviceRemovalHookCapability;
+      }
+    });
     Object.defineProperty(exports, "deviceStateCapability", {
       enumerable: true,
       get: function() {
@@ -112906,11 +113278,11 @@ ${values.join("\n")}` : `${blockName} :`;
   }
 });
 
-// ../system/dist/device-ca-CnbrgfmW.js
-var require_device_ca_CnbrgfmW = __commonJS({
-  "../system/dist/device-ca-CnbrgfmW.js"(exports) {
+// ../system/dist/device-ca-75rt3U_U.js
+var require_device_ca_75rt3U_U = __commonJS({
+  "../system/dist/device-ca-75rt3U_U.js"(exports) {
     "use strict";
-    var require_dist10 = require_dist_BkNfEJKa();
+    var require_dist10 = require_dist_Ct88catN();
     var require_x509_es = require_x509_es_C4cOo48M();
     var node_crypto = __require("crypto");
     var SYSTEM_SECRET_OWNER = "system";
@@ -113325,11 +113697,11 @@ var require_device_ca_CnbrgfmW = __commonJS({
   }
 });
 
-// ../system/dist/phase6-declare-gate-Bl7KocEs.js
-var require_phase6_declare_gate_Bl7KocEs = __commonJS({
-  "../system/dist/phase6-declare-gate-Bl7KocEs.js"(exports) {
+// ../system/dist/phase6-declare-gate-C6WqagkC.js
+var require_phase6_declare_gate_C6WqagkC = __commonJS({
+  "../system/dist/phase6-declare-gate-C6WqagkC.js"(exports) {
     "use strict";
-    var require_dist10 = require_dist_BkNfEJKa();
+    var require_dist10 = require_dist_Ct88catN();
     function legacyTableRowCountFromList(tables, collection) {
       return tables.find((t) => t.name === collection)?.rows ?? 0;
     }
@@ -113423,9 +113795,9 @@ var require_alerts_addon = __commonJS({
       [Symbol.toStringTag]: { value: "Module" }
     });
     require_chunk_Cek0wNdY();
-    var require_dist10 = require_dist_BkNfEJKa();
+    var require_dist10 = require_dist_Ct88catN();
     var require_read_all_rows$1 = require_read_all_rows_CVoO1ONM();
-    var require_phase6_declare_gate = require_phase6_declare_gate_Bl7KocEs();
+    var require_phase6_declare_gate = require_phase6_declare_gate_C6WqagkC();
     var CRITICAL_CATEGORIES = /* @__PURE__ */ new Set([
       "addon.runner-failed",
       "addon.runner-refused",
@@ -115075,7 +115447,7 @@ var require_calendars_addon = __commonJS({
       [Symbol.toStringTag]: { value: "Module" }
     });
     require_chunk_Cek0wNdY();
-    var require_dist10 = require_dist_BkNfEJKa();
+    var require_dist10 = require_dist_Ct88catN();
     var require_settle_sources = require_settle_sources_Bhsy57y();
     var zod = require_zod();
     var CALENDAR_COLOR_PALETTE = [
@@ -115293,11 +115665,11 @@ var require_calendars = __commonJS({
   }
 });
 
-// ../system/dist/composition-sources-BwIIltnZ.js
-var require_composition_sources_BwIIltnZ = __commonJS({
-  "../system/dist/composition-sources-BwIIltnZ.js"(exports) {
+// ../system/dist/composition-sources-BQmhc3se.js
+var require_composition_sources_BQmhc3se = __commonJS({
+  "../system/dist/composition-sources-BQmhc3se.js"(exports) {
     "use strict";
-    var require_dist10 = require_dist_BkNfEJKa();
+    var require_dist10 = require_dist_Ct88catN();
     function normalizedNativeOwner(owner) {
       const trimmed = owner?.trim();
       return trimmed ? trimmed : null;
@@ -115412,8 +115784,8 @@ var require_composer_addon = __commonJS({
       [Symbol.toStringTag]: { value: "Module" }
     });
     require_chunk_Cek0wNdY();
-    var require_dist10 = require_dist_BkNfEJKa();
-    var require_composition_sources = require_composition_sources_BwIIltnZ();
+    var require_dist10 = require_dist_Ct88catN();
+    var require_composition_sources = require_composition_sources_BQmhc3se();
     var zod = require_zod();
     function isRecord$2(value) {
       return typeof value === "object" && value !== null && !Array.isArray(value);
@@ -119223,7 +119595,7 @@ var require_console_logging = __commonJS({
       [Symbol.toStringTag]: { value: "Module" }
     });
     require_chunk_Cek0wNdY();
-    var require_dist10 = require_dist_BkNfEJKa();
+    var require_dist10 = require_dist_Ct88catN();
     var require_formatter = require_formatter_DqAKDlvN();
     var LEVEL_RANK = {
       debug: 0,
@@ -123616,9 +123988,9 @@ var require_core_blocks_addon = __commonJS({
     "use strict";
     Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
     var require_chunk = require_chunk_Cek0wNdY();
-    var require_dist10 = require_dist_BkNfEJKa();
+    var require_dist10 = require_dist_Ct88catN();
     var require_read_all_rows$1 = require_read_all_rows_CVoO1ONM();
-    var require_composition_sources = require_composition_sources_BwIIltnZ();
+    var require_composition_sources = require_composition_sources_BQmhc3se();
     var require_prefix_range = require_prefix_range_D_KueXbQ();
     var require_prefix_walk = require_prefix_walk_Dv6MLZlM();
     var zod = require_zod();
@@ -136160,7 +136532,7 @@ var require_device_manager_addon = __commonJS({
       [Symbol.toStringTag]: { value: "Module" }
     });
     require_chunk_Cek0wNdY();
-    var require_dist10 = require_dist_BkNfEJKa();
+    var require_dist10 = require_dist_Ct88catN();
     var require_read_all_rows$1 = require_read_all_rows_CVoO1ONM();
     var require_prefix_range = require_prefix_range_D_KueXbQ();
     var require_prefix_walk = require_prefix_walk_Dv6MLZlM();
@@ -145234,7 +145606,7 @@ var require_hub_forwarder = __commonJS({
       [Symbol.toStringTag]: { value: "Module" }
     });
     require_chunk_Cek0wNdY();
-    var require_dist10 = require_dist_BkNfEJKa();
+    var require_dist10 = require_dist_Ct88catN();
     var require_formatter = require_formatter_DqAKDlvN();
     var DEFAULT_OUTBOUND_BUFFER_SIZE = 500;
     var HubForwarderDestination = class {
@@ -145371,7 +145743,7 @@ var require_liveness_monitor_addon = __commonJS({
     "use strict";
     Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
     require_chunk_Cek0wNdY();
-    var require_dist10 = require_dist_BkNfEJKa();
+    var require_dist10 = require_dist_Ct88catN();
     var NO_DEVICES = "liveness:no-devices";
     var ALL_OFFLINE = "liveness:all-devices-offline";
     var NO_FOOTAGE_PREFIX = "liveness:no-footage:";
@@ -145734,12 +146106,12 @@ var require_local_auth_addon = __commonJS({
       [Symbol.toStringTag]: { value: "Module" }
     });
     var require_chunk = require_chunk_Cek0wNdY();
-    var require_dist10 = require_dist_BkNfEJKa();
+    var require_dist10 = require_dist_Ct88catN();
     var require_read_all_rows$1 = require_read_all_rows_CVoO1ONM();
     var require_safe_buffer$1 = require_safe_buffer_D3aoa_7X();
     var require_ms$1 = require_ms_LB3giGoU();
-    var require_device_ca = require_device_ca_CnbrgfmW();
-    var require_phase6_declare_gate = require_phase6_declare_gate_Bl7KocEs();
+    var require_device_ca = require_device_ca_75rt3U_U();
+    var require_phase6_declare_gate = require_phase6_declare_gate_C6WqagkC();
     var zod = require_zod();
     var node_crypto = __require("crypto");
     node_crypto = require_chunk.__toESM(node_crypto);
@@ -156534,7 +156906,7 @@ var require_loki_logging = __commonJS({
       [Symbol.toStringTag]: { value: "Module" }
     });
     require_chunk_Cek0wNdY();
-    var require_dist10 = require_dist_BkNfEJKa();
+    var require_dist10 = require_dist_Ct88catN();
     function sanitizeLabelName(raw) {
       const replaced = raw.replaceAll(/[^a-zA-Z0-9_]/g, "_");
       return /^[a-zA-Z_]/.test(replaced) ? replaced : `_${replaced}`;
@@ -157206,7 +157578,7 @@ var require_native_metrics_addon = __commonJS({
       [Symbol.toStringTag]: { value: "Module" }
     });
     var require_chunk = require_chunk_Cek0wNdY();
-    var require_dist10 = require_dist_BkNfEJKa();
+    var require_dist10 = require_dist_Ct88catN();
     var node_fs_promises = __require("fs/promises");
     var node_util = __require("util");
     var node_os = __require("os");
@@ -157701,11 +158073,9 @@ var require_native_metrics_addon = __commonJS({
       * rather than a replay of a timestamp this node has already delivered.
       *
       * The return value is not diagnostics. It is the idempotence gate the
-      * DURABLE tier rides on (`load-series-store.ts`): only an accepted sample is
-      * appended to the table, which is what lets that table carry an `INTEGER`
-      * rowid key instead of a composite unique index over two million rows. The
-      * gate is one monotonic comparison in memory; the index it replaces was
-      * measured at ~40 bytes per row.
+      * DURABLE tier rides on this return value (`node-metrics-history-recorder.ts`):
+      * only an accepted sample is sent to device-history. The gate is one monotonic
+      * comparison in memory.
       */
       record(nodeId, atMs, processes) {
         if (nodeId.length === 0) return false;
@@ -157830,138 +158200,7 @@ var require_native_metrics_addon = __commonJS({
         this.lastWriteSeq.delete(nodeId);
       }
     };
-    var CONTAINER_MEMORY_COLLECTION = "metrics:node-memory-samples";
     var CONTAINER_MEMORY_MAX_TOTAL_ROWS = 2880;
-    var CONTAINER_MEMORY_MAX_ROWS = 5e4;
-    var CONTAINER_MEMORY_COLUMNS = [
-      {
-        name: "id",
-        type: "INTEGER",
-        primaryKey: true,
-        notNull: true
-      },
-      {
-        name: "nodeId",
-        type: "TEXT",
-        notNull: true
-      },
-      /** Shared with the process rows of the same tick — that is the whole point. */
-      {
-        name: "atMs",
-        type: "INTEGER",
-        notNull: true
-      },
-      {
-        name: "source",
-        type: "TEXT",
-        notNull: true
-      },
-      /**
-      * Whole MiB, like `rssMib` on the process row and for the same reason: a
-      * byte-exact residency on a value in the tens of gigabytes is precision no
-      * chart can draw, and it costs bytes on every row forever.
-      */
-      {
-        name: "currentMib",
-        type: "INTEGER",
-        notNull: true
-      },
-      /** `NULL` = NO LIMIT. Never a sentinel. */
-      {
-        name: "limitMib",
-        type: "INTEGER"
-      },
-      /** `NULL` = UNKNOWN on all four. Never zero. */
-      {
-        name: "anonMib",
-        type: "INTEGER"
-      },
-      {
-        name: "fileMib",
-        type: "INTEGER"
-      },
-      {
-        name: "shmemMib",
-        type: "INTEGER"
-      },
-      {
-        name: "slabMib",
-        type: "INTEGER"
-      },
-      /** Host-wide i915 GEM bytes. `NULL` wherever debugfs is not mounted. */
-      {
-        name: "gpuShmemMib",
-        type: "INTEGER"
-      }
-    ];
-    var CONTAINER_MEMORY_INDEXES = [
-      /** The one index, and it serves both the read and the prune — see the
-      *  process table's `idx_load_samples_node_at` for the full reasoning. */
-      {
-        name: "idx_node_memory_node_at",
-        columns: ["nodeId", "atMs"]
-      }
-    ];
-    var BYTES_PER_MIB$1 = 1048576;
-    function toMib(value) {
-      return value === null ? null : Math.round(value / BYTES_PER_MIB$1);
-    }
-    function fromMib(value) {
-      return value === null ? null : value * BYTES_PER_MIB$1;
-    }
-    function snapshotToRow(nodeId, atMs, snapshot) {
-      return {
-        nodeId,
-        atMs,
-        source: snapshot.source,
-        currentMib: Math.round(snapshot.currentBytes / BYTES_PER_MIB$1),
-        limitMib: toMib(snapshot.limitBytes),
-        anonMib: toMib(snapshot.anonBytes),
-        fileMib: toMib(snapshot.fileBytes),
-        shmemMib: toMib(snapshot.shmemBytes),
-        slabMib: toMib(snapshot.slabBytes),
-        gpuShmemMib: toMib(snapshot.gpuShmemBytes)
-      };
-    }
-    function rowToPoint(row) {
-      if (row.source !== "cgroup-v2" && row.source !== "cgroup-v1") return null;
-      return {
-        atMs: row.atMs,
-        source: row.source,
-        currentBytes: row.currentMib * BYTES_PER_MIB$1,
-        limitBytes: fromMib(row.limitMib),
-        anonBytes: fromMib(row.anonMib),
-        fileBytes: fromMib(row.fileMib),
-        shmemBytes: fromMib(row.shmemMib),
-        slabBytes: fromMib(row.slabMib),
-        gpuShmemBytes: fromMib(row.gpuShmemMib)
-      };
-    }
-    function recordToMemoryRow(data) {
-      const nodeId = data["nodeId"];
-      const source = data["source"];
-      if (typeof nodeId !== "string" || typeof source !== "string") return null;
-      const atMs = Number(data["atMs"]);
-      const currentMib = Number(data["currentMib"]);
-      if (!Number.isFinite(atMs) || !Number.isFinite(currentMib)) return null;
-      const optional = (raw) => {
-        if (raw === null || raw === void 0) return null;
-        const n = Number(raw);
-        return Number.isFinite(n) ? n : null;
-      };
-      return {
-        nodeId,
-        atMs,
-        source,
-        currentMib,
-        limitMib: optional(data["limitMib"]),
-        anonMib: optional(data["anonMib"]),
-        fileMib: optional(data["fileMib"]),
-        shmemMib: optional(data["shmemMib"]),
-        slabMib: optional(data["slabMib"]),
-        gpuShmemMib: optional(data["gpuShmemMib"])
-      };
-    }
     var ContainerMemoryRing = class {
       ring;
       constructor(options = {}) {
@@ -157971,17 +158210,9 @@ var require_native_metrics_addon = __commonJS({
           ...options.now !== void 0 ? { now: options.now } : {}
         });
       }
-      /** Retain one reading. `false` = a timestamp this node already delivered. */
       record(nodeId, atMs, snapshot) {
         return this.ring.record(nodeId, atMs, [snapshot]);
       }
-      /**
-      * Read one node's retained readings, oldest-first. `sinceMs` is EXCLUSIVE,
-      * matching every other reader in this subsystem.
-      *
-      * A node nobody has recorded answers EMPTY — which is what "this node has no
-      * cgroup" looks like, and it must stay distinguishable from a zero.
-      */
       read(nodeId, sinceMs) {
         const series = this.ring.read(nodeId, sinceMs);
         const out = [];
@@ -158015,623 +158246,7 @@ var require_native_metrics_addon = __commonJS({
       for (const point of hot) byAt.set(point.atMs, point);
       return [...byAt.values()].toSorted((a, b) => a.atMs - b.atMs);
     }
-    var ContainerMemoryStore = class {
-      declared = false;
-      store;
-      logger;
-      nowFn;
-      prunePageRows;
-      constructor(deps) {
-        this.store = deps.store;
-        this.logger = deps.logger;
-        this.nowFn = deps.now ?? (() => Date.now());
-        this.prunePageRows = deps.prunePageRows ?? 2e4;
-      }
-      /** Idempotently declare the collection. `false` when the store refused. */
-      async declare() {
-        if (this.declared) return true;
-        try {
-          await this.store.declareCollection.mutate({
-            collection: CONTAINER_MEMORY_COLLECTION,
-            columns: [...CONTAINER_MEMORY_COLUMNS],
-            indexes: CONTAINER_MEMORY_INDEXES.map((i) => ({
-              name: i.name,
-              columns: [...i.columns]
-            }))
-          });
-          this.declared = true;
-          return true;
-        } catch (err) {
-          this.logger.warn("container memory declareCollection failed \u2014 nothing will be retained on disk", { meta: {
-            collection: CONTAINER_MEMORY_COLLECTION,
-            error: require_dist10.errMsg(err)
-          } });
-          return false;
-        }
-      }
-      /** Append ONE reading. */
-      async append(nodeId, atMs, snapshot) {
-        if (!await this.declare()) return 0;
-        const record = { ...snapshotToRow(nodeId, atMs, snapshot) };
-        try {
-          const { inserted } = await this.store.insertMany.mutate({
-            collection: CONTAINER_MEMORY_COLLECTION,
-            records: [{ data: record }]
-          });
-          return inserted;
-        } catch (err) {
-          this.logger.warn("container memory reading not retained \u2014 this interval will be missing", { meta: {
-            nodeId,
-            atMs,
-            error: require_dist10.errMsg(err)
-          } });
-          return 0;
-        }
-      }
-      /** Read one node's cold readings, oldest-first. `sinceMs` is EXCLUSIVE. */
-      async read(nodeId, sinceMs, limitRows) {
-        if (!await this.declare()) return [];
-        try {
-          const records = await this.store.query.query({
-            collection: CONTAINER_MEMORY_COLLECTION,
-            filter: {
-              where: { nodeId },
-              whereBetween: { atMs: [sinceMs + 1, Number.MAX_SAFE_INTEGER] },
-              orderBy: {
-                field: "atMs",
-                direction: "asc"
-              },
-              limit: limitRows
-            }
-          });
-          const points = [];
-          for (const record of records) {
-            const row = recordToMemoryRow(record.data);
-            if (row === null) continue;
-            const point = rowToPoint(row);
-            if (point !== null) points.push(point);
-          }
-          return points;
-        } catch (err) {
-          this.logger.warn("container memory cold read failed \u2014 answering from the hot window only", { meta: {
-            nodeId,
-            sinceMs,
-            error: require_dist10.errMsg(err)
-          } });
-          return [];
-        }
-      }
-      /**
-      * Enforce BOTH bounds, oldest-first, through a bounded page each.
-      *
-      * Not rate-limited here: it is driven by the process store's own prune
-      * cadence, so it runs at most once a minute by construction and a second
-      * timer would be a second thing to get wrong.
-      */
-      async prune(nodeIds, retention) {
-        if (!await this.declare()) return null;
-        const ageCutoff = this.nowFn() - retention.retentionHours * 36e5;
-        let deletedByAge = 0;
-        let rowsExamined = 0;
-        for (const nodeId of nodeIds) {
-          const outcome = await this.deleteOldestPage(nodeId, ageCutoff, this.prunePageRows);
-          deletedByAge += outcome.deleted;
-          rowsExamined += outcome.examined;
-        }
-        const total = await this.count();
-        const excess = total === null ? 0 : total - CONTAINER_MEMORY_MAX_ROWS;
-        let deletedByCap = 0;
-        if (excess > 0) {
-          let remaining = Math.min(excess, this.prunePageRows);
-          for (const nodeId of nodeIds) {
-            if (remaining <= 0) break;
-            const outcome = await this.deleteOldestPage(nodeId, null, remaining);
-            deletedByCap += outcome.deleted;
-            remaining -= outcome.deleted;
-            rowsExamined += outcome.examined;
-          }
-          this.logger.warn("container memory ROW CAP bit \u2014 evicting the oldest readings", { meta: {
-            collection: CONTAINER_MEMORY_COLLECTION,
-            rows: total,
-            cap: CONTAINER_MEMORY_MAX_ROWS,
-            over: excess,
-            deleted: deletedByCap,
-            hint: "lower the retention or the sampling cadence \u2014 the cap is the guarantee, not the intention"
-          } });
-        }
-        return {
-          deletedByAge,
-          deletedByCap,
-          rowsExamined,
-          capBit: excess > 0
-        };
-      }
-      /** Total rows, or `null` when the store could not answer. */
-      async count() {
-        if (!await this.declare()) return null;
-        try {
-          return await this.store.count.query({ collection: CONTAINER_MEMORY_COLLECTION });
-        } catch (err) {
-          this.logger.warn("container memory count failed \u2014 the row cap is not enforced this pass", { meta: { error: require_dist10.errMsg(err) } });
-          return null;
-        }
-      }
-      /**
-      * Delete this node's oldest rows, at most one page's worth.
-      *
-      * `cutoff === null` means "the oldest rows, whatever their age" — the
-      * row-cap path, which is bounded by `limitRows` instead. Either way the page
-      * is READ FIRST, ordered by the one index, and its last `atMs` becomes the
-      * effective cutoff for a single bounded delete. An unbounded `deleteWhere`
-      * would be one statement and one stalling transaction the first time a
-      * retention is lowered.
-      */
-      async deleteOldestPage(nodeId, cutoff, limitRows) {
-        if (limitRows <= 0) return {
-          deleted: 0,
-          examined: 0
-        };
-        try {
-          const page = await this.store.query.query({
-            collection: CONTAINER_MEMORY_COLLECTION,
-            filter: {
-              where: { nodeId },
-              ...cutoff === null ? {} : { whereBetween: { atMs: [0, cutoff] } },
-              orderBy: {
-                field: "atMs",
-                direction: "asc"
-              },
-              limit: Math.min(limitRows, this.prunePageRows)
-            },
-            columns: ["atMs"]
-          });
-          if (page.length === 0) return {
-            deleted: 0,
-            examined: 0
-          };
-          const effectiveCutoff = Number(page.at(-1)?.data["atMs"]);
-          if (!Number.isFinite(effectiveCutoff)) return {
-            deleted: 0,
-            examined: page.length
-          };
-          const { deleted } = await this.store.deleteWhere.mutate({
-            collection: CONTAINER_MEMORY_COLLECTION,
-            filter: {
-              where: { nodeId },
-              whereBetween: { atMs: [0, effectiveCutoff] }
-            }
-          });
-          return {
-            deleted,
-            examined: page.length
-          };
-        } catch (err) {
-          this.logger.warn("container memory prune failed \u2014 the table keeps growing this pass", { meta: {
-            nodeId,
-            cutoff,
-            error: require_dist10.errMsg(err)
-          } });
-          return {
-            deleted: 0,
-            examined: 0
-          };
-        }
-      }
-    };
-    var LOAD_SERIES_COLLECTION = "metrics:node-load-samples";
     var DEFAULT_MAX_ROWS = 5e5;
-    var LOAD_SERIES_COLUMNS = [
-      /** `INTEGER PRIMARY KEY` = SQLite rowid alias: the key IS the row's address,
-      *  so it costs no separate index and no stored string. */
-      {
-        name: "id",
-        type: "INTEGER",
-        primaryKey: true,
-        notNull: true
-      },
-      {
-        name: "nodeId",
-        type: "TEXT",
-        notNull: true
-      },
-      /** The EMITTING node's timestamp for the sample this row belongs to. Every
-      *  row of one sample shares it — that is what makes a sample reassemblable. */
-      {
-        name: "atMs",
-        type: "INTEGER",
-        notNull: true
-      },
-      {
-        name: "pid",
-        type: "INTEGER",
-        notNull: true
-      },
-      /** `NULL` for a process no addon owns — `root` and `system` both. */
-      {
-        name: "addonId",
-        type: "TEXT"
-      },
-      {
-        name: "classification",
-        type: "TEXT",
-        notNull: true
-      },
-      /** `ps pcpu` x 10. A LIFETIME average, not a rate — see `NodeProcess`. */
-      {
-        name: "cpuDeci",
-        type: "INTEGER",
-        notNull: true
-      },
-      {
-        name: "rssMib",
-        type: "INTEGER",
-        notNull: true
-      },
-      /** Instantaneous main-thread CPU% x 10. `NULL` = UNKNOWN, never zero. */
-      {
-        name: "cpuMainDeci",
-        type: "INTEGER"
-      },
-      /** Instantaneous V8-helper-pool CPU% x 10. `NULL` = UNKNOWN, never zero. */
-      {
-        name: "cpuGcDeci",
-        type: "INTEGER"
-      }
-    ];
-    var LOAD_SERIES_INDEXES = [
-      /**
-      * The ONE index, and it serves both jobs.
-      *
-      * Reads are always "this node, newer than T" — `nodeId` leads so the
-      * equality is a range scan and `atMs` supplies the order without a sort.
-      * Prunes are always "this node, oldest first" — the same index, walked from
-      * the other end. A second index on `atMs` alone was measured and rejected:
-      * it cost 23 B/row (196.0 → 172.8 with the two column drops) to serve a
-      * cross-node prune that a per-node loop over three nodes already serves.
-      */
-      {
-        name: "idx_load_samples_node_at",
-        columns: ["nodeId", "atMs"]
-      }
-    ];
-    var BYTES_PER_MIB = 1048576;
-    function fromDeci(value) {
-      return value === null ? null : Math.round(value) / 10;
-    }
-    function toDeci(value) {
-      return value === null ? null : Math.round(value * 10);
-    }
-    function rowToProcess(row) {
-      return {
-        pid: row.pid,
-        addonId: row.addonId,
-        classification: row.classification,
-        cpuPercent: fromDeci(row.cpuDeci) ?? 0,
-        memoryRssBytes: row.rssMib * BYTES_PER_MIB,
-        cpuMainPercent: fromDeci(row.cpuMainDeci),
-        cpuGcPercent: fromDeci(row.cpuGcDeci)
-      };
-    }
-    function processToRow(nodeId, atMs, process2) {
-      return {
-        nodeId,
-        atMs,
-        pid: process2.pid,
-        addonId: process2.addonId,
-        classification: process2.classification,
-        cpuDeci: toDeci(process2.cpuPercent) ?? 0,
-        rssMib: Math.round(process2.memoryRssBytes / BYTES_PER_MIB),
-        cpuMainDeci: toDeci(process2.cpuMainPercent),
-        cpuGcDeci: toDeci(process2.cpuGcPercent)
-      };
-    }
-    function rowsToSamples(rows) {
-      const byAt = /* @__PURE__ */ new Map();
-      for (const row of rows) {
-        const held = byAt.get(row.atMs);
-        if (held === void 0) byAt.set(row.atMs, [rowToProcess(row)]);
-        else held.push(rowToProcess(row));
-      }
-      return [...byAt.entries()].toSorted((a, b) => a[0] - b[0]).map(([atMs, processes]) => ({
-        atMs,
-        processes
-      }));
-    }
-    var LoadSeriesStore = class {
-      declared = false;
-      lastPruneAtMs = 0;
-      store;
-      logger;
-      nowFn;
-      prunePageRows;
-      pruneIntervalMs;
-      constructor(deps) {
-        this.store = deps.store;
-        this.logger = deps.logger;
-        this.nowFn = deps.now ?? (() => Date.now());
-        this.prunePageRows = deps.prunePageRows ?? 2e4;
-        this.pruneIntervalMs = deps.pruneIntervalMs ?? 6e4;
-      }
-      /** Idempotently declare the collection. `false` when the store refused. */
-      async declare() {
-        if (this.declared) return true;
-        try {
-          await this.store.declareCollection.mutate({
-            collection: LOAD_SERIES_COLLECTION,
-            columns: [...LOAD_SERIES_COLUMNS],
-            indexes: LOAD_SERIES_INDEXES.map((i) => ({
-              name: i.name,
-              columns: [...i.columns]
-            }))
-          });
-          this.declared = true;
-          return true;
-        } catch (err) {
-          this.logger.warn("load series declareCollection failed \u2014 nothing will be retained on disk", { meta: {
-            collection: LOAD_SERIES_COLLECTION,
-            error: require_dist10.errMsg(err)
-          } });
-          return false;
-        }
-      }
-      /**
-      * Append ONE sample — every process row of it — in ONE transaction.
-      *
-      * Never a write per row. `insertMany` exists for exactly this: at the 10 s
-      * default the fleet produces 7.6 rows/s, and 7.6 separate commits per second
-      * on the connection that also serves every cluster-wide configuration read
-      * is a constant load nobody asked for.
-      */
-      async append(nodeId, atMs, processes) {
-        if (processes.length === 0) return 0;
-        if (!await this.declare()) return 0;
-        const records = processes.map((p) => ({ data: { ...processToRow(nodeId, atMs, p) } }));
-        try {
-          const { inserted } = await this.store.insertMany.mutate({
-            collection: LOAD_SERIES_COLLECTION,
-            records
-          });
-          return inserted;
-        } catch (err) {
-          this.logger.warn("load series sample not retained \u2014 this interval will be missing", { meta: {
-            nodeId,
-            atMs,
-            rows: processes.length,
-            error: require_dist10.errMsg(err)
-          } });
-          return 0;
-        }
-      }
-      /**
-      * Read one node's cold samples, oldest-first.
-      *
-      * `sinceMs` is EXCLUSIVE, matching the ring, so a caller passing the newest
-      * timestamp it holds gets only what it is missing. `limitRows` bounds the
-      * read in ROWS (not samples) because rows are what the query costs.
-      */
-      async read(nodeId, sinceMs, limitRows) {
-        if (!await this.declare()) return [];
-        try {
-          const records = await this.store.query.query({
-            collection: LOAD_SERIES_COLLECTION,
-            filter: {
-              where: { nodeId },
-              whereBetween: { atMs: [sinceMs + 1, Number.MAX_SAFE_INTEGER] },
-              orderBy: {
-                field: "atMs",
-                direction: "asc"
-              },
-              limit: limitRows
-            }
-          });
-          const rows = [];
-          for (const record of records) {
-            const row = recordToRow(record.data);
-            if (row !== null) rows.push(row);
-          }
-          return rowsToSamples(rows);
-        } catch (err) {
-          this.logger.warn("load series cold read failed \u2014 answering from the hot window only", { meta: {
-            nodeId,
-            sinceMs,
-            error: require_dist10.errMsg(err)
-          } });
-          return [];
-        }
-      }
-      /**
-      * Enforce BOTH bounds, oldest-first, through a bounded page each.
-      *
-      * Rate-limited to {@link pruneIntervalMs}: a bound is not a deadline, and the
-      * append path must not pay a sweep on every sample.
-      */
-      async prune(nodeIds, retention, force = false) {
-        const now = this.nowFn();
-        if (!force && now - this.lastPruneAtMs < this.pruneIntervalMs) return null;
-        this.lastPruneAtMs = now;
-        if (!await this.declare()) return null;
-        let deletedByAge = 0;
-        let deletedByCap = 0;
-        let rowsExamined = 0;
-        const ageCutoff = now - retention.retentionHours * 36e5;
-        for (const nodeId of nodeIds) {
-          const outcome = await this.pruneNodeToCutoff(nodeId, ageCutoff);
-          deletedByAge += outcome.deleted;
-          rowsExamined += outcome.examined;
-        }
-        const total = await this.count();
-        const excess = total === null ? 0 : total - retention.maxRows;
-        if (excess > 0) {
-          const outcome = await this.pruneOldestRows(nodeIds, excess);
-          deletedByCap = outcome.deleted;
-          rowsExamined += outcome.examined;
-          this.logger.warn("load series ROW CAP bit \u2014 evicting the oldest samples", { meta: {
-            collection: LOAD_SERIES_COLLECTION,
-            rows: total,
-            cap: retention.maxRows,
-            over: excess,
-            deleted: outcome.deleted,
-            retentionHours: retention.retentionHours,
-            hint: "lower the retention or the sampling cadence \u2014 the cap is the guarantee, not the intention"
-          } });
-        }
-        return {
-          deletedByAge,
-          deletedByCap,
-          rowsExamined,
-          capBit: excess > 0
-        };
-      }
-      /** Total rows, or `null` when the store could not answer. */
-      async count() {
-        if (!await this.declare()) return null;
-        try {
-          return await this.store.count.query({ collection: LOAD_SERIES_COLLECTION });
-        } catch (err) {
-          this.logger.warn("load series count failed \u2014 the row cap is not enforced this pass", { meta: { error: require_dist10.errMsg(err) } });
-          return null;
-        }
-      }
-      /**
-      * Delete this node's rows older than `cutoff`, at most one page's worth.
-      *
-      * The page is the whole point. `deleteWhere({ atMs: [0, cutoff] })` on its
-      * own is one statement but an UNBOUNDED one — a first pass after a retention
-      * change would delete millions of rows inside a single stalling transaction.
-      * So the page is read first (keys only, ordered by the index), its last
-      * `atMs` becomes the EFFECTIVE cutoff, and the delete is bounded by it.
-      */
-      async pruneNodeToCutoff(nodeId, cutoff) {
-        try {
-          const page = await this.store.query.query({
-            collection: LOAD_SERIES_COLLECTION,
-            filter: {
-              where: { nodeId },
-              whereBetween: { atMs: [0, cutoff] },
-              orderBy: {
-                field: "atMs",
-                direction: "asc"
-              },
-              limit: this.prunePageRows
-            },
-            columns: ["atMs"]
-          });
-          if (page.length === 0) return {
-            deleted: 0,
-            examined: 0
-          };
-          const effectiveCutoff = Number(page.at(-1)?.data["atMs"]);
-          if (!Number.isFinite(effectiveCutoff)) return {
-            deleted: 0,
-            examined: page.length
-          };
-          const { deleted } = await this.store.deleteWhere.mutate({
-            collection: LOAD_SERIES_COLLECTION,
-            filter: {
-              where: { nodeId },
-              whereBetween: { atMs: [0, effectiveCutoff] }
-            }
-          });
-          return {
-            deleted,
-            examined: page.length
-          };
-        } catch (err) {
-          this.logger.warn("load series age prune failed \u2014 the table keeps growing this pass", { meta: {
-            nodeId,
-            cutoff,
-            error: require_dist10.errMsg(err)
-          } });
-          return {
-            deleted: 0,
-            examined: 0
-          };
-        }
-      }
-      /**
-      * Drop the oldest rows across the known nodes until `excess` is covered.
-      *
-      * Same bounded-page technique, walked per node so the one index serves it.
-      * The node holding the oldest rows pays first, which is also the node
-      * producing the pressure when a runaway process count is the cause.
-      */
-      async pruneOldestRows(nodeIds, excess) {
-        let remaining = Math.min(excess, this.prunePageRows);
-        let deleted = 0;
-        let examined = 0;
-        for (const nodeId of nodeIds) {
-          if (remaining <= 0) break;
-          try {
-            const page = await this.store.query.query({
-              collection: LOAD_SERIES_COLLECTION,
-              filter: {
-                where: { nodeId },
-                orderBy: {
-                  field: "atMs",
-                  direction: "asc"
-                },
-                limit: remaining
-              },
-              columns: ["atMs"]
-            });
-            examined += page.length;
-            if (page.length === 0) continue;
-            const cutoff = Number(page.at(-1)?.data["atMs"]);
-            if (!Number.isFinite(cutoff)) continue;
-            const result = await this.store.deleteWhere.mutate({
-              collection: LOAD_SERIES_COLLECTION,
-              filter: {
-                where: { nodeId },
-                whereBetween: { atMs: [0, cutoff] }
-              }
-            });
-            deleted += result.deleted;
-            remaining -= result.deleted;
-          } catch (err) {
-            this.logger.warn("load series cap prune failed \u2014 the cap is not enforced this pass", { meta: {
-              nodeId,
-              error: require_dist10.errMsg(err)
-            } });
-          }
-        }
-        return {
-          deleted,
-          examined
-        };
-      }
-    };
-    function recordToRow(data) {
-      const nodeId = data["nodeId"];
-      const classification = data["classification"];
-      if (typeof nodeId !== "string" || typeof classification !== "string") return null;
-      const atMs = Number(data["atMs"]);
-      const pid = Number(data["pid"]);
-      const cpuDeci = Number(data["cpuDeci"]);
-      const rssMib = Number(data["rssMib"]);
-      if (![
-        atMs,
-        pid,
-        cpuDeci,
-        rssMib
-      ].every((n) => Number.isFinite(n))) return null;
-      const rawAddon = data["addonId"];
-      const optional = (raw) => {
-        if (raw === null || raw === void 0) return null;
-        const n = Number(raw);
-        return Number.isFinite(n) ? n : null;
-      };
-      return {
-        nodeId,
-        atMs,
-        pid,
-        addonId: typeof rawAddon === "string" ? rawAddon : null,
-        classification,
-        cpuDeci,
-        rssMib,
-        cpuMainDeci: optional(data["cpuMainDeci"]),
-        cpuGcDeci: optional(data["cpuGcDeci"])
-      };
-    }
     var LoadSeriesConfigError = class extends Error {
       constructor(message) {
         super(message);
@@ -158730,6 +158345,201 @@ var require_native_metrics_addon = __commonJS({
         oldestAtMs
       };
     }
+    var ADDON_ID = "metrics-native";
+    var NODE_PROCESS_CPU_KEY = `addon:${ADDON_ID}/process-cpu-percent`;
+    var NODE_PROCESS_RSS_KEY = `addon:${ADDON_ID}/process-rss-mib`;
+    var NODE_CONTAINER_CURRENT_KEY = `addon:${ADDON_ID}/container-current-mib`;
+    function nodeMetricsHistoryClient(api) {
+      return {
+        declareSeries: (input) => api.declareSeries.mutate(input),
+        record: (input) => api.record.mutate({ points: [...input.points] }),
+        queryNode: async (input) => {
+          return { series: (await api.queryNode.query(input)).series.map((s) => ({
+            scope: s.scope,
+            points: s.points.map((p) => ({
+              t: p.t,
+              samples: p.samples,
+              value: p.last ?? p.mean
+            }))
+          })) };
+        }
+      };
+    }
+    var NodeMetricsHistoryRecorder = class {
+      deps;
+      declared = false;
+      constructor(deps) {
+        this.deps = deps;
+      }
+      async declare() {
+        if (this.declared) return;
+        const { deviceHistory } = this.deps;
+        await deviceHistory.declareSeries({
+          name: "process-cpu-percent",
+          subjectKind: "node",
+          kind: "gauge",
+          displayName: "Process CPU %",
+          ingest: "points",
+          unit: "%"
+        });
+        await deviceHistory.declareSeries({
+          name: "process-rss-mib",
+          subjectKind: "node",
+          kind: "gauge",
+          displayName: "Process RSS (MiB)",
+          ingest: "points",
+          unit: "MiB"
+        });
+        await deviceHistory.declareSeries({
+          name: "container-current-mib",
+          subjectKind: "node",
+          kind: "gauge",
+          displayName: "Container memory current (MiB)",
+          ingest: "points",
+          unit: "MiB"
+        });
+        this.declared = true;
+      }
+      async recordSample(nodeId, atMs, processes, containerMemory) {
+        if (!await this.ensureDeclared()) return;
+        const points = [];
+        for (const p of processes) {
+          const scope = String(p.pid);
+          points.push({
+            key: NODE_PROCESS_CPU_KEY,
+            subject: {
+              kind: "node",
+              nodeId
+            },
+            scope,
+            ts: atMs,
+            value: p.cpuPercent
+          });
+          points.push({
+            key: NODE_PROCESS_RSS_KEY,
+            subject: {
+              kind: "node",
+              nodeId
+            },
+            scope,
+            ts: atMs,
+            value: Math.round(p.memoryRssBytes / 1048576)
+          });
+        }
+        if (containerMemory !== null) points.push({
+          key: NODE_CONTAINER_CURRENT_KEY,
+          subject: {
+            kind: "node",
+            nodeId
+          },
+          scope: "",
+          ts: atMs,
+          value: Math.round(containerMemory.currentBytes / 1048576)
+        });
+        if (points.length === 0) return;
+        try {
+          await this.deps.deviceHistory.record({ points });
+        } catch (err) {
+          this.deps.logger.warn("node metrics history sample not stored", { meta: {
+            nodeId,
+            atMs,
+            error: err instanceof Error ? err.message : String(err)
+          } });
+        }
+      }
+      async readContainerPoints(nodeId, sinceMs, maxPoints) {
+        if (!await this.ensureDeclared()) return [];
+        const result = await this.deps.deviceHistory.queryNode({
+          nodeId,
+          key: NODE_CONTAINER_CURRENT_KEY,
+          from: sinceMs + 1,
+          to: Date.now(),
+          resolution: "raw",
+          maxPoints
+        });
+        const out = [];
+        for (const s of result.series) for (const p of s.points) {
+          if (p.value === null || !Number.isFinite(p.value)) continue;
+          out.push({
+            atMs: p.t,
+            source: "cgroup-v2",
+            currentBytes: p.value * 1048576,
+            limitBytes: null,
+            anonBytes: null,
+            fileBytes: null,
+            shmemBytes: null,
+            slabBytes: null,
+            gpuShmemBytes: null
+          });
+        }
+        return out.toSorted((a, b) => a.atMs - b.atMs);
+      }
+      async readProcessSamples(nodeId, sinceMs, maxPoints) {
+        if (!await this.ensureDeclared()) return [];
+        const to = Date.now();
+        const [cpuResult, rssResult] = await Promise.all([this.deps.deviceHistory.queryNode({
+          nodeId,
+          key: NODE_PROCESS_CPU_KEY,
+          from: sinceMs + 1,
+          to,
+          resolution: "raw",
+          maxPoints
+        }), this.deps.deviceHistory.queryNode({
+          nodeId,
+          key: NODE_PROCESS_RSS_KEY,
+          from: sinceMs + 1,
+          to,
+          resolution: "raw",
+          maxPoints
+        })]);
+        const byAt = /* @__PURE__ */ new Map();
+        const ingest = (series, field) => {
+          for (const s of series) {
+            const pid = Number(s.scope);
+            if (!Number.isFinite(pid)) continue;
+            for (const p of s.points) {
+              if (p.value === null || !Number.isFinite(p.value)) continue;
+              let perPid = byAt.get(p.t);
+              if (perPid === void 0) {
+                perPid = /* @__PURE__ */ new Map();
+                byAt.set(p.t, perPid);
+              }
+              const base = perPid.get(pid) ?? {
+                pid,
+                addonId: null,
+                classification: "managed",
+                cpuPercent: 0,
+                memoryRssBytes: 0,
+                cpuMainPercent: null,
+                cpuGcPercent: null
+              };
+              perPid.set(pid, field === "cpuPercent" ? {
+                ...base,
+                cpuPercent: p.value
+              } : {
+                ...base,
+                memoryRssBytes: p.value * 1048576
+              });
+            }
+          }
+        };
+        ingest(cpuResult.series, "cpuPercent");
+        ingest(rssResult.series, "memoryRssBytes");
+        return [...byAt.entries()].toSorted((a, b) => a[0] - b[0]).map(([atMs, perPid]) => ({
+          atMs,
+          processes: [...perPid.values()]
+        }));
+      }
+      async ensureDeclared() {
+        try {
+          await this.declare();
+          return true;
+        } catch (err) {
+          this.deps.logger.warn("node metrics history declare failed", { meta: { error: err instanceof Error ? err.message : String(err) } });
+          return false;
+        }
+      }
+    };
     var nodeAccessCheck = (path) => (0, node_fs_promises.access)(path, node_fs.constants.X_OK);
     async function findOnPath(binary, pathEnv, check = nodeAccessCheck) {
       const dirs = (pathEnv ?? "").split(":").filter((dir) => dir.length > 0);
@@ -159577,7 +159387,7 @@ var require_native_metrics_addon = __commonJS({
       * the `settings-store` singleton would ship its rows over Moleculer, once
       * per sample, to reach that very same table.
       */
-      loadStore = null;
+      metricsHistory = null;
       /**
       * The container's OWN memory, sampled on the process-snapshot tick.
       *
@@ -159589,10 +159399,8 @@ var require_native_metrics_addon = __commonJS({
       */
       memoryProbe = null;
       pidsProbe = null;
-      /** Hot tier for the container reading. Bounds in `container-memory-series.ts`. */
+      /** Hot tier for the container reading. Bounds in `container-memory-ring.ts`. */
       memoryRing = new ContainerMemoryRing();
-      /** Cold tier, HUB only — same reasoning as `loadStore`. */
-      memoryStore = null;
       /** The resolved knobs. Re-resolved on every settings write. */
       loadConfig = {
         cadenceSec: 10,
@@ -159665,13 +159473,12 @@ var require_native_metrics_addon = __commonJS({
         };
         this.applyLoadSeriesConfig();
         if (this.isHub) {
-          this.loadStore = new LoadSeriesStore({
-            store: this.ctx.api.settingsStore,
-            logger: this.ctx.logger.child("LoadSeries")
+          this.metricsHistory = new NodeMetricsHistoryRecorder({
+            deviceHistory: nodeMetricsHistoryClient(this.ctx.api.deviceHistory),
+            logger: this.ctx.logger.child("NodeMetricsHistory")
           });
-          this.memoryStore = new ContainerMemoryStore({
-            store: this.ctx.api.settingsStore,
-            logger: this.ctx.logger.child("ContainerMemory")
+          this.metricsHistory.declare().catch((err) => {
+            this.ctx.logger.warn("node metrics history declare failed", { meta: { error: err instanceof Error ? err.message : String(err) } });
           });
         }
         this.memoryProbe = new ContainerMemoryProbe({ logger: this.ctx.logger.child("ContainerMemory") });
@@ -159692,7 +159499,7 @@ var require_native_metrics_addon = __commonJS({
       * this node has already delivered, and only an accepted sample reaches the
       * table. That is what makes the append idempotent without a unique index
       * over two million rows — the composite key it replaces was measured at ~40
-      * bytes per row (`load-series-store.ts`).
+      * bytes per row (measured on the old SQLite tier; see D850).
       *
       * The durable append is fire-and-forget: a storage stall must cost a gap in
       * the cold window, never a blocked event-bus handler. Every failure logs.
@@ -159702,26 +159509,9 @@ var require_native_metrics_addon = __commonJS({
         if (!this.loadRing.record(nodeId, atMs, retained)) return;
         this.observedRowsByNode.set(nodeId, retained.length);
         if (containerMemory !== null) this.memoryRing.record(nodeId, atMs, containerMemory);
-        const store = this.loadStore;
-        if (store === null) return;
-        store.append(nodeId, atMs, retained).then(() => store.prune([...this.observedRowsByNode.keys()], this.loadConfig)).then(async (outcome) => {
-          if (outcome === null) return;
-          await this.memoryStore?.prune([...this.observedRowsByNode.keys()], this.loadConfig);
-        }).catch((err) => {
-          this.ctx.logger.warn("durable load series write failed", { meta: {
-            nodeId,
-            atMs,
-            error: err instanceof Error ? err.message : String(err)
-          } });
-        });
-        if (containerMemory === null) return;
-        this.memoryStore?.append(nodeId, atMs, containerMemory).catch((err) => {
-          this.ctx.logger.warn("durable container memory write failed", { meta: {
-            nodeId,
-            atMs,
-            error: err instanceof Error ? err.message : String(err)
-          } });
-        });
+        const history = this.metricsHistory;
+        if (history === null) return;
+        history.recordSample(nodeId, atMs, retained, containerMemory);
       }
       /**
       * The ONE reader, over both tiers.
@@ -159740,9 +159530,9 @@ var require_native_metrics_addon = __commonJS({
           atMs: sample.atMs,
           processes: sample.processes
         }));
-        const store = this.loadStore;
+        const history = this.metricsHistory;
         const merged = mergeLoadSeries({
-          cold: store === null ? [] : await store.read(params.forNodeId, sinceMs, this.loadConfig.maxRows),
+          cold: history === null ? [] : await history.readProcessSamples(params.forNodeId, sinceMs, this.loadConfig.maxRows),
           hot: hotSamples,
           cadenceMs,
           ...params.maxPoints !== void 0 ? { maxPoints: params.maxPoints } : {}
@@ -159762,7 +159552,7 @@ var require_native_metrics_addon = __commonJS({
           retainedSamples: merged.retainedSamples,
           oldestAtMs: merged.oldestAtMs,
           cadenceMs,
-          durable: store !== null
+          durable: history !== null
         };
       }
       /**
@@ -159778,8 +159568,8 @@ var require_native_metrics_addon = __commonJS({
       */
       async readContainerMemory(params) {
         const hot = this.memoryRing.read(params.forNodeId, params.exclusiveSinceMs);
-        const store = this.memoryStore;
-        const merged = mergeContainerMemory(store === null ? [] : await store.read(params.forNodeId, params.sinceMs, CONTAINER_MEMORY_MAX_ROWS), hot);
+        const history = this.metricsHistory;
+        const merged = mergeContainerMemory(history === null ? [] : await history.readContainerPoints(params.forNodeId, params.sinceMs, 5e3), hot);
         if (params.bucketMs <= params.cadenceMs) return merged;
         return reduceContainerMemory(merged, params.bucketMs, params.origin ?? 0);
       }
@@ -160160,6 +159950,2685 @@ var require_native_metrics_addon = __commonJS({
   }
 });
 
+// ../system/dist/builtins/device-history/device-history.addon.js
+var require_device_history_addon = __commonJS({
+  "../system/dist/builtins/device-history/device-history.addon.js"(exports) {
+    "use strict";
+    Object.defineProperties(exports, {
+      __esModule: { value: true },
+      [Symbol.toStringTag]: { value: "Module" }
+    });
+    require_chunk_Cek0wNdY();
+    var require_dist10 = require_dist_Ct88catN();
+    function subjectIdOf(subject) {
+      return subject.kind === "device" ? `d:${subject.deviceId}` : `n:${subject.nodeId}`;
+    }
+    function deviceIdOf(subject) {
+      return subject.kind === "device" ? subject.deviceId : null;
+    }
+    function identityOf(key, subjectId, scope) {
+      return `${key}\0${subjectId}\0${scope}`;
+    }
+    var LOAD_PAGE = 5e3;
+    var SeriesRegistry = class {
+      store;
+      metrics = /* @__PURE__ */ new Map();
+      byIdentity = /* @__PURE__ */ new Map();
+      byId = /* @__PURE__ */ new Map();
+      inflight = /* @__PURE__ */ new Map();
+      removeListeners = [];
+      constructor(store) {
+        this.store = store;
+      }
+      async load() {
+        this.metrics.clear();
+        this.byIdentity.clear();
+        this.byId.clear();
+        for (const m of await this.store.loadMetrics()) this.metrics.set(m.key, m);
+        let afterId = 0;
+        for (; ; ) {
+          const page = await this.store.loadSeriesPage(afterId, LOAD_PAGE);
+          for (const s of page) this.index(s);
+          const last = page[page.length - 1];
+          if (last === void 0 || page.length < LOAD_PAGE) break;
+          afterId = last.id;
+        }
+      }
+      index(series) {
+        this.byId.set(series.id, series);
+        this.byIdentity.set(identityOf(series.key, series.subject, series.scope), series);
+      }
+      metric(key) {
+        return this.metrics.get(key);
+      }
+      allMetrics() {
+        return [...this.metrics.values()];
+      }
+      /** Persist and remember a metric; idempotent. */
+      async declareMetric(metric) {
+        const existing = this.metrics.get(metric.key);
+        if (existing !== void 0 && sameMetric(existing, metric)) return;
+        await this.store.upsertMetric(metric);
+        this.metrics.set(metric.key, metric);
+      }
+      find(key, subjectId, scope) {
+        return this.byIdentity.get(identityOf(key, subjectId, scope));
+      }
+      byIdOf(id) {
+        return this.byId.get(id);
+      }
+      all() {
+        return [...this.byId.values()];
+      }
+      forSubject(subjectId) {
+        return this.all().filter((s) => s.subject === subjectId);
+      }
+      forKeyAndSubject(key, subjectId) {
+        return this.all().filter((s) => s.key === key && s.subject === subjectId);
+      }
+      /** The series, created on first sight. `ts` stamps `first_ts`/`last_ts` of a new one. */
+      async ensure(key, subject, scope, ts) {
+        const subjectId = subjectIdOf(subject);
+        const identity = identityOf(key, subjectId, scope);
+        const known = this.byIdentity.get(identity);
+        if (known !== void 0) return known;
+        const pending = this.inflight.get(identity);
+        if (pending !== void 0) return pending;
+        const created = this.create(key, subjectId, deviceIdOf(subject), scope, ts).finally(() => {
+          this.inflight.delete(identity);
+        });
+        this.inflight.set(identity, created);
+        return created;
+      }
+      async create(key, subjectId, deviceId, scope, ts) {
+        const stored = await this.store.findSeries(key, subjectId, scope) ?? await this.store.insertSeries({
+          key,
+          subject: subjectId,
+          deviceId,
+          scope,
+          ts
+        });
+        this.index(stored);
+        return stored;
+      }
+      /** Remember a widened span (the store write is the caller's). */
+      noteSpan(id, firstTs, lastTs) {
+        const current = this.byId.get(id);
+        if (current === void 0) return;
+        this.index({
+          ...current,
+          firstTs: Math.min(current.firstTs, firstTs),
+          lastTs: Math.max(current.lastTs, lastTs)
+        });
+      }
+      remove(id) {
+        const current = this.byId.get(id);
+        if (current === void 0) return;
+        this.byId.delete(id);
+        this.byIdentity.delete(identityOf(current.key, current.subject, current.scope));
+        for (const listener of this.removeListeners) listener(current);
+      }
+      /** Per-series state elsewhere (last recorded value, dirty marks, rate limits) is dropped through this. */
+      onRemove(listener) {
+        this.removeListeners.push(listener);
+      }
+    };
+    function sameMetric(a, b) {
+      return a.source === b.source && a.ownerAddon === b.ownerAddon && a.subjectKind === b.subjectKind && a.kind === b.kind && a.unit === b.unit && a.displayName === b.displayName && a.ingest === b.ingest;
+    }
+    var DEADBAND_EPSILON = 1e-9;
+    function minIntervalOf(spec) {
+      if (spec.minIntervalMs !== void 0) return spec.minIntervalMs;
+      return spec.kind === "boolean" ? 0 : require_dist10.HISTORY_DEFAULT_MIN_INTERVAL_MS;
+    }
+    function clearsDeadband(spec, last, value) {
+      if (spec.kind === "boolean") return true;
+      const delta = Math.abs(value - last);
+      if (spec.deadband !== void 0 && delta < spec.deadband - DEADBAND_EPSILON) return false;
+      if (spec.deadbandPct !== void 0) {
+        if (delta < Math.abs(last) * spec.deadbandPct / 100 - DEADBAND_EPSILON) return false;
+      }
+      return true;
+    }
+    function decideCapture(spec, recorded, value, now, options = {}) {
+      if (!Number.isFinite(value)) return {
+        action: "skip",
+        reason: "non-finite"
+      };
+      if (recorded === null) return { action: "emit" };
+      if (value === recorded.value) return {
+        action: "skip",
+        reason: "unchanged"
+      };
+      if (!clearsDeadband(spec, recorded.value, value)) return {
+        action: "skip",
+        reason: "deadband"
+      };
+      if (options.ignoreFloor !== true) {
+        const notBefore = recorded.ts + minIntervalOf(spec);
+        if (now < notBefore) return {
+          action: "defer",
+          notBefore
+        };
+      }
+      return { action: "emit" };
+    }
+    function isRealDeviceType(type) {
+      return type !== require_dist10.DeviceType.Hub && type !== require_dist10.DeviceType.Container;
+    }
+    var DeviceDirectory = class {
+      source;
+      counters;
+      logger;
+      clock;
+      types = /* @__PURE__ */ new Map();
+      inflight = /* @__PURE__ */ new Map();
+      refreshInflight = null;
+      lastFullRefreshAt = null;
+      constructor(source, counters, logger, clock) {
+        this.source = source;
+        this.counters = counters;
+        this.logger = logger;
+        this.clock = clock;
+      }
+      typeOf(deviceId) {
+        return this.types.get(deviceId);
+      }
+      size() {
+        return this.types.size;
+      }
+      /** When the full listing last ANSWERED; `null` before the first answer. */
+      lastRefreshAt() {
+        return this.lastFullRefreshAt;
+      }
+      /** Ids in the directory now (the last full listing plus per-device lookups). */
+      listedIds() {
+        return new Set(this.types.keys());
+      }
+      knows(deviceId) {
+        return this.types.has(deviceId);
+      }
+      /** Replace the map from the full listing. Returns false (map untouched) when the read failed. */
+      refresh() {
+        if (this.refreshInflight !== null) return this.refreshInflight;
+        const run = this.doRefresh().finally(() => {
+          this.refreshInflight = null;
+        });
+        this.refreshInflight = run;
+        return run;
+      }
+      async doRefresh() {
+        try {
+          const all = await this.source.listAll();
+          this.types = new Map(all.map((d) => [d.id, d.type]));
+          this.lastFullRefreshAt = this.clock();
+          this.counters.directoryRefreshAt = this.lastFullRefreshAt;
+          return true;
+        } catch (err) {
+          this.logger.warn("device directory: listing failed \u2014 keeping the previous map", { meta: { error: err instanceof Error ? err.message : String(err) } });
+          return false;
+        }
+      }
+      /** The device's type, asking the hub once when the map does not know it. */
+      ensure(deviceId) {
+        const known = this.types.get(deviceId);
+        if (known !== void 0) return Promise.resolve(known);
+        const pending = this.inflight.get(deviceId);
+        if (pending !== void 0) return pending;
+        const run = this.lookup(deviceId).finally(() => {
+          this.inflight.delete(deviceId);
+        });
+        this.inflight.set(deviceId, run);
+        return run;
+      }
+      async lookup(deviceId) {
+        try {
+          const device = await this.source.getDevice(deviceId);
+          if (device === null) return void 0;
+          this.types.set(device.id, device.type);
+          return device.type;
+        } catch (err) {
+          this.logger.warn("device directory: lookup failed", {
+            tags: { deviceId },
+            meta: { error: err instanceof Error ? err.message : String(err) }
+          });
+          return;
+        }
+      }
+    };
+    function isRecord$1(value) {
+      return typeof value === "object" && value !== null && !Array.isArray(value);
+    }
+    function readPath(slice, path) {
+      let current = slice;
+      for (const step of path.split(".")) {
+        if (!isRecord$1(current)) return void 0;
+        current = current[step];
+      }
+      return current;
+    }
+    function readNumeric(slice, path, kind) {
+      const raw = readPath(slice, path);
+      if (kind === "boolean") {
+        if (typeof raw === "boolean") return raw ? 1 : 0;
+        return null;
+      }
+      if (typeof raw === "number" && Number.isFinite(raw)) return raw;
+      return null;
+    }
+    function readUnit(slice, unitFrom) {
+      const raw = readPath(slice, unitFrom);
+      return typeof raw === "string" && raw.length > 0 ? raw : null;
+    }
+    var CAP_KEY_PREFIX = "cap:";
+    function capSeriesKey(capName, fieldPath) {
+      return `${CAP_KEY_PREFIX}${capName}.${fieldPath}`;
+    }
+    function humanize(capName, fieldPath) {
+      const field = fieldPath.replace(/([A-Z])/g, " $1").replace(/\./g, " ").toLowerCase();
+      return `${capName.replace(/-/g, " ")} ${field}`;
+    }
+    function catalogMetrics(catalog, now) {
+      return Object.entries(catalog).flatMap(([capName, fields]) => Object.entries(fields).map(([path, spec]) => ({
+        key: capSeriesKey(capName, path),
+        source: "cap",
+        ownerAddon: "device-history",
+        subjectKind: "device",
+        kind: spec.kind,
+        unit: spec.unit ?? null,
+        displayName: spec.displayName ?? humanize(capName, path),
+        ingest: "points",
+        declaredAt: now
+      })));
+    }
+    var MAX_PARKED_DEVICES = 5e3;
+    var SEED_CONCURRENCY = 8;
+    var CaptureEngine = class {
+      deps;
+      recorded = /* @__PURE__ */ new Map();
+      pending = /* @__PURE__ */ new Map();
+      parked = /* @__PURE__ */ new Map();
+      constructor(deps) {
+        this.deps = deps;
+      }
+      /** Learn the last recorded value of every cap series from the store, so a restart repeats nothing. */
+      async seed() {
+        const { registry, store } = this.deps;
+        const capSeries = registry.all().filter((s) => s.key.startsWith(CAP_KEY_PREFIX));
+        for (let i = 0; i < capSeries.length; i += SEED_CONCURRENCY) await Promise.all(capSeries.slice(i, i + SEED_CONCURRENCY).map(async (series) => {
+          const newest = await store.rawBefore(series.id, Number.MAX_SAFE_INTEGER);
+          if (newest === null) return;
+          this.recorded.set(identityOf(series.key, series.subject, series.scope), newest);
+        }));
+      }
+      /** One `DeviceStateChanged`. Synchronous: the bus must never wait on us. */
+      handleState(deviceId, capName, slice, at) {
+        const fields = this.deps.catalog[capName];
+        if (fields === void 0) return;
+        const { counters, directory } = this.deps;
+        counters.eventsSeen += 1;
+        if (this.deps.optedOut().has(deviceId)) {
+          counters.skip("opted-out");
+          return;
+        }
+        const type = directory.typeOf(deviceId);
+        if (type === void 0) {
+          this.park(deviceId, capName, slice, at);
+          return;
+        }
+        if (!isRealDeviceType(type)) {
+          counters.skip("not-a-real-device");
+          return;
+        }
+        for (const [path, spec] of Object.entries(fields)) {
+          if (spec.excludeDeviceTypes?.includes(type) === true) {
+            counters.skip("excluded-device-type");
+            continue;
+          }
+          const value = readNumeric(slice, path, spec.kind);
+          if (value === null) continue;
+          this.consider(deviceId, capName, path, spec, value, at, false);
+        }
+      }
+      consider(deviceId, capName, path, spec, value, at, reconciling) {
+        const key = capSeriesKey(capName, path);
+        const subject = {
+          kind: "device",
+          deviceId
+        };
+        const identity = identityOf(key, `d:${deviceId}`, "");
+        const decision = decideCapture(spec, this.recorded.get(identity) ?? null, value, at, { ignoreFloor: reconciling });
+        if (decision.action === "emit") {
+          this.emit(identity, key, subject, value, at);
+          if (reconciling) this.deps.counters.reconciledPoints += 1;
+          return;
+        }
+        if (decision.action === "defer") {
+          this.pending.set(identity, {
+            key,
+            subject,
+            spec,
+            value
+          });
+          return;
+        }
+        this.pending.delete(identity);
+        this.deps.counters.skip(decision.reason);
+      }
+      emit(identity, key, subject, value, ts) {
+        this.recorded.set(identity, {
+          value,
+          ts
+        });
+        this.pending.delete(identity);
+        this.deps.counters.pointsEmitted += 1;
+        this.deps.writer.enqueue({
+          key,
+          subject,
+          scope: "",
+          ts,
+          value
+        });
+      }
+      /** Emit every pending change whose capture floor has passed, stamped where the floor ended. */
+      tickPending(now) {
+        for (const [identity, p] of this.pending) {
+          const recorded = this.recorded.get(identity);
+          const deviceId = p.subject.kind === "device" ? p.subject.deviceId : -1;
+          if (this.deps.optedOut().has(deviceId)) {
+            this.pending.delete(identity);
+            this.deps.counters.skip("opted-out");
+            continue;
+          }
+          const notBefore = (recorded?.ts ?? now) + minIntervalOf(p.spec);
+          if (now < notBefore) continue;
+          this.emit(identity, p.key, p.subject, p.value, notBefore);
+          this.deps.counters.trailingEmitted += 1;
+        }
+      }
+      park(deviceId, capName, slice, at) {
+        const existing = this.parked.get(deviceId);
+        if (existing !== void 0) {
+          existing.set(capName, {
+            capName,
+            slice,
+            at
+          });
+          return;
+        }
+        if (this.parked.size >= MAX_PARKED_DEVICES) {
+          const oldest = this.parked.keys().next();
+          if (oldest.done !== true) this.parked.delete(oldest.value);
+          this.deps.counters.skip("parked-overflow");
+        }
+        this.parked.set(deviceId, /* @__PURE__ */ new Map([[capName, {
+          capName,
+          slice,
+          at
+        }]]));
+        this.deps.directory.ensure(deviceId).then((type) => {
+          const waiting = this.parked.get(deviceId);
+          this.parked.delete(deviceId);
+          if (waiting === void 0) return;
+          if (type === void 0) {
+            this.deps.counters.skip("unknown-device", waiting.size);
+            return;
+          }
+          for (const p of waiting.values()) this.handleState(deviceId, p.capName, p.slice, p.at);
+        });
+      }
+      /**
+      * Restore a missed change from the state mirror's whole snapshot: a field whose
+      * value differs from the last recorded one gets a point stamped `now`.
+      * Additive only — it never removes anything, and a snapshot that could not be
+      * read is the CALLER's failure to count (D49), not an empty snapshot.
+      */
+      reconcile(snapshots, now) {
+        const optedOut = this.deps.optedOut();
+        for (const [deviceKey, caps] of Object.entries(snapshots)) {
+          const deviceId = Number(deviceKey);
+          if (!Number.isInteger(deviceId) || optedOut.has(deviceId)) continue;
+          const type = this.deps.directory.typeOf(deviceId);
+          if (type === void 0 || !isRealDeviceType(type)) continue;
+          for (const [capName, fields] of Object.entries(this.deps.catalog)) {
+            const slice = caps[capName];
+            if (slice === void 0) continue;
+            for (const [path, spec] of Object.entries(fields)) {
+              if (spec.excludeDeviceTypes?.includes(type) === true) continue;
+              const value = readNumeric(slice, path, spec.kind);
+              if (value === null) continue;
+              this.consider(deviceId, capName, path, spec, value, now, true);
+            }
+          }
+        }
+      }
+      /**
+      * Forget what was "recorded" for points that never reached the store (dropped),
+      * so the next change-only comparison — and the next reconcile — starts from what
+      * is really there instead of leaving a hole until the value moves.
+      */
+      forget(points) {
+        for (const p of points) {
+          const identity = identityOf(p.key, subjectIdOf(p.subject), p.scope);
+          this.recorded.delete(identity);
+          this.pending.delete(identity);
+        }
+      }
+      /** A purged series leaves no state behind. */
+      forgetSeries(series) {
+        const identity = identityOf(series.key, series.subject, series.scope);
+        this.recorded.delete(identity);
+        this.pending.delete(identity);
+      }
+      /** For status and specs. */
+      pendingCount() {
+        return this.pending.size;
+      }
+      /** The last recorded state of a series, for specs. */
+      lastRecorded(key, subjectId) {
+        return this.recorded.get(identityOf(key, subjectId, ""));
+      }
+    };
+    var FLUSH_INTERVAL_MS = 1e4;
+    var MAX_BUFFER_AGE_MS = 6e4;
+    var MAX_QUEUE_POINTS = 1e5;
+    var QUEUE_DROP_FRACTION = 0.1;
+    var MAX_DEVICES_IN_DROP_LINE = 20;
+    var MAX_DEVICE_LINES_PER_DROP = 10;
+    var DEVICE_LINES_MIN_GAP_MS = 1e4;
+    var PointWriter = class {
+      deps;
+      queue = [];
+      flushing = null;
+      lastDeviceLinesAt = Number.NEGATIVE_INFINITY;
+      constructor(deps) {
+        this.deps = deps;
+      }
+      enqueue(point) {
+        this.queue.push({
+          ...point,
+          bufferedAt: this.deps.clock()
+        });
+        if (this.queue.length > 1e5) {
+          const count = Math.ceil(MAX_QUEUE_POINTS * QUEUE_DROP_FRACTION);
+          this.drop(this.queue.splice(0, count), "queue full");
+        }
+      }
+      depth() {
+        return this.queue.length;
+      }
+      /** One flush at a time; a call while one runs waits for it and returns. */
+      flush() {
+        if (this.flushing !== null) return this.flushing;
+        const run = this.doFlush().finally(() => {
+          this.flushing = null;
+        });
+        this.flushing = run;
+        return run;
+      }
+      async doFlush() {
+        const batch = this.queue;
+        if (batch.length === 0) return;
+        this.queue = [];
+        const { registry, store, counters, logger, clock } = this.deps;
+        try {
+          const bySeries = /* @__PURE__ */ new Map();
+          for (const point of batch) {
+            const series = await registry.ensure(point.key, point.subject, point.scope, point.ts);
+            const list = bySeries.get(series.id) ?? [];
+            list.push({
+              ts: point.ts,
+              value: point.value
+            });
+            bySeries.set(series.id, list);
+          }
+          const rows = [...bySeries].flatMap(([seriesId, points]) => points.map((p) => ({
+            seriesId,
+            ts: p.ts,
+            value: p.value
+          })));
+          await store.upsertRaw(rows);
+          await this.recordSpans(bySeries);
+          counters.pointsWritten += rows.length;
+          counters.addRawRows(rows.length);
+          counters.lastFlushAt = clock();
+          this.deps.onWritten([...bySeries].map(([seriesId, points]) => ({
+            seriesId,
+            timestamps: points.map((p) => p.ts)
+          })));
+        } catch (err) {
+          counters.flushFailures += 1;
+          logger.warn("device-history: raw flush failed \u2014 keeping the batch", { meta: {
+            points: batch.length,
+            error: err instanceof Error ? err.message : String(err)
+          } });
+          this.requeue(batch);
+        }
+      }
+      async recordSpans(bySeries) {
+        const { registry, store } = this.deps;
+        const touch = [];
+        for (const [seriesId, points] of bySeries) {
+          const current = registry.byIdOf(seriesId);
+          if (current === void 0) continue;
+          let minTs = Number.POSITIVE_INFINITY;
+          let maxTs = Number.NEGATIVE_INFINITY;
+          for (const p of points) {
+            if (p.ts < minTs) minTs = p.ts;
+            if (p.ts > maxTs) maxTs = p.ts;
+          }
+          if (minTs < current.firstTs) await store.widenSeriesStart(seriesId, minTs);
+          if (maxTs > current.lastTs) touch.push({
+            id: seriesId,
+            lastTs: maxTs
+          });
+          registry.noteSpan(seriesId, minTs, maxTs);
+        }
+        await store.touchSeries(touch);
+      }
+      requeue(batch) {
+        const now = this.deps.clock();
+        const keep = [];
+        const dropped = [];
+        for (const point of batch) if (now - point.bufferedAt > 6e4) dropped.push(point);
+        else keep.push(point);
+        this.queue = [...keep, ...this.queue];
+        if (dropped.length > 0) this.drop(dropped, `older than ${MAX_BUFFER_AGE_MS} ms`);
+      }
+      /** Account for, say, and report to the owner a set of points that will never be written. */
+      drop(dropped, reason) {
+        if (dropped.length === 0) return;
+        const { counters, logger, clock } = this.deps;
+        counters.pointsDropped += dropped.length;
+        const perDevice = /* @__PURE__ */ new Map();
+        for (const p of dropped) if (p.subject.kind === "device") perDevice.set(p.subject.deviceId, (perDevice.get(p.subject.deviceId) ?? 0) + 1);
+        logger.error("device-history: dropped points the store would not take", { meta: {
+          dropped: dropped.length,
+          reason,
+          maxAgeMs: MAX_BUFFER_AGE_MS,
+          deviceIds: [...perDevice.keys()].slice(0, MAX_DEVICES_IN_DROP_LINE)
+        } });
+        const now = clock();
+        if (now - this.lastDeviceLinesAt >= DEVICE_LINES_MIN_GAP_MS) {
+          this.lastDeviceLinesAt = now;
+          for (const [deviceId, count] of [...perDevice].slice(0, MAX_DEVICE_LINES_PER_DROP)) logger.warn("device-history: points dropped for this device", {
+            tags: { deviceId },
+            meta: {
+              dropped: count,
+              reason
+            }
+          });
+        }
+        this.deps.onDropped(dropped);
+      }
+    };
+    var FIVE_MINUTES_MS = 5 * 6e4;
+    var HOUR_MS = 60 * 6e4;
+    var DAY_MS = 24 * HOUR_MS;
+    function floorTo(ts, widthMs) {
+      return Math.floor(ts / widthMs) * widthMs;
+    }
+    function startOfLocalDay(ts) {
+      const d = new Date(ts);
+      d.setHours(0, 0, 0, 0);
+      return d.getTime();
+    }
+    function nextLocalDayStart(dayStart) {
+      const d = new Date(dayStart);
+      d.setDate(d.getDate() + 1);
+      d.setHours(0, 0, 0, 0);
+      return d.getTime();
+    }
+    function bucketStartOf(tier, ts) {
+      if (tier === "5m") return floorTo(ts, FIVE_MINUTES_MS);
+      if (tier === "1h") return floorTo(ts, HOUR_MS);
+      return startOfLocalDay(ts);
+    }
+    function bucketEndOf(tier, start) {
+      if (tier === "5m") return start + FIVE_MINUTES_MS;
+      if (tier === "1h") return start + HOUR_MS;
+      return nextLocalDayStart(start);
+    }
+    var ROLLUP_GRACE_MS = {
+      "5m": 3e4,
+      "1h": 5 * 6e4,
+      "1d": 15 * 6e4
+    };
+    function addRefusal(refusals, key, reason) {
+      const byReason = refusals.get(key) ?? /* @__PURE__ */ new Map();
+      byReason.set(reason, (byReason.get(reason) ?? 0) + 1);
+      refusals.set(key, byReason);
+    }
+    function toResult(accepted, refusals) {
+      return {
+        accepted,
+        refused: [...refusals].flatMap(([key, byReason]) => [...byReason].map(([reason, count]) => ({
+          key,
+          reason,
+          count
+        })))
+      };
+    }
+    var ProducerIngest = class {
+      deps;
+      /** Last accepted point time per series, for the sustained-rate bound. */
+      lastAccepted = /* @__PURE__ */ new Map();
+      constructor(deps) {
+        this.deps = deps;
+      }
+      /** A purged series leaves no rate-limit state behind. */
+      forgetSeries(series) {
+        this.lastAccepted.delete(identityOf(series.key, series.subject, series.scope));
+      }
+      async declareSeries(callerAddonId, input) {
+        if (callerAddonId === null) throw new Error("declareSeries: the caller addon could not be identified");
+        const key = `addon:${callerAddonId}/${input.name}`;
+        const metric = {
+          key,
+          source: "addon",
+          ownerAddon: callerAddonId,
+          subjectKind: input.subjectKind,
+          kind: input.kind,
+          unit: input.unit ?? null,
+          displayName: input.displayName,
+          ingest: input.ingest,
+          declaredAt: this.deps.clock()
+        };
+        await this.deps.registry.declareMetric(metric);
+        return { key };
+      }
+      /** Why a write to `metric` by `caller` for this subject must be refused, or null. */
+      async refusalFor(callerAddonId, metric, ingest, subject) {
+        if (metric === void 0) return "undeclared";
+        if (callerAddonId === null || metric.ownerAddon !== callerAddonId) return "not-owner";
+        if (metric.ingest !== ingest) return "ingest-mismatch";
+        if (metric.subjectKind !== subject.kind) return "undeclared";
+        if (subject.kind === "device") {
+          if (this.deps.optedOut().has(subject.deviceId)) return "opted-out";
+          const type = await this.deps.directory.ensure(subject.deviceId);
+          if (type === void 0 || !isRealDeviceType(type)) return "not-a-real-device";
+        }
+        return null;
+      }
+      async record(callerAddonId, points) {
+        const { clock, counters } = this.deps;
+        const now = clock();
+        const { rawMs } = this.deps.retention();
+        const refusals = /* @__PURE__ */ new Map();
+        let accepted = 0;
+        for (const point of points) {
+          const reason = await this.refusalFor(callerAddonId, this.deps.registry.metric(point.key), "points", point.subject);
+          if (reason !== null) {
+            addRefusal(refusals, point.key, reason);
+            counters.refuse(reason);
+            continue;
+          }
+          if (!Number.isFinite(point.value) || !Number.isFinite(point.ts) || point.ts > now + 3e5 || point.ts < now - rawMs) {
+            addRefusal(refusals, point.key, "out-of-range");
+            counters.refuse("out-of-range");
+            continue;
+          }
+          const identity = identityOf(point.key, subjectIdOf(point.subject), point.scope);
+          const last = this.lastAccepted.get(identity);
+          if (last !== void 0 && point.ts >= last && point.ts - last < 1e4) {
+            addRefusal(refusals, point.key, "rate");
+            counters.refuse("rate");
+            continue;
+          }
+          this.lastAccepted.set(identity, Math.max(last ?? point.ts, point.ts));
+          this.deps.writer.enqueue({
+            key: point.key,
+            subject: point.subject,
+            scope: point.scope,
+            ts: point.ts,
+            value: point.value
+          });
+          accepted += 1;
+        }
+        counters.ingestAccepted += accepted;
+        return toResult(accepted, refusals);
+      }
+      async recordBuckets(callerAddonId, buckets) {
+        const { clock, counters, registry, store } = this.deps;
+        const now = clock();
+        const { fiveMinuteMs } = this.deps.retention();
+        const refusals = /* @__PURE__ */ new Map();
+        const rows = [];
+        for (const bucket of buckets) {
+          const reason = await this.refusalFor(callerAddonId, registry.metric(bucket.key), "buckets", bucket.subject);
+          if (reason !== null) {
+            addRefusal(refusals, bucket.key, reason);
+            counters.refuse(reason);
+            continue;
+          }
+          const aligned = bucket.bucketStart % FIVE_MINUTES_MS === 0;
+          const consistent = Number.isFinite(bucket.sum) && Number.isFinite(bucket.min) && Number.isFinite(bucket.max) && bucket.min <= bucket.max;
+          if (!aligned || !consistent || bucket.bucketStart > now + 3e5 || bucket.bucketStart < now - fiveMinuteMs) {
+            addRefusal(refusals, bucket.key, "out-of-range");
+            counters.refuse("out-of-range");
+            continue;
+          }
+          const series = await registry.ensure(bucket.key, bucket.subject, bucket.scope, bucket.bucketStart);
+          rows.push({
+            seriesId: series.id,
+            bucketStart: bucket.bucketStart,
+            samples: bucket.samples,
+            sum: bucket.sum,
+            min: bucket.min,
+            max: bucket.max,
+            last: bucket.last,
+            lastTs: bucket.lastTs,
+            twSum: null,
+            twMs: null
+          });
+        }
+        await store.upsertRollups("5m", rows);
+        const bySeries = /* @__PURE__ */ new Map();
+        for (const row of rows) bySeries.set(row.seriesId, [...bySeries.get(row.seriesId) ?? [], row.bucketStart]);
+        for (const [seriesId, starts] of bySeries) counters.noteRollupRows("5m", seriesId, starts.toSorted((a, b) => a - b));
+        await this.recordSpans(rows);
+        for (const row of rows) this.deps.onBucketWritten(row.seriesId, row.bucketStart);
+        counters.ingestAccepted += rows.length;
+        return toResult(rows.length, refusals);
+      }
+      /** Persist the widened span of every series a bucket batch touched, then remember it. */
+      async recordSpans(rows) {
+        const { registry, store } = this.deps;
+        const spans = /* @__PURE__ */ new Map();
+        for (const row of rows) {
+          const end = row.lastTs ?? row.bucketStart;
+          const span = spans.get(row.seriesId);
+          spans.set(row.seriesId, {
+            first: span === void 0 ? row.bucketStart : Math.min(span.first, row.bucketStart),
+            last: span === void 0 ? end : Math.max(span.last, end)
+          });
+        }
+        const touch = [];
+        for (const [id, span] of spans) {
+          const current = registry.byIdOf(id);
+          if (current === void 0) continue;
+          if (span.first < current.firstTs) await store.widenSeriesStart(id, span.first);
+          if (span.last > current.lastTs) touch.push({
+            id,
+            lastTs: span.last
+          });
+          registry.noteSpan(id, span.first, span.last);
+        }
+        await store.touchSeries(touch);
+      }
+    };
+    var TIER_ORDER = [
+      "raw",
+      "5m",
+      "1h",
+      "1d"
+    ];
+    var BUCKET_MS = {
+      "5m": FIVE_MINUTES_MS,
+      "1h": HOUR_MS,
+      "1d": DAY_MS
+    };
+    var MAX_SCOPES = 50;
+    function retentionMsOf(tier, policy) {
+      if (tier === "raw") return policy.rawDays * DAY_MS;
+      if (tier === "5m") return policy.fiveMinuteDays * DAY_MS;
+      if (tier === "1h") return policy.hourDays * DAY_MS;
+      return policy.dayDays === null || policy.dayDays <= 0 ? null : policy.dayDays * DAY_MS;
+    }
+    function rawPoint(ts, value) {
+      return {
+        t: ts,
+        samples: 1,
+        mean: value,
+        twMean: null,
+        min: value,
+        max: value,
+        last: value
+      };
+    }
+    function rollupPoint(row) {
+      return {
+        t: row.bucketStart,
+        samples: row.samples,
+        mean: row.samples > 0 ? row.sum / row.samples : null,
+        twMean: row.twSum !== null && row.twMs !== null && row.twMs > 0 ? row.twSum / row.twMs : null,
+        min: row.min,
+        max: row.max,
+        last: row.last
+      };
+    }
+    var HistoryQuery = class {
+      deps;
+      constructor(deps) {
+        this.deps = deps;
+      }
+      async query(input) {
+        const { registry } = this.deps;
+        const subjectId = subjectIdOf(input.subject);
+        const wanted = registry.forKeyAndSubject(input.key, subjectId).filter((s) => input.scope === void 0 || s.scope === input.scope).toSorted((a, b) => a.scope.localeCompare(b.scope)).slice(0, MAX_SCOPES);
+        const candidates = this.coveringTiers(input.from);
+        const forced = input.resolution === "auto" ? null : input.resolution;
+        const order = forced === null ? candidates : [forced];
+        let chosen = order[order.length - 1] ?? "1d";
+        let reads = [];
+        for (const [index, tier] of order.entries()) {
+          const last = index === order.length - 1;
+          if (!this.fits(tier, input, wanted) && !last) continue;
+          chosen = tier;
+          reads = await Promise.all(wanted.map(async (s) => [s, await this.readTier(tier, s, input)]));
+          if (reads.some(([, r]) => r.overflow) && !last) continue;
+          break;
+        }
+        const series = [];
+        for (const [s, read] of reads) series.push({
+          scope: s.scope,
+          before: await this.before(chosen, s, input.from),
+          points: read.points
+        });
+        return {
+          resolution: chosen,
+          series,
+          truncated: reads.some(([, r]) => r.overflow)
+        };
+      }
+      /** Tiers whose retention covers `from`, finest first; the coarsest is always present. */
+      coveringTiers(from) {
+        const policy = this.deps.retention();
+        const now = this.deps.clock();
+        const covering = TIER_ORDER.filter((tier) => {
+          const ms = retentionMsOf(tier, policy);
+          return ms === null || from >= now - ms;
+        });
+        return covering.length > 0 ? covering : ["1d"];
+      }
+      /** Cheap fit test for rollup tiers; raw is decided by the read itself. */
+      fits(tier, input, series) {
+        if (tier === "raw" || series.length === 0) return true;
+        const width = BUCKET_MS[tier];
+        return Math.ceil((input.to - input.from) / width) <= input.maxPoints;
+      }
+      async readTier(tier, series, input) {
+        const { store } = this.deps;
+        const limit = input.maxPoints + 1;
+        if (tier === "raw") {
+          const rows2 = await store.readRaw(series.id, input.from, input.to, limit, "desc");
+          return this.shape(rows2.map((r) => rawPoint(r.ts, r.value)), input.maxPoints);
+        }
+        const lower = bucketStartOf(tier, input.from);
+        const rows = await store.readRollups(tier, series.id, lower, input.to, limit, "desc");
+        return this.shape(rows.map(rollupPoint), input.maxPoints);
+      }
+      /** Rows arrive newest first and one over the bound; keep the newest `maxPoints`, oldest first. */
+      shape(newestFirst, maxPoints) {
+        const overflow = newestFirst.length > maxPoints;
+        return {
+          points: (overflow ? newestFirst.slice(0, maxPoints) : newestFirst).toReversed(),
+          overflow
+        };
+      }
+      async before(tier, series, from) {
+        const { store } = this.deps;
+        if (tier === "raw") {
+          const p = await store.rawBefore(series.id, from);
+          return p === null ? null : {
+            t: p.ts,
+            value: p.value
+          };
+        }
+        const row = await store.rollupBefore(tier, series.id, bucketStartOf(tier, from));
+        return row === null ? null : {
+          t: row.bucketStart,
+          value: row.last
+        };
+      }
+      async listSeries(subject) {
+        const { registry } = this.deps;
+        const slices = /* @__PURE__ */ new Map();
+        const infos = [];
+        for (const s of registry.forSubject(subjectIdOf(subject))) {
+          const metric = registry.metric(s.key);
+          if (metric === void 0) continue;
+          infos.push({
+            key: s.key,
+            scope: s.scope,
+            kind: metric.kind,
+            unit: await this.unitOf(subject, s, metric.unit, slices),
+            displayName: metric.displayName,
+            source: metric.source,
+            firstTs: s.firstTs,
+            lastTs: s.lastTs
+          });
+        }
+        return infos.toSorted((a, b) => a.key.localeCompare(b.key) || a.scope.localeCompare(b.scope));
+      }
+      /** The metric's fixed unit, else the device's own (a `unitFrom` field), else unknown. */
+      async unitOf(subject, series, fixed, slices) {
+        if (fixed !== null || subject.kind !== "device" || !series.key.startsWith("cap:")) return fixed;
+        const spec = this.specOf(series.key);
+        if (spec?.unitFrom === void 0) return null;
+        const capName = series.key.slice(CAP_KEY_PREFIX.length, series.key.indexOf("."));
+        const pending = slices.get(capName) ?? this.deps.readCapSlice(subject.deviceId, capName).catch(() => null);
+        slices.set(capName, pending);
+        const slice = await pending;
+        return slice === null ? null : readUnit(slice, spec.unitFrom);
+      }
+      specOf(key) {
+        const body = key.slice(CAP_KEY_PREFIX.length);
+        const dot = body.indexOf(".");
+        if (dot < 0) return void 0;
+        return this.deps.catalog[body.slice(0, dot)]?.[body.slice(dot + 1)];
+      }
+    };
+    var DEPARTED_ABSENCE_MS = 7 * DAY_MS;
+    var DepartureTracker = class {
+      store;
+      registry;
+      logger;
+      missing = /* @__PURE__ */ new Map();
+      constructor(store, registry, logger) {
+        this.store = store;
+        this.registry = registry;
+        this.logger = logger;
+      }
+      async load() {
+        this.missing = await this.store.loadDepartures();
+      }
+      missingSince(deviceId) {
+        return this.missing.get(deviceId);
+      }
+      /** Forget a device's clock — its series were removed because it was DELETED (D865). */
+      async forget(deviceId) {
+        await this.store.clearMissing([deviceId]);
+        const next = new Map(this.missing);
+        next.delete(deviceId);
+        this.missing = next;
+      }
+      /** Feed one SUCCESSFUL listing. A failed read never reaches here. */
+      async observe(listed, now) {
+        const withSeries = new Set(this.registry.all().flatMap((s) => s.deviceId === null ? [] : [s.deviceId]));
+        const back = [...this.missing.keys()].filter((id) => listed.has(id));
+        const gone = [...withSeries].filter((id) => !listed.has(id) && !this.missing.has(id));
+        try {
+          await this.store.clearMissing(back);
+          await this.store.markMissing(gone, now);
+        } catch (err) {
+          this.logger.warn("device-history: departure clock not written", { meta: { error: err instanceof Error ? err.message : String(err) } });
+          return;
+        }
+        const next = new Map(this.missing);
+        for (const id of back) next.delete(id);
+        for (const id of gone) next.set(id, now);
+        this.missing = next;
+      }
+    };
+    var DEFAULT_RETENTION = {
+      rawDays: 7,
+      fiveMinuteDays: 14,
+      hourDays: 365,
+      dayDays: null
+    };
+    function retentionCutoffs(policy, now) {
+      return {
+        raw: now - policy.rawDays * DAY_MS,
+        "5m": now - policy.fiveMinuteDays * DAY_MS,
+        "1h": now - policy.hourDays * DAY_MS,
+        "1d": policy.dayDays === null || policy.dayDays <= 0 ? null : now - policy.dayDays * DAY_MS
+      };
+    }
+    var TIERS = [
+      "raw",
+      "5m",
+      "1h",
+      "1d"
+    ];
+    var RETENTION_STEP_MS = {
+      raw: HOUR_MS,
+      "5m": HOUR_MS,
+      "1h": DAY_MS,
+      "1d": DAY_MS
+    };
+    var MAX_PURGES_PER_RUN = 20;
+    var SLICE_MS = {
+      raw: DAY_MS,
+      "5m": DAY_MS,
+      "1h": 30 * DAY_MS,
+      "1d": 30 * DAY_MS
+    };
+    var BUCKET_LEAD_MS = 2 * DAY_MS;
+    var SHORT_TIER_LOOKBACK_MS = 400 * DAY_MS;
+    var yieldToEventLoop = () => new Promise((resolve) => setImmediate(resolve));
+    var RetentionJob = class {
+      deps;
+      appliedUpTo = /* @__PURE__ */ new Map();
+      running = null;
+      constructor(deps) {
+        this.deps = deps;
+      }
+      run(policy, now) {
+        if (this.running !== null) return this.running;
+        const run = this.doRun(policy, now).finally(() => {
+          this.running = null;
+        });
+        this.running = run;
+        return run;
+      }
+      async doRun(policy, now) {
+        const { registry, counters, logger } = this.deps;
+        const cutoffs = retentionCutoffs(policy, now);
+        try {
+          for (const tier of TIERS) {
+            const cutoff = cutoffs[tier];
+            if (cutoff === null) continue;
+            for (const series of registry.all()) {
+              if (series.firstTs - 864e5 >= cutoff) continue;
+              if (tier === "raw" && registry.metric(series.key)?.ingest === "buckets") continue;
+              const marker = `${tier}:${series.id}`;
+              const applied = this.appliedUpTo.get(marker);
+              if (applied !== void 0 && cutoff - applied < RETENTION_STEP_MS[tier]) continue;
+              const lo = Math.max(0, applied === void 0 ? series.firstTs - BUCKET_LEAD_MS : applied - RETENTION_STEP_MS[tier]);
+              counters.addDeleted(tier, await this.deleteSliced(tier, series.id, lo, cutoff - 1));
+              this.appliedUpTo.set(marker, cutoff);
+            }
+          }
+          await this.purgeDeparted(now);
+          counters.retentionLastRunAt = now;
+        } catch (err) {
+          logger.warn("device-history: retention pass failed \u2014 retried at the next run", { meta: { error: err instanceof Error ? err.message : String(err) } });
+        }
+      }
+      /** Delete `[lo, hiInclusive]` of one tier in time slices, yielding between them. */
+      /** Drop the visit markers of a purged series. */
+      forgetSeries(seriesId) {
+        for (const tier of TIERS) this.appliedUpTo.delete(`${tier}:${seriesId}`);
+      }
+      async deleteSliced(tier, seriesId, lo, hiInclusive) {
+        const yieldNow = this.deps.yieldNow ?? yieldToEventLoop;
+        let deleted = 0;
+        for (let from = lo; from <= hiInclusive; from += SLICE_MS[tier]) {
+          const to = Math.min(from + SLICE_MS[tier] - 1, hiInclusive);
+          deleted += await this.deps.store.deleteRange(tier, seriesId, from, to);
+          await yieldNow();
+        }
+        return deleted;
+      }
+      /** Tier by tier in slices, then the series row (and whatever the slices missed). */
+      async purgeSeries(series, now) {
+        for (const tier of TIERS) {
+          const lo = tier === "raw" || tier === "5m" ? Math.max(series.firstTs - BUCKET_LEAD_MS, now - SHORT_TIER_LOOKBACK_MS) : series.firstTs - BUCKET_LEAD_MS;
+          await this.deleteSliced(tier, series.id, Math.max(0, lo), now + DAY_MS);
+        }
+        await this.deps.store.deleteSeries(series.id);
+      }
+      /**
+      * Delete every series of a DELETED device now (D865). Driven by a tombstone
+      * through the `device-removal-hook`, never by a listing: the week-long
+      * absence clock above remains the backstop for a device removed before
+      * tombstones existed.
+      */
+      async purgeDevice(deviceId, now) {
+        const { registry, counters } = this.deps;
+        let purged = 0;
+        for (const series of registry.all()) {
+          if (series.deviceId !== deviceId) continue;
+          await this.purgeSeries(series, now);
+          registry.remove(series.id);
+          counters.purgedSeries += 1;
+          purged += 1;
+        }
+        return purged;
+      }
+      async purgeDeparted(now) {
+        const { registry, departures, counters, logger } = this.deps;
+        let purged = 0;
+        for (const series of registry.all()) {
+          if (purged >= MAX_PURGES_PER_RUN) break;
+          if (series.deviceId === null) continue;
+          const since = departures.missingSince(series.deviceId);
+          if (since === void 0 || now - since < DEPARTED_ABSENCE_MS) continue;
+          await this.purgeSeries(series, now);
+          registry.remove(series.id);
+          counters.purgedSeries += 1;
+          purged += 1;
+          logger.info("device-history: purged the series of an unregistered device", {
+            tags: { deviceId: series.deviceId },
+            meta: { key: series.key }
+          });
+        }
+      }
+    };
+    var HISTORY_NAMESPACE = "device-history";
+    var COLLECTIONS = {
+      metrics: "metrics",
+      series: "series",
+      raw: "raw",
+      rollup5m: "rollup-5m",
+      rollup1h: "rollup-1h",
+      rollup1d: "rollup-1d",
+      optOuts: "device-opt-outs",
+      departures: "device-departures"
+    };
+    function rollupCollectionOf(tier) {
+      if (tier === "5m") return COLLECTIONS.rollup5m;
+      if (tier === "1h") return COLLECTIONS.rollup1h;
+      return COLLECTIONS.rollup1d;
+    }
+    function rollupDeclaration(collection) {
+      return {
+        namespace: HISTORY_NAMESPACE,
+        collection,
+        database: "history",
+        primaryKey: ["series_id", "bucket_start"],
+        withoutRowid: true,
+        columns: [
+          {
+            name: "series_id",
+            type: "INTEGER"
+          },
+          {
+            name: "bucket_start",
+            type: "INTEGER"
+          },
+          {
+            name: "samples",
+            type: "INTEGER",
+            notNull: true
+          },
+          {
+            name: "sum",
+            type: "REAL",
+            notNull: true
+          },
+          {
+            name: "min",
+            type: "REAL",
+            notNull: true
+          },
+          {
+            name: "max",
+            type: "REAL",
+            notNull: true
+          },
+          {
+            name: "last",
+            type: "REAL"
+          },
+          {
+            name: "last_ts",
+            type: "INTEGER"
+          },
+          {
+            name: "tw_sum",
+            type: "REAL"
+          },
+          {
+            name: "tw_ms",
+            type: "INTEGER"
+          }
+        ]
+      };
+    }
+    var HISTORY_DECLARATIONS = [
+      {
+        namespace: HISTORY_NAMESPACE,
+        collection: COLLECTIONS.metrics,
+        database: "history",
+        columns: [
+          {
+            name: "key",
+            type: "TEXT",
+            primaryKey: true,
+            notNull: true
+          },
+          {
+            name: "source",
+            type: "TEXT",
+            notNull: true
+          },
+          {
+            name: "owner_addon",
+            type: "TEXT",
+            notNull: true
+          },
+          {
+            name: "subject_kind",
+            type: "TEXT",
+            notNull: true
+          },
+          {
+            name: "kind",
+            type: "TEXT",
+            notNull: true
+          },
+          {
+            name: "unit",
+            type: "TEXT"
+          },
+          {
+            name: "display_name",
+            type: "TEXT",
+            notNull: true
+          },
+          {
+            name: "ingest",
+            type: "TEXT",
+            notNull: true
+          },
+          {
+            name: "declared_at",
+            type: "INTEGER",
+            notNull: true
+          }
+        ]
+      },
+      {
+        namespace: HISTORY_NAMESPACE,
+        collection: COLLECTIONS.series,
+        database: "history",
+        columns: [
+          {
+            name: "id",
+            type: "INTEGER",
+            primaryKey: true
+          },
+          {
+            name: "key",
+            type: "TEXT",
+            notNull: true
+          },
+          {
+            name: "subject",
+            type: "TEXT",
+            notNull: true
+          },
+          {
+            name: "device_id",
+            type: "INTEGER"
+          },
+          {
+            name: "scope",
+            type: "TEXT",
+            notNull: true,
+            defaultValue: ""
+          },
+          {
+            name: "first_ts",
+            type: "INTEGER",
+            notNull: true
+          },
+          {
+            name: "last_ts",
+            type: "INTEGER",
+            notNull: true
+          }
+        ],
+        indexes: [{
+          name: "idx_dh_series_identity",
+          columns: [
+            "key",
+            "subject",
+            "scope"
+          ],
+          unique: true
+        }, {
+          name: "idx_dh_series_device",
+          columns: ["device_id"]
+        }]
+      },
+      {
+        namespace: HISTORY_NAMESPACE,
+        collection: COLLECTIONS.raw,
+        database: "history",
+        primaryKey: ["series_id", "ts"],
+        withoutRowid: true,
+        columns: [
+          {
+            name: "series_id",
+            type: "INTEGER"
+          },
+          {
+            name: "ts",
+            type: "INTEGER"
+          },
+          {
+            name: "value",
+            type: "REAL",
+            notNull: true
+          }
+        ]
+      },
+      rollupDeclaration(COLLECTIONS.rollup5m),
+      rollupDeclaration(COLLECTIONS.rollup1h),
+      rollupDeclaration(COLLECTIONS.rollup1d),
+      {
+        namespace: HISTORY_NAMESPACE,
+        collection: COLLECTIONS.optOuts,
+        columns: [
+          {
+            name: "id",
+            type: "INTEGER",
+            primaryKey: true
+          },
+          {
+            name: "device_id",
+            type: "INTEGER",
+            notNull: true
+          },
+          {
+            name: "opted_out_at",
+            type: "INTEGER",
+            notNull: true
+          }
+        ],
+        indexes: [{
+          name: "idx_dh_opt_outs_device",
+          columns: ["device_id"],
+          unique: true
+        }]
+      },
+      {
+        namespace: HISTORY_NAMESPACE,
+        collection: COLLECTIONS.departures,
+        columns: [
+          {
+            name: "id",
+            type: "INTEGER",
+            primaryKey: true
+          },
+          {
+            name: "device_id",
+            type: "INTEGER",
+            notNull: true
+          },
+          {
+            name: "missing_since",
+            type: "INTEGER",
+            notNull: true
+          }
+        ],
+        indexes: [{
+          name: "idx_dh_departures_device",
+          columns: ["device_id"],
+          unique: true
+        }]
+      }
+    ];
+    function readNumber(data, column) {
+      const v = data[column];
+      if (typeof v === "number" && Number.isFinite(v)) return v;
+      throw new Error(`history row: column "${column}" is not a number (${typeof v})`);
+    }
+    function readNumberOrNull(data, column) {
+      const v = data[column];
+      if (v === null || v === void 0) return null;
+      if (typeof v === "number" && Number.isFinite(v)) return v;
+      throw new Error(`history row: column "${column}" is not a number or null (${typeof v})`);
+    }
+    function readText(data, column) {
+      const v = data[column];
+      if (typeof v === "string") return v;
+      throw new Error(`history row: column "${column}" is not a string (${typeof v})`);
+    }
+    function readTextOrNull(data, column) {
+      const v = data[column];
+      if (v === null || v === void 0) return null;
+      if (typeof v === "string") return v;
+      throw new Error(`history row: column "${column}" is not a string or null (${typeof v})`);
+    }
+    var WRITE_CHUNK = 1e3;
+    var TRANSACT_CHUNK = 200;
+    var READ_PAGE = 5e3;
+    function chunks(items, size) {
+      const out = [];
+      for (let i = 0; i < items.length; i += size) out.push(items.slice(i, i + size));
+      return out;
+    }
+    function parseKind(value) {
+      if (value === "gauge" || value === "counter" || value === "boolean") return value;
+      throw new Error(`history row: unknown kind "${value}"`);
+    }
+    function parseMetric(data) {
+      const source = readText(data, "source");
+      const subjectKind = readText(data, "subject_kind");
+      const ingest = readText(data, "ingest");
+      if (source !== "cap" && source !== "addon") throw new Error(`history row: unknown source "${source}"`);
+      if (subjectKind !== "device" && subjectKind !== "node") throw new Error(`history row: unknown subject_kind "${subjectKind}"`);
+      if (ingest !== "points" && ingest !== "buckets") throw new Error(`history row: unknown ingest "${ingest}"`);
+      return {
+        key: readText(data, "key"),
+        source,
+        ownerAddon: readText(data, "owner_addon"),
+        subjectKind,
+        kind: parseKind(readText(data, "kind")),
+        unit: readTextOrNull(data, "unit"),
+        displayName: readText(data, "display_name"),
+        ingest,
+        declaredAt: readNumber(data, "declared_at")
+      };
+    }
+    function parseSeries(data) {
+      return {
+        id: readNumber(data, "id"),
+        key: readText(data, "key"),
+        subject: readText(data, "subject"),
+        deviceId: readNumberOrNull(data, "device_id"),
+        scope: readText(data, "scope"),
+        firstTs: readNumber(data, "first_ts"),
+        lastTs: readNumber(data, "last_ts")
+      };
+    }
+    function parseRollup(data) {
+      return {
+        seriesId: readNumber(data, "series_id"),
+        bucketStart: readNumber(data, "bucket_start"),
+        samples: readNumber(data, "samples"),
+        sum: readNumber(data, "sum"),
+        min: readNumber(data, "min"),
+        max: readNumber(data, "max"),
+        last: readNumberOrNull(data, "last"),
+        lastTs: readNumberOrNull(data, "last_ts"),
+        twSum: readNumberOrNull(data, "tw_sum"),
+        twMs: readNumberOrNull(data, "tw_ms")
+      };
+    }
+    function rollupData(row) {
+      return {
+        series_id: row.seriesId,
+        bucket_start: row.bucketStart,
+        samples: row.samples,
+        sum: row.sum,
+        min: row.min,
+        max: row.max,
+        last: row.last,
+        last_ts: row.lastTs,
+        tw_sum: row.twSum,
+        tw_ms: row.twMs
+      };
+    }
+    function collectionOf(tier) {
+      return tier === "raw" ? COLLECTIONS.raw : rollupCollectionOf(tier);
+    }
+    function orderColumnOf(tier) {
+      return tier === "raw" ? "ts" : "bucket_start";
+    }
+    var HistoryStore = class {
+      door;
+      constructor(door) {
+        this.door = door;
+      }
+      async declare() {
+        for (const declaration of HISTORY_DECLARATIONS) await this.door.declareCollection.mutate(declaration);
+      }
+      async loadMetrics() {
+        return (await this.door.query.query({
+          namespace: HISTORY_NAMESPACE,
+          collection: COLLECTIONS.metrics,
+          filter: { limit: 2e4 }
+        })).map((r) => parseMetric(r.data));
+      }
+      async upsertMetric(metric) {
+        await this.door.upsertMany.mutate({
+          namespace: HISTORY_NAMESPACE,
+          collection: COLLECTIONS.metrics,
+          conflict: ["key"],
+          records: [{ data: {
+            key: metric.key,
+            source: metric.source,
+            owner_addon: metric.ownerAddon,
+            subject_kind: metric.subjectKind,
+            kind: metric.kind,
+            unit: metric.unit,
+            display_name: metric.displayName,
+            ingest: metric.ingest,
+            declared_at: metric.declaredAt
+          } }]
+        });
+      }
+      /** Series with `id > afterId`, ascending — the boot load pages with this. */
+      async loadSeriesPage(afterId, limit) {
+        return (await this.door.query.query({
+          namespace: HISTORY_NAMESPACE,
+          collection: COLLECTIONS.series,
+          filter: {
+            whereBetween: { id: [afterId + 1, Number.MAX_SAFE_INTEGER] },
+            orderBy: {
+              field: "id",
+              direction: "asc"
+            },
+            limit
+          }
+        })).map((r) => parseSeries(r.data));
+      }
+      async findSeries(key, subject, scope) {
+        const first = (await this.door.query.query({
+          namespace: HISTORY_NAMESPACE,
+          collection: COLLECTIONS.series,
+          filter: {
+            where: {
+              key,
+              subject,
+              scope
+            },
+            limit: 1
+          }
+        }))[0];
+        return first === void 0 ? null : parseSeries(first.data);
+      }
+      async insertSeries(series) {
+        const { id } = await this.door.insert.mutate({
+          namespace: HISTORY_NAMESPACE,
+          collection: COLLECTIONS.series,
+          record: { data: {
+            key: series.key,
+            subject: series.subject,
+            device_id: series.deviceId,
+            scope: series.scope,
+            first_ts: series.ts,
+            last_ts: series.ts
+          } }
+        });
+        return {
+          id: typeof id === "number" ? id : Number(id),
+          key: series.key,
+          subject: series.subject,
+          deviceId: series.deviceId,
+          scope: series.scope,
+          firstTs: series.ts,
+          lastTs: series.ts
+        };
+      }
+      async touchSeries(updates) {
+        for (const batch of chunks(updates, TRANSACT_CHUNK)) await this.door.transact.mutate({
+          namespace: HISTORY_NAMESPACE,
+          ops: batch.map((u) => ({
+            op: "update",
+            collection: COLLECTIONS.series,
+            id: String(u.id),
+            data: { last_ts: u.lastTs }
+          }))
+        });
+      }
+      async widenSeriesStart(id, firstTs) {
+        await this.door.update.mutate({
+          namespace: HISTORY_NAMESPACE,
+          collection: COLLECTIONS.series,
+          id: String(id),
+          data: { first_ts: firstTs }
+        });
+      }
+      async upsertRaw(rows) {
+        for (const batch of chunks(rows, WRITE_CHUNK)) await this.door.upsertMany.mutate({
+          namespace: HISTORY_NAMESPACE,
+          collection: COLLECTIONS.raw,
+          conflict: ["series_id", "ts"],
+          records: batch.map((r) => ({ data: {
+            series_id: r.seriesId,
+            ts: r.ts,
+            value: r.value
+          } }))
+        });
+      }
+      /** Points of a series in `[from, toInclusive]`, ascending, at most `limit`. */
+      async readRaw(seriesId, from, toInclusive, limit, direction = "asc") {
+        return (await this.door.query.query({
+          namespace: HISTORY_NAMESPACE,
+          collection: COLLECTIONS.raw,
+          filter: {
+            where: { series_id: seriesId },
+            whereBetween: { ts: [from, toInclusive] },
+            orderBy: {
+              field: "ts",
+              direction
+            },
+            limit
+          }
+        })).map((r) => ({
+          ts: readNumber(r.data, "ts"),
+          value: readNumber(r.data, "value")
+        }));
+      }
+      /** The newest raw point strictly before `ts`, if any. */
+      async rawBefore(seriesId, ts) {
+        return (await this.readRaw(seriesId, 0, ts - 1, 1, "desc"))[0] ?? null;
+      }
+      async upsertRollups(tier, rows) {
+        for (const batch of chunks(rows, WRITE_CHUNK)) await this.door.upsertMany.mutate({
+          namespace: HISTORY_NAMESPACE,
+          collection: rollupCollectionOf(tier),
+          conflict: ["series_id", "bucket_start"],
+          records: batch.map((r) => ({ data: rollupData(r) }))
+        });
+      }
+      async readRollups(tier, seriesId, from, toInclusive, limit, direction = "asc") {
+        return (await this.door.query.query({
+          namespace: HISTORY_NAMESPACE,
+          collection: rollupCollectionOf(tier),
+          filter: {
+            where: { series_id: seriesId },
+            whereBetween: { bucket_start: [from, toInclusive] },
+            orderBy: {
+              field: "bucket_start",
+              direction
+            },
+            limit
+          }
+        })).map((r) => parseRollup(r.data));
+      }
+      /** The newest rollup row of `tier` strictly before `bucketStart`, if any. */
+      async rollupBefore(tier, seriesId, bucketStart) {
+        return (await this.readRollups(tier, seriesId, 0, bucketStart - 1, 1, "desc"))[0] ?? null;
+      }
+      /** Delete one series' rows of a tier with the order column in `[lo, hiInclusive]`. */
+      async deleteRange(tier, seriesId, lo, hiInclusive) {
+        const { deleted } = await this.door.deleteWhere.mutate({
+          namespace: HISTORY_NAMESPACE,
+          collection: collectionOf(tier),
+          filter: {
+            where: { series_id: seriesId },
+            whereBetween: { [orderColumnOf(tier)]: [lo, hiInclusive] }
+          }
+        });
+        return deleted;
+      }
+      /** Delete every row of one series, in every tier, then the series row. */
+      async deleteSeries(seriesId) {
+        for (const tier of [
+          "raw",
+          "5m",
+          "1h",
+          "1d"
+        ]) await this.door.deleteWhere.mutate({
+          namespace: HISTORY_NAMESPACE,
+          collection: collectionOf(tier),
+          filter: { where: { series_id: seriesId } }
+        });
+        await this.door.delete.mutate({
+          namespace: HISTORY_NAMESPACE,
+          collection: COLLECTIONS.series,
+          key: String(seriesId)
+        });
+      }
+      async countRows(tier) {
+        return this.door.count.query({
+          namespace: HISTORY_NAMESPACE,
+          collection: collectionOf(tier)
+        });
+      }
+      async loadOptOuts() {
+        const rows = await this.door.query.query({
+          namespace: HISTORY_NAMESPACE,
+          collection: COLLECTIONS.optOuts,
+          filter: { limit: 2e4 }
+        });
+        return new Set(rows.map((r) => readNumber(r.data, "device_id")));
+      }
+      async setOptOut(deviceId, at) {
+        await this.door.upsertMany.mutate({
+          namespace: HISTORY_NAMESPACE,
+          collection: COLLECTIONS.optOuts,
+          conflict: ["device_id"],
+          records: [{ data: {
+            device_id: deviceId,
+            opted_out_at: at
+          } }]
+        });
+      }
+      async loadDepartures() {
+        const rows = await this.door.query.query({
+          namespace: HISTORY_NAMESPACE,
+          collection: COLLECTIONS.departures,
+          filter: { limit: 2e4 }
+        });
+        return new Map(rows.map((r) => [readNumber(r.data, "device_id"), readNumber(r.data, "missing_since")]));
+      }
+      async markMissing(deviceIds, at) {
+        for (const batch of chunks(deviceIds, WRITE_CHUNK)) await this.door.upsertMany.mutate({
+          namespace: HISTORY_NAMESPACE,
+          collection: COLLECTIONS.departures,
+          conflict: ["device_id"],
+          records: batch.map((id) => ({ data: {
+            device_id: id,
+            missing_since: at
+          } }))
+        });
+      }
+      async clearMissing(deviceIds) {
+        for (const batch of chunks(deviceIds, WRITE_CHUNK)) await this.door.deleteWhere.mutate({
+          namespace: HISTORY_NAMESPACE,
+          collection: COLLECTIONS.departures,
+          filter: { whereIn: { device_id: [...batch] } }
+        });
+      }
+      async clearOptOut(deviceId) {
+        await this.door.deleteWhere.mutate({
+          namespace: HISTORY_NAMESPACE,
+          collection: COLLECTIONS.optOuts,
+          filter: { where: { device_id: deviceId } }
+        });
+      }
+    };
+    function rawToFiveMinuteRows(input) {
+      const rows = [];
+      const { points, seriesId, horizon } = input;
+      let held = input.carryIn === null ? null : input.carryIn.value;
+      let i = 0;
+      while (i < points.length) {
+        const first = points[i];
+        if (first === void 0) break;
+        const bucketStart = floorTo(first.ts, FIVE_MINUTES_MS);
+        const bucketEnd = bucketStart + FIVE_MINUTES_MS;
+        const coverageEnd = Math.min(bucketEnd, Math.max(horizon, bucketStart));
+        let samples = 0;
+        let sum = 0;
+        let min = Number.POSITIVE_INFINITY;
+        let max = Number.NEGATIVE_INFINITY;
+        let twSum = 0;
+        let twMs = 0;
+        let cursor = bucketStart;
+        let value = held;
+        if (value !== null) {
+          min = value;
+          max = value;
+        }
+        let last = first;
+        while (i < points.length) {
+          const p = points[i];
+          if (p === void 0 || p.ts >= bucketEnd) break;
+          if (value !== null) {
+            const dt = p.ts - cursor;
+            twSum += value * dt;
+            twMs += dt;
+          }
+          cursor = p.ts;
+          value = p.value;
+          samples += 1;
+          sum += p.value;
+          if (p.value < min) min = p.value;
+          if (p.value > max) max = p.value;
+          last = p;
+          i += 1;
+        }
+        if (value !== null && coverageEnd > cursor) {
+          twSum += value * (coverageEnd - cursor);
+          twMs += coverageEnd - cursor;
+        }
+        held = last.value;
+        rows.push({
+          seriesId,
+          bucketStart,
+          samples,
+          sum,
+          min,
+          max,
+          last: last.value,
+          lastTs: last.ts,
+          twSum,
+          twMs
+        });
+      }
+      return rows;
+    }
+    function combineRows(input) {
+      const { rows } = input;
+      const lastRow = rows[rows.length - 1];
+      if (lastRow === void 0) return null;
+      const hasTw = rows.some((r) => r.twSum !== null && r.twMs !== null);
+      let samples = 0;
+      let sum = 0;
+      let min = Number.POSITIVE_INFINITY;
+      let max = Number.NEGATIVE_INFINITY;
+      let twSum = 0;
+      let twMs = 0;
+      let held = input.carryIn;
+      let cursor = input.windowStart;
+      for (const row of rows) {
+        samples += row.samples;
+        sum += row.sum;
+        if (row.min < min) min = row.min;
+        if (row.max > max) max = row.max;
+        const gap = row.bucketStart - cursor;
+        if (hasTw && gap > 0 && held !== null) {
+          twSum += held * gap;
+          twMs += gap;
+          if (held < min) min = held;
+          if (held > max) max = held;
+        }
+        if (row.twSum !== null && row.twMs !== null) {
+          twSum += row.twSum;
+          twMs += row.twMs;
+        }
+        cursor = row.bucketStart + input.childWidthMs;
+        held = row.last;
+      }
+      const coverageEnd = Math.min(input.windowEnd, input.horizon);
+      if (hasTw && held !== null && coverageEnd > cursor) {
+        twSum += held * (coverageEnd - cursor);
+        twMs += coverageEnd - cursor;
+      }
+      return {
+        seriesId: input.seriesId,
+        bucketStart: input.windowStart,
+        samples,
+        sum,
+        min,
+        max,
+        last: lastRow.last,
+        lastTs: lastRow.lastTs,
+        twSum: hasTw ? twSum : null,
+        twMs: hasTw ? twMs : null
+      };
+    }
+    var BOOT_WINDOW_MS = 3 * HOUR_MS;
+    var markVersion = 0;
+    function mark(sets, seriesId, bucketStart) {
+      const map = sets.get(seriesId) ?? /* @__PURE__ */ new Map();
+      markVersion += 1;
+      map.set(bucketStart, markVersion);
+      sets.set(seriesId, map);
+    }
+    function settle(sets, seriesId, handled) {
+      const map = sets.get(seriesId);
+      if (map === void 0) return;
+      for (const { bucket, version } of handled) if (map.get(bucket) === version) map.delete(bucket);
+      if (map.size === 0) sets.delete(seriesId);
+    }
+    var MAX_RANGE_GAP_MS = HOUR_MS;
+    function clusterRanges(sorted) {
+      const ranges = [];
+      for (const start of sorted) {
+        const current = ranges[ranges.length - 1];
+        if (current !== void 0 && start - current[1] <= MAX_RANGE_GAP_MS) current[1] = start + FIVE_MINUTES_MS;
+        else ranges.push([start, start + FIVE_MINUTES_MS]);
+      }
+      return ranges;
+    }
+    var RollupEngine = class {
+      deps;
+      dirty5m = /* @__PURE__ */ new Map();
+      dirty1h = /* @__PURE__ */ new Map();
+      dirty1d = /* @__PURE__ */ new Map();
+      ticking = null;
+      constructor(deps) {
+        this.deps = deps;
+      }
+      dirtyCounts() {
+        const count = (sets) => [...sets.values()].reduce((n, set) => n + set.size, 0);
+        return {
+          m5: count(this.dirty5m),
+          h1: count(this.dirty1h),
+          d1: count(this.dirty1d)
+        };
+      }
+      /** Raw points landed: their 5-minute buckets (and a late bucket's successor) are dirty. */
+      markPoints(written) {
+        const now = this.deps.clock();
+        for (const { seriesId, timestamps } of written) for (const ts of timestamps) {
+          const bucket = floorTo(ts, FIVE_MINUTES_MS);
+          mark(this.dirty5m, seriesId, bucket);
+          if (bucket + 3e5 + ROLLUP_GRACE_MS["5m"] <= now) mark(this.dirty5m, seriesId, bucket + FIVE_MINUTES_MS);
+        }
+      }
+      /** A 5m row landed (computed, or a producer bucket): its hour is dirty. */
+      markFiveMinuteRow(seriesId, bucketStart) {
+        mark(this.dirty1h, seriesId, bucketStartOf("1h", bucketStart));
+      }
+      /** One pass over the three tiers. Single-flight; errors are counted and the work stays dirty. */
+      tick() {
+        if (this.ticking !== null) return this.ticking;
+        const run = this.doTick().finally(() => {
+          this.ticking = null;
+        });
+        this.ticking = run;
+        return run;
+      }
+      async doTick() {
+        const now = this.deps.clock();
+        await this.guarded("5m", () => this.tickFiveMinute(now));
+        await this.guarded("1h", () => this.tickHour(now));
+        await this.guarded("1d", () => this.tickDay(now));
+      }
+      async guarded(tier, run) {
+        try {
+          await run();
+        } catch (err) {
+          this.deps.counters.rollupErrors += 1;
+          this.deps.logger.warn(`device-history: ${tier} rollup pass failed \u2014 work stays dirty`, { meta: { error: err instanceof Error ? err.message : String(err) } });
+        }
+      }
+      closedBuckets(map, tier, now) {
+        return [...map].filter(([start]) => bucketEndOf(tier, start) + ROLLUP_GRACE_MS[tier] <= now).map(([bucket, version]) => ({
+          bucket,
+          version
+        })).toSorted((a, b) => a.bucket - b.bucket);
+      }
+      /** Forget everything held for a series that was purged. */
+      forgetSeries(seriesId) {
+        this.dirty5m.delete(seriesId);
+        this.dirty1h.delete(seriesId);
+        this.dirty1d.delete(seriesId);
+        this.deps.counters.forgetSeries(seriesId);
+      }
+      async tickFiveMinute(now) {
+        let handled = 0;
+        for (const [seriesId, set] of this.dirty5m) {
+          if (handled >= 400) break;
+          const closed = this.closedBuckets(set, "5m", now);
+          if (closed.length === 0) continue;
+          handled += 1;
+          for (const [from, to] of clusterRanges(closed.map((c) => c.bucket))) await this.recomputeFiveMinute(seriesId, from, to, now);
+          settle(this.dirty5m, seriesId, closed);
+        }
+        if (handled > 0) this.deps.counters.last5mAt = now;
+      }
+      async tickHour(now) {
+        let handled = 0;
+        for (const [seriesId, set] of this.dirty1h) {
+          if (handled >= 400) break;
+          const closed = this.closedBuckets(set, "1h", now);
+          if (closed.length === 0) continue;
+          handled += 1;
+          for (const hour of closed) {
+            await this.recomputeHour(seriesId, hour.bucket, now);
+            settle(this.dirty1h, seriesId, [hour]);
+          }
+        }
+        if (handled > 0) this.deps.counters.last1hAt = now;
+      }
+      async tickDay(now) {
+        let handled = 0;
+        for (const [seriesId, set] of this.dirty1d) {
+          if (handled >= 400) break;
+          const closed = this.closedBuckets(set, "1d", now);
+          if (closed.length === 0) continue;
+          handled += 1;
+          for (const day of closed) {
+            await this.recomputeDay(seriesId, day.bucket, now);
+            settle(this.dirty1d, seriesId, [day]);
+          }
+        }
+        if (handled > 0) this.deps.counters.last1dAt = now;
+      }
+      /** Raw → 5m rows for buckets in `[from, toExclusive)`; writes them and marks their hours. */
+      async recomputeFiveMinute(seriesId, from, toExclusive, horizon) {
+        const { store } = this.deps;
+        const points = [];
+        let cursor = from;
+        for (; ; ) {
+          const page = await store.readRaw(seriesId, cursor, toExclusive - 1, READ_PAGE);
+          points.push(...page);
+          const last = page[page.length - 1];
+          if (last === void 0 || page.length < 5e3) break;
+          cursor = last.ts + 1;
+        }
+        const rows = rawToFiveMinuteRows({
+          seriesId,
+          points,
+          carryIn: await store.rawBefore(seriesId, from),
+          horizon
+        });
+        if (rows.length === 0) return 0;
+        await store.upsertRollups("5m", rows);
+        this.deps.counters.noteRollupRows("5m", seriesId, rows.map((r) => r.bucketStart));
+        for (const row of rows) this.markFiveMinuteRow(seriesId, row.bucketStart);
+        return rows.length;
+      }
+      async recomputeHour(seriesId, hour, now) {
+        await this.recomputeFrom("5m", "1h", FIVE_MINUTES_MS, seriesId, hour, now);
+      }
+      async recomputeDay(seriesId, day, now) {
+        await this.recomputeFrom("1h", "1d", HOUR_MS, seriesId, day, now);
+      }
+      async recomputeFrom(child, parent, childWidthMs, seriesId, windowStart, now) {
+        const { store } = this.deps;
+        const windowEnd = bucketEndOf(parent, windowStart);
+        const combined = combineRows({
+          seriesId,
+          windowStart,
+          windowEnd,
+          childWidthMs,
+          rows: await store.readRollups(child, seriesId, windowStart, windowEnd - 1, READ_PAGE),
+          carryIn: (await store.rollupBefore(child, seriesId, windowStart))?.last ?? null,
+          horizon: now
+        });
+        if (combined === null) return;
+        await store.upsertRollups(parent, [combined]);
+        this.deps.counters.noteRollupRows(parent, seriesId, [combined.bucketStart]);
+        if (parent === "1h") mark(this.dirty1d, seriesId, bucketStartOf("1d", windowStart));
+      }
+      /**
+      * After a restart the dirty sets are gone. Rebuild the recent window from raw
+      * (the still-open bucket included, time-weighted up to `now`), then mark the
+      * 1h / 1d buckets of that window dirty so the next ticks recompute them.
+      */
+      async bootRecompute(now) {
+        const windowStart = floorTo(now - BOOT_WINDOW_MS, FIVE_MINUTES_MS);
+        const openBucket = floorTo(now, FIVE_MINUTES_MS);
+        let series = 0;
+        for (const s of this.deps.registry.all()) {
+          if (s.lastTs < windowStart) continue;
+          const metric = this.deps.registry.metric(s.key);
+          series += 1;
+          if (metric?.ingest === "points") {
+            await this.recomputeFiveMinute(s.id, windowStart, openBucket + FIVE_MINUTES_MS, now);
+            mark(this.dirty5m, s.id, openBucket);
+            mark(this.dirty5m, s.id, openBucket - FIVE_MINUTES_MS);
+          }
+          for (let hour = floorTo(windowStart, HOUR_MS); hour <= now; hour += HOUR_MS) mark(this.dirty1h, s.id, hour);
+          mark(this.dirty1d, s.id, bucketStartOf("1d", windowStart));
+          mark(this.dirty1d, s.id, bucketStartOf("1d", now));
+        }
+        return series;
+      }
+    };
+    function deltas(now, before) {
+      const out = {};
+      for (const [k, v] of now) {
+        const d = v - (before.get(k) ?? 0);
+        if (d > 0) out[k] = d;
+      }
+      return out;
+    }
+    var HistoryCounters = class {
+      eventsSeen = 0;
+      pointsEmitted = 0;
+      pointsWritten = 0;
+      pointsDropped = 0;
+      trailingEmitted = 0;
+      reconciledPoints = 0;
+      reconcileRuns = 0;
+      reconcileFailures = 0;
+      lastReconcileAt = null;
+      lastFlushAt = null;
+      flushFailures = 0;
+      ingestAccepted = 0;
+      rollupErrors = 0;
+      last5mAt = null;
+      last1hAt = null;
+      last1dAt = null;
+      retentionLastRunAt = null;
+      purgedSeries = 0;
+      directoryRefreshAt = null;
+      skipped = /* @__PURE__ */ new Map();
+      refused = /* @__PURE__ */ new Map();
+      deleted = /* @__PURE__ */ new Map();
+      reported = {
+        skipped: /* @__PURE__ */ new Map(),
+        refused: /* @__PURE__ */ new Map(),
+        deleted: /* @__PURE__ */ new Map(),
+        flushFailures: 0
+      };
+      /** Net rows written minus deleted per tier since boot — the estimate behind `getStatus` row counts. */
+      rowDelta = /* @__PURE__ */ new Map();
+      /** Newest bucket seen per (tier, series): a row beyond it is NEW, a rewrite of an older one is not. */
+      newestBucket = /* @__PURE__ */ new Map();
+      skip(reason, count = 1) {
+        this.skipped.set(reason, (this.skipped.get(reason) ?? 0) + count);
+      }
+      refuse(reason, count = 1) {
+        this.refused.set(reason, (this.refused.get(reason) ?? 0) + count);
+      }
+      addDeleted(tier, count) {
+        if (count <= 0) return;
+        this.deleted.set(tier, (this.deleted.get(tier) ?? 0) + count);
+        if (tier === "raw" || tier === "5m" || tier === "1h" || tier === "1d") this.rowDelta.set(tier, (this.rowDelta.get(tier) ?? 0) - count);
+      }
+      addRawRows(count) {
+        this.rowDelta.set("raw", (this.rowDelta.get("raw") ?? 0) + count);
+      }
+      /** Rollup rows written: only a bucket newer than the series' newest known is counted as a new row. */
+      noteRollupRows(tier, seriesId, bucketStarts) {
+        const marker = `${tier}:${seriesId}`;
+        let newest = this.newestBucket.get(marker) ?? Number.NEGATIVE_INFINITY;
+        let added = 0;
+        for (const b of bucketStarts) if (b > newest) {
+          added += 1;
+          newest = b;
+        }
+        this.newestBucket.set(marker, newest);
+        if (added > 0) this.rowDelta.set(tier, (this.rowDelta.get(tier) ?? 0) + added);
+      }
+      rowDeltaOf(tier) {
+        return this.rowDelta.get(tier) ?? 0;
+      }
+      forgetSeries(seriesId) {
+        for (const tier of [
+          "5m",
+          "1h",
+          "1d"
+        ]) this.newestBucket.delete(`${tier}:${seriesId}`);
+      }
+      skippedRecord() {
+        return Object.fromEntries(this.skipped);
+      }
+      refusedRecord() {
+        return Object.fromEntries(this.refused);
+      }
+      deletedRecord() {
+        return Object.fromEntries(this.deleted);
+      }
+      /** What was skipped, refused, deleted or failed since the last call; `null` when nothing. */
+      summarySinceLast() {
+        const summary = {
+          skipped: deltas(this.skipped, this.reported.skipped),
+          refused: deltas(this.refused, this.reported.refused),
+          deleted: deltas(this.deleted, this.reported.deleted),
+          flushFailures: this.flushFailures - this.reported.flushFailures
+        };
+        this.reported = {
+          skipped: new Map(this.skipped),
+          refused: new Map(this.refused),
+          deleted: new Map(this.deleted),
+          flushFailures: this.flushFailures
+        };
+        return Object.keys(summary.skipped).length === 0 && Object.keys(summary.refused).length === 0 && Object.keys(summary.deleted).length === 0 && summary.flushFailures === 0 ? null : summary;
+      }
+    };
+    var ROLLUP_INTERVAL_MS = 6e4;
+    var RECONCILE_INTERVAL_MS = 5 * 6e4;
+    var RETENTION_INTERVAL_MS = 10 * 6e4;
+    var FIRST_COUNT_DELAY_MS = 9e4;
+    var APPROX_BYTES_PER_ROW = {
+      raw: 24,
+      "5m": 72,
+      "1h": 72,
+      "1d": 72
+    };
+    var HistoryRuntime = class {
+      deps;
+      counters = new HistoryCounters();
+      store;
+      registry;
+      directory;
+      rollup;
+      writer;
+      capture;
+      ingest;
+      query;
+      retentionJob;
+      departures;
+      optedOutDevices = /* @__PURE__ */ new Set();
+      tierCounts = /* @__PURE__ */ new Map();
+      startedAt;
+      timers = [];
+      countTimeout = null;
+      ready = false;
+      constructor(deps) {
+        this.deps = deps;
+        const { logger, clock, catalog } = deps;
+        this.startedAt = clock();
+        this.store = new HistoryStore(deps.door);
+        this.registry = new SeriesRegistry(this.store);
+        this.directory = new DeviceDirectory(deps.deviceSource, this.counters, logger, clock);
+        this.rollup = new RollupEngine({
+          store: this.store,
+          registry: this.registry,
+          counters: this.counters,
+          logger,
+          clock
+        });
+        this.writer = new PointWriter({
+          registry: this.registry,
+          store: this.store,
+          counters: this.counters,
+          logger,
+          clock,
+          onWritten: (written) => this.rollup.markPoints(written),
+          onDropped: (dropped) => this.capture.forget(dropped)
+        });
+        const optedOut = () => this.optedOutDevices;
+        this.capture = new CaptureEngine({
+          catalog,
+          registry: this.registry,
+          store: this.store,
+          directory: this.directory,
+          writer: this.writer,
+          optedOut,
+          counters: this.counters,
+          logger,
+          clock
+        });
+        this.ingest = new ProducerIngest({
+          registry: this.registry,
+          store: this.store,
+          directory: this.directory,
+          writer: this.writer,
+          counters: this.counters,
+          logger,
+          clock,
+          optedOut,
+          retention: () => {
+            const policy = deps.retention();
+            return {
+              rawMs: policy.rawDays * DAY_MS,
+              fiveMinuteMs: policy.fiveMinuteDays * DAY_MS
+            };
+          },
+          onBucketWritten: (seriesId, bucketStart) => this.rollup.markFiveMinuteRow(seriesId, bucketStart)
+        });
+        this.query = new HistoryQuery({
+          registry: this.registry,
+          store: this.store,
+          clock,
+          retention: deps.retention,
+          catalog,
+          readCapSlice: deps.readCapSlice
+        });
+        this.departures = new DepartureTracker(this.store, this.registry, logger);
+        this.registry.onRemove((series) => {
+          this.capture.forgetSeries(series);
+          this.ingest.forgetSeries(series);
+          this.rollup.forgetSeries(series.id);
+          this.retentionJob.forgetSeries(series.id);
+        });
+        this.retentionJob = new RetentionJob({
+          store: this.store,
+          registry: this.registry,
+          departures: this.departures,
+          counters: this.counters,
+          logger
+        });
+      }
+      async prepare() {
+        await this.store.declare();
+        await this.registry.load();
+        for (const metric of catalogMetrics(this.deps.catalog, this.deps.clock())) await this.registry.declareMetric(metric);
+        this.optedOutDevices = await this.store.loadOptOuts();
+        await this.departures.load();
+        await this.directory.refresh();
+        await this.capture.seed();
+      }
+      async finishBoot() {
+        const series = await this.rollup.bootRecompute(this.deps.clock());
+        this.deps.logger.info("device-history: recent rollup window rebuilt", { meta: { series } });
+        await this.reconcile();
+      }
+      startTimers() {
+        const every = (ms, run) => {
+          const timer = setInterval(() => {
+            run().catch((err) => {
+              this.deps.logger.warn("device-history: scheduled pass threw", { meta: { error: err instanceof Error ? err.message : String(err) } });
+            });
+          }, ms);
+          timer.unref();
+          this.timers.push(timer);
+        };
+        every(FLUSH_INTERVAL_MS, () => this.flushNow());
+        every(ROLLUP_INTERVAL_MS, async () => {
+          await this.rollup.tick();
+          this.reportWindow();
+        });
+        every(RECONCILE_INTERVAL_MS, async () => {
+          await this.reconcile();
+          this.reportWindow();
+        });
+        every(RETENTION_INTERVAL_MS, async () => {
+          await this.retentionJob.run(this.deps.retention(), this.deps.clock());
+          this.reportWindow();
+        });
+        this.countTimeout = setTimeout(() => {
+          this.refreshCounts().catch(() => void 0);
+        }, FIRST_COUNT_DELAY_MS);
+        this.countTimeout.unref();
+      }
+      async stop() {
+        for (const t of this.timers) clearInterval(t);
+        this.timers = [];
+        if (this.countTimeout !== null) clearTimeout(this.countTimeout);
+        this.countTimeout = null;
+        await this.writer.flush();
+      }
+      /** Emit pending trailing points, then write the buffer. */
+      async flushNow() {
+        this.capture.tickPending(this.deps.clock());
+        await this.writer.flush();
+      }
+      /**
+      * Restore changes a dropped event missed. A FAILED read changes nothing (D49):
+      * it is counted and logged, and the next pass tries again.
+      */
+      async reconcile() {
+        const { logger, clock } = this.deps;
+        if (await this.directory.refresh()) await this.departures.observe(this.directory.listedIds(), clock());
+        let snapshots;
+        try {
+          snapshots = await this.deps.readSnapshots();
+        } catch (err) {
+          this.counters.reconcileFailures += 1;
+          logger.warn("device-history: reconcile read failed \u2014 nothing changed", { meta: { error: err instanceof Error ? err.message : String(err) } });
+          return;
+        }
+        const now = clock();
+        this.capture.reconcile(snapshots, now);
+        this.counters.reconcileRuns += 1;
+        this.counters.lastReconcileAt = now;
+        this.ready = true;
+      }
+      async refreshCounts() {
+        for (const tier of [
+          "raw",
+          "5m",
+          "1h",
+          "1d"
+        ]) {
+          const deltaAtCount = this.counters.rowDeltaOf(tier);
+          const rows = await this.store.countRows(tier);
+          this.tierCounts.set(tier, {
+            rows,
+            countedAt: this.deps.clock(),
+            deltaAtCount
+          });
+        }
+      }
+      /**
+      * ONE aggregated INFO naming what was skipped, refused, deleted or failed since the
+      * previous report (D391) — the counts a per-event line would drown. Silent when
+      * nothing happened.
+      */
+      reportWindow() {
+        const summary = this.counters.summarySinceLast();
+        if (summary === null) return;
+        this.deps.logger.info("device-history: since the last report", { meta: { ...summary } });
+      }
+      isEnabled(deviceId) {
+        return !this.optedOutDevices.has(deviceId);
+      }
+      async setEnabled(deviceId, enabled) {
+        if (enabled) {
+          await this.store.clearOptOut(deviceId);
+          this.optedOutDevices = new Set([...this.optedOutDevices].filter((id) => id !== deviceId));
+        } else {
+          await this.store.setOptOut(deviceId, this.deps.clock());
+          this.optedOutDevices = /* @__PURE__ */ new Set([...this.optedOutDevices, deviceId]);
+        }
+        return enabled;
+      }
+      /** Delete the history of a deleted device: its series, opt-out and absence clock. */
+      async removeDevice(deviceId) {
+        const series = await this.retentionJob.purgeDevice(deviceId, this.deps.clock());
+        await this.store.clearOptOut(deviceId);
+        await this.departures.forget(deviceId);
+        this.optedOutDevices = new Set([...this.optedOutDevices].filter((id) => id !== deviceId));
+        return { series };
+      }
+      /** Series held per device, for the admin clean-up listing. */
+      seriesByDevice() {
+        const out = /* @__PURE__ */ new Map();
+        for (const s of this.registry.all()) {
+          if (s.deviceId === null) continue;
+          out.set(s.deviceId, (out.get(s.deviceId) ?? 0) + 1);
+        }
+        return out;
+      }
+      status() {
+        const c = this.counters;
+        const dirty = this.rollup.dirtyCounts();
+        return {
+          startedAt: this.startedAt,
+          ready: this.ready,
+          series: this.registry.all().length,
+          metrics: this.registry.allMetrics().length,
+          optedOutDevices: this.optedOutDevices.size,
+          tiers: [
+            "raw",
+            "5m",
+            "1h",
+            "1d"
+          ].map((tier) => {
+            const count = this.tierCounts.get(tier);
+            const rows = count === void 0 ? null : Math.max(0, count.rows + this.counters.rowDeltaOf(tier) - count.deltaAtCount);
+            return {
+              tier,
+              rows,
+              approxBytes: rows === null ? null : rows * APPROX_BYTES_PER_ROW[tier],
+              countedAt: count?.countedAt ?? null
+            };
+          }),
+          capture: {
+            eventsSeen: c.eventsSeen,
+            pointsEmitted: c.pointsEmitted,
+            pointsWritten: c.pointsWritten,
+            pointsDropped: c.pointsDropped,
+            bufferDepth: this.writer.depth(),
+            trailingEmitted: c.trailingEmitted,
+            reconciledPoints: c.reconciledPoints,
+            reconcileRuns: c.reconcileRuns,
+            reconcileFailures: c.reconcileFailures,
+            lastReconcileAt: c.lastReconcileAt,
+            lastFlushAt: c.lastFlushAt,
+            flushFailures: c.flushFailures,
+            skipped: c.skippedRecord()
+          },
+          ingest: {
+            accepted: c.ingestAccepted,
+            refused: c.refusedRecord()
+          },
+          rollup: {
+            last5mAt: c.last5mAt,
+            last1hAt: c.last1hAt,
+            last1dAt: c.last1dAt,
+            errors: c.rollupErrors,
+            dirty5m: dirty.m5,
+            dirty1h: dirty.h1,
+            dirty1d: dirty.d1
+          },
+          retention: {
+            lastRunAt: c.retentionLastRunAt,
+            deleted: c.deletedRecord(),
+            purgedSeries: c.purgedSeries
+          },
+          directory: {
+            devices: this.directory.size(),
+            lastRefreshAt: this.directory.lastRefreshAt()
+          }
+        };
+      }
+    };
+    var DEFAULT_CONFIG = {
+      rawDays: DEFAULT_RETENTION.rawDays,
+      fiveMinuteDays: DEFAULT_RETENTION.fiveMinuteDays,
+      hourDays: DEFAULT_RETENTION.hourDays,
+      dayDays: 0
+    };
+    function isRecord(value) {
+      return typeof value === "object" && value !== null && !Array.isArray(value);
+    }
+    function callerOf(input) {
+      if (!isRecord(input)) return null;
+      const raw = input["callerAddonId"];
+      return typeof raw === "string" && raw.length > 0 ? raw : null;
+    }
+    function positiveOr(value, fallback) {
+      return typeof value === "number" && Number.isFinite(value) && value > 0 ? value : fallback;
+    }
+    var DeviceHistoryAddon = class extends require_dist10.BaseAddon {
+      runtime = null;
+      unsubscribe = null;
+      removalHook = null;
+      constructor() {
+        super({ ...DEFAULT_CONFIG });
+      }
+      retention() {
+        const c = this.config;
+        return {
+          rawDays: positiveOr(c.rawDays, DEFAULT_RETENTION.rawDays),
+          fiveMinuteDays: positiveOr(c.fiveMinuteDays, DEFAULT_RETENTION.fiveMinuteDays),
+          hourDays: positiveOr(c.hourDays, DEFAULT_RETENTION.hourDays),
+          dayDays: positiveOr(c.dayDays, 0) > 0 ? c.dayDays : null
+        };
+      }
+      requireRuntime() {
+        if (this.runtime === null) throw new Error("device-history is starting \u2014 the history store is not open yet");
+        return this.runtime;
+      }
+      async onInitialize() {
+        const provider = {
+          listSeries: async (input) => this.requireRuntime().query.listSeries({
+            kind: "device",
+            deviceId: input.deviceId
+          }),
+          listNodeSeries: async (input) => this.requireRuntime().query.listSeries({
+            kind: "node",
+            nodeId: input.nodeId
+          }),
+          query: async ({ deviceId, ...window2 }) => this.requireRuntime().query.query({
+            ...window2,
+            subject: {
+              kind: "device",
+              deviceId
+            }
+          }),
+          queryNode: async ({ nodeId, ...window2 }) => this.requireRuntime().query.query({
+            ...window2,
+            subject: {
+              kind: "node",
+              nodeId
+            }
+          }),
+          declareSeries: async (input) => this.requireRuntime().ingest.declareSeries(callerOf(input), input),
+          record: async (input) => this.requireRuntime().ingest.record(callerOf(input), input.points),
+          recordBuckets: async (input) => this.requireRuntime().ingest.recordBuckets(callerOf(input), input.buckets),
+          getDeviceEnabled: async (input) => ({ enabled: this.requireRuntime().isEnabled(input.deviceId) }),
+          setDeviceEnabled: async (input) => ({ enabled: await this.requireRuntime().setEnabled(input.deviceId, input.enabled) }),
+          getStatus: async () => this.requireRuntime().status()
+        };
+        this.ctx.logger.info("Initialized \u2014 device-history provider registered (store opens on hub link)");
+        const removalHook = {
+          onDeviceRemoved: async (input) => {
+            const { series } = await this.requireRuntime().removeDevice(input.deviceId);
+            if (series > 0) this.ctx.logger.info("device-history: removed the history of a deleted device", {
+              tags: { deviceId: input.deviceId },
+              meta: {
+                counts: { series },
+                deletedAt: input.deletedAt
+              }
+            });
+            return { counts: { series } };
+          },
+          listDeviceData: async () => [...this.requireRuntime().seriesByDevice()].map(([deviceId, count]) => ({
+            store: "series",
+            deviceId,
+            count
+          }))
+        };
+        this.removalHook = removalHook;
+        return [{
+          capability: require_dist10.deviceHistoryCapability,
+          provider
+        }, {
+          capability: require_dist10.deviceRemovalHookCapability,
+          provider: removalHook
+        }];
+      }
+      async onHubReachable() {
+        const api = this.ctx.api;
+        const runtime = new HistoryRuntime({
+          door: api.settingsStore,
+          catalog: require_dist10.HISTORY_CATALOG,
+          deviceSource: {
+            listAll: async () => {
+              return (await api.deviceManager.listAll.query({ projection: "slim" })).map((d) => ({
+                id: d.id,
+                type: d.type
+              }));
+            },
+            getDevice: async (deviceId) => {
+              const d = await api.deviceManager.getDevice.query({ deviceId });
+              return d === null ? null : {
+                id: d.id,
+                type: d.type
+              };
+            }
+          },
+          readSnapshots: async () => api.deviceState.getAllSnapshots.query({}),
+          readCapSlice: (deviceId, capName) => api.deviceState.getCapSlice.query({
+            deviceId,
+            capName
+          }),
+          retention: () => this.retention(),
+          logger: this.ctx.logger,
+          clock: () => Date.now()
+        });
+        await runtime.prepare();
+        this.unsubscribe = this.ctx.eventBus.subscribe({ category: require_dist10.EventCategory.DeviceStateChanged }, (event) => {
+          const data = event.data;
+          if (!isRecord(data)) return;
+          const { deviceId, capName, slice } = data;
+          if (typeof deviceId !== "number" || typeof capName !== "string" || !isRecord(slice)) return;
+          const at = event.timestamp instanceof Date ? event.timestamp.getTime() : Date.now();
+          runtime.capture.handleState(deviceId, capName, slice, at);
+        });
+        this.ctx.addDisposer(async () => this.stopRuntime());
+        this.runtime = runtime;
+        await runtime.finishBoot();
+        runtime.startTimers();
+        const removalHook = this.removalHook;
+        if (removalHook !== null) this.ctx.addDisposer(require_dist10.armRemovalReconcile({
+          api: this.ctx.api,
+          logger: this.ctx.logger,
+          remove: (input) => removalHook.onDeviceRemoved(input)
+        }));
+        this.ctx.logger.info("device-history: capturing", { meta: {
+          series: runtime.status().series,
+          metrics: runtime.status().metrics
+        } });
+      }
+      async stopRuntime() {
+        this.unsubscribe?.();
+        this.unsubscribe = null;
+        await this.runtime?.stop();
+      }
+      async onShutdown() {
+        await this.stopRuntime();
+        this.runtime = null;
+      }
+      globalSettingsSchema() {
+        return this.schema({ sections: [{
+          id: "retention",
+          title: "Retention",
+          description: "How long each tier is kept. The raw points feed the 5-minute rollup; the 1-day tier is kept forever unless a number of days is set.",
+          columns: 2,
+          fields: [
+            {
+              type: "number",
+              key: "rawDays",
+              label: "Raw points (days)",
+              min: 1,
+              max: 60,
+              step: 1
+            },
+            {
+              type: "number",
+              key: "fiveMinuteDays",
+              label: "5-minute rollup (days)",
+              min: 1,
+              max: 365,
+              step: 1
+            },
+            {
+              type: "number",
+              key: "hourDays",
+              label: "1-hour rollup (days)",
+              min: 7,
+              max: 3650,
+              step: 1
+            },
+            {
+              type: "number",
+              key: "dayDays",
+              label: "1-day rollup (days, 0 = forever)",
+              min: 0,
+              max: 36500,
+              step: 1
+            }
+          ]
+        }] });
+      }
+    };
+    exports.DeviceHistoryAddon = DeviceHistoryAddon;
+    exports.default = DeviceHistoryAddon;
+    exports.callerOf = callerOf;
+  }
+});
+
 // ../system/dist/builtins/sqlite-storage/filesystem-storage.addon.js
 var require_filesystem_storage_addon = __commonJS({
   "../system/dist/builtins/sqlite-storage/filesystem-storage.addon.js"(exports) {
@@ -160169,7 +162638,7 @@ var require_filesystem_storage_addon = __commonJS({
       [Symbol.toStringTag]: { value: "Module" }
     });
     var require_chunk = require_chunk_Cek0wNdY();
-    var require_dist10 = require_dist_BkNfEJKa();
+    var require_dist10 = require_dist_Ct88catN();
     var node_crypto = __require("crypto");
     var node_fs_promises = __require("fs/promises");
     var node_path = __require("path");
@@ -161279,12 +163748,12 @@ var require_lib = __commonJS({
   }
 });
 
-// ../system/dist/wal-maintenance-CuG1DUca.js
-var require_wal_maintenance_CuG1DUca = __commonJS({
-  "../system/dist/wal-maintenance-CuG1DUca.js"(exports) {
+// ../system/dist/wal-maintenance-mwCBe3Vr.js
+var require_wal_maintenance_mwCBe3Vr = __commonJS({
+  "../system/dist/wal-maintenance-mwCBe3Vr.js"(exports) {
     "use strict";
     var require_chunk = require_chunk_Cek0wNdY();
-    var require_dist10 = require_dist_BkNfEJKa();
+    var require_dist10 = require_dist_Ct88catN();
     var require_prefix_range = require_prefix_range_D_KueXbQ();
     var node_crypto = __require("crypto");
     var node_module = __require("module");
@@ -164825,6 +167294,22 @@ CREATE TABLE IF NOT EXISTS _record_sequences (
         ...profiler ? { profiler } : {}
       });
     }
+    function vectorProviderOfOwnedFile(openEvents) {
+      const call = async (op, input) => {
+        return (await openEvents()).vector(op, input);
+      };
+      return {
+        declareIndex: async (input) => call("declareIndex", input),
+        upsert: async (input) => call("upsert", input),
+        query: async (input) => call("query", input),
+        getByIds: async (input) => call("getByIds", input),
+        fetchByIds: async (input) => call("fetchByIds", input),
+        scan: async (input) => call("scan", input),
+        deleteByIds: async (input) => call("deleteByIds", input),
+        deleteByFilter: async (input) => call("deleteByFilter", input),
+        stats: async (input) => call("stats", input)
+      };
+    }
     function vectorProviderOf(vectorIndex) {
       return {
         declareIndex: async (input) => {
@@ -165268,6 +167753,12 @@ CREATE TABLE IF NOT EXISTS _record_sequences (
         return vectorProviderOf;
       }
     });
+    Object.defineProperty(exports, "vectorProviderOfOwnedFile", {
+      enumerable: true,
+      get: function() {
+        return vectorProviderOfOwnedFile;
+      }
+    });
   }
 });
 
@@ -165446,9 +167937,9 @@ var require_sqlite_settings_addon = __commonJS({
       [Symbol.toStringTag]: { value: "Module" }
     });
     var require_chunk = require_chunk_Cek0wNdY();
-    var require_dist10 = require_dist_BkNfEJKa();
+    var require_dist10 = require_dist_Ct88catN();
     var require_retired_settings_keys = require_retired_settings_keys_D_VwZiDt();
-    var require_wal_maintenance = require_wal_maintenance_CuG1DUca();
+    var require_wal_maintenance = require_wal_maintenance_mwCBe3Vr();
     var require_sqlite_snapshot_protocol = require_sqlite_snapshot_protocol_B9OndqZv();
     var require_wal_checkpoint_policy = require_wal_checkpoint_policy_d2z2qPqx();
     var node_fs_promises = __require("fs/promises");
@@ -167145,7 +169636,7 @@ var require_sqlite_settings_addon = __commonJS({
           livePath: settingsPath,
           thread: "main",
           autoVacuum: "none",
-          loadVectorExtension: true
+          loadVectorExtension: false
         }, deps);
         if (!(settings instanceof InlineOwnedFile)) throw new Error("sqlite-settings: the settings file must be served on the main thread");
         this.settingsFile = settings;
@@ -167158,8 +169649,7 @@ var require_sqlite_settings_addon = __commonJS({
           logger: this.ctx.logger.child("Placement")
         });
         this.router = router;
-        const vectorIndex = settings.getVectorIndex();
-        if (vectorIndex === null) throw new Error("vector-store: the settings file has no vector index");
+        const vectorProvider = require_wal_maintenance.vectorProviderOfOwnedFile(() => router.recordsFileFor("events"));
         const records = new RecordsProvider(router, this.ctx.logger.child("Records"));
         await records.init();
         this.startRecordsSweep(records);
@@ -167175,7 +169665,7 @@ var require_sqlite_settings_addon = __commonJS({
           },
           {
             capability: require_dist10.vectorStoreCapability,
-            provider: require_wal_maintenance.vectorProviderOf(vectorIndex)
+            provider: vectorProvider
           },
           {
             capability: require_dist10.databaseSnapshotCapability,
@@ -167244,9 +169734,9 @@ var require_sqlite_settings_addon = __commonJS({
       getRouter() {
         return this.router;
       }
-      /** Exposed for tests; null before `onInitialize`. */
+      /** Exposed for tests; vectors are served from the events file (P5). */
       getVectorIndex() {
-        return this.settingsFile?.getVectorIndex() ?? null;
+        return null;
       }
     };
     function workerSpec(databaseId, livePath) {
@@ -167255,7 +169745,7 @@ var require_sqlite_settings_addon = __commonJS({
         livePath,
         thread: "worker",
         autoVacuum: "incremental",
-        loadVectorExtension: false
+        loadVectorExtension: databaseId === "events"
       };
     }
     exports.SqliteSettingsAddon = SqliteSettingsAddon;
@@ -167273,7 +169763,7 @@ var require_sqlite_storage = __commonJS({
     });
     require_chunk_Cek0wNdY();
     var require_builtins_sqlite_storage_filesystem_storage_addon = require_filesystem_storage_addon();
-    var require_wal_maintenance = require_wal_maintenance_CuG1DUca();
+    var require_wal_maintenance = require_wal_maintenance_mwCBe3Vr();
     var require_builtins_sqlite_storage_sqlite_settings_addon = require_sqlite_settings_addon();
     var ConfigStore = class {
       db;
@@ -167357,7 +169847,7 @@ var require_storage_orchestrator_addon = __commonJS({
       [Symbol.toStringTag]: { value: "Module" }
     });
     var require_chunk = require_chunk_Cek0wNdY();
-    var require_dist10 = require_dist_BkNfEJKa();
+    var require_dist10 = require_dist_Ct88catN();
     var require_read_all_rows$1 = require_read_all_rows_CVoO1ONM();
     var zod = require_zod();
     var node_crypto = __require("crypto");
@@ -171488,11 +173978,11 @@ var require_storage_orchestrator = __commonJS({
   }
 });
 
-// ../system/dist/constants-DA_tjzIk.js
-var require_constants_DA_tjzIk = __commonJS({
-  "../system/dist/constants-DA_tjzIk.js"(exports) {
+// ../system/dist/constants-BPWA-r-Y.js
+var require_constants_BPWA_r_Y = __commonJS({
+  "../system/dist/constants-BPWA-r-Y.js"(exports) {
     "use strict";
-    var MESH_CA_KEY_REF = require_dist_BkNfEJKa().buildSecretRef({
+    var MESH_CA_KEY_REF = require_dist_Ct88catN().buildSecretRef({
       owner: "system",
       scope: { kind: "global" },
       fieldPath: "meshCaKey"
@@ -171555,14 +174045,14 @@ var require_constants_DA_tjzIk = __commonJS({
   }
 });
 
-// ../system/dist/agent-https-5DYAOJMO.js
-var require_agent_https_5DYAOJMO = __commonJS({
-  "../system/dist/agent-https-5DYAOJMO.js"(exports) {
+// ../system/dist/agent-https-CMz4S56_.js
+var require_agent_https_CMz4S56 = __commonJS({
+  "../system/dist/agent-https-CMz4S56_.js"(exports) {
     "use strict";
     var require_chunk = require_chunk_Cek0wNdY();
-    var require_dist10 = require_dist_BkNfEJKa();
+    var require_dist10 = require_dist_Ct88catN();
     var require_x509_es = require_x509_es_C4cOo48M();
-    var require_constants15 = require_constants_DA_tjzIk();
+    var require_constants15 = require_constants_BPWA_r_Y();
     var zod = require_zod();
     var node_crypto = __require("crypto");
     var _camstack_types_node = require_node();
@@ -190305,11 +192795,11 @@ var require_system_config_addon = __commonJS({
       [Symbol.toStringTag]: { value: "Module" }
     });
     var require_chunk = require_chunk_Cek0wNdY();
-    var require_dist10 = require_dist_BkNfEJKa();
+    var require_dist10 = require_dist_Ct88catN();
     var require_safe_buffer$1 = require_safe_buffer_D3aoa_7X();
     var require_x509_es = require_x509_es_C4cOo48M();
-    var require_constants$8 = require_constants_DA_tjzIk();
-    var require_agent_https = require_agent_https_5DYAOJMO();
+    var require_constants$8 = require_constants_BPWA_r_Y();
+    var require_agent_https = require_agent_https_CMz4S56();
     var require_src$1 = require_src_CnAqG6EF();
     var zod = require_zod();
     var node_crypto = __require("crypto");
@@ -270022,7 +272512,7 @@ var require_winston_logging = __commonJS({
       [Symbol.toStringTag]: { value: "Module" }
     });
     var require_chunk = require_chunk_Cek0wNdY();
-    var require_dist10 = require_dist_BkNfEJKa();
+    var require_dist10 = require_dist_Ct88catN();
     var require_formatter = require_formatter_DqAKDlvN();
     var node_path = __require("path");
     node_path = require_chunk.__toESM(node_path);
@@ -277672,14 +280162,14 @@ var require_lib_8oZrELLm = __commonJS({
   }
 });
 
-// ../system/dist/hub-mdns-ciao-m5LIr4oA.js
-var require_hub_mdns_ciao_m5LIr4oA = __commonJS({
-  "../system/dist/hub-mdns-ciao-m5LIr4oA.js"(exports) {
+// ../system/dist/hub-mdns-ciao-DAU1WttG.js
+var require_hub_mdns_ciao_DAU1WttG = __commonJS({
+  "../system/dist/hub-mdns-ciao-DAU1WttG.js"(exports) {
     "use strict";
     var require_chunk = require_chunk_Cek0wNdY();
-    var require_dist10 = require_dist_BkNfEJKa();
+    var require_dist10 = require_dist_Ct88catN();
     var require_x509_es = require_x509_es_C4cOo48M();
-    var require_agent_https = require_agent_https_5DYAOJMO();
+    var require_agent_https = require_agent_https_CMz4S56();
     var node_crypto = __require("crypto");
     var _camstack_types_node = require_node();
     var node_fs_promises = __require("fs/promises");
@@ -278678,12 +281168,12 @@ var require_platform_key_source_Di7HrlGR = __commonJS({
   }
 });
 
-// ../system/dist/restore-archive-B57xI5Ue.js
-var require_restore_archive_B57xI5Ue = __commonJS({
-  "../system/dist/restore-archive-B57xI5Ue.js"(exports) {
+// ../system/dist/restore-archive-Cprdh3P9.js
+var require_restore_archive_Cprdh3P9 = __commonJS({
+  "../system/dist/restore-archive-Cprdh3P9.js"(exports) {
     "use strict";
     var require_chunk = require_chunk_Cek0wNdY();
-    var require_dist10 = require_dist_BkNfEJKa();
+    var require_dist10 = require_dist_Ct88catN();
     var require_read_all_rows$1 = require_read_all_rows_CVoO1ONM();
     var zod = require_zod();
     var node_crypto = __require("crypto");
@@ -290004,9 +292494,9 @@ var require_dist3 = __commonJS({
     "use strict";
     Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
     var require_chunk = require_chunk_Cek0wNdY();
-    var require_dist10 = require_dist_BkNfEJKa();
+    var require_dist10 = require_dist_Ct88catN();
     var require_read_all_rows$1 = require_read_all_rows_CVoO1ONM();
-    var require_device_ca = require_device_ca_CnbrgfmW();
+    var require_device_ca = require_device_ca_75rt3U_U();
     var require_builtins_alerts_alerts_addon = require_alerts_addon();
     require_alerts();
     var require_builtins_calendars_calendars_addon = require_calendars_addon();
@@ -290029,22 +292519,23 @@ var require_dist3 = __commonJS({
     require_local_auth();
     var require_builtins_loki_logging_index = require_loki_logging();
     var require_builtins_native_metrics_native_metrics_addon = require_native_metrics_addon();
+    var require_builtins_device_history_device_history_addon = require_device_history_addon();
     var require_builtins_sqlite_storage_filesystem_storage_addon = require_filesystem_storage_addon();
-    var require_wal_maintenance = require_wal_maintenance_CuG1DUca();
+    var require_wal_maintenance = require_wal_maintenance_mwCBe3Vr();
     var require_builtins_sqlite_storage_sqlite_settings_addon = require_sqlite_settings_addon();
     var require_builtins_sqlite_storage_index = require_sqlite_storage();
     var require_builtins_storage_orchestrator_storage_orchestrator_addon = require_storage_orchestrator_addon();
     require_storage_orchestrator();
-    var require_constants15 = require_constants_DA_tjzIk();
-    var require_agent_https = require_agent_https_5DYAOJMO();
+    var require_constants15 = require_constants_BPWA_r_Y();
+    var require_agent_https = require_agent_https_CMz4S56();
     var require_builtins_system_config_system_config_addon = require_system_config_addon();
     require_system_config();
     var require_builtins_winston_logging_index = require_winston_logging();
     var require_custom_action_registry = require_custom_action_registry_COyb49zm();
-    var require_hub_mdns_ciao = require_hub_mdns_ciao_m5LIr4oA();
+    var require_hub_mdns_ciao = require_hub_mdns_ciao_DAU1WttG();
     var require_platform_key_source = require_platform_key_source_Di7HrlGR();
     var require_resource_monitor = require_resource_monitor_mio9dSCT();
-    var require_restore_archive = require_restore_archive_B57xI5Ue();
+    var require_restore_archive = require_restore_archive_Cprdh3P9();
     var zod = require_zod();
     var node_crypto = __require("crypto");
     node_crypto = require_chunk.__toESM(node_crypto);
@@ -312707,6 +315198,7 @@ var require_dist3 = __commonJS({
     exports.DataPlaneRegistry = DataPlaneRegistry;
     exports.DeviceCaStore = require_builtins_local_auth_local_auth_addon.DeviceCaStore;
     exports.DeviceCredentialManager = require_builtins_local_auth_local_auth_addon.DeviceCredentialManager;
+    exports.DeviceHistoryAddon = require_builtins_device_history_device_history_addon.DeviceHistoryAddon;
     exports.DeviceManagerAddon = require_builtins_device_manager_device_manager_addon.DeviceManagerAddon;
     exports.DeviceRegistry = DeviceRegistry;
     exports.DeviceStore = require_builtins_sqlite_storage_index.DeviceStore$1;