@secondlayer/subgraphs 4.1.5 → 4.2.1

package/dist/src/index.js

@@ -98,6 +98,15 @@ var amountRange = {
   minAmount: z.bigint().optional(),
   maxAmount: z.bigint().optional()
 };
+var MaterializeColumnSchema = z.union([
+  z.object({ from: z.string().min(1) }).strict(),
+  z.object({ fromTx: z.enum(["sender", "txId"]) }).strict(),
+  z.object({ fromBlock: z.enum(["height", "hash", "timestamp"]) }).strict()
+]);
+var MaterializeSpecSchema = z.object({
+  table: z.string().min(1),
+  columns: z.record(z.string(), MaterializeColumnSchema)
+}).strict();
 var SubgraphFilterUnion = z.discriminatedUnion("type", [
   z.object({
     type: z.literal("stx_transfer"),
@@ -180,11 +189,114 @@ var SubgraphFilterUnion = z.discriminatedUnion("type", [
     contractId: contractIdField.optional(),
     topic: z.string().optional(),
     prints: z.record(z.string(), z.record(z.string(), PrintFieldSchema)).optional(),
+    materialize: MaterializeSpecSchema.optional(),
     ...traitScope,
     ...factoryScope
   }).strict()
 ]);
 var SubgraphFilterSchema = SubgraphFilterUnion;
+function hasPinnedContractId(contractId) {
+  if (typeof contractId === "string")
+    return contractId.length > 0;
+  if (Array.isArray(contractId))
+    return contractId.length > 0;
+  return false;
+}
+function printMaterializeFromKeys(prints) {
+  const keys = new Set(["topic"]);
+  if (prints) {
+    for (const fields of Object.values(prints)) {
+      for (const k of Object.keys(fields))
+        keys.add(k);
+    }
+  }
+  return [...keys].sort();
+}
+function refineMaterialize(name, filter, schema, ctx) {
+  if (!("materialize" in filter) || filter.materialize === undefined)
+    return;
+  const spec = filter.materialize;
+  const table = schema[spec.table];
+  if (!table) {
+    ctx.addIssue({
+      code: "custom",
+      path: ["sources", name, "materialize", "table"],
+      message: `materialize table "${spec.table}" is not in schema`
+    });
+    return;
+  }
+  for (const col of Object.keys(spec.columns)) {
+    if (!(col in table.columns)) {
+      ctx.addIssue({
+        code: "custom",
+        path: ["sources", name, "materialize", "columns", col],
+        message: `materialize column "${col}" is not on schema table "${spec.table}"`
+      });
+    }
+  }
+  if (filter.type === "print_event") {
+    const known = printMaterializeFromKeys(filter.prints);
+    const knownSet = new Set(known);
+    for (const [col, mapping] of Object.entries(spec.columns)) {
+      if (!("from" in mapping))
+        continue;
+      if (!knownSet.has(mapping.from)) {
+        ctx.addIssue({
+          code: "custom",
+          path: ["sources", name, "materialize", "columns", col, "from"],
+          message: `materialize from "${mapping.from}" is not a known print field — known: ${known.join(", ")}`
+        });
+      }
+    }
+  }
+}
+function refineDeployGates(def, ctx) {
+  for (const [name, filter] of Object.entries(def.sources)) {
+    if (filter.type === "print_event") {
+      const pinned = hasPinnedContractId(filter.contractId) && !filter.trait;
+      if (pinned) {
+        const prints = filter.prints;
+        if (prints === undefined || typeof prints !== "object" || Object.keys(prints).length === 0) {
+          ctx.addIssue({
+            code: "custom",
+            path: ["sources", name, "prints"],
+            message: `print_event source "${name}" has no prints map — field names would be untyped and empty tables would typecheck. Declare prints from index_print_schema / create --from-contract.`
+          });
+        }
+      }
+    }
+    if (filter.type === "contract_call" && filter.functionName !== undefined) {
+      if (filter.abi === undefined) {
+        ctx.addIssue({
+          code: "custom",
+          path: ["sources", name, "abi"],
+          message: `contract_call source "${name}" has functionName but no abi — pass a canonical ABI (normalizeAbi() from @secondlayer/stacks/clarity).`
+        });
+      }
+    }
+    refineMaterialize(name, filter, def.schema, ctx);
+  }
+  const hasCatchAll = def.handlers["*"] != null;
+  for (const [name, filter] of Object.entries(def.sources)) {
+    const hasMaterialize = "materialize" in filter && filter.materialize !== undefined;
+    const hasHandler = def.handlers[name] != null;
+    if (hasMaterialize && hasHandler) {
+      ctx.addIssue({
+        code: "custom",
+        path: ["handlers", name],
+        message: `source "${name}" has both materialize and a handler — use one or the other`
+      });
+      continue;
+    }
+    if (!hasHandler && !hasMaterialize && !hasCatchAll) {
+      ctx.addIssue({
+        code: "custom",
+        path: ["handlers", name],
+        message: `source "${name}" has no handler (and no "*") — events will be skipped and the table stay empty.`
+      });
+    }
+  }
+}
 var SubgraphDefinitionSchema = z.object({
   name: SubgraphNameSchema,
   version: z.string().optional(),
@@ -194,6 +306,8 @@ var SubgraphDefinitionSchema = z.object({
   sources: z.record(z.string(), SubgraphFilterSchema).refine((s) => Object.keys(s).length > 0, "Must have at least one source"),
   schema: SubgraphSchemaSchema,
   handlers: z.record(z.string(), z.any())
+}).superRefine((def, ctx) => {
+  refineDeployGates(def, ctx);
 });
 function validateSubgraphDefinition(def) {
   return SubgraphDefinitionSchema.parse(def);
@@ -1427,7 +1541,7 @@ function matchSources(sources, transactions, events, traitContracts = new Map, f
 
 // src/runtime/runner.ts
 import { getErrorMessage } from "@secondlayer/shared";
-import { logger as logger3 } from "@secondlayer/shared/logger";
+import { logger as logger4 } from "@secondlayer/shared/logger";
 import {
   clarityValueToJS,
   deserializeCV as deserializeCV4,
@@ -1441,6 +1555,19 @@ import {
 function camelizeDataKey(str) {
   return str.replace(/-([a-z0-9])/g, (_, c) => c.toUpperCase());
 }
+function camelizeKeys(obj) {
+  if (obj === null || obj === undefined)
+    return obj;
+  if (typeof obj !== "object")
+    return obj;
+  if (Array.isArray(obj))
+    return obj.map(camelizeKeys);
+  const result = {};
+  for (const [k, v] of Object.entries(obj)) {
+    result[camelizeDataKey(k)] = camelizeKeys(v);
+  }
+  return result;
+}
 function cvToTree(cv) {
   switch (cv.type) {
     case "uint":
@@ -1765,6 +1892,58 @@ function inferPrintTopics(samples) {
   return out.sort((a, b) => b.count - a.count);
 }
 
+// src/runtime/materialize.ts
+function resolveColumn(col, event, tx, block) {
+  if ("fromTx" in col) {
+    return { ok: true, value: tx[col.fromTx] };
+  }
+  if ("fromBlock" in col) {
+    return { ok: true, value: block[col.fromBlock] };
+  }
+  const data = event.data;
+  const dataObj = data !== null && typeof data === "object" && !Array.isArray(data) ? data : undefined;
+  if (dataObj && Object.prototype.hasOwnProperty.call(dataObj, col.from)) {
+    return { ok: true, value: dataObj[col.from] };
+  }
+  if (col.from === "topic" && "topic" in event) {
+    return { ok: true, value: event.topic };
+  }
+  if (Object.prototype.hasOwnProperty.call(event, col.from)) {
+    return { ok: true, value: event[col.from] };
+  }
+  return { ok: false, missing: col.from };
+}
+function buildMaterializeRow(spec, event, ctx, tableColumns) {
+  const row = {};
+  for (const [colName, mapping] of Object.entries(spec.columns)) {
+    const resolved = resolveColumn(mapping, event, ctx.tx, ctx.block);
+    if (!resolved.ok) {
+      const colDef = tableColumns[colName];
+      if (colDef?.nullable) {
+        row[colName] = null;
+        continue;
+      }
+      return {
+        ok: false,
+        reason: `required materialize field "${resolved.missing}" missing for column "${colName}"`
+      };
+    }
+    row[colName] = resolved.value ?? null;
+  }
+  return { ok: true, row };
+}
+function applyMaterializeInsert(spec, event, ctx, schema) {
+  const table = schema[spec.table];
+  if (!table) {
+    return { ok: false, reason: `materialize table "${spec.table}" missing` };
+  }
+  const built = buildMaterializeRow(spec, event, ctx, table.columns);
+  if (!built.ok)
+    return built;
+  ctx.insert(spec.table, built.row);
+  return { ok: true };
+}
+
 // src/runtime/print-validate.ts
 var COLUMN_TYPES = new Set([
   "text",
@@ -1844,21 +2023,62 @@ function validatePrintPayload(prints, topic, data) {
   return matchesTopic(declared, data);
 }
 
-// src/runtime/runner.ts
-var DEFAULT_ERROR_THRESHOLD = 50;
-function camelizeKeys(obj) {
-  if (obj === null || obj === undefined)
-    return obj;
-  if (typeof obj !== "object")
-    return obj;
-  if (Array.isArray(obj))
-    return obj.map(camelizeKeys);
-  const result = {};
-  for (const [k, v] of Object.entries(obj)) {
-    result[camelizeDataKey(k)] = camelizeKeys(v);
+// src/runtime/violations.ts
+import { getTargetDb } from "@secondlayer/shared/db";
+import { logger as logger3 } from "@secondlayer/shared/logger";
+import { sql as sql2 } from "kysely";
+var VIOLATIONS_CAP_PER_SUBGRAPH = 100;
+function jsonSafe2(value) {
+  if (typeof value === "bigint")
+    return value.toString();
+  if (value === null || value === undefined)
+    return value;
+  if (Array.isArray(value))
+    return value.map(jsonSafe2);
+  if (typeof value === "object") {
+    const out = {};
+    for (const [k, v] of Object.entries(value)) {
+      out[k] = jsonSafe2(v);
+    }
+    return out;
   }
-  return result;
+  return value;
 }
+async function defaultRecordPrintViolation(input) {
+  try {
+    const db = getTargetDb();
+    const sample = jsonSafe2(input.samplePayload);
+    await db.insertInto("subgraph_violations").values({
+      subgraph_name: input.subgraphName,
+      source_name: input.sourceName,
+      block_height: input.blockHeight,
+      tx_id: input.txId,
+      reason: input.reason,
+      sample_payload: sample
+    }).execute();
+    await sql2`
+			DELETE FROM subgraph_violations
+			WHERE id IN (
+				SELECT id FROM subgraph_violations
+				WHERE subgraph_name = ${input.subgraphName}
+				ORDER BY seen_at DESC
+				OFFSET ${VIOLATIONS_CAP_PER_SUBGRAPH}
+			)
+		`.execute(db);
+  } catch (err) {
+    logger3.warn("Failed to record print violation", {
+      subgraph: input.subgraphName,
+      error: err instanceof Error ? err.message : String(err)
+    });
+  }
+}
+var recorder = defaultRecordPrintViolation;
+async function recordPrintViolation(input) {
+  await recorder(input);
+}
+
+// src/runtime/runner.ts
+var DEFAULT_ERROR_THRESHOLD = 50;
 function decodeFunctionArgs2(args) {
   let parsed = args;
   if (typeof parsed === "string") {
@@ -2106,16 +2326,18 @@ async function runHandlers(subgraph, matched, ctx, opts) {
   units.sort((a, b) => (a.tx.tx_index ?? 0) - (b.tx.tx_index ?? 0) || (a.event?.event_index ?? -1) - (b.event?.event_index ?? -1));
   for (const { tx, event, sourceName } of units) {
     if (errors >= threshold) {
-      logger3.error("Subgraph error threshold reached, skipping remaining events", {
+      logger4.error("Subgraph error threshold reached, skipping remaining events", {
         subgraph: subgraph.name,
         errors,
         threshold
       });
       return { processed, errors, ...skipped > 0 ? { skipped } : {} };
     }
+    const filter = filterLookup.get(sourceName);
+    const materialize = filter && "materialize" in filter && filter.materialize !== undefined ? filter.materialize : undefined;
     const handler = subgraph.handlers[sourceName] ?? subgraph.handlers["*"] ?? null;
-    if (!handler) {
-      logger3.warn("No handler found for source", {
+    if (!handler && !materialize) {
+      logger4.warn("No handler found for source", {
         subgraph: subgraph.name,
         sourceName,
         txId: tx.tx_id
@@ -2130,7 +2352,6 @@ async function runHandlers(subgraph, matched, ctx, opts) {
       contractId: tx.contract_id ?? null,
       functionName: tx.function_name ?? null
     });
-    const filter = filterLookup.get(sourceName);
     const checkpoint = ctx.opsCheckpoint();
     try {
       let payload;
@@ -2172,22 +2393,48 @@ async function runHandlers(subgraph, matched, ctx, opts) {
         const verdict = validatePrintPayload(filter.prints, printPayload.topic ?? "", printPayload.data ?? {});
         if (!verdict.ok) {
           skipped++;
-          logger3.warn("Print payload does not match declared prints schema", {
+          logger4.warn("Print payload does not match declared prints schema", {
             subgraph: subgraph.name,
             sourceName,
             topic: printPayload.topic,
             txId: tx.tx_id,
             reason: verdict.reason
           });
+          recordPrintViolation({
+            subgraphName: subgraph.name,
+            sourceName,
+            blockHeight: ctx.block.height,
+            txId: tx.tx_id,
+            reason: verdict.reason,
+            samplePayload: {
+              topic: printPayload.topic ?? "",
+              data: printPayload.data ?? {}
+            }
+          });
+          continue;
+        }
+      }
+      if (materialize) {
+        const result = applyMaterializeInsert(materialize, payload, ctx, subgraph.schema);
+        if (!result.ok) {
+          skipped++;
+          logger4.warn("Materialize skipped: required field missing", {
+            subgraph: subgraph.name,
+            sourceName,
+            txId: tx.tx_id,
+            reason: result.reason
+          });
           continue;
         }
+        processed++;
+      } else if (handler) {
+        await handler(payload, ctx);
+        processed++;
       }
-      await handler(payload, ctx);
-      processed++;
     } catch (err) {
       ctx.rollbackTo(checkpoint);
       errors++;
-      logger3.error("Subgraph handler error", {
+      logger4.error("Subgraph handler error", {
         subgraph: subgraph.name,
         sourceName,
         txId: tx.tx_id,
@@ -2200,7 +2447,7 @@ async function runHandlers(subgraph, matched, ctx, opts) {
 }
 
 // src/runtime/block-processor.ts
-import { getTargetDb } from "@secondlayer/shared/db";
+import { getTargetDb as getTargetDb2 } from "@secondlayer/shared/db";
 import { resolveTraitContractIds } from "@secondlayer/shared/db/queries/contracts";
 import { recordGapBatch } from "@secondlayer/shared/db/queries/subgraph-gaps";
 import { advanceOperationCursor } from "@secondlayer/shared/db/queries/subgraph-operations";
@@ -2211,15 +2458,15 @@ import {
   rewindLiveProgress,
   updateSubgraphStatus
 } from "@secondlayer/shared/db/queries/subgraphs";
-import { logger as logger7 } from "@secondlayer/shared/logger";
-import { sql as sql3 } from "kysely";
+import { logger as logger8 } from "@secondlayer/shared/logger";
+import { sql as sql4 } from "kysely";
 
 // src/runtime/block-source.ts
 import { getSourceDb as getSourceDb2 } from "@secondlayer/shared/db";
 import {
   createInternalIndexHttpClient
 } from "@secondlayer/shared/index-http";
-import { logger as logger4 } from "@secondlayer/shared/logger";
+import { logger as logger5 } from "@secondlayer/shared/logger";
 
 // src/runtime/batch-loader.ts
 async function loadBlockRange(db, fromHeight, toHeight) {
@@ -2706,7 +2953,7 @@ class FallbackBlockSource {
     try {
       return await this.primary.getTip();
     } catch (err) {
-      logger4.warn("block source primary getTip failed — using DB tap", {
+      logger5.warn("block source primary getTip failed — using DB tap", {
         error: err instanceof Error ? err.message : String(err)
       });
       return this.fallback.getTip();
@@ -2716,7 +2963,7 @@ class FallbackBlockSource {
     try {
       return await this.primary.loadBlockRange(fromHeight, toHeight);
     } catch (err) {
-      logger4.warn("block source primary loadBlockRange failed — using DB tap", {
+      logger5.warn("block source primary loadBlockRange failed — using DB tap", {
         from: fromHeight,
         to: toHeight,
         error: err instanceof Error ? err.message : String(err)
@@ -2753,7 +3000,7 @@ function resolveBlockSource(subgraph) {
     return new FallbackBlockSource(new PublicApiBlockSource(buildHttpClient(), referencedIndexEventTypes(subgraph), canSparseScan(subgraph) ? sparseProbeTargets(subgraph) : undefined, needsTransactionData(subgraph)), postgresBlockSource);
   }
   if (process.env.SUBGRAPH_SOURCE === "streams-index" && subgraph) {
-    logger4.debug("Subgraph not streams-index eligible, using DB tap", {
+    logger5.debug("Subgraph not streams-index eligible, using DB tap", {
       subgraph: subgraph.name
     });
   }
@@ -2762,7 +3009,7 @@ function resolveBlockSource(subgraph) {
 
 // src/runtime/outbox-emit.ts
 import { createHash as createHash2 } from "node:crypto";
-import { logger as logger5 } from "@secondlayer/shared/logger";
+import { logger as logger6 } from "@secondlayer/shared/logger";
 var loggedKillSwitch = false;
 var OP_VERB = {
   insert: "created",
@@ -2786,7 +3033,7 @@ function stableStringify(obj) {
 async function emitSubscriptionOutbox(tx, subgraphName, manifest, matcher, blockHeight) {
   if (!isEmitOutboxEnabled()) {
     if (!loggedKillSwitch) {
-      logger5.warn("SECONDLAYER_EMIT_OUTBOX=false — outbox emission bypassed");
+      logger6.warn("SECONDLAYER_EMIT_OUTBOX=false — outbox emission bypassed");
       loggedKillSwitch = true;
     }
     return 0;
@@ -2831,7 +3078,7 @@ function sandboxEnabled(subgraph) {
 // src/runtime/sandbox/host.ts
 import { tmpdir } from "node:os";
 import { fileURLToPath } from "node:url";
-import { logger as logger6 } from "@secondlayer/shared/logger";
+import { logger as logger7 } from "@secondlayer/shared/logger";
 
 // src/runtime/sandbox/bundle.ts
 import esbuild from "esbuild";
@@ -2911,7 +3158,7 @@ function spawnSandboxProcess() {
           break;
         const text = decoder.decode(value, { stream: true });
         if (text.trim()) {
-          logger6.warn("Sandbox subprocess stderr", { stderr: text.trim() });
+          logger7.warn("Sandbox subprocess stderr", { stderr: text.trim() });
         }
       }
     } catch {}
@@ -2969,7 +3216,7 @@ async function ensureSandboxProcess(subgraphName, version, handlerCode) {
     try {
       await initSandboxProcess(existing.proc, subgraphName, version, handlerCode);
       existing.version = version;
-      logger6.info("Sandbox subprocess handler reloaded", {
+      logger7.info("Sandbox subprocess handler reloaded", {
         subgraph: subgraphName,
         version
       });
@@ -2977,7 +3224,7 @@ async function ensureSandboxProcess(subgraphName, version, handlerCode) {
     } catch (err) {
       existing.proc.kill();
       pool.delete(subgraphName);
-      logger6.warn("Sandbox subprocess re-init failed; respawning", {
+      logger7.warn("Sandbox subprocess re-init failed; respawning", {
         subgraph: subgraphName,
         error: err instanceof Error ? err.message : String(err)
       });
@@ -3060,7 +3307,7 @@ async function runBlockThroughProcess(entry, subgraphName, hostCtx, block, match
     return result;
   } catch (err) {
     evictSandboxWorker(subgraphName);
-    logger6.warn("Sandbox subprocess run failed; subprocess evicted", {
+    logger7.warn("Sandbox subprocess run failed; subprocess evicted", {
       subgraph: subgraphName,
       blockHeight: block.height,
       error: err instanceof Error ? err.message : String(err)
@@ -3131,7 +3378,7 @@ async function answerRead(hostCtx, msg) {
 
 // src/runtime/subscription-state.ts
 import { listSubscriptions } from "@secondlayer/shared/db/queries/subscriptions";
-import { sql as sql2 } from "kysely";
+import { sql as sql3 } from "kysely";
 
 // src/runtime/emitter-matcher.ts
 function isPrimitive(v) {
@@ -3295,7 +3542,7 @@ class SubscriptionMatcher {
 // src/runtime/subscription-state.ts
 var matcher = new SubscriptionMatcher;
 async function refreshMatcher(db) {
-  const rows = await sql2`
+  const rows = await sql3`
 		SELECT * FROM subscriptions WHERE status = 'active'
 	`.execute(db);
   matcher.setAll(rows.rows);
@@ -3317,7 +3564,7 @@ async function resolveRoute(subgraphName, targetDb) {
     version: row?.version ?? ""
   };
   routeCache.set(subgraphName, route);
-  logger7.info("subgraph handler dispatch path resolved", {
+  logger8.info("subgraph handler dispatch path resolved", {
     subgraph: subgraphName,
     path: sandboxEnabled({ sandbox_workers: route.sandboxWorkers }) ? "sandbox" : "in-process"
   });
@@ -3341,8 +3588,8 @@ async function resolveFactoryContracts(subgraph, blockHeight, schemaName, db, tx
   for (const [discoveringSource, factory] of factories) {
     const known = new Set;
     try {
-      const rows = await sql3`
-				SELECT address FROM ${sql3.raw(`"${schemaName}"."_factory_addresses"`)}
+      const rows = await sql4`
+				SELECT address FROM ${sql4.raw(`"${schemaName}"."_factory_addresses"`)}
 				WHERE source_name = ${discoveringSource} AND block_height <= ${blockHeight}
 			`.execute(db);
       for (const row of rows.rows)
@@ -3370,8 +3617,8 @@ async function persistFactoryDiscoveries(schemaName, db, blockHeight, discovered
   if (discovered.length === 0)
     return;
   for (const { sourceName, address } of discovered) {
-    await sql3`
-			INSERT INTO ${sql3.raw(`"${schemaName}"."_factory_addresses"`)}
+    await sql4`
+			INSERT INTO ${sql4.raw(`"${schemaName}"."_factory_addresses"`)}
 				(source_name, address, block_height)
 			VALUES (${sourceName}, ${address}, ${blockHeight})
 			ON CONFLICT (source_name, address) DO NOTHING
@@ -3431,7 +3678,7 @@ async function processBlockWithRetry(subgraph, subgraphName, blockHeight, opts,
       const delay = retryDelaysMs[attempt];
       if (delay === undefined)
         break;
-      logger7.warn("Block processing failed, retrying", {
+      logger8.warn("Block processing failed, retrying", {
         subgraph: subgraphName,
         blockHeight,
         attempt: attempt + 1,
@@ -3444,7 +3691,7 @@ async function processBlockWithRetry(subgraph, subgraphName, blockHeight, opts,
   throw lastError;
 }
 async function processBlock(subgraph, subgraphName, blockHeight, opts) {
-  const targetDb = getTargetDb();
+  const targetDb = getTargetDb2();
   const blockStart = performance.now();
   const result = {
     blockHeight,
@@ -3463,7 +3710,7 @@ async function processBlock(subgraph, subgraphName, blockHeight, opts) {
   } else {
     const data = (await resolveBlockSource(subgraph).loadBlockRange(blockHeight, blockHeight)).get(blockHeight);
     if (!data) {
-      logger7.debug("Block not found or non-canonical for subgraph processing", {
+      logger8.debug("Block not found or non-canonical for subgraph processing", {
         subgraph: subgraphName,
         blockHeight
       });
@@ -3529,7 +3776,7 @@ async function processBlock(subgraph, subgraphName, blockHeight, opts) {
           { start: blockHeight, end: blockHeight, reason: "processing_error" }
         ]);
       } else {
-        logger7.warn("Block errors not recorded as a gap — no subgraphId", {
+        logger8.warn("Block errors not recorded as a gap — no subgraphId", {
           subgraph: subgraphName,
           blockHeight,
           errors: rr.errors
@@ -3602,7 +3849,7 @@ async function processBlock(subgraph, subgraphName, blockHeight, opts) {
     });
   } catch (err) {
     if (err instanceof CursorRaceLostError || err instanceof LiveCursorRaceLostError) {
-      logger7.warn("cursor race lost — block already covered", {
+      logger8.warn("cursor race lost — block already covered", {
         subgraph: subgraphName,
         blockHeight,
         error: err.message
@@ -3627,10 +3874,10 @@ async function processBlock(subgraph, subgraphName, blockHeight, opts) {
     try {
       const tables = Object.keys(subgraph.schema);
       for (const table of tables) {
-        const { rows } = await sql3.raw(`SELECT n_live_tup AS count FROM pg_stat_user_tables WHERE schemaname = '${schemaName}' AND relname = '${table}'`).execute(route.dataDb);
+        const { rows } = await sql4.raw(`SELECT n_live_tup AS count FROM pg_stat_user_tables WHERE schemaname = '${schemaName}' AND relname = '${table}'`).execute(route.dataDb);
         const count = Number(rows[0]?.count ?? 0);
         if (count >= 1e7) {
-          logger7.warn("Subgraph table exceeds 10M rows (estimate)", {
+          logger8.warn("Subgraph table exceeds 10M rows (estimate)", {
             subgraph: subgraphName,
             table,
             count
@@ -3638,13 +3885,13 @@ async function processBlock(subgraph, subgraphName, blockHeight, opts) {
         }
       }
     } catch (err) {
-      logger7.debug("Row count sample failed", {
+      logger8.debug("Row count sample failed", {
         subgraph: subgraphName,
         error: err instanceof Error ? err.message : String(err)
       });
     }
     if (journalEnabled(opts)) {
-      await sql3.raw(`DELETE FROM "${schemaName}"."_journal" WHERE "block_height" < ${blockHeight - JOURNAL_RETENTION_BLOCKS}`).execute(route.dataDb).catch(() => {});
+      await sql4.raw(`DELETE FROM "${schemaName}"."_journal" WHERE "block_height" < ${blockHeight - JOURNAL_RETENTION_BLOCKS}`).execute(route.dataDb).catch(() => {});
     }
   }
   return result;
@@ -3714,9 +3961,9 @@ class StatsAccumulator {
 }
 
 // src/runtime/catchup.ts
-import { getTargetDb as getTargetDb2, sql as sql4 } from "@secondlayer/shared/db";
+import { getTargetDb as getTargetDb3, sql as sql5 } from "@secondlayer/shared/db";
 import { getSubgraph } from "@secondlayer/shared/db/queries/subgraphs";
-import { logger as logger8 } from "@secondlayer/shared/logger";
+import { logger as logger9 } from "@secondlayer/shared/logger";
 
 // src/runtime/catchup-leader.ts
 import {
@@ -3846,8 +4093,8 @@ async function withSubgraphBlockLock(name, fn) {
   }
 }
 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 getTargetDb3().transaction().execute(async (lockTx) => {
+    await sql5`SELECT pg_advisory_xact_lock(hashtext(${`subgraph-block:${name}`}))`.execute(lockTx);
     return fn();
   });
 }
@@ -3908,7 +4155,7 @@ async function catchUpSubgraph(subgraph, subgraphName) {
   catchingUp.add(subgraphName);
   try {
     const source = resolveBlockSource(subgraph);
-    const targetDb = getTargetDb2();
+    const targetDb = getTargetDb3();
     const subgraphRow = await getSubgraph(targetDb, subgraphName);
     if (!subgraphRow)
       return 0;
@@ -3920,7 +4167,7 @@ async function catchUpSubgraph(subgraph, subgraphName) {
     if (usesDecodedIndexPlane(subgraph)) {
       const bound = await boundSourceTip(rawTip, decoderNamesForSubgraph(subgraph));
       if (!bound.ok) {
-        logger8.warn("Subgraph catch-up stalled: missing decoder checkpoint", {
+        logger9.warn("Subgraph catch-up stalled: missing decoder checkpoint", {
           event: "subgraph_catchup_decoder_stall",
           subgraph: subgraphName,
           missing: bound.missing
@@ -3928,7 +4175,7 @@ async function catchUpSubgraph(subgraph, subgraphName) {
         return 0;
       }
       if (bound.floor !== null && bound.floor < rawTip) {
-        logger8.debug("Subgraph catch-up tip bounded by decoder progress", {
+        logger9.debug("Subgraph catch-up tip bounded by decoder progress", {
           event: "subgraph_catchup_decoder_floor",
           subgraph: subgraphName,
           rawTip,
@@ -3943,7 +4190,7 @@ async function catchUpSubgraph(subgraph, subgraphName) {
     const subgraphStart = Number(subgraphRow.start_block) || 1;
     const startBlock = Math.max(lastProcessedBlock + 1, subgraphStart);
     const totalBlocks = chainTip - lastProcessedBlock;
-    logger8.info("Subgraph catch-up starting", {
+    logger9.info("Subgraph catch-up starting", {
       subgraph: subgraphName,
       from: startBlock,
       to: chainTip,
@@ -3959,7 +4206,7 @@ async function catchUpSubgraph(subgraph, subgraphName) {
     let nextBatchPromise = batchConfig.prefetch ? source.loadBlockRange(currentHeight, prefetchedBatchEnd) : undefined;
     while (currentHeight <= chainTip) {
       if (!isCatchUpLeader()) {
-        logger8.info("Lost catch-up leadership, stopping catch-up", {
+        logger9.info("Lost catch-up leadership, stopping catch-up", {
           subgraph: subgraphName,
           processed
         });
@@ -3967,7 +4214,7 @@ async function catchUpSubgraph(subgraph, subgraphName) {
       }
       const currentRow = await getSubgraph(targetDb, subgraphName);
       if (!currentRow || currentRow.status !== "active") {
-        logger8.info("Subgraph status changed, stopping catch-up", {
+        logger9.info("Subgraph status changed, stopping catch-up", {
           subgraph: subgraphName,
           status: currentRow?.status ?? "deleted"
         });
@@ -3996,7 +4243,7 @@ async function catchUpSubgraph(subgraph, subgraphName) {
           blockData = (await source.loadBlockRange(height, height)).get(height);
         }
         if (!blockData) {
-          logger8.warn("Block missing during catch-up, deferring to next tick", {
+          logger9.warn("Block missing during catch-up, deferring to next tick", {
             subgraph: subgraphName,
             blockHeight: height
           });
@@ -4017,12 +4264,12 @@ async function catchUpSubgraph(subgraph, subgraphName) {
           });
         } catch (err) {
           if (err instanceof ReorgEpochChangedError) {
-            logger8.info("Reorg detected mid catch-up, aborting walk without writing further progress", { subgraph: subgraphName, blockHeight: height });
+            logger9.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", {
+          logger9.error("Block processing failed persistently during catch-up", {
             subgraph: subgraphName,
             blockHeight: height,
             error: errorMsg
@@ -4041,7 +4288,7 @@ async function catchUpSubgraph(subgraph, subgraphName) {
           }
         }
         if (processed % LOG_INTERVAL === 0) {
-          logger8.info("Subgraph catch-up progress", {
+          logger9.info("Subgraph catch-up progress", {
             subgraph: subgraphName,
             processed,
             total: totalBlocks,
@@ -4057,7 +4304,7 @@ async function catchUpSubgraph(subgraph, subgraphName) {
       currentHeight = batchEnd + 1;
     }
     await stats.flush(targetDb);
-    logger8.info("Subgraph catch-up complete", {
+    logger9.info("Subgraph catch-up complete", {
       subgraph: subgraphName,
       processed
     });
@@ -4069,7 +4316,7 @@ async function catchUpSubgraph(subgraph, subgraphName) {
 
 // src/runtime/reindex.ts
 import { getErrorMessage as getErrorMessage3 } from "@secondlayer/shared";
-import { getRawClient, getTargetDb as getTargetDb3 } from "@secondlayer/shared/db";
+import { getRawClient, getTargetDb as getTargetDb4 } from "@secondlayer/shared/db";
 import {
   recordGapBatch as recordGapBatch2,
   resolveGaps
@@ -4082,11 +4329,11 @@ import {
   recordSubgraphProcessed as recordSubgraphProcessed2,
   updateSubgraphStatus as updateSubgraphStatus2
 } from "@secondlayer/shared/db/queries/subgraphs";
-import { logger as logger10 } from "@secondlayer/shared/logger";
+import { logger as logger11 } from "@secondlayer/shared/logger";
 
 // src/runtime/reindex-notify.ts
 import { getErrorMessage as getErrorMessage2 } from "@secondlayer/shared";
-import { logger as logger9 } from "@secondlayer/shared/logger";
+import { logger as logger10 } from "@secondlayer/shared/logger";
 async function notifyReindexComplete(db, subgraphName, stats) {
   try {
     const subgraph = await db.selectFrom("subgraphs").select(["account_id"]).where("name", "=", subgraphName).executeTakeFirst();
@@ -4097,7 +4344,7 @@ async function notifyReindexComplete(db, subgraphName, stats) {
       return;
     const resendKey = process.env.RESEND_API_KEY;
     if (!resendKey) {
-      logger9.warn("RESEND_API_KEY unset — skipping reindex-complete email", {
+      logger10.warn("RESEND_API_KEY unset — skipping reindex-complete email", {
         subgraph: subgraphName
       });
       return;
@@ -4119,14 +4366,14 @@ async function notifyReindexComplete(db, subgraphName, stats) {
     });
     if (!res.ok) {
       const text = await res.text().catch(() => "");
-      logger9.warn("reindex-complete email failed", {
+      logger10.warn("reindex-complete email failed", {
         subgraph: subgraphName,
         status: res.status,
         body: text.slice(0, 200)
       });
     }
   } catch (err) {
-    logger9.warn("reindex-complete email threw", {
+    logger10.warn("reindex-complete email threw", {
       subgraph: subgraphName,
       error: getErrorMessage2(err)
     });
@@ -4195,7 +4442,7 @@ function coalesceFailedBlocks(blocks) {
 }
 async function processBlockRange(def, opts) {
   const source = resolveBlockSource(def);
-  const targetDb = getTargetDb3();
+  const targetDb = getTargetDb4();
   const subgraphName = def.name;
   const { fromBlock, toBlock, status } = opts;
   const totalBlocks = toBlock - fromBlock + 1;
@@ -4238,7 +4485,7 @@ async function processBlockRange(def, opts) {
   while (currentHeight <= toBlock) {
     if (opts.signal?.aborted) {
       aborted = true;
-      logger10.info("Block processing aborted", {
+      logger11.info("Block processing aborted", {
         subgraph: subgraphName,
         currentBlock: currentHeight,
         reason: String(opts.signal.reason ?? "unknown")
@@ -4289,7 +4536,7 @@ async function processBlockRange(def, opts) {
         result = mayWrite ? await withSubgraphBlockWriteLock(subgraphName, runBlock) : await runBlock();
       } catch (err) {
         const errorMsg = getErrorMessage3(err);
-        logger10.error("Block processing failed persistently", {
+        logger11.error("Block processing failed persistently", {
           subgraph: subgraphName,
           blockHeight: height,
           error: errorMsg
@@ -4335,7 +4582,7 @@ async function processBlockRange(def, opts) {
         lastProgressFlushAt = now;
       }
       if (blocksProcessed % LOG_INTERVAL2 === 0) {
-        logger10.info(`${status === "reindexing" ? "Reindex" : "Backfill"} progress`, {
+        logger11.info(`${status === "reindexing" ? "Reindex" : "Backfill"} progress`, {
           subgraph: subgraphName,
           processed: blocksProcessed,
           total: totalBlocks,
@@ -4355,7 +4602,7 @@ async function processBlockRange(def, opts) {
     if (batchFailedBlocks.length > 0 && opts.subgraphId) {
       const gaps = coalesceFailedBlocks(batchFailedBlocks);
       await recordGapBatch2(targetDb, opts.subgraphId, subgraphName, gaps).catch((err) => {
-        logger10.warn("Failed to record subgraph gaps", {
+        logger11.warn("Failed to record subgraph gaps", {
           subgraph: subgraphName,
           error: err instanceof Error ? err.message : String(err)
         });
@@ -4372,7 +4619,7 @@ async function processBlockRange(def, opts) {
         } else {
           await updateSubgraphStatus2(targetDb, subgraphName, status, jumpTo - 1);
         }
-        logger10.info("Sparse skip", {
+        logger11.info("Sparse skip", {
           subgraph: subgraphName,
           from: batchEnd + 1,
           to: jumpTo - 1,
@@ -4406,7 +4653,7 @@ async function resolveBlockRange(source, def, opts) {
   }
   const bound = await boundSourceTip(rawTip, decoderNamesForSubgraph(def));
   if (!bound.ok) {
-    logger10.warn("Reindex stalled: missing decoder checkpoint", {
+    logger11.warn("Reindex stalled: missing decoder checkpoint", {
       event: "subgraph_reindex_decoder_stall",
       subgraph: def.name,
       missing: bound.missing
@@ -4414,7 +4661,7 @@ async function resolveBlockRange(source, def, opts) {
     throw new Error(`Reindex stalled: missing decoder checkpoint (${bound.missing.join(", ")})`);
   }
   if (bound.floor !== null && bound.floor < rawTip) {
-    logger10.debug("Reindex tip bounded by decoder progress", {
+    logger11.debug("Reindex tip bounded by decoder progress", {
       event: "subgraph_reindex_decoder_floor",
       subgraph: def.name,
       rawTip,
@@ -4429,16 +4676,16 @@ async function clearReindexMetadata(db, subgraphName) {
 }
 async function reindexSubgraph(def, opts) {
   const source = resolveBlockSource(def);
-  const targetDb = getTargetDb3();
+  const targetDb = getTargetDb4();
   const client = getRawClient("target");
   const subgraphName = def.name;
   const schemaName = opts?.schemaName ?? pgSchemaName(subgraphName);
   await updateSubgraphStatus2(targetDb, subgraphName, "reindexing");
-  logger10.info("Reindex starting", { subgraph: subgraphName });
+  logger11.info("Reindex starting", { subgraph: subgraphName });
   try {
     const { fromBlock, toBlock } = await resolveBlockRange(source, def, opts);
     if (fromBlock > toBlock) {
-      logger10.info("No blocks to reindex", {
+      logger11.info("No blocks to reindex", {
         subgraph: subgraphName,
         fromBlock,
         toBlock
@@ -4452,7 +4699,7 @@ async function reindexSubgraph(def, opts) {
       await client.unsafe(stmt);
     }
     await updateSubgraphStatus2(targetDb, subgraphName, "reindexing", Math.max(0, fromBlock - 1));
-    logger10.info("Schema recreated for reindex", {
+    logger11.info("Schema recreated for reindex", {
       subgraph: subgraphName,
       cursorResetTo: Math.max(0, fromBlock - 1)
     });
@@ -4466,7 +4713,7 @@ async function reindexSubgraph(def, opts) {
       last_error_at: null,
       updated_at: new Date
     }).where("name", "=", subgraphName).execute();
-    logger10.info("Reindexing blocks", {
+    logger11.info("Reindexing blocks", {
       subgraph: subgraphName,
       fromBlock,
       toBlock,
@@ -4488,9 +4735,9 @@ async function reindexSubgraph(def, opts) {
       if (reason === "user-cancelled") {
         await updateSubgraphStatus2(targetDb, subgraphName, "active");
         await clearReindexMetadata(targetDb, subgraphName);
-        logger10.info("Reindex cancelled by user", { subgraph: subgraphName });
+        logger11.info("Reindex cancelled by user", { subgraph: subgraphName });
       } else {
-        logger10.info("Reindex interrupted by shutdown, will resume", {
+        logger11.info("Reindex interrupted by shutdown, will resume", {
           subgraph: subgraphName
         });
       }
@@ -4498,7 +4745,7 @@ async function reindexSubgraph(def, opts) {
     }
     await updateSubgraphStatus2(targetDb, subgraphName, "active", toBlock);
     await clearReindexMetadata(targetDb, subgraphName);
-    logger10.info("Reindex complete", {
+    logger11.info("Reindex complete", {
       subgraph: subgraphName,
       blocks: result.blocksProcessed,
       events: result.totalEventsProcessed,
@@ -4511,7 +4758,7 @@ async function reindexSubgraph(def, opts) {
     });
     return { processed: result.blocksProcessed };
   } catch (err) {
-    logger10.error("Reindex failed", {
+    logger11.error("Reindex failed", {
       subgraph: subgraphName,
       error: getErrorMessage3(err)
     });
@@ -4520,7 +4767,7 @@ async function reindexSubgraph(def, opts) {
   }
 }
 async function resumeReindex(def, opts) {
-  const targetDb = getTargetDb3();
+  const targetDb = getTargetDb4();
   const subgraphName = def.name;
   const row = await targetDb.selectFrom("subgraphs").select([
     "id",
@@ -4533,7 +4780,7 @@ async function resumeReindex(def, opts) {
   const fromBlock = resolveReindexResumeBlock(row);
   const toBlock = Number(row.reindex_to_block);
   if (fromBlock == null) {
-    logger10.info("No reindex metadata, starting fresh reindex", {
+    logger11.info("No reindex metadata, starting fresh reindex", {
       subgraph: subgraphName
     });
     return reindexSubgraph(def, {
@@ -4542,12 +4789,12 @@ async function resumeReindex(def, opts) {
     });
   }
   if (fromBlock > toBlock) {
-    logger10.info("Resume: no remaining blocks", { subgraph: subgraphName });
+    logger11.info("Resume: no remaining blocks", { subgraph: subgraphName });
     await updateSubgraphStatus2(targetDb, subgraphName, "active", toBlock);
     await clearReindexMetadata(targetDb, subgraphName);
     return { processed: 0 };
   }
-  logger10.info("Resuming reindex", {
+  logger11.info("Resuming reindex", {
     subgraph: subgraphName,
     fromBlock,
     toBlock,
@@ -4569,9 +4816,9 @@ async function resumeReindex(def, opts) {
       if (reason === "user-cancelled") {
         await updateSubgraphStatus2(targetDb, subgraphName, "active");
         await clearReindexMetadata(targetDb, subgraphName);
-        logger10.info("Resume cancelled by user", { subgraph: subgraphName });
+        logger11.info("Resume cancelled by user", { subgraph: subgraphName });
       } else {
-        logger10.info("Resume interrupted by shutdown, will resume again", {
+        logger11.info("Resume interrupted by shutdown, will resume again", {
           subgraph: subgraphName
         });
       }
@@ -4579,13 +4826,13 @@ async function resumeReindex(def, opts) {
     }
     await updateSubgraphStatus2(targetDb, subgraphName, "active", toBlock);
     await clearReindexMetadata(targetDb, subgraphName);
-    logger10.info("Resumed reindex complete", {
+    logger11.info("Resumed reindex complete", {
       subgraph: subgraphName,
       blocks: result.blocksProcessed
     });
     return { processed: result.blocksProcessed };
   } catch (err) {
-    logger10.error("Resumed reindex failed", {
+    logger11.error("Resumed reindex failed", {
       subgraph: subgraphName,
       error: getErrorMessage3(err)
     });
@@ -4594,9 +4841,9 @@ async function resumeReindex(def, opts) {
   }
 }
 async function backfillSubgraph(def, opts) {
-  const targetDb = getTargetDb3();
+  const targetDb = getTargetDb4();
   const subgraphName = def.name;
-  logger10.info("Backfill starting", {
+  logger11.info("Backfill starting", {
     subgraph: subgraphName,
     from: opts.fromBlock,
     to: opts.toBlock
@@ -4614,17 +4861,17 @@ async function backfillSubgraph(def, opts) {
       signal: opts.signal
     });
     if (result.aborted) {
-      logger10.info("Backfill aborted", { subgraph: subgraphName });
+      logger11.info("Backfill aborted", { subgraph: subgraphName });
       return { processed: result.blocksProcessed };
     }
     const resolved = await resolveGaps(targetDb, subgraphName, opts.fromBlock, opts.toBlock).catch(() => 0);
     if (resolved > 0) {
-      logger10.info("Resolved subgraph gaps via backfill", {
+      logger11.info("Resolved subgraph gaps via backfill", {
         subgraph: subgraphName,
         resolved
       });
     }
-    logger10.info("Backfill complete", {
+    logger11.info("Backfill complete", {
       subgraph: subgraphName,
       blocks: result.blocksProcessed,
       events: result.totalEventsProcessed,
@@ -4632,7 +4879,7 @@ async function backfillSubgraph(def, opts) {
     });
     return { processed: result.blocksProcessed };
   } catch (err) {
-    logger10.error("Backfill failed", {
+    logger11.error("Backfill failed", {
       subgraph: subgraphName,
       error: getErrorMessage3(err)
     });
@@ -5200,7 +5447,7 @@ function generateIndexSchema(target, opts = {}) {
 }
 var INDEX_CODEGEN_TABLES = Object.keys(SOURCE_READ_TYPES);
 // src/schema/deployer.ts
-import { sql as sql5 } from "kysely";
+import { sql as sql6 } from "kysely";
 function toJsonSafe(obj) {
   return JSON.parse(JSON.stringify(obj, (_key, value) => typeof value === "bigint" ? value.toString() : value));
 }
@@ -5323,7 +5570,7 @@ async function deploySchema(db, def, handlerPath, opts) {
     startBlock: def.startBlock
   };
   if (existing) {
-    const schemaExists = await sql5`
+    const schemaExists = await sql6`
 			SELECT EXISTS (
 				SELECT 1 FROM information_schema.schemata
 				WHERE schema_name = ${schemaName}
@@ -5331,7 +5578,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 sql5.raw(stmt).execute(ddlDb);
+        await sql6.raw(stmt).execute(ddlDb);
       }
       const sg2 = await registerSubgraph(db, regData);
       return { action: "reindexed", subgraphId: sg2.id, version: newVersion };
@@ -5355,9 +5602,9 @@ async function deploySchema(db, def, handlerPath, opts) {
       };
     }
     if (existing.schema_hash === hash && opts?.forceReindex) {
-      await sql5.raw(`DROP SCHEMA IF EXISTS "${schemaName}" CASCADE`).execute(ddlDb);
+      await sql6.raw(`DROP SCHEMA IF EXISTS "${schemaName}" CASCADE`).execute(ddlDb);
       for (const stmt of statements) {
-        await sql5.raw(stmt).execute(ddlDb);
+        await sql6.raw(stmt).execute(ddlDb);
       }
       const sg2 = await registerSubgraph(db, regData);
       return { action: "reindexed", subgraphId: sg2.id, version: newVersion };
@@ -5366,9 +5613,9 @@ async function deploySchema(db, def, handlerPath, opts) {
       const diff = diffSchema(existing.definition.schema, def.schema);
       const { breaking, reasons } = hasBreakingChanges(diff);
       if (breaking || opts?.forceReindex) {
-        await sql5.raw(`DROP SCHEMA IF EXISTS "${schemaName}" CASCADE`).execute(ddlDb);
+        await sql6.raw(`DROP SCHEMA IF EXISTS "${schemaName}" CASCADE`).execute(ddlDb);
         for (const stmt of statements) {
-          await sql5.raw(stmt).execute(ddlDb);
+          await sql6.raw(stmt).execute(ddlDb);
         }
         const sg3 = await registerSubgraph(db, regData);
         const deployDiff2 = toDeployDiff(diff, reasons);
@@ -5381,16 +5628,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 sql5.raw("CREATE EXTENSION IF NOT EXISTS pg_trgm").execute(ddlDb);
+        await sql6.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 sql5.raw(stmt).execute(ddlDb);
+          await sql6.raw(stmt).execute(ddlDb);
         }
       }
       for (const { tableName, tableDef } of addedDefs) {
         for (const stmt of emitForeignKeyDDL(schemaName, tableName, tableDef)) {
-          await sql5.raw(stmt).execute(ddlDb);
+          await sql6.raw(stmt).execute(ddlDb);
         }
       }
       for (const [tableName, colDiff] of Object.entries(diff.tables)) {
@@ -5408,12 +5655,12 @@ async function deploySchema(db, def, handlerPath, opts) {
           if (!sqlType)
             continue;
           const nullable = col.nullable ? "" : ` NOT NULL DEFAULT ${getDefault(col.type)}`;
-          await sql5.raw(`ALTER TABLE ${qualifiedName} ADD COLUMN ${colName} ${sqlType}${nullable}`).execute(ddlDb);
+          await sql6.raw(`ALTER TABLE ${qualifiedName} ADD COLUMN ${colName} ${sqlType}${nullable}`).execute(ddlDb);
           if (col.indexed) {
-            await sql5.raw(`CREATE INDEX IF NOT EXISTS idx_${schemaName}_${tableName}_${colName} ON ${qualifiedName} (${colName})`).execute(ddlDb);
+            await sql6.raw(`CREATE INDEX IF NOT EXISTS idx_${schemaName}_${tableName}_${colName} ON ${qualifiedName} (${colName})`).execute(ddlDb);
           }
           if (col.search) {
-            await sql5.raw(`CREATE INDEX IF NOT EXISTS idx_${schemaName}_${tableName}_${colName}_trgm ON ${qualifiedName} USING gin (${colName} gin_trgm_ops)`).execute(ddlDb);
+            await sql6.raw(`CREATE INDEX IF NOT EXISTS idx_${schemaName}_${tableName}_${colName}_trgm ON ${qualifiedName} USING gin (${colName} gin_trgm_ops)`).execute(ddlDb);
           }
         }
       }
@@ -5421,7 +5668,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 sql5.raw("CREATE EXTENSION IF NOT EXISTS pg_trgm").execute(ddlDb);
+        await sql6.raw("CREATE EXTENSION IF NOT EXISTS pg_trgm").execute(ddlDb);
       }
       for (const [tableName, colDiff] of Object.entries(diff.tables)) {
         if (colDiff.indexChanged.length === 0)
@@ -5436,14 +5683,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 sql5.raw(`CREATE INDEX CONCURRENTLY IF NOT EXISTS ${plainIdx} ON ${qualifiedName} (${colName})`).execute(ddlDb);
+            await sql6.raw(`CREATE INDEX CONCURRENTLY IF NOT EXISTS ${plainIdx} ON ${qualifiedName} (${colName})`).execute(ddlDb);
           } else if (!now.indexed && was?.indexed) {
-            await sql5.raw(`DROP INDEX CONCURRENTLY IF EXISTS ${schemaName}.${plainIdx}`).execute(ddlDb);
+            await sql6.raw(`DROP INDEX CONCURRENTLY IF EXISTS ${schemaName}.${plainIdx}`).execute(ddlDb);
           }
           if (now.search && !was?.search) {
-            await sql5.raw(`CREATE INDEX CONCURRENTLY IF NOT EXISTS ${trgmIdx} ON ${qualifiedName} USING gin (${colName} gin_trgm_ops)`).execute(ddlDb);
+            await sql6.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 sql5.raw(`DROP INDEX CONCURRENTLY IF EXISTS ${schemaName}.${trgmIdx}`).execute(ddlDb);
+            await sql6.raw(`DROP INDEX CONCURRENTLY IF EXISTS ${schemaName}.${trgmIdx}`).execute(ddlDb);
           }
         }
       }
@@ -5452,28 +5699,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 sql5`
+          const exists = await sql6`
 						SELECT EXISTS (
 							SELECT 1 FROM pg_constraint
 							WHERE conname = ${constraintName}
 						) AS "exists"
 					`.execute(ddlDb).then((r) => r.rows[0]?.exists ?? false);
           if (!exists) {
-            await sql5.raw(`ALTER TABLE ${qualifiedName} ADD CONSTRAINT ${constraintName} UNIQUE (${cols.join(", ")})`).execute(ddlDb);
+            await sql6.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 sql5.raw(`CREATE INDEX CONCURRENTLY IF NOT EXISTS ${idxName} ON ${qualifiedName} (${cols.join(", ")})`).execute(ddlDb);
+          await sql6.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 sql5.raw(`DROP INDEX CONCURRENTLY IF EXISTS ${schemaName}.${idxName}`).execute(ddlDb);
+          await sql6.raw(`DROP INDEX CONCURRENTLY IF EXISTS ${schemaName}.${idxName}`).execute(ddlDb);
         }
       }
       const sg2 = await registerSubgraph(db, regData);
@@ -5499,7 +5746,7 @@ async function deploySchema(db, def, handlerPath, opts) {
     }
   }
   for (const stmt of statements) {
-    await sql5.raw(stmt).execute(ddlDb);
+    await sql6.raw(stmt).execute(ddlDb);
   }
   const sg = await registerSubgraph(db, regData);
   return { action: "created", subgraphId: sg.id, version: newVersion };
@@ -5544,11 +5791,12 @@ export {
   defineSubgraph,
   defineSchema,
   canSparseScan,
+  camelizeKeys,
   camelizeDataKey,
   backfillSubgraph,
   INDEX_CODEGEN_TABLES,
   ChainReadError
 };
 
-//# debugId=9E787D5A8AD21D8264756E2164756E21
+//# debugId=226325936FFF7D9F64756E2164756E21
 //# sourceMappingURL=index.js.map