@secondlayer/shared 7.8.0 → 7.10.0

package/dist/src/coverage/index.js

@@ -0,0 +1,1483 @@
+import { createRequire } from "node:module";
+var __defProp = Object.defineProperty;
+var __returnValue = (v) => v;
+function __exportSetter(name, newValue) {
+  this[name] = __returnValue.bind(null, newValue);
+}
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, {
+      get: all[name],
+      enumerable: true,
+      configurable: true,
+      set: __exportSetter.bind(all, name)
+    });
+};
+
+// src/coverage/constraints.ts
+var STAGE_KINDS = ["raw", "decode", "subgraph", "queue"];
+var NATIVE_CLOCKS = ["block", "cursor", "queue"];
+var REPAIR_MODES = [
+  "range_safe",
+  "full_reindex",
+  "archive_replay",
+  "none"
+];
+var RUN_STATUSES = [
+  "pending",
+  "running",
+  "complete",
+  "syncing",
+  "lagging",
+  "gap",
+  "stale",
+  "failed",
+  "unverified_import",
+  "unanchored",
+  "source_unavailable",
+  "out_of_scope",
+  "disabled",
+  "halted"
+];
+var FAILURE_UNITS = ["block", "range", "cursor", "queue"];
+var FAILURE_CLASSES = [
+  "omission",
+  "version",
+  "digest_mismatch",
+  "crash",
+  "reorg",
+  "source_gap",
+  "handler",
+  "timeout",
+  "unknown"
+];
+var RETRY_STATES = ["open", "retrying", "halted", "resolved"];
+var FAILURE_RETENTION_DAYS = 30;
+function isMember(set, value) {
+  return set.includes(value);
+}
+function isStageKind(value) {
+  return isMember(STAGE_KINDS, value);
+}
+function isNativeClock(value) {
+  return isMember(NATIVE_CLOCKS, value);
+}
+function isRepairMode(value) {
+  return isMember(REPAIR_MODES, value);
+}
+function isRunStatus(value) {
+  return isMember(RUN_STATUSES, value);
+}
+function isFailureUnit(value) {
+  return isMember(FAILURE_UNITS, value);
+}
+function isFailureClass(value) {
+  return isMember(FAILURE_CLASSES, value);
+}
+function isRetryState(value) {
+  return isMember(RETRY_STATES, value);
+}
+function isNonNegativeInt(value) {
+  return Number.isSafeInteger(value) && value >= 0;
+}
+function rangeIsOrdered(from, to) {
+  return isNonNegativeInt(from) && isNonNegativeInt(to) && from <= to;
+}
+function receiptRetentionHolds(row) {
+  if (!isNonNegativeInt(row.block_height))
+    return false;
+  if (!isNonNegativeInt(row.input_count))
+    return false;
+  if (row.compacted_at !== null && !row.finalized)
+    return false;
+  return true;
+}
+function failureRangeHolds(row) {
+  if (row.from_height !== null && !isNonNegativeInt(row.from_height)) {
+    return false;
+  }
+  if (row.to_height !== null && !isNonNegativeInt(row.to_height)) {
+    return false;
+  }
+  if (row.from_height !== null && row.to_height !== null && row.from_height > row.to_height) {
+    return false;
+  }
+  return true;
+}
+function failureRetentionHolds(row) {
+  if (!isNonNegativeInt(row.retry_count))
+    return false;
+  if (row.retain_until.getTime() < row.created_at.getTime())
+    return false;
+  if (row.retry_state === "resolved")
+    return row.resolved_at !== null;
+  return true;
+}
+function segmentsOverlap(a, b) {
+  return a.from_height <= b.to_height && b.from_height <= a.to_height;
+}
+function defaultRetainUntil(createdAt) {
+  return new Date(createdAt.getTime() + FAILURE_RETENTION_DAYS * 24 * 60 * 60 * 1000);
+}
+// src/streams-cursor.ts
+var EMPTY_RANGE_EVENT_INDEX_SENTINEL = 2147483647;
+function encodeStreamsCursor(cursor) {
+  return `${cursor.block_height}:${cursor.event_index}`;
+}
+function decodeStreamsCursor(cursor) {
+  const match = /^(0|[1-9]\d*):(0|[1-9]\d*)$/.exec(cursor);
+  if (!match) {
+    throw new Error("Invalid Streams cursor");
+  }
+  const decoded = {
+    block_height: Number(match[1]),
+    event_index: Number(match[2])
+  };
+  if (!Number.isSafeInteger(decoded.block_height) || !Number.isSafeInteger(decoded.event_index)) {
+    throw new Error("Invalid Streams cursor");
+  }
+  return decoded;
+}
+function compareStreamsCursor(a, b) {
+  if (a.block_height !== b.block_height) {
+    return a.block_height < b.block_height ? -1 : 1;
+  }
+  if (a.event_index !== b.event_index) {
+    return a.event_index < b.event_index ? -1 : 1;
+  }
+  return 0;
+}
+function isEmptyRangeCursor(cursor) {
+  return cursor.event_index === EMPTY_RANGE_EVENT_INDEX_SENTINEL;
+}
+function blockEndCursor(height) {
+  return {
+    block_height: height,
+    event_index: EMPTY_RANGE_EVENT_INDEX_SENTINEL
+  };
+}
+
+// src/coverage/evaluate.ts
+var COVERAGE_REPORT_SCHEMA_VERSION = 1;
+var COVERAGE_STATES = [
+  "complete",
+  "syncing",
+  "lagging",
+  "gap",
+  "stale",
+  "failed",
+  "unverified_import",
+  "unanchored",
+  "source_unavailable",
+  "out_of_scope",
+  "disabled"
+];
+var HARD_DEP_STATES = new Set([
+  "disabled",
+  "failed",
+  "source_unavailable",
+  "out_of_scope",
+  "unverified_import",
+  "unanchored",
+  "gap"
+]);
+var DEFAULT_MAX_BLOCKS_BEHIND_FINALIZED = 256;
+var DEFAULT_MAX_SOURCE_AGE_SECONDS = 300;
+function mergeRanges(ranges) {
+  const sorted = ranges.filter((r) => rangeIsOrdered(r.from_height, r.to_height)).map((r) => ({ from_height: r.from_height, to_height: r.to_height })).sort((a, b) => a.from_height - b.from_height || a.to_height - b.to_height);
+  const out = [];
+  for (const range of sorted) {
+    const last = out[out.length - 1];
+    if (last && range.from_height <= last.to_height + 1) {
+      last.to_height = Math.max(last.to_height, range.to_height);
+    } else {
+      out.push(range);
+    }
+  }
+  return out;
+}
+function contiguousThrough(ranges, start) {
+  const merged = mergeRanges(ranges);
+  let through = null;
+  let need = start;
+  for (const range of merged) {
+    if (range.to_height < need)
+      continue;
+    if (range.from_height > need)
+      break;
+    through = range.to_height;
+    need = range.to_height + 1;
+  }
+  return through;
+}
+function findRangeGaps(ranges, from, to) {
+  if (to < from)
+    return [];
+  const merged = mergeRanges(ranges);
+  const gaps = [];
+  let cursor = from;
+  for (const range of merged) {
+    if (range.to_height < from)
+      continue;
+    if (range.from_height > to)
+      break;
+    if (range.from_height > cursor) {
+      gaps.push({
+        from_height: cursor,
+        to_height: Math.min(range.from_height - 1, to)
+      });
+    }
+    cursor = Math.max(cursor, range.to_height + 1);
+    if (cursor > to)
+      break;
+  }
+  if (cursor <= to) {
+    gaps.push({ from_height: cursor, to_height: to });
+  }
+  return gaps;
+}
+function cursorHeight(cursor) {
+  if (!cursor)
+    return null;
+  try {
+    return decodeStreamsCursor(cursor).block_height;
+  } catch {
+    return null;
+  }
+}
+function topoSort(stages) {
+  const ids = new Set(stages.map((s) => s.id));
+  const incoming = new Map;
+  const outgoing = new Map;
+  for (const stage of stages) {
+    incoming.set(stage.id, 0);
+    outgoing.set(stage.id, []);
+  }
+  for (const stage of stages) {
+    if (!stage.depends_on || !ids.has(stage.depends_on))
+      continue;
+    outgoing.get(stage.depends_on)?.push(stage.id);
+    incoming.set(stage.id, (incoming.get(stage.id) ?? 0) + 1);
+  }
+  const queue = [...incoming.entries()].filter(([, n]) => n === 0).map(([id]) => id).sort();
+  const order = [];
+  while (queue.length > 0) {
+    const id = queue.shift();
+    if (!id)
+      break;
+    order.push(id);
+    for (const next of outgoing.get(id) ?? []) {
+      const left = (incoming.get(next) ?? 1) - 1;
+      incoming.set(next, left);
+      if (left === 0)
+        queue.push(next);
+      queue.sort();
+    }
+  }
+  const leftover = stages.map((s) => s.id).filter((id) => !order.includes(id));
+  return { order, cycles: leftover.length > 0 ? [leftover.sort()] : [] };
+}
+function lastByStage(rows) {
+  const map = new Map;
+  for (const row of rows)
+    map.set(row.stage_id, row);
+  return map;
+}
+function emptyEvidence(stageId) {
+  return {
+    stage_id: stageId,
+    ranges: [],
+    open_failures: [],
+    cursor: null,
+    queue: null,
+    unanchored: false,
+    unverified_import: false,
+    source_available: true
+  };
+}
+function declaredEnd(args) {
+  return args.run?.target_height ?? args.scope.target_height ?? args.source.finalized_height ?? args.source.tip_height;
+}
+function clockRanges(stage, evidence) {
+  if (stage.native_clock === "block") {
+    return { ranges: evidence.ranges, invalidCursor: false };
+  }
+  const cursor = stage.native_clock === "cursor" ? evidence.cursor : evidence.queue?.fence_cursor ?? null;
+  if (!cursor)
+    return { ranges: evidence.ranges, invalidCursor: false };
+  const height = cursorHeight(cursor);
+  if (height === null)
+    return { ranges: evidence.ranges, invalidCursor: true };
+  return {
+    ranges: mergeRanges([
+      ...evidence.ranges,
+      { from_height: 0, to_height: height }
+    ]),
+    invalidCursor: false
+  };
+}
+function queueCaught(queue) {
+  if (!queue)
+    return false;
+  return queue.accepted === queue.decided && queue.delivered + queue.dead === queue.accepted;
+}
+function sourceAgeSeconds(source, now) {
+  if (!source.observed_at)
+    return source.tip_height === null ? null : 0;
+  const observed = Date.parse(source.observed_at);
+  if (Number.isNaN(observed))
+    return null;
+  return Math.max(0, Math.round((now.getTime() - observed) / 1000));
+}
+function evaluateOne(stage, input, run, evidence, dep, missingDep, inCycle) {
+  const sourceTip = input.source.tip_height;
+  const finalized = input.source.finalized_height;
+  const recordedTarget = run?.target_height ?? input.scope.target_height;
+  const maxBehind = input.options.maxBlocksBehindFinalized ?? DEFAULT_MAX_BLOCKS_BEHIND_FINALIZED;
+  const maxAge = input.options.maxSourceAgeSeconds ?? DEFAULT_MAX_SOURCE_AGE_SECONDS;
+  const age = sourceAgeSeconds(input.source, input.options.now);
+  const sourceFresh = sourceTip !== null && finalized !== null && (age === null || age <= maxAge);
+  const base = {
+    stage_id: stage.id,
+    kind: stage.kind,
+    native_clock: stage.native_clock,
+    depends_on: stage.depends_on,
+    source_tip: sourceTip,
+    finalized_height: finalized,
+    recorded_target: recordedTarget
+  };
+  const done = (state, detail, extra = {}) => {
+    const completeThrough2 = extra.complete_through ?? null;
+    const caughtUp = extra.caught_up ?? (state !== "disabled" && state !== "failed" && state !== "gap" && state !== "out_of_scope" && state !== "unverified_import" && state !== "unanchored" && state !== "source_unavailable" && completeThrough2 !== null && finalized !== null && completeThrough2 >= finalized && sourceFresh);
+    return {
+      ...base,
+      state,
+      detail,
+      complete_through: completeThrough2,
+      declared_range: extra.declared_range ?? null,
+      gaps: extra.gaps ?? [],
+      caught_up: caughtUp,
+      blocked_by: extra.blocked_by ?? null
+    };
+  };
+  if (!stage.enabled) {
+    return done("disabled", "stage is disabled");
+  }
+  if (inCycle) {
+    return done("failed", "dependency cycle");
+  }
+  if (missingDep) {
+    return done("failed", `depends on unknown stage ${stage.depends_on}`);
+  }
+  if (dep && HARD_DEP_STATES.has(dep.state)) {
+    return done(dep.state, `blocked by ${dep.stage_id}: ${dep.detail}`, {
+      complete_through: dep.complete_through,
+      blocked_by: dep.stage_id,
+      declared_range: dep.declared_range,
+      gaps: dep.gaps,
+      caught_up: false
+    });
+  }
+  if (evidence.open_failures.length > 0 || run?.status === "failed") {
+    const first = evidence.open_failures[0];
+    return done("failed", first ? `open ${first.class} failure (${first.retry_state})` : "run marked failed");
+  }
+  if (evidence.unverified_import || run?.status === "unverified_import") {
+    return done("unverified_import", "imported data has not been audited");
+  }
+  if (evidence.unanchored || run?.status === "unanchored") {
+    return done("unanchored", "receipts are missing a block hash or node anchor");
+  }
+  if (!evidence.source_available) {
+    return done("source_unavailable", "native source is unavailable");
+  }
+  const { ranges, invalidCursor } = clockRanges(stage, evidence);
+  if (invalidCursor) {
+    return done("failed", "native clock cursor is not a valid streams cursor");
+  }
+  const end = declaredEnd({ run, scope: input.scope, source: input.source });
+  if (end !== null && end < input.scope.start_height) {
+    return done("out_of_scope", "recorded target is below the instance start");
+  }
+  const sourceSilent = sourceTip === null && finalized === null && recordedTarget === null;
+  if (sourceSilent) {
+    return done("source_unavailable", "the chain source could not be reached, so the declared range is unknown");
+  }
+  if (end === null) {
+    return done("source_unavailable", "no recorded target and the source tip is unknown");
+  }
+  const declaredRange = {
+    from_height: input.scope.start_height,
+    to_height: end
+  };
+  let completeThrough = contiguousThrough(ranges, input.scope.start_height);
+  if (dep?.complete_through !== null && dep?.complete_through !== undefined) {
+    if (completeThrough === null) {} else {
+      completeThrough = Math.min(completeThrough, dep.complete_through);
+    }
+  } else if (dep && dep.complete_through === null) {
+    completeThrough = null;
+  }
+  const gaps = findRangeGaps(ranges, declaredRange.from_height, declaredRange.to_height);
+  const tiled = gaps.length === 0 && completeThrough !== null && completeThrough >= declaredRange.to_height;
+  const trailingGap = gaps.length === 1 && gaps[0].to_height === declaredRange.to_height && (completeThrough === null ? gaps[0].from_height === declaredRange.from_height : gaps[0].from_height === completeThrough + 1);
+  const queueIncomplete = stage.native_clock === "queue" && !queueCaught(evidence.queue);
+  if (gaps.length > 0 && !trailingGap) {
+    const first = gaps[0];
+    return done("gap", `missing ${first.from_height}–${first.to_height}`, {
+      complete_through: completeThrough,
+      declared_range: declaredRange,
+      gaps,
+      caught_up: false
+    });
+  }
+  if (queueIncomplete || !tiled) {
+    return done("syncing", "contiguous from start, not yet through the recorded target", {
+      complete_through: completeThrough,
+      declared_range: declaredRange,
+      gaps,
+      caught_up: false
+    });
+  }
+  const sourceStale = age !== null && age > maxAge;
+  const behindFinalized = finalized !== null && completeThrough !== null ? Math.max(0, finalized - completeThrough) : null;
+  const behindTip = sourceTip !== null && completeThrough !== null ? Math.max(0, sourceTip - completeThrough) : null;
+  const pinned = recordedTarget !== null && finalized !== null && recordedTarget < finalized;
+  if (sourceStale) {
+    return done("stale", `source observation is ${age}s old, beyond the ${maxAge}s freshness objective`, {
+      complete_through: completeThrough,
+      declared_range: declaredRange,
+      gaps,
+      caught_up: false
+    });
+  }
+  if (behindFinalized !== null && behindFinalized > maxBehind) {
+    return done("stale", `${behindFinalized} blocks behind the finalized height, beyond the ${maxBehind} threshold`, {
+      complete_through: completeThrough,
+      declared_range: declaredRange,
+      gaps,
+      caught_up: false
+    });
+  }
+  if (!pinned && behindFinalized !== null && behindFinalized > 0) {
+    return done("lagging", `${behindFinalized} blocks behind the finalized height`, {
+      complete_through: completeThrough,
+      declared_range: declaredRange,
+      gaps,
+      caught_up: false
+    });
+  }
+  if (!pinned && behindTip !== null && behindTip > 0) {
+    return done("lagging", `${behindTip} blocks behind the chain tip`, {
+      complete_through: completeThrough,
+      declared_range: declaredRange,
+      gaps
+    });
+  }
+  return done("complete", "processed every unit through the recorded target", {
+    complete_through: completeThrough,
+    declared_range: declaredRange,
+    gaps
+  });
+}
+function evaluateCoverage(input) {
+  const { order, cycles } = topoSort(input.stages);
+  const cyclic = new Set(cycles.flat());
+  const known = new Set(input.stages.map((s) => s.id));
+  const runs = lastByStage(input.runs);
+  const evidence = lastByStage(input.evidence);
+  const byId = new Map(input.stages.map((s) => [s.id, s]));
+  const evaluated = new Map;
+  const visit = (id) => {
+    const stage = byId.get(id);
+    if (!stage || evaluated.has(id))
+      return;
+    const depId = stage.depends_on;
+    const missingDep = Boolean(depId && !known.has(depId));
+    const dep = depId && !missingDep ? evaluated.get(depId) ?? null : null;
+    evaluated.set(id, evaluateOne(stage, input, runs.get(id), evidence.get(id) ?? emptyEvidence(id), dep, missingDep, cyclic.has(id)));
+  };
+  for (const id of order)
+    visit(id);
+  for (const id of cyclic)
+    visit(id);
+  const stages = [...evaluated.values()].sort((a, b) => a.stage_id.localeCompare(b.stage_id));
+  return {
+    schema_version: COVERAGE_REPORT_SCHEMA_VERSION,
+    network: input.scope.network,
+    generated_at: input.options.now.toISOString(),
+    source_tip: input.source.tip_height,
+    finalized_height: input.source.finalized_height,
+    stages,
+    evaluation_order: order,
+    cycles
+  };
+}
+// src/coverage/runner.ts
+var RUNNER_STATUSES = [
+  "pending",
+  "running",
+  "complete",
+  "failed",
+  "halted"
+];
+var RUNNER_EVENT_TYPES = [
+  "start",
+  "ack",
+  "fail",
+  "retry",
+  "halt",
+  "resume",
+  "reorg",
+  "version",
+  "finish"
+];
+var DEFAULT_MAX_RETRIES = 3;
+var RUNNER_TRANSITION_TABLE = [
+  { from: "pending", event: "start", to: "running" },
+  { from: "pending", event: "ack", to: "reject" },
+  { from: "pending", event: "fail", to: "reject" },
+  { from: "pending", event: "retry", to: "reject" },
+  { from: "pending", event: "halt", to: "reject" },
+  { from: "pending", event: "resume", to: "reject" },
+  { from: "pending", event: "reorg", to: "reject" },
+  { from: "pending", event: "version", to: "pending" },
+  { from: "pending", event: "finish", to: "reject" },
+  { from: "running", event: "start", to: "reject" },
+  { from: "running", event: "ack", to: "running" },
+  { from: "running", event: "fail", to: "failed" },
+  { from: "running", event: "retry", to: "reject" },
+  { from: "running", event: "halt", to: "halted" },
+  { from: "running", event: "resume", to: "running" },
+  { from: "running", event: "reorg", to: "running" },
+  { from: "running", event: "version", to: "halted" },
+  { from: "running", event: "finish", to: "complete" },
+  { from: "complete", event: "start", to: "reject" },
+  { from: "complete", event: "ack", to: "reject" },
+  { from: "complete", event: "fail", to: "reject" },
+  { from: "complete", event: "retry", to: "reject" },
+  { from: "complete", event: "halt", to: "reject" },
+  { from: "complete", event: "resume", to: "reject" },
+  { from: "complete", event: "reorg", to: "running" },
+  { from: "complete", event: "version", to: "complete" },
+  { from: "complete", event: "finish", to: "complete" },
+  { from: "failed", event: "start", to: "reject" },
+  { from: "failed", event: "ack", to: "reject" },
+  { from: "failed", event: "fail", to: "reject" },
+  { from: "failed", event: "retry", to: "running" },
+  { from: "failed", event: "halt", to: "halted" },
+  { from: "failed", event: "resume", to: "running" },
+  { from: "failed", event: "reorg", to: "failed" },
+  { from: "failed", event: "version", to: "halted" },
+  { from: "failed", event: "finish", to: "reject" },
+  { from: "halted", event: "start", to: "reject" },
+  { from: "halted", event: "ack", to: "reject" },
+  { from: "halted", event: "fail", to: "reject" },
+  { from: "halted", event: "retry", to: "running" },
+  { from: "halted", event: "halt", to: "halted" },
+  { from: "halted", event: "resume", to: "running" },
+  { from: "halted", event: "reorg", to: "halted" },
+  { from: "halted", event: "version", to: "halted" },
+  { from: "halted", event: "finish", to: "reject" }
+];
+var RULE_INDEX = new Map(RUNNER_TRANSITION_TABLE.map((rule) => [`${rule.from}:${rule.event}`, rule]));
+function lookupTransition(from, event) {
+  const rule = RULE_INDEX.get(`${from}:${event}`);
+  if (!rule) {
+    throw new Error(`missing transition ${from} + ${event}`);
+  }
+  return rule;
+}
+function versionsEqual(a, b) {
+  return a.code_hash === b.code_hash && a.config_hash === b.config_hash && a.handler_hash === b.handler_hash;
+}
+function expectedAckHeight(state) {
+  return state.complete_through === null ? state.start_height : state.complete_through + 1;
+}
+function createRunnerState(init) {
+  return {
+    stage_id: init.stage_id,
+    status: "pending",
+    version: init.version,
+    start_height: init.start_height,
+    target_height: init.target_height ?? null,
+    complete_through: null,
+    last_acked_hash: null,
+    retry_count: 0,
+    open_failure: null
+  };
+}
+function ok(state, effects = []) {
+  return { ok: true, state, effects };
+}
+function reject(state, reason) {
+  return { ok: false, reason, state };
+}
+function clone(state, patch) {
+  return { ...state, ...patch };
+}
+function rewind(state, forkPoint) {
+  const from = Math.max(forkPoint, state.start_height);
+  const through = state.complete_through;
+  if (through === null || through < from) {
+    return { next: state, effects: [] };
+  }
+  const completeThrough = from <= state.start_height ? null : from - 1;
+  return {
+    next: clone(state, {
+      complete_through: completeThrough,
+      last_acked_hash: null
+    }),
+    effects: [
+      {
+        type: "invalidate_receipts",
+        range: { from_height: from, to_height: through }
+      }
+    ]
+  };
+}
+function applyRetry(state, maxRetries) {
+  if (state.retry_count >= maxRetries) {
+    const failure2 = state.open_failure ? { ...state.open_failure, retry_state: "halted" } : null;
+    return ok(clone(state, { status: "halted", open_failure: failure2 }));
+  }
+  const failure = state.open_failure ? { ...state.open_failure, retry_state: "retrying" } : null;
+  return ok(clone(state, {
+    status: "running",
+    retry_count: state.retry_count + 1,
+    open_failure: failure
+  }));
+}
+function applyRunnerEvent(state, event, opts) {
+  const maxRetries = opts?.maxRetries ?? DEFAULT_MAX_RETRIES;
+  const rule = lookupTransition(state.status, event.type);
+  if (rule.to === "reject") {
+    return reject(state, `${state.status} cannot ${event.type}`);
+  }
+  const nextStatus = rule.to;
+  switch (event.type) {
+    case "start":
+      return ok(clone(state, { status: "running" }));
+    case "ack": {
+      if (event.height === state.complete_through) {
+        if (event.hash === state.last_acked_hash)
+          return ok(state);
+        return reject(state, `ack at ${event.height} has a different hash; reorg first`);
+      }
+      const expected = expectedAckHeight(state);
+      if (event.height !== expected) {
+        return reject(state, `ack at ${event.height} skips ${expected}; acknowledgements must be ordered`);
+      }
+      const effects = [];
+      const failure = state.open_failure;
+      const coversFailure = failure && failure.from_height !== null && event.height >= failure.from_height && (failure.to_height === null || event.height <= failure.to_height);
+      if (coversFailure)
+        effects.push({ type: "resolve_failure" });
+      return ok(clone(state, {
+        status: "running",
+        complete_through: event.height,
+        last_acked_hash: event.hash,
+        open_failure: coversFailure ? null : failure
+      }), effects);
+    }
+    case "fail": {
+      const failure = {
+        unit_kind: event.unit_kind,
+        class: event.class,
+        retry_state: "open",
+        from_height: event.from_height,
+        to_height: event.to_height,
+        error: event.error
+      };
+      return ok(clone(state, { status: "failed", open_failure: failure }), [
+        { type: "open_failure", failure }
+      ]);
+    }
+    case "retry":
+      return applyRetry(state, maxRetries);
+    case "halt": {
+      const failure = state.open_failure ? { ...state.open_failure, retry_state: "halted" } : state.open_failure;
+      return ok(clone(state, { status: "halted", open_failure: failure }));
+    }
+    case "resume":
+      if (state.status === "running")
+        return ok(state);
+      if (state.open_failure)
+        return applyRetry(state, maxRetries);
+      return ok(clone(state, { status: "running" }));
+    case "reorg": {
+      if (event.fork_point < state.start_height) {
+        return reject(state, `reorg fork ${event.fork_point} is below start ${state.start_height}`);
+      }
+      const { next, effects } = rewind(state, event.fork_point);
+      if (effects.length === 0)
+        return ok(state);
+      return ok(clone(next, { status: nextStatus }), effects);
+    }
+    case "version": {
+      if (versionsEqual(state.version, event.version))
+        return ok(state);
+      if (state.status === "pending") {
+        return ok(clone(state, { version: event.version }));
+      }
+      const sealed = state.status === "complete" ? "complete" : "halted";
+      return ok(clone(state, { status: sealed }), [
+        { type: "spawn_run", version: event.version }
+      ]);
+    }
+    case "finish": {
+      if (state.status === "complete")
+        return ok(state);
+      if (state.target_height === null) {
+        return reject(state, "cannot finish a follow-the-chain run");
+      }
+      if (state.complete_through === null || state.complete_through < state.target_height) {
+        return reject(state, `cannot finish: complete_through ${state.complete_through} is short of target ${state.target_height}`);
+      }
+      return ok(clone(state, { status: "complete" }));
+    }
+  }
+}
+// src/coverage/decoder-clock.ts
+import { createHash } from "node:crypto";
+function inputDigest(cursors) {
+  if (cursors.length === 0) {
+    return createHash("sha256").update(`no-match
+`).digest("hex");
+  }
+  const hash = createHash("sha256");
+  for (const cursor of cursors)
+    hash.update(`${cursor}
+`);
+  return hash.digest("hex");
+}
+function cursorIsAfterBlock(cursor, height) {
+  return compareStreamsCursor(cursor, blockEndCursor(height)) >= 0;
+}
+function cursorIsBeforeBlock(cursor, height) {
+  return cursor.block_height < height;
+}
+function parseCursor(value, label) {
+  try {
+    return { ok: true, cursor: decodeStreamsCursor(value) };
+  } catch {
+    return { ok: false, reason: `${label} is not a valid streams cursor` };
+  }
+}
+function planDecoderReceipts(input) {
+  const to = parseCursor(input.to_cursor, "to_cursor");
+  if (!to.ok)
+    return { ok: false, reason: to.reason, receipts: [] };
+  let from = null;
+  if (input.from_cursor !== null) {
+    const parsed = parseCursor(input.from_cursor, "from_cursor");
+    if (!parsed.ok)
+      return { ok: false, reason: parsed.reason, receipts: [] };
+    from = parsed.cursor;
+    if (compareStreamsCursor(from, to.cursor) >= 0) {
+      return {
+        ok: false,
+        reason: "to_cursor must be after from_cursor",
+        receipts: []
+      };
+    }
+  }
+  const startFull = from === null ? input.start_height : from.block_height + 1;
+  const lastFull = isEmptyRangeCursor(to.cursor) ? to.cursor.block_height : to.cursor.block_height - 1;
+  if (lastFull < startFull) {
+    return { ok: true, receipts: [], through_cursor: input.to_cursor };
+  }
+  if (startFull < input.start_height) {
+    return {
+      ok: false,
+      reason: `window starts at ${startFull}, below start_height ${input.start_height}`,
+      receipts: []
+    };
+  }
+  const byHeight = new Map;
+  let prevHeight = null;
+  for (const block of input.blocks) {
+    if (prevHeight !== null && block.height !== prevHeight + 1) {
+      return {
+        ok: false,
+        reason: `blocks are not contiguous (${prevHeight} → ${block.height})`,
+        receipts: []
+      };
+    }
+    if (byHeight.has(block.height)) {
+      return {
+        ok: false,
+        reason: `duplicate canonical height ${block.height}`,
+        receipts: []
+      };
+    }
+    byHeight.set(block.height, block);
+    prevHeight = block.height;
+  }
+  for (let height = startFull;height <= lastFull; height++) {
+    if (!byHeight.has(height)) {
+      return {
+        ok: false,
+        reason: `missing canonical block ${height}`,
+        receipts: []
+      };
+    }
+  }
+  const decoded = [];
+  let previous = from;
+  for (const event of input.events) {
+    const parsed = parseCursor(event.cursor, "event.cursor");
+    if (!parsed.ok)
+      return { ok: false, reason: parsed.reason, receipts: [] };
+    if (previous && compareStreamsCursor(parsed.cursor, previous) <= 0) {
+      return {
+        ok: false,
+        reason: `event cursor ${event.cursor} is not after ${encodeStreamsCursor(previous)}`,
+        receipts: []
+      };
+    }
+    if (compareStreamsCursor(parsed.cursor, to.cursor) >= 0) {
+      return {
+        ok: false,
+        reason: `event cursor ${event.cursor} is not before to_cursor`,
+        receipts: []
+      };
+    }
+    if (from && compareStreamsCursor(parsed.cursor, from) <= 0) {
+      return {
+        ok: false,
+        reason: `event cursor ${event.cursor} is not after from_cursor`,
+        receipts: []
+      };
+    }
+    const block = byHeight.get(parsed.cursor.block_height);
+    if (!block) {
+      return {
+        ok: false,
+        reason: `event ${event.cursor} has no canonical block`,
+        receipts: []
+      };
+    }
+    if (block.hash !== event.block_hash) {
+      return {
+        ok: false,
+        reason: `event ${event.cursor} hash ${event.block_hash} does not match canonical ${block.hash}`,
+        receipts: []
+      };
+    }
+    decoded.push({
+      cursor: parsed.cursor,
+      encoded: event.cursor,
+      block_hash: event.block_hash,
+      matched: event.matched
+    });
+    previous = parsed.cursor;
+  }
+  const receipts = [];
+  for (let height = startFull;height <= lastFull; height++) {
+    const block = byHeight.get(height);
+    if (!block) {
+      return {
+        ok: false,
+        reason: `missing canonical block ${height}`,
+        receipts
+      };
+    }
+    const inBlock = decoded.filter((e) => e.cursor.block_height === height);
+    const matched = inBlock.filter((e) => e.matched);
+    const last = inBlock[inBlock.length - 1];
+    const through = last ? last.encoded : encodeStreamsCursor(blockEndCursor(height));
+    receipts.push({
+      height,
+      hash: block.hash,
+      input_count: matched.length,
+      input_cursors: matched.map((e) => e.encoded),
+      input_digest: inputDigest(matched.map((e) => e.encoded)),
+      through_cursor: through,
+      no_match: matched.length === 0
+    });
+  }
+  return { ok: true, receipts, through_cursor: input.to_cursor };
+}
+// src/coverage/adapter.ts
+var DECODER_COMMIT_STEPS = [
+  "output",
+  "checkpoint",
+  "receipt",
+  "failure"
+];
+
+class DecoderAdapterCrash extends Error {
+  step;
+  name = "DecoderAdapterCrash";
+  constructor(step) {
+    super(`decoder adapter crash after ${step}`);
+    this.step = step;
+  }
+}
+async function runDecoderCommitSteps(steps, crashAfter) {
+  for (const step of DECODER_COMMIT_STEPS) {
+    await steps[step]();
+    if (crashAfter === step)
+      throw new DecoderAdapterCrash(step);
+  }
+}
+function applyDecoderReceipts(state, receipts) {
+  let current = state;
+  if (current.status === "pending") {
+    const started = applyRunnerEvent(current, { type: "start" });
+    if (!started.ok)
+      return started;
+    current = started.state;
+  }
+  for (const receipt of receipts) {
+    const event = {
+      type: "ack",
+      height: receipt.height,
+      hash: receipt.hash,
+      input_count: receipt.input_count,
+      input_digest: receipt.input_digest,
+      effect_digest: receipt.effect_digest
+    };
+    const next = applyRunnerEvent(current, event);
+    if (!next.ok)
+      return next;
+    current = next.state;
+  }
+  return { ok: true, state: current, effects: [] };
+}
+async function upsertRegistry(tx, stageId) {
+  await tx.insertInto("stage_registry").values({
+    id: stageId,
+    kind: "decode",
+    depends_on: null,
+    native_clock: "block",
+    producer_version: "v1",
+    repair_mode: "full_reindex"
+  }).onConflict((oc) => oc.column("id").doNothing()).execute();
+}
+async function writeCheckpoint(tx, decoderName, cursor) {
+  if (cursor === null)
+    return;
+  await tx.insertInto("decoder_checkpoints").values({
+    decoder_name: decoderName,
+    last_cursor: cursor
+  }).onConflict((oc) => oc.column("decoder_name").doUpdateSet({
+    last_cursor: cursor,
+    updated_at: new Date
+  })).execute();
+}
+async function writeReceipts(tx, stageId, runId, receipts) {
+  if (receipts.length === 0)
+    return;
+  await tx.insertInto("stage_block_receipts").values(receipts.map((receipt) => ({
+    stage_id: stageId,
+    run_id: runId,
+    block_height: receipt.height,
+    block_hash: receipt.hash,
+    input_count: receipt.input_count,
+    input_digest: receipt.input_digest,
+    effect_digest: receipt.effect_digest
+  }))).onConflict((oc) => oc.columns(["stage_id", "block_height", "block_hash"]).doUpdateSet((eb) => ({
+    input_count: eb.ref("excluded.input_count"),
+    input_digest: eb.ref("excluded.input_digest"),
+    effect_digest: eb.ref("excluded.effect_digest"),
+    run_id: eb.ref("excluded.run_id")
+  }))).execute();
+}
+async function writeFailure(tx, stageId, runId, failure) {
+  await tx.insertInto("stage_failures").values({
+    stage_id: stageId,
+    run_id: runId,
+    unit_kind: failure.unit_kind,
+    from_height: failure.from_height,
+    to_height: failure.to_height,
+    class: failure.class,
+    retry_state: failure.retry_state,
+    retry_count: failure.retry_count ?? 0,
+    last_error: failure.error
+  }).execute();
+}
+async function commitDecoderAdapter(db, input) {
+  const runId = input.run_id ?? null;
+  const failure = input.failure ?? null;
+  await db.transaction().execute(async (tx) => {
+    await upsertRegistry(tx, input.stage_id);
+    await runDecoderCommitSteps({
+      output: () => input.writeOutput(tx),
+      checkpoint: () => writeCheckpoint(tx, input.decoder_name, input.checkpoint_cursor),
+      receipt: () => writeReceipts(tx, input.stage_id, runId, input.receipts),
+      failure: () => failure ? writeFailure(tx, input.stage_id, runId, failure) : Promise.resolve()
+    }, input.crashAfter);
+  });
+}
+// src/coverage/sealer.ts
+import { createHash as createHash2 } from "node:crypto";
+function rangeDigestOf(parts) {
+  const hash = createHash2("sha256");
+  for (const part of parts)
+    hash.update(`${part}
+`);
+  return hash.digest("hex");
+}
+function sealFinalizedRange(receipts, range) {
+  const inRange = receipts.filter((r) => r.height >= range.from_height && r.height <= range.to_height).sort((a, b) => a.height - b.height);
+  if (inRange.length === 0) {
+    return { ok: false, reason: "no receipts in range" };
+  }
+  let expected = range.from_height;
+  for (const receipt of inRange) {
+    if (!receipt.finalized) {
+      return { ok: false, reason: `unfinalized receipt at ${receipt.height}` };
+    }
+    if (receipt.height !== expected) {
+      return {
+        ok: false,
+        reason: `gap at ${expected} before ${receipt.height}`
+      };
+    }
+    expected += 1;
+  }
+  if (inRange[inRange.length - 1]?.height !== range.to_height) {
+    return { ok: false, reason: "range is not fully covered" };
+  }
+  return {
+    ok: true,
+    compacted: inRange.length,
+    segment: {
+      from_height: range.from_height,
+      to_height: range.to_height,
+      chain_digest: rangeDigestOf(inRange.map((r) => `${r.height}:${r.hash}`)),
+      input_digest: rangeDigestOf(inRange.map((r) => r.input_digest)),
+      output_digest: rangeDigestOf(inRange.map((r) => r.effect_digest))
+    }
+  };
+}
+function segmentsSurviveReorg(segments, fork) {
+  return segments.filter((s) => s.to_height < fork);
+}
+function receiptsAfterReorg(receipts, fork) {
+  return receipts.filter((r) => r.height < fork);
+}
+// src/coverage/effect-manifest.ts
+import { createHash as createHash3 } from "node:crypto";
+function canonicalizeMutations(ops) {
+  return ops.map((op) => ({
+    op: op.op,
+    table: op.table,
+    key: sortRecord(op.key),
+    value: op.value ? sortRecord(op.value) : undefined
+  }));
+}
+function sortRecord(record) {
+  const out = {};
+  for (const key of Object.keys(record).sort())
+    out[key] = record[key] ?? null;
+  return out;
+}
+function hashEffectManifest(ops) {
+  const canonical = canonicalizeMutations(ops);
+  const hash = createHash3("sha256");
+  hash.update(JSON.stringify(canonical));
+  return hash.digest("hex");
+}
+function manifestsEqual(a, b) {
+  return hashEffectManifest(a) === hashEffectManifest(b);
+}
+// src/coverage/subgraph-adapter.ts
+var SUBGRAPH_COMMIT_STEPS = [
+  "effects",
+  "rows",
+  "journal",
+  "cursor",
+  "receipt",
+  "failure"
+];
+
+class SubgraphAdapterCrash extends Error {
+  step;
+  name = "SubgraphAdapterCrash";
+  constructor(step) {
+    super(`subgraph adapter crash after ${step}`);
+    this.step = step;
+  }
+}
+async function runSubgraphCommitSteps(steps, crashAfter) {
+  for (const step of SUBGRAPH_COMMIT_STEPS) {
+    await steps[step]();
+    if (crashAfter === step)
+      throw new SubgraphAdapterCrash(step);
+  }
+}
+async function commitSubgraphAdapter(input, wrap = (fn) => fn()) {
+  await wrap(() => runSubgraphCommitSteps({
+    effects: input.writeEffects,
+    rows: input.writeRows,
+    journal: input.writeJournal,
+    cursor: input.writeCursor,
+    receipt: input.writeReceipts,
+    failure: input.writeFailure
+  }, input.crashAfter));
+}
+// src/coverage/sparse.ts
+import { createHash as createHash4 } from "node:crypto";
+function skipReceipt(skip, chainHash) {
+  const empty = hashEffectManifest([]);
+  return {
+    height: skip.from_height,
+    hash: chainHash,
+    effect_digest: empty,
+    row_digest: empty
+  };
+}
+function sequentialDigests(heights) {
+  const ordered = [...heights].sort((a, b) => a.height - b.height);
+  return {
+    chain: rangeDigestOf(ordered.map((h) => `${h.height}:${h.hash}`)),
+    effect: rangeDigestOf(ordered.map((h) => h.effect_digest)),
+    row: rangeDigestOf(ordered.map((h) => h.row_digest))
+  };
+}
+function sparseDigests(executed, skips) {
+  const skipped = skips.flatMap(({ skip, hash }) => {
+    const out = [];
+    for (let h = skip.from_height;h <= skip.to_height; h++) {
+      out.push(skipReceipt({ ...skip, from_height: h, to_height: h }, hash));
+    }
+    return out;
+  });
+  return sequentialDigests([...executed, ...skipped]);
+}
+function proofsAgree(sequential, sparse) {
+  return sequential.chain === sparse.chain && sequential.effect === sparse.effect && sequential.row === sparse.row;
+}
+// src/coverage/deep-verify.ts
+import { createHash as createHash5 } from "node:crypto";
+function finalRowDigest(rows) {
+  const ordered = [...rows].sort((a, b) => a.table.localeCompare(b.table) || a.key.localeCompare(b.key));
+  const hash = createHash5("sha256");
+  for (const row of ordered) {
+    hash.update(`${row.table}	${row.key}	${row.value}
+`);
+  }
+  return hash.digest("hex");
+}
+function applyMutations(rows, ops) {
+  const map = new Map(rows.map((r) => [`${r.table}:${r.key}`, { ...r }]));
+  for (const op of ops) {
+    const id = String(op.key.id ?? JSON.stringify(op.key));
+    const k = `${op.table}:${id}`;
+    if (op.op === "delete") {
+      map.delete(k);
+      continue;
+    }
+    map.set(k, {
+      table: op.table,
+      key: id,
+      value: JSON.stringify(op.value ?? {})
+    });
+  }
+  return [...map.values()];
+}
+function deepVerify(opts) {
+  const scratch = applyMutations([], opts.replay);
+  const liveDigest = finalRowDigest(opts.live);
+  const scratchDigest = finalRowDigest(scratch);
+  let found = false;
+  if (opts.seed) {
+    const tainted = applyMutations(opts.live, [opts.seed]);
+    found = finalRowDigest(tainted) !== liveDigest;
+  }
+  return {
+    ok: liveDigest === scratchDigest,
+    live_digest: liveDigest,
+    scratch_digest: scratchDigest,
+    found_mutation: found
+  };
+}
+// src/coverage/queue.ts
+var QUEUE_STAGES = [
+  "decision",
+  "outbox",
+  "delivery",
+  "rollback",
+  "dlq",
+  "replay"
+];
+function emptyQueueState() {
+  return {
+    stage: "decision",
+    accepted: 0,
+    decided: 0,
+    enqueued: 0,
+    delivered: 0,
+    dead: 0,
+    fence_cursor: null,
+    last_cursor: null,
+    dedupe: new Set
+  };
+}
+function applyQueueEvent(state, event, dedupeKey) {
+  if (dedupeKey && state.dedupe.has(dedupeKey)) {
+    return { ok: true, state };
+  }
+  const next = {
+    ...state,
+    dedupe: new Set(state.dedupe)
+  };
+  if (dedupeKey)
+    next.dedupe.add(dedupeKey);
+  switch (event.type) {
+    case "accept":
+      next.accepted += 1;
+      next.stage = "decision";
+      return { ok: true, state: next };
+    case "decide":
+      if (next.decided >= next.accepted) {
+        return { ok: false, reason: "decide without accept", state };
+      }
+      next.decided += 1;
+      next.stage = event.matched ? "outbox" : "decision";
+      return { ok: true, state: next };
+    case "enqueue":
+      if (next.enqueued >= next.decided) {
+        return { ok: false, reason: "enqueue without decide", state };
+      }
+      next.enqueued += 1;
+      next.stage = "outbox";
+      return { ok: true, state: next };
+    case "deliver":
+      if (next.delivered + next.dead >= next.enqueued) {
+        return { ok: false, reason: "deliver without enqueue", state };
+      }
+      next.delivered += 1;
+      next.stage = "delivery";
+      return { ok: true, state: next };
+    case "fail":
+      next.stage = "delivery";
+      return { ok: true, state: next };
+    case "dead":
+      if (next.delivered + next.dead >= next.enqueued) {
+        return { ok: false, reason: "dead without enqueue", state };
+      }
+      next.dead += 1;
+      next.stage = "dlq";
+      return { ok: true, state: next };
+    case "requeue":
+      if (next.dead < 1)
+        return { ok: false, reason: "requeue empty dlq", state };
+      next.dead -= 1;
+      next.enqueued += 1;
+      next.stage = "outbox";
+      return { ok: true, state: next };
+    case "rollback":
+      next.stage = "rollback";
+      return { ok: true, state: next };
+    case "replay":
+      next.stage = "replay";
+      next.last_cursor = event.cursor;
+      next.fence_cursor = event.cursor;
+      return { ok: true, state: next };
+  }
+}
+function queueCaughtUp(state) {
+  return state.accepted === state.decided && state.delivered + state.dead === state.enqueued;
+}
+// src/coverage/repair.ts
+var SAFE_REPAIR_MODES = [
+  "range_safe",
+  "full_reindex",
+  "archive_replay"
+];
+function planRepair(input) {
+  if (input.range.from_height > input.range.to_height) {
+    return {
+      ...input,
+      safe: false,
+      reason: "inverted range"
+    };
+  }
+  if (!SAFE_REPAIR_MODES.includes(input.mode)) {
+    return {
+      ...input,
+      safe: false,
+      reason: `mode ${input.mode} is not registered`
+    };
+  }
+  if (input.mode === "range_safe" && !input.range_safe_proven) {
+    return {
+      ...input,
+      safe: false,
+      reason: "range_safe requires a proven range"
+    };
+  }
+  if (input.defect === "source_gap" && input.mode !== "archive_replay") {
+    return {
+      ...input,
+      safe: false,
+      reason: "raw/source gaps require archive_replay"
+    };
+  }
+  return {
+    ...input,
+    safe: true,
+    reason: `dry-run ${input.mode} for ${input.defect}`
+  };
+}
+function applyRepair(plan, opts) {
+  if (!plan.safe) {
+    return { ok: false, reason: plan.reason, plan };
+  }
+  if (!opts?.apply) {
+    return { ok: true, applied: false, plan };
+  }
+  return { ok: true, applied: true, plan };
+}
+// src/coverage/verify-target.ts
+var VERIFY_EXIT = {
+  CLEAN: 0,
+  DIVERGED: 1,
+  UNANCHORED: 2
+};
+function parseVerifyTarget(value) {
+  const raw = (value ?? "raw").trim();
+  if (raw === "all")
+    return { kind: "all" };
+  if (raw === "raw" || raw === "")
+    return { kind: "raw" };
+  if (raw.startsWith("decode:")) {
+    const name = raw.slice("decode:".length).trim();
+    if (!name)
+      throw new Error("decode: target needs a decoder name");
+    return { kind: "decode", name };
+  }
+  if (raw.startsWith("subgraph:")) {
+    const name = raw.slice("subgraph:".length).trim();
+    if (!name)
+      throw new Error("subgraph: target needs a subgraph name");
+    return { kind: "subgraph", name };
+  }
+  throw new Error(`verify target must be all | raw | decode:<name> | subgraph:<name> (got ${value})`);
+}
+var RAW_DATASETS = new Set(["blocks", "transactions", "events"]);
+function datasetMatchesTarget(dataset, target) {
+  if (target.kind === "all")
+    return true;
+  const name = dataset.toLowerCase();
+  if (target.kind === "raw")
+    return RAW_DATASETS.has(name);
+  if (target.kind === "decode") {
+    return name === target.name.toLowerCase() || name === `decode:${target.name.toLowerCase()}` || name.endsWith(`_${target.name.toLowerCase()}`);
+  }
+  return name === target.name.toLowerCase() || name === `subgraph:${target.name.toLowerCase()}` || name.startsWith(`${target.name.toLowerCase()}_`);
+}
+function reportVerify(opts) {
+  const mode = opts.mode ?? "quick";
+  if (opts.anchored === false) {
+    return {
+      target: opts.target,
+      mode,
+      exit: VERIFY_EXIT.UNANCHORED,
+      status: "unanchored",
+      detail: opts.detail ?? "reference unavailable or unverifiable"
+    };
+  }
+  if (opts.diverged) {
+    return {
+      target: opts.target,
+      mode,
+      exit: VERIFY_EXIT.DIVERGED,
+      status: "diverged",
+      detail: opts.detail ?? "coverage or archive diverged"
+    };
+  }
+  const label = opts.target.kind === "decode" ? `decode:${opts.target.name}` : opts.target.kind === "subgraph" ? `subgraph:${opts.target.name}` : opts.target.kind;
+  return {
+    target: opts.target,
+    mode,
+    exit: VERIFY_EXIT.CLEAN,
+    status: "clean",
+    detail: opts.detail ?? `${label} ${mode} is clean`
+  };
+}
+export {
+  versionsEqual,
+  topoSort,
+  sparseDigests,
+  sequentialDigests,
+  segmentsSurviveReorg,
+  segmentsOverlap,
+  sealFinalizedRange,
+  runSubgraphCommitSteps,
+  runDecoderCommitSteps,
+  reportVerify,
+  receiptsAfterReorg,
+  receiptRetentionHolds,
+  rangeIsOrdered,
+  rangeDigestOf,
+  queueCaughtUp,
+  proofsAgree,
+  planRepair,
+  planDecoderReceipts,
+  parseVerifyTarget,
+  mergeRanges,
+  manifestsEqual,
+  lookupTransition,
+  isStageKind,
+  isRunStatus,
+  isRetryState,
+  isRepairMode,
+  isNonNegativeInt,
+  isNativeClock,
+  isFailureUnit,
+  isFailureClass,
+  inputDigest,
+  hashEffectManifest,
+  findRangeGaps,
+  finalRowDigest,
+  failureRetentionHolds,
+  failureRangeHolds,
+  expectedAckHeight,
+  evaluateCoverage,
+  emptyQueueState,
+  defaultRetainUntil,
+  deepVerify,
+  datasetMatchesTarget,
+  cursorIsBeforeBlock,
+  cursorIsAfterBlock,
+  cursorHeight,
+  createRunnerState,
+  contiguousThrough,
+  commitSubgraphAdapter,
+  commitDecoderAdapter,
+  canonicalizeMutations,
+  applyRunnerEvent,
+  applyRepair,
+  applyQueueEvent,
+  applyMutations,
+  applyDecoderReceipts,
+  VERIFY_EXIT,
+  SubgraphAdapterCrash,
+  SUBGRAPH_COMMIT_STEPS,
+  STAGE_KINDS,
+  SAFE_REPAIR_MODES,
+  RUN_STATUSES,
+  RUNNER_TRANSITION_TABLE,
+  RUNNER_STATUSES,
+  RUNNER_EVENT_TYPES,
+  RETRY_STATES,
+  REPAIR_MODES,
+  QUEUE_STAGES,
+  NATIVE_CLOCKS,
+  FAILURE_UNITS,
+  FAILURE_RETENTION_DAYS,
+  FAILURE_CLASSES,
+  DecoderAdapterCrash,
+  DEFAULT_MAX_RETRIES,
+  DECODER_COMMIT_STEPS,
+  COVERAGE_STATES,
+  COVERAGE_REPORT_SCHEMA_VERSION
+};
+
+//# debugId=74D0FA2357387FF664756E2164756E21
+//# sourceMappingURL=index.js.map