@noego/telemetry 0.0.1

package/dist/sqlite/index.js

@@ -0,0 +1,3382 @@
+/* @noego/telemetry */
+
+// src/transports/sqlite_transport.ts
+import { randomUUID } from "crypto";
+import { resolve as resolve2 } from "path";
+import { fileURLToPath } from "url";
+import { MigrationRunnerFactory } from "@noego/proper";
+import BetterSqlite3 from "better-sqlite3";
+import { createSqliteDb } from "sqlstack/adapters";
+
+// src/core/helper/canonical_json.ts
+var UTF8_ENCODER = new TextEncoder();
+function compareCanonicalKeys(left, right) {
+  if (left === right) return 0;
+  if (/^[\x00-\x7f]*$/.test(left) && /^[\x00-\x7f]*$/.test(right)) {
+    return left < right ? -1 : 1;
+  }
+  const leftBytes = UTF8_ENCODER.encode(left);
+  const rightBytes = UTF8_ENCODER.encode(right);
+  const length = Math.min(leftBytes.length, rightBytes.length);
+  for (let index = 0; index < length; index += 1) {
+    const difference = (leftBytes[index] ?? 0) - (rightBytes[index] ?? 0);
+    if (difference !== 0) return difference;
+  }
+  return leftBytes.length - rightBytes.length;
+}
+function canonicalJson(value) {
+  if (value === null || typeof value === "string" || typeof value === "boolean") {
+    return JSON.stringify(value);
+  }
+  if (typeof value === "number") {
+    if (!Number.isFinite(value)) {
+      throw new Error("Canonical telemetry JSON cannot encode a non-finite number");
+    }
+    return JSON.stringify(value);
+  }
+  if (Array.isArray(value)) {
+    const items = value.map((item) => canonicalJson(item));
+    return `[${items.join(",")}]`;
+  }
+  if (typeof value !== "object") {
+    throw new Error(`Canonical telemetry JSON cannot encode ${typeof value}`);
+  }
+  const entries = Object.entries(value).sort(([left], [right]) => compareCanonicalKeys(left, right));
+  const properties = entries.map(([key, item]) => `${JSON.stringify(key)}:${canonicalJson(item)}`);
+  return `{${properties.join(",")}}`;
+}
+function telemetryUtf8Length(value) {
+  return new TextEncoder().encode(value).byteLength;
+}
+function telemetryChecksum(value) {
+  const bytes = new TextEncoder().encode(canonicalJson(value));
+  let hash = 0xcbf29ce484222325n;
+  const prime = 0x100000001b3n;
+  for (const byte of bytes) {
+    hash ^= BigInt(byte);
+    hash = BigInt.asUintN(64, hash * prime);
+  }
+  return hash.toString(16).padStart(16, "0");
+}
+
+// src/storage/helper/sqlite_table_names.ts
+var SQLITE_LOGICAL_TABLE_NAMES = [
+  "rawEvents",
+  "batchAcknowledgements",
+  "ingestWatermarks",
+  "metricDefinitions",
+  "metricSamples",
+  "metricRollups",
+  "rollupCompletions",
+  "extractionFailures",
+  "maintenanceRuns",
+  "readerLeases",
+  "committedDropCounters",
+  "migrationHistory"
+];
+var SQLITE_DEFAULT_TABLE_NAMES = Object.freeze({
+  rawEvents: "raw_events",
+  batchAcknowledgements: "batch_acknowledgements",
+  ingestWatermarks: "ingest_watermarks",
+  metricDefinitions: "metric_definitions",
+  metricSamples: "metric_samples",
+  metricRollups: "metric_rollups",
+  rollupCompletions: "rollup_completions",
+  extractionFailures: "extraction_failures",
+  maintenanceRuns: "maintenance_runs",
+  readerLeases: "reader_leases",
+  committedDropCounters: "committed_drop_counters",
+  migrationHistory: "migration_history"
+});
+var SQLITE_SCHEMA_MANIFEST_TABLE = "telemetry_schema_manifest";
+
+// src/storage/sqlite_ownership_lease.ts
+import {
+  closeSync,
+  existsSync,
+  mkdirSync,
+  openSync,
+  readFileSync,
+  realpathSync,
+  renameSync,
+  rmSync,
+  writeFileSync
+} from "fs";
+import { dirname, resolve } from "path";
+var SqliteOwnershipLease = class {
+  constructor(options) {
+    this.options = options;
+    mkdirSync(dirname(options.databasePath), { recursive: true });
+    const canonicalDirectory = realpathSync(dirname(resolve(options.databasePath)));
+    const databaseName = resolve(options.databasePath).slice(dirname(resolve(options.databasePath)).length + 1);
+    this.canonicalDatabasePath = resolve(canonicalDirectory, databaseName);
+    this.leasePath = `${this.canonicalDatabasePath}.telemetry-owner.json`;
+  }
+  options;
+  canonicalDatabasePath;
+  leasePath;
+  held = false;
+  acquire() {
+    const firstAttempt = this.writeExclusive(this.createRecord());
+    if (firstAttempt.ok) {
+      this.held = true;
+      return firstAttempt;
+    }
+    const recovered = this.recoverStaleLease();
+    if (!recovered.ok) {
+      return recovered;
+    }
+    const secondAttempt = this.writeExclusive(this.createRecord());
+    if (secondAttempt.ok) {
+      this.held = true;
+    }
+    return secondAttempt;
+  }
+  heartbeat() {
+    if (!this.held) {
+      return { ok: false, error: "Cannot heartbeat a telemetry lease that is not held" };
+    }
+    const current = this.readRecord();
+    if (!current.ok) {
+      return current;
+    }
+    if (current.value.processToken !== this.options.processToken) {
+      this.held = false;
+      return { ok: false, error: "Telemetry ownership lease was replaced by another owner" };
+    }
+    const now = this.options.now();
+    return this.writeReplace({
+      ...current.value,
+      heartbeatAtMs: now,
+      expiresAtMs: now + this.options.expiryMs
+    });
+  }
+  release() {
+    if (!this.held || !existsSync(this.leasePath)) {
+      this.held = false;
+      return;
+    }
+    const current = this.readRecord();
+    if (current.ok && current.value.processToken === this.options.processToken) {
+      try {
+        rmSync(this.leasePath, { force: true });
+      } catch {
+      }
+    }
+    this.held = false;
+  }
+  isHeld() {
+    return this.held;
+  }
+  path() {
+    return this.leasePath;
+  }
+  createRecord() {
+    const now = this.options.now();
+    return {
+      formatVersion: 1,
+      targetId: this.options.targetId,
+      databasePath: this.canonicalDatabasePath,
+      mode: this.options.mode,
+      pid: process.pid,
+      processToken: this.options.processToken,
+      acquiredAtMs: now,
+      heartbeatAtMs: now,
+      expiresAtMs: now + this.options.expiryMs
+    };
+  }
+  writeExclusive(record) {
+    let descriptor = null;
+    try {
+      descriptor = openSync(this.leasePath, "wx", 384);
+      writeFileSync(descriptor, JSON.stringify(record), { encoding: "utf8" });
+      closeSync(descriptor);
+      return { ok: true, value: void 0 };
+    } catch (cause) {
+      if (descriptor !== null) {
+        try {
+          closeSync(descriptor);
+        } catch {
+        }
+      }
+      return { ok: false, error: this.errorMessage(cause) };
+    }
+  }
+  writeReplace(record) {
+    const temporaryPath = `${this.leasePath}.${this.options.processToken}.tmp`;
+    try {
+      writeFileSync(temporaryPath, JSON.stringify(record), { encoding: "utf8", mode: 384 });
+      renameSync(temporaryPath, this.leasePath);
+      return { ok: true, value: void 0 };
+    } catch (cause) {
+      try {
+        rmSync(temporaryPath, { force: true });
+      } catch {
+      }
+      return { ok: false, error: this.errorMessage(cause) };
+    }
+  }
+  readRecord() {
+    try {
+      const parsed = JSON.parse(readFileSync(this.leasePath, "utf8"));
+      if (!this.isLeaseRecord(parsed)) {
+        return { ok: false, error: `Invalid telemetry ownership lease at ${this.leasePath}` };
+      }
+      return { ok: true, value: parsed };
+    } catch (cause) {
+      return { ok: false, error: this.errorMessage(cause) };
+    }
+  }
+  recoverStaleLease() {
+    const current = this.readRecord();
+    if (!current.ok) {
+      return current;
+    }
+    const expired = current.value.expiresAtMs < this.options.now();
+    const processAlive = this.isProcessAlive(current.value.pid);
+    if (!expired || processAlive) {
+      return {
+        ok: false,
+        error: `Telemetry target ${this.options.targetId} is owned by pid ${current.value.pid} (${current.value.mode})`
+      };
+    }
+    try {
+      const stalePath = `${this.leasePath}.stale.${current.value.processToken}`;
+      renameSync(this.leasePath, stalePath);
+      rmSync(stalePath, { force: true });
+      return { ok: true, value: void 0 };
+    } catch (cause) {
+      return { ok: false, error: this.errorMessage(cause) };
+    }
+  }
+  isProcessAlive(pid) {
+    try {
+      process.kill(pid, 0);
+      return true;
+    } catch (cause) {
+      const code = typeof cause === "object" && cause !== null && "code" in cause ? Reflect.get(cause, "code") : null;
+      return code === "EPERM";
+    }
+  }
+  isLeaseRecord(value) {
+    if (typeof value !== "object" || value === null || Array.isArray(value)) {
+      return false;
+    }
+    return Reflect.get(value, "formatVersion") === 1 && typeof Reflect.get(value, "targetId") === "string" && typeof Reflect.get(value, "databasePath") === "string" && (Reflect.get(value, "mode") === "writer" || Reflect.get(value, "mode") === "offline-maintenance") && Number.isInteger(Reflect.get(value, "pid")) && typeof Reflect.get(value, "processToken") === "string" && typeof Reflect.get(value, "acquiredAtMs") === "number" && typeof Reflect.get(value, "heartbeatAtMs") === "number" && typeof Reflect.get(value, "expiresAtMs") === "number";
+  }
+  errorMessage(cause) {
+    return cause instanceof Error ? cause.message : String(cause);
+  }
+};
+
+// src/storage/telemetry_proper_sql_runner.ts
+var TelemetryProperSqlRunner = class {
+  constructor(connection, tableMap) {
+    this.connection = connection;
+    this.tableMap = tableMap;
+  }
+  connection;
+  tableMap;
+  async query(sql, params = []) {
+    const substituted = this.substitute(sql);
+    const normalized = this.leadingKeyword(substituted);
+    if (normalized === "SELECT" || normalized === "WITH" || normalized === "PRAGMA" || normalized === "EXPLAIN") {
+      return [this.connection.prepare(substituted).all(...params), void 0];
+    }
+    if (params.length > 0) {
+      return [this.connection.prepare(substituted).run(...params), void 0];
+    }
+    this.connection.exec(substituted);
+    return [{ changes: 0 }, void 0];
+  }
+  async execute(sql, params = []) {
+    const substituted = this.substitute(sql);
+    if (params.length > 0) {
+      return [this.connection.prepare(substituted).run(...params), void 0];
+    }
+    this.connection.exec(substituted);
+    return [{ changes: 0 }, void 0];
+  }
+  async end() {
+  }
+  substitute(sql) {
+    const substituted = this.tableMap.substitute(sql);
+    if (!substituted.ok) {
+      throw new Error(substituted.error);
+    }
+    return substituted.value;
+  }
+  leadingKeyword(sql) {
+    const withoutComments = sql.replace(/--.*$/gm, "").replace(/\/\*[\s\S]*?\*\//g, "").trimStart();
+    return withoutComments.split(/\s+/, 1)[0]?.toUpperCase() ?? "";
+  }
+};
+
+// src/storage/telemetry_repository.ts
+import { createHash } from "crypto";
+
+// src/core/metric_definition_contract.ts
+var MetricDefinitionContract = class {
+  normalize(definition) {
+    const parsedSelector = this.parseSelector(definition.selector);
+    if (!parsedSelector.ok) {
+      return parsedSelector;
+    }
+    const bracketGroupBy = parsedSelector.value.groupBy;
+    const configuredGroupBy = definition.groupBy;
+    const bothSpecifyDifferentGrouping = bracketGroupBy.length > 0 && configuredGroupBy.length > 0 && bracketGroupBy.join(".") !== configuredGroupBy.join(".");
+    if (bothSpecifyDifferentGrouping) {
+      return { ok: false, error: `Metric ${definition.name} has conflicting selector and groupBy declarations` };
+    }
+    const groupBy = configuredGroupBy.length > 0 ? configuredGroupBy : bracketGroupBy;
+    const basicError = this.validateBasic(definition, parsedSelector.value.selector, groupBy);
+    if (basicError !== null) {
+      return { ok: false, error: basicError };
+    }
+    if (parsedSelector.value.wildcardUngrouped && definition.measurements.some((measurement) => measurement.kind !== "count")) {
+      return {
+        ok: false,
+        error: `Metric ${definition.name} uses [*] and may only declare count`
+      };
+    }
+    return {
+      ok: true,
+      value: Object.freeze({
+        ...definition,
+        selector: parsedSelector.value.selector,
+        groupBy: Object.freeze([...groupBy]),
+        resolutionsMs: Object.freeze([...definition.resolutionsMs].sort((left, right) => left - right)),
+        measurements: Object.freeze([...definition.measurements]),
+        targetIds: Object.freeze([...definition.targetIds]),
+        cardinality: Object.freeze({ ...definition.cardinality })
+      })
+    };
+  }
+  matches(selector, label) {
+    const selectorSegments = selector.split(".");
+    const labelSegments = label.split(".");
+    return this.matchSegments(selectorSegments, labelSegments, 0, 0);
+  }
+  parseSelector(selector) {
+    if (selector.startsWith("[")) {
+      return { ok: false, error: "A metric selector cannot omit its event label or glob" };
+    }
+    const bracketStart = selector.lastIndexOf("[");
+    if (bracketStart < 0) {
+      return { ok: true, value: { selector, groupBy: [], wildcardUngrouped: false } };
+    }
+    if (!selector.endsWith("]")) {
+      return { ok: false, error: `Invalid metric selector ${selector}` };
+    }
+    const eventSelector = selector.slice(0, bracketStart);
+    const bracket = selector.slice(bracketStart + 1, -1).trim();
+    if (!eventSelector || !bracket) {
+      return { ok: false, error: `Invalid metric selector ${selector}` };
+    }
+    return {
+      ok: true,
+      value: {
+        selector: eventSelector,
+        groupBy: bracket === "*" ? [] : [bracket],
+        wildcardUngrouped: bracket === "*"
+      }
+    };
+  }
+  validateBasic(definition, selector, groupBy) {
+    if (!/^[A-Za-z0-9_*][A-Za-z0-9_.:*\-]*$/.test(selector)) {
+      return `Metric ${definition.name} has an invalid selector`;
+    }
+    if (!/^[A-Za-z][A-Za-z0-9_]*$/.test(definition.name)) {
+      return `Metric name ${definition.name} is invalid`;
+    }
+    if (!Number.isInteger(definition.version) || definition.version <= 0) {
+      return `Metric ${definition.name} must have a positive integer version`;
+    }
+    if (definition.measurements.length === 0) {
+      return `Metric ${definition.name} must declare at least one measurement`;
+    }
+    const invalidResolution = definition.resolutionsMs.some(
+      (resolution) => !Number.isInteger(resolution) || resolution <= 0
+    );
+    const duplicateResolution = new Set(definition.resolutionsMs).size !== definition.resolutionsMs.length;
+    if (invalidResolution || duplicateResolution || definition.resolutionsMs.length === 0) {
+      return `Metric ${definition.name} has invalid or duplicate resolutions`;
+    }
+    const missingCardinality = groupBy.find((field) => definition.cardinality[field] === void 0);
+    if (missingCardinality) {
+      return `Metric ${definition.name} is missing cardinality policy for ${missingCardinality}`;
+    }
+    const invalidCardinality = Object.values(definition.cardinality).some(
+      (rule) => !Number.isInteger(rule.maxValuesPerBucket) || rule.maxValuesPerBucket <= 0
+    );
+    if (invalidCardinality) {
+      return `Metric ${definition.name} has an invalid cardinality limit`;
+    }
+    return null;
+  }
+  matchSegments(selector, label, selectorIndex, labelIndex) {
+    if (selectorIndex === selector.length) {
+      return labelIndex === label.length;
+    }
+    const segment = selector[selectorIndex];
+    if (segment === "**") {
+      if (selectorIndex === selector.length - 1) {
+        return true;
+      }
+      for (let next = labelIndex; next <= label.length; next += 1) {
+        if (this.matchSegments(selector, label, selectorIndex + 1, next)) {
+          return true;
+        }
+      }
+      return false;
+    }
+    if (labelIndex >= label.length) {
+      return false;
+    }
+    const segmentMatches = segment === "*" || segment === label[labelIndex];
+    return segmentMatches && this.matchSegments(selector, label, selectorIndex + 1, labelIndex + 1);
+  }
+};
+
+// src/storage/schema/telemetry_repository_rows.ts
+import { z } from "zod";
+var integer = z.number().int();
+var RawTelemetryEventRowSchema = z.object({
+  producer_id: z.string(),
+  sequence: integer.nonnegative(),
+  event_id: z.string(),
+  occurred_at_ms: integer,
+  monotonic_ns: z.string().nullable(),
+  source: z.string(),
+  process_kind: z.string(),
+  level: z.string(),
+  label: z.string(),
+  conversation_id: z.string().nullable(),
+  conversation_id_kind: z.enum(["string", "number"]).nullable(),
+  correlation_id: z.string().nullable(),
+  metadata_json: z.string(),
+  schema_version: integer.positive()
+}).strict();
+var BatchAcknowledgementRowSchema = z.object({
+  idempotency_key: z.string(),
+  producer_id: z.string(),
+  sequence_start: integer.nonnegative(),
+  sequence_end: integer.nonnegative(),
+  schema_version: integer.positive(),
+  checksum: z.string(),
+  accepted_events: integer.nonnegative(),
+  committed_at_ms: integer
+}).strict();
+var MetricSampleRowSchema = z.object({
+  metric_name: z.string(),
+  definition_version: integer.positive(),
+  occurred_at_ms: integer,
+  producer_id: z.string(),
+  sequence: integer.nonnegative(),
+  dimension_key: z.string(),
+  dimensions_json: z.string(),
+  values_json: z.string()
+}).strict();
+var MetricRollupRowSchema = z.object({
+  metric_name: z.string(),
+  definition_version: integer.positive(),
+  resolution_ms: integer.positive(),
+  bucket_start_ms: integer,
+  dimension_key: z.string(),
+  dimensions_json: z.string(),
+  values_json: z.string()
+}).strict();
+var RollupCompletionRowSchema = z.object({
+  metric_name: z.string(),
+  definition_version: integer.positive(),
+  resolution_ms: integer.positive(),
+  bucket_start_ms: integer,
+  sample_count: integer.nonnegative(),
+  sample_watermark_ms: integer,
+  completed_at_ms: integer,
+  state: z.enum(["completed", "rejected"]),
+  detail: z.string().nullable()
+}).strict();
+var TimelineCursorSchema = z.object({
+  version: z.literal(1),
+  order: z.enum(["asc", "desc"]),
+  occurredAtMs: integer,
+  producerId: z.string(),
+  sequence: integer.nonnegative()
+}).strict();
+var MetricCursorSchema = z.object({
+  version: z.literal(1),
+  order: z.enum(["asc", "desc"]),
+  bucketStartMs: integer,
+  resolutionMs: integer.positive(),
+  definitionVersion: integer.positive(),
+  dimensionKey: z.string()
+}).strict();
+var TelemetryJsonObjectSchema = z.record(z.string(), z.json());
+var NumericValuesSchema = z.record(z.string(), z.number().finite());
+var StoredMetricMeasurementSchema = z.discriminatedUnion("kind", [
+  z.object({ kind: z.literal("count") }).strict(),
+  z.object({
+    kind: z.literal("field"),
+    field: z.string().min(1),
+    aggregates: z.array(z.enum(["sum", "min", "max", "last"])).min(1)
+  }).strict()
+]);
+var StoredMetricDefinitionSchema = z.object({
+  name: z.string().min(1),
+  version: integer.positive(),
+  selector: z.string().min(1),
+  groupBy: z.array(z.string().min(1)),
+  measurements: z.array(StoredMetricMeasurementSchema).min(1),
+  cardinality: z.record(
+    z.string(),
+    z.object({
+      maxValuesPerBucket: integer.positive(),
+      overflow: z.enum(["other", "drop", "reject"])
+    }).strict()
+  ),
+  targetIds: z.array(z.string().min(1)),
+  resolutionsMs: z.array(integer.positive()).min(1),
+  missingField: z.enum(["skip", "record-failure"])
+}).strict();
+var StoredMetricDefinitionRowSchema = z.object({
+  metric_name: z.string(),
+  definition_version: integer.positive(),
+  definition_json: z.string(),
+  definition_checksum: z.string(),
+  active: integer.min(0).max(1)
+}).strict();
+var MetricRollupValuesSchema = z.object({
+  count: integer.nonnegative(),
+  fields: z.record(
+    z.string(),
+    z.object({
+      count: integer.nonnegative(),
+      sum: z.number().finite(),
+      min: z.number().finite(),
+      max: z.number().finite(),
+      last: z.number().finite(),
+      lastOccurredAtMs: integer,
+      lastProducerId: z.string(),
+      lastSequence: integer.nonnegative()
+    }).strict()
+  )
+}).strict();
+
+// src/storage/telemetry_repository_row_parser.ts
+var TelemetryRepositoryRowParser = class {
+  parseRawEnvelope(input) {
+    const parsed = RawTelemetryEventRowSchema.safeParse(input);
+    if (!parsed.success) {
+      return { ok: false, error: parsed.error.message };
+    }
+    const metadata = this.parseJsonObject(parsed.data.metadata_json);
+    if (!metadata.ok) {
+      return metadata;
+    }
+    const conversationId = this.parseConversationId(
+      parsed.data.conversation_id,
+      parsed.data.conversation_id_kind
+    );
+    if (!conversationId.ok) {
+      return conversationId;
+    }
+    return {
+      ok: true,
+      value: Object.freeze({
+        schemaVersion: parsed.data.schema_version,
+        eventId: parsed.data.event_id,
+        producerId: parsed.data.producer_id,
+        sequence: parsed.data.sequence,
+        occurredAtMs: parsed.data.occurred_at_ms,
+        monotonicNs: parsed.data.monotonic_ns,
+        source: parsed.data.source,
+        processKind: parsed.data.process_kind,
+        level: parsed.data.level,
+        label: parsed.data.label,
+        conversationId: conversationId.value,
+        correlationId: parsed.data.correlation_id,
+        metadata: metadata.value
+      })
+    };
+  }
+  parseMetricSample(input) {
+    const parsed = MetricSampleRowSchema.safeParse(input);
+    return parsed.success ? { ok: true, value: parsed.data } : { ok: false, error: parsed.error.message };
+  }
+  parseMetricRollup(input) {
+    const parsed = MetricRollupRowSchema.safeParse(input);
+    return parsed.success ? { ok: true, value: parsed.data } : { ok: false, error: parsed.error.message };
+  }
+  parseJsonObject(input) {
+    try {
+      const decoded = JSON.parse(input);
+      const parsed = TelemetryJsonObjectSchema.safeParse(decoded);
+      return parsed.success ? { ok: true, value: Object.freeze(parsed.data) } : { ok: false, error: parsed.error.message };
+    } catch (cause) {
+      return { ok: false, error: cause instanceof Error ? cause.message : String(cause) };
+    }
+  }
+  parseNumericValues(input) {
+    try {
+      const decoded = JSON.parse(input);
+      const parsed = NumericValuesSchema.safeParse(decoded);
+      return parsed.success ? { ok: true, value: Object.freeze(parsed.data) } : { ok: false, error: parsed.error.message };
+    } catch (cause) {
+      return { ok: false, error: cause instanceof Error ? cause.message : String(cause) };
+    }
+  }
+  parseRollupValues(input) {
+    try {
+      const decoded = JSON.parse(input);
+      const parsed = MetricRollupValuesSchema.safeParse(decoded);
+      return parsed.success ? { ok: true, value: parsed.data } : { ok: false, error: parsed.error.message };
+    } catch (cause) {
+      return { ok: false, error: cause instanceof Error ? cause.message : String(cause) };
+    }
+  }
+  parseTimelineCursor(input) {
+    return this.parseCursor(input, TimelineCursorSchema);
+  }
+  parseMetricCursor(input) {
+    return this.parseCursor(input, MetricCursorSchema);
+  }
+  parseCursor(input, schema) {
+    try {
+      const decodedText = Buffer.from(input, "base64url").toString("utf8");
+      const decoded = JSON.parse(decodedText);
+      const parsed = schema.safeParse(decoded);
+      return parsed.success ? { ok: true, value: parsed.data } : { ok: false, error: parsed.error.message };
+    } catch (cause) {
+      return { ok: false, error: cause instanceof Error ? cause.message : String(cause) };
+    }
+  }
+  parseConversationId(value, kind) {
+    if (value === null) {
+      return { ok: true, value: null };
+    }
+    if (kind === "string") {
+      return { ok: true, value };
+    }
+    if (kind === "number") {
+      const numeric = Number(value);
+      return Number.isFinite(numeric) ? { ok: true, value: numeric } : { ok: false, error: `Invalid numeric conversation id ${value}` };
+    }
+    return { ok: false, error: "Conversation id kind is missing" };
+  }
+};
+
+// src/storage/telemetry_repository.ts
+var RETENTION_PAGE_SIZE = 500;
+var MetricCardinalityRejectionError = class extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "MetricCardinalityRejectionError";
+  }
+};
+var TelemetryRepository = class {
+  constructor(options) {
+    this.options = options;
+  }
+  options;
+  rowParser = new TelemetryRepositoryRowParser();
+  definitionContract = new MetricDefinitionContract();
+  definitions = /* @__PURE__ */ new Map();
+  registerDefinitions(definitions) {
+    try {
+      const normalizedDefinitions = this.normalizeDefinitions(definitions);
+      const registeredAtMs = this.options.now();
+      const byName = /* @__PURE__ */ new Map();
+      for (const definition of normalizedDefinitions) {
+        const versions = byName.get(definition.name) ?? [];
+        versions.push(definition);
+        byName.set(definition.name, versions);
+      }
+      const transaction = this.options.connection.transaction(() => {
+        const table = this.options.tableMap.quoted("metricDefinitions");
+        const deactivate = this.options.connection.prepare(
+          `UPDATE ${table} SET active = 0 WHERE target_id = ? AND metric_name = ?`
+        );
+        const existing = this.options.connection.prepare(
+          `SELECT definition_checksum FROM ${table}
+           WHERE target_id = ? AND metric_name = ? AND definition_version = ?`
+        );
+        const insert = this.options.connection.prepare(
+          `INSERT INTO ${table} (
+             target_id, metric_name, definition_version, definition_json,
+             definition_checksum, active, registered_at_ms
+           ) VALUES (?, ?, ?, ?, ?, ?, ?)`
+        );
+        const activate = this.options.connection.prepare(
+          `UPDATE ${table} SET active = 1
+           WHERE target_id = ? AND metric_name = ? AND definition_version = ?`
+        );
+        for (const [metricName, versions] of byName) {
+          deactivate.run(this.options.targetId, metricName);
+          const latestVersion = Math.max(...versions.map((definition) => definition.version));
+          for (const definition of versions) {
+            const definitionJson = canonicalJson(definition);
+            const definitionChecksum = telemetryChecksum(definition);
+            const prior = existing.get(this.options.targetId, definition.name, definition.version);
+            if (prior !== void 0) {
+              const priorChecksum = this.readStringField(prior, "definition_checksum");
+              if (priorChecksum !== definitionChecksum) {
+                throw new Error(
+                  `Metric ${definition.name} version ${definition.version} changed without a version bump`
+                );
+              }
+            } else {
+              insert.run(
+                this.options.targetId,
+                definition.name,
+                definition.version,
+                definitionJson,
+                definitionChecksum,
+                definition.version === latestVersion ? 1 : 0,
+                registeredAtMs
+              );
+            }
+          }
+          activate.run(this.options.targetId, metricName, latestVersion);
+        }
+      });
+      transaction();
+      const loaded = this.loadDefinitionsReadOnly(normalizedDefinitions);
+      if (!loaded.ok) {
+        throw new Error(loaded.error);
+      }
+      return { ok: true, value: void 0 };
+    } catch (cause) {
+      return { ok: false, error: this.errorMessage(cause) };
+    }
+  }
+  loadDefinitionsReadOnly(expectedDefinitions) {
+    try {
+      const normalizedExpectedDefinitions = this.normalizeDefinitions(expectedDefinitions);
+      const table = this.options.tableMap.quoted("metricDefinitions");
+      const rows = this.options.connection.prepare(
+        `SELECT metric_name, definition_version, definition_json, definition_checksum, active
+         FROM ${table} WHERE target_id = ?`
+      ).all(this.options.targetId);
+      const loaded = /* @__PURE__ */ new Map();
+      for (const rawRow of rows) {
+        const row = StoredMetricDefinitionRowSchema.parse(rawRow);
+        const parsedJson = JSON.parse(row.definition_json);
+        const parsedDefinition = StoredMetricDefinitionSchema.parse(parsedJson);
+        const normalized = this.definitionContract.normalize(parsedDefinition);
+        if (!normalized.ok) {
+          throw new Error(normalized.error);
+        }
+        const definition = normalized.value;
+        const identityMatches = definition.name === row.metric_name && definition.version === row.definition_version;
+        if (!identityMatches) {
+          throw new Error("Stored metric definition identity does not match its row");
+        }
+        const checksum = telemetryChecksum(definition);
+        const canonicalRowMatches = checksum === row.definition_checksum && canonicalJson(definition) === row.definition_json;
+        const legacyRowMatches = !canonicalRowMatches && createHash("sha256").update(row.definition_json, "utf8").digest("hex") === row.definition_checksum;
+        if (!canonicalRowMatches && !legacyRowMatches) {
+          if (row.active !== 1) {
+            continue;
+          }
+          throw new Error(
+            `Stored metric ${definition.name} version ${definition.version} checksum is invalid`
+          );
+        }
+        loaded.set(this.definitionKey(definition.name, definition.version), definition);
+      }
+      for (const expected of normalizedExpectedDefinitions) {
+        const stored = loaded.get(this.definitionKey(expected.name, expected.version));
+        if (stored === void 0 || telemetryChecksum(stored) !== telemetryChecksum(expected)) {
+          throw new Error(
+            `Configured metric ${expected.name} version ${expected.version} is not registered in target ${this.options.targetId}`
+          );
+        }
+      }
+      this.definitions.clear();
+      for (const [identity, definition] of loaded) {
+        this.definitions.set(identity, definition);
+      }
+      return { ok: true, value: void 0 };
+    } catch (cause) {
+      return { ok: false, error: this.errorMessage(cause) };
+    }
+  }
+  persist(request) {
+    try {
+      const outsideHorizon = this.outsideIngestionHorizon(request.batch);
+      if (outsideHorizon !== null) {
+        return { kind: "acknowledged", acknowledgement: outsideHorizon };
+      }
+      const replay = this.findReplay(request.batch);
+      if (replay !== null) {
+        return { kind: "acknowledged", acknowledgement: replay };
+      }
+      const acknowledgement = this.persistTransaction(request);
+      return { kind: "acknowledged", acknowledgement };
+    } catch (cause) {
+      return { kind: "failed", reason: this.errorMessage(cause) };
+    }
+  }
+  timeline(query, rawRetentionCutoffMs) {
+    try {
+      const cursor = query.cursor === null ? null : this.rowParser.parseTimelineCursor(query.cursor);
+      if (cursor !== null && !cursor.ok) {
+        return { ok: false, error: { kind: "invalid-query", message: cursor.error } };
+      }
+      if (cursor !== null && cursor.value.order !== query.order) {
+        return {
+          ok: false,
+          error: { kind: "invalid-query", message: "Timeline cursor order changed" }
+        };
+      }
+      const availableFromMs = Math.max(query.fromMs, rawRetentionCutoffMs);
+      const clauses = ["target_id = ?", "occurred_at_ms >= ?", "occurred_at_ms < ?"];
+      const params = [this.options.targetId, availableFromMs, query.toMs];
+      this.addTimelineFilters(query, clauses, params);
+      if (cursor?.ok) {
+        this.addTimelineCursor(cursor.value, query.order, clauses, params);
+      }
+      const direction = query.order === "asc" ? "ASC" : "DESC";
+      const table = this.options.tableMap.quoted("rawEvents");
+      const sql = `SELECT
+          producer_id, sequence, event_id, occurred_at_ms, monotonic_ns,
+          source, process_kind, level, label, conversation_id,
+          conversation_id_kind, correlation_id, metadata_json, schema_version
+        FROM ${table}
+        WHERE ${clauses.join(" AND ")}
+        ORDER BY occurred_at_ms ${direction}, producer_id ${direction}, sequence ${direction}
+        LIMIT ?`;
+      params.push(query.limit + 1);
+      const rows = this.options.connection.prepare(sql).all(...params);
+      const hasNextPage = rows.length > query.limit;
+      const pageRows = hasNextPage ? rows.slice(0, query.limit) : rows;
+      const events = [];
+      for (const row of pageRows) {
+        const parsed = this.rowParser.parseRawEnvelope(row);
+        if (!parsed.ok) {
+          return { ok: false, error: { kind: "storage-failure", message: parsed.error } };
+        }
+        events.push(parsed.value);
+      }
+      const last = events[events.length - 1];
+      const nextCursor = hasNextPage && last ? this.encodeCursor({
+        version: 1,
+        order: query.order,
+        occurredAtMs: last.occurredAtMs,
+        producerId: last.producerId,
+        sequence: last.sequence
+      }) : null;
+      const unavailableEnd = Math.min(query.toMs, rawRetentionCutoffMs);
+      const gaps = query.fromMs < unavailableEnd ? [{ fromMs: query.fromMs, toMs: unavailableEnd, reason: "raw-retention" }] : [];
+      return {
+        ok: true,
+        value: {
+          targetId: this.options.targetId,
+          events: Object.freeze(events),
+          gaps: Object.freeze(gaps),
+          nextCursor
+        }
+      };
+    } catch (cause) {
+      return { ok: false, error: { kind: "storage-failure", message: this.errorMessage(cause) } };
+    }
+  }
+  metrics(query) {
+    try {
+      const definitions = this.metricDefinitions(query.metric);
+      if (definitions.length === 0) {
+        return {
+          ok: false,
+          error: { kind: "invalid-query", message: `Unknown metric ${query.metric}` }
+        };
+      }
+      const validationError = this.validateMetricQuery(query, definitions);
+      if (validationError !== null) {
+        return { ok: false, error: { kind: "invalid-query", message: validationError } };
+      }
+      const cursor = query.cursor === null ? null : this.rowParser.parseMetricCursor(query.cursor);
+      if (cursor !== null && !cursor.ok) {
+        return { ok: false, error: { kind: "invalid-query", message: cursor.error } };
+      }
+      if (cursor !== null && cursor.value.order !== query.order) {
+        return {
+          ok: false,
+          error: { kind: "invalid-query", message: "Metric cursor order changed" }
+        };
+      }
+      const coverage = this.planCoverage(query, definitions);
+      const rows = this.readRollupsForCoverage(query, coverage.intervals);
+      const filtered = rows.filter((row) => this.matchesWhere(row.bucket.dimensions, query.where));
+      const ordered = filtered.sort(
+        (left, right) => this.compareParsedRollups(left, right, query.order)
+      );
+      const afterCursor = cursor?.ok ? ordered.filter((row) => this.isAfterMetricCursor(row, cursor.value, query.order)) : ordered;
+      const hasNextPage = afterCursor.length > query.limit;
+      const page = hasNextPage ? afterCursor.slice(0, query.limit) : afterCursor;
+      const projected = page.map((row) => ({
+        ...row,
+        bucket: {
+          ...row.bucket,
+          values: this.selectMeasurements(row.bucket.values, query.measurements)
+        }
+      }));
+      const segments = this.rowsToSegments(coverage.intervals, projected);
+      const last = page[page.length - 1];
+      const nextCursor = hasNextPage && last ? this.encodeCursor({
+        version: 1,
+        order: query.order,
+        bucketStartMs: last.bucket.startMs,
+        resolutionMs: last.resolutionMs,
+        definitionVersion: last.definitionVersion,
+        dimensionKey: last.dimensionKey
+      }) : null;
+      return {
+        ok: true,
+        value: {
+          targetId: this.options.targetId,
+          metric: query.metric,
+          segments,
+          gaps: coverage.gaps,
+          nextCursor,
+          partialFailures: []
+        }
+      };
+    } catch (cause) {
+      return { ok: false, error: { kind: "storage-failure", message: this.errorMessage(cause) } };
+    }
+  }
+  materializeRollups(nowMs, maxWorkMs) {
+    const startedAt = this.options.now();
+    let affectedRows = 0;
+    let rejectedBucketCount = 0;
+    const rejectedBucketExamples = [];
+    try {
+      for (const definition of this.definitions.values()) {
+        for (const resolutionMs of definition.resolutionsMs) {
+          const dueBeforeMs = nowMs - this.options.retention.lateArrivalMs;
+          const bucketStarts = this.findDueBucketStarts(definition, resolutionMs, dueBeforeMs);
+          for (const bucketStartMs of bucketStarts) {
+            if (this.options.now() - startedAt >= maxWorkMs) {
+              return {
+                ok: true,
+                value: {
+                  stage: "rollup",
+                  affectedRows,
+                  affectedPages: 0,
+                  elapsedMs: this.options.now() - startedAt,
+                  detail: this.rollupStageDetail(
+                    rejectedBucketCount,
+                    rejectedBucketExamples,
+                    true
+                  )
+                }
+              };
+            }
+            const work = this.loadBucketWork(definition, resolutionMs, bucketStartMs);
+            if (this.bucketIsCurrent(work)) {
+              continue;
+            }
+            try {
+              affectedRows += this.materializeBucket(work, nowMs);
+            } catch (cause) {
+              if (!(cause instanceof MetricCardinalityRejectionError)) {
+                throw cause;
+              }
+              this.recordRejectedBucket(work, nowMs, cause.message);
+              rejectedBucketCount += 1;
+              if (rejectedBucketExamples.length < 3) {
+                rejectedBucketExamples.push(
+                  `${definition.name}:${definition.version}:${resolutionMs}:${bucketStartMs}: ${cause.message}`
+                );
+              }
+            }
+          }
+        }
+      }
+      return {
+        ok: true,
+        value: {
+          stage: "rollup",
+          affectedRows,
+          affectedPages: 0,
+          elapsedMs: this.options.now() - startedAt,
+          detail: this.rollupStageDetail(
+            rejectedBucketCount,
+            rejectedBucketExamples,
+            false
+          )
+        }
+      };
+    } catch (cause) {
+      return { ok: false, error: this.errorMessage(cause) };
+    }
+  }
+  beginRetentionDrain(nowMs) {
+    const steps = [
+      this.createRawEventRetentionStep(nowMs),
+      this.createSampleRetentionStep(nowMs),
+      ...this.createRollupRetentionSteps(nowMs),
+      ...this.createAuxiliaryRetentionSteps(nowMs)
+    ];
+    let index = 0;
+    return {
+      nextBatch: () => {
+        try {
+          if (steps.length === 0) {
+            return { ok: true, value: { deletedRows: 0, hasMore: false } };
+          }
+          if (index >= steps.length) {
+            index = 0;
+          }
+          const step = steps[index];
+          if (step === void 0) {
+            return { ok: true, value: { deletedRows: 0, hasMore: false } };
+          }
+          const outcome = step();
+          if (outcome.done) {
+            steps.splice(index, 1);
+          } else {
+            index += 1;
+          }
+          return {
+            ok: true,
+            value: { deletedRows: outcome.deleted, hasMore: steps.length > 0 }
+          };
+        } catch (cause) {
+          return { ok: false, error: this.errorMessage(cause) };
+        }
+      }
+    };
+  }
+  checkpoint() {
+    const startedAt = this.options.now();
+    try {
+      const rows = this.options.connection.pragma("wal_checkpoint(PASSIVE)");
+      return {
+        ok: true,
+        value: {
+          stage: "checkpoint",
+          affectedRows: Array.isArray(rows) ? rows.length : 0,
+          affectedPages: 0,
+          elapsedMs: this.options.now() - startedAt,
+          detail: null
+        }
+      };
+    } catch (cause) {
+      return { ok: false, error: this.errorMessage(cause) };
+    }
+  }
+  reclaim(maxPages) {
+    const startedAt = this.options.now();
+    try {
+      const before = Number(this.options.connection.pragma("freelist_count", { simple: true }));
+      this.options.connection.pragma(`incremental_vacuum(${Math.max(0, Math.floor(maxPages))})`);
+      const after = Number(this.options.connection.pragma("freelist_count", { simple: true }));
+      return {
+        ok: true,
+        value: {
+          stage: "reclaim",
+          affectedRows: 0,
+          affectedPages: Math.max(0, before - after),
+          elapsedMs: this.options.now() - startedAt,
+          detail: null
+        }
+      };
+    } catch (cause) {
+      return { ok: false, error: this.errorMessage(cause) };
+    }
+  }
+  pageStats() {
+    try {
+      return {
+        ok: true,
+        value: {
+          pageCount: Number(this.options.connection.pragma("page_count", { simple: true })),
+          freePages: Number(this.options.connection.pragma("freelist_count", { simple: true })),
+          pageSize: Number(this.options.connection.pragma("page_size", { simple: true }))
+        }
+      };
+    } catch (cause) {
+      return { ok: false, error: this.errorMessage(cause) };
+    }
+  }
+  recordMaintenance(record) {
+    try {
+      const table = this.options.tableMap.quoted("maintenanceRuns");
+      const affectedRows = record.stages.reduce((sum, stage) => sum + stage.affectedRows, 0);
+      const affectedPages = record.stages.reduce((sum, stage) => sum + stage.affectedPages, 0);
+      const detail = canonicalJson({
+        stages: record.stages,
+        failedStage: record.failedStage,
+        error: record.error
+      });
+      this.options.connection.prepare(
+        `INSERT INTO ${table} (
+           target_id, run_id, state, stage, started_at_ms, completed_at_ms,
+           affected_rows, affected_pages, detail
+         ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?)
+         ON CONFLICT(target_id, run_id, stage) DO UPDATE SET
+           state = excluded.state,
+           completed_at_ms = excluded.completed_at_ms,
+           affected_rows = excluded.affected_rows,
+           affected_pages = excluded.affected_pages,
+           detail = excluded.detail`
+      ).run(
+        this.options.targetId,
+        record.runId,
+        record.state,
+        record.kind,
+        record.startedAtMs,
+        record.completedAtMs,
+        affectedRows,
+        affectedPages,
+        detail
+      );
+      return { ok: true, value: void 0 };
+    } catch (cause) {
+      return { ok: false, error: this.errorMessage(cause) };
+    }
+  }
+  recoverInterruptedMaintenance(nowMs) {
+    try {
+      const table = this.options.tableMap.quoted("maintenanceRuns");
+      const detail = canonicalJson({
+        stages: [],
+        failedStage: null,
+        error: "interrupted-before-restart"
+      });
+      const result = this.options.connection.prepare(
+        `UPDATE ${table}
+         SET state = 'failed', completed_at_ms = ?, detail = ?
+         WHERE target_id = ? AND state = 'started'`
+      ).run(nowMs, detail, this.options.targetId);
+      return { ok: true, value: result.changes };
+    } catch (cause) {
+      return { ok: false, error: this.errorMessage(cause) };
+    }
+  }
+  committedDropCounters() {
+    try {
+      const table = this.options.tableMap.quoted("committedDropCounters");
+      const rows = this.options.connection.prepare(
+        `SELECT reason, priority, count
+           FROM ${table}
+           WHERE target_id = ?
+           ORDER BY reason ASC, priority ASC`
+      ).all(this.options.targetId);
+      const counters = rows.map((row) => this.parseCommittedDropCounter(row));
+      return { ok: true, value: Object.freeze(counters) };
+    } catch (cause) {
+      return { ok: false, error: this.errorMessage(cause) };
+    }
+  }
+  findReplay(batch) {
+    const table = this.options.tableMap.quoted("batchAcknowledgements");
+    const rows = this.options.connection.prepare(
+      `SELECT idempotency_key, producer_id, sequence_start, sequence_end,
+              schema_version, checksum, accepted_events, committed_at_ms
+       FROM ${table}
+       WHERE target_id = ? AND producer_id = ?
+         AND sequence_start <= ? AND sequence_end >= ?`
+    ).all(this.options.targetId, batch.producerId, batch.sequenceEnd, batch.sequenceStart);
+    if (rows.length === 0) {
+      return this.findPrunedReplayConflict(batch);
+    }
+    for (const row of rows) {
+      const parsed = BatchAcknowledgementRowSchema.safeParse(row);
+      if (!parsed.success) {
+        throw new Error(parsed.error.message);
+      }
+      const identical = parsed.data.idempotency_key === batch.idempotencyKey && parsed.data.checksum === batch.checksum && parsed.data.sequence_start === batch.sequenceStart && parsed.data.sequence_end === batch.sequenceEnd;
+      if (identical) {
+        return {
+          kind: "committed",
+          idempotencyKey: batch.idempotencyKey,
+          committedAtMs: parsed.data.committed_at_ms,
+          acceptedEvents: parsed.data.accepted_events,
+          duplicate: true,
+          targetStates: [this.committedTargetState(0)]
+        };
+      }
+    }
+    return {
+      kind: "conflict",
+      idempotencyKey: batch.idempotencyKey,
+      reason: "Producer sequence range overlaps a different committed batch",
+      targetStates: [
+        {
+          targetId: this.options.targetId,
+          delivery: "required",
+          state: "failed",
+          attempts: 1,
+          reason: "sequence-range-conflict"
+        }
+      ]
+    };
+  }
+  outsideIngestionHorizon(batch) {
+    const cutoffMs = this.options.now() - this.longestRetentionMs();
+    const containsExpiredEvent = batch.envelopes.some(
+      (envelope) => envelope.occurredAtMs < cutoffMs
+    );
+    if (!containsExpiredEvent) {
+      return null;
+    }
+    return {
+      kind: "rejected",
+      idempotencyKey: batch.idempotencyKey,
+      code: "invalid-batch",
+      reason: "Telemetry batch is older than the configured ingestion horizon",
+      targetStates: [
+        {
+          targetId: this.options.targetId,
+          delivery: "required",
+          state: "failed",
+          attempts: 1,
+          reason: "batch-outside-ingestion-horizon"
+        }
+      ]
+    };
+  }
+  findPrunedReplayConflict(batch) {
+    const table = this.options.tableMap.quoted("ingestWatermarks");
+    const row = this.options.connection.prepare(
+      `SELECT highest_sequence
+         FROM ${table}
+         WHERE target_id = ? AND producer_id = ?`
+    ).get(this.options.targetId, batch.producerId);
+    if (row === void 0) {
+      return null;
+    }
+    const highestSequence = this.readNumberField(row, "highest_sequence");
+    if (batch.sequenceStart > highestSequence) {
+      return null;
+    }
+    return {
+      kind: "conflict",
+      idempotencyKey: batch.idempotencyKey,
+      reason: "Producer sequence range is at or below the durable ingest watermark",
+      targetStates: [
+        {
+          targetId: this.options.targetId,
+          delivery: "required",
+          state: "failed",
+          attempts: 1,
+          reason: "sequence-at-or-below-watermark"
+        }
+      ]
+    };
+  }
+  persistTransaction(request) {
+    const committedAtMs = this.options.now();
+    const transaction = this.options.connection.transaction(() => {
+      this.insertRawEvents(request, committedAtMs);
+      this.insertMetricSamples(request, committedAtMs);
+      this.insertExtractionFailures(request, committedAtMs);
+      this.upsertCommittedDropCounters(request.batch, committedAtMs);
+      this.insertBatchAcknowledgement(request.batch, committedAtMs);
+      this.updateIngestWatermark(request.batch, committedAtMs);
+    });
+    transaction();
+    return {
+      kind: "committed",
+      idempotencyKey: request.batch.idempotencyKey,
+      committedAtMs,
+      acceptedEvents: request.batch.envelopes.length,
+      duplicate: false,
+      targetStates: [this.committedTargetState(1)]
+    };
+  }
+  insertRawEvents(request, insertedAtMs) {
+    const table = this.options.tableMap.quoted("rawEvents");
+    const insert = this.options.connection.prepare(
+      `INSERT INTO ${table} (
+         target_id, producer_id, sequence, event_id, batch_idempotency_key,
+         occurred_at_ms, monotonic_ns, source, process_kind, level, label,
+         conversation_id, conversation_id_kind, correlation_id, metadata_json,
+         schema_version, inserted_at_ms
+       ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`
+    );
+    for (const envelope of request.batch.envelopes) {
+      const conversationId = envelope.conversationId === null ? null : String(envelope.conversationId);
+      const conversationKind = envelope.conversationId === null ? null : typeof envelope.conversationId;
+      insert.run(
+        this.options.targetId,
+        envelope.producerId,
+        envelope.sequence,
+        envelope.eventId,
+        request.batch.idempotencyKey,
+        envelope.occurredAtMs,
+        envelope.monotonicNs,
+        envelope.source,
+        envelope.processKind,
+        envelope.level,
+        envelope.label,
+        conversationId,
+        conversationKind,
+        envelope.correlationId,
+        canonicalJson(envelope.metadata),
+        envelope.schemaVersion,
+        insertedAtMs
+      );
+    }
+  }
+  insertMetricSamples(request, _insertedAtMs) {
+    const samplesTable = this.options.tableMap.quoted("metricSamples");
+    const completionTable = this.options.tableMap.quoted("rollupCompletions");
+    const insert = this.options.connection.prepare(
+      `INSERT INTO ${samplesTable} (
+         target_id, metric_name, definition_version, occurred_at_ms,
+         producer_id, sequence, dimension_key, dimensions_json, values_json
+       ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?)`
+    );
+    const invalidate = this.options.connection.prepare(
+      `DELETE FROM ${completionTable}
+       WHERE target_id = ? AND metric_name = ? AND definition_version = ?
+         AND resolution_ms = ? AND bucket_start_ms = ?`
+    );
+    for (const sample of request.samples) {
+      insert.run(
+        this.options.targetId,
+        sample.metricName,
+        sample.definitionVersion,
+        sample.occurredAtMs,
+        sample.producerId,
+        sample.sequence,
+        sample.dimensionKey,
+        canonicalJson(sample.dimensions),
+        canonicalJson(sample.values)
+      );
+      const definition = this.definitions.get(
+        this.definitionKey(sample.metricName, sample.definitionVersion)
+      );
+      if (!definition) {
+        throw new Error(
+          `Missing registered metric definition ${sample.metricName}:${sample.definitionVersion}`
+        );
+      }
+      for (const resolutionMs of definition.resolutionsMs) {
+        const bucketStartMs = this.bucketStart(sample.occurredAtMs, resolutionMs);
+        invalidate.run(
+          this.options.targetId,
+          sample.metricName,
+          sample.definitionVersion,
+          resolutionMs,
+          bucketStartMs
+        );
+      }
+    }
+  }
+  insertExtractionFailures(request, recordedAtMs) {
+    const table = this.options.tableMap.quoted("extractionFailures");
+    const insert = this.options.connection.prepare(
+      `INSERT OR REPLACE INTO ${table} (
+         target_id, metric_name, definition_version, producer_id,
+         sequence, reason, recorded_at_ms
+       ) VALUES (?, ?, ?, ?, ?, ?, ?)`
+    );
+    for (const failure of request.extractionFailures) {
+      insert.run(
+        this.options.targetId,
+        failure.metricName,
+        failure.definitionVersion,
+        failure.producerId,
+        failure.sequence,
+        failure.reason.slice(0, 1024),
+        recordedAtMs
+      );
+    }
+  }
+  upsertCommittedDropCounters(batch, committedAtMs) {
+    const table = this.options.tableMap.quoted("committedDropCounters");
+    const upsert = this.options.connection.prepare(
+      `INSERT INTO ${table} (
+         target_id, reason, priority, count, first_committed_at_ms, last_committed_at_ms
+       ) VALUES (?, ?, ?, ?, ?, ?)
+       ON CONFLICT(target_id, reason, priority) DO UPDATE SET
+         count = MIN(9007199254740991, ${table}.count + excluded.count),
+         first_committed_at_ms = MIN(
+           ${table}.first_committed_at_ms,
+           excluded.first_committed_at_ms
+         ),
+         last_committed_at_ms = MAX(
+           ${table}.last_committed_at_ms,
+           excluded.last_committed_at_ms
+         )`
+    );
+    for (const counter of batch.dropCounters) {
+      if (!Number.isSafeInteger(counter.count) || counter.count <= 0) {
+        throw new Error("Committed telemetry drop counters must be positive safe integers");
+      }
+      upsert.run(
+        this.options.targetId,
+        counter.reason,
+        counter.priority,
+        counter.count,
+        committedAtMs,
+        committedAtMs
+      );
+    }
+  }
+  insertBatchAcknowledgement(batch, committedAtMs) {
+    const table = this.options.tableMap.quoted("batchAcknowledgements");
+    this.options.connection.prepare(
+      `INSERT INTO ${table} (
+         target_id, idempotency_key, producer_id, sequence_start, sequence_end,
+         schema_version, checksum, accepted_events, committed_at_ms
+       ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?)`
+    ).run(
+      this.options.targetId,
+      batch.idempotencyKey,
+      batch.producerId,
+      batch.sequenceStart,
+      batch.sequenceEnd,
+      batch.schemaVersion,
+      batch.checksum,
+      batch.envelopes.length,
+      committedAtMs
+    );
+  }
+  updateIngestWatermark(batch, committedAtMs) {
+    const table = this.options.tableMap.quoted("ingestWatermarks");
+    const lastOccurredAtMs = Math.max(...batch.envelopes.map((envelope) => envelope.occurredAtMs));
+    const internalGapCount = batch.sequenceEnd - batch.sequenceStart + 1 - batch.envelopes.length;
+    const initialGapCount = batch.sequenceStart + internalGapCount;
+    this.options.connection.prepare(
+      `INSERT INTO ${table} (
+         target_id, producer_id, highest_sequence, last_occurred_at_ms,
+         last_committed_at_ms, observed_gap_count
+       ) VALUES (?, ?, ?, ?, ?, ?)
+       ON CONFLICT(target_id, producer_id) DO UPDATE SET
+         observed_gap_count = ${table}.observed_gap_count
+           + MAX(0, ? - ${table}.highest_sequence - 1)
+           + ?,
+         highest_sequence = MAX(${table}.highest_sequence, excluded.highest_sequence),
+         last_occurred_at_ms = MAX(${table}.last_occurred_at_ms, excluded.last_occurred_at_ms),
+         last_committed_at_ms = excluded.last_committed_at_ms`
+    ).run(
+      this.options.targetId,
+      batch.producerId,
+      batch.sequenceEnd,
+      lastOccurredAtMs,
+      committedAtMs,
+      initialGapCount,
+      batch.sequenceStart,
+      internalGapCount
+    );
+  }
+  addTimelineFilters(query, clauses, params) {
+    const filters = [
+      [
+        query.conversationId,
+        "conversation_id = ?",
+        query.conversationId === null ? null : String(query.conversationId)
+      ],
+      [query.source, "source = ?", query.source],
+      [query.label, "label = ?", query.label],
+      [query.level, "level = ?", query.level],
+      [query.producerId, "producer_id = ?", query.producerId],
+      [query.correlationId, "correlation_id = ?", query.correlationId]
+    ];
+    for (const [guard, clause, parameter] of filters) {
+      if (guard !== null) {
+        clauses.push(clause);
+        params.push(parameter);
+      }
+    }
+  }
+  addTimelineCursor(cursor, order, clauses, params) {
+    const comparison = order === "asc" ? ">" : "<";
+    clauses.push(`(
+      occurred_at_ms ${comparison} ?
+      OR (occurred_at_ms = ? AND producer_id ${comparison} ?)
+      OR (occurred_at_ms = ? AND producer_id = ? AND sequence ${comparison} ?)
+    )`);
+    params.push(
+      cursor.occurredAtMs,
+      cursor.occurredAtMs,
+      cursor.producerId,
+      cursor.occurredAtMs,
+      cursor.producerId,
+      cursor.sequence
+    );
+  }
+  findDueBucketStarts(definition, resolutionMs, dueBeforeMs) {
+    const sampleTable = this.options.tableMap.quoted("metricSamples");
+    const completionTable = this.options.tableMap.quoted("rollupCompletions");
+    const rows = this.options.connection.prepare(
+      `WITH sample_buckets AS (
+           SELECT
+             CAST(occurred_at_ms / ? AS INTEGER) * ? AS bucket_start_ms,
+             COUNT(*) AS sample_count,
+             MAX(occurred_at_ms) AS sample_watermark_ms
+           FROM ${sampleTable}
+           WHERE target_id = ? AND metric_name = ? AND definition_version = ?
+             AND occurred_at_ms < ?
+             AND (CAST(occurred_at_ms / ? AS INTEGER) * ?) + ? <= ?
+           GROUP BY bucket_start_ms
+         )
+         SELECT bucket.bucket_start_ms
+         FROM sample_buckets AS bucket
+         LEFT JOIN ${completionTable} AS completion
+           ON completion.target_id = ?
+          AND completion.metric_name = ?
+          AND completion.definition_version = ?
+          AND completion.resolution_ms = ?
+          AND completion.bucket_start_ms = bucket.bucket_start_ms
+         WHERE completion.bucket_start_ms IS NULL
+            OR completion.sample_count <> bucket.sample_count
+            OR completion.sample_watermark_ms <> bucket.sample_watermark_ms
+         ORDER BY bucket.bucket_start_ms ASC
+         LIMIT 256`
+    ).all(
+      resolutionMs,
+      resolutionMs,
+      this.options.targetId,
+      definition.name,
+      definition.version,
+      dueBeforeMs,
+      resolutionMs,
+      resolutionMs,
+      resolutionMs,
+      dueBeforeMs,
+      this.options.targetId,
+      definition.name,
+      definition.version,
+      resolutionMs
+    );
+    return rows.map((row) => this.readNumberField(row, "bucket_start_ms"));
+  }
+  loadBucketWork(definition, resolutionMs, bucketStartMs) {
+    const table = this.options.tableMap.quoted("metricSamples");
+    const rows = this.options.connection.prepare(
+      `SELECT metric_name, definition_version, occurred_at_ms, producer_id,
+              sequence, dimension_key, dimensions_json, values_json
+       FROM ${table}
+       WHERE target_id = ? AND metric_name = ? AND definition_version = ?
+         AND occurred_at_ms >= ? AND occurred_at_ms < ?
+       ORDER BY occurred_at_ms ASC, producer_id ASC, sequence ASC`
+    ).all(
+      this.options.targetId,
+      definition.name,
+      definition.version,
+      bucketStartMs,
+      bucketStartMs + resolutionMs
+    );
+    const samples = rows.map((row) => {
+      const parsed = this.rowParser.parseMetricSample(row);
+      if (!parsed.ok) {
+        throw new Error(parsed.error);
+      }
+      return parsed.value;
+    });
+    return { definition, resolutionMs, bucketStartMs, samples };
+  }
+  bucketIsCurrent(work) {
+    const table = this.options.tableMap.quoted("rollupCompletions");
+    const row = this.options.connection.prepare(
+      `SELECT sample_count, sample_watermark_ms
+       FROM ${table}
+       WHERE target_id = ? AND metric_name = ? AND definition_version = ?
+         AND resolution_ms = ? AND bucket_start_ms = ?`
+    ).get(
+      this.options.targetId,
+      work.definition.name,
+      work.definition.version,
+      work.resolutionMs,
+      work.bucketStartMs
+    );
+    if (row === void 0) {
+      return false;
+    }
+    const sampleCount = this.readNumberField(row, "sample_count");
+    const watermark = this.readNumberField(row, "sample_watermark_ms");
+    return sampleCount === work.samples.length && watermark === this.sampleWatermark(work);
+  }
+  sampleWatermark(work) {
+    return work.samples.length === 0 ? work.bucketStartMs : Math.max(...work.samples.map((sample) => sample.occurred_at_ms));
+  }
+  materializeBucket(work, materializedAtMs) {
+    const normalized = this.normalizeSamplesForCardinality(work);
+    const groups = this.aggregateSamples(work.definition.measurements, normalized);
+    const rollupTable = this.options.tableMap.quoted("metricRollups");
+    const completionTable = this.options.tableMap.quoted("rollupCompletions");
+    const transaction = this.options.connection.transaction(() => {
+      this.options.connection.prepare(
+        `DELETE FROM ${rollupTable}
+         WHERE target_id = ? AND metric_name = ? AND definition_version = ?
+           AND resolution_ms = ? AND bucket_start_ms = ?`
+      ).run(
+        this.options.targetId,
+        work.definition.name,
+        work.definition.version,
+        work.resolutionMs,
+        work.bucketStartMs
+      );
+      const insert = this.options.connection.prepare(
+        `INSERT INTO ${rollupTable} (
+           target_id, metric_name, definition_version, resolution_ms,
+           bucket_start_ms, dimension_key, dimensions_json, values_json,
+           materialized_at_ms
+         ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?)`
+      );
+      for (const [dimensionKey, group] of groups) {
+        insert.run(
+          this.options.targetId,
+          work.definition.name,
+          work.definition.version,
+          work.resolutionMs,
+          work.bucketStartMs,
+          dimensionKey,
+          group.dimensionsJson,
+          canonicalJson(group.values),
+          materializedAtMs
+        );
+      }
+      this.options.connection.prepare(
+        `INSERT INTO ${completionTable} (
+           target_id, metric_name, definition_version, resolution_ms,
+           bucket_start_ms, sample_count, sample_watermark_ms, completed_at_ms,
+           state, detail
+         ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, 'completed', NULL)
+         ON CONFLICT(
+           target_id, metric_name, definition_version, resolution_ms, bucket_start_ms
+         ) DO UPDATE SET
+           sample_count = excluded.sample_count,
+           sample_watermark_ms = excluded.sample_watermark_ms,
+           completed_at_ms = excluded.completed_at_ms,
+           state = 'completed',
+           detail = NULL`
+      ).run(
+        this.options.targetId,
+        work.definition.name,
+        work.definition.version,
+        work.resolutionMs,
+        work.bucketStartMs,
+        work.samples.length,
+        this.sampleWatermark(work),
+        materializedAtMs
+      );
+    });
+    transaction();
+    return groups.size;
+  }
+  recordRejectedBucket(work, recordedAtMs, detail) {
+    const rollupTable = this.options.tableMap.quoted("metricRollups");
+    const completionTable = this.options.tableMap.quoted("rollupCompletions");
+    const transaction = this.options.connection.transaction(() => {
+      this.options.connection.prepare(
+        `DELETE FROM ${rollupTable}
+         WHERE target_id = ? AND metric_name = ? AND definition_version = ?
+           AND resolution_ms = ? AND bucket_start_ms = ?`
+      ).run(
+        this.options.targetId,
+        work.definition.name,
+        work.definition.version,
+        work.resolutionMs,
+        work.bucketStartMs
+      );
+      this.options.connection.prepare(
+        `INSERT INTO ${completionTable} (
+           target_id, metric_name, definition_version, resolution_ms,
+           bucket_start_ms, sample_count, sample_watermark_ms, completed_at_ms,
+           state, detail
+         ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, 'rejected', ?)
+         ON CONFLICT(
+           target_id, metric_name, definition_version, resolution_ms, bucket_start_ms
+         ) DO UPDATE SET
+           sample_count = excluded.sample_count,
+           sample_watermark_ms = excluded.sample_watermark_ms,
+           completed_at_ms = excluded.completed_at_ms,
+           state = 'rejected',
+           detail = excluded.detail`
+      ).run(
+        this.options.targetId,
+        work.definition.name,
+        work.definition.version,
+        work.resolutionMs,
+        work.bucketStartMs,
+        work.samples.length,
+        this.sampleWatermark(work),
+        recordedAtMs,
+        detail.slice(0, 1024)
+      );
+    });
+    transaction();
+  }
+  rollupStageDetail(rejectedBucketCount, examples, workBudgetReached) {
+    const rejected = rejectedBucketCount === 0 ? null : `cardinality-rejected-buckets=${rejectedBucketCount}; ${examples.join("; ")}`;
+    const detail = workBudgetReached ? ["work-budget-reached", rejected].filter((value) => value !== null).join("; ") : rejected;
+    return detail?.slice(0, 2048) ?? null;
+  }
+  normalizeSamplesForCardinality(work) {
+    const admittedByField = /* @__PURE__ */ new Map();
+    const normalized = [];
+    for (const sample of work.samples) {
+      const dimensions = this.rowParser.parseJsonObject(sample.dimensions_json);
+      const values = this.rowParser.parseNumericValues(sample.values_json);
+      if (!dimensions.ok) {
+        throw new Error(dimensions.error);
+      }
+      if (!values.ok) {
+        throw new Error(values.error);
+      }
+      const admittedDimensions = { ...dimensions.value };
+      let dropSample = false;
+      for (const field of work.definition.groupBy) {
+        const rule = work.definition.cardinality[field];
+        if (!rule) {
+          throw new Error(`Missing cardinality rule for ${field}`);
+        }
+        const dimensionValue = admittedDimensions[field];
+        const valueKey = canonicalJson(dimensionValue);
+        const admittedValues = admittedByField.get(field) ?? /* @__PURE__ */ new Set();
+        if (!admittedValues.has(valueKey) && admittedValues.size >= rule.maxValuesPerBucket) {
+          if (rule.overflow === "other") {
+            admittedDimensions[field] = "__telemetry_other__";
+          } else if (rule.overflow === "reject") {
+            throw new MetricCardinalityRejectionError(
+              `Metric ${work.definition.name} rejected cardinality overflow for ${field}`
+            );
+          } else {
+            dropSample = true;
+            break;
+          }
+        } else {
+          admittedValues.add(valueKey);
+          admittedByField.set(field, admittedValues);
+        }
+      }
+      if (dropSample) {
+        continue;
+      }
+      const dimensionsJson = canonicalJson(admittedDimensions);
+      normalized.push({
+        dimensionKey: dimensionsJson,
+        dimensionsJson,
+        values: values.value,
+        occurredAtMs: sample.occurred_at_ms,
+        producerId: sample.producer_id,
+        sequence: sample.sequence
+      });
+    }
+    return normalized;
+  }
+  aggregateSamples(measurements, samples) {
+    const groups = /* @__PURE__ */ new Map();
+    const fields = measurements.filter((measurement) => {
+      return measurement.kind === "field";
+    }).map((measurement) => measurement.field);
+    for (const sample of samples) {
+      const group = groups.get(sample.dimensionKey) ?? {
+        dimensionsJson: sample.dimensionsJson,
+        values: { count: 0, fields: {} }
+      };
+      group.values.count += 1;
+      for (const field of fields) {
+        const measured = sample.values[field];
+        if (measured === void 0) {
+          continue;
+        }
+        const aggregate = group.values.fields[field] ?? this.newFieldAggregate(measured, sample);
+        aggregate.count += group.values.fields[field] === void 0 ? 0 : 1;
+        aggregate.sum += group.values.fields[field] === void 0 ? 0 : measured;
+        aggregate.min = Math.min(aggregate.min, measured);
+        aggregate.max = Math.max(aggregate.max, measured);
+        aggregate.last = measured;
+        aggregate.lastOccurredAtMs = sample.occurredAtMs;
+        aggregate.lastProducerId = sample.producerId;
+        aggregate.lastSequence = sample.sequence;
+        group.values.fields[field] = aggregate;
+      }
+      groups.set(sample.dimensionKey, group);
+    }
+    return groups;
+  }
+  newFieldAggregate(measured, sample) {
+    return {
+      count: 1,
+      sum: measured,
+      min: measured,
+      max: measured,
+      last: measured,
+      lastOccurredAtMs: sample.occurredAtMs,
+      lastProducerId: sample.producerId,
+      lastSequence: sample.sequence
+    };
+  }
+  createRawEventRetentionStep(nowMs) {
+    const cutoffMs = nowMs - this.options.retention.rawMs;
+    const table = this.options.tableMap.quoted("rawEvents");
+    const readFirstPage = this.options.connection.prepare(
+      `SELECT producer_id, sequence, event_id, occurred_at_ms, monotonic_ns,
+              source, process_kind, level, label, conversation_id,
+              conversation_id_kind, correlation_id, metadata_json, schema_version
+       FROM ${table}
+       WHERE target_id = ? AND occurred_at_ms < ?
+       ORDER BY occurred_at_ms ASC, producer_id ASC, sequence ASC
+       LIMIT ${RETENTION_PAGE_SIZE}`
+    );
+    const readNextPage = this.options.connection.prepare(
+      `SELECT producer_id, sequence, event_id, occurred_at_ms, monotonic_ns,
+              source, process_kind, level, label, conversation_id,
+              conversation_id_kind, correlation_id, metadata_json, schema_version
+       FROM ${table}
+       WHERE target_id = ? AND occurred_at_ms < ?
+         AND (occurred_at_ms, producer_id, sequence) > (?, ?, ?)
+       ORDER BY occurred_at_ms ASC, producer_id ASC, sequence ASC
+       LIMIT ${RETENTION_PAGE_SIZE}`
+    );
+    const remove = this.options.connection.prepare(
+      `DELETE FROM ${table} WHERE target_id = ? AND producer_id = ? AND sequence = ?`
+    );
+    let cursor = null;
+    return () => {
+      const rows = cursor === null ? readFirstPage.all(this.options.targetId, cutoffMs) : readNextPage.all(
+        this.options.targetId,
+        cutoffMs,
+        cursor.occurredAtMs,
+        cursor.producerId,
+        cursor.sequence
+      );
+      if (rows.length === 0) {
+        return { deleted: 0, done: true };
+      }
+      const scanned = rows.map((row) => {
+        const parsed = this.rowParser.parseRawEnvelope(row);
+        if (!parsed.ok) {
+          throw new Error(parsed.error);
+        }
+        return parsed.value;
+      });
+      const eligible = scanned.filter((envelope) => this.rawEventHasRequiredRollups(envelope));
+      const transaction = this.options.connection.transaction(() => {
+        let deleted2 = 0;
+        for (const envelope of eligible) {
+          deleted2 += remove.run(
+            this.options.targetId,
+            envelope.producerId,
+            envelope.sequence
+          ).changes;
+        }
+        return deleted2;
+      });
+      const deleted = transaction();
+      const last = scanned[scanned.length - 1];
+      if (last === void 0 || rows.length < RETENTION_PAGE_SIZE) {
+        return { deleted, done: true };
+      }
+      cursor = {
+        occurredAtMs: last.occurredAtMs,
+        producerId: last.producerId,
+        sequence: last.sequence
+      };
+      return { deleted, done: false };
+    };
+  }
+  rawEventHasRequiredRollups(envelope) {
+    const applicable = [...this.definitions.values()].filter((definition) => {
+      return this.definitionContract.matches(definition.selector, envelope.label);
+    });
+    return applicable.every((definition) => {
+      if (!this.metricSampleExists(definition, envelope)) {
+        return true;
+      }
+      return definition.resolutionsMs.every((resolutionMs) => {
+        return this.hasCompletion(
+          definition.name,
+          definition.version,
+          resolutionMs,
+          this.bucketStart(envelope.occurredAtMs, resolutionMs)
+        );
+      });
+    });
+  }
+  metricSampleExists(definition, envelope) {
+    const table = this.options.tableMap.quoted("metricSamples");
+    const row = this.options.connection.prepare(
+      `SELECT 1 AS present
+       FROM ${table}
+       WHERE target_id = ? AND metric_name = ? AND definition_version = ?
+         AND producer_id = ? AND sequence = ?`
+    ).get(
+      this.options.targetId,
+      definition.name,
+      definition.version,
+      envelope.producerId,
+      envelope.sequence
+    );
+    return row !== void 0;
+  }
+  createSampleRetentionStep(nowMs) {
+    const cutoffMs = nowMs - this.options.retention.samplesMs;
+    const table = this.options.tableMap.quoted("metricSamples");
+    const readFirstPage = this.options.connection.prepare(
+      `SELECT metric_name, definition_version, occurred_at_ms, producer_id,
+              sequence, dimension_key, dimensions_json, values_json
+       FROM ${table}
+       WHERE target_id = ? AND occurred_at_ms < ?
+       ORDER BY occurred_at_ms ASC, metric_name ASC, definition_version ASC,
+                producer_id ASC, sequence ASC
+       LIMIT ${RETENTION_PAGE_SIZE}`
+    );
+    const readNextPage = this.options.connection.prepare(
+      `SELECT metric_name, definition_version, occurred_at_ms, producer_id,
+              sequence, dimension_key, dimensions_json, values_json
+       FROM ${table}
+       WHERE target_id = ? AND occurred_at_ms < ?
+         AND (
+           occurred_at_ms, metric_name, definition_version, producer_id, sequence
+         ) > (?, ?, ?, ?, ?)
+       ORDER BY occurred_at_ms ASC, metric_name ASC, definition_version ASC,
+                producer_id ASC, sequence ASC
+       LIMIT ${RETENTION_PAGE_SIZE}`
+    );
+    const remove = this.options.connection.prepare(
+      `DELETE FROM ${table}
+       WHERE target_id = ? AND metric_name = ? AND definition_version = ?
+         AND producer_id = ? AND sequence = ?`
+    );
+    let cursor = null;
+    return () => {
+      const rows = cursor === null ? readFirstPage.all(this.options.targetId, cutoffMs) : readNextPage.all(
+        this.options.targetId,
+        cutoffMs,
+        cursor.occurredAtMs,
+        cursor.metricName,
+        cursor.definitionVersion,
+        cursor.producerId,
+        cursor.sequence
+      );
+      if (rows.length === 0) {
+        return { deleted: 0, done: true };
+      }
+      const samples = rows.map((row) => {
+        const parsed = this.rowParser.parseMetricSample(row);
+        if (!parsed.ok) {
+          throw new Error(parsed.error);
+        }
+        return parsed.value;
+      });
+      const transaction = this.options.connection.transaction(() => {
+        let deleted2 = 0;
+        for (const sample of samples) {
+          const definition = this.definitions.get(
+            this.definitionKey(sample.metric_name, sample.definition_version)
+          );
+          if (!definition) {
+            continue;
+          }
+          const complete = definition.resolutionsMs.every((resolutionMs) => {
+            return this.hasCompletion(
+              definition.name,
+              definition.version,
+              resolutionMs,
+              this.bucketStart(sample.occurred_at_ms, resolutionMs)
+            );
+          });
+          if (complete) {
+            deleted2 += remove.run(
+              this.options.targetId,
+              sample.metric_name,
+              sample.definition_version,
+              sample.producer_id,
+              sample.sequence
+            ).changes;
+          }
+        }
+        return deleted2;
+      });
+      const deleted = transaction();
+      const last = samples[samples.length - 1];
+      if (last === void 0 || rows.length < RETENTION_PAGE_SIZE) {
+        return { deleted, done: true };
+      }
+      cursor = {
+        occurredAtMs: last.occurred_at_ms,
+        metricName: last.metric_name,
+        definitionVersion: last.definition_version,
+        producerId: last.producer_id,
+        sequence: last.sequence
+      };
+      return { deleted, done: false };
+    };
+  }
+  createRollupRetentionSteps(nowMs) {
+    const rollupTable = this.options.tableMap.quoted("metricRollups");
+    const completionTable = this.options.tableMap.quoted("rollupCompletions");
+    const steps = [];
+    for (const tier of this.options.retention.rollups) {
+      const cutoffMs = nowMs - tier.retainMs;
+      steps.push(this.createExpiredRollupStep(rollupTable, tier.resolutionMs, cutoffMs, false));
+      steps.push(this.createExpiredRollupStep(completionTable, tier.resolutionMs, cutoffMs, true));
+    }
+    return steps;
+  }
+  createExpiredRollupStep(table, resolutionMs, cutoffMs, completedOnly) {
+    const statePredicate = completedOnly ? " AND state = 'completed'" : "";
+    const remove = this.options.connection.prepare(
+      `DELETE FROM ${table}
+       WHERE rowid IN (
+         SELECT rowid FROM ${table}
+         WHERE target_id = ? AND resolution_ms = ? AND bucket_start_ms < ?${statePredicate}
+         ORDER BY bucket_start_ms ASC
+         LIMIT 500
+       )`
+    );
+    return this.createPagedDeleteStep(
+      () => remove.run(this.options.targetId, resolutionMs, cutoffMs).changes
+    );
+  }
+  createPagedDeleteStep(deletePage) {
+    return () => {
+      const changes = deletePage();
+      return { deleted: changes, done: changes < RETENTION_PAGE_SIZE };
+    };
+  }
+  createAuxiliaryRetentionSteps(nowMs) {
+    const acknowledgementCutoffMs = nowMs - this.acknowledgementRetentionMs();
+    const ingestionCutoffMs = nowMs - this.longestRetentionMs();
+    const extractionCutoffMs = nowMs - this.options.retention.samplesMs;
+    return [
+      this.createRowsBeforeStep("batchAcknowledgements", "committed_at_ms", acknowledgementCutoffMs),
+      this.createRowsBeforeStep("extractionFailures", "recorded_at_ms", extractionCutoffMs),
+      this.createFinishedMaintenanceRunStep(acknowledgementCutoffMs),
+      ...this.createReaderLeaseSteps(nowMs),
+      this.createStaleIngestWatermarkStep(ingestionCutoffMs),
+      this.createUnreferencedMetricDefinitionStep()
+    ];
+  }
+  createRowsBeforeStep(logicalTable, timestampColumn, cutoffMs) {
+    const table = this.options.tableMap.quoted(logicalTable);
+    const remove = this.options.connection.prepare(
+      `DELETE FROM ${table}
+         WHERE rowid IN (
+           SELECT rowid FROM ${table}
+           WHERE target_id = ? AND ${timestampColumn} < ?
+           ORDER BY ${timestampColumn} ASC
+           LIMIT 500
+         )`
+    );
+    return this.createPagedDeleteStep(
+      () => remove.run(this.options.targetId, cutoffMs).changes
+    );
+  }
+  createFinishedMaintenanceRunStep(cutoffMs) {
+    const table = this.options.tableMap.quoted("maintenanceRuns");
+    const remove = this.options.connection.prepare(
+      `DELETE FROM ${table}
+         WHERE rowid IN (
+           SELECT rowid FROM ${table}
+           WHERE target_id = ? AND state IN ('completed', 'failed')
+             AND COALESCE(completed_at_ms, started_at_ms) < ?
+           ORDER BY COALESCE(completed_at_ms, started_at_ms) ASC
+           LIMIT 500
+         )`
+    );
+    return this.createPagedDeleteStep(
+      () => remove.run(this.options.targetId, cutoffMs).changes
+    );
+  }
+  createReaderLeaseSteps(nowMs) {
+    const table = this.options.tableMap.quoted("readerLeases");
+    const expire = this.options.connection.prepare(
+      `UPDATE ${table}
+         SET state = 'expired'
+         WHERE rowid IN (
+           SELECT rowid FROM ${table}
+           WHERE target_id = ? AND state = 'active' AND expires_at_ms <= ?
+           ORDER BY expires_at_ms ASC
+           LIMIT 500
+         )`
+    );
+    const remove = this.options.connection.prepare(
+      `DELETE FROM ${table}
+         WHERE rowid IN (
+           SELECT rowid FROM ${table}
+           WHERE target_id = ? AND state IN ('released', 'expired')
+             AND expires_at_ms <= ?
+           ORDER BY expires_at_ms ASC
+           LIMIT 500
+         )`
+    );
+    return [
+      this.createPagedDeleteStep(() => expire.run(this.options.targetId, nowMs).changes),
+      this.createPagedDeleteStep(() => remove.run(this.options.targetId, nowMs).changes)
+    ];
+  }
+  createStaleIngestWatermarkStep(cutoffMs) {
+    const watermarks = this.options.tableMap.quoted("ingestWatermarks");
+    const acknowledgements = this.options.tableMap.quoted("batchAcknowledgements");
+    const rawEvents = this.options.tableMap.quoted("rawEvents");
+    const samples = this.options.tableMap.quoted("metricSamples");
+    const failures = this.options.tableMap.quoted("extractionFailures");
+    const remove = this.options.connection.prepare(
+      `DELETE FROM ${watermarks}
+         WHERE rowid IN (
+           SELECT watermark.rowid
+           FROM ${watermarks} AS watermark
+           WHERE watermark.target_id = ?
+             AND watermark.last_occurred_at_ms < ?
+             AND watermark.last_committed_at_ms < ?
+             AND NOT EXISTS (
+               SELECT 1 FROM ${acknowledgements} AS acknowledgement
+               WHERE acknowledgement.target_id = watermark.target_id
+                 AND acknowledgement.producer_id = watermark.producer_id
+             )
+             AND NOT EXISTS (
+               SELECT 1 FROM ${rawEvents} AS raw_event
+               WHERE raw_event.target_id = watermark.target_id
+                 AND raw_event.producer_id = watermark.producer_id
+             )
+             AND NOT EXISTS (
+               SELECT 1 FROM ${samples} AS sample
+               WHERE sample.target_id = watermark.target_id
+                 AND sample.producer_id = watermark.producer_id
+             )
+             AND NOT EXISTS (
+               SELECT 1 FROM ${failures} AS failure
+               WHERE failure.target_id = watermark.target_id
+                 AND failure.producer_id = watermark.producer_id
+             )
+           ORDER BY watermark.last_committed_at_ms ASC
+           LIMIT 500
+         )`
+    );
+    return this.createPagedDeleteStep(
+      () => remove.run(this.options.targetId, cutoffMs, cutoffMs).changes
+    );
+  }
+  createUnreferencedMetricDefinitionStep() {
+    const definitions = this.options.tableMap.quoted("metricDefinitions");
+    const samples = this.options.tableMap.quoted("metricSamples");
+    const rollups = this.options.tableMap.quoted("metricRollups");
+    const completions = this.options.tableMap.quoted("rollupCompletions");
+    const failures = this.options.tableMap.quoted("extractionFailures");
+    const read = this.options.connection.prepare(
+      `SELECT definition.metric_name, definition.definition_version
+         FROM ${definitions} AS definition
+         WHERE definition.target_id = ? AND definition.active = 0
+           AND NOT EXISTS (
+             SELECT 1 FROM ${samples} AS sample
+             WHERE sample.target_id = definition.target_id
+               AND sample.metric_name = definition.metric_name
+               AND sample.definition_version = definition.definition_version
+           )
+           AND NOT EXISTS (
+             SELECT 1 FROM ${rollups} AS rollup
+             WHERE rollup.target_id = definition.target_id
+               AND rollup.metric_name = definition.metric_name
+               AND rollup.definition_version = definition.definition_version
+           )
+           AND NOT EXISTS (
+             SELECT 1 FROM ${completions} AS completion
+             WHERE completion.target_id = definition.target_id
+               AND completion.metric_name = definition.metric_name
+               AND completion.definition_version = definition.definition_version
+           )
+           AND NOT EXISTS (
+             SELECT 1 FROM ${failures} AS failure
+             WHERE failure.target_id = definition.target_id
+               AND failure.metric_name = definition.metric_name
+               AND failure.definition_version = definition.definition_version
+           )
+         ORDER BY definition.registered_at_ms ASC
+         LIMIT 500`
+    );
+    const remove = this.options.connection.prepare(
+      `DELETE FROM ${definitions}
+       WHERE target_id = ? AND metric_name = ? AND definition_version = ? AND active = 0`
+    );
+    return () => {
+      const rows = read.all(this.options.targetId).map((row) => ({
+        metricName: this.readStringField(row, "metric_name"),
+        definitionVersion: this.readNumberField(row, "definition_version")
+      }));
+      if (rows.length === 0) {
+        return { deleted: 0, done: true };
+      }
+      const transaction = this.options.connection.transaction(() => {
+        let deleted2 = 0;
+        for (const row of rows) {
+          deleted2 += remove.run(
+            this.options.targetId,
+            row.metricName,
+            row.definitionVersion
+          ).changes;
+        }
+        return deleted2;
+      });
+      const deleted = transaction();
+      for (const row of rows) {
+        this.definitions.delete(this.definitionKey(row.metricName, row.definitionVersion));
+      }
+      return { deleted, done: deleted === 0 || rows.length < RETENTION_PAGE_SIZE };
+    };
+  }
+  acknowledgementRetentionMs() {
+    return this.options.retention.rawMs + this.options.retention.lateArrivalMs;
+  }
+  longestRetentionMs() {
+    return Math.max(
+      this.options.retention.rawMs,
+      this.options.retention.samplesMs,
+      ...this.options.retention.rollups.map((tier) => tier.retainMs)
+    );
+  }
+  hasCompletion(metricName, definitionVersion, resolutionMs, bucketStartMs) {
+    const table = this.options.tableMap.quoted("rollupCompletions");
+    const row = this.options.connection.prepare(
+      `SELECT 1 AS present FROM ${table}
+       WHERE target_id = ? AND metric_name = ? AND definition_version = ?
+         AND resolution_ms = ? AND bucket_start_ms = ?
+         AND state = 'completed'`
+    ).get(this.options.targetId, metricName, definitionVersion, resolutionMs, bucketStartMs);
+    return row !== void 0;
+  }
+  metricDefinitions(metricName) {
+    return [...this.definitions.values()].filter((definition) => definition.name === metricName).sort((left, right) => left.version - right.version);
+  }
+  validateMetricQuery(query, definitions) {
+    const dimensionSets = definitions.map((definition) => new Set(definition.groupBy));
+    const invalidDimension = Object.keys(query.where).find((field) => {
+      return dimensionSets.some((dimensions) => !dimensions.has(field));
+    });
+    if (invalidDimension) {
+      return `Metric ${query.metric} does not declare dimension ${invalidDimension}`;
+    }
+    if (query.resolution !== "auto") {
+      const explicitResolution = query.resolution;
+      const unavailable = definitions.every(
+        (definition) => !definition.resolutionsMs.includes(explicitResolution)
+      );
+      if (unavailable) {
+        return `Resolution ${query.resolution} is not configured for metric ${query.metric}`;
+      }
+    }
+    const invalidMeasurement = query.measurements.find((measurement) => {
+      return definitions.some(
+        (definition) => !this.definitionHasMeasurement(definition, measurement)
+      );
+    });
+    return invalidMeasurement ? `Metric ${query.metric} does not declare measurement ${invalidMeasurement}` : null;
+  }
+  definitionHasMeasurement(definition, requested) {
+    if (requested === "count") {
+      return definition.measurements.some((measurement) => measurement.kind === "count");
+    }
+    const [field, aggregate] = requested.split(".");
+    if (!field || !aggregate) {
+      return false;
+    }
+    return definition.measurements.some((measurement) => {
+      return measurement.kind === "field" && measurement.field === field && (aggregate === "avg" && measurement.aggregates.includes("sum") || this.isMetricAggregate(aggregate) && measurement.aggregates.includes(aggregate));
+    });
+  }
+  planCoverage(query, definitions) {
+    const table = this.options.tableMap.quoted("rollupCompletions");
+    const rows = this.options.connection.prepare(
+      `SELECT definition_version, resolution_ms, bucket_start_ms
+       FROM ${table}
+       WHERE target_id = ? AND metric_name = ?
+         AND state = 'completed'
+         AND bucket_start_ms < ?
+         AND bucket_start_ms + resolution_ms > ?
+       ORDER BY bucket_start_ms ASC, resolution_ms ASC, definition_version DESC`
+    ).all(this.options.targetId, query.metric, query.toMs, query.fromMs);
+    const definitionVersions = new Set(definitions.map((definition) => definition.version));
+    const available = rows.map((row) => ({
+      fromMs: this.readNumberField(row, "bucket_start_ms"),
+      toMs: this.readNumberField(row, "bucket_start_ms") + this.readNumberField(row, "resolution_ms"),
+      definitionVersion: this.readNumberField(row, "definition_version"),
+      resolutionMs: this.readNumberField(row, "resolution_ms")
+    })).filter((row) => {
+      return definitionVersions.has(row.definitionVersion) && (query.resolution === "auto" || row.resolutionMs === query.resolution);
+    });
+    const intervals = [];
+    for (const definition of definitions) {
+      const versionCandidates = available.filter(
+        (candidate) => candidate.definitionVersion === definition.version
+      );
+      intervals.push(...this.planDefinitionCoverage(query, versionCandidates));
+    }
+    const orderedIntervals = intervals.sort((left, right) => {
+      return left.fromMs - right.fromMs || left.definitionVersion - right.definitionVersion || left.resolutionMs - right.resolutionMs;
+    });
+    return {
+      intervals: orderedIntervals,
+      gaps: this.coverageGaps(query, orderedIntervals, available)
+    };
+  }
+  planDefinitionCoverage(query, candidates) {
+    const contained = candidates.filter((candidate) => {
+      return candidate.fromMs >= query.fromMs && candidate.toMs <= query.toMs;
+    });
+    const intervals = [];
+    let cursor = query.fromMs;
+    while (cursor < query.toMs) {
+      const starting = contained.filter((candidate) => candidate.fromMs === cursor).sort((left, right) => left.resolutionMs - right.resolutionMs);
+      const chosen = starting[0];
+      if (chosen) {
+        this.appendCoverageInterval(intervals, chosen);
+        cursor = chosen.toMs;
+        continue;
+      }
+      const nextStart = contained.map((candidate) => candidate.fromMs).filter((startMs) => startMs > cursor).sort((left, right) => left - right)[0];
+      cursor = nextStart ?? query.toMs;
+    }
+    return intervals;
+  }
+  appendCoverageInterval(intervals, candidate) {
+    const previous = intervals[intervals.length - 1];
+    const extendsPrevious = previous !== void 0 && previous.toMs === candidate.fromMs && previous.resolutionMs === candidate.resolutionMs && previous.definitionVersion === candidate.definitionVersion;
+    if (extendsPrevious) {
+      intervals[intervals.length - 1] = { ...previous, toMs: candidate.toMs };
+      return;
+    }
+    intervals.push(candidate);
+  }
+  coverageGaps(query, intervals, candidates) {
+    const coverage = [...intervals].sort(
+      (left, right) => left.fromMs - right.fromMs || right.toMs - left.toMs
+    );
+    const gaps = [];
+    let cursor = query.fromMs;
+    for (const interval of coverage) {
+      if (interval.fromMs > cursor) {
+        this.appendSplitCoverageGaps(gaps, cursor, interval.fromMs, query, candidates);
+      }
+      cursor = Math.max(cursor, interval.toMs);
+    }
+    if (cursor < query.toMs) {
+      this.appendSplitCoverageGaps(gaps, cursor, query.toMs, query, candidates);
+    }
+    return Object.freeze(gaps);
+  }
+  appendSplitCoverageGaps(gaps, fromMs, toMs, query, candidates) {
+    const partialCandidates = candidates.filter((candidate) => {
+      const outsideQuery = candidate.fromMs < query.fromMs || candidate.toMs > query.toMs;
+      return outsideQuery && candidate.fromMs < toMs && candidate.toMs > fromMs;
+    });
+    const boundaries = /* @__PURE__ */ new Set([fromMs, toMs]);
+    for (const candidate of partialCandidates) {
+      boundaries.add(Math.max(fromMs, candidate.fromMs));
+      boundaries.add(Math.min(toMs, candidate.toMs));
+    }
+    const ordered = [...boundaries].sort((left, right) => left - right);
+    for (let index = 0; index < ordered.length - 1; index += 1) {
+      const gapStart = ordered[index];
+      const gapEnd = ordered[index + 1];
+      if (gapStart === void 0 || gapEnd === void 0 || gapStart >= gapEnd) {
+        continue;
+      }
+      const isPartialBucket = partialCandidates.some((candidate) => {
+        return candidate.fromMs < gapEnd && candidate.toMs > gapStart;
+      });
+      this.appendMetricGap(gaps, {
+        fromMs: gapStart,
+        toMs: gapEnd,
+        reason: isPartialBucket ? "partial-bucket" : "not-materialized"
+      });
+    }
+  }
+  appendMetricGap(gaps, gap) {
+    const previous = gaps[gaps.length - 1];
+    if (previous && previous.toMs === gap.fromMs && previous.reason === gap.reason) {
+      gaps[gaps.length - 1] = { ...previous, toMs: gap.toMs };
+      return;
+    }
+    gaps.push(gap);
+  }
+  readRollupsForCoverage(query, intervals) {
+    const table = this.options.tableMap.quoted("metricRollups");
+    const parsedRows = [];
+    for (const interval of intervals) {
+      const rows = this.options.connection.prepare(
+        `SELECT metric_name, definition_version, resolution_ms, bucket_start_ms,
+                dimension_key, dimensions_json, values_json
+         FROM ${table}
+         WHERE target_id = ? AND metric_name = ? AND definition_version = ?
+           AND resolution_ms = ? AND bucket_start_ms >= ?
+           AND bucket_start_ms + resolution_ms <= ?`
+      ).all(
+        this.options.targetId,
+        query.metric,
+        interval.definitionVersion,
+        interval.resolutionMs,
+        interval.fromMs,
+        interval.toMs
+      );
+      for (const row of rows) {
+        const parsed = this.rowParser.parseMetricRollup(row);
+        if (!parsed.ok) {
+          throw new Error(parsed.error);
+        }
+        const dimensions = this.rowParser.parseJsonObject(parsed.value.dimensions_json);
+        const values = this.rowParser.parseRollupValues(parsed.value.values_json);
+        if (!dimensions.ok) {
+          throw new Error(dimensions.error);
+        }
+        if (!values.ok) {
+          throw new Error(values.error);
+        }
+        parsedRows.push({
+          bucket: {
+            startMs: parsed.value.bucket_start_ms,
+            endMs: parsed.value.bucket_start_ms + parsed.value.resolution_ms,
+            dimensions: dimensions.value,
+            values: this.rollupValuesToJson(values.value)
+          },
+          resolutionMs: parsed.value.resolution_ms,
+          definitionVersion: parsed.value.definition_version,
+          dimensionKey: parsed.value.dimension_key
+        });
+      }
+    }
+    return parsedRows;
+  }
+  rollupValuesToJson(values) {
+    const fields = {};
+    for (const [field, aggregate] of Object.entries(values.fields)) {
+      fields[field] = {
+        count: aggregate.count,
+        sum: aggregate.sum,
+        min: aggregate.min,
+        max: aggregate.max,
+        last: aggregate.last,
+        avg: aggregate.count === 0 ? 0 : aggregate.sum / aggregate.count
+      };
+    }
+    return Object.freeze({ count: values.count, ...fields });
+  }
+  selectMeasurements(values, measurements) {
+    const selected = {};
+    for (const measurement of measurements) {
+      if (measurement === "count") {
+        selected.count = values.count ?? 0;
+        continue;
+      }
+      const [field, aggregate] = measurement.split(".");
+      const fieldValues = field ? values[field] : null;
+      if (!field || !aggregate) {
+        continue;
+      }
+      if (!this.isJsonObject(fieldValues)) {
+        continue;
+      }
+      const existing = selected[field];
+      const selectedField = this.isJsonObject(existing) ? { ...existing } : {};
+      const aggregateValue = fieldValues[aggregate];
+      if (aggregateValue !== void 0) {
+        selectedField[aggregate] = aggregateValue;
+      }
+      selected[field] = selectedField;
+    }
+    return Object.freeze(selected);
+  }
+  matchesWhere(dimensions, where) {
+    return Object.entries(where).every(([field, expected]) => {
+      const actual = dimensions[field];
+      const candidates = Array.isArray(expected) ? expected : [expected];
+      return candidates.some((candidate) => canonicalJson(candidate) === canonicalJson(actual));
+    });
+  }
+  compareParsedRollups(left, right, order) {
+    const direction = order === "asc" ? 1 : -1;
+    return direction * this.compareRollupIdentity(
+      left.bucket.startMs,
+      left.resolutionMs,
+      left.definitionVersion,
+      left.dimensionKey,
+      right.bucket.startMs,
+      right.resolutionMs,
+      right.definitionVersion,
+      right.dimensionKey
+    );
+  }
+  isAfterMetricCursor(row, cursor, order) {
+    const comparison = this.compareRollupIdentity(
+      row.bucket.startMs,
+      row.resolutionMs,
+      row.definitionVersion,
+      row.dimensionKey,
+      cursor.bucketStartMs,
+      cursor.resolutionMs,
+      cursor.definitionVersion,
+      cursor.dimensionKey
+    );
+    return order === "asc" ? comparison > 0 : comparison < 0;
+  }
+  compareRollupIdentity(leftStartMs, leftResolutionMs, leftDefinitionVersion, leftDimensionKey, rightStartMs, rightResolutionMs, rightDefinitionVersion, rightDimensionKey) {
+    return leftStartMs - rightStartMs || leftResolutionMs - rightResolutionMs || leftDefinitionVersion - rightDefinitionVersion || leftDimensionKey.localeCompare(rightDimensionKey);
+  }
+  rowsToSegments(intervals, rows) {
+    return Object.freeze(
+      intervals.map((interval) => ({
+        fromMs: interval.fromMs,
+        toMs: interval.toMs,
+        resolutionMs: interval.resolutionMs,
+        isAggregated: true,
+        definitionVersion: interval.definitionVersion,
+        buckets: Object.freeze(
+          rows.filter(
+            (row) => row.resolutionMs === interval.resolutionMs && row.definitionVersion === interval.definitionVersion && row.bucket.startMs >= interval.fromMs && row.bucket.endMs <= interval.toMs
+          ).map((row) => row.bucket)
+        )
+      }))
+    );
+  }
+  committedTargetState(attempts) {
+    return {
+      targetId: this.options.targetId,
+      delivery: "required",
+      state: "committed",
+      attempts,
+      reason: null
+    };
+  }
+  definitionKey(name, version) {
+    return `${name}:${version}`;
+  }
+  normalizeDefinitions(definitions) {
+    return definitions.map((definition) => {
+      const normalized = this.definitionContract.normalize(definition);
+      if (!normalized.ok) {
+        throw new Error(normalized.error);
+      }
+      return normalized.value;
+    });
+  }
+  bucketStart(occurredAtMs, resolutionMs) {
+    return Math.floor(occurredAtMs / resolutionMs) * resolutionMs;
+  }
+  encodeCursor(cursor) {
+    return Buffer.from(canonicalJson(cursor), "utf8").toString("base64url");
+  }
+  readStringField(row, field) {
+    if (typeof row !== "object" || row === null || Array.isArray(row)) {
+      throw new Error(`Expected a SQLite row while reading ${field}`);
+    }
+    const value = Reflect.get(row, field);
+    if (typeof value !== "string") {
+      throw new Error(`Expected string field ${field}`);
+    }
+    return value;
+  }
+  readNumberField(row, field) {
+    if (typeof row !== "object" || row === null || Array.isArray(row)) {
+      throw new Error(`Expected a SQLite row while reading ${field}`);
+    }
+    const value = Reflect.get(row, field);
+    if (typeof value !== "number" || !Number.isFinite(value)) {
+      throw new Error(`Expected numeric field ${field}`);
+    }
+    return value;
+  }
+  parseCommittedDropCounter(row) {
+    const reason = this.readStringField(row, "reason");
+    const priority = this.readStringField(row, "priority");
+    const count = this.readNumberField(row, "count");
+    if (!this.isDropReason(reason) || !this.isDropPriority(priority)) {
+      throw new Error("Stored committed telemetry drop counter identity is invalid");
+    }
+    if (!Number.isSafeInteger(count) || count < 0) {
+      throw new Error("Stored committed telemetry drop counter value is invalid");
+    }
+    return Object.freeze({ reason, priority, count });
+  }
+  errorMessage(cause) {
+    return cause instanceof Error ? cause.message : String(cause);
+  }
+  isJsonObject(value) {
+    return typeof value === "object" && value !== null && !Array.isArray(value);
+  }
+  isMetricAggregate(value) {
+    return value === "sum" || value === "min" || value === "max" || value === "last";
+  }
+  isDropReason(value) {
+    return value === "capacity" || value === "sampled" || value === "stopped" || value === "invalid" || value === "transport";
+  }
+  isDropPriority(value) {
+    return value === "low" || value === "normal" || value === "high";
+  }
+};
+
+// src/storage/telemetry_table_map.ts
+var TelemetryTableMap = class _TelemetryTableMap {
+  constructor(mapping, checksum) {
+    this.mapping = mapping;
+    this.checksum = checksum;
+    this.tokenMap = Object.freeze({
+      ...mapping,
+      rawEventsOccurredIndex: this.indexName(mapping.rawEvents, "occurred"),
+      rawEventsConversationIndex: this.indexName(mapping.rawEvents, "conversation"),
+      rawEventsLabelIndex: this.indexName(mapping.rawEvents, "label"),
+      metricSamplesTimeIndex: this.indexName(mapping.metricSamples, "time"),
+      metricSamplesEventIndex: this.indexName(mapping.metricSamples, "event"),
+      metricRollupsTimeIndex: this.indexName(mapping.metricRollups, "time")
+    });
+  }
+  mapping;
+  checksum;
+  tokenMap;
+  static create(configuration) {
+    const prefixError = _TelemetryTableMap.validateOptionalPrefix(configuration.tablePrefix);
+    if (prefixError !== null) {
+      return { ok: false, error: prefixError };
+    }
+    const entries = SQLITE_LOGICAL_TABLE_NAMES.map((logicalName) => {
+      const override = configuration.tables[logicalName];
+      const defaultName = SQLITE_DEFAULT_TABLE_NAMES[logicalName];
+      const physicalName = override ?? (configuration.tablePrefix === null ? defaultName : `${configuration.tablePrefix}${defaultName}`);
+      return [logicalName, physicalName];
+    });
+    for (const [logicalName, physicalName] of entries) {
+      const identifierError = _TelemetryTableMap.validateIdentifier(physicalName);
+      if (identifierError !== null) {
+        return { ok: false, error: `${logicalName}: ${identifierError}` };
+      }
+      if (physicalName.toLowerCase() === SQLITE_SCHEMA_MANIFEST_TABLE) {
+        return { ok: false, error: `${logicalName} cannot use the fixed schema manifest name` };
+      }
+    }
+    const foldedNames = entries.map(([, physicalName]) => physicalName.toLowerCase());
+    if (new Set(foldedNames).size !== foldedNames.length) {
+      return { ok: false, error: "Resolved telemetry table names must be unique after case folding" };
+    }
+    const mapping = Object.freeze(Object.fromEntries(entries));
+    const checksum = telemetryChecksum(mapping);
+    return { ok: true, value: new _TelemetryTableMap(mapping, checksum) };
+  }
+  physical(logicalName) {
+    return this.mapping[logicalName];
+  }
+  quoted(logicalName) {
+    return this.quote(this.mapping[logicalName]);
+  }
+  manifestMapping() {
+    return this.mapping;
+  }
+  substitute(sql) {
+    const unknownTokens = [];
+    const substituted = sql.replace(/\{\{([A-Za-z][A-Za-z0-9]*)\}\}/g, (_match, token) => {
+      const identifier = this.tokenMap[token];
+      if (identifier === void 0) {
+        unknownTokens.push(token);
+        return `{{${token}}}`;
+      }
+      return this.quote(identifier);
+    });
+    if (unknownTokens.length > 0 || substituted.includes("{{")) {
+      return {
+        ok: false,
+        error: `Unknown telemetry migration identifier token(s): ${unknownTokens.join(", ") || "malformed token"}`
+      };
+    }
+    return { ok: true, value: substituted };
+  }
+  quote(identifier) {
+    return `"${identifier.replaceAll('"', '""')}"`;
+  }
+  indexName(tableName, purpose) {
+    const raw = `${tableName}_${purpose}_idx`;
+    if (raw.length <= 63) {
+      return raw;
+    }
+    const suffix = telemetryChecksum(raw).slice(0, 8);
+    return `${raw.slice(0, 54)}_${suffix}`;
+  }
+  static validateOptionalPrefix(prefix) {
+    if (prefix === null) {
+      return null;
+    }
+    return this.validateIdentifier(prefix);
+  }
+  static validateIdentifier(identifier) {
+    if (!/^[A-Za-z_][A-Za-z0-9_]*$/.test(identifier)) {
+      return `Invalid SQLite identifier ${identifier}`;
+    }
+    if (identifier.length > 63) {
+      return `SQLite identifier ${identifier} exceeds 63 characters`;
+    }
+    if (identifier.toLowerCase().startsWith("sqlite_")) {
+      return `SQLite identifier ${identifier} uses the reserved sqlite_ prefix`;
+    }
+    return null;
+  }
+};
+
+// src/transports/schema/telemetry_schema_manifest.ts
+import { z as z2 } from "zod";
+var TelemetrySchemaManifestRowSchema = z2.object({
+  target_id: z2.string(),
+  format_version: z2.number().int().positive(),
+  mapping_json: z2.string(),
+  mapping_checksum: z2.string(),
+  state: z2.enum(["ready", "renaming"]),
+  pending_mapping_json: z2.string().nullable(),
+  updated_at_ms: z2.number().int()
+}).strict();
+
+// src/transports/sqlite_transport.ts
+var DEFAULT_MIGRATIONS_DIRECTORY = typeof __dirname === "string" ? resolve2(__dirname, "../../migrations") : fileURLToPath(new URL("../../migrations/", import.meta.url));
+var SQLiteTelemetryTransport = class {
+  constructor(options) {
+    this.options = options;
+    this.targetId = options.configuration.targetId;
+    this.validateConfiguration();
+  }
+  options;
+  targetId;
+  capabilities = Object.freeze({
+    rawPersistence: true,
+    metricSamples: true,
+    rollups: true,
+    queries: true,
+    retention: true,
+    maintenance: true
+  });
+  state = "created";
+  detail = null;
+  tableMap = null;
+  connection = null;
+  repository = null;
+  definitions = Object.freeze([]);
+  lease = null;
+  heartbeatHandle = null;
+  activeReaders = 0;
+  activeWrites = 0;
+  accepting = false;
+  static defaults(configuration) {
+    return {
+      configuration,
+      migrationsDirectory: DEFAULT_MIGRATIONS_DIRECTORY,
+      processToken: randomUUID(),
+      now: () => Date.now(),
+      createInterval: (work, intervalMs) => setInterval(work, intervalMs),
+      clearInterval: (handle) => clearInterval(handle),
+      delay: (durationMs) => new Promise((resolve3) => setTimeout(resolve3, durationMs))
+    };
+  }
+  async start(definitions) {
+    if (this.state !== "created" && this.state !== "stopped") {
+      return { ok: false, error: `Cannot start SQLite telemetry target from state ${this.state}` };
+    }
+    this.state = "starting";
+    this.detail = null;
+    const tableMap = TelemetryTableMap.create(this.options.configuration.schema);
+    if (!tableMap.ok) {
+      return this.failStart(tableMap.error);
+    }
+    this.tableMap = tableMap.value;
+    this.lease = new SqliteOwnershipLease({
+      targetId: this.targetId,
+      databasePath: this.options.configuration.path,
+      mode: "writer",
+      expiryMs: this.options.configuration.leaseExpiryMs,
+      processToken: this.options.processToken,
+      now: this.options.now
+    });
+    const acquired = this.lease.acquire();
+    if (!acquired.ok) {
+      return this.failStart(acquired.error);
+    }
+    try {
+      const connection = new BetterSqlite3(this.options.configuration.path);
+      this.connection = connection;
+      this.configureConnection(connection);
+      const manifestNeedsUpgrade = this.initializeAndVerifyManifest(connection, tableMap.value);
+      await this.runMigrations(connection, tableMap.value);
+      this.verifySchema(connection, tableMap.value);
+      if (manifestNeedsUpgrade) {
+        this.upgradeManifestMapping(connection, tableMap.value);
+      }
+      const stackDatabase = await createSqliteDb(connection);
+      this.repository = new TelemetryRepository({
+        targetId: this.targetId,
+        connection,
+        stackDatabase,
+        tableMap: tableMap.value,
+        retention: this.options.configuration.retention,
+        now: this.options.now
+      });
+      const recovered = this.repository.recoverInterruptedMaintenance(this.options.now());
+      if (!recovered.ok) {
+        throw new Error(recovered.error);
+      }
+      const registered = this.repository.registerDefinitions(definitions);
+      if (!registered.ok) {
+        throw new Error(registered.error);
+      }
+      this.definitions = Object.freeze([...definitions]);
+      this.startHeartbeat();
+      this.accepting = true;
+      this.state = "ready";
+      return { ok: true, value: void 0 };
+    } catch (cause) {
+      this.closeOwnedResources();
+      return this.failStart(this.errorMessage(cause));
+    }
+  }
+  async persist(request) {
+    if (!this.accepting || this.state !== "ready" || this.repository === null) {
+      return this.closedAcknowledgement(request.batch.idempotencyKey);
+    }
+    this.activeWrites += 1;
+    try {
+      const persisted = this.repository.persist(request);
+      if (persisted.kind === "acknowledged") {
+        return persisted.acknowledgement;
+      }
+      this.detail = persisted.reason;
+      return {
+        kind: "retryable",
+        idempotencyKey: request.batch.idempotencyKey,
+        reason: persisted.reason,
+        retryAfterMs: 100,
+        targetStates: [{
+          targetId: this.targetId,
+          delivery: this.options.configuration.delivery,
+          state: "failed",
+          attempts: 1,
+          reason: persisted.reason
+        }]
+      };
+    } finally {
+      this.activeWrites -= 1;
+    }
+  }
+  async timeline(query) {
+    const queryError = this.validateTimelineQuery(query);
+    if (queryError !== null) {
+      return { ok: false, error: { kind: "invalid-query", message: queryError } };
+    }
+    const result = this.withReaderLease(() => {
+      const repository = this.requireRepository();
+      const rawCutoffMs = this.options.now() - this.options.configuration.retention.rawMs;
+      return repository.timeline(query, rawCutoffMs);
+    });
+    return this.enforceResponseBytes(result);
+  }
+  async metrics(query) {
+    const queryError = this.validateMetricQuery(query);
+    if (queryError !== null) {
+      return { ok: false, error: { kind: "invalid-query", message: queryError } };
+    }
+    const result = this.withReaderLease(() => this.requireRepository().metrics(query));
+    if (result.ok) {
+      const bucketCount = result.value.segments.reduce((count, segment) => count + segment.buckets.length, 0);
+      if (bucketCount > this.options.configuration.query.maxBuckets) {
+        return {
+          ok: false,
+          error: { kind: "invalid-query", message: "Metric result exceeds the configured bucket maximum" }
+        };
+      }
+    }
+    return this.enforceResponseBytes(result);
+  }
+  async materializeRollups(nowMs, maxWorkMs) {
+    return this.requireRepositoryResult((repository) => repository.materializeRollups(nowMs, maxWorkMs));
+  }
+  async enforceRetention(nowMs, shouldContinue = () => true) {
+    const startedAt = this.options.now();
+    let drain;
+    try {
+      drain = this.requireRepository().beginRetentionDrain(nowMs);
+    } catch (cause) {
+      return { ok: false, error: this.errorMessage(cause) };
+    }
+    let affectedRows = 0;
+    let deletionRounds = 0;
+    let interrupted = false;
+    for (; ; ) {
+      if (!shouldContinue()) {
+        interrupted = true;
+        break;
+      }
+      const batch = drain.nextBatch();
+      if (!batch.ok) {
+        return batch;
+      }
+      affectedRows += batch.value.deletedRows;
+      deletionRounds += 1;
+      if (!batch.value.hasMore) {
+        break;
+      }
+      await this.options.delay(0);
+    }
+    return {
+      ok: true,
+      value: {
+        stage: "retention",
+        affectedRows,
+        affectedPages: 0,
+        elapsedMs: this.options.now() - startedAt,
+        detail: interrupted ? "interrupted" : null,
+        deletionRounds,
+        completed: !interrupted,
+        interrupted
+      }
+    };
+  }
+  async checkpoint() {
+    return this.requireRepositoryResult((repository) => repository.checkpoint());
+  }
+  async reclaim(maxPages) {
+    return this.requireRepositoryResult((repository) => repository.reclaim(maxPages));
+  }
+  async compact(deadlineMs) {
+    const startedAt = this.options.now();
+    this.accepting = false;
+    while ((this.activeReaders > 0 || this.activeWrites > 0) && this.options.now() < deadlineMs) {
+      await this.options.delay(1);
+    }
+    if (this.activeReaders > 0 || this.activeWrites > 0) {
+      this.accepting = true;
+      return { ok: false, error: "Timed out waiting for telemetry readers/writers to quiesce" };
+    }
+    try {
+      const tableMap = this.requireTableMap();
+      this.closeDatabaseConnectionForCompaction();
+      this.compactClosedDatabase(tableMap);
+      await this.reopenDatabaseAfterCompaction(tableMap);
+      this.accepting = true;
+      return {
+        ok: true,
+        value: {
+          stage: "compaction",
+          affectedRows: 0,
+          affectedPages: 0,
+          elapsedMs: this.options.now() - startedAt,
+          detail: null
+        }
+      };
+    } catch (cause) {
+      const compactionError = this.errorMessage(cause);
+      try {
+        await this.reopenDatabaseAfterCompaction(this.requireTableMap());
+        this.accepting = true;
+      } catch (reopenCause) {
+        this.state = "failed";
+        this.detail = this.errorMessage(reopenCause);
+      }
+      return { ok: false, error: compactionError };
+    }
+  }
+  async recordMaintenance(record) {
+    try {
+      return this.requireRepository().recordMaintenance(record);
+    } catch (cause) {
+      return { ok: false, error: this.errorMessage(cause) };
+    }
+  }
+  status() {
+    const committedDropCounters = this.repository?.committedDropCounters();
+    return Object.freeze({
+      targetId: this.targetId,
+      state: this.state,
+      detail: this.detail,
+      writerLeaseHeld: this.lease?.isHeld() ?? false,
+      committedDropCounters: committedDropCounters?.ok === true ? committedDropCounters.value : Object.freeze([])
+    });
+  }
+  maintenanceConfiguration() {
+    return this.options.configuration.maintenance;
+  }
+  async stop(deadlineMs) {
+    this.accepting = false;
+    while ((this.activeReaders > 0 || this.activeWrites > 0) && this.options.now() < deadlineMs) {
+      await this.options.delay(1);
+    }
+    this.closeOwnedResources();
+    this.state = "stopped";
+    this.detail = null;
+  }
+  configureConnection(connection) {
+    const userTableCount = this.readCount(connection.prepare(
+      `SELECT COUNT(*) AS count FROM sqlite_master
+       WHERE type = 'table' AND name NOT LIKE 'sqlite_%'`
+    ).get());
+    if (userTableCount === 0) {
+      connection.pragma("auto_vacuum = INCREMENTAL");
+      connection.exec("VACUUM");
+    }
+    const autoVacuum = Number(connection.pragma("auto_vacuum", { simple: true }));
+    if (autoVacuum !== 2) {
+      throw new Error("Telemetry SQLite target must use auto_vacuum=INCREMENTAL");
+    }
+    connection.pragma("journal_mode = WAL");
+    connection.pragma("synchronous = NORMAL");
+    connection.pragma("foreign_keys = ON");
+    connection.pragma("busy_timeout = 5000");
+  }
+  closeDatabaseConnectionForCompaction() {
+    const connection = this.requireConnection();
+    connection.pragma("wal_checkpoint(TRUNCATE)");
+    this.repository = null;
+    this.connection = null;
+    connection.close();
+  }
+  compactClosedDatabase(tableMap) {
+    const connection = new BetterSqlite3(this.options.configuration.path);
+    try {
+      this.configureConnection(connection);
+      connection.exec("VACUUM");
+      this.verifySchema(connection, tableMap);
+    } finally {
+      connection.close();
+    }
+  }
+  async reopenDatabaseAfterCompaction(tableMap) {
+    if (this.connection !== null && this.repository !== null) {
+      return;
+    }
+    const connection = new BetterSqlite3(this.options.configuration.path);
+    try {
+      this.configureConnection(connection);
+      this.initializeAndVerifyManifest(connection, tableMap);
+      this.verifySchema(connection, tableMap);
+      const stackDatabase = await createSqliteDb(connection);
+      const repository = new TelemetryRepository({
+        targetId: this.targetId,
+        connection,
+        stackDatabase,
+        tableMap,
+        retention: this.options.configuration.retention,
+        now: this.options.now
+      });
+      const loaded = repository.loadDefinitionsReadOnly(this.definitions);
+      if (!loaded.ok) {
+        throw new Error(loaded.error);
+      }
+      this.connection = connection;
+      this.repository = repository;
+    } catch (cause) {
+      connection.close();
+      throw cause;
+    }
+  }
+  initializeAndVerifyManifest(connection, tableMap) {
+    connection.exec(
+      `CREATE TABLE IF NOT EXISTS "${SQLITE_SCHEMA_MANIFEST_TABLE}" (
+         target_id TEXT PRIMARY KEY,
+         format_version INTEGER NOT NULL,
+         mapping_json TEXT NOT NULL,
+         mapping_checksum TEXT NOT NULL,
+         state TEXT NOT NULL CHECK (state IN ('ready', 'renaming')),
+         pending_mapping_json TEXT,
+         updated_at_ms INTEGER NOT NULL
+       )`
+    );
+    const rows = connection.prepare(
+      `SELECT target_id, format_version, mapping_json, mapping_checksum,
+              state, pending_mapping_json, updated_at_ms
+       FROM "${SQLITE_SCHEMA_MANIFEST_TABLE}"`
+    ).all();
+    if (rows.length === 0) {
+      connection.prepare(
+        `INSERT INTO "${SQLITE_SCHEMA_MANIFEST_TABLE}" (
+           target_id, format_version, mapping_json, mapping_checksum,
+           state, pending_mapping_json, updated_at_ms
+         ) VALUES (?, ?, ?, ?, 'ready', NULL, ?)`
+      ).run(
+        this.targetId,
+        2,
+        JSON.stringify(tableMap.manifestMapping()),
+        tableMap.checksum,
+        this.options.now()
+      );
+      return false;
+    }
+    if (rows.length !== 1) {
+      throw new Error("Telemetry schema manifest must contain exactly one target mapping");
+    }
+    const parsed = TelemetrySchemaManifestRowSchema.safeParse(rows[0]);
+    if (!parsed.success) {
+      throw new Error(parsed.error.message);
+    }
+    if (parsed.data.target_id !== this.targetId) {
+      throw new Error(`Telemetry database belongs to target ${parsed.data.target_id}, not ${this.targetId}`);
+    }
+    if (parsed.data.state !== "ready") {
+      throw new Error("Telemetry schema rename recovery is required before startup");
+    }
+    if (parsed.data.mapping_checksum === tableMap.checksum) {
+      return false;
+    }
+    if (this.isLegacyManifestMapping(parsed.data, tableMap)) {
+      return true;
+    }
+    throw new Error("Telemetry table mapping differs from the schema manifest; run offline schema rename");
+  }
+  isLegacyManifestMapping(manifest, tableMap) {
+    if (manifest.format_version !== 1) {
+      return false;
+    }
+    const parsed = JSON.parse(manifest.mapping_json);
+    if (typeof parsed !== "object" || parsed === null || Array.isArray(parsed)) {
+      return false;
+    }
+    if (telemetryChecksum(parsed) !== manifest.mapping_checksum) {
+      return false;
+    }
+    const expected = tableMap.manifestMapping();
+    const legacyEntries = Object.entries(expected).filter(
+      ([logicalName]) => logicalName !== "committedDropCounters"
+    );
+    const actualEntries = Object.entries(parsed);
+    return actualEntries.length === legacyEntries.length && legacyEntries.every(([logicalName, physicalName]) => {
+      return Reflect.get(parsed, logicalName) === physicalName;
+    });
+  }
+  upgradeManifestMapping(connection, tableMap) {
+    connection.prepare(
+      `UPDATE "${SQLITE_SCHEMA_MANIFEST_TABLE}"
+         SET format_version = 2, mapping_json = ?, mapping_checksum = ?, updated_at_ms = ?
+         WHERE target_id = ?`
+    ).run(
+      JSON.stringify(tableMap.manifestMapping()),
+      tableMap.checksum,
+      this.options.now(),
+      this.targetId
+    );
+  }
+  async runMigrations(connection, tableMap) {
+    const sqlRunner = new TelemetryProperSqlRunner(connection, tableMap);
+    const migrationRunner = await new MigrationRunnerFactory().create({
+      migration_folder: this.options.migrationsDirectory,
+      migration_table: tableMap.quoted("migrationHistory"),
+      database: "sqlite",
+      sqlite: { database: this.options.configuration.path }
+    }, sqlRunner);
+    const pending = await migrationRunner.getPendingMigrations();
+    await migrationRunner.migrate(pending, true);
+  }
+  verifySchema(connection, tableMap) {
+    const rows = connection.prepare(
+      `SELECT name FROM sqlite_master WHERE type = 'table'`
+    ).all();
+    const names = new Set(rows.map((row) => this.readName(row)));
+    if (!names.has(SQLITE_SCHEMA_MANIFEST_TABLE)) {
+      throw new Error("Telemetry schema manifest is missing");
+    }
+    const missing = SQLITE_LOGICAL_TABLE_NAMES.map((logicalName) => tableMap.physical(logicalName)).filter((physicalName) => !names.has(physicalName));
+    if (missing.length > 0) {
+      throw new Error(`Telemetry schema is missing table(s): ${missing.join(", ")}`);
+    }
+  }
+  startHeartbeat() {
+    const intervalMs = Math.max(1e3, Math.floor(this.options.configuration.leaseExpiryMs / 3));
+    this.heartbeatHandle = this.options.createInterval(() => {
+      const heartbeat = this.lease?.heartbeat();
+      if (heartbeat && !heartbeat.ok) {
+        this.accepting = false;
+        this.state = "failed";
+        this.detail = heartbeat.error;
+      }
+    }, intervalMs);
+  }
+  withReaderLease(work) {
+    if (!this.accepting || this.state !== "ready") {
+      return { ok: false, error: { kind: "storage-failure", message: "Telemetry target is not accepting readers" } };
+    }
+    this.activeReaders += 1;
+    const leaseId = randomUUID();
+    const table = this.requireTableMap().quoted("readerLeases");
+    const connection = this.requireConnection();
+    try {
+      const acquiredAtMs = this.options.now();
+      connection.prepare(
+        `INSERT INTO ${table} (
+           target_id, lease_id, owner_id, acquired_at_ms, expires_at_ms, state
+         ) VALUES (?, ?, ?, ?, ?, 'active')`
+      ).run(
+        this.targetId,
+        leaseId,
+        this.options.processToken,
+        acquiredAtMs,
+        acquiredAtMs + this.options.configuration.leaseExpiryMs
+      );
+      return work();
+    } finally {
+      connection.prepare(
+        `UPDATE ${table} SET state = 'released' WHERE target_id = ? AND lease_id = ?`
+      ).run(this.targetId, leaseId);
+      this.activeReaders -= 1;
+    }
+  }
+  requireRepositoryResult(work) {
+    try {
+      return work(this.requireRepository());
+    } catch (cause) {
+      return { ok: false, error: this.errorMessage(cause) };
+    }
+  }
+  validateTimelineQuery(query) {
+    const commonError = this.validateQueryRange(query.targetId, query.fromMs, query.toMs, query.limit);
+    return commonError;
+  }
+  validateMetricQuery(query) {
+    const rangeError = this.validateQueryRange(query.targetId, query.fromMs, query.toMs, query.limit);
+    if (rangeError !== null) {
+      return rangeError;
+    }
+    if (query.limit > this.options.configuration.query.maxBuckets) {
+      return "Metric query limit exceeds the configured bucket maximum";
+    }
+    return null;
+  }
+  validateQueryRange(targetId, fromMs, toMs, limit) {
+    if (targetId !== null && targetId !== this.targetId) {
+      return `Query target ${targetId} does not match ${this.targetId}`;
+    }
+    if (!Number.isSafeInteger(fromMs) || !Number.isSafeInteger(toMs) || fromMs >= toMs) {
+      return "Query time range must use safe integer milliseconds and be non-empty";
+    }
+    if (toMs - fromMs > this.options.configuration.query.maxRangeMs) {
+      return "Query time range exceeds the configured maximum";
+    }
+    if (!Number.isInteger(limit) || limit <= 0 || limit > this.options.configuration.query.maxRows) {
+      return "Query row limit is outside the configured bounds";
+    }
+    return null;
+  }
+  validateConfiguration() {
+    const configuration = this.options.configuration;
+    if (!configuration.targetId.trim() || !configuration.path.trim()) {
+      throw new Error("SQLite telemetry target id and path are required");
+    }
+    if (!Number.isInteger(configuration.leaseExpiryMs) || configuration.leaseExpiryMs < 1e3) {
+      throw new Error("SQLite telemetry ownership lease expiry must be at least one second");
+    }
+    const queryLimits = Object.values(configuration.query);
+    if (queryLimits.some((limit) => !Number.isSafeInteger(limit) || limit <= 0)) {
+      throw new Error("SQLite telemetry query limits must be positive safe integers");
+    }
+    const retention = configuration.retention;
+    const invalidRetention = retention.rawMs <= 0 || retention.lateArrivalMs < 0 || retention.samplesMs < retention.rawMs + retention.lateArrivalMs;
+    if (invalidRetention) {
+      throw new Error("SQLite telemetry retention values are invalid");
+    }
+    this.validateRollupTiers();
+  }
+  validateRollupTiers() {
+    const retention = this.options.configuration.retention;
+    const tiers = retention.rollups;
+    if (tiers.length === 0) {
+      throw new Error("SQLite telemetry requires at least one rollup retention tier");
+    }
+    for (let index = 0; index < tiers.length; index += 1) {
+      const tier = tiers[index];
+      const previous = tiers[index - 1];
+      if (!tier || tier.resolutionMs <= 0 || tier.retainMs < retention.rawMs) {
+        throw new Error("SQLite telemetry rollup tiers are invalid");
+      }
+      if (previous && (tier.resolutionMs <= previous.resolutionMs || tier.retainMs < previous.retainMs)) {
+        throw new Error("SQLite telemetry rollup tiers must increase by resolution and retention");
+      }
+    }
+  }
+  enforceResponseBytes(result) {
+    if (!result.ok) {
+      return result;
+    }
+    try {
+      const bytes = telemetryUtf8Length(canonicalJson(result.value));
+      if (bytes > this.options.configuration.query.maxResponseBytes) {
+        return {
+          ok: false,
+          error: { kind: "invalid-query", message: "Query result exceeds the configured response byte maximum" }
+        };
+      }
+      return result;
+    } catch (cause) {
+      return {
+        ok: false,
+        error: { kind: "storage-failure", message: `Unable to size telemetry query result: ${this.errorMessage(cause)}` }
+      };
+    }
+  }
+  failStart(error) {
+    this.state = "failed";
+    this.detail = error;
+    return { ok: false, error };
+  }
+  closedAcknowledgement(idempotencyKey) {
+    return {
+      kind: "retryable",
+      idempotencyKey,
+      reason: "SQLite telemetry target is not ready",
+      retryAfterMs: 100,
+      targetStates: [{
+        targetId: this.targetId,
+        delivery: this.options.configuration.delivery,
+        state: "failed",
+        attempts: 0,
+        reason: "target-not-ready"
+      }]
+    };
+  }
+  closeOwnedResources() {
+    if (this.heartbeatHandle !== null) {
+      this.options.clearInterval(this.heartbeatHandle);
+      this.heartbeatHandle = null;
+    }
+    if (this.connection?.open) {
+      try {
+        this.connection.close();
+      } catch {
+      }
+    }
+    this.connection = null;
+    this.repository = null;
+    this.lease?.release();
+    this.lease = null;
+  }
+  requireRepository() {
+    if (this.repository === null) {
+      throw new Error("SQLite telemetry repository is not initialized");
+    }
+    return this.repository;
+  }
+  requireConnection() {
+    if (this.connection === null) {
+      throw new Error("SQLite telemetry connection is not initialized");
+    }
+    return this.connection;
+  }
+  requireTableMap() {
+    if (this.tableMap === null) {
+      throw new Error("SQLite telemetry table map is not initialized");
+    }
+    return this.tableMap;
+  }
+  readCount(row) {
+    if (typeof row !== "object" || row === null || Array.isArray(row)) {
+      throw new Error("SQLite count query returned no row");
+    }
+    const count = Reflect.get(row, "count");
+    if (typeof count !== "number") {
+      throw new Error("SQLite count query returned an invalid count");
+    }
+    return count;
+  }
+  readName(row) {
+    if (typeof row !== "object" || row === null || Array.isArray(row)) {
+      throw new Error("SQLite schema query returned an invalid row");
+    }
+    const name = Reflect.get(row, "name");
+    if (typeof name !== "string") {
+      throw new Error("SQLite schema query returned an invalid table name");
+    }
+    return name;
+  }
+  errorMessage(cause) {
+    return cause instanceof Error ? cause.message : String(cause);
+  }
+};
+export {
+  SQLiteTelemetryTransport
+};
+//# sourceMappingURL=index.js.map