@secondlayer/cli 22.1.0 → 22.2.0

package/dist/cli.js

@@ -29488,7 +29488,7 @@ var init_git_status = () => {};
 
 // ../../node_modules/typescript/lib/typescript.js
 var require_typescript = __commonJS(function(exports, module) {
-  var __dirname = "/Users/ryan/projects/secondlayer/.claude/worktrees/rel313/node_modules/typescript/lib", __filename = "/Users/ryan/projects/secondlayer/.claude/worktrees/rel313/node_modules/typescript/lib/typescript.js";
+  var __dirname = "/Users/ryan/projects/secondlayer/.claude/worktrees/fix312/node_modules/typescript/lib", __filename = "/Users/ryan/projects/secondlayer/.claude/worktrees/fix312/node_modules/typescript/lib/typescript.js";
   /*! *****************************************************************************
   Copyright (c) Microsoft Corporation. All rights reserved.
   Licensed under the Apache License, Version 2.0 (the "License"); you may not use
@@ -202711,7 +202711,7 @@ var {
 // package.json
 var package_default = {
   name: "@secondlayer/cli",
-  version: "22.1.0",
+  version: "22.2.0",
   description: "Run a Stacks index on your own hardware — set it up, restore verified history, and keep it current.",
   repository: {
     type: "git",
@@ -202750,8 +202750,8 @@ var package_default = {
     "@inquirer/prompts": "^8.2.0",
     "@secondlayer/bundler": "^0.7.1",
     "@secondlayer/scaffold": "^1.6.2",
-    "@secondlayer/sdk": "^15.1.0",
-    "@secondlayer/shared": "^13.7.0",
+    "@secondlayer/sdk": "^15.4.1",
+    "@secondlayer/shared": "^13.14.0",
     "@secondlayer/stacks": "^6.4.0",
     "@secondlayer/subgraphs": "^7.2.0",
     "@secondlayer/verify": "^0.6.0",
@@ -202924,6 +202924,12 @@ import {
   copyStatement,
   writeRowsToCopyStream
 } from "@secondlayer/shared/archive/copy-loader";
+import {
+  ARCHIVE_DATASETS as ARCHIVE_DATASETS2,
+  archiveHeightColumn,
+  isArchiveDataset,
+  manifestPublishes
+} from "@secondlayer/shared/archive/datasets";
 import {
   computeRangeDigest
 } from "@secondlayer/shared/archive/range-digest";
@@ -203071,7 +203077,15 @@ async function fetchVerifiedPartition(reference, partition, gate, fetchOpts) {
 }
 
 // src/lib/bootstrap-resume.ts
-var RESUME_DATASETS = ["blocks", "transactions", "events"];
+import {
+  ARCHIVE_DATASETS
+} from "@secondlayer/shared/archive/datasets";
+var RESUME_DATASETS = ARCHIVE_DATASETS;
+var FK_PARENT = {
+  transactions: "blocks",
+  events: "transactions",
+  state_writes: "blocks"
+};
 function isResumeDataset(value) {
   return RESUME_DATASETS.includes(value);
 }
@@ -203085,16 +203099,8 @@ function planTornImport(input) {
   if (RESUME_DATASETS.every((d) => input.highWater[d] === null)) {
     return { action: "fresh" };
   }
-  const truncateFrom = {
-    blocks: null,
-    transactions: null,
-    events: null
-  };
-  const skipThrough = {
-    blocks: 0,
-    transactions: 0,
-    events: 0
-  };
+  const truncateFrom = Object.fromEntries(RESUME_DATASETS.map((d) => [d, null]));
+  const skipThrough = Object.fromEntries(RESUME_DATASETS.map((d) => [d, 0]));
   for (const dataset of RESUME_DATASETS) {
     const mark = input.highWater[dataset];
     if (mark === null)
@@ -203109,17 +203115,18 @@ function planTornImport(input) {
     const defined = values.filter((v) => v !== null);
     return defined.length === 0 ? null : Math.min(...defined);
   };
-  truncateFrom.transactions = minDefined(truncateFrom.blocks, truncateFrom.transactions);
-  truncateFrom.events = minDefined(truncateFrom.transactions, truncateFrom.events);
-  const capTo = (dataset, parentSealed) => {
-    if (skipThrough[dataset] <= parentSealed)
-      return;
-    skipThrough[dataset] = parentSealed;
-    truncateFrom[dataset] = minDefined(truncateFrom[dataset], parentSealed + 1);
-  };
-  capTo("transactions", skipThrough.blocks);
-  capTo("events", skipThrough.transactions);
-  truncateFrom.events = minDefined(truncateFrom.transactions, truncateFrom.events);
+  const children = RESUME_DATASETS.filter((d) => d !== "blocks");
+  for (const dataset of children) {
+    truncateFrom[dataset] = minDefined(truncateFrom[FK_PARENT[dataset]], truncateFrom[dataset]);
+  }
+  for (const dataset of children) {
+    const parent = FK_PARENT[dataset];
+    if (skipThrough[dataset] > skipThrough[parent]) {
+      skipThrough[dataset] = skipThrough[parent];
+      truncateFrom[dataset] = minDefined(truncateFrom[dataset], skipThrough[parent] + 1);
+    }
+    truncateFrom[dataset] = minDefined(truncateFrom[parent], truncateFrom[dataset]);
+  }
   return { action: "resume", truncateFrom, skipThrough };
 }
 function partitionIsLoaded(partition, skipThrough) {
@@ -203211,41 +203218,38 @@ async function loadPartition(reference, partition, rawClient, gate) {
   }
   return written;
 }
-var LOAD_ORDER = [
-  "blocks",
-  "transactions",
-  "events"
-];
+function restoredSummary(loaded) {
+  return LOAD_ORDER.filter((d) => loaded[d] !== undefined).map((d) => `${(loaded[d] ?? 0).toLocaleString()} ${d}`).join(", ");
+}
+var LOAD_ORDER = ARCHIVE_DATASETS2;
 function loadOrder(partitions) {
   return LOAD_ORDER.flatMap((dataset) => partitions.filter((p) => p.dataset === dataset).sort((a, b) => a.from_block - b.from_block));
 }
 function parseVerifyDatasets(value) {
   if (value === undefined || value === "all") {
-    return ["blocks", "transactions", "events"];
+    return [...ARCHIVE_DATASETS2];
   }
   if (value === "blocks")
     return ["blocks"];
   throw new Error(`--verify must be "all" or "blocks", got "${String(value)}"`);
 }
 async function readHighWater(db) {
-  const asMark = (value) => value === null || value === undefined ? null : Number(value);
-  const blocks = await db.selectFrom("blocks").select(({ fn }) => fn.max("height").as("max")).executeTakeFirst();
-  const transactions = await db.selectFrom("transactions").select(({ fn }) => fn.max("block_height").as("max")).executeTakeFirst();
-  const events = await db.selectFrom("events").select(({ fn }) => fn.max("block_height").as("max")).executeTakeFirst();
-  return {
-    blocks: asMark(blocks?.max),
-    transactions: asMark(transactions?.max),
-    events: asMark(events?.max)
-  };
+  const marks = {};
+  for (const dataset of RESUME_DATASETS) {
+    const { rows } = await sql`
+			SELECT max(${sql.ref(archiveHeightColumn(dataset))}) AS max
+			FROM ${sql.table(dataset)}
+		`.execute(db);
+    const max = rows[0]?.max;
+    marks[dataset] = max === null || max === undefined ? null : Number(max);
+  }
+  return marks;
 }
 async function truncateDatasetFrom(db, dataset, from) {
-  if (dataset === "blocks") {
-    await sql`DELETE FROM blocks WHERE height >= ${from}`.execute(db);
-  } else if (dataset === "transactions") {
-    await sql`DELETE FROM transactions WHERE block_height >= ${from}`.execute(db);
-  } else {
-    await sql`DELETE FROM events WHERE block_height >= ${from}`.execute(db);
-  }
+  await sql`
+		DELETE FROM ${sql.table(dataset)}
+		WHERE ${sql.ref(archiveHeightColumn(dataset))} >= ${from}
+	`.execute(db);
 }
 function attachBootstrapCommand(cmd) {
   return cmd.requiredOption("--against <manifest>", "archive manifest: an https URL or a local file path").option("--to-block <n>", "stop at this height instead of the archive tip").option("--from-block <n>", "forward-only: restore from this height instead of genesis; earlier history is declared out of scope").option("--public-key <pem>", "pin a signing key; default is the archive key built into this release").option("--verify <datasets>", "digests checked after the load: all (blocks, transactions, events; adds minutes on a full chain) or blocks", "all").option("-y, --yes", "skip the confirmation prompt").option("--json", "Output as JSON").addHelpText("after", `
@@ -203259,7 +203263,7 @@ Exit codes:
   1  restore completed but verification found divergence
   2  refused (non-empty target, or an untrusted reference)`).action(async (opts) => {
     try {
-      const verifyDatasets = parseVerifyDatasets(opts.verify);
+      const requestedVerify = parseVerifyDatasets(opts.verify);
       const publicKey = await resolveArchivePublicKey({
         explicitPem: opts.publicKey,
         envPem: process.env.ARCHIVE_SIGNING_PUBLIC_KEY ?? process.env.STREAMS_SIGNING_PUBLIC_KEY,
@@ -203269,6 +203273,7 @@ Exit codes:
         publicKeyPem: publicKey
       });
       const signature = checkSignature(reference.manifest, publicKey, false);
+      const verifyDatasets = requestedVerify.filter((d) => manifestPublishes(reference.manifest, d));
       if (!signature.verified) {
         printError(`Refusing to bootstrap from an untrusted archive: ${signature.reason}.`, {
           hint: "Pass --public-key <pem> to pin the archive's signing key."
@@ -203280,7 +203285,14 @@ Exit codes:
       const highWater = await readHighWater(db);
       const toBlock = opts.toBlock === undefined ? undefined : Number(opts.toBlock);
       const fromBlock = opts.fromBlock === undefined ? undefined : Number(opts.fromBlock);
-      const declared = (reference.manifest.partitions ?? []).filter((p) => (toBlock === undefined || p.to_block <= toBlock) && (fromBlock === undefined || p.from_block >= fromBlock));
+      const inScope = (reference.manifest.partitions ?? []).filter((p) => (toBlock === undefined || p.to_block <= toBlock) && (fromBlock === undefined || p.from_block >= fromBlock));
+      const unknown = [
+        ...new Set(inScope.map((p) => p.dataset).filter((d) => !isArchiveDataset(d)))
+      ];
+      if (unknown.length > 0) {
+        warn(`Skipping archive datasets this release does not know: ${unknown.join(", ")}. Upgrade the CLI to load them.`);
+      }
+      const declared = inScope.filter((p) => isArchiveDataset(p.dataset));
       if (declared.length === 0) {
         printError("The archive has no partitions for that range.", {
           hint: "Check --from-block and --to-block against the manifest's coverage."
@@ -203379,16 +203391,16 @@ Exit codes:
       }
       const nodeTipAtStart = await readNodeTip();
       const rawClient = getRawClient("source");
-      const loaded = { blocks: 0, transactions: 0, events: 0 };
+      const loaded = Object.fromEntries(LOAD_ORDER.filter((d) => manifestPublishes(reference.manifest, d)).map((d) => [d, 0]));
       const startedAt = Date.now();
       for (const dataset of LOAD_ORDER) {
         const datasetPartitions = loadOrder(partitions).filter((p) => p.dataset === dataset);
         for (const [index, partition] of datasetPartitions.entries()) {
-          loaded[dataset] += await loadPartition(reference, partition, rawClient, gate);
+          loaded[dataset] = (loaded[dataset] ?? 0) + await loadPartition(reference, partition, rawClient, gate);
           const done = index + 1;
           if (done % 10 === 0 || done === datasetPartitions.length) {
             const elapsed = (Date.now() - startedAt) / 1000;
-            note(`  ${dataset}: ${done}/${datasetPartitions.length} partitions · ${loaded[dataset].toLocaleString()} rows · ${formatDuration(elapsed)} elapsed`);
+            note(`  ${dataset}: ${done}/${datasetPartitions.length} partitions · ${(loaded[dataset] ?? 0).toLocaleString()} rows · ${formatDuration(elapsed)} elapsed`);
           }
         }
       }
@@ -203456,7 +203468,7 @@ Exit codes:
         data: report,
         human: () => {
           if (divergent === 0) {
-            success(`Restored ${loaded.blocks.toLocaleString()} blocks, ${loaded.transactions.toLocaleString()} transactions, ${loaded.events.toLocaleString()} events in ${formatDuration(elapsed)}.`);
+            success(`Restored ${restoredSummary(loaded)} in ${formatDuration(elapsed)}.`);
             if (referenceDigests.length > 0) {
               note(`  verified ${referenceDigests.length} ${verifyDatasets.join("/")} ranges against the archive`);
             } else {
@@ -203478,7 +203490,7 @@ Exit codes:
             }
           } else {
             const byDataset = verifyDatasets.map((d) => `${divergentRanges.filter((r) => r.dataset === d).length} ${d}`).join(", ");
-            warn(`Restored ${loaded.blocks.toLocaleString()} blocks but ${divergent} ranges do not match the archive (${byDataset}).`);
+            warn(`Restored ${(loaded.blocks ?? 0).toLocaleString()} blocks but ${divergent} ranges do not match the archive (${byDataset}).`);
             console.error(dim("  Investigate with: secondlayer verify --against <manifest>"));
           }
         }
@@ -203511,6 +203523,10 @@ import {
   copyStatement as copyStatement2,
   writeRowsToCopyStream as writeRowsToCopyStream2
 } from "@secondlayer/shared/archive/copy-loader";
+import {
+  ARCHIVE_DATASETS as ARCHIVE_DATASETS3,
+  manifestPublishes as manifestPublishes2
+} from "@secondlayer/shared/archive/datasets";
 import {
   compareRangeDigests,
   computeRangeDigest as computeRangeDigest2
@@ -203594,38 +203610,43 @@ async function planRange(db, reference, partition, gate) {
   const extraHeights = [...localByHeight.keys()].sort((a, b) => a - b);
   return { fixes, extraHeights };
 }
-var CHILD_DATASETS = ["transactions", "events"];
-var REPAIR_DATASETS = [
-  "blocks",
-  "transactions",
-  "events"
-];
+var CHILD_DATASETS = ARCHIVE_DATASETS3.filter((d) => d !== "blocks");
+var REWRITE_TOGETHER = {
+  transactions: ["transactions", "events"],
+  events: ["transactions", "events"],
+  state_writes: ["state_writes"]
+};
+function publishedChildren(manifest) {
+  return CHILD_DATASETS.filter((d) => manifestPublishes2(manifest, d));
+}
+function reportedDatasets(children) {
+  return ARCHIVE_DATASETS3.filter((d) => d === "blocks" || children.includes(d));
+}
+function zeroCounts(datasets) {
+  return Object.fromEntries(datasets.map((d) => [d, 0]));
+}
 function childPartitionFor(partitions, dataset, height) {
   return partitions.find((p) => p.dataset === dataset && p.from_block <= height && p.to_block >= height);
 }
-function planChildRewrite(partitions, heights) {
-  const missing = {
-    transactions: [],
-    events: []
-  };
+function planChildRewrite(partitions, heights, children = ["transactions", "events"]) {
+  const missing = {};
   const found = new Map;
-  for (const dataset of CHILD_DATASETS) {
+  for (const dataset of children) {
+    missing[dataset] = [];
     for (const height of heights) {
       const partition = childPartitionFor(partitions, dataset, height);
       if (!partition) {
-        missing[dataset].push(height);
+        missing[dataset]?.push(height);
         continue;
       }
       found.set(height, { ...found.get(height), [dataset]: partition });
     }
   }
-  const rewritable = heights.filter((h) => {
-    const entry = found.get(h);
-    return !!entry?.transactions && !!entry?.events;
-  });
+  const rewritable = {};
   const byPartition = new Map;
-  for (const height of rewritable) {
-    for (const dataset of CHILD_DATASETS) {
+  for (const dataset of children) {
+    rewritable[dataset] = heights.filter((h) => REWRITE_TOGETHER[dataset].every((d) => !!found.get(h)?.[d]));
+    for (const height of rewritable[dataset] ?? []) {
       const partition = found.get(height)?.[dataset];
       if (!partition)
         continue;
@@ -203647,11 +203668,9 @@ async function* onlyHeights(rows, heights) {
 }
 async function applyFixes(rawClient, reference, partition, fixes, gate) {
   const applied = {
-    blocks: 0,
-    transactions: 0,
-    events: 0,
-    missing: { transactions: [], events: [] },
-    rewritten: []
+    rows: Object.fromEntries(ARCHIVE_DATASETS3.map((d) => [d, 0])),
+    missing: {},
+    rewritten: {}
   };
   if (fixes.length === 0)
     return applied;
@@ -203660,20 +203679,20 @@ async function applyFixes(rawClient, reference, partition, fixes, gate) {
   const byHeight = new Map(archiveBlocks.map((b) => [b.height, b]));
   const targets = fixes.map((fix) => byHeight.get(fix.height)).filter((b) => b !== undefined);
   const heights = targets.map((b) => b.height);
-  const children = planChildRewrite(reference.manifest.partitions ?? [], heights);
+  const children = planChildRewrite(reference.manifest.partitions ?? [], heights, publishedChildren(reference.manifest));
   applied.missing = children.missing;
   applied.rewritten = children.rewritable;
-  const rewritable = new Set(children.rewritable);
   const childBytes = new Map;
   for (const [path, { partition: child }] of children.byPartition) {
     childBytes.set(path, await fetchVerifiedPartition(reference, child, gate));
   }
   await rawClient.begin(async (tx) => {
-    for (const height of rewritable) {
-      await tx.unsafe("DELETE FROM events WHERE block_height = $1", [height]);
-      await tx.unsafe("DELETE FROM transactions WHERE block_height = $1", [
-        height
-      ]);
+    for (const dataset of [...CHILD_DATASETS].reverse()) {
+      for (const height of children.rewritable[dataset] ?? []) {
+        await tx.unsafe(`DELETE FROM ${dataset} WHERE block_height = $1`, [
+          height
+        ]);
+      }
     }
     for (const block of targets) {
       await tx.unsafe(`INSERT INTO blocks (
@@ -203697,8 +203716,9 @@ async function applyFixes(rawClient, reference, partition, fixes, gate) {
         block.timestamp
       ]);
     }
-    applied.blocks = targets.length;
+    applied.rows.blocks = targets.length;
     for (const dataset of CHILD_DATASETS) {
+      const keep = new Set(children.rewritable[dataset] ?? []);
       for (const [path, { partition: child }] of children.byPartition) {
         if (child.dataset !== dataset)
           continue;
@@ -203706,24 +203726,20 @@ async function applyFixes(rawClient, reference, partition, fixes, gate) {
         if (!bytes)
           continue;
         const writable = await tx.unsafe(copyStatement2(dataset)).writable();
-        applied[dataset] += await writeRowsToCopyStream2({
+        applied.rows[dataset] += await writeRowsToCopyStream2({
           writable,
           dataset,
-          rows: onlyHeights(readPartitionRows(bytes, `repair-${dataset}-${child.from_block}`), rewritable)
+          rows: onlyHeights(readPartitionRows(bytes, `repair-${dataset}-${child.from_block}`), keep)
         });
       }
     }
   });
   return applied;
 }
-async function reverify(db, reference, ranges) {
-  const remaining = {
-    blocks: 0,
-    transactions: 0,
-    events: 0
-  };
+async function reverify(db, reference, ranges, datasets) {
+  const remaining = {};
   const published = reference.manifest.range_digests ?? [];
-  for (const dataset of REPAIR_DATASETS) {
+  for (const dataset of datasets) {
     const expected = published.filter((d) => d.dataset === dataset && ranges.some((r) => r.from_block === d.from_block && r.to_block === d.to_block));
     const actual = [];
     for (const range of expected) {
@@ -203739,10 +203755,16 @@ function findChildPartition(partitions, dataset, fromBlock, toBlock) {
 function expectedZeroRows(zeroRecordRanges, dataset, fromBlock, toBlock) {
   return zeroRecordRanges.some((r) => r.dataset === dataset && r.from_block === fromBlock && r.to_block === toBlock);
 }
-async function planChildPartitionDivergence(db, partitions, zeroRecordRanges, inRange) {
+var CHILD_LABEL = {
+  transactions: "TX",
+  events: "EVENTS",
+  state_writes: "WRITES"
+};
+async function planChildPartitionDivergence(db, partitions, zeroRecordRanges, inRange, children = ["transactions", "events"]) {
+  const isChild = (dataset) => children.includes(dataset);
   const ranges = new Map;
   for (const p of partitions) {
-    if (p.dataset !== "transactions" && p.dataset !== "events")
+    if (!isChild(p.dataset))
       continue;
     if (!inRange(p.from_block, p.to_block))
       continue;
@@ -203753,59 +203775,74 @@ async function planChildPartitionDivergence(db, partitions, zeroRecordRanges, in
   }
   const mismatches = [];
   for (const { from, to } of ranges.values()) {
-    const txPartition = findChildPartition(partitions, "transactions", from, to);
-    const evPartition = findChildPartition(partitions, "events", from, to);
-    const expectedTx = txPartition?.row_count ?? (expectedZeroRows(zeroRecordRanges, "transactions", from, to) ? 0 : null);
-    const expectedEv = evPartition?.row_count ?? (expectedZeroRows(zeroRecordRanges, "events", from, to) ? 0 : null);
-    if (expectedTx === null && expectedEv === null)
-      continue;
-    const actualTx = (await computeRangeDigest2(db, "transactions", from, to)).row_count;
-    const actualEv = (await computeRangeDigest2(db, "events", from, to)).row_count;
-    if (expectedTx !== null && actualTx !== expectedTx || expectedEv !== null && actualEv !== expectedEv) {
-      mismatches.push({
-        from_block: from,
-        to_block: to,
-        transactions: { expected: expectedTx ?? actualTx, actual: actualTx },
-        events: { expected: expectedEv ?? actualEv, actual: actualEv }
-      });
+    const expected = new Map;
+    for (const dataset of children) {
+      expected.set(dataset, findChildPartition(partitions, dataset, from, to)?.row_count ?? (expectedZeroRows(zeroRecordRanges, dataset, from, to) ? 0 : null));
     }
+    if ([...expected.values()].every((count) => count === null))
+      continue;
+    const mismatch = { from_block: from, to_block: to };
+    let diverged = false;
+    for (const dataset of children) {
+      const actual = (await computeRangeDigest2(db, dataset, from, to)).row_count;
+      const want = expected.get(dataset) ?? actual;
+      mismatch[dataset] = { expected: want, actual };
+      if (want !== actual)
+        diverged = true;
+    }
+    if (diverged)
+      mismatches.push(mismatch);
   }
   return mismatches;
 }
+function childRewritesFor(mismatch) {
+  const rewrite = new Set;
+  for (const dataset of CHILD_DATASETS) {
+    const count = mismatch[dataset];
+    if (!count || count.expected === count.actual)
+      continue;
+    for (const partner of REWRITE_TOGETHER[dataset]) {
+      if (mismatch[partner])
+        rewrite.add(partner);
+    }
+  }
+  return CHILD_DATASETS.filter((d) => rewrite.has(d));
+}
 async function applyChildRangeFix(rawClient, reference, mismatch, gate) {
   const partitions = reference.manifest.partitions ?? [];
-  const txPartition = findChildPartition(partitions, "transactions", mismatch.from_block, mismatch.to_block);
-  const evPartition = findChildPartition(partitions, "events", mismatch.from_block, mismatch.to_block);
-  const txBytes = txPartition ? await fetchVerifiedPartition(reference, txPartition, gate) : null;
-  const evBytes = evPartition ? await fetchVerifiedPartition(reference, evPartition, gate) : null;
+  const rewrite = childRewritesFor(mismatch);
+  const bytes = new Map;
+  for (const dataset of rewrite) {
+    const partition = findChildPartition(partitions, dataset, mismatch.from_block, mismatch.to_block);
+    if (partition) {
+      bytes.set(dataset, await fetchVerifiedPartition(reference, partition, gate));
+    }
+  }
   const written = {
-    transactions: 0,
-    events: 0,
+    rows: Object.fromEntries(rewrite.map((d) => [d, 0])),
     vm_events: { restored: 0, dropped: 0 }
   };
+  const parksVmEvents = rewrite.includes("transactions");
   await rawClient.begin(async (tx) => {
-    await tx.unsafe("CREATE TEMP TABLE repair_vm_events_keep ON COMMIT DROP AS SELECT * FROM vm_events WHERE block_height BETWEEN $1 AND $2", [mismatch.from_block, mismatch.to_block]);
-    await tx.unsafe("DELETE FROM events WHERE block_height BETWEEN $1 AND $2", [
-      mismatch.from_block,
-      mismatch.to_block
-    ]);
-    await tx.unsafe("DELETE FROM transactions WHERE block_height BETWEEN $1 AND $2", [mismatch.from_block, mismatch.to_block]);
-    if (txBytes) {
-      const writable = await tx.unsafe(copyStatement2("transactions")).writable();
-      written.transactions = await writeRowsToCopyStream2({
-        writable,
-        dataset: "transactions",
-        rows: readPartitionRows(txBytes, `repair-transactions-${mismatch.from_block}`)
-      });
+    if (parksVmEvents) {
+      await tx.unsafe("CREATE TEMP TABLE repair_vm_events_keep ON COMMIT DROP AS SELECT * FROM vm_events WHERE block_height BETWEEN $1 AND $2", [mismatch.from_block, mismatch.to_block]);
     }
-    if (evBytes) {
-      const writable = await tx.unsafe(copyStatement2("events")).writable();
-      written.events = await writeRowsToCopyStream2({
+    for (const dataset of [...rewrite].reverse()) {
+      await tx.unsafe(`DELETE FROM ${dataset} WHERE block_height BETWEEN $1 AND $2`, [mismatch.from_block, mismatch.to_block]);
+    }
+    for (const dataset of rewrite) {
+      const partitionBytes = bytes.get(dataset);
+      if (!partitionBytes)
+        continue;
+      const writable = await tx.unsafe(copyStatement2(dataset)).writable();
+      written.rows[dataset] = await writeRowsToCopyStream2({
         writable,
-        dataset: "events",
-        rows: readPartitionRows(evBytes, `repair-events-${mismatch.from_block}`)
+        dataset,
+        rows: readPartitionRows(partitionBytes, `repair-${dataset}-${mismatch.from_block}`)
       });
     }
+    if (!parksVmEvents)
+      return;
     const kept = await tx.unsafe("SELECT count(*)::int AS n FROM repair_vm_events_keep");
     const keptCount = Number(kept[0]?.n ?? 0);
     if (keptCount > 0) {
@@ -203817,18 +203854,14 @@ async function applyChildRangeFix(rawClient, reference, mismatch, gate) {
   return written;
 }
 async function runChildOnlyRepair(params) {
-  const { reference, childMismatches, apply, json, yes } = params;
+  const { reference, childMismatches, children, apply, json, yes } = params;
   if (childMismatches.length === 0) {
     success("Nothing to repair — local data matches the archive.");
     output({ json, data: { status: "clean", fixes: [] }, human: () => {} });
     process.exit(REPAIR_EXIT.OK);
   }
   const partitions = reference.manifest.partitions ?? [];
-  const fetchPaths = childMismatches.flatMap((m) => {
-    const tx = findChildPartition(partitions, "transactions", m.from_block, m.to_block);
-    const ev = findChildPartition(partitions, "events", m.from_block, m.to_block);
-    return [tx?.path, ev?.path].filter((p) => p !== undefined);
-  });
+  const fetchPaths = childMismatches.flatMap((m) => childRewritesFor(m).map((dataset) => findChildPartition(partitions, dataset, m.from_block, m.to_block)?.path).filter((p) => p !== undefined));
   let gate;
   let quoteLine;
   if (apply && isOfficialArchive(reference)) {
@@ -203859,14 +203892,20 @@ async function runChildOnlyRepair(params) {
     }
     gate = createGatedFetcher(fetchPaths, "repair");
   }
-  const applied = { transactions: 0, events: 0 };
+  const applied = zeroCounts(children);
+  const rewritten = new Set;
   const vmEvents = { restored: 0, dropped: 0 };
   if (apply) {
     const rawClient = getRawClient2("source");
     for (const mismatch of childMismatches) {
       const result = await applyChildRangeFix(rawClient, reference, mismatch, gate);
-      applied.transactions += result.transactions;
-      applied.events += result.events;
+      for (const dataset of CHILD_DATASETS) {
+        const rows = result.rows[dataset];
+        if (rows === undefined)
+          continue;
+        applied[dataset] = (applied[dataset] ?? 0) + rows;
+        rewritten.add(dataset);
+      }
       vmEvents.restored += result.vm_events.restored;
       vmEvents.dropped += result.vm_events.dropped;
     }
@@ -203876,13 +203915,17 @@ async function runChildOnlyRepair(params) {
   if (apply) {
     remaining = 0;
     for (const mismatch of childMismatches) {
-      const [actualTx, actualEv] = await Promise.all([
-        computeRangeDigest2(db, "transactions", mismatch.from_block, mismatch.to_block),
-        computeRangeDigest2(db, "events", mismatch.from_block, mismatch.to_block)
-      ]);
-      if (actualTx.row_count !== mismatch.transactions.expected || actualEv.row_count !== mismatch.events.expected) {
-        remaining++;
+      let stillDiverges = false;
+      for (const dataset of children) {
+        const count = mismatch[dataset];
+        if (!count)
+          continue;
+        const actual = await computeRangeDigest2(db, dataset, mismatch.from_block, mismatch.to_block);
+        if (actual.row_count !== count.expected)
+          stillDiverges = true;
       }
+      if (stillDiverges)
+        remaining++;
     }
   }
   const complete = apply && remaining === 0;
@@ -203895,7 +203938,7 @@ async function runChildOnlyRepair(params) {
     local_only_heights: [],
     applied: 0,
     rows_written: { blocks: 0, ...applied },
-    datasets_rewritten: apply ? ["transactions", "events"] : [],
+    datasets_rewritten: CHILD_DATASETS.filter((d) => rewritten.has(d)),
     heights_missing_child_partitions: [],
     child_partition_mismatches: childMismatches,
     fixes: [],
@@ -203910,27 +203953,27 @@ async function runChildOnlyRepair(params) {
         if (vmEvents.dropped > 0) {
           warn(`Dropped ${vmEvents.dropped} vm_events row(s) whose transaction is not in the archive; vm_events can't be refetched from the archive.`);
         }
-        const written = `${applied.transactions} transactions, ${applied.events} events`;
+        const written = children.map((d) => `${applied[d] ?? 0} ${d}`).join(", ");
         if (complete) {
           success(`Repaired ${childMismatches.length} range(s) (rewrote ${written}); blocks were already correct.`);
         } else {
           warn(`Rewrote ${written} but ${remaining} range(s) still diverge from the archive.`);
         }
       } else {
-        warn(`${childMismatches.length} range(s) have transactions/events that diverge from the archive, while their blocks match.`);
+        warn(`${childMismatches.length} range(s) have ${children.join("/")} that diverge from the archive, while their blocks match.`);
         console.error("");
         console.error(formatTable([
           "RANGE",
-          "TX EXPECTED",
-          "TX LOCAL",
-          "EVENTS EXPECTED",
-          "EVENTS LOCAL"
+          ...children.flatMap((d) => [
+            `${CHILD_LABEL[d]} EXPECTED`,
+            `${CHILD_LABEL[d]} LOCAL`
+          ])
         ], childMismatches.slice(0, 20).map((m) => [
           `${m.from_block}-${m.to_block}`,
-          String(m.transactions.expected),
-          String(m.transactions.actual),
-          String(m.events.expected),
-          String(m.events.actual)
+          ...children.flatMap((d) => [
+            String(m[d]?.expected ?? "—"),
+            String(m[d]?.actual ?? "—")
+          ])
         ])));
         console.error("");
         console.error(dim("(dry-run — pass --apply to write the repair)"));
@@ -203946,15 +203989,16 @@ Examples:
   $ secondlayer repair --against ./snapshot.json --apply              # write the fix
   $ secondlayer repair --against ./snapshot.json --from-block 8500000 --to-block 8549999
 
-A fixed block is rewritten together with its transactions and events from the
-archive's partitions for that height. When the reference carries no
-transactions or events partition for a height, the block is rewritten alone,
-the run names the height, and it exits 1.
+A fixed block is rewritten together with its transactions and events (and
+state_writes, when the archive publishes them) from the archive's partitions
+for that height. When the reference carries no partition of one of those for
+a height, the block is rewritten alone, the run names the height, and it
+exits 1.
 
-When blocks already match the archive but a transactions or events partition
-does not, that range's transactions and events are replaced outright — there
-is no block or fork boundary to preserve, only stale rows underneath one that
-was never wrong.
+When blocks already match the archive but a child partition does not, that
+range's diverging rows are replaced outright (transactions and events always
+as a pair) — there is no block or fork boundary to preserve, only stale rows
+underneath one that was never wrong.
 
 Exit codes:
   0  nothing to repair, or the repair completed and re-verified clean
@@ -203992,11 +204036,14 @@ Exit codes:
         local.push(await computeRangeDigest2(db, "blocks", range.from_block, range.to_block));
       }
       const divergent = compareRangeDigests(local, referenceDigests).filter((c) => c.status !== "match");
+      const children = publishedChildren(reference.manifest);
+      const reported = reportedDatasets(children);
       if (divergent.length === 0) {
-        const childMismatches = await planChildPartitionDivergence(db, reference.manifest.partitions ?? [], reference.manifest.zero_record_ranges ?? [], inRange);
+        const childMismatches = await planChildPartitionDivergence(db, reference.manifest.partitions ?? [], reference.manifest.zero_record_ranges ?? [], inRange, children);
         await runChildOnlyRepair({
           reference,
           childMismatches,
+          children,
           apply: !!opts.apply,
           json: !!opts.json,
           yes: !!opts.yes
@@ -204004,7 +204051,7 @@ Exit codes:
         return;
       }
       const partitions = (reference.manifest.partitions ?? []).filter((p) => p.dataset === "blocks" && divergent.some((d) => d.from_block === p.from_block && d.to_block === p.to_block));
-      const childPartitions = opts.apply ? (reference.manifest.partitions ?? []).filter((p) => (p.dataset === "transactions" || p.dataset === "events") && divergent.some((d) => p.from_block <= d.to_block && p.to_block >= d.from_block)) : [];
+      const childPartitions = opts.apply ? (reference.manifest.partitions ?? []).filter((p) => children.includes(p.dataset) && divergent.some((d) => p.from_block <= d.to_block && p.to_block >= d.from_block)) : [];
       const fetchPaths = [...partitions, ...childPartitions].map((p) => p.path);
       let gate;
       let quoteLine;
@@ -204047,37 +204094,34 @@ Exit codes:
         allFixes.push(...fixes);
         allExtra.push(...extraHeights);
       }
-      const applied = { blocks: 0, transactions: 0, events: 0 };
-      const missingChild = {
-        transactions: [],
-        events: []
-      };
-      let childrenRewritten = 0;
+      const applied = zeroCounts(reported);
+      const missingChild = new Map(children.map((d) => [d, []]));
+      const rewrittenHeights = new Map;
       if (opts.apply) {
         const rawClient = getRawClient2("source");
         for (const { partition, fixes } of planned) {
           const result = await applyFixes(rawClient, reference, partition, fixes, gate);
-          applied.blocks += result.blocks;
-          applied.transactions += result.transactions;
-          applied.events += result.events;
-          missingChild.transactions.push(...result.missing.transactions);
-          missingChild.events.push(...result.missing.events);
-          childrenRewritten += result.rewritten.length;
+          for (const dataset of reported) {
+            applied[dataset] = (applied[dataset] ?? 0) + result.rows[dataset];
+          }
+          for (const dataset of children) {
+            missingChild.get(dataset)?.push(...result.missing[dataset] ?? []);
+            rewrittenHeights.set(dataset, (rewrittenHeights.get(dataset) ?? 0) + (result.rewritten[dataset]?.length ?? 0));
+          }
         }
       }
       const missingHeights = [
-        ...new Set([...missingChild.transactions, ...missingChild.events])
+        ...new Set([...missingChild.values()].flat())
       ].sort((a, b) => a - b);
-      const rewritten = opts.apply ? REPAIR_DATASETS.filter((d) => d === "blocks" || childrenRewritten > 0) : [];
+      const rewritten = opts.apply ? reported.filter((d) => d === "blocks" || (rewrittenHeights.get(d) ?? 0) > 0) : [];
       let remainingByDataset = {
-        blocks: divergent.length,
-        transactions: 0,
-        events: 0
+        ...zeroCounts(reported),
+        blocks: divergent.length
       };
       if (opts.apply) {
-        remainingByDataset = await reverify(db, reference, referenceDigests);
+        remainingByDataset = await reverify(db, reference, referenceDigests, reported);
       }
-      const remaining = remainingByDataset.blocks + remainingByDataset.transactions + remainingByDataset.events;
+      const remaining = reported.reduce((sum, d) => sum + (remainingByDataset[d] ?? 0), 0);
       const complete = !!opts.apply && remaining === 0 && missingHeights.length === 0;
       const report = {
         status: opts.apply ? complete ? "repaired" : "incomplete" : "plan",
@@ -204086,7 +204130,7 @@ Exit codes:
         blocks_to_replace: allFixes.filter((f) => f.kind === "replace").length,
         blocks_to_insert: allFixes.filter((f) => f.kind === "insert").length,
         local_only_heights: allExtra,
-        applied: applied.blocks,
+        applied: applied.blocks ?? 0,
         rows_written: applied,
         datasets_rewritten: rewritten,
         heights_missing_child_partitions: missingHeights,
@@ -204095,14 +204139,15 @@ Exit codes:
         metered: quoteLine ?? null
       };
       if (missingHeights.length > 0) {
-        for (const dataset of CHILD_DATASETS) {
-          const heights = missingChild[dataset];
+        for (const dataset of children) {
+          const heights = missingChild.get(dataset) ?? [];
           if (heights.length === 0)
             continue;
           warn(`  the reference has no ${dataset} partition for ${heights.length} height(s): ${heights.slice(0, 5).join(", ")}${heights.length > 5 ? ", …" : ""}`);
         }
         for (const height of missingHeights.slice(0, 5)) {
-          console.error(dim(`  the archive has no transactions/events at ${height} either: it cannot be repaired in place; re-ingest ${height} from your own node, or bootstrap a fresh database from the archive`));
+          const lacking = children.filter((d) => missingChild.get(d)?.includes(height)).join("/");
+          console.error(dim(`  the archive has no ${lacking} at ${height} either: it cannot be repaired in place; re-ingest ${height} from your own node, or bootstrap a fresh database from the archive`));
         }
       }
       output({
@@ -204112,14 +204157,14 @@ Exit codes:
           const replace = report.blocks_to_replace;
           const insert = report.blocks_to_insert;
           if (opts.apply) {
-            const written = `${applied.blocks} blocks, ${applied.transactions} transactions, ${applied.events} events`;
+            const written = reported.map((d) => `${applied[d] ?? 0} ${d}`).join(", ");
             if (complete) {
               success(`Repaired ${applied.blocks} heights across ${divergent.length} ranges (rewrote ${written}); re-verified clean on ${rewritten.join(", ")}.`);
             } else if (remaining > 0) {
-              const byDataset = REPAIR_DATASETS.map((d) => `${remainingByDataset[d]} ${d}`).join(", ");
+              const byDataset = reported.map((d) => `${remainingByDataset[d] ?? 0} ${d}`).join(", ");
               warn(`Rewrote ${written} but ${remaining} ranges still diverge (${byDataset}).`);
             } else {
-              warn(`Rewrote ${written}; blocks re-verified clean, but transactions and events at ${missingHeights.length} height(s) were not rewritten.`);
+              warn(`Rewrote ${written}; blocks re-verified clean, but child rows at ${missingHeights.length} height(s) were not rewritten.`);
             }
           } else {
             warn(`${divergent.length} ranges diverge — ${replace} blocks to replace, ${insert} to insert.`);
@@ -204170,6 +204215,7 @@ function registerRepairCommand(program) {
 }
 
 // src/commands/verify.ts
+import { isArchiveDataset as isArchiveDataset2 } from "@secondlayer/shared/archive/datasets";
 import {
   compareRangeDigests as compareRangeDigests2,
   computeRangeDigest as computeRangeDigest3
@@ -204186,6 +204232,7 @@ import {
 import { getDb as getDb3 } from "@secondlayer/shared/db";
 
 // src/lib/archive-heights.ts
+import { assertNeverDataset } from "@secondlayer/shared/archive/datasets";
 import {
   PerHeightDigestAccumulator
 } from "@secondlayer/shared/archive/per-height-digest";
@@ -204197,6 +204244,18 @@ var PART_FOR_DATASET = {
   transactions: "transactions",
   events: "events"
 };
+function sidecarNarrows(dataset) {
+  switch (dataset) {
+    case "blocks":
+    case "transactions":
+    case "events":
+      return true;
+    case "state_writes":
+      return false;
+    default:
+      return assertNeverDataset(dataset);
+  }
+}
 async function localPerHeightDigests(db, fromBlock, toBlock, datasets = ["blocks", "transactions", "events"]) {
   const accumulator = new PerHeightDigestAccumulator;
   for await (const { height, digest } of streamHeightDigests(db, "blocks", fromBlock, toBlock)) {
@@ -204261,15 +204320,21 @@ function compareHeights(params) {
   return out;
 }
 function partsMatch(dataset, a, b) {
-  if (dataset === "blocks")
-    return a.block_digest === b.block_digest;
-  if (dataset === "transactions") {
-    return a.transactions_rollup === b.transactions_rollup;
+  switch (dataset) {
+    case "blocks":
+      return a.block_digest === b.block_digest;
+    case "transactions":
+      return a.transactions_rollup === b.transactions_rollup;
+    case "events":
+      return a.events_rollup === b.events_rollup;
+    default:
+      return assertNeverDataset(dataset);
   }
-  return a.events_rollup === b.events_rollup;
 }
 async function divergentHeightsForRange(params) {
   const { db, reference, dataset, fromBlock, toBlock } = params;
+  if (!sidecarNarrows(dataset))
+    return null;
   const sidecars = sidecarsCovering(params.digestIndex, fromBlock, toBlock);
   if (sidecars.length === 0)
     return null;
@@ -204812,6 +204877,8 @@ Exit codes:
       const countChecks = [];
       if (opts.counts && manifest.partitions) {
         for (const partition of manifest.partitions) {
+          if (!isArchiveDataset2(partition.dataset))
+            continue;
           if (partition.dataset === "blocks")
             continue;
           if (fromBlock !== undefined && partition.to_block < fromBlock)
@@ -204833,6 +204900,8 @@ Exit codes:
       }
       const semanticChecks = [];
       const referenceSemantic = (manifest.partition_semantic_digests ?? []).filter((d) => {
+        if (!isArchiveDataset2(d.dataset))
+          return false;
         if (!datasetMatchesTarget(d.dataset, target))
           return false;
         if (fromBlock !== undefined && d.to_block < fromBlock)
@@ -204879,6 +204948,10 @@ Exit codes:
         heightNotes.push("This snapshot has no per-height digests; exact diverging heights need a newer snapshot.");
       } else {
         for (const range of diverged) {
+          if (!sidecarNarrows(range.dataset)) {
+            heightNotes.push(`${range.dataset} ${range.from_block}-${range.to_block} is checked as a whole range: per-height digests carry no ${range.dataset} part.`);
+            continue;
+          }
           try {
             const heights = await divergentHeightsForRange({
               db,
@@ -208854,5 +208927,5 @@ registerCreditsCommand(program);
 registerArchiveCommand(program);
 program.parse();
 
-//# debugId=32F86A2D9F7E084964756E2164756E21
+//# debugId=68E0C291ECE1B27C64756E2164756E21
 //# sourceMappingURL=cli.js.map