rigscope 0.1.8 → 0.2.1

package/dist/ops.cjs

@@ -35,6 +35,7 @@ __export(main_exports, {
 });
 module.exports = __toCommonJS(main_exports);
 var import_node_util = require("node:util");
+var import_node_path8 = require("node:path");
 
 // src/operations/database.ts
 var import_node_fs3 = require("node:fs");
@@ -50,8 +51,17 @@ var import_node_path = require("node:path");
 var import_node_sqlite = require("node:sqlite");
 var sqlite = __toESM(require("node:sqlite"));
 
+// src/contracts/telemetry.ts
+var MAX_CORES = 1024;
+var MIN_EPOCH = Date.parse("2000-01-01T00:00:00Z");
+var MAX_EPOCH = Date.parse("2200-01-01T00:00:00Z");
+
 // src/hub/config.ts
 var MAX_HUB_COLLECTORS_BYTES = 1024 * 1024;
+var DEFAULT_MEMORY_BUDGET_BYTES = 128 * 1024 * 1024;
+var DEFAULT_RECORDING_MAX_DURATION_MS = 60 * 6e4;
+var DEFAULT_RECORDING_MAX_BYTES = 64 * 1024 * 1024;
+var DEFAULT_RECORDING_BACKLOG_MS = 10 * 6e4;
 
 // src/hub/auth/password.ts
 var import_node_crypto = require("node:crypto");
@@ -418,8 +428,45 @@ var MIGRATIONS = [
   },
   { version: 3, name: "admin", up: adminSchema },
   { version: 4, name: "alerts", up: installAlertSchema },
-  { version: 5, name: "collector_registry", up: installRegistrySchema }
+  { version: 5, name: "collector_registry", up: installRegistrySchema },
+  { version: 6, name: "telemetry_modes_and_recordings", up: telemetryModesAndRecordings }
 ];
+function telemetryModesAndRecordings(db) {
+  db.exec(`
+    CREATE TABLE IF NOT EXISTS points_10s (
+      series_id INTEGER NOT NULL,
+      bucket_ms INTEGER NOT NULL,
+      min REAL,
+      max REAL,
+      sum REAL NOT NULL DEFAULT 0,
+      count INTEGER NOT NULL DEFAULT 0,
+      null_count INTEGER NOT NULL DEFAULT 0,
+      PRIMARY KEY (series_id, bucket_ms)
+    ) WITHOUT ROWID;
+
+    CREATE TABLE IF NOT EXISTS recordings (
+      id TEXT PRIMARY KEY,
+      created_by TEXT NOT NULL,
+      status TEXT NOT NULL,
+      machines_json TEXT NOT NULL,
+      metrics_json TEXT NOT NULL,
+      resolution_ms INTEGER NOT NULL,
+      created_at_ms INTEGER NOT NULL,
+      started_at_ms INTEGER NOT NULL,
+      stopped_at_ms INTEGER,
+      deadline_ms INTEGER NOT NULL,
+      max_bytes INTEGER NOT NULL,
+      bytes_written INTEGER NOT NULL DEFAULT 0,
+      file_name TEXT NOT NULL,
+      include_backlog INTEGER NOT NULL DEFAULT 0,
+      reason TEXT,
+      error TEXT
+    );
+
+    CREATE INDEX IF NOT EXISTS recordings_created
+      ON recordings (created_at_ms DESC);
+  `);
+}
 
 // src/hub/storage/db.ts
 var BUSY_TIMEOUT_MS = 5e3;
@@ -496,7 +543,7 @@ var SqliteHubDatabase = class {
     const walBudgetBytes = Math.max(64 * 1024, Math.min(HUB_WAL_RESERVE_BYTES, Math.floor(limitBytes / 16)));
     const mainBudgetBytes = Math.max(pageSize, limitBytes - walBudgetBytes);
     const requestedPages = Math.max(1, Math.floor(mainBudgetBytes / pageSize));
-    const checkpointPages = Math.max(16, Math.min(1e3, Math.floor(walBudgetBytes / pageSize)));
+    const checkpointPages = Math.max(16, Math.min(16384, Math.floor(walBudgetBytes / pageSize)));
     this.db.exec(`PRAGMA journal_size_limit = ${walBudgetBytes}`);
     this.db.exec(`PRAGMA wal_autocheckpoint = ${checkpointPages}`);
     let maxPageCount = requestedPages;
@@ -1035,7 +1082,9 @@ var COUNTED_TABLES = /* @__PURE__ */ new Set([
   "machine_meta",
   "machine_latest",
   "inventory",
+  "points_10s",
   "gaps",
+  "recordings",
   "alert_rules",
   "alert_incidents",
   "alert_jobs",
@@ -1505,6 +1554,63 @@ async function migrateDatabase(options, now = options.now ?? Date.now) {
     integrity: after.integrity
   };
 }
+function resetTelemetryHistory(options) {
+  const database = resolvePath(options.database, "database");
+  assertPrivateRegularFile(database, "database");
+  if (!options.confirmStopped) {
+    throw new OperationsError(
+      "confirmation-required",
+      "resetting telemetry history requires --confirm-stopped after the hub is stopped"
+    );
+  }
+  assertNoActiveHubLock(database);
+  const db = openHubDatabase(database);
+  const tables = [
+    "points_raw",
+    "points_10s",
+    "points_1m",
+    "points_1h",
+    "sample_receipts",
+    "gaps",
+    "machine_latest",
+    "series"
+  ];
+  const deleted = {};
+  try {
+    db.db.exec("BEGIN IMMEDIATE");
+    try {
+      for (const table of tables) {
+        const result = db.db.prepare(`DELETE FROM ${table}`).run();
+        deleted[table] = Number(result.changes);
+      }
+      db.db.exec("COMMIT");
+    } catch (error) {
+      try {
+        db.db.exec("ROLLBACK");
+      } catch {
+      }
+      throw error;
+    }
+    db.reclaimPages(1024);
+    db.checkpoint();
+  } finally {
+    db.close();
+  }
+  const info = inspectDatabase(database);
+  return {
+    database,
+    deleted,
+    integrity: info.integrity,
+    preserved: [
+      "users",
+      "collector registry/grants/audit",
+      "alert rules/incidents/jobs/webhook",
+      "machine metadata",
+      "inventory",
+      "recordings"
+    ]
+  };
+}
 function schemaVersionOf(database) {
   if (!(0, import_node_fs3.existsSync)(database)) return null;
   const info = inspectDatabase(database);
@@ -3051,27 +3157,29 @@ var HOUR_MS = 36e5;
 var DAY_MS = 24 * HOUR_MS;
 var DEFAULT_RETENTION_POLICY = {
   rawMs: 2 * DAY_MS,
+  tenSecondMs: 2 * HOUR_MS,
   oneMinuteMs: 30 * DAY_MS,
   oneHourMs: 400 * DAY_MS,
-  receiptsMs: 2 * DAY_MS,
+  receiptsMs: 7 * DAY_MS,
   gapsMs: 400 * DAY_MS
 };
 function resolveRetentionPolicy(partial) {
   const rawMs = checkedMs(partial?.rawMs, DEFAULT_RETENTION_POLICY.rawMs, "rawMs");
+  const tenSecondMs = checkedMs(partial?.tenSecondMs, DEFAULT_RETENTION_POLICY.tenSecondMs, "tenSecondMs");
   const oneMinuteMs = checkedMs(partial?.oneMinuteMs, DEFAULT_RETENTION_POLICY.oneMinuteMs, "oneMinuteMs");
   const oneHourMs = checkedMs(partial?.oneHourMs, DEFAULT_RETENTION_POLICY.oneHourMs, "oneHourMs");
-  const receiptsDefault = partial?.rawMs !== void 0 ? rawMs : DEFAULT_RETENTION_POLICY.receiptsMs;
-  const gapsDefault = partial?.oneHourMs !== void 0 ? oneHourMs : DEFAULT_RETENTION_POLICY.gapsMs;
   return {
     rawMs,
+    tenSecondMs,
     oneMinuteMs,
     oneHourMs,
-    receiptsMs: checkedMs(partial?.receiptsMs, receiptsDefault, "receiptsMs"),
-    gapsMs: checkedMs(partial?.gapsMs, gapsDefault, "gapsMs")
+    receiptsMs: checkedMs(partial?.receiptsMs, DEFAULT_RETENTION_POLICY.receiptsMs, "receiptsMs"),
+    gapsMs: checkedMs(partial?.gapsMs, DEFAULT_RETENTION_POLICY.gapsMs, "gapsMs")
   };
 }
 var RETENTION_DELETE_SQL = {
   raw: "DELETE FROM points_raw WHERE (series_id, ts_ms) IN (SELECT series_id, ts_ms FROM points_raw WHERE series_id = ? AND ts_ms < ? LIMIT ?)",
+  tenSecond: "DELETE FROM points_10s WHERE (series_id, bucket_ms) IN (SELECT series_id, bucket_ms FROM points_10s WHERE series_id = ? AND bucket_ms < ? LIMIT ?)",
   oneMinute: "DELETE FROM points_1m WHERE (series_id, bucket_ms) IN (SELECT series_id, bucket_ms FROM points_1m WHERE series_id = ? AND bucket_ms < ? LIMIT ?)",
   oneHour: "DELETE FROM points_1h WHERE (series_id, bucket_ms) IN (SELECT series_id, bucket_ms FROM points_1h WHERE series_id = ? AND bucket_ms < ? LIMIT ?)"
 };
@@ -3098,6 +3206,7 @@ var RetentionManager = class {
     walBytes: 0
   };
   deleteRaw;
+  delete10s;
   delete1m;
   delete1h;
   deleteReceipts;
@@ -3126,6 +3235,7 @@ var RetentionManager = class {
     this.chunkSize = positiveInt(options.chunkSize, 5e3, "chunkSize");
     this.maxChunksPerPass = positiveInt(options.maxChunksPerPass, 1e4, "maxChunksPerPass");
     this.deleteRaw = database.db.prepare(RETENTION_DELETE_SQL.raw);
+    this.delete10s = database.db.prepare(RETENTION_DELETE_SQL.tenSecond);
     this.delete1m = database.db.prepare(RETENTION_DELETE_SQL.oneMinute);
     this.delete1h = database.db.prepare(RETENTION_DELETE_SQL.oneHour);
     this.deleteReceipts = database.db.prepare(
@@ -3161,7 +3271,7 @@ var RetentionManager = class {
   }
   /**
    * Synchronous, bounded pressure relief for the write path. Deletes only
-   * oldest raw/one-minute rows outside the most-recent-hour floor, then asks
+   * oldest raw/ten-second/one-minute rows outside the most-recent-hour floor, then asks
    * SQLite for bounded incremental reclaim. It never deletes one-hour rollups
    * to pretend a hard cap fits.
    */
@@ -3191,6 +3301,9 @@ var RetentionManager = class {
     const rawCutoff = nowMs - this.policy.rawMs;
     const seriesIds = this.seriesIds();
     let deleted = this.deleteTierChunk(this.deleteRaw, seriesIds, rawCutoff);
+    if (deleted === 0) {
+      deleted = this.deleteTierChunk(this.delete10s, seriesIds, nowMs - this.policy.tenSecondMs);
+    }
     if (deleted === 0) {
       deleted = this.deleteTierChunk(this.delete1m, seriesIds, nowMs - this.policy.oneMinuteMs);
     }
@@ -3204,6 +3317,7 @@ var RetentionManager = class {
       const floorCutoff = nowMs - HOUR_MS;
       effectiveRawCutoff = Math.max(rawCutoff, floorCutoff);
       deleted = this.deleteTierChunk(this.deleteRaw, seriesIds, effectiveRawCutoff);
+      if (deleted === 0) deleted = this.deleteTierChunk(this.delete10s, seriesIds, floorCutoff);
       if (deleted === 0) deleted = this.deleteTierChunk(this.delete1m, seriesIds, floorCutoff);
       if (deleted > 0) {
         this.db.reclaimPages(64);
@@ -3291,7 +3405,7 @@ var RetentionManager = class {
   }
 };
 function yieldToEventLoop() {
-  return new Promise((resolve6) => setImmediate(resolve6));
+  return new Promise((resolve7) => setImmediate(resolve7));
 }
 function checkedMs(value, fallback, name) {
   const resolved = value ?? fallback;
@@ -3554,958 +3668,1097 @@ function seriesKey(machineId, metric, resourceId) {
   return `${machineId}\0${metric}\0${resourceId}`;
 }
 
-// src/hub/storage/telemetry-store.ts
+// src/contracts/index.ts
+var MIN_TIMESTAMP_EPOCH = Date.parse("2000-01-01T00:00:00Z");
+var MAX_TIMESTAMP_EPOCH = Date.parse("2200-01-01T00:00:00Z");
+
+// src/hub/storage/history-query.ts
 var DAY_MS2 = 864e5;
-var FUTURE_TOLERANCE_MS = DAY_MS2;
-var FAILURE_RETRY_MS = 5e3;
-var MIN_DERIVED_PHYSICAL_BYTES = 8 * 1024 * 1024;
-var TelemetryStore = class {
-  database;
-  now;
-  maxQueuedRecords;
-  flushIntervalMs;
-  maxRecordsPerTransaction;
-  maxPhysicalBytes;
-  series;
-  retention;
-  queue = [];
-  timer = null;
-  driver = null;
-  closed = false;
-  committedRecords = 0;
-  duplicateRecords = 0;
-  rejectedRecords = 0;
-  writeFailures = 0;
-  diskFullFailures = 0;
-  lastWriteError = null;
-  lastFlushMs = null;
-  lastFlushDurationMs = null;
-  receiptInsert;
-  rawInsert;
-  upsert1m;
-  upsert1h;
-  gapInsert;
-  latestSelect;
-  latestUpsert;
-  inventoryUpsert;
-  inventorySelect;
-  metaUpsertBoth;
-  metaUpsertDisplay;
-  metaUpsertTags;
-  metaTouch;
-  metaSelect;
-  metaSelectAll;
-  latestSelectAll;
-  constructor(options) {
-    this.database = options.database;
-    this.now = options.now ?? (() => Date.now());
-    this.maxQueuedRecords = positiveInt2(options.maxQueuedRecords, 4096, "maxQueuedRecords");
-    this.flushIntervalMs = nonnegativeInt(options.flushIntervalMs, 20, "flushIntervalMs");
-    this.maxRecordsPerTransaction = positiveInt2(
-      options.maxRecordsPerTransaction,
-      512,
-      "maxRecordsPerTransaction"
-    );
-    this.maxPhysicalBytes = resolvePhysicalLimit(options);
-    const db = options.database.db;
-    this.series = new SeriesCatalog(db);
-    this.receiptInsert = db.prepare(
-      "INSERT OR IGNORE INTO sample_receipts (collector_id, run_id, seq, machine_id, kind, mode, captured_at_ms, received_at_ms, expected_interval_ms) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?)"
-    );
-    this.rawInsert = db.prepare(
-      "INSERT OR IGNORE INTO points_raw (series_id, ts_ms, value) VALUES (?, ?, ?)"
-    );
-    this.upsert1m = prepareRollupUpsert(db, "points_1m");
-    this.upsert1h = prepareRollupUpsert(db, "points_1h");
-    this.gapInsert = db.prepare(
-      "INSERT OR IGNORE INTO gaps (collector_id, run_id, seq, machine_id, from_ms, to_ms, dropped, reason, received_at_ms) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?)"
-    );
-    this.latestSelect = db.prepare(
-      "SELECT run_id, seq, captured_at_ms FROM machine_latest WHERE machine_id = ?"
-    );
-    this.latestUpsert = db.prepare(
-      "INSERT INTO machine_latest (machine_id, collector_id, run_id, boot_id, seq, captured_at_ms, received_at_ms, expected_interval_ms, hostname, payload_json) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?) ON CONFLICT(machine_id) DO UPDATE SET collector_id = excluded.collector_id, run_id = excluded.run_id, boot_id = excluded.boot_id, seq = excluded.seq, captured_at_ms = excluded.captured_at_ms, received_at_ms = excluded.received_at_ms, expected_interval_ms = COALESCE(excluded.expected_interval_ms, expected_interval_ms), hostname = COALESCE(excluded.hostname, hostname), payload_json = excluded.payload_json"
-    );
-    this.latestSelectAll = db.prepare(
-      "SELECT machine_id, collector_id, run_id, boot_id, seq, captured_at_ms, received_at_ms, expected_interval_ms, hostname, payload_json FROM machine_latest ORDER BY machine_id"
-    );
-    this.inventoryUpsert = db.prepare(
-      "INSERT INTO inventory (machine_id, captured_at_ms, received_at_ms, inventory_json) VALUES (?, ?, ?, ?) ON CONFLICT(machine_id) DO UPDATE SET captured_at_ms = excluded.captured_at_ms, received_at_ms = excluded.received_at_ms, inventory_json = excluded.inventory_json"
-    );
-    this.inventorySelect = db.prepare(
-      "SELECT captured_at_ms, received_at_ms, inventory_json FROM inventory WHERE machine_id = ?"
-    );
-    this.metaUpsertBoth = db.prepare(
-      "INSERT INTO machine_meta (machine_id, display_name, tags_json, updated_at_ms) VALUES (?, ?, ?, ?) ON CONFLICT(machine_id) DO UPDATE SET display_name = excluded.display_name, tags_json = excluded.tags_json, updated_at_ms = excluded.updated_at_ms"
-    );
-    this.metaUpsertDisplay = db.prepare(
-      "INSERT INTO machine_meta (machine_id, display_name, tags_json, updated_at_ms) VALUES (?, ?, '[]', ?) ON CONFLICT(machine_id) DO UPDATE SET display_name = excluded.display_name, updated_at_ms = excluded.updated_at_ms"
-    );
-    this.metaUpsertTags = db.prepare(
-      "INSERT INTO machine_meta (machine_id, display_name, tags_json, updated_at_ms) VALUES (?, NULL, ?, ?) ON CONFLICT(machine_id) DO UPDATE SET tags_json = excluded.tags_json, updated_at_ms = excluded.updated_at_ms"
-    );
-    this.metaTouch = db.prepare(
-      "INSERT INTO machine_meta (machine_id, display_name, tags_json, updated_at_ms) VALUES (?, NULL, '[]', ?) ON CONFLICT(machine_id) DO UPDATE SET updated_at_ms = excluded.updated_at_ms"
-    );
-    this.metaSelect = db.prepare(
-      "SELECT display_name, tags_json, updated_at_ms FROM machine_meta WHERE machine_id = ?"
-    );
-    this.metaSelectAll = db.prepare(
-      "SELECT machine_id, display_name, tags_json FROM machine_meta ORDER BY machine_id"
-    );
-    this.retention = new RetentionManager(options.database, {
-      policy: options.retention,
-      maxDatabaseBytes: options.maxDatabaseBytes ?? null,
-      maxPhysicalBytes: this.maxPhysicalBytes,
-      now: this.now
-    });
-    this.retention.start();
-  }
-  /**
-   * Queues one batch. The promise resolves only after the transaction that
-   * writes it has committed, or immediately as `busy` when the bounded queue
-   * cannot hold it (no database work is done in that case).
-   */
-  enqueue(batch) {
-    return new Promise((resolve6) => {
-      if (this.closed) {
-        resolve6({ status: "busy", retryAfterMs: FAILURE_RETRY_MS, reason: "storage is closed" });
-        return;
-      }
-      validateBatch(batch);
-      const queued = this.queuedRecords();
-      if (queued + batch.records.length > this.maxQueuedRecords) {
-        const ratio = this.maxQueuedRecords === 0 ? 1 : queued / this.maxQueuedRecords;
-        const retryAfterMs = Math.min(5e3, Math.max(1e3, Math.round(1e3 + ratio * 4e3)));
-        resolve6({ status: "busy", retryAfterMs, reason: "ingest queue is full" });
-        return;
-      }
-      this.queue.push({
-        batch,
-        receivedAtMs: this.now(),
-        resolve: resolve6,
-        settled: false,
-        accepted: [],
-        rejected: [],
-        newLive: null
-      });
-      this.scheduleFlush(this.flushIntervalMs);
-    });
-  }
-  /** Persisted latest LIVE metrics per machine, for restart recovery. */
-  latestLive() {
-    const rows = this.latestSelectAll.all();
-    return rows.map((row) => ({
-      machineId: row.machine_id,
-      collectorId: row.collector_id,
-      runId: row.run_id,
-      bootId: row.boot_id,
-      sequence: Number(row.seq),
-      capturedAt: new Date(Number(row.captured_at_ms)).toISOString(),
-      receivedAt: new Date(Number(row.received_at_ms)).toISOString(),
-      hostname: row.hostname,
-      expectedIntervalMs: row.expected_interval_ms === null ? null : Number(row.expected_interval_ms),
-      payload: JSON.parse(row.payload_json)
-    }));
+var MAX_RANGE_MS = 400 * DAY_MS2;
+var MAX_METRICS = Object.keys(METRICS).length;
+var MAX_RESOURCE_IDS = 64;
+var DEFAULT_MAX_POINTS = 600;
+var MAX_POINTS = 2e3;
+var MAX_GAPS = 500;
+var TIER_RESOLUTION_MS = { raw: 100, "10s": 1e4, "1m": 6e4, "1h": 36e5 };
+var HistoryQueryError = class extends Error {
+  code = "invalid-query";
+  constructor(message) {
+    super(message);
+    this.name = "HistoryQueryError";
   }
-  saveInventory(machineId, capturedAt, inventory) {
-    const capturedMs = Date.parse(capturedAt);
-    if (!Number.isFinite(capturedMs)) throw new Error("inventory capturedAt must be a parseable timestamp");
-    this.inventoryUpsert.run(machineId, capturedMs, this.now(), JSON.stringify(inventory));
+};
+var DEFAULT_TIERS = ["raw", "10s", "1m", "1h"];
+function queryHistory(db, q, budget = {}) {
+  const started = performance.now();
+  const maxPoints = validatedMaxPoints(q.maxPoints);
+  const maxSeries = validatedBudget(budget.maxSeries, 64, "maxSeries");
+  const maxRowsScanned = validatedBudget(budget.maxRowsScanned, 25e4, "maxRowsScanned");
+  const maxElapsedMs = validatedBudget(budget.maxElapsedMs, 5e3, "maxElapsedMs");
+  const retention = resolveRetentionPolicy(budget.retention);
+  validatedQuery(q);
+  const rangeMs = q.toMs - q.fromMs;
+  const nowMs = budget.nowMs ?? Date.now();
+  let allSeries = loadSeries(db, q);
+  let truncated = false;
+  if (allSeries.length > maxSeries) {
+    allSeries = allSeries.slice(0, maxSeries);
+    truncated = true;
   }
-  loadInventory(machineId) {
-    const row = this.inventorySelect.get(machineId);
-    if (!row) return null;
-    return {
-      capturedAt: new Date(Number(row.captured_at_ms)).toISOString(),
-      receivedAt: new Date(Number(row.received_at_ms)).toISOString(),
-      inventory: JSON.parse(row.inventory_json)
-    };
+  const chosen = chooseTier(
+    db,
+    allSeries.map((row) => Number(row.series_id)),
+    q.fromMs,
+    q.toMs,
+    nowMs,
+    retention,
+    budget.tiers,
+    maxRowsScanned,
+    maxElapsedMs,
+    started
+  );
+  if (chosen.timeExceeded || chosen.overBudget) truncated = true;
+  let seriesRows = allSeries;
+  if (chosen.cutSeries < seriesRows.length) {
+    seriesRows = seriesRows.slice(0, Math.max(0, chosen.cutSeries));
+    truncated = true;
   }
-  /**
-   * Merges presentation metadata. Omitted fields are preserved; an explicit
-   * `displayName: null` clears it.
-   */
-  setMachineMeta(machineId, meta) {
-    const updatedAt = this.now();
-    const hasDisplay = meta.displayName !== void 0;
-    const hasTags = meta.tags !== void 0;
-    const displayName = meta.displayName ?? null;
-    const tags = hasTags ? validateTags(meta.tags) : [];
-    if (hasDisplay && hasTags) {
-      this.metaUpsertBoth.run(machineId, displayName, JSON.stringify(tags), updatedAt);
-    } else if (hasDisplay) {
-      this.metaUpsertDisplay.run(machineId, displayName, updatedAt);
-    } else if (hasTags) {
-      this.metaUpsertTags.run(machineId, JSON.stringify(tags), updatedAt);
-    } else {
-      this.metaTouch.run(machineId, updatedAt);
+  const stepMs = Math.max(1, Math.ceil(rangeMs / maxPoints / chosen.resolutionMs)) * chosen.resolutionMs;
+  const originMs = Math.floor(q.fromMs / stepMs) * stepMs;
+  const series = [];
+  for (const row of seriesRows) {
+    if (performance.now() - started > maxElapsedMs) {
+      truncated = true;
+      break;
     }
+    const metric = row.metric;
+    const definition = METRICS[metric];
+    if (!definition) continue;
+    const points = readSeries(
+      db,
+      chosen.tier,
+      Number(row.series_id),
+      fromBucketMs(chosen.tier, q.fromMs),
+      q.toMs,
+      originMs,
+      stepMs,
+      // An additional per-series guard. Tier selection already keeps the total
+      // under budget; this makes a single query bounded even if a custom
+      // retention policy forces the coarse fallback.
+      maxRowsScanned
+    );
+    if (points.length === 0) continue;
+    series.push({ metric: row.metric, resourceId: row.resource_id, unit: definition.unit, points });
   }
-  getMachineMeta(machineId) {
-    const row = this.metaSelect.get(machineId);
-    if (!row) return { displayName: null, tags: [] };
-    return { displayName: row.display_name, tags: parseTags(row.tags_json) };
+  const gaps = readGaps(db, q.machineId, q.fromMs, q.toMs);
+  return {
+    machineId: q.machineId,
+    fromMs: q.fromMs,
+    toMs: q.toMs,
+    stepMs,
+    tier: chosen.tier,
+    series,
+    gaps,
+    truncated,
+    elapsedMs: Math.max(0, Math.round(performance.now() - started))
+  };
+}
+function loadSeries(db, q) {
+  const placeholders = q.metrics.map(() => "?").join(", ");
+  const params = [q.machineId, ...q.metrics];
+  let sql = `SELECT series_id, metric, resource_id FROM series WHERE machine_id = ? AND metric IN (${placeholders})`;
+  if (q.resourceIds && q.resourceIds.length > 0) {
+    sql += ` AND resource_id IN (${q.resourceIds.map(() => "?").join(", ")})`;
+    params.push(...q.resourceIds);
   }
-  listMachineMeta() {
-    const rows = this.metaSelectAll.all();
-    const result = /* @__PURE__ */ new Map();
-    for (const row of rows) {
-      result.set(row.machine_id, {
-        displayName: row.display_name,
-        tags: parseTags(row.tags_json)
-      });
+  if (q.coreIds !== void 0) {
+    if (q.coreIds.length === 0) sql += " AND metric <> 'cpu.core'";
+    else {
+      sql += ` AND (metric <> 'cpu.core' OR resource_id IN (${q.coreIds.map(() => "?").join(", ")}))`;
+      params.push(...q.coreIds);
     }
-    return result;
-  }
-  stats() {
-    return {
-      queuedRecords: this.queuedRecords(),
-      queuedBatches: this.queue.length,
-      lastFlushMs: this.lastFlushMs,
-      lastFlushDurationMs: this.lastFlushDurationMs,
-      committedRecords: this.committedRecords,
-      duplicateRecords: this.duplicateRecords,
-      rejectedRecords: this.rejectedRecords,
-      writeFailures: this.writeFailures,
-      lastWriteError: this.lastWriteError,
-      diskFullFailures: this.diskFullFailures,
-      dbBytes: this.database.sizeBytes(),
-      dbWalBytes: this.database.walBytes(),
-      dbBytesLimit: this.maxPhysicalBytes,
-      retention: this.retention.status()
-    };
   }
-  /** Drains the queue immediately; intended for tests and shutdown. */
-  async flushNow() {
-    if (this.closed) return;
-    if (this.timer !== null) {
-      clearTimeout(this.timer);
-      this.timer = null;
-    }
-    await this.drive();
-    while (!this.closed && this.queue.length > 0 && this.driver === null) {
-      const failures = this.writeFailures;
-      await this.drive();
-      if (this.writeFailures > failures) break;
-    }
+  sql += " ORDER BY metric, resource_id";
+  return db.db.prepare(sql).all(...params);
+}
+var TIER_CANDIDATES = [
+  { tier: "raw", resolutionMs: TIER_RESOLUTION_MS.raw, retentionMs: 0 },
+  { tier: "10s", resolutionMs: TIER_RESOLUTION_MS["10s"], retentionMs: 0 },
+  { tier: "1m", resolutionMs: TIER_RESOLUTION_MS["1m"], retentionMs: 0 },
+  { tier: "1h", resolutionMs: TIER_RESOLUTION_MS["1h"], retentionMs: 0 }
+];
+function chooseTier(db, seriesIds, fromMs, toMs, nowMs, retention, tiers, maxRowsScanned, maxElapsedMs, started) {
+  const allowed = new Set(
+    (tiers ?? DEFAULT_TIERS).filter((tier) => tier !== "1s")
+  );
+  const candidates = TIER_CANDIDATES.filter(
+    (candidate) => allowed.has(candidate.tier)
+  ).map((candidate) => ({
+    ...candidate,
+    retentionMs: candidate.tier === "raw" ? retention.rawMs : candidate.tier === "10s" ? retention.tenSecondMs : candidate.tier === "1m" ? retention.oneMinuteMs : retention.oneHourMs
+  }));
+  if (candidates.length === 0) {
+    throw new HistoryQueryError("no history storage tiers are available");
   }
-  /**
-   * Drains for up to ~2s, then resolves anything left as busy and closes the
-   * database. Batches that were already committed have resolved normally.
-   */
-  async close() {
-    if (this.closed) return;
-    this.closed = true;
-    this.retention.stop();
-    if (this.timer !== null) {
-      clearTimeout(this.timer);
-      this.timer = null;
+  const available = candidates.filter((candidate) => fromMs >= nowMs - candidate.retentionMs);
+  const pool = available.length > 0 ? available : [candidates[candidates.length - 1]];
+  let timeExceeded = false;
+  for (const candidate of pool) {
+    if (performance.now() - started > maxElapsedMs) {
+      timeExceeded = true;
+      break;
     }
-    if (this.driver !== null) {
-      try {
-        await this.driver;
-      } catch {
-      }
+    const rows = countRowsBounded(
+      db,
+      candidate.tier,
+      seriesIds,
+      fromBucketMs(candidate.tier, fromMs),
+      toMs,
+      maxRowsScanned
+    );
+    if (rows <= maxRowsScanned) {
+      if (rows === 0 && candidate !== pool[pool.length - 1]) continue;
+      return {
+        tier: candidate.tier,
+        resolutionMs: candidate.resolutionMs,
+        cutSeries: seriesIds.length,
+        timeExceeded,
+        overBudget: false
+      };
     }
-    const deadline = Date.now() + 2e3;
-    while (this.queue.length > 0 && Date.now() < deadline) {
-      const ok = this.flushTransaction();
-      if (!ok) break;
-      if (this.queue.length > 0) await yieldToEventLoop2();
+    if (performance.now() - started > maxElapsedMs) {
+      timeExceeded = true;
+      break;
     }
-    while (this.queue.length > 0) {
-      const pending = this.queue.shift();
-      this.resolveBusy(pending, FAILURE_RETRY_MS, "storage is shutting down");
+  }
+  const fallback = pool[pool.length - 1];
+  let cut = seriesIds.length;
+  let fits = seriesIds.length === 0;
+  if (timeExceeded) cut = Math.max(1, Math.floor(cut / 2));
+  while (!fits && cut >= 1) {
+    if (performance.now() - started > maxElapsedMs) {
+      timeExceeded = true;
+      break;
     }
-    try {
-      this.database.close();
-    } catch {
+    const rows = countRowsBounded(
+      db,
+      fallback.tier,
+      seriesIds.slice(0, cut),
+      fromBucketMs(fallback.tier, fromMs),
+      toMs,
+      maxRowsScanned
+    );
+    if (rows <= maxRowsScanned) {
+      fits = true;
+      break;
     }
+    if (cut === 1) break;
+    cut = Math.max(1, Math.floor(cut / 2));
   }
-  queuedRecords() {
-    let total = 0;
-    for (const pending of this.queue) total += pending.batch.records.length;
-    return total;
-  }
-  scheduleFlush(delayMs) {
-    if (this.closed || this.timer !== null || this.driver !== null) return;
-    this.timer = setTimeout(() => {
-      this.timer = null;
-      void this.drive();
-    }, delayMs);
-    this.timer.unref?.();
-  }
-  drive() {
-    if (this.driver !== null) return this.driver;
-    const promise = this.runDriver().finally(() => {
-      if (this.driver === promise) this.driver = null;
-      if (!this.closed && this.queue.length > 0 && this.timer === null) {
-        this.scheduleFlush(FAILURE_RETRY_MS);
-      }
-    });
-    this.driver = promise;
-    return promise;
-  }
-  async runDriver() {
-    while (!this.closed && this.queue.length > 0) {
-      const ok = this.flushTransaction();
-      if (!ok) return;
-      if (this.queue.length > 0) await yieldToEventLoop2();
-    }
+  return {
+    tier: fallback.tier,
+    resolutionMs: fallback.resolutionMs,
+    cutSeries: Math.max(1, Math.min(cut, seriesIds.length)),
+    timeExceeded,
+    overBudget: !fits
+  };
+}
+function countRowsBounded(db, tier, seriesIds, fromMs, toMs, budget) {
+  if (seriesIds.length === 0) return 0;
+  const column = tier === "raw" ? "ts_ms" : "bucket_ms";
+  const table = tableForTier(tier);
+  const statement = db.db.prepare(
+    `SELECT COUNT(*) AS n FROM (SELECT 1 FROM ${table} WHERE series_id = ? AND ${column} >= ? AND ${column} <= ? LIMIT ?)`
+  );
+  let total = 0;
+  for (const seriesId of seriesIds) {
+    const remaining = budget + 1 - total;
+    if (remaining <= 0) return total;
+    const row = statement.get(seriesId, fromMs, toMs, remaining);
+    total += Number(row?.n ?? 0);
+    if (total > budget) return total;
   }
-  /**
-   * Commits the front of the queue as one transaction. Returns false when the
-   * transaction failed; every batch in it has then been resolved as busy.
-   */
-  flushTransaction() {
-    if (this.queue.length === 0) return true;
-    const selected = [];
-    let recordCount = 0;
-    for (const pending of this.queue) {
-      const size = pending.batch.records.length;
-      if (selected.length > 0 && recordCount + size > this.maxRecordsPerTransaction) break;
-      selected.push(pending);
-      recordCount += size;
-      if (recordCount >= this.maxRecordsPerTransaction) break;
-    }
-    this.queue.splice(0, selected.length);
-    if (this.maxPhysicalBytes !== null) {
-      try {
-        let physical = this.database.physicalLimit();
-        let bytes = this.database.sizeBytes();
-        const pageFull = physical !== null && physical.pageCount >= physical.maxPageCount && physical.freePages === 0;
-        if (bytes >= this.maxPhysicalBytes || pageFull) {
-          this.retention.relievePressure(4);
-          physical = this.database.physicalLimit();
-          bytes = this.database.sizeBytes();
-        }
-        const stillFull = physical !== null && physical.pageCount >= physical.maxPageCount && physical.freePages === 0;
-        if (bytes >= this.maxPhysicalBytes || stillFull) {
-          this.diskFullFailures += 1;
-          this.lastWriteError = "storage disk budget reached";
-          for (const pending of selected) {
-            this.resolveBusy(pending, FAILURE_RETRY_MS, "storage disk budget reached");
-          }
-          return false;
-        }
-      } catch (error) {
-        const full = isStorageFullError(error);
-        if (full) this.diskFullFailures += 1;
-        this.lastWriteError = full ? "storage disk budget reached" : sanitizeWriteError(error);
-        for (const pending of selected) {
-          this.resolveBusy(
-            pending,
-            FAILURE_RETRY_MS,
-            full ? "storage disk budget reached" : "storage write failed"
-          );
-        }
-        return false;
-      }
-    }
-    const started = import_node_perf_hooks.performance.now();
-    const counters = { committed: 0, duplicates: 0, rejected: 0 };
-    const cursors = /* @__PURE__ */ new Map();
-    const upserts = /* @__PURE__ */ new Map();
-    try {
-      this.database.db.exec("BEGIN IMMEDIATE");
-      for (const pending of selected) {
-        this.processBatch(pending, counters, cursors, upserts);
-      }
-      for (const [machineId, live] of upserts) {
-        this.latestUpsert.run(
-          machineId,
-          live.record.collectorId,
-          live.record.runId,
-          live.record.bootId,
-          live.record.sequence,
-          Date.parse(live.record.capturedAt),
-          live.receivedAtMs,
-          live.expectedIntervalMs,
-          live.hostname,
-          JSON.stringify(live.record.payload)
-        );
-      }
-      this.database.db.exec("COMMIT");
-    } catch (error) {
-      try {
-        this.database.db.exec("ROLLBACK");
-      } catch {
-      }
-      this.writeFailures += 1;
-      const full = isStorageFullError(error);
-      if (full) this.diskFullFailures += 1;
-      this.lastWriteError = full ? "storage disk budget reached" : sanitizeWriteError(error);
-      for (const pending of selected) {
-        this.resolveBusy(
-          pending,
-          FAILURE_RETRY_MS,
-          full ? "storage disk budget reached" : "storage write failed"
-        );
-      }
-      return false;
-    }
-    this.committedRecords += counters.committed;
-    this.duplicateRecords += counters.duplicates;
-    this.rejectedRecords += counters.rejected;
-    this.lastFlushMs = this.now();
-    this.lastFlushDurationMs = Math.max(0, Math.round(import_node_perf_hooks.performance.now() - started));
-    this.checkpointWALIfNeeded();
-    if (this.maxPhysicalBytes !== null && this.database.sizeBytes() > this.maxPhysicalBytes) {
-      try {
-        this.retention.relievePressure(4);
-      } catch {
-      }
-    }
-    for (const pending of selected) this.resolveCommitted(pending);
-    return true;
-  }
-  checkpointWALIfNeeded() {
-    if (this.maxPhysicalBytes === null) return;
-    try {
-      const physical = this.database.physicalLimit();
-      if (physical !== null && this.database.walBytes() > physical.walBudgetBytes) {
-        this.database.checkpoint();
-      }
-    } catch {
-    }
-  }
-  processBatch(pending, counters, cursors, upserts) {
-    const batch = pending.batch;
-    let best = null;
-    let bestCapturedMs = 0;
-    let bestSequence = -1;
-    for (const record of batch.records) {
-      const ref = { runId: record.runId, sequence: record.sequence };
-      const reason = rejectionReason(record, batch, pending.receivedAtMs);
-      if (reason !== null) {
-        pending.rejected.push({ ...ref, reason });
-        counters.rejected += 1;
-        continue;
-      }
-      const capturedMs = Date.parse(record.capturedAt);
-      const inserted = Number(
-        this.receiptInsert.run(
-          batch.collectorId,
-          record.runId,
-          record.sequence,
-          batch.machineId,
-          record.kind,
-          batch.mode,
-          capturedMs,
-          pending.receivedAtMs,
-          batch.expectedIntervalMs
-        ).changes
-      ) === 1;
-      if (!inserted) {
-        pending.accepted.push(ref);
-        counters.duplicates += 1;
-        continue;
-      }
-      pending.accepted.push(ref);
-      counters.committed += 1;
-      if (record.kind === "metrics") {
-        const known = needsKnownSeries(record.payload) ? this.series.knownFor(batch.machineId) : void 0;
-        for (const point of flattenMetrics(record.payload, known)) {
-          const seriesId = this.series.idFor(batch.machineId, point.metric, point.resourceId);
-          this.insertPoint(seriesId, capturedMs, point.value);
-        }
-        if (batch.mode === "live") {
-          if (best === null || capturedMs > bestCapturedMs || capturedMs === bestCapturedMs && record.sequence > bestSequence) {
-            best = record;
-            bestCapturedMs = capturedMs;
-            bestSequence = record.sequence;
-          }
-        }
-      } else {
-        this.gapInsert.run(
-          batch.collectorId,
-          record.runId,
-          record.sequence,
-          batch.machineId,
-          Date.parse(record.payload.fromCapturedAt),
-          Date.parse(record.payload.toCapturedAt),
-          record.payload.droppedRecords,
-          record.payload.reason,
-          pending.receivedAtMs
-        );
-      }
-    }
-    if (batch.mode !== "live" || best === null) return;
-    const cursor = this.latestCursor(batch.machineId, cursors);
-    const candidate = {
-      runId: best.runId,
-      sequence: best.sequence,
-      capturedAtMs: bestCapturedMs
+  return total;
+}
+function readSeries(db, tier, seriesId, fromBucketMs2, toMs, originMs, stepMs, rowLimit) {
+  const statement = tier === "raw" ? db.db.prepare(
+    "SELECT ? + CAST((ts_ms - ?) / ? AS INTEGER) * ? AS bucket, MIN(value) AS min_value, MAX(value) AS max_value, SUM(value) AS sum_value, COUNT(value) AS count_value, COUNT(*) AS row_count FROM (SELECT ts_ms, value FROM points_raw WHERE series_id = ? AND ts_ms >= ? AND ts_ms <= ? ORDER BY ts_ms LIMIT ?) GROUP BY bucket ORDER BY bucket"
+  ) : db.db.prepare(
+    `SELECT ? + CAST((bucket_ms - ?) / ? AS INTEGER) * ? AS bucket, MIN(min) AS min_value, MAX(max) AS max_value, SUM(sum) AS sum_value, SUM(count) AS count_value, COUNT(*) AS row_count FROM (SELECT bucket_ms, min, max, sum, count FROM ${tableForTier(tier)} WHERE series_id = ? AND bucket_ms >= ? AND bucket_ms <= ? ORDER BY bucket_ms LIMIT ?) GROUP BY bucket ORDER BY bucket`
+  );
+  const rows = statement.all(
+    originMs,
+    originMs,
+    stepMs,
+    stepMs,
+    seriesId,
+    fromBucketMs2,
+    toMs,
+    rowLimit
+  );
+  return rows.map((row) => {
+    const count = Number(row.count_value ?? 0);
+    return {
+      t: Number(row.bucket),
+      min: row.min_value === null ? null : Number(row.min_value),
+      max: row.max_value === null ? null : Number(row.max_value),
+      avg: count > 0 && row.sum_value !== null ? Number(row.sum_value) / count : null
     };
-    if (cursor === null || isNewer(candidate, cursor)) {
-      pending.newLive = best;
-      cursors.set(batch.machineId, candidate);
-      upserts.set(batch.machineId, {
-        record: best,
-        receivedAtMs: pending.receivedAtMs,
-        expectedIntervalMs: batch.expectedIntervalMs,
-        hostname: batch.hostname ?? null
-      });
-    }
+  });
+}
+function fromBucketMs(tier, fromMs) {
+  if (tier === "raw") return fromMs;
+  const span = tier === "10s" ? 1e4 : tier === "1m" ? 6e4 : 36e5;
+  return Math.floor(fromMs / span) * span;
+}
+function tableForTier(tier) {
+  return tier === "raw" ? "points_raw" : `points_${tier}`;
+}
+function readGaps(db, machineId, fromMs, toMs) {
+  const dropped = db.db.prepare(
+    "SELECT from_ms, to_ms, dropped, reason FROM gaps WHERE machine_id = ? AND to_ms >= ? AND from_ms <= ? ORDER BY from_ms LIMIT ?"
+  ).all(machineId, fromMs, toMs, MAX_GAPS);
+  const missing = db.db.prepare(
+    "WITH before_window AS ( SELECT captured_at_ms, expected_interval_ms FROM sample_receipts WHERE machine_id = ? AND captured_at_ms < ? ORDER BY captured_at_ms DESC LIMIT 1 ), in_window AS ( SELECT captured_at_ms, expected_interval_ms FROM sample_receipts WHERE machine_id = ? AND captured_at_ms >= ? AND captured_at_ms <= ? ), ordered AS ( SELECT captured_at_ms, expected_interval_ms, LAG(captured_at_ms) OVER (ORDER BY captured_at_ms) AS prev_ms FROM (SELECT * FROM before_window UNION ALL SELECT * FROM in_window) ) SELECT MAX(prev_ms, ?) AS from_ms, captured_at_ms AS to_ms FROM ordered WHERE prev_ms IS NOT NULL AND captured_at_ms > ? AND captured_at_ms - prev_ms > MAX(15000, 3 * COALESCE(expected_interval_ms, 5000)) ORDER BY captured_at_ms LIMIT ?"
+  ).all(machineId, fromMs, machineId, fromMs, toMs, fromMs, fromMs, MAX_GAPS);
+  const gaps = [
+    ...dropped.map((row) => ({
+      fromMs: Number(row.from_ms),
+      toMs: Number(row.to_ms),
+      kind: "dropped",
+      reason: row.reason,
+      droppedRecords: Number(row.dropped)
+    })),
+    ...missing.map((row) => ({
+      fromMs: Number(row.from_ms),
+      toMs: Number(row.to_ms),
+      kind: "missing",
+      reason: "expected interval missed"
+    }))
+  ];
+  gaps.sort((a, b) => a.fromMs - b.fromMs || a.toMs - b.toMs);
+  return gaps.slice(0, MAX_GAPS);
+}
+function validatedQuery(q) {
+  if (q === null || typeof q !== "object") throw new HistoryQueryError("query must be an object");
+  if (typeof q.machineId !== "string" || q.machineId.length === 0 || q.machineId.length > 256) {
+    throw new HistoryQueryError("machineId must be a nonempty string");
   }
-  latestCursor(machineId, cache) {
-    if (cache.has(machineId)) return cache.get(machineId);
-    const row = this.latestSelect.get(machineId);
-    const cursor = row ? { runId: row.run_id, sequence: Number(row.seq), capturedAtMs: Number(row.captured_at_ms) } : null;
-    cache.set(machineId, cursor);
-    return cursor;
+  if (!Array.isArray(q.metrics) || q.metrics.length === 0 || q.metrics.length > MAX_METRICS) {
+    throw new HistoryQueryError(`metrics must contain 1..${MAX_METRICS} metric names`);
   }
-  /**
-   * Writes one raw point and incrementally updates both rollup tiers. The raw
-   * INSERT OR IGNORE guard prevents a collision (same series/timestamp) from
-   * double-counting a rollup.
-   */
-  insertPoint(seriesId, tsMs, value) {
-    if (Number(this.rawInsert.run(seriesId, tsMs, value).changes) !== 1) return;
-    const minute = Math.floor(tsMs / 6e4) * 6e4;
-    const hour = Math.floor(tsMs / 36e5) * 36e5;
-    this.applyRollup(this.upsert1m, seriesId, minute, value);
-    this.applyRollup(this.upsert1h, seriesId, hour, value);
+  const seenMetrics = /* @__PURE__ */ new Set();
+  for (const metric of q.metrics) {
+    if (typeof metric !== "string" || !Object.prototype.hasOwnProperty.call(METRICS, metric)) {
+      throw new HistoryQueryError(`unknown metric ${JSON.stringify(metric)}`);
+    }
+    if (seenMetrics.has(metric)) throw new HistoryQueryError(`duplicate metric ${JSON.stringify(metric)}`);
+    seenMetrics.add(metric);
   }
-  applyRollup(statement, seriesId, bucketMs, value) {
-    if (value === null) {
-      statement.run(seriesId, bucketMs, null, null, 0, 0, 1);
-    } else {
-      statement.run(seriesId, bucketMs, value, value, value, 1, 0);
+  if (q.resourceIds !== void 0) {
+    if (!Array.isArray(q.resourceIds) || q.resourceIds.length > MAX_RESOURCE_IDS) {
+      throw new HistoryQueryError(`resourceIds must contain at most ${MAX_RESOURCE_IDS} ids`);
+    }
+    const seenResources = /* @__PURE__ */ new Set();
+    for (const id of q.resourceIds) {
+      if (typeof id !== "string" || id.length === 0 || id.length > 256) {
+        throw new HistoryQueryError("resourceIds must be nonempty strings");
+      }
+      if (seenResources.has(id)) throw new HistoryQueryError(`duplicate resource id ${JSON.stringify(id)}`);
+      seenResources.add(id);
     }
   }
-  resolveCommitted(pending) {
-    if (pending.settled) return;
-    pending.settled = true;
-    pending.resolve({
-      status: "committed",
-      accepted: pending.accepted,
-      rejected: pending.rejected,
-      newLive: pending.newLive,
-      receivedAtMs: pending.receivedAtMs
-    });
+  if (q.coreIds !== void 0 && (!Array.isArray(q.coreIds) || q.coreIds.length > MAX_CORES || q.coreIds.some((id) => typeof id !== "string" || !/^core:(?:0|[1-9]\d{0,3})$/.test(id) || Number(id.slice(5)) >= MAX_CORES) || new Set(q.coreIds).size !== q.coreIds.length)) {
+    throw new HistoryQueryError(`coreIds must contain at most ${MAX_CORES} unique core identifiers`);
   }
-  resolveBusy(pending, retryAfterMs, reason) {
-    if (pending.settled) return;
-    pending.settled = true;
-    pending.resolve({ status: "busy", retryAfterMs, reason });
+  if (!Number.isSafeInteger(q.fromMs) || !Number.isSafeInteger(q.toMs)) {
+    throw new HistoryQueryError("fromMs and toMs must be safe integer epoch milliseconds");
+  }
+  if (q.fromMs >= q.toMs) throw new HistoryQueryError("fromMs must be before toMs");
+  if (q.toMs - q.fromMs > MAX_RANGE_MS) {
+    throw new HistoryQueryError("range exceeds 400 days");
   }
-};
-function prepareRollupUpsert(db, table) {
-  return db.prepare(
-    `INSERT INTO ${table} (series_id, bucket_ms, min, max, sum, count, null_count) VALUES (?, ?, ?, ?, ?, ?, ?) ON CONFLICT(series_id, bucket_ms) DO UPDATE SET min = CASE WHEN excluded.count = 0 THEN min WHEN min IS NULL THEN excluded.min ELSE MIN(min, excluded.min) END, max = CASE WHEN excluded.count = 0 THEN max WHEN max IS NULL THEN excluded.max ELSE MAX(max, excluded.max) END, sum = sum + excluded.sum, count = count + excluded.count, null_count = null_count + excluded.null_count`
-  );
 }
-function isNewer(candidate, latest) {
-  if (candidate.runId === latest.runId) return candidate.sequence > latest.sequence;
-  return candidate.capturedAtMs > latest.capturedAtMs;
+function validatedMaxPoints(value) {
+  if (value === void 0) return DEFAULT_MAX_POINTS;
+  if (!Number.isSafeInteger(value) || value <= 0) {
+    throw new HistoryQueryError("maxPoints must be a positive safe integer");
+  }
+  return Math.min(value, MAX_POINTS);
 }
-function needsKnownSeries(payload) {
-  return payload.cpu.status === "unavailable" || payload.gpus.status === "unavailable" || payload.disks.status === "unavailable" || payload.network.status === "unavailable";
+function validatedBudget(value, fallback, name) {
+  if (value === void 0) return fallback;
+  if (!Number.isSafeInteger(value) || value <= 0) {
+    throw new HistoryQueryError(`${name} must be a positive safe integer`);
+  }
+  return value;
 }
-function rejectionReason(record, batch, receivedAtMs) {
-  if (record.collectorId !== batch.collectorId) {
-    return "collectorId does not match the authenticated batch";
+
+// src/hub/storage/telemetry-store.ts
+var DAY_MS3 = 864e5;
+var FUTURE_TOLERANCE_MS = DAY_MS3;
+var FAILURE_RETRY_MS = 5e3;
+var MIN_DERIVED_PHYSICAL_BYTES = 8 * 1024 * 1024;
+var TelemetryStore = class {
+  historyMode = "persistent";
+  database;
+  now;
+  maxQueuedRecords;
+  flushIntervalMs;
+  maxRecordsPerTransaction;
+  maxPhysicalBytes;
+  storageTier;
+  series;
+  retention;
+  queue = [];
+  timer = null;
+  driver = null;
+  closed = false;
+  committedRecords = 0;
+  duplicateRecords = 0;
+  rejectedRecords = 0;
+  writeFailures = 0;
+  diskFullFailures = 0;
+  lastWriteError = null;
+  lastFlushMs = null;
+  lastFlushDurationMs = null;
+  receiptInsert;
+  rawInsert;
+  upsert10s;
+  upsert1m;
+  upsert1h;
+  gapInsert;
+  latestSelect;
+  latestUpsert;
+  inventoryUpsert;
+  inventorySelect;
+  metaUpsertBoth;
+  metaUpsertDisplay;
+  metaUpsertTags;
+  metaTouch;
+  metaSelect;
+  metaSelectAll;
+  latestSelectAll;
+  constructor(options) {
+    this.database = options.database;
+    this.now = options.now ?? (() => Date.now());
+    this.maxQueuedRecords = positiveInt2(options.maxQueuedRecords, 4096, "maxQueuedRecords");
+    this.flushIntervalMs = nonnegativeInt(options.flushIntervalMs, 20, "flushIntervalMs");
+    this.maxRecordsPerTransaction = positiveInt2(
+      options.maxRecordsPerTransaction,
+      512,
+      "maxRecordsPerTransaction"
+    );
+    this.maxPhysicalBytes = resolvePhysicalLimit(options);
+    this.storageTier = options.storageTier ?? "raw";
+    if (this.storageTier !== "raw" && this.storageTier !== "summary") {
+      throw new Error("storageTier must be raw or summary");
+    }
+    const db = options.database.db;
+    this.series = new SeriesCatalog(db);
+    this.receiptInsert = db.prepare(
+      "INSERT OR IGNORE INTO sample_receipts (collector_id, run_id, seq, machine_id, kind, mode, captured_at_ms, received_at_ms, expected_interval_ms) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?)"
+    );
+    this.rawInsert = db.prepare(
+      "INSERT OR IGNORE INTO points_raw (series_id, ts_ms, value) VALUES (?, ?, ?)"
+    );
+    this.upsert10s = prepareRollupUpsert(db, "points_10s");
+    this.upsert1m = prepareRollupUpsert(db, "points_1m");
+    this.upsert1h = prepareRollupUpsert(db, "points_1h");
+    this.gapInsert = db.prepare(
+      "INSERT OR IGNORE INTO gaps (collector_id, run_id, seq, machine_id, from_ms, to_ms, dropped, reason, received_at_ms) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?)"
+    );
+    this.latestSelect = db.prepare(
+      "SELECT run_id, seq, captured_at_ms FROM machine_latest WHERE machine_id = ?"
+    );
+    this.latestUpsert = db.prepare(
+      "INSERT INTO machine_latest (machine_id, collector_id, run_id, boot_id, seq, captured_at_ms, received_at_ms, expected_interval_ms, hostname, payload_json) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?) ON CONFLICT(machine_id) DO UPDATE SET collector_id = excluded.collector_id, run_id = excluded.run_id, boot_id = excluded.boot_id, seq = excluded.seq, captured_at_ms = excluded.captured_at_ms, received_at_ms = excluded.received_at_ms, expected_interval_ms = COALESCE(excluded.expected_interval_ms, expected_interval_ms), hostname = COALESCE(excluded.hostname, hostname), payload_json = excluded.payload_json"
+    );
+    this.latestSelectAll = db.prepare(
+      "SELECT machine_id, collector_id, run_id, boot_id, seq, captured_at_ms, received_at_ms, expected_interval_ms, hostname, payload_json FROM machine_latest ORDER BY machine_id"
+    );
+    this.inventoryUpsert = db.prepare(
+      "INSERT INTO inventory (machine_id, captured_at_ms, received_at_ms, inventory_json) VALUES (?, ?, ?, ?) ON CONFLICT(machine_id) DO UPDATE SET captured_at_ms = excluded.captured_at_ms, received_at_ms = excluded.received_at_ms, inventory_json = excluded.inventory_json"
+    );
+    this.inventorySelect = db.prepare(
+      "SELECT captured_at_ms, received_at_ms, inventory_json FROM inventory WHERE machine_id = ?"
+    );
+    this.metaUpsertBoth = db.prepare(
+      "INSERT INTO machine_meta (machine_id, display_name, tags_json, updated_at_ms) VALUES (?, ?, ?, ?) ON CONFLICT(machine_id) DO UPDATE SET display_name = excluded.display_name, tags_json = excluded.tags_json, updated_at_ms = excluded.updated_at_ms"
+    );
+    this.metaUpsertDisplay = db.prepare(
+      "INSERT INTO machine_meta (machine_id, display_name, tags_json, updated_at_ms) VALUES (?, ?, '[]', ?) ON CONFLICT(machine_id) DO UPDATE SET display_name = excluded.display_name, updated_at_ms = excluded.updated_at_ms"
+    );
+    this.metaUpsertTags = db.prepare(
+      "INSERT INTO machine_meta (machine_id, display_name, tags_json, updated_at_ms) VALUES (?, NULL, ?, ?) ON CONFLICT(machine_id) DO UPDATE SET tags_json = excluded.tags_json, updated_at_ms = excluded.updated_at_ms"
+    );
+    this.metaTouch = db.prepare(
+      "INSERT INTO machine_meta (machine_id, display_name, tags_json, updated_at_ms) VALUES (?, NULL, '[]', ?) ON CONFLICT(machine_id) DO UPDATE SET updated_at_ms = excluded.updated_at_ms"
+    );
+    this.metaSelect = db.prepare(
+      "SELECT display_name, tags_json, updated_at_ms FROM machine_meta WHERE machine_id = ?"
+    );
+    this.metaSelectAll = db.prepare(
+      "SELECT machine_id, display_name, tags_json FROM machine_meta ORDER BY machine_id"
+    );
+    this.retention = new RetentionManager(options.database, {
+      policy: options.retention,
+      maxDatabaseBytes: options.maxDatabaseBytes ?? null,
+      maxPhysicalBytes: this.maxPhysicalBytes,
+      now: this.now
+    });
+    this.retention.start();
   }
-  const capturedMs = Date.parse(record.capturedAt);
-  if (!Number.isFinite(capturedMs)) return "capturedAt is not a parseable timestamp";
-  if (capturedMs > receivedAtMs + FUTURE_TOLERANCE_MS) {
-    return "capturedAt is more than 24h in the future";
+  /**
+   * Queues one batch. The promise resolves only after the transaction that
+   * writes it has committed, or immediately as `busy` when the bounded queue
+   * cannot hold it (no database work is done in that case).
+   */
+  enqueue(batch) {
+    return new Promise((resolve7) => {
+      if (this.closed) {
+        resolve7({ status: "busy", retryAfterMs: FAILURE_RETRY_MS, reason: "storage is closed" });
+        return;
+      }
+      validateBatch(batch);
+      const queued = this.queuedRecords();
+      if (queued + batch.records.length > this.maxQueuedRecords) {
+        const ratio = this.maxQueuedRecords === 0 ? 1 : queued / this.maxQueuedRecords;
+        const retryAfterMs = Math.min(5e3, Math.max(1e3, Math.round(1e3 + ratio * 4e3)));
+        resolve7({ status: "busy", retryAfterMs, reason: "ingest queue is full" });
+        return;
+      }
+      this.queue.push({
+        batch,
+        receivedAtMs: this.now(),
+        resolve: resolve7,
+        settled: false,
+        accepted: [],
+        rejected: [],
+        newLive: null
+      });
+      this.scheduleFlush(this.flushIntervalMs);
+    });
   }
-  return null;
-}
-function validateBatch(batch) {
-  if (batch === null || typeof batch !== "object") throw new Error("ingest batch must be an object");
-  if (typeof batch.machineId !== "string" || batch.machineId.length === 0) {
-    throw new Error("ingest batch machineId must be a nonempty string");
+  /** Persisted latest LIVE metrics per machine, for restart recovery. */
+  latestLive() {
+    const rows = this.latestSelectAll.all();
+    return rows.map((row) => ({
+      machineId: row.machine_id,
+      collectorId: row.collector_id,
+      runId: row.run_id,
+      bootId: row.boot_id,
+      sequence: Number(row.seq),
+      capturedAt: new Date(Number(row.captured_at_ms)).toISOString(),
+      receivedAt: new Date(Number(row.received_at_ms)).toISOString(),
+      hostname: row.hostname,
+      expectedIntervalMs: row.expected_interval_ms === null ? null : Number(row.expected_interval_ms),
+      payload: JSON.parse(row.payload_json)
+    }));
   }
-  if (typeof batch.collectorId !== "string" || batch.collectorId.length === 0) {
-    throw new Error("ingest batch collectorId must be a nonempty string");
+  saveInventory(machineId, capturedAt, inventory) {
+    const capturedMs = Date.parse(capturedAt);
+    if (!Number.isFinite(capturedMs)) throw new Error("inventory capturedAt must be a parseable timestamp");
+    this.inventoryUpsert.run(machineId, capturedMs, this.now(), JSON.stringify(inventory));
   }
-  if (batch.mode !== "live" && batch.mode !== "replay") {
-    throw new Error("ingest batch mode must be live or replay");
+  loadInventory(machineId) {
+    const row = this.inventorySelect.get(machineId);
+    if (!row) return null;
+    return {
+      capturedAt: new Date(Number(row.captured_at_ms)).toISOString(),
+      receivedAt: new Date(Number(row.received_at_ms)).toISOString(),
+      inventory: JSON.parse(row.inventory_json)
+    };
   }
-  if (!Array.isArray(batch.records)) throw new Error("ingest batch records must be an array");
-  if (batch.expectedIntervalMs !== null && !Number.isSafeInteger(batch.expectedIntervalMs)) {
-    throw new Error("ingest batch expectedIntervalMs must be a safe integer or null");
+  /**
+   * Merges presentation metadata. Omitted fields are preserved; an explicit
+   * `displayName: null` clears it.
+   */
+  setMachineMeta(machineId, meta) {
+    const updatedAt = this.now();
+    const hasDisplay = meta.displayName !== void 0;
+    const hasTags = meta.tags !== void 0;
+    const displayName = meta.displayName ?? null;
+    const tags = hasTags ? validateTags(meta.tags) : [];
+    if (hasDisplay && hasTags) {
+      this.metaUpsertBoth.run(machineId, displayName, JSON.stringify(tags), updatedAt);
+    } else if (hasDisplay) {
+      this.metaUpsertDisplay.run(machineId, displayName, updatedAt);
+    } else if (hasTags) {
+      this.metaUpsertTags.run(machineId, JSON.stringify(tags), updatedAt);
+    } else {
+      this.metaTouch.run(machineId, updatedAt);
+    }
   }
-  if (batch.hostname !== void 0 && batch.hostname !== null && (typeof batch.hostname !== "string" || batch.hostname.length > 255)) {
-    throw new Error("ingest batch hostname must be a string of at most 255 characters or null");
+  getMachineMeta(machineId) {
+    const row = this.metaSelect.get(machineId);
+    if (!row) return { displayName: null, tags: [] };
+    return { displayName: row.display_name, tags: parseTags(row.tags_json) };
   }
-}
-function validateTags(tags) {
-  if (!Array.isArray(tags) || tags.length > 64) throw new Error("tags must be an array of at most 64 strings");
-  const result = [];
-  const seen = /* @__PURE__ */ new Set();
-  for (const tag of tags) {
-    if (typeof tag !== "string" || tag.length === 0 || tag.length > 64) {
-      throw new Error("tags must be nonempty strings of at most 64 characters");
+  listMachineMeta() {
+    const rows = this.metaSelectAll.all();
+    const result = /* @__PURE__ */ new Map();
+    for (const row of rows) {
+      result.set(row.machine_id, {
+        displayName: row.display_name,
+        tags: parseTags(row.tags_json)
+      });
     }
-    if (seen.has(tag)) throw new Error("tags must be unique");
-    seen.add(tag);
-    result.push(tag);
+    return result;
   }
-  return result;
-}
-function parseTags(raw) {
-  try {
-    const parsed = JSON.parse(raw);
-    if (!Array.isArray(parsed)) return [];
-    return parsed.filter((tag) => typeof tag === "string");
-  } catch {
-    return [];
+  stats() {
+    return {
+      queuedRecords: this.queuedRecords(),
+      queuedBatches: this.queue.length,
+      lastFlushMs: this.lastFlushMs,
+      lastFlushDurationMs: this.lastFlushDurationMs,
+      committedRecords: this.committedRecords,
+      duplicateRecords: this.duplicateRecords,
+      rejectedRecords: this.rejectedRecords,
+      writeFailures: this.writeFailures,
+      lastWriteError: this.lastWriteError,
+      diskFullFailures: this.diskFullFailures,
+      dbBytes: this.database.sizeBytes(),
+      dbWalBytes: this.database.walBytes(),
+      dbBytesLimit: this.maxPhysicalBytes,
+      retention: this.retention.status()
+    };
   }
-}
-function sanitizeWriteError(error) {
-  const message = error instanceof Error ? error.message : String(error);
-  return message.replace(/\s+/g, " ").slice(0, 200);
-}
-function positiveInt2(value, fallback, name) {
-  const resolved = value ?? fallback;
-  if (!Number.isSafeInteger(resolved) || resolved <= 0) {
-    throw new Error(`${name} must be a positive safe integer`);
+  queryHistory(query, budget = {}) {
+    return queryHistory(this.database, query, {
+      ...budget,
+      nowMs: budget.nowMs ?? this.now(),
+      retention: { ...this.retention.policy, ...budget.retention },
+      tiers: budget.tiers ?? (this.storageTier === "summary" ? ["10s", "1m", "1h"] : void 0)
+    });
   }
-  return resolved;
-}
-function resolvePhysicalLimit(options) {
-  if (options.maxPhysicalBytes === null) return null;
-  if (options.maxPhysicalBytes !== void 0) {
-    if (!Number.isSafeInteger(options.maxPhysicalBytes) || options.maxPhysicalBytes < 16 * 1024) {
-      throw new Error("maxPhysicalBytes must be a safe integer of at least 16 KiB or null");
+  historyStatus() {
+    const stats = this.stats();
+    const physical = this.database.physicalLimit();
+    const now = this.now();
+    const retention = this.retention.policy;
+    return {
+      mode: "persistent",
+      persistentHistory: true,
+      availableFromMs: this.storageTier === "summary" ? now - Math.max(retention.tenSecondMs, retention.oneMinuteMs, retention.oneHourMs) : now - Math.max(retention.rawMs, retention.oneMinuteMs, retention.oneHourMs),
+      availableToMs: now,
+      memory: null,
+      persistence: {
+        enabled: true,
+        storageTier: this.storageTier,
+        flushIntervalMs: this.flushIntervalMs,
+        queuedRecords: stats.queuedRecords,
+        queuedBatches: stats.queuedBatches,
+        lastFlushMs: stats.lastFlushMs,
+        lastFlushDurationMs: stats.lastFlushDurationMs,
+        writeFailures: stats.writeFailures,
+        lastWriteError: stats.lastWriteError,
+        dbBytes: stats.dbBytes,
+        dbWalBytes: stats.dbWalBytes,
+        dbBytesLimit: physical?.limitBytes ?? this.maxPhysicalBytes,
+        tiers: this.storageTier === "summary" ? [
+          { tier: "10s", stepMs: 1e4, retentionMs: retention.tenSecondMs, bytes: stats.dbBytes },
+          { tier: "1m", stepMs: 6e4, retentionMs: retention.oneMinuteMs, bytes: 0 },
+          { tier: "1h", stepMs: 36e5, retentionMs: retention.oneHourMs, bytes: 0 }
+        ] : [
+          { tier: "raw", stepMs: 100, retentionMs: retention.rawMs, bytes: stats.dbBytes },
+          { tier: "1m", stepMs: 6e4, retentionMs: retention.oneMinuteMs, bytes: 0 },
+          { tier: "1h", stepMs: 36e5, retentionMs: retention.oneHourMs, bytes: 0 }
+        ]
+      },
+      gaps: 0,
+      acceptedRecords: stats.committedRecords,
+      generatedAt: new Date(now).toISOString()
+    };
+  }
+  /** Drains the queue immediately; intended for tests and shutdown. */
+  async flushNow() {
+    if (this.closed) return;
+    if (this.timer !== null) {
+      clearTimeout(this.timer);
+      this.timer = null;
+    }
+    await this.drive();
+    while (!this.closed && this.queue.length > 0 && this.driver === null) {
+      const failures = this.writeFailures;
+      await this.drive();
+      if (this.writeFailures > failures) break;
     }
-    return options.maxPhysicalBytes;
   }
-  if (options.maxDatabaseBytes !== null && options.maxDatabaseBytes !== void 0 && options.maxDatabaseBytes >= MIN_DERIVED_PHYSICAL_BYTES) {
-    return options.maxDatabaseBytes;
+  /**
+   * Drains for up to ~2s, then resolves anything left as busy and closes the
+   * database. Batches that were already committed have resolved normally.
+   */
+  async close() {
+    if (this.closed) return;
+    this.closed = true;
+    this.retention.stop();
+    if (this.timer !== null) {
+      clearTimeout(this.timer);
+      this.timer = null;
+    }
+    if (this.driver !== null) {
+      try {
+        await this.driver;
+      } catch {
+      }
+    }
+    const deadline = Date.now() + 2e3;
+    while (this.queue.length > 0 && Date.now() < deadline) {
+      const ok = this.flushTransaction();
+      if (!ok) break;
+      if (this.queue.length > 0) await yieldToEventLoop2();
+    }
+    while (this.queue.length > 0) {
+      const pending = this.queue.shift();
+      this.resolveBusy(pending, FAILURE_RETRY_MS, "storage is shutting down");
+    }
+    try {
+      this.database.close();
+    } catch {
+    }
   }
-  return DEFAULT_MAX_DATABASE_DISK_BYTES;
-}
-function nonnegativeInt(value, fallback, name) {
-  const resolved = value ?? fallback;
-  if (!Number.isSafeInteger(resolved) || resolved < 0) {
-    throw new Error(`${name} must be a nonnegative safe integer`);
+  queuedRecords() {
+    let total = 0;
+    for (const pending of this.queue) total += pending.batch.records.length;
+    return total;
   }
-  return resolved;
-}
-function yieldToEventLoop2() {
-  return new Promise((resolve6) => setImmediate(resolve6));
-}
-
-// src/contracts/telemetry.ts
-var MAX_CORES = 1024;
-var MIN_EPOCH = Date.parse("2000-01-01T00:00:00Z");
-var MAX_EPOCH = Date.parse("2200-01-01T00:00:00Z");
-
-// src/contracts/index.ts
-var MIN_TIMESTAMP_EPOCH = Date.parse("2000-01-01T00:00:00Z");
-var MAX_TIMESTAMP_EPOCH = Date.parse("2200-01-01T00:00:00Z");
-
-// src/hub/storage/history-query.ts
-var DAY_MS3 = 864e5;
-var MAX_RANGE_MS = 400 * DAY_MS3;
-var MAX_METRICS = Object.keys(METRICS).length;
-var MAX_RESOURCE_IDS = 64;
-var DEFAULT_MAX_POINTS = 600;
-var MAX_POINTS = 2e3;
-var MAX_GAPS = 500;
-var TIER_RESOLUTION_MS = { raw: 100, "1m": 6e4, "1h": 36e5 };
-var HistoryQueryError = class extends Error {
-  code = "invalid-query";
-  constructor(message) {
-    super(message);
-    this.name = "HistoryQueryError";
+  scheduleFlush(delayMs) {
+    if (this.closed || this.timer !== null || this.driver !== null) return;
+    this.timer = setTimeout(() => {
+      this.timer = null;
+      void this.drive();
+    }, delayMs);
+    this.timer.unref?.();
   }
-};
-function queryHistory(db, q, budget = {}) {
-  const started = performance.now();
-  const maxPoints = validatedMaxPoints(q.maxPoints);
-  const maxSeries = validatedBudget(budget.maxSeries, 64, "maxSeries");
-  const maxRowsScanned = validatedBudget(budget.maxRowsScanned, 25e4, "maxRowsScanned");
-  const maxElapsedMs = validatedBudget(budget.maxElapsedMs, 5e3, "maxElapsedMs");
-  const retention = resolveRetentionPolicy(budget.retention);
-  validatedQuery(q);
-  const rangeMs = q.toMs - q.fromMs;
-  const nowMs = Date.now();
-  let allSeries = loadSeries(db, q);
-  let truncated = false;
-  if (allSeries.length > maxSeries) {
-    allSeries = allSeries.slice(0, maxSeries);
-    truncated = true;
+  drive() {
+    if (this.driver !== null) return this.driver;
+    const promise = this.runDriver().finally(() => {
+      if (this.driver === promise) this.driver = null;
+      if (!this.closed && this.queue.length > 0 && this.timer === null) {
+        this.scheduleFlush(FAILURE_RETRY_MS);
+      }
+    });
+    this.driver = promise;
+    return promise;
   }
-  const chosen = chooseTier(
-    db,
-    allSeries.map((row) => Number(row.series_id)),
-    q.fromMs,
-    q.toMs,
-    nowMs,
-    retention,
-    maxRowsScanned,
-    maxElapsedMs,
-    started
-  );
-  if (chosen.timeExceeded || chosen.overBudget) truncated = true;
-  let seriesRows = allSeries;
-  if (chosen.cutSeries < seriesRows.length) {
-    seriesRows = seriesRows.slice(0, Math.max(0, chosen.cutSeries));
-    truncated = true;
+  async runDriver() {
+    while (!this.closed && this.queue.length > 0) {
+      const ok = this.flushTransaction();
+      if (!ok) return;
+      if (this.queue.length > 0) await yieldToEventLoop2();
+    }
   }
-  const stepMs = Math.max(1, Math.ceil(rangeMs / maxPoints / chosen.resolutionMs)) * chosen.resolutionMs;
-  const originMs = Math.floor(q.fromMs / stepMs) * stepMs;
-  const series = [];
-  for (const row of seriesRows) {
-    if (performance.now() - started > maxElapsedMs) {
-      truncated = true;
-      break;
+  /**
+   * Commits the front of the queue as one transaction. Returns false when the
+   * transaction failed; every batch in it has then been resolved as busy.
+   */
+  flushTransaction() {
+    if (this.queue.length === 0) return true;
+    const selected = [];
+    let recordCount = 0;
+    for (const pending of this.queue) {
+      const size = pending.batch.records.length;
+      if (selected.length > 0 && recordCount + size > this.maxRecordsPerTransaction) break;
+      selected.push(pending);
+      recordCount += size;
+      if (recordCount >= this.maxRecordsPerTransaction) break;
+    }
+    this.queue.splice(0, selected.length);
+    if (this.maxPhysicalBytes !== null) {
+      try {
+        let physical = this.database.physicalLimit();
+        let bytes = this.database.sizeBytes();
+        const pageFull = physical !== null && physical.pageCount >= physical.maxPageCount && physical.freePages === 0;
+        if (bytes >= this.maxPhysicalBytes || pageFull) {
+          this.retention.relievePressure(4);
+          physical = this.database.physicalLimit();
+          bytes = this.database.sizeBytes();
+        }
+        const stillFull = physical !== null && physical.pageCount >= physical.maxPageCount && physical.freePages === 0;
+        if (bytes >= this.maxPhysicalBytes || stillFull) {
+          this.diskFullFailures += 1;
+          this.lastWriteError = "storage disk budget reached";
+          for (const pending of selected) {
+            this.resolveBusy(pending, FAILURE_RETRY_MS, "storage disk budget reached");
+          }
+          return false;
+        }
+      } catch (error) {
+        const full = isStorageFullError(error);
+        if (full) this.diskFullFailures += 1;
+        this.lastWriteError = full ? "storage disk budget reached" : sanitizeWriteError(error);
+        for (const pending of selected) {
+          this.resolveBusy(
+            pending,
+            FAILURE_RETRY_MS,
+            full ? "storage disk budget reached" : "storage write failed"
+          );
+        }
+        return false;
+      }
     }
-    const metric = row.metric;
-    const definition = METRICS[metric];
-    if (!definition) continue;
-    const points = readSeries(
-      db,
-      chosen.tier,
-      Number(row.series_id),
-      fromBucketMs(chosen.tier, q.fromMs),
-      q.toMs,
-      originMs,
-      stepMs,
-      // An additional per-series guard. Tier selection already keeps the total
-      // under budget; this makes a single query bounded even if a custom
-      // retention policy forces the coarse fallback.
-      maxRowsScanned
-    );
-    if (points.length === 0) continue;
-    series.push({ metric: row.metric, resourceId: row.resource_id, unit: definition.unit, points });
-  }
-  const gaps = readGaps(db, q.machineId, q.fromMs, q.toMs);
-  return {
-    machineId: q.machineId,
-    fromMs: q.fromMs,
-    toMs: q.toMs,
-    stepMs,
-    tier: chosen.tier,
-    series,
-    gaps,
-    truncated,
-    elapsedMs: Math.max(0, Math.round(performance.now() - started))
-  };
-}
-function loadSeries(db, q) {
-  const placeholders = q.metrics.map(() => "?").join(", ");
-  const params = [q.machineId, ...q.metrics];
-  let sql = `SELECT series_id, metric, resource_id FROM series WHERE machine_id = ? AND metric IN (${placeholders})`;
-  if (q.resourceIds && q.resourceIds.length > 0) {
-    sql += ` AND resource_id IN (${q.resourceIds.map(() => "?").join(", ")})`;
-    params.push(...q.resourceIds);
+    const started = import_node_perf_hooks.performance.now();
+    const counters = { committed: 0, duplicates: 0, rejected: 0 };
+    const cursors = /* @__PURE__ */ new Map();
+    const upserts = /* @__PURE__ */ new Map();
+    const summaries = /* @__PURE__ */ new Map();
+    try {
+      this.database.db.exec("BEGIN IMMEDIATE");
+      for (const pending of selected) {
+        this.processBatch(pending, counters, cursors, upserts, summaries);
+      }
+      if (this.storageTier === "summary" && summaries.size > 0) {
+        this.writeSummaries(summaries);
+      }
+      for (const [machineId, live] of upserts) {
+        this.latestUpsert.run(
+          machineId,
+          live.record.collectorId,
+          live.record.runId,
+          live.record.bootId,
+          live.record.sequence,
+          Date.parse(live.record.capturedAt),
+          live.receivedAtMs,
+          live.expectedIntervalMs,
+          live.hostname,
+          JSON.stringify(live.record.payload)
+        );
+      }
+      this.database.db.exec("COMMIT");
+    } catch (error) {
+      try {
+        this.database.db.exec("ROLLBACK");
+      } catch {
+      }
+      this.writeFailures += 1;
+      const full = isStorageFullError(error);
+      if (full) this.diskFullFailures += 1;
+      this.lastWriteError = full ? "storage disk budget reached" : sanitizeWriteError(error);
+      for (const pending of selected) {
+        this.resolveBusy(
+          pending,
+          FAILURE_RETRY_MS,
+          full ? "storage disk budget reached" : "storage write failed"
+        );
+      }
+      return false;
+    }
+    this.committedRecords += counters.committed;
+    this.duplicateRecords += counters.duplicates;
+    this.rejectedRecords += counters.rejected;
+    this.lastFlushMs = this.now();
+    this.lastFlushDurationMs = Math.max(0, Math.round(import_node_perf_hooks.performance.now() - started));
+    this.checkpointWALIfNeeded();
+    if (this.maxPhysicalBytes !== null && this.database.sizeBytes() > this.maxPhysicalBytes) {
+      try {
+        this.retention.relievePressure(4);
+      } catch {
+      }
+    }
+    for (const pending of selected) this.resolveCommitted(pending);
+    return true;
   }
-  if (q.coreIds !== void 0) {
-    if (q.coreIds.length === 0) sql += " AND metric <> 'cpu.core'";
-    else {
-      sql += ` AND (metric <> 'cpu.core' OR resource_id IN (${q.coreIds.map(() => "?").join(", ")}))`;
-      params.push(...q.coreIds);
+  checkpointWALIfNeeded() {
+    if (this.maxPhysicalBytes === null) return;
+    try {
+      const physical = this.database.physicalLimit();
+      if (physical !== null && this.database.walBytes() > physical.walBudgetBytes) {
+        this.database.checkpoint();
+      }
+    } catch {
     }
   }
-  sql += " ORDER BY metric, resource_id";
-  return db.db.prepare(sql).all(...params);
-}
-var TIER_CANDIDATES = [
-  { tier: "raw", resolutionMs: TIER_RESOLUTION_MS.raw, retentionMs: 0 },
-  { tier: "1m", resolutionMs: TIER_RESOLUTION_MS["1m"], retentionMs: 0 },
-  { tier: "1h", resolutionMs: TIER_RESOLUTION_MS["1h"], retentionMs: 0 }
-];
-function chooseTier(db, seriesIds, fromMs, toMs, nowMs, retention, maxRowsScanned, maxElapsedMs, started) {
-  const candidates = TIER_CANDIDATES.map((candidate) => ({
-    ...candidate,
-    retentionMs: candidate.tier === "raw" ? retention.rawMs : candidate.tier === "1m" ? retention.oneMinuteMs : retention.oneHourMs
-  }));
-  const available = candidates.filter((candidate) => fromMs >= nowMs - candidate.retentionMs);
-  const pool = available.length > 0 ? available : [candidates[candidates.length - 1]];
-  let timeExceeded = false;
-  for (const candidate of pool) {
-    if (performance.now() - started > maxElapsedMs) {
-      timeExceeded = true;
-      break;
+  processBatch(pending, counters, cursors, upserts, summaries) {
+    const batch = pending.batch;
+    let best = null;
+    let bestCapturedMs = 0;
+    let bestSequence = -1;
+    for (const record of batch.records) {
+      const ref = { runId: record.runId, sequence: record.sequence };
+      const reason = rejectionReason(record, batch, pending.receivedAtMs);
+      if (reason !== null) {
+        pending.rejected.push({ ...ref, reason });
+        counters.rejected += 1;
+        continue;
+      }
+      const capturedMs = Date.parse(record.capturedAt);
+      const inserted = Number(
+        this.receiptInsert.run(
+          batch.collectorId,
+          record.runId,
+          record.sequence,
+          batch.machineId,
+          record.kind,
+          batch.mode,
+          capturedMs,
+          pending.receivedAtMs,
+          batch.expectedIntervalMs
+        ).changes
+      ) === 1;
+      if (!inserted) {
+        pending.accepted.push(ref);
+        counters.duplicates += 1;
+        continue;
+      }
+      pending.accepted.push(ref);
+      counters.committed += 1;
+      if (record.kind === "metrics") {
+        const known = needsKnownSeries(record.payload) ? this.series.knownFor(batch.machineId) : void 0;
+        for (const point of flattenMetrics(record.payload, known)) {
+          const seriesId = this.series.idFor(batch.machineId, point.metric, point.resourceId);
+          if (this.storageTier === "summary") {
+            addSummaryPoint(summaries, seriesId, capturedMs, point.value);
+          } else {
+            this.insertPoint(seriesId, capturedMs, point.value);
+          }
+        }
+        if (batch.mode === "live") {
+          if (best === null || capturedMs > bestCapturedMs || capturedMs === bestCapturedMs && record.sequence > bestSequence) {
+            best = record;
+            bestCapturedMs = capturedMs;
+            bestSequence = record.sequence;
+          }
+        }
+      } else {
+        this.gapInsert.run(
+          batch.collectorId,
+          record.runId,
+          record.sequence,
+          batch.machineId,
+          Date.parse(record.payload.fromCapturedAt),
+          Date.parse(record.payload.toCapturedAt),
+          record.payload.droppedRecords,
+          record.payload.reason,
+          pending.receivedAtMs
+        );
+      }
     }
-    const rows = countRowsBounded(
-      db,
-      candidate.tier,
-      seriesIds,
-      fromBucketMs(candidate.tier, fromMs),
-      toMs,
-      maxRowsScanned
-    );
-    if (rows <= maxRowsScanned) {
-      return {
-        tier: candidate.tier,
-        resolutionMs: candidate.resolutionMs,
-        cutSeries: seriesIds.length,
-        timeExceeded,
-        overBudget: false
-      };
+    if (batch.mode !== "live" || best === null) return;
+    const cursor = this.latestCursor(batch.machineId, cursors);
+    const candidate = {
+      runId: best.runId,
+      sequence: best.sequence,
+      capturedAtMs: bestCapturedMs
+    };
+    if (cursor === null || isNewer(candidate, cursor)) {
+      pending.newLive = best;
+      cursors.set(batch.machineId, candidate);
+      upserts.set(batch.machineId, {
+        record: best,
+        receivedAtMs: pending.receivedAtMs,
+        expectedIntervalMs: batch.expectedIntervalMs,
+        hostname: batch.hostname ?? null
+      });
     }
-    if (performance.now() - started > maxElapsedMs) {
-      timeExceeded = true;
-      break;
+  }
+  latestCursor(machineId, cache) {
+    if (cache.has(machineId)) return cache.get(machineId);
+    const row = this.latestSelect.get(machineId);
+    const cursor = row ? { runId: row.run_id, sequence: Number(row.seq), capturedAtMs: Number(row.captured_at_ms) } : null;
+    cache.set(machineId, cursor);
+    return cursor;
+  }
+  /**
+   * Writes one compact ten-second summary per series/bucket and folds the same
+   * aggregate into both larger rollups. The ten-second row is upserted because
+   * late or replayed samples may extend a bucket across flushes; the one-minute
+   * and one-hour rows only receive the new delta, so a sample is counted once.
+   */
+  writeSummaries(summaries) {
+    for (const [seriesId, buckets] of summaries) {
+      for (const [bucketMs, aggregate] of buckets) {
+        this.upsert10s.run(
+          seriesId,
+          bucketMs,
+          aggregate.min,
+          aggregate.max,
+          aggregate.sum,
+          aggregate.count,
+          aggregate.nullCount
+        );
+        this.applyRollupAggregate(
+          this.upsert1m,
+          seriesId,
+          Math.floor(bucketMs / 6e4) * 6e4,
+          aggregate
+        );
+        this.applyRollupAggregate(
+          this.upsert1h,
+          seriesId,
+          Math.floor(bucketMs / 36e5) * 36e5,
+          aggregate
+        );
+      }
     }
   }
-  const fallback = pool[pool.length - 1];
-  let cut = seriesIds.length;
-  let fits = seriesIds.length === 0;
-  if (timeExceeded) cut = Math.max(1, Math.floor(cut / 2));
-  while (!fits && cut >= 1) {
-    if (performance.now() - started > maxElapsedMs) {
-      timeExceeded = true;
-      break;
+  /**
+   * Writes one raw point and incrementally updates both rollup tiers. The raw
+   * INSERT OR IGNORE guard prevents a collision (same series/timestamp) from
+   * double-counting a rollup.
+   */
+  insertPoint(seriesId, tsMs, value) {
+    if (Number(this.rawInsert.run(seriesId, tsMs, value).changes) !== 1) return;
+    const minute = Math.floor(tsMs / 6e4) * 6e4;
+    const hour = Math.floor(tsMs / 36e5) * 36e5;
+    this.applyRollup(this.upsert1m, seriesId, minute, value);
+    this.applyRollup(this.upsert1h, seriesId, hour, value);
+  }
+  applyRollup(statement, seriesId, bucketMs, value) {
+    if (value === null) {
+      statement.run(seriesId, bucketMs, null, null, 0, 0, 1);
+    } else {
+      statement.run(seriesId, bucketMs, value, value, value, 1, 0);
     }
-    const rows = countRowsBounded(
-      db,
-      fallback.tier,
-      seriesIds.slice(0, cut),
-      fromBucketMs(fallback.tier, fromMs),
-      toMs,
-      maxRowsScanned
+  }
+  applyRollupAggregate(statement, seriesId, bucketMs, aggregate) {
+    statement.run(
+      seriesId,
+      bucketMs,
+      aggregate.min,
+      aggregate.max,
+      aggregate.sum,
+      aggregate.count,
+      aggregate.nullCount
     );
-    if (rows <= maxRowsScanned) {
-      fits = true;
-      break;
-    }
-    if (cut === 1) break;
-    cut = Math.max(1, Math.floor(cut / 2));
   }
-  return {
-    tier: fallback.tier,
-    resolutionMs: fallback.resolutionMs,
-    cutSeries: Math.max(1, Math.min(cut, seriesIds.length)),
-    timeExceeded,
-    overBudget: !fits
-  };
-}
-function countRowsBounded(db, tier, seriesIds, fromMs, toMs, budget) {
-  if (seriesIds.length === 0) return 0;
-  const column = tier === "raw" ? "ts_ms" : "bucket_ms";
-  const table = tier === "raw" ? "points_raw" : `points_${tier}`;
-  const statement = db.db.prepare(
-    `SELECT COUNT(*) AS n FROM (SELECT 1 FROM ${table} WHERE series_id = ? AND ${column} >= ? AND ${column} <= ? LIMIT ?)`
-  );
-  let total = 0;
-  for (const seriesId of seriesIds) {
-    const remaining = budget + 1 - total;
-    if (remaining <= 0) return total;
-    const row = statement.get(seriesId, fromMs, toMs, remaining);
-    total += Number(row?.n ?? 0);
-    if (total > budget) return total;
+  resolveCommitted(pending) {
+    if (pending.settled) return;
+    pending.settled = true;
+    pending.resolve({
+      status: "committed",
+      accepted: pending.accepted,
+      rejected: pending.rejected,
+      newLive: pending.newLive,
+      receivedAtMs: pending.receivedAtMs
+    });
   }
-  return total;
-}
-function readSeries(db, tier, seriesId, fromBucketMs2, toMs, originMs, stepMs, rowLimit) {
-  const statement = tier === "raw" ? db.db.prepare(
-    "SELECT ? + CAST((ts_ms - ?) / ? AS INTEGER) * ? AS bucket, MIN(value) AS min_value, MAX(value) AS max_value, SUM(value) AS sum_value, COUNT(value) AS count_value, COUNT(*) AS row_count FROM (SELECT ts_ms, value FROM points_raw WHERE series_id = ? AND ts_ms >= ? AND ts_ms <= ? ORDER BY ts_ms LIMIT ?) GROUP BY bucket ORDER BY bucket"
-  ) : db.db.prepare(
-    `SELECT ? + CAST((bucket_ms - ?) / ? AS INTEGER) * ? AS bucket, MIN(min) AS min_value, MAX(max) AS max_value, SUM(sum) AS sum_value, SUM(count) AS count_value, COUNT(*) AS row_count FROM (SELECT bucket_ms, min, max, sum, count FROM points_${tier} WHERE series_id = ? AND bucket_ms >= ? AND bucket_ms <= ? ORDER BY bucket_ms LIMIT ?) GROUP BY bucket ORDER BY bucket`
-  );
-  const rows = statement.all(
-    originMs,
-    originMs,
-    stepMs,
-    stepMs,
-    seriesId,
-    fromBucketMs2,
-    toMs,
-    rowLimit
+  resolveBusy(pending, retryAfterMs, reason) {
+    if (pending.settled) return;
+    pending.settled = true;
+    pending.resolve({ status: "busy", retryAfterMs, reason });
+  }
+};
+function prepareRollupUpsert(db, table) {
+  return db.prepare(
+    `INSERT INTO ${table} (series_id, bucket_ms, min, max, sum, count, null_count) VALUES (?, ?, ?, ?, ?, ?, ?) ON CONFLICT(series_id, bucket_ms) DO UPDATE SET min = CASE WHEN excluded.count = 0 THEN min WHEN min IS NULL THEN excluded.min ELSE MIN(min, excluded.min) END, max = CASE WHEN excluded.count = 0 THEN max WHEN max IS NULL THEN excluded.max ELSE MAX(max, excluded.max) END, sum = sum + excluded.sum, count = count + excluded.count, null_count = null_count + excluded.null_count`
   );
-  return rows.map((row) => {
-    const count = Number(row.count_value ?? 0);
-    return {
-      t: Number(row.bucket),
-      min: row.min_value === null ? null : Number(row.min_value),
-      max: row.max_value === null ? null : Number(row.max_value),
-      avg: count > 0 && row.sum_value !== null ? Number(row.sum_value) / count : null
-    };
-  });
 }
-function fromBucketMs(tier, fromMs) {
-  if (tier === "raw") return fromMs;
-  const span = tier === "1m" ? 6e4 : 36e5;
-  return Math.floor(fromMs / span) * span;
+function isNewer(candidate, latest) {
+  if (candidate.runId === latest.runId) return candidate.sequence > latest.sequence;
+  return candidate.capturedAtMs > latest.capturedAtMs;
 }
-function readGaps(db, machineId, fromMs, toMs) {
-  const dropped = db.db.prepare(
-    "SELECT from_ms, to_ms, dropped, reason FROM gaps WHERE machine_id = ? AND to_ms >= ? AND from_ms <= ? ORDER BY from_ms LIMIT ?"
-  ).all(machineId, fromMs, toMs, MAX_GAPS);
-  const missing = db.db.prepare(
-    "WITH before_window AS ( SELECT captured_at_ms, expected_interval_ms FROM sample_receipts WHERE machine_id = ? AND captured_at_ms < ? ORDER BY captured_at_ms DESC LIMIT 1 ), in_window AS ( SELECT captured_at_ms, expected_interval_ms FROM sample_receipts WHERE machine_id = ? AND captured_at_ms >= ? AND captured_at_ms <= ? ), ordered AS ( SELECT captured_at_ms, expected_interval_ms, LAG(captured_at_ms) OVER (ORDER BY captured_at_ms) AS prev_ms FROM (SELECT * FROM before_window UNION ALL SELECT * FROM in_window) ) SELECT MAX(prev_ms, ?) AS from_ms, captured_at_ms AS to_ms FROM ordered WHERE prev_ms IS NOT NULL AND captured_at_ms > ? AND captured_at_ms - prev_ms > MAX(15000, 3 * COALESCE(expected_interval_ms, 5000)) ORDER BY captured_at_ms LIMIT ?"
-  ).all(machineId, fromMs, machineId, fromMs, toMs, fromMs, fromMs, MAX_GAPS);
-  const gaps = [
-    ...dropped.map((row) => ({
-      fromMs: Number(row.from_ms),
-      toMs: Number(row.to_ms),
-      kind: "dropped",
-      reason: row.reason,
-      droppedRecords: Number(row.dropped)
-    })),
-    ...missing.map((row) => ({
-      fromMs: Number(row.from_ms),
-      toMs: Number(row.to_ms),
-      kind: "missing",
-      reason: "expected interval missed"
-    }))
-  ];
-  gaps.sort((a, b) => a.fromMs - b.fromMs || a.toMs - b.toMs);
-  return gaps.slice(0, MAX_GAPS);
+function needsKnownSeries(payload) {
+  return payload.cpu.status === "unavailable" || payload.gpus.status === "unavailable" || payload.disks.status === "unavailable" || payload.network.status === "unavailable";
 }
-function validatedQuery(q) {
-  if (q === null || typeof q !== "object") throw new HistoryQueryError("query must be an object");
-  if (typeof q.machineId !== "string" || q.machineId.length === 0 || q.machineId.length > 256) {
-    throw new HistoryQueryError("machineId must be a nonempty string");
+function rejectionReason(record, batch, receivedAtMs) {
+  if (record.collectorId !== batch.collectorId) {
+    return "collectorId does not match the authenticated batch";
   }
-  if (!Array.isArray(q.metrics) || q.metrics.length === 0 || q.metrics.length > MAX_METRICS) {
-    throw new HistoryQueryError(`metrics must contain 1..${MAX_METRICS} metric names`);
+  const capturedMs = Date.parse(record.capturedAt);
+  if (!Number.isFinite(capturedMs)) return "capturedAt is not a parseable timestamp";
+  if (capturedMs > receivedAtMs + FUTURE_TOLERANCE_MS) {
+    return "capturedAt is more than 24h in the future";
   }
-  const seenMetrics = /* @__PURE__ */ new Set();
-  for (const metric of q.metrics) {
-    if (typeof metric !== "string" || !Object.prototype.hasOwnProperty.call(METRICS, metric)) {
-      throw new HistoryQueryError(`unknown metric ${JSON.stringify(metric)}`);
-    }
-    if (seenMetrics.has(metric)) throw new HistoryQueryError(`duplicate metric ${JSON.stringify(metric)}`);
-    seenMetrics.add(metric);
+  return null;
+}
+function validateBatch(batch) {
+  if (batch === null || typeof batch !== "object") throw new Error("ingest batch must be an object");
+  if (typeof batch.machineId !== "string" || batch.machineId.length === 0) {
+    throw new Error("ingest batch machineId must be a nonempty string");
   }
-  if (q.resourceIds !== void 0) {
-    if (!Array.isArray(q.resourceIds) || q.resourceIds.length > MAX_RESOURCE_IDS) {
-      throw new HistoryQueryError(`resourceIds must contain at most ${MAX_RESOURCE_IDS} ids`);
-    }
-    const seenResources = /* @__PURE__ */ new Set();
-    for (const id of q.resourceIds) {
-      if (typeof id !== "string" || id.length === 0 || id.length > 256) {
-        throw new HistoryQueryError("resourceIds must be nonempty strings");
-      }
-      if (seenResources.has(id)) throw new HistoryQueryError(`duplicate resource id ${JSON.stringify(id)}`);
-      seenResources.add(id);
+  if (typeof batch.collectorId !== "string" || batch.collectorId.length === 0) {
+    throw new Error("ingest batch collectorId must be a nonempty string");
+  }
+  if (batch.mode !== "live" && batch.mode !== "replay") {
+    throw new Error("ingest batch mode must be live or replay");
+  }
+  if (!Array.isArray(batch.records)) throw new Error("ingest batch records must be an array");
+  if (batch.expectedIntervalMs !== null && !Number.isSafeInteger(batch.expectedIntervalMs)) {
+    throw new Error("ingest batch expectedIntervalMs must be a safe integer or null");
+  }
+  if (batch.hostname !== void 0 && batch.hostname !== null && (typeof batch.hostname !== "string" || batch.hostname.length > 255)) {
+    throw new Error("ingest batch hostname must be a string of at most 255 characters or null");
+  }
+}
+function validateTags(tags) {
+  if (!Array.isArray(tags) || tags.length > 64) throw new Error("tags must be an array of at most 64 strings");
+  const result = [];
+  const seen = /* @__PURE__ */ new Set();
+  for (const tag of tags) {
+    if (typeof tag !== "string" || tag.length === 0 || tag.length > 64) {
+      throw new Error("tags must be nonempty strings of at most 64 characters");
     }
+    if (seen.has(tag)) throw new Error("tags must be unique");
+    seen.add(tag);
+    result.push(tag);
   }
-  if (q.coreIds !== void 0 && (!Array.isArray(q.coreIds) || q.coreIds.length > MAX_CORES || q.coreIds.some((id) => typeof id !== "string" || !/^core:(?:0|[1-9]\d{0,3})$/.test(id) || Number(id.slice(5)) >= MAX_CORES) || new Set(q.coreIds).size !== q.coreIds.length)) {
-    throw new HistoryQueryError(`coreIds must contain at most ${MAX_CORES} unique core identifiers`);
+  return result;
+}
+function parseTags(raw) {
+  try {
+    const parsed = JSON.parse(raw);
+    if (!Array.isArray(parsed)) return [];
+    return parsed.filter((tag) => typeof tag === "string");
+  } catch {
+    return [];
   }
-  if (!Number.isSafeInteger(q.fromMs) || !Number.isSafeInteger(q.toMs)) {
-    throw new HistoryQueryError("fromMs and toMs must be safe integer epoch milliseconds");
+}
+function sanitizeWriteError(error) {
+  const message = error instanceof Error ? error.message : String(error);
+  return message.replace(/\s+/g, " ").slice(0, 200);
+}
+function positiveInt2(value, fallback, name) {
+  const resolved = value ?? fallback;
+  if (!Number.isSafeInteger(resolved) || resolved <= 0) {
+    throw new Error(`${name} must be a positive safe integer`);
   }
-  if (q.fromMs >= q.toMs) throw new HistoryQueryError("fromMs must be before toMs");
-  if (q.toMs - q.fromMs > MAX_RANGE_MS) {
-    throw new HistoryQueryError("range exceeds 400 days");
+  return resolved;
+}
+function resolvePhysicalLimit(options) {
+  if (options.maxPhysicalBytes === null) return null;
+  if (options.maxPhysicalBytes !== void 0) {
+    if (!Number.isSafeInteger(options.maxPhysicalBytes) || options.maxPhysicalBytes < 16 * 1024) {
+      throw new Error("maxPhysicalBytes must be a safe integer of at least 16 KiB or null");
+    }
+    return options.maxPhysicalBytes;
   }
+  if (options.maxDatabaseBytes !== null && options.maxDatabaseBytes !== void 0 && options.maxDatabaseBytes >= MIN_DERIVED_PHYSICAL_BYTES) {
+    return options.maxDatabaseBytes;
+  }
+  return DEFAULT_MAX_DATABASE_DISK_BYTES;
 }
-function validatedMaxPoints(value) {
-  if (value === void 0) return DEFAULT_MAX_POINTS;
-  if (!Number.isSafeInteger(value) || value <= 0) {
-    throw new HistoryQueryError("maxPoints must be a positive safe integer");
+function nonnegativeInt(value, fallback, name) {
+  const resolved = value ?? fallback;
+  if (!Number.isSafeInteger(resolved) || resolved < 0) {
+    throw new Error(`${name} must be a nonnegative safe integer`);
   }
-  return Math.min(value, MAX_POINTS);
+  return resolved;
 }
-function validatedBudget(value, fallback, name) {
-  if (value === void 0) return fallback;
-  if (!Number.isSafeInteger(value) || value <= 0) {
-    throw new HistoryQueryError(`${name} must be a positive safe integer`);
+var SUMMARY_STEP_MS = 1e4;
+function addSummaryPoint(summaries, seriesId, tsMs, value) {
+  const bucketMs = Math.floor(tsMs / SUMMARY_STEP_MS) * SUMMARY_STEP_MS;
+  let buckets = summaries.get(seriesId);
+  if (buckets === void 0) {
+    buckets = /* @__PURE__ */ new Map();
+    summaries.set(seriesId, buckets);
+  }
+  let aggregate = buckets.get(bucketMs);
+  if (aggregate === void 0) {
+    aggregate = { min: null, max: null, sum: 0, count: 0, nullCount: 0 };
+    buckets.set(bucketMs, aggregate);
+  }
+  if (value === null) {
+    aggregate.nullCount += 1;
+  } else {
+    aggregate.min = aggregate.min === null ? value : Math.min(aggregate.min, value);
+    aggregate.max = aggregate.max === null ? value : Math.max(aggregate.max, value);
+    aggregate.sum += value;
+    aggregate.count += 1;
   }
-  return value;
+}
+function yieldToEventLoop2() {
+  return new Promise((resolve7) => setImmediate(resolve7));
 }
 
 // src/operations/measure.ts
@@ -4646,7 +4899,7 @@ async function measure(options = {}) {
     const historyWallStart = import_node_perf_hooks2.performance.now();
     const historyHolder = { value: null };
     const runHistoryQuery = async () => {
-      await new Promise((resolve6) => setImmediate(resolve6));
+      await new Promise((resolve7) => setImmediate(resolve7));
       const historyStart = import_node_perf_hooks2.performance.now();
       const result = queryHistory(
         database,
@@ -4765,6 +5018,7 @@ Usage:
                [--database PATH] [--activate --confirm-stopped] [--install-deps] [--json]
   ops activate --prefix DIR --state-dir DIR --version V [--confirm-stopped] [--json]
   ops rollback --prefix DIR --state-dir DIR --confirm-stopped [--json]
+  ops reset-telemetry --database PATH [--backup-dir DIR] --confirm-stopped [--json]
   ops recover-admin --database PATH --password-file PATH [--user NAME] [--enable] [--json]
   ops measure  [--machines N] [--batches N] [--records-per-batch N] [--gpus N]
                [--viewers N] [--history-concurrency N] [--history-points N] [--mode live|replay|mixed]
@@ -5051,6 +5305,42 @@ async function run() {
     }
     return 0;
   }
+  if (command === "reset-telemetry") {
+    const parsed = (0, import_node_util.parseArgs)({
+      args: options,
+      options: {
+        database: { type: "string" },
+        "backup-dir": { type: "string" },
+        "confirm-stopped": { type: "boolean" },
+        json: { type: "boolean" }
+      },
+      allowPositionals: false
+    });
+    const database = optionString(parsed.values, "database", true);
+    const backupDir = optionString(parsed.values, "backup-dir");
+    let backupPath = null;
+    if (backupDir !== void 0) {
+      const report2 = await backupDatabase({
+        database,
+        output: (0, import_node_path8.resolve)(backupDir, `telemetry-pre-reset-${Date.now()}.sqlite`)
+      });
+      backupPath = report2.output;
+    }
+    const report = resetTelemetryHistory({
+      database,
+      confirmStopped: optionBoolean(parsed.values, "confirm-stopped")
+    });
+    if (optionBoolean(parsed.values, "json")) {
+      console.log(JSON.stringify({ ...report, backupPath }, null, 2));
+    } else {
+      console.log(`telemetry history reset: ${report.database}`);
+      console.log(`deleted rows: ${Object.entries(report.deleted).map(([table, rows]) => `${table}=${rows}`).join(", ")}`);
+      console.log(`preserved: ${report.preserved.join(", ")}`);
+      console.log(`integrity: ${report.integrity}`);
+      if (backupPath !== null) console.log(`pre-reset backup: ${backupPath}`);
+    }
+    return 0;
+  }
   if (command === "recover-admin") {
     const parsed = (0, import_node_util.parseArgs)({
       args: options,