@secondlayer/subgraphs 3.26.1 → 3.26.3

package/dist/src/index.js

@@ -231,6 +231,13 @@ function quotePgIdent(name) {
     return name;
   return `"${name.replace(/"/g, '""')}"`;
 }
+function snakeToCamel(name) {
+  return name.replace(/_([a-z0-9])/g, (_, c) => c.toUpperCase());
+}
+function pascalCase(name) {
+  const camel = snakeToCamel(name);
+  return camel.charAt(0).toUpperCase() + camel.slice(1);
+}
 
 // src/schema/generator.ts
 var TYPE_MAP = {
@@ -3259,9 +3266,278 @@ class StatsAccumulator {
   }
 }
 
+// src/runtime/catchup.ts
+import { getTargetDb as getTargetDb2, sql as sql4 } from "@secondlayer/shared/db";
+import { getSubgraph } from "@secondlayer/shared/db/queries/subgraphs";
+import { logger as logger8 } from "@secondlayer/shared/logger";
+
+// src/runtime/catchup-leader.ts
+import {
+  SUBGRAPH_CATCHUP_LOCK_KEY,
+  createPostgresLeaderBackend,
+  withLeaderLock
+} from "@secondlayer/shared/leader";
+import { targetListenerUrl } from "@secondlayer/shared/queue/listener";
+var catchUpLeader = false;
+function isCatchUpLeader() {
+  return catchUpLeader;
+}
+function startCatchUpLeader(opts = {}) {
+  return withLeaderLock(SUBGRAPH_CATCHUP_LOCK_KEY, async () => {
+    catchUpLeader = true;
+    await opts.onAcquire?.();
+    return () => {
+      catchUpLeader = false;
+    };
+  }, {
+    pollMs: opts.pollMs,
+    heartbeatMs: opts.heartbeatMs,
+    createBackend: opts.createBackend ?? (() => createPostgresLeaderBackend(targetListenerUrl()))
+  });
+}
+
+// src/runtime/catchup.ts
+var LOG_INTERVAL = 1000;
+var STANDARD_CATCHUP_BATCH_CONFIG = {
+  defaultBatchSize: 500,
+  minBatchSize: 100,
+  maxBatchSize: 1000,
+  prefetch: true
+};
+var catchingUp = new Set;
+var subgraphBlockLockHeld = new Set;
+var subgraphBlockLockWaiters = new Map;
+var reorgEpoch = new Map;
+async function acquireSubgraphBlockLock(name) {
+  if (!subgraphBlockLockHeld.has(name)) {
+    subgraphBlockLockHeld.add(name);
+    return () => releaseSubgraphBlockLock(name);
+  }
+  return new Promise((resolve) => {
+    const waiters = subgraphBlockLockWaiters.get(name) ?? [];
+    waiters.push(() => resolve(() => releaseSubgraphBlockLock(name)));
+    subgraphBlockLockWaiters.set(name, waiters);
+  });
+}
+function releaseSubgraphBlockLock(name) {
+  const waiters = subgraphBlockLockWaiters.get(name);
+  if (waiters && waiters.length > 0) {
+    const next = waiters.shift();
+    if (waiters.length === 0)
+      subgraphBlockLockWaiters.delete(name);
+    next();
+    return;
+  }
+  subgraphBlockLockHeld.delete(name);
+}
+async function withSubgraphBlockLock(name, fn) {
+  const release = await acquireSubgraphBlockLock(name);
+  try {
+    return await fn();
+  } finally {
+    release();
+  }
+}
+async function withSubgraphBlockAdvisoryLock(name, fn) {
+  return getTargetDb2().transaction().execute(async (lockTx) => {
+    await sql4`SELECT pg_advisory_xact_lock(hashtext(${`subgraph-block:${name}`}))`.execute(lockTx);
+    return fn();
+  });
+}
+async function withSubgraphBlockWriteLock(name, fn) {
+  return withSubgraphBlockLock(name, () => withSubgraphBlockAdvisoryLock(name, fn));
+}
+function bumpReorgEpoch(name) {
+  reorgEpoch.set(name, (reorgEpoch.get(name) ?? 0) + 1);
+}
+function getReorgEpoch(name) {
+  return reorgEpoch.get(name) ?? 0;
+}
+
+class ReorgEpochChangedError extends Error {
+  constructor(name) {
+    super(`reorg epoch changed for ${name} mid catch-up`);
+    this.name = "ReorgEpochChangedError";
+  }
+}
+function parsePositiveInt(value) {
+  if (value == null || value.trim() === "")
+    return;
+  const parsed = Number.parseInt(value, 10);
+  return Number.isFinite(parsed) && parsed > 0 ? parsed : undefined;
+}
+function parseBoolean(value) {
+  if (value == null || value.trim() === "")
+    return;
+  const normalized = value.trim().toLowerCase();
+  if (normalized === "true")
+    return true;
+  if (normalized === "false")
+    return false;
+  return;
+}
+function resolveCatchupBatchConfig(env = process.env) {
+  const base = STANDARD_CATCHUP_BATCH_CONFIG;
+  const minBatchSize = parsePositiveInt(env.SUBGRAPH_CATCHUP_MIN_BATCH_SIZE) ?? base.minBatchSize;
+  const maxBatchSize = parsePositiveInt(env.SUBGRAPH_CATCHUP_MAX_BATCH_SIZE) ?? base.maxBatchSize;
+  const defaultBatchSize = parsePositiveInt(env.SUBGRAPH_CATCHUP_BATCH_SIZE) ?? base.defaultBatchSize;
+  return {
+    minBatchSize,
+    maxBatchSize,
+    defaultBatchSize: Math.min(Math.max(defaultBatchSize, minBatchSize), maxBatchSize),
+    prefetch: parseBoolean(env.SUBGRAPH_CATCHUP_PREFETCH) ?? base.prefetch
+  };
+}
+function adjustBatchSize(current, avgEvents, config) {
+  if (avgEvents > 50)
+    return Math.max(Math.round(current * 0.5), config.minBatchSize);
+  if (avgEvents < 10)
+    return Math.min(Math.round(current * 1.5), config.maxBatchSize);
+  return current;
+}
+async function catchUpSubgraph(subgraph, subgraphName) {
+  if (catchingUp.has(subgraphName))
+    return 0;
+  catchingUp.add(subgraphName);
+  try {
+    const source = resolveBlockSource(subgraph);
+    const targetDb = getTargetDb2();
+    const subgraphRow = await getSubgraph(targetDb, subgraphName);
+    if (!subgraphRow)
+      return 0;
+    const lastProcessedBlock = Number(subgraphRow.last_processed_block);
+    const chainTip = await source.getTip();
+    if (chainTip <= 0 || lastProcessedBlock >= chainTip)
+      return 0;
+    const subgraphStart = Number(subgraphRow.start_block) || 1;
+    const startBlock = Math.max(lastProcessedBlock + 1, subgraphStart);
+    const totalBlocks = chainTip - lastProcessedBlock;
+    logger8.info("Subgraph catch-up starting", {
+      subgraph: subgraphName,
+      from: startBlock,
+      to: chainTip,
+      blocks: totalBlocks
+    });
+    const stats = new StatsAccumulator(subgraphName, true);
+    let processed = 0;
+    const batchConfig = resolveCatchupBatchConfig();
+    let batchSize = batchConfig.defaultBatchSize;
+    let currentHeight = startBlock;
+    const walkEpoch = getReorgEpoch(subgraphName);
+    let prefetchedBatchEnd = Math.min(currentHeight + batchSize - 1, chainTip);
+    let nextBatchPromise = batchConfig.prefetch ? source.loadBlockRange(currentHeight, prefetchedBatchEnd) : undefined;
+    while (currentHeight <= chainTip) {
+      if (!isCatchUpLeader()) {
+        logger8.info("Lost catch-up leadership, stopping catch-up", {
+          subgraph: subgraphName,
+          processed
+        });
+        break;
+      }
+      const currentRow = await getSubgraph(targetDb, subgraphName);
+      if (!currentRow || currentRow.status !== "active") {
+        logger8.info("Subgraph status changed, stopping catch-up", {
+          subgraph: subgraphName,
+          status: currentRow?.status ?? "deleted"
+        });
+        break;
+      }
+      let batchEnd;
+      let batch;
+      if (nextBatchPromise) {
+        batch = await nextBatchPromise;
+        batchEnd = prefetchedBatchEnd;
+        const nextStart = batchEnd + 1;
+        if (nextStart <= chainTip) {
+          prefetchedBatchEnd = Math.min(nextStart + batchSize - 1, chainTip);
+          nextBatchPromise = source.loadBlockRange(nextStart, prefetchedBatchEnd);
+        } else {
+          nextBatchPromise = undefined;
+        }
+      } else {
+        batchEnd = Math.min(currentHeight + batchSize - 1, chainTip);
+        batch = await source.loadBlockRange(currentHeight, batchEnd);
+      }
+      let stopCatchup = false;
+      for (let height = currentHeight;height <= batchEnd; height++) {
+        let blockData = batch.get(height);
+        if (!blockData) {
+          blockData = (await source.loadBlockRange(height, height)).get(height);
+        }
+        if (!blockData) {
+          logger8.warn("Block missing during catch-up, deferring to next tick", {
+            subgraph: subgraphName,
+            blockHeight: height
+          });
+          stopCatchup = true;
+          break;
+        }
+        const preloaded = blockData;
+        let result;
+        try {
+          result = await withSubgraphBlockWriteLock(subgraphName, async () => {
+            if (getReorgEpoch(subgraphName) !== walkEpoch) {
+              throw new ReorgEpochChangedError(subgraphName);
+            }
+            return processBlockWithRetry(subgraph, subgraphName, height, {
+              preloaded
+            });
+          });
+        } catch (err) {
+          if (err instanceof ReorgEpochChangedError) {
+            logger8.info("Reorg detected mid catch-up, aborting walk without writing further progress", { subgraph: subgraphName, blockHeight: height });
+            stopCatchup = true;
+            break;
+          }
+          const errorMsg = err instanceof Error ? err.message : String(err);
+          logger8.error("Block processing failed persistently during catch-up", {
+            subgraph: subgraphName,
+            blockHeight: height,
+            error: errorMsg
+          });
+          const { updateSubgraphStatus: updateSubgraphStatus2, recordSubgraphProcessed: recordSubgraphProcessed2 } = await import("@secondlayer/shared/db/queries/subgraphs");
+          await recordSubgraphProcessed2(targetDb, subgraphName, 0, 1, `catch-up halted at block ${height}: ${errorMsg}`).catch(() => {});
+          await updateSubgraphStatus2(targetDb, subgraphName, "error").catch(() => {});
+          stopCatchup = true;
+          break;
+        }
+        processed++;
+        if (result.timing) {
+          stats.record(result.timing, result.processed);
+          if (stats.shouldFlush()) {
+            await stats.flush(targetDb);
+          }
+        }
+        if (processed % LOG_INTERVAL === 0) {
+          logger8.info("Subgraph catch-up progress", {
+            subgraph: subgraphName,
+            processed,
+            total: totalBlocks,
+            currentBlock: height,
+            pct: Math.round(processed / totalBlocks * 100)
+          });
+        }
+      }
+      if (stopCatchup)
+        break;
+      const avg = avgEventsPerBlock(batch);
+      batchSize = adjustBatchSize(batchSize, avg, batchConfig);
+      currentHeight = batchEnd + 1;
+    }
+    await stats.flush(targetDb);
+    logger8.info("Subgraph catch-up complete", {
+      subgraph: subgraphName,
+      processed
+    });
+    return processed;
+  } finally {
+    catchingUp.delete(subgraphName);
+  }
+}
+
 // src/runtime/reindex.ts
 import { getErrorMessage as getErrorMessage3 } from "@secondlayer/shared";
-import { getRawClient, getTargetDb as getTargetDb2 } from "@secondlayer/shared/db";
+import { getRawClient, getTargetDb as getTargetDb3 } from "@secondlayer/shared/db";
 import {
   recordGapBatch,
   resolveGaps
@@ -3274,11 +3550,11 @@ import {
   recordSubgraphProcessed as recordSubgraphProcessed2,
   updateSubgraphStatus as updateSubgraphStatus2
 } from "@secondlayer/shared/db/queries/subgraphs";
-import { logger as logger9 } from "@secondlayer/shared/logger";
+import { logger as logger10 } from "@secondlayer/shared/logger";
 
 // src/runtime/reindex-notify.ts
 import { getErrorMessage as getErrorMessage2 } from "@secondlayer/shared";
-import { logger as logger8 } from "@secondlayer/shared/logger";
+import { logger as logger9 } from "@secondlayer/shared/logger";
 async function notifyReindexComplete(db, subgraphName, stats) {
   try {
     const subgraph = await db.selectFrom("subgraphs").select(["account_id"]).where("name", "=", subgraphName).executeTakeFirst();
@@ -3289,7 +3565,7 @@ async function notifyReindexComplete(db, subgraphName, stats) {
       return;
     const resendKey = process.env.RESEND_API_KEY;
     if (!resendKey) {
-      logger8.warn("RESEND_API_KEY unset — skipping reindex-complete email", {
+      logger9.warn("RESEND_API_KEY unset — skipping reindex-complete email", {
         subgraph: subgraphName
       });
       return;
@@ -3311,14 +3587,14 @@ async function notifyReindexComplete(db, subgraphName, stats) {
     });
     if (!res.ok) {
       const text = await res.text().catch(() => "");
-      logger8.warn("reindex-complete email failed", {
+      logger9.warn("reindex-complete email failed", {
         subgraph: subgraphName,
         status: res.status,
         body: text.slice(0, 200)
       });
     }
   } catch (err) {
-    logger8.warn("reindex-complete email threw", {
+    logger9.warn("reindex-complete email threw", {
       subgraph: subgraphName,
       error: getErrorMessage2(err)
     });
@@ -3326,7 +3602,7 @@ async function notifyReindexComplete(db, subgraphName, stats) {
 }
 
 // src/runtime/reindex.ts
-var LOG_INTERVAL = 1000;
+var LOG_INTERVAL2 = 1000;
 var HEALTH_FLUSH_INTERVAL = 1000;
 var PROGRESS_FLUSH_INTERVAL_MS = 5000;
 var EMPTY_BATCH_HALT_THRESHOLD = 3;
@@ -3346,7 +3622,7 @@ function resolveReindexResumeBlock(row) {
   const reindexFromBlock = Number(row.reindex_from_block);
   return Math.max(lastProcessedBlock + 1, reindexFromBlock);
 }
-function parsePositiveInt(value) {
+function parsePositiveInt2(value) {
   if (value == null || value.trim() === "")
     return;
   const parsed = Number.parseInt(value, 10);
@@ -3354,9 +3630,9 @@ function parsePositiveInt(value) {
 }
 function resolveReindexBatchConfig(env = process.env) {
   const base = STANDARD_REINDEX_BATCH_CONFIG;
-  const minBatchSize = parsePositiveInt(env.SUBGRAPH_REINDEX_MIN_BATCH_SIZE) ?? base.minBatchSize;
-  const maxBatchSize = parsePositiveInt(env.SUBGRAPH_REINDEX_MAX_BATCH_SIZE) ?? base.maxBatchSize;
-  const defaultBatchSize = parsePositiveInt(env.SUBGRAPH_REINDEX_BATCH_SIZE) ?? base.defaultBatchSize;
+  const minBatchSize = parsePositiveInt2(env.SUBGRAPH_REINDEX_MIN_BATCH_SIZE) ?? base.minBatchSize;
+  const maxBatchSize = parsePositiveInt2(env.SUBGRAPH_REINDEX_MAX_BATCH_SIZE) ?? base.maxBatchSize;
+  const defaultBatchSize = parsePositiveInt2(env.SUBGRAPH_REINDEX_BATCH_SIZE) ?? base.defaultBatchSize;
   return {
     minBatchSize,
     maxBatchSize,
@@ -3387,7 +3663,7 @@ function coalesceFailedBlocks(blocks) {
 }
 async function processBlockRange(def, opts) {
   const source = resolveBlockSource(def);
-  const targetDb = getTargetDb2();
+  const targetDb = getTargetDb3();
   const subgraphName = def.name;
   const { fromBlock, toBlock, status } = opts;
   const totalBlocks = toBlock - fromBlock + 1;
@@ -3430,7 +3706,7 @@ async function processBlockRange(def, opts) {
   while (currentHeight <= toBlock) {
     if (opts.signal?.aborted) {
       aborted = true;
-      logger9.info("Block processing aborted", {
+      logger10.info("Block processing aborted", {
         subgraph: subgraphName,
         currentBlock: currentHeight,
         reason: String(opts.signal.reason ?? "unknown")
@@ -3472,14 +3748,16 @@ async function processBlockRange(def, opts) {
       }
       let result;
       try {
-        result = await processBlockWithRetry(def, subgraphName, height, {
+        const mayWrite = blockData.txs.length > 0 || blockData.events.length > 0;
+        const runBlock = () => processBlockWithRetry(def, subgraphName, height, {
           skipProgressUpdate: true,
           atomicProgress,
           preloaded: blockData
         });
+        result = mayWrite ? await withSubgraphBlockWriteLock(subgraphName, runBlock) : await runBlock();
       } catch (err) {
         const errorMsg = getErrorMessage3(err);
-        logger9.error("Block processing failed persistently", {
+        logger10.error("Block processing failed persistently", {
           subgraph: subgraphName,
           blockHeight: height,
           error: errorMsg
@@ -3524,8 +3802,8 @@ async function processBlockRange(def, opts) {
         }
         lastProgressFlushAt = now;
       }
-      if (blocksProcessed % LOG_INTERVAL === 0) {
-        logger9.info(`${status === "reindexing" ? "Reindex" : "Backfill"} progress`, {
+      if (blocksProcessed % LOG_INTERVAL2 === 0) {
+        logger10.info(`${status === "reindexing" ? "Reindex" : "Backfill"} progress`, {
           subgraph: subgraphName,
           processed: blocksProcessed,
           total: totalBlocks,
@@ -3545,7 +3823,7 @@ async function processBlockRange(def, opts) {
     if (batchFailedBlocks.length > 0 && opts.subgraphId) {
       const gaps = coalesceFailedBlocks(batchFailedBlocks);
       await recordGapBatch(targetDb, opts.subgraphId, subgraphName, gaps).catch((err) => {
-        logger9.warn("Failed to record subgraph gaps", {
+        logger10.warn("Failed to record subgraph gaps", {
           subgraph: subgraphName,
           error: err instanceof Error ? err.message : String(err)
         });
@@ -3562,7 +3840,7 @@ async function processBlockRange(def, opts) {
         } else {
           await updateSubgraphStatus2(targetDb, subgraphName, status, jumpTo - 1);
         }
-        logger9.info("Sparse skip", {
+        logger10.info("Sparse skip", {
           subgraph: subgraphName,
           from: batchEnd + 1,
           to: jumpTo - 1,
@@ -3597,16 +3875,16 @@ async function clearReindexMetadata(db, subgraphName) {
 }
 async function reindexSubgraph(def, opts) {
   const source = resolveBlockSource(def);
-  const targetDb = getTargetDb2();
+  const targetDb = getTargetDb3();
   const client = getRawClient("target");
   const subgraphName = def.name;
   const schemaName = opts?.schemaName ?? pgSchemaName(subgraphName);
   await updateSubgraphStatus2(targetDb, subgraphName, "reindexing");
-  logger9.info("Reindex starting", { subgraph: subgraphName });
+  logger10.info("Reindex starting", { subgraph: subgraphName });
   try {
     const { fromBlock, toBlock } = await resolveBlockRange(source, def, opts);
     if (fromBlock > toBlock) {
-      logger9.info("No blocks to reindex", {
+      logger10.info("No blocks to reindex", {
         subgraph: subgraphName,
         fromBlock,
         toBlock
@@ -3620,7 +3898,7 @@ async function reindexSubgraph(def, opts) {
       await client.unsafe(stmt);
     }
     await updateSubgraphStatus2(targetDb, subgraphName, "reindexing", Math.max(0, fromBlock - 1));
-    logger9.info("Schema recreated for reindex", {
+    logger10.info("Schema recreated for reindex", {
       subgraph: subgraphName,
       cursorResetTo: Math.max(0, fromBlock - 1)
     });
@@ -3634,7 +3912,7 @@ async function reindexSubgraph(def, opts) {
       last_error_at: null,
       updated_at: new Date
     }).where("name", "=", subgraphName).execute();
-    logger9.info("Reindexing blocks", {
+    logger10.info("Reindexing blocks", {
       subgraph: subgraphName,
       fromBlock,
       toBlock,
@@ -3656,9 +3934,9 @@ async function reindexSubgraph(def, opts) {
       if (reason === "user-cancelled") {
         await updateSubgraphStatus2(targetDb, subgraphName, "active");
         await clearReindexMetadata(targetDb, subgraphName);
-        logger9.info("Reindex cancelled by user", { subgraph: subgraphName });
+        logger10.info("Reindex cancelled by user", { subgraph: subgraphName });
       } else {
-        logger9.info("Reindex interrupted by shutdown, will resume", {
+        logger10.info("Reindex interrupted by shutdown, will resume", {
           subgraph: subgraphName
         });
       }
@@ -3666,7 +3944,7 @@ async function reindexSubgraph(def, opts) {
     }
     await updateSubgraphStatus2(targetDb, subgraphName, "active", toBlock);
     await clearReindexMetadata(targetDb, subgraphName);
-    logger9.info("Reindex complete", {
+    logger10.info("Reindex complete", {
       subgraph: subgraphName,
       blocks: result.blocksProcessed,
       events: result.totalEventsProcessed,
@@ -3679,7 +3957,7 @@ async function reindexSubgraph(def, opts) {
     });
     return { processed: result.blocksProcessed };
   } catch (err) {
-    logger9.error("Reindex failed", {
+    logger10.error("Reindex failed", {
       subgraph: subgraphName,
       error: getErrorMessage3(err)
     });
@@ -3688,7 +3966,7 @@ async function reindexSubgraph(def, opts) {
   }
 }
 async function resumeReindex(def, opts) {
-  const targetDb = getTargetDb2();
+  const targetDb = getTargetDb3();
   const subgraphName = def.name;
   const row = await targetDb.selectFrom("subgraphs").select([
     "id",
@@ -3701,7 +3979,7 @@ async function resumeReindex(def, opts) {
   const fromBlock = resolveReindexResumeBlock(row);
   const toBlock = Number(row.reindex_to_block);
   if (fromBlock == null) {
-    logger9.info("No reindex metadata, starting fresh reindex", {
+    logger10.info("No reindex metadata, starting fresh reindex", {
       subgraph: subgraphName
     });
     return reindexSubgraph(def, {
@@ -3710,12 +3988,12 @@ async function resumeReindex(def, opts) {
     });
   }
   if (fromBlock > toBlock) {
-    logger9.info("Resume: no remaining blocks", { subgraph: subgraphName });
+    logger10.info("Resume: no remaining blocks", { subgraph: subgraphName });
     await updateSubgraphStatus2(targetDb, subgraphName, "active", toBlock);
     await clearReindexMetadata(targetDb, subgraphName);
     return { processed: 0 };
   }
-  logger9.info("Resuming reindex", {
+  logger10.info("Resuming reindex", {
     subgraph: subgraphName,
     fromBlock,
     toBlock,
@@ -3737,9 +4015,9 @@ async function resumeReindex(def, opts) {
       if (reason === "user-cancelled") {
         await updateSubgraphStatus2(targetDb, subgraphName, "active");
         await clearReindexMetadata(targetDb, subgraphName);
-        logger9.info("Resume cancelled by user", { subgraph: subgraphName });
+        logger10.info("Resume cancelled by user", { subgraph: subgraphName });
       } else {
-        logger9.info("Resume interrupted by shutdown, will resume again", {
+        logger10.info("Resume interrupted by shutdown, will resume again", {
           subgraph: subgraphName
         });
       }
@@ -3747,13 +4025,13 @@ async function resumeReindex(def, opts) {
     }
     await updateSubgraphStatus2(targetDb, subgraphName, "active", toBlock);
     await clearReindexMetadata(targetDb, subgraphName);
-    logger9.info("Resumed reindex complete", {
+    logger10.info("Resumed reindex complete", {
       subgraph: subgraphName,
       blocks: result.blocksProcessed
     });
     return { processed: result.blocksProcessed };
   } catch (err) {
-    logger9.error("Resumed reindex failed", {
+    logger10.error("Resumed reindex failed", {
       subgraph: subgraphName,
       error: getErrorMessage3(err)
     });
@@ -3762,9 +4040,9 @@ async function resumeReindex(def, opts) {
   }
 }
 async function backfillSubgraph(def, opts) {
-  const targetDb = getTargetDb2();
+  const targetDb = getTargetDb3();
   const subgraphName = def.name;
-  logger9.info("Backfill starting", {
+  logger10.info("Backfill starting", {
     subgraph: subgraphName,
     from: opts.fromBlock,
     to: opts.toBlock
@@ -3782,17 +4060,17 @@ async function backfillSubgraph(def, opts) {
       signal: opts.signal
     });
     if (result.aborted) {
-      logger9.info("Backfill aborted", { subgraph: subgraphName });
+      logger10.info("Backfill aborted", { subgraph: subgraphName });
       return { processed: result.blocksProcessed };
     }
     const resolved = await resolveGaps(targetDb, subgraphName, opts.fromBlock, opts.toBlock).catch(() => 0);
     if (resolved > 0) {
-      logger9.info("Resolved subgraph gaps via backfill", {
+      logger10.info("Resolved subgraph gaps via backfill", {
         subgraph: subgraphName,
         resolved
       });
     }
-    logger9.info("Backfill complete", {
+    logger10.info("Backfill complete", {
       subgraph: subgraphName,
       blocks: result.blocksProcessed,
       events: result.totalEventsProcessed,
@@ -3800,7 +4078,7 @@ async function backfillSubgraph(def, opts) {
     });
     return { processed: result.blocksProcessed };
   } catch (err) {
-    logger9.error("Backfill failed", {
+    logger10.error("Backfill failed", {
       subgraph: subgraphName,
       error: getErrorMessage3(err)
     });
@@ -4165,13 +4443,6 @@ var SYSTEM_FIELDS = [
     line: "DateTime @default(now()) @db.Timestamptz"
   }
 ];
-function snakeToCamel(name) {
-  return name.replace(/_([a-z0-9])/g, (_, c) => c.toUpperCase());
-}
-function pascalCase(name) {
-  const camel = snakeToCamel(name);
-  return camel.charAt(0).toUpperCase() + camel.slice(1);
-}
 function quotePrismaDefault(value) {
   if (typeof value === "string")
     return `@default("${value.replace(/"/g, "\\\"")}")`;
@@ -4296,13 +4567,6 @@ var BUILDERS_USED = {
   timestamp: "timestamp",
   jsonb: "jsonb"
 };
-function snakeToCamel2(name) {
-  return name.replace(/_([a-z0-9])/g, (_, c) => c.toUpperCase());
-}
-function pascalCase2(name) {
-  const camel = snakeToCamel2(name);
-  return camel.charAt(0).toUpperCase() + camel.slice(1);
-}
 function literalDefault(value) {
   return typeof value === "string" ? `"${value.replace(/"/g, "\\\"")}"` : `${value}`;
 }
@@ -4314,7 +4578,7 @@ function renderTable2(varName, tableName, table) {
     `  createdAt: timestamp("_created_at", { withTimezone: true }).notNull().defaultNow(),`
   ];
   for (const [colName, col] of Object.entries(table.columns)) {
-    let line = `  ${snakeToCamel2(colName)}: ${DRIZZLE_BUILDER[col.type](colName)}`;
+    let line = `  ${snakeToCamel(colName)}: ${DRIZZLE_BUILDER[col.type](colName)}`;
     if (!col.nullable)
       line += ".notNull()";
     if (col.default !== undefined)
@@ -4324,16 +4588,16 @@ function renderTable2(varName, tableName, table) {
   const extras = [];
   for (const [colName, col] of Object.entries(table.columns)) {
     if (col.indexed) {
-      const f = snakeToCamel2(colName);
+      const f = snakeToCamel(colName);
       extras.push(`    ${f}Idx: index("idx_${tableName}_${colName}").on(t.${f})`);
     }
   }
   table.indexes?.forEach((idxCols, i) => {
-    const on = idxCols.map((c) => `t.${snakeToCamel2(c)}`).join(", ");
+    const on = idxCols.map((c) => `t.${snakeToCamel(c)}`).join(", ");
     extras.push(`    idx${i}: index("idx_${tableName}_${i}").on(${on})`);
   });
   table.uniqueKeys?.forEach((uqCols, i) => {
-    const on = uqCols.map((c) => `t.${snakeToCamel2(c)}`).join(", ");
+    const on = uqCols.map((c) => `t.${snakeToCamel(c)}`).join(", ");
     extras.push(`    uq${i}: uniqueIndex("uq_${tableName}_${i}").on(${on})`);
   });
   const extrasBlock = extras.length ? `, (t) => ({
@@ -4351,19 +4615,19 @@ function renderRelations(schema) {
     for (const rel of table.relations ?? []) {
       const list = back.get(rel.references) ?? [];
       list.push({
-        field: `${snakeToCamel2(owning)}${pascalCase2(rel.name)}`,
-        from: snakeToCamel2(owning)
+        field: `${snakeToCamel(owning)}${pascalCase(rel.name)}`,
+        from: snakeToCamel(owning)
       });
       back.set(rel.references, list);
     }
   }
   const out = [];
   for (const [tableName, table] of Object.entries(schema)) {
-    const v = snakeToCamel2(tableName);
+    const v = snakeToCamel(tableName);
     const ones = (table.relations ?? []).map((rel) => {
-      const localFields = rel.fields.map((f) => `${v}.${snakeToCamel2(f)}`).join(", ");
-      const refFields = rel.referencedColumns.map((c) => `${snakeToCamel2(rel.references)}.${snakeToCamel2(c)}`).join(", ");
-      return `  ${rel.name}: one(${snakeToCamel2(rel.references)}, { fields: [${localFields}], references: [${refFields}] }),`;
+      const localFields = rel.fields.map((f) => `${v}.${snakeToCamel(f)}`).join(", ");
+      const refFields = rel.referencedColumns.map((c) => `${snakeToCamel(rel.references)}.${snakeToCamel(c)}`).join(", ");
+      return `  ${rel.name}: one(${snakeToCamel(rel.references)}, { fields: [${localFields}], references: [${refFields}] }),`;
     });
     const manys = (back.get(tableName) ?? []).map((b) => `  ${b.field}: many(${b.from}),`);
     if (ones.length === 0 && manys.length === 0)
@@ -4400,9 +4664,9 @@ function generateDrizzleSchema(def, opts = {}) {
     ...hasRelations ? [`import { relations } from "drizzle-orm";`] : []
   ].join(`
 `);
-  const tables = Object.entries(def.schema).map(([name, table]) => renderTable2(snakeToCamel2(name), name, table));
+  const tables = Object.entries(def.schema).map(([name, table]) => renderTable2(snakeToCamel(name), name, table));
   const relationDecls = renderRelations(def.schema);
-  const typeExports = Object.keys(def.schema).map((name) => `export type ${pascalCase2(name)} = typeof ${snakeToCamel2(name)}.$inferSelect;`);
+  const typeExports = Object.keys(def.schema).map((name) => `export type ${pascalCase(name)} = typeof ${snakeToCamel(name)}.$inferSelect;`);
   return [
     `// Generated by \`sl subgraphs codegen --target drizzle\` from subgraph "${def.name}". Do not edit by hand.`,
     imports,
@@ -4438,9 +4702,6 @@ var SYSTEM_FIELDS2 = [
   { col: "_tx_id", type: "string" },
   { col: "_created_at", type: "Generated<Date>" }
 ];
-function pascalCase3(name) {
-  return name.replace(/_([a-z0-9])/g, (_, c) => c.toUpperCase()).replace(/^[a-z]/, (c) => c.toUpperCase());
-}
 function renderTable3(tableName, table) {
   const lines = SYSTEM_FIELDS2.map((f) => `  ${f.col}: ${f.type};`);
   for (const [colName, col] of Object.entries(table.columns)) {
@@ -4451,7 +4712,7 @@ function renderTable3(tableName, table) {
       type = `Generated<${type}>`;
     lines.push(`  ${colName}: ${type};`);
   }
-  return `export interface ${pascalCase3(tableName)} {
+  return `export interface ${pascalCase(tableName)} {
 ${lines.join(`
 `)}
 }`;
@@ -4459,12 +4720,12 @@ ${lines.join(`
 function generateKyselySchema(def, opts = {}) {
   const schemaName = opts.schemaName ?? pgSchemaName(def.name);
   const interfaces = Object.entries(def.schema).map(([name, table]) => renderTable3(name, table));
-  const dbEntries = Object.keys(def.schema).map((name) => `  "${schemaName}.${name}": ${pascalCase3(name)};`);
+  const dbEntries = Object.keys(def.schema).map((name) => `  "${schemaName}.${name}": ${pascalCase(name)};`);
   const dbRegistry = `export interface DB {
 ${dbEntries.join(`
 `)}
 }`;
-  const rowExports = Object.keys(def.schema).map((name) => `export type ${pascalCase3(name)}Row = Selectable<${pascalCase3(name)}>;`);
+  const rowExports = Object.keys(def.schema).map((name) => `export type ${pascalCase(name)}Row = Selectable<${pascalCase(name)}>;`);
   return [
     `// Generated by \`sl subgraphs codegen --target kysely\` from subgraph "${def.name}". Do not edit by hand.`,
     `import type { Generated, Selectable } from "kysely";`,
@@ -4486,12 +4747,6 @@ import {
   SOURCE_READ_PKS,
   SOURCE_READ_TYPES
 } from "@secondlayer/shared/db";
-function pascalCase4(name) {
-  return name.replace(/_([a-z0-9])/g, (_, c) => c.toUpperCase()).replace(/^[a-z]/, (c) => c.toUpperCase());
-}
-function snakeToCamel3(name) {
-  return name.replace(/_([a-z0-9])/g, (_, c) => c.toUpperCase());
-}
 function selectTables(opts) {
   const all = SOURCE_READ_TYPES;
   const names = opts.tables ?? Object.keys(all);
@@ -4516,16 +4771,16 @@ function generateKysely(entries, schemaName) {
       const type = def.nullable ? `${KYSELY_TYPE2[def.type]} | null` : KYSELY_TYPE2[def.type];
       return `  ${col}: ${type};`;
     });
-    return `export interface ${pascalCase4(table)} {
+    return `export interface ${pascalCase(table)} {
 ${lines.join(`
 `)}
 }`;
   });
   const dbEntries = entries.map(([table]) => {
     const key2 = schemaName ? `${schemaName}.${table}` : table;
-    return `  "${key2}": ${pascalCase4(table)};`;
+    return `  "${key2}": ${pascalCase(table)};`;
   });
-  const rows = entries.map(([table]) => `export type ${pascalCase4(table)}Row = Selectable<${pascalCase4(table)}>;`);
+  const rows = entries.map(([table]) => `export type ${pascalCase(table)}Row = Selectable<${pascalCase(table)}>;`);
   return [
     "// Generated by `sl index codegen --target kysely`. Do not edit by hand.",
     `import type { Selectable } from "kysely";`,
@@ -4571,17 +4826,17 @@ function generateDrizzle(entries, schemaName) {
   const tableFn = schemaName ? "sg.table" : "pgTable";
   const tables = entries.map(([table, cols]) => {
     const lines = Object.entries(cols).map(([col, def]) => {
-      let line = `  ${snakeToCamel3(col)}: ${DRIZZLE_BUILDER2[def.type](col)}`;
+      let line = `  ${snakeToCamel(col)}: ${DRIZZLE_BUILDER2[def.type](col)}`;
       if (!def.nullable)
         line += ".notNull()";
       return `${line},`;
     });
-    return `export const ${snakeToCamel3(table)} = ${tableFn}("${table}", {
+    return `export const ${snakeToCamel(table)} = ${tableFn}("${table}", {
 ${lines.join(`
 `)}
 });`;
   });
-  const rows = entries.map(([table]) => `export type ${pascalCase4(table)} = typeof ${snakeToCamel3(table)}.$inferSelect;`);
+  const rows = entries.map(([table]) => `export type ${pascalCase(table)} = typeof ${snakeToCamel(table)}.$inferSelect;`);
   return [
     "// Generated by `sl index codegen --target drizzle`. Do not edit by hand.",
     `import { ${[...used].sort().join(", ")} } from "drizzle-orm/pg-core";`,
@@ -4619,7 +4874,7 @@ function generateJsonSchema(entries) {
           required.push(col);
       }
     }
-    defs[pascalCase4(table)] = {
+    defs[pascalCase(table)] = {
       type: "object",
       properties,
       required,
@@ -4652,7 +4907,7 @@ function generatePrisma(entries, schemaName, datasourceEnv) {
     }
     const single = pk.length === 1 ? pk[0] : null;
     const lines = Object.entries(cols).map(([col, def]) => {
-      const field = snakeToCamel3(col);
+      const field = snakeToCamel(col);
       const mapped = PRISMA_TYPE2[def.type];
       const attrs = [];
       if (single === col)
@@ -4666,12 +4921,12 @@ function generatePrisma(entries, schemaName, datasourceEnv) {
     });
     const block = [];
     if (!single) {
-      block.push(`  @@id([${pk.map(snakeToCamel3).join(", ")}])`);
+      block.push(`  @@id([${pk.map(snakeToCamel).join(", ")}])`);
     }
     block.push(`  @@map("${table}")`);
     if (schemaName)
       block.push(`  @@schema("${schemaName}")`);
-    models.push(`model ${pascalCase4(table)} {
+    models.push(`model ${pascalCase(table)} {
 ${lines.join(`
 `)}
 
@@ -4721,7 +4976,7 @@ function generateIndexSchema(target, opts = {}) {
 }
 var INDEX_CODEGEN_TABLES = Object.keys(SOURCE_READ_TYPES);
 // src/schema/deployer.ts
-import { sql as sql4 } from "kysely";
+import { sql as sql5 } from "kysely";
 function toJsonSafe(obj) {
   return JSON.parse(JSON.stringify(obj, (_key, value) => typeof value === "bigint" ? value.toString() : value));
 }
@@ -4836,7 +5091,7 @@ function renderDeployPlan(def, schemaName) {
 async function deploySchema(db, def, handlerPath, opts) {
   validateSubgraphDefinition(def);
   const { statements, hash } = generateSubgraphSQL(def, opts?.schemaName);
-  const { getSubgraph, registerSubgraph } = await import("@secondlayer/shared/db/queries/subgraphs");
+  const { getSubgraph: getSubgraph2, registerSubgraph } = await import("@secondlayer/shared/db/queries/subgraphs");
   const ddlDb = opts?.dataDb ?? db;
   const byo = opts?.dataDb != null;
   const refuseDestructiveOnByo = (reasons, diff) => {
@@ -4848,7 +5103,7 @@ async function deploySchema(db, def, handlerPath, opts) {
       grantScript: plan.grantScript
     });
   };
-  const existing = await getSubgraph(db, def.name, opts?.accountId);
+  const existing = await getSubgraph2(db, def.name, opts?.accountId);
   const schemaName = opts?.schemaName ?? pgSchemaName(def.name);
   const newVersion = opts?.version ?? (existing ? bumpPatch(existing.version) : "1.0.0");
   const regData = {
@@ -4873,7 +5128,7 @@ async function deploySchema(db, def, handlerPath, opts) {
     databaseUrlEnc: opts?.databaseUrlEnc ?? null
   };
   if (existing) {
-    const schemaExists = await sql4`
+    const schemaExists = await sql5`
 			SELECT EXISTS (
 				SELECT 1 FROM information_schema.schemata
 				WHERE schema_name = ${schemaName}
@@ -4881,7 +5136,7 @@ async function deploySchema(db, def, handlerPath, opts) {
 		`.execute(ddlDb).then((r) => r.rows[0]?.exists ?? false);
     if (!schemaExists) {
       for (const stmt of statements) {
-        await sql4.raw(stmt).execute(ddlDb);
+        await sql5.raw(stmt).execute(ddlDb);
       }
       const sg2 = await registerSubgraph(db, regData);
       return { action: "reindexed", subgraphId: sg2.id, version: newVersion };
@@ -4907,9 +5162,9 @@ async function deploySchema(db, def, handlerPath, opts) {
     if (existing.schema_hash === hash && opts?.forceReindex) {
       if (byo)
         refuseDestructiveOnByo(["force reindex"], null);
-      await sql4.raw(`DROP SCHEMA IF EXISTS "${schemaName}" CASCADE`).execute(ddlDb);
+      await sql5.raw(`DROP SCHEMA IF EXISTS "${schemaName}" CASCADE`).execute(ddlDb);
       for (const stmt of statements) {
-        await sql4.raw(stmt).execute(ddlDb);
+        await sql5.raw(stmt).execute(ddlDb);
       }
       const sg2 = await registerSubgraph(db, regData);
       return { action: "reindexed", subgraphId: sg2.id, version: newVersion };
@@ -4921,9 +5176,9 @@ async function deploySchema(db, def, handlerPath, opts) {
         if (byo) {
           refuseDestructiveOnByo(reasons.length > 0 ? reasons : ["force reindex"], diff);
         }
-        await sql4.raw(`DROP SCHEMA IF EXISTS "${schemaName}" CASCADE`).execute(ddlDb);
+        await sql5.raw(`DROP SCHEMA IF EXISTS "${schemaName}" CASCADE`).execute(ddlDb);
         for (const stmt of statements) {
-          await sql4.raw(stmt).execute(ddlDb);
+          await sql5.raw(stmt).execute(ddlDb);
         }
         const sg3 = await registerSubgraph(db, regData);
         const deployDiff2 = toDeployDiff(diff, reasons);
@@ -4936,16 +5191,16 @@ async function deploySchema(db, def, handlerPath, opts) {
       }
       const addedDefs = diff.addedTables.map((tableName) => ({ tableName, tableDef: def.schema[tableName] })).filter((t) => t.tableDef !== undefined);
       if (addedDefs.some(({ tableDef }) => tableNeedsTrgm(tableDef))) {
-        await sql4.raw("CREATE EXTENSION IF NOT EXISTS pg_trgm").execute(ddlDb);
+        await sql5.raw("CREATE EXTENSION IF NOT EXISTS pg_trgm").execute(ddlDb);
       }
       for (const { tableName, tableDef } of addedDefs) {
         for (const stmt of emitTableDDL(schemaName, tableName, tableDef)) {
-          await sql4.raw(stmt).execute(ddlDb);
+          await sql5.raw(stmt).execute(ddlDb);
         }
       }
       for (const { tableName, tableDef } of addedDefs) {
         for (const stmt of emitForeignKeyDDL(schemaName, tableName, tableDef)) {
-          await sql4.raw(stmt).execute(ddlDb);
+          await sql5.raw(stmt).execute(ddlDb);
         }
       }
       for (const [tableName, colDiff] of Object.entries(diff.tables)) {
@@ -4963,12 +5218,12 @@ async function deploySchema(db, def, handlerPath, opts) {
           if (!sqlType)
             continue;
           const nullable = col.nullable ? "" : ` NOT NULL DEFAULT ${getDefault(col.type)}`;
-          await sql4.raw(`ALTER TABLE ${qualifiedName} ADD COLUMN ${colName} ${sqlType}${nullable}`).execute(ddlDb);
+          await sql5.raw(`ALTER TABLE ${qualifiedName} ADD COLUMN ${colName} ${sqlType}${nullable}`).execute(ddlDb);
           if (col.indexed) {
-            await sql4.raw(`CREATE INDEX IF NOT EXISTS idx_${schemaName}_${tableName}_${colName} ON ${qualifiedName} (${colName})`).execute(ddlDb);
+            await sql5.raw(`CREATE INDEX IF NOT EXISTS idx_${schemaName}_${tableName}_${colName} ON ${qualifiedName} (${colName})`).execute(ddlDb);
           }
           if (col.search) {
-            await sql4.raw(`CREATE INDEX IF NOT EXISTS idx_${schemaName}_${tableName}_${colName}_trgm ON ${qualifiedName} USING gin (${colName} gin_trgm_ops)`).execute(ddlDb);
+            await sql5.raw(`CREATE INDEX IF NOT EXISTS idx_${schemaName}_${tableName}_${colName}_trgm ON ${qualifiedName} USING gin (${colName} gin_trgm_ops)`).execute(ddlDb);
           }
         }
       }
@@ -4976,7 +5231,7 @@ async function deploySchema(db, def, handlerPath, opts) {
       const flagFlips = {};
       const needsTrgmForFlips = Object.entries(diff.tables).some(([tableName, colDiff]) => colDiff.indexChanged.some((colName) => def.schema[tableName]?.columns[colName]?.search && !existingSchema[tableName]?.columns[colName]?.search));
       if (needsTrgmForFlips) {
-        await sql4.raw("CREATE EXTENSION IF NOT EXISTS pg_trgm").execute(ddlDb);
+        await sql5.raw("CREATE EXTENSION IF NOT EXISTS pg_trgm").execute(ddlDb);
       }
       for (const [tableName, colDiff] of Object.entries(diff.tables)) {
         if (colDiff.indexChanged.length === 0)
@@ -4991,14 +5246,14 @@ async function deploySchema(db, def, handlerPath, opts) {
           const plainIdx = `idx_${schemaName}_${tableName}_${colName}`;
           const trgmIdx = `idx_${schemaName}_${tableName}_${colName}_trgm`;
           if (now.indexed && !was?.indexed) {
-            await sql4.raw(`CREATE INDEX CONCURRENTLY IF NOT EXISTS ${plainIdx} ON ${qualifiedName} (${colName})`).execute(ddlDb);
+            await sql5.raw(`CREATE INDEX CONCURRENTLY IF NOT EXISTS ${plainIdx} ON ${qualifiedName} (${colName})`).execute(ddlDb);
           } else if (!now.indexed && was?.indexed) {
-            await sql4.raw(`DROP INDEX CONCURRENTLY IF EXISTS ${schemaName}.${plainIdx}`).execute(ddlDb);
+            await sql5.raw(`DROP INDEX CONCURRENTLY IF EXISTS ${schemaName}.${plainIdx}`).execute(ddlDb);
           }
           if (now.search && !was?.search) {
-            await sql4.raw(`CREATE INDEX CONCURRENTLY IF NOT EXISTS ${trgmIdx} ON ${qualifiedName} USING gin (${colName} gin_trgm_ops)`).execute(ddlDb);
+            await sql5.raw(`CREATE INDEX CONCURRENTLY IF NOT EXISTS ${trgmIdx} ON ${qualifiedName} USING gin (${colName} gin_trgm_ops)`).execute(ddlDb);
           } else if (!now.search && was?.search) {
-            await sql4.raw(`DROP INDEX CONCURRENTLY IF EXISTS ${schemaName}.${trgmIdx}`).execute(ddlDb);
+            await sql5.raw(`DROP INDEX CONCURRENTLY IF EXISTS ${schemaName}.${trgmIdx}`).execute(ddlDb);
           }
         }
       }
@@ -5007,28 +5262,28 @@ async function deploySchema(db, def, handlerPath, opts) {
         const qualifiedName = `${schemaName}.${tableName}`;
         for (const cols of conDiff.addedUniqueKeys) {
           const constraintName = `uq_${schemaName}_${tableName}_${cols.join("_")}`;
-          const exists = await sql4`
+          const exists = await sql5`
 						SELECT EXISTS (
 							SELECT 1 FROM pg_constraint
 							WHERE conname = ${constraintName}
 						) AS "exists"
 					`.execute(ddlDb).then((r) => r.rows[0]?.exists ?? false);
           if (!exists) {
-            await sql4.raw(`ALTER TABLE ${qualifiedName} ADD CONSTRAINT ${constraintName} UNIQUE (${cols.join(", ")})`).execute(ddlDb);
+            await sql5.raw(`ALTER TABLE ${qualifiedName} ADD CONSTRAINT ${constraintName} UNIQUE (${cols.join(", ")})`).execute(ddlDb);
           }
           addedUq[tableName] = [...addedUq[tableName] ?? [], cols];
         }
         for (const cols of conDiff.addedIndexes) {
           const i = (def.schema[tableName]?.indexes ?? []).findIndex((entry) => JSON.stringify(entry) === JSON.stringify(cols));
           const idxName = `idx_${schemaName}_${tableName}_composite_${i}`;
-          await sql4.raw(`CREATE INDEX CONCURRENTLY IF NOT EXISTS ${idxName} ON ${qualifiedName} (${cols.join(", ")})`).execute(ddlDb);
+          await sql5.raw(`CREATE INDEX CONCURRENTLY IF NOT EXISTS ${idxName} ON ${qualifiedName} (${cols.join(", ")})`).execute(ddlDb);
         }
         for (const cols of conDiff.removedIndexes) {
           const i = (existingSchema[tableName]?.indexes ?? []).findIndex((entry) => JSON.stringify(entry) === JSON.stringify(cols));
           if (i < 0)
             continue;
           const idxName = `idx_${schemaName}_${tableName}_composite_${i}`;
-          await sql4.raw(`DROP INDEX CONCURRENTLY IF EXISTS ${schemaName}.${idxName}`).execute(ddlDb);
+          await sql5.raw(`DROP INDEX CONCURRENTLY IF EXISTS ${schemaName}.${idxName}`).execute(ddlDb);
         }
       }
       const sg2 = await registerSubgraph(db, regData);
@@ -5054,7 +5309,7 @@ async function deploySchema(db, def, handlerPath, opts) {
     }
   }
   for (const stmt of statements) {
-    await sql4.raw(stmt).execute(ddlDb);
+    await sql5.raw(stmt).execute(ddlDb);
   }
   const sg = await registerSubgraph(db, regData);
   return { action: "created", subgraphId: sg.id, version: newVersion };
@@ -5106,5 +5361,5 @@ export {
   ByoBreakingChangeError
 };
 
-//# debugId=7F2918CDE1AF5BC064756E2164756E21
+//# debugId=720FEFA20DA031E864756E2164756E21
 //# sourceMappingURL=index.js.map