@secondlayer/subgraphs 4.4.1 → 5.0.1

package/dist/src/runtime/reindex.js

@@ -1,4802 +0,0 @@
-import { createRequire } from "node:module";
-var __require = /* @__PURE__ */ createRequire(import.meta.url);
-
-// src/runtime/context.ts
-import { logger as logger2 } from "@secondlayer/shared/logger";
-import { formatUnits } from "@secondlayer/stacks/utils";
-import { sql } from "kysely";
-
-// src/schema/generator.ts
-import { createHash } from "node:crypto";
-
-// src/schema/utils.ts
-import { pgSchemaName } from "@secondlayer/shared/db/queries/subgraphs";
-function quotePgIdent(name) {
-  if (/^[a-z_][a-z0-9_]*$/i.test(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 = {
-  text: "TEXT",
-  uint: "NUMERIC",
-  int: "NUMERIC",
-  principal: "TEXT",
-  boolean: "BOOLEAN",
-  timestamp: "TIMESTAMPTZ",
-  jsonb: "JSONB"
-};
-var MAX_IDENT_BYTES = 63;
-function safeIndexName(name) {
-  if (name.length <= MAX_IDENT_BYTES)
-    return name;
-  const hash = createHash("sha256").update(name).digest("hex").slice(0, 8);
-  return `${name.slice(0, MAX_IDENT_BYTES - hash.length - 1)}_${hash}`;
-}
-function emitIndexedColumnIndexDDL(schemaName, tableName, colName, opts) {
-  const concurrently = opts?.concurrently ? " CONCURRENTLY" : "";
-  const qualified = `${quotePgIdent(schemaName)}.${quotePgIdent(tableName)}`;
-  const plain = `idx_${schemaName}_${tableName}_${colName}`;
-  const composite = safeIndexName(`idx_${schemaName}_${tableName}_${colName}_id`);
-  const col = quotePgIdent(colName);
-  const id = quotePgIdent("_id");
-  return {
-    create: [
-      `CREATE INDEX${concurrently} IF NOT EXISTS ${quotePgIdent(plain)} ON ${qualified} (${col})`,
-      `CREATE INDEX${concurrently} IF NOT EXISTS ${quotePgIdent(composite)} ON ${qualified} (${col}, ${id})`
-    ],
-    drop: [
-      `DROP INDEX${concurrently} IF EXISTS ${quotePgIdent(schemaName)}.${quotePgIdent(plain)}`,
-      `DROP INDEX${concurrently} IF EXISTS ${quotePgIdent(schemaName)}.${quotePgIdent(composite)}`
-    ]
-  };
-}
-function escapeLiteralDefault(value) {
-  if (value === null || value === undefined)
-    return "NULL";
-  if (typeof value === "number" || typeof value === "bigint")
-    return String(value);
-  if (typeof value === "boolean")
-    return value ? "TRUE" : "FALSE";
-  return `'${String(value).replace(/'/g, "''")}'`;
-}
-function tableNeedsTrgm(tableDef) {
-  return Object.values(tableDef.columns).some((col) => col.search);
-}
-function emitTableDDL(schemaName, tableName, tableDef) {
-  const qualifiedName = `${quotePgIdent(schemaName)}.${quotePgIdent(tableName)}`;
-  const statements = [];
-  const columnDefs = [
-    "_id BIGSERIAL PRIMARY KEY",
-    "_block_height BIGINT NOT NULL",
-    "_tx_id TEXT NOT NULL",
-    "_created_at TIMESTAMPTZ NOT NULL DEFAULT NOW()"
-  ];
-  for (const [colName, col] of Object.entries(tableDef.columns)) {
-    const sqlType = TYPE_MAP[col.type];
-    const nullable = col.nullable ? "" : " NOT NULL";
-    let colDef = `${quotePgIdent(colName)} ${sqlType}${nullable}`;
-    if (col.default !== undefined) {
-      colDef += ` DEFAULT ${escapeLiteralDefault(col.default)}`;
-    }
-    if (col.type === "uint") {
-      colDef += ` CHECK (${quotePgIdent(colName)} >= 0)`;
-    }
-    columnDefs.push(colDef);
-  }
-  statements.push(`CREATE TABLE IF NOT EXISTS ${qualifiedName} (
-  ${columnDefs.join(`,
-  `)}
-)`);
-  statements.push(`CREATE INDEX IF NOT EXISTS ${quotePgIdent(`idx_${schemaName}_${tableName}_block_height`)} ON ${qualifiedName} (_block_height)`);
-  statements.push(`CREATE INDEX IF NOT EXISTS ${quotePgIdent(`idx_${schemaName}_${tableName}_tx_id`)} ON ${qualifiedName} (_tx_id)`);
-  for (const [colName, col] of Object.entries(tableDef.columns)) {
-    if (col.indexed) {
-      statements.push(...emitIndexedColumnIndexDDL(schemaName, tableName, colName).create);
-    }
-  }
-  for (const [colName, col] of Object.entries(tableDef.columns)) {
-    if (col.search) {
-      statements.push(`CREATE INDEX IF NOT EXISTS ${quotePgIdent(`idx_${schemaName}_${tableName}_${colName}_trgm`)} ON ${qualifiedName} USING gin (${quotePgIdent(colName)} gin_trgm_ops)`);
-    }
-  }
-  if (tableDef.indexes) {
-    for (let i = 0;i < tableDef.indexes.length; i++) {
-      const cols = tableDef.indexes[i];
-      const idxName = quotePgIdent(`idx_${schemaName}_${tableName}_composite_${i}`);
-      statements.push(`CREATE INDEX IF NOT EXISTS ${idxName} ON ${qualifiedName} (${cols.map(quotePgIdent).join(", ")})`);
-    }
-  }
-  if (tableDef.uniqueKeys) {
-    for (let i = 0;i < tableDef.uniqueKeys.length; i++) {
-      const cols = tableDef.uniqueKeys[i];
-      const constraintName = quotePgIdent(`uq_${schemaName}_${tableName}_${cols.join("_")}`);
-      statements.push(`ALTER TABLE ${qualifiedName} ADD CONSTRAINT ${constraintName} UNIQUE (${cols.map(quotePgIdent).join(", ")})`);
-    }
-  }
-  return statements;
-}
-function emitJournalDDL(schemaName) {
-  return [
-    `CREATE TABLE IF NOT EXISTS ${schemaName}._journal (
-  _jid BIGSERIAL PRIMARY KEY,
-  block_height BIGINT NOT NULL,
-  table_name TEXT NOT NULL,
-  row_key JSONB NOT NULL,
-  prev_row JSONB,
-  _created_at TIMESTAMPTZ NOT NULL DEFAULT NOW()
-)`,
-    `CREATE INDEX IF NOT EXISTS idx_${schemaName}_journal_height ON ${schemaName}._journal (block_height)`
-  ];
-}
-function emitFactoryDDL(schemaName) {
-  return [
-    `CREATE TABLE IF NOT EXISTS ${schemaName}._factory_addresses (
-  source_name TEXT NOT NULL,
-  address TEXT NOT NULL,
-  block_height BIGINT NOT NULL,
-  _created_at TIMESTAMPTZ NOT NULL DEFAULT NOW(),
-  PRIMARY KEY (source_name, address)
-)`,
-    `CREATE INDEX IF NOT EXISTS idx_${schemaName}_factory_height ON ${schemaName}._factory_addresses (block_height)`
-  ];
-}
-function emitForeignKeyDDL(schemaName, tableName, tableDef) {
-  return (tableDef.relations ?? []).map((rel) => {
-    const constraintName = quotePgIdent(`fk_${schemaName}_${tableName}_${rel.name}`);
-    return `ALTER TABLE ${quotePgIdent(schemaName)}.${quotePgIdent(tableName)} ADD CONSTRAINT ${constraintName} ` + `FOREIGN KEY (${rel.fields.map(quotePgIdent).join(", ")}) ` + `REFERENCES ${quotePgIdent(schemaName)}.${quotePgIdent(rel.references)} (${rel.referencedColumns.map(quotePgIdent).join(", ")})`;
-  });
-}
-function generateSubgraphSQL(def, schemaNameOverride) {
-  const schemaName = schemaNameOverride ?? pgSchemaName(def.name);
-  const statements = [];
-  const needsTrgm = Object.values(def.schema).some((table) => Object.values(table.columns).some((col) => col.search));
-  if (needsTrgm) {
-    statements.push("CREATE EXTENSION IF NOT EXISTS pg_trgm");
-  }
-  statements.push(`CREATE SCHEMA IF NOT EXISTS ${schemaName}`);
-  for (const [tableName, tableDef] of Object.entries(def.schema)) {
-    statements.push(...emitTableDDL(schemaName, tableName, tableDef));
-  }
-  statements.push(...emitJournalDDL(schemaName));
-  if (Object.values(def.sources ?? {}).some((src) => src.factory !== undefined)) {
-    statements.push(...emitFactoryDDL(schemaName));
-  }
-  for (const [tableName, tableDef] of Object.entries(def.schema)) {
-    statements.push(...emitForeignKeyDDL(schemaName, tableName, tableDef));
-  }
-  const hashInput = JSON.stringify({
-    name: def.name,
-    schema: def.schema,
-    sources: def.sources
-  }, (_key, value) => typeof value === "bigint" ? value.toString() : value);
-  const hash = createHash("sha256").update(hashInput).digest("hex");
-  return { statements, hash };
-}
-
-// src/runtime/chain-read.ts
-import { getSourceDb } from "@secondlayer/shared/db";
-import { logger } from "@secondlayer/shared/logger";
-import { http, createPublicClient } from "@secondlayer/stacks";
-import {
-  ContractResponseError,
-  buildFunctionArgs,
-  isResponseOutput,
-  readContract
-} from "@secondlayer/stacks/actions";
-import {
-  clarityValueToJSUntyped,
-  deserializeCV,
-  normalizeAbi,
-  serializeCV,
-  toCamelCase
-} from "@secondlayer/stacks/clarity";
-function readContractAt(ctx, contractId, abi, options) {
-  return ctx.client.contract(contractId, abi, options);
-}
-
-class ChainReadError extends Error {
-  name = "ChainReadError";
-}
-function nodeClient(rpcUrl) {
-  return createPublicClient({
-    transport: http(rpcUrl, { retryCount: 0, timeout: 1e4 })
-  });
-}
-
-class ConcurrencyGate {
-  limit;
-  active = 0;
-  queue = [];
-  constructor(limit) {
-    this.limit = limit;
-  }
-  async run(fn) {
-    if (this.active >= this.limit) {
-      await new Promise((resolve) => this.queue.push(resolve));
-    }
-    this.active++;
-    try {
-      return await fn();
-    } finally {
-      this.active--;
-      this.queue.shift()?.();
-    }
-  }
-}
-var DEFAULT_MAX_CONCURRENT_READS = 4;
-function maxConcurrentReads() {
-  const raw = process.env.SUBGRAPH_CHAIN_READ_CONCURRENCY;
-  const parsed = raw ? Number.parseInt(raw, 10) : Number.NaN;
-  return Number.isFinite(parsed) && parsed > 0 ? parsed : DEFAULT_MAX_CONCURRENT_READS;
-}
-var gate = new ConcurrencyGate(maxConcurrentReads());
-function hashArgs(args) {
-  const serialized = args.map((arg) => serializeCV(arg)).join(",");
-  return Bun.hash(serialized).toString(16);
-}
-function findFunction(abi, name) {
-  const fn = abi.functions.find((f) => f.name === name);
-  if (!fn) {
-    throw new ChainReadError(`No function "${name}" in the supplied ABI.`);
-  }
-  if (fn.access !== "read-only") {
-    throw new ChainReadError(`"${name}" is ${fn.access}, not read-only — a handler cannot call it.`);
-  }
-  return fn;
-}
-function createChainReadClient(ctx) {
-  const readValue = async (contractId, abi, functionName, args, options) => {
-    const rpcUrl = ctx.rpcUrl ?? process.env.STACKS_NODE_RPC_URL;
-    if (!rpcUrl) {
-      throw new ChainReadError("ctx.client needs a Stacks node: set STACKS_NODE_RPC_URL on the subgraph processor.");
-    }
-    const constant = options.cache === "contract-constant";
-    if (!constant && !ctx.indexBlockHash) {
-      throw new ChainReadError(`Block ${ctx.blockHeight} has no index_block_hash, so a read cannot be pinned to it. Reading at the node's tip would make this handler non-deterministic (the same reindex would produce different rows). Re-ingest the block, or pass cache: "contract-constant" if the value genuinely cannot change.`);
-    }
-    const fn = findFunction(abi, functionName);
-    const clarityArgs = buildFunctionArgs(fn, args);
-    const db = ctx.db ?? getSourceDb();
-    const argsHash = hashArgs(clarityArgs);
-    const pinnedTo = constant ? null : ctx.indexBlockHash;
-    const cached = await db.selectFrom("chain_read_cache").select("result_hex").where("contract_id", "=", contractId).where("function_name", "=", fn.name).where("args_hash", "=", argsHash).where((eb) => pinnedTo === null ? eb("index_block_hash", "is", null) : eb("index_block_hash", "=", pinnedTo)).executeTakeFirst();
-    const resultHex = cached?.result_hex ?? await gate.run(async () => {
-      if (!ctx.indexBlockHash) {
-        logger.warn("Chain read is not pinned to a block (no index_block_hash)", {
-          contractId,
-          functionName: fn.name,
-          blockHeight: ctx.blockHeight,
-          note: 'cache: "contract-constant" asserts this value cannot change; the node answered at its own tip'
-        });
-      }
-      const value2 = await readContract(nodeClient(rpcUrl), {
-        contract: contractId,
-        functionName: fn.name,
-        args: clarityArgs,
-        tip: ctx.indexBlockHash ?? undefined
-      });
-      return serializeCV(value2);
-    });
-    if (!cached) {
-      await db.insertInto("chain_read_cache").values({
-        contract_id: contractId,
-        function_name: fn.name,
-        args_hash: argsHash,
-        index_block_hash: pinnedTo,
-        block_height: constant ? null : ctx.blockHeight,
-        result_hex: resultHex
-      }).onConflict((oc) => oc.doNothing()).execute();
-    }
-    const value = deserializeCV(resultHex);
-    const js = clarityValueToJSUntyped(fn.outputs, value);
-    if (isResponseOutput(fn.outputs)) {
-      const response = js;
-      if ("ok" in response)
-        return response.ok;
-      throw new ContractResponseError(`${contractId}::${fn.name} returned an err response.`, response.err);
-    }
-    return js;
-  };
-  return {
-    contract(contractId, rawAbi, options = {}) {
-      const abi = normalizeAbi(rawAbi);
-      const camelToKebab = new Map;
-      for (const fn of abi.functions) {
-        camelToKebab.set(toCamelCase(fn.name), fn.name);
-      }
-      const read = new Proxy({}, {
-        get(_target, prop) {
-          const fnName = camelToKebab.get(prop) ?? prop;
-          return (args = {}) => readValue(contractId, abi, fnName, args, options);
-        }
-      });
-      return { read };
-    }
-  };
-}
-
-// src/runtime/context.ts
-var JOURNAL_RETENTION_BLOCKS = 300;
-var journalEnsured = new Set;
-function validateColumnName(name) {
-  if (!/^[a-z_][a-z0-9_]*$/i.test(name)) {
-    throw new Error(`Invalid column name: ${name}`);
-  }
-}
-
-class SubgraphContext {
-  block;
-  _tx;
-  db;
-  pgSchemaName;
-  subgraphSchema;
-  ops = [];
-  journal;
-  _client;
-  constructor(db, pgSchemaName2, subgraphSchema, block, tx, journal = false) {
-    this.db = db;
-    this.pgSchemaName = pgSchemaName2;
-    this.subgraphSchema = subgraphSchema;
-    this.block = block;
-    this._tx = tx;
-    this.journal = journal;
-  }
-  get client() {
-    this._client ??= createChainReadClient({
-      blockHeight: this.block.height,
-      indexBlockHash: this.block.indexBlockHash
-    });
-    return this._client;
-  }
-  get tx() {
-    return this._tx;
-  }
-  setTx(tx) {
-    this._tx = tx;
-  }
-  insert(table, row) {
-    this.validateTable(table);
-    this.ops.push({
-      kind: "insert",
-      table,
-      data: { ...row, _block_height: this.block.height, _tx_id: this._tx.txId }
-    });
-  }
-  update(table, where, set) {
-    this.validateTable(table);
-    this.ops.push({ kind: "update", table, data: where, set });
-  }
-  upsert(table, key, row) {
-    this.validateTable(table);
-    const tableDef = this.subgraphSchema[table];
-    if (!tableDef)
-      return;
-    const keyColumns = Object.keys(key);
-    const hasUniqueConstraint = tableDef.uniqueKeys?.some((uk) => uk.length === keyColumns.length && uk.every((c) => keyColumns.includes(c)));
-    const meta = { _block_height: this.block.height, _tx_id: this._tx.txId };
-    if (hasUniqueConstraint) {
-      this.ops.push({
-        kind: "insert",
-        table,
-        data: { ...key, ...row, ...meta, _upsert_keys: keyColumns }
-      });
-    } else {
-      logger2.warn("upsert called without matching uniqueKeys constraint, using fallback", {
-        table,
-        keys: keyColumns
-      });
-      this.ops.push({
-        kind: "insert",
-        table,
-        data: {
-          ...key,
-          ...row,
-          ...meta,
-          _upsert_fallback_keys: keyColumns,
-          _upsert_fallback_set: row
-        }
-      });
-    }
-  }
-  delete(table, where) {
-    this.validateTable(table);
-    this.ops.push({ kind: "delete", table, data: where });
-  }
-  increment(table, key, deltas) {
-    this.validateTable(table);
-    const tableDef = this.subgraphSchema[table];
-    const keyColumns = Object.keys(key);
-    const hasUniqueConstraint = tableDef?.uniqueKeys?.some((uk) => uk.length === keyColumns.length && uk.every((c) => keyColumns.includes(c)));
-    if (!hasUniqueConstraint) {
-      throw new Error(`increment("${table}") requires a uniqueKeys constraint on [${keyColumns.join(", ")}]`);
-    }
-    for (const [col, v] of Object.entries(deltas)) {
-      validateColumnName(col);
-      if (keyColumns.includes(col)) {
-        throw new Error(`increment("${table}"): "${col}" is a key column`);
-      }
-      if (typeof v !== "bigint" && typeof v !== "number") {
-        throw new Error(`increment("${table}"): delta for "${col}" must be bigint or number`);
-      }
-    }
-    this.ops.push({
-      kind: "increment",
-      table,
-      data: {
-        ...key,
-        _block_height: this.block.height,
-        _tx_id: this._tx.txId,
-        _upsert_keys: keyColumns
-      },
-      set: { ...deltas }
-    });
-  }
-  opsCheckpoint() {
-    return this.ops.length;
-  }
-  rollbackTo(checkpoint) {
-    if (checkpoint < 0 || checkpoint > this.ops.length)
-      return;
-    this.ops.length = checkpoint;
-  }
-  patch(table, where, set) {
-    this.update(table, where, set);
-  }
-  async patchOrInsert(table, key, row) {
-    const existing = await this.findOne(table, key);
-    const resolved = {};
-    for (const [k, v] of Object.entries(row)) {
-      resolved[k] = typeof v === "function" ? v(existing) : v;
-    }
-    this.upsert(table, key, resolved);
-  }
-  formatUnits(value, decimals) {
-    return formatUnits(value, decimals);
-  }
-  async readRows(table, where, limit) {
-    const qualifiedTable = `"${this.pgSchemaName}"."${table}"`;
-    const { clause } = buildWhereClause(where);
-    const query = `SELECT * FROM ${qualifiedTable} WHERE ${clause}${limit !== undefined ? ` LIMIT ${limit}` : ""}`;
-    const { rows } = await sql.raw(query).execute(this.db);
-    return rows.map((r) => this.coerceRow(table, r));
-  }
-  async findOne(table, where) {
-    this.validateTable(table);
-    const row = (await this.readRows(table, where, 1))[0] ?? null;
-    return this.overlayOne(table, where, row);
-  }
-  async findMany(table, where) {
-    this.validateTable(table);
-    return this.overlayMany(table, where, await this.readRows(table, where));
-  }
-  overlayOne(table, where, dbRow) {
-    if (this.ops.length === 0)
-      return dbRow;
-    let row = dbRow;
-    for (const op of this.ops) {
-      if (op.table !== table)
-        continue;
-      row = this.applyOpToRow(op, row, where);
-    }
-    return row;
-  }
-  overlayMany(table, where, dbRows) {
-    if (this.ops.length === 0)
-      return [...dbRows];
-    let result = [...dbRows];
-    for (const op of this.ops) {
-      if (op.table !== table)
-        continue;
-      if (op.kind === "update") {
-        for (let i = 0;i < result.length; i++) {
-          if (rowMatches(result[i], op.data))
-            result[i] = { ...result[i], ...op.set ?? {} };
-        }
-      } else if (op.kind === "delete") {
-        result = result.filter((r) => !rowMatches(r, op.data));
-      } else {
-        const upsertKeys = op.data._upsert_keys;
-        const clean = stripControlKeys(op.data);
-        const idx = upsertKeys ? result.findIndex((r) => upsertKeys.every((k) => valEq(r[k], clean[k]))) : -1;
-        if (idx >= 0) {
-          const existing = result[idx];
-          result[idx] = this.applyOpToRow(op, existing, where) ?? existing;
-        } else {
-          const created = this.applyOpToRow(op, null, where);
-          if (created)
-            result.push(created);
-        }
-      }
-    }
-    return result;
-  }
-  applyOpToRow(op, row, where) {
-    const upsertKeys = op.data._upsert_keys;
-    const clean = stripControlKeys(op.data);
-    switch (op.kind) {
-      case "insert": {
-        if (row) {
-          if (upsertKeys?.every((k) => valEq(row[k], clean[k]))) {
-            const merged = { ...row };
-            for (const [k, v] of Object.entries(clean)) {
-              if (!upsertKeys.includes(k) && !k.startsWith("_"))
-                merged[k] = v;
-            }
-            return merged;
-          }
-          return row;
-        }
-        return rowMatches(clean, where) ? { ...clean } : null;
-      }
-      case "increment": {
-        const deltas = op.set ?? {};
-        if (row) {
-          if (upsertKeys.every((k) => valEq(row[k], clean[k]))) {
-            const merged = { ...row };
-            for (const [col, d] of Object.entries(deltas)) {
-              merged[col] = toBigIntOr0(merged[col]) + toBigIntOr0(d);
-            }
-            return merged;
-          }
-          return row;
-        }
-        if (!rowMatches(clean, where))
-          return null;
-        const created = { ...clean };
-        for (const [col, d] of Object.entries(deltas)) {
-          created[col] = toBigIntOr0(d);
-        }
-        return created;
-      }
-      case "update":
-        return row && rowMatches(row, op.data) ? { ...row, ...op.set ?? {} } : row;
-      case "delete":
-        return row && rowMatches(row, op.data) ? null : row;
-    }
-  }
-  async count(table, where) {
-    this.validateTable(table);
-    const qualifiedTable = `"${this.pgSchemaName}"."${table}"`;
-    const whereClause = where ? `WHERE ${buildWhereClause(where).clause}` : "";
-    const { rows } = await sql.raw(`SELECT COUNT(*)::int AS count FROM ${qualifiedTable} ${whereClause}`).execute(this.db);
-    return Number(rows[0]?.count ?? 0);
-  }
-  async sum(table, column, where) {
-    this.validateTable(table);
-    validateColumnName(column);
-    const qualifiedTable = `"${this.pgSchemaName}"."${table}"`;
-    const whereClause = where ? `WHERE ${buildWhereClause(where).clause}` : "";
-    const { rows } = await sql.raw(`SELECT COALESCE(SUM("${column}"), 0) AS total FROM ${qualifiedTable} ${whereClause}`).execute(this.db);
-    return BigInt(rows[0]?.total?.toString() ?? "0");
-  }
-  async min(table, column, where) {
-    this.validateTable(table);
-    validateColumnName(column);
-    const qualifiedTable = `"${this.pgSchemaName}"."${table}"`;
-    const whereClause = where ? `WHERE ${buildWhereClause(where).clause}` : "";
-    const { rows } = await sql.raw(`SELECT MIN("${column}") AS val FROM ${qualifiedTable} ${whereClause}`).execute(this.db);
-    const val = rows[0]?.val;
-    return val != null ? BigInt(val.toString()) : null;
-  }
-  async max(table, column, where) {
-    this.validateTable(table);
-    validateColumnName(column);
-    const qualifiedTable = `"${this.pgSchemaName}"."${table}"`;
-    const whereClause = where ? `WHERE ${buildWhereClause(where).clause}` : "";
-    const { rows } = await sql.raw(`SELECT MAX("${column}") AS val FROM ${qualifiedTable} ${whereClause}`).execute(this.db);
-    const val = rows[0]?.val;
-    return val != null ? BigInt(val.toString()) : null;
-  }
-  async countDistinct(table, column, where) {
-    this.validateTable(table);
-    validateColumnName(column);
-    const qualifiedTable = `"${this.pgSchemaName}"."${table}"`;
-    const whereClause = where ? `WHERE ${buildWhereClause(where).clause}` : "";
-    const { rows } = await sql.raw(`SELECT COUNT(DISTINCT "${column}")::int AS count FROM ${qualifiedTable} ${whereClause}`).execute(this.db);
-    return Number(rows[0]?.count ?? 0);
-  }
-  coerceRow(table, row) {
-    const tableDef = this.subgraphSchema[table];
-    if (!tableDef)
-      return row;
-    const result = { ...row };
-    for (const [col, def] of Object.entries(tableDef.columns)) {
-      if ((def.type === "uint" || def.type === "int") && typeof result[col] === "string") {
-        result[col] = BigInt(result[col]);
-      }
-    }
-    return result;
-  }
-  get pendingOps() {
-    return this.ops.length;
-  }
-  async flush() {
-    if (this.ops.length === 0)
-      return { count: 0, writes: [] };
-    await this.ensureJournalTable();
-    const opsToFlush = [...this.ops];
-    this.ops.length = 0;
-    const statements = this.buildStatements(opsToFlush);
-    if ("isTransaction" in this.db) {
-      await this.execStatements(this.db, statements);
-    } else {
-      await this.db.transaction().execute(async (tx) => {
-        await this.execStatements(tx, statements);
-      });
-    }
-    const writes = opsToFlush.map((op, rowIndex) => {
-      const blockHeight = op.data._block_height ?? this.block.height;
-      const txId = op.data._tx_id ?? this._tx.txId;
-      const baseRow = op.kind === "update" || op.kind === "increment" ? { ...op.data, ...op.set ?? {} } : { ...op.data };
-      baseRow._upsert_keys = undefined;
-      baseRow._upsert_fallback_keys = undefined;
-      baseRow._upsert_fallback_set = undefined;
-      return {
-        op: op.kind === "increment" ? "update" : op.kind,
-        table: op.table,
-        row: jsonSafe(baseRow),
-        pk: { blockHeight, txId, rowIndex }
-      };
-    });
-    return { count: opsToFlush.length, writes };
-  }
-  async execStatements(executor, statements) {
-    const affected = (r) => r.numAffectedRows ?? 0n;
-    for (const stmt of statements) {
-      if (typeof stmt === "string") {
-        await sql.raw(stmt).execute(executor);
-        continue;
-      }
-      const updated = await sql.raw(stmt.update).execute(executor);
-      if (affected(updated) > 0n)
-        continue;
-      const inserted = await sql.raw(stmt.insert).execute(executor);
-      if (affected(inserted) > 0n)
-        continue;
-      const retried = await sql.raw(stmt.update).execute(executor);
-      if (affected(retried) === 0n) {
-        throw new Error(`increment could not be applied to ${this.pgSchemaName}.${stmt.table} where ${stmt.keyPred}: row neither updated nor inserted`);
-      }
-    }
-  }
-  prepareInsert(op) {
-    const upsertKeys = op.data._upsert_keys;
-    const data = { ...op.data };
-    delete data._upsert_keys;
-    delete data._upsert_fallback_keys;
-    delete data._upsert_fallback_set;
-    if (!data._block_height)
-      data._block_height = this.block.height;
-    if (!data._tx_id)
-      data._tx_id = this._tx.txId;
-    data._created_at = "NOW()";
-    const cols = Object.keys(data);
-    cols.forEach(validateColumnName);
-    const vals = cols.map((c) => data[c] === "NOW()" ? "NOW()" : escapeLiteral(data[c]));
-    const batchKey = `${op.table}:${[...cols].sort().join(",")}:${upsertKeys ? [...upsertKeys].sort().join(",") : ""}`;
-    return { data, cols, vals, upsertKeys, batchKey };
-  }
-  async ensureJournalTable() {
-    if (!this.journal || journalEnsured.has(this.pgSchemaName))
-      return;
-    const { rows } = await sql.raw(`SELECT to_regclass('"${this.pgSchemaName}"."_journal"') AS r`).execute(this.db);
-    if (rows[0]?.r) {
-      journalEnsured.add(this.pgSchemaName);
-      return;
-    }
-    for (const stmt of emitJournalDDL(this.pgSchemaName)) {
-      await sql.raw(stmt).execute(this.db);
-    }
-  }
-  columnSqlType(table, col) {
-    const def = this.subgraphSchema[table]?.columns?.[col];
-    return def ? TYPE_MAP[def.type] : undefined;
-  }
-  journalCaptureSQL(table, keyCols, keyLiteralRows) {
-    const cast = (col, expr) => {
-      const t = this.columnSqlType(table, col);
-      return t ? `CAST(${expr} AS ${t})` : expr;
-    };
-    const keyObj = keyCols.map((k) => `'${k}', ${cast(k, `v."${k}"`)}`).join(", ");
-    const joinCond = keyCols.map((k) => `t."${k}" = ${cast(k, `v."${k}"`)}`).join(" AND ");
-    const valuesList = keyLiteralRows.map((r) => `(${r.join(", ")})`).join(", ");
-    return `INSERT INTO "${this.pgSchemaName}"."_journal" ("block_height", "table_name", "row_key", "prev_row") ` + `SELECT ${this.block.height}, '${table}', jsonb_build_object(${keyObj}), to_jsonb(t.*) ` + `FROM (VALUES ${valuesList}) AS v(${keyCols.map((k) => `"${k}"`).join(", ")}) ` + `LEFT JOIN "${this.pgSchemaName}"."${table}" t ON ${joinCond}`;
-  }
-  journalCaptureByWhereSQL(table, clause) {
-    return `INSERT INTO "${this.pgSchemaName}"."_journal" ("block_height", "table_name", "row_key", "prev_row") ` + `SELECT ${this.block.height}, '${table}', jsonb_build_object('_id', t."_id"), to_jsonb(t.*) ` + `FROM "${this.pgSchemaName}"."${table}" t WHERE ${clause}`;
-  }
-  buildStatements(ops) {
-    const statements = [];
-    let currentBatch = null;
-    let currentBatchKey = "";
-    let incBatch = null;
-    let incBatchKey = "";
-    const flushIncrementBatch = () => {
-      if (!incBatch)
-        return;
-      const batch = incBatch;
-      const qualifiedTable = `"${this.pgSchemaName}"."${batch.table}"`;
-      const cols = [
-        ...batch.keyCols,
-        ...batch.deltaCols,
-        "_block_height",
-        "_tx_id",
-        "_created_at"
-      ];
-      if (this.journal) {
-        statements.push(this.journalCaptureSQL(batch.table, batch.keyCols, Array.from(batch.rows.values()).map((r) => batch.keyCols.map((k) => escapeLiteral(r.keys[k])))));
-      }
-      for (const r of batch.rows.values()) {
-        const keyPred = batch.keyCols.map((k) => `"${k}" = ${escapeLiteral(r.keys[k])}`).join(" AND ");
-        const updSet = batch.deltaCols.map((c) => `"${c}" = COALESCE("${c}", 0) + (${String(r.deltas[c] ?? 0n)})`).join(", ");
-        const insertVals = [
-          ...batch.keyCols.map((k) => escapeLiteral(r.keys[k])),
-          ...batch.deltaCols.map((c) => String(r.deltas[c] ?? 0n)),
-          escapeLiteral(r.meta.blockHeight),
-          escapeLiteral(r.meta.txId),
-          "NOW()"
-        ];
-        statements.push({
-          kind: "increment",
-          table: batch.table,
-          keyPred,
-          update: `UPDATE ${qualifiedTable} SET ${updSet} WHERE ${keyPred}`,
-          insert: `INSERT INTO ${qualifiedTable} (${cols.map((c) => `"${c}"`).join(", ")}) ` + `SELECT ${insertVals.join(", ")} ` + `WHERE NOT EXISTS (SELECT 1 FROM ${qualifiedTable} WHERE ${keyPred})`
-        });
-      }
-      incBatch = null;
-      incBatchKey = "";
-    };
-    const flushInsertBatch = () => {
-      if (!currentBatch)
-        return;
-      const batch = currentBatch;
-      const qualifiedTable = `"${this.pgSchemaName}"."${batch.table}"`;
-      const colList = batch.cols.map((c) => `"${c}"`).join(", ");
-      let rows = batch.rows;
-      if (batch.upsertKeys && batch.upsertKeys.length > 0) {
-        const uKeys = batch.upsertKeys;
-        const keyIndices = uKeys.map((k) => batch.cols.indexOf(k));
-        const seen = new Map;
-        for (let i = 0;i < rows.length; i++) {
-          const key = keyIndices.map((ki) => rows[i][ki]).join("\x00");
-          seen.set(key, i);
-        }
-        if (seen.size < rows.length) {
-          rows = Array.from(seen.values()).map((i) => rows[i]);
-        }
-      }
-      const valuesList = rows.map((r) => `(${r.join(", ")})`).join(", ");
-      let stmt = `INSERT INTO ${qualifiedTable} (${colList}) VALUES ${valuesList}`;
-      if (this.journal && batch.upsertKeys && batch.upsertKeys.length > 0) {
-        const uKeys = batch.upsertKeys;
-        const keyIndices = uKeys.map((k) => batch.cols.indexOf(k));
-        statements.push(this.journalCaptureSQL(batch.table, uKeys, rows.map((r) => keyIndices.map((ki) => r[ki]))));
-      }
-      if (batch.upsertKeys && batch.upsertKeys.length > 0) {
-        const batchKeys = batch.upsertKeys;
-        const updateCols = batch.cols.filter((c) => !batchKeys.includes(c) && !c.startsWith("_"));
-        if (updateCols.length > 0) {
-          const setClauses = updateCols.map((c) => `"${c}" = EXCLUDED."${c}"`);
-          stmt += ` ON CONFLICT (${batchKeys.map((k) => `"${k}"`).join(", ")}) DO UPDATE SET ${setClauses.join(", ")}`;
-        } else {
-          stmt += ` ON CONFLICT (${batchKeys.map((k) => `"${k}"`).join(", ")}) DO NOTHING`;
-        }
-      }
-      statements.push(stmt);
-      currentBatch = null;
-      currentBatchKey = "";
-    };
-    for (const op of ops) {
-      const qualifiedTable = `"${this.pgSchemaName}"."${op.table}"`;
-      if (op.kind === "insert") {
-        flushIncrementBatch();
-        const { cols, vals, upsertKeys, batchKey } = this.prepareInsert(op);
-        if (batchKey === currentBatchKey && currentBatch) {
-          currentBatch.rows.push(vals);
-        } else {
-          flushInsertBatch();
-          currentBatch = { table: op.table, cols, rows: [vals], upsertKeys };
-          currentBatchKey = batchKey;
-        }
-      } else if (op.kind === "increment") {
-        flushInsertBatch();
-        const keyCols = [...op.data._upsert_keys].sort();
-        const deltaCols = Object.keys(op.set ?? {}).sort();
-        const batchKey = `inc:${op.table}:${keyCols.join(",")}:${deltaCols.join(",")}`;
-        if (batchKey !== incBatchKey || !incBatch) {
-          flushIncrementBatch();
-          incBatch = { table: op.table, keyCols, deltaCols, rows: new Map };
-          incBatchKey = batchKey;
-        }
-        const clean = stripControlKeys(op.data);
-        const keySig = keyCols.map((k) => escapeLiteral(clean[k])).join("\x00");
-        const existing = incBatch.rows.get(keySig);
-        if (existing) {
-          for (const c of deltaCols) {
-            existing.deltas[c] = (existing.deltas[c] ?? 0n) + toBigIntOr0(op.set?.[c]);
-          }
-        } else {
-          const deltas = {};
-          for (const c of deltaCols)
-            deltas[c] = toBigIntOr0(op.set?.[c]);
-          incBatch.rows.set(keySig, {
-            keys: clean,
-            deltas,
-            meta: {
-              blockHeight: op.data._block_height ?? this.block.height,
-              txId: op.data._tx_id ?? this._tx.txId
-            }
-          });
-        }
-      } else {
-        flushInsertBatch();
-        flushIncrementBatch();
-        if (op.kind === "update") {
-          const setEntries = Object.entries(op.set ?? {});
-          for (const [k] of setEntries)
-            validateColumnName(k);
-          const setClauses = setEntries.map(([k, v]) => `"${k}" = ${escapeLiteral(v)}`);
-          const { clause } = buildWhereClause(op.data);
-          if (this.journal) {
-            statements.push(this.journalCaptureByWhereSQL(op.table, clause));
-          }
-          statements.push(`UPDATE ${qualifiedTable} SET ${setClauses.join(", ")} WHERE ${clause}`);
-        } else if (op.kind === "delete") {
-          const { clause } = buildWhereClause(op.data);
-          if (this.journal) {
-            statements.push(this.journalCaptureByWhereSQL(op.table, clause));
-          }
-          statements.push(`DELETE FROM ${qualifiedTable} WHERE ${clause}`);
-        }
-      }
-    }
-    flushInsertBatch();
-    flushIncrementBatch();
-    return statements;
-  }
-  validateTable(table) {
-    if (!this.subgraphSchema[table]) {
-      throw new Error(`Table "${table}" not found in subgraph schema. Available: [${Object.keys(this.subgraphSchema).join(", ")}]`);
-    }
-  }
-}
-function stripControlKeys(data) {
-  const {
-    _upsert_keys: _a,
-    _upsert_fallback_keys: _b,
-    _upsert_fallback_set: _c,
-    ...clean
-  } = data;
-  return clean;
-}
-function valEq(a, b) {
-  if (a === b)
-    return true;
-  if (a == null || b == null)
-    return false;
-  return String(a) === String(b);
-}
-function rowMatches(row, where) {
-  return Object.entries(where).every(([k, v]) => valEq(row[k], v));
-}
-function toBigIntOr0(v) {
-  if (typeof v === "bigint")
-    return v;
-  if (v == null)
-    return 0n;
-  try {
-    return BigInt(String(v));
-  } catch {
-    return 0n;
-  }
-}
-function jsonSafe(row) {
-  const out = {};
-  for (const [k, v] of Object.entries(row)) {
-    out[k] = typeof v === "bigint" ? v.toString() : v;
-  }
-  return out;
-}
-function escapeLiteral(value) {
-  if (value === null || value === undefined)
-    return "NULL";
-  if (typeof value === "number" || typeof value === "bigint")
-    return String(value);
-  if (typeof value === "boolean")
-    return value ? "TRUE" : "FALSE";
-  if (typeof value === "object")
-    return `'${JSON.stringify(value, (_k, v) => typeof v === "bigint" ? v.toString() : v).replace(/'/g, "''")}'::jsonb`;
-  return `'${String(value).replace(/'/g, "''")}'`;
-}
-function buildWhereClause(where) {
-  const entries = Object.entries(where);
-  if (entries.length === 0)
-    return { clause: "TRUE", values: [] };
-  for (const [k] of entries)
-    validateColumnName(k);
-  const parts = entries.map(([k, v]) => `"${k}" = ${escapeLiteral(v)}`);
-  return { clause: parts.join(" AND "), values: [] };
-}
-
-// src/runtime/clarity.ts
-import { cvToValue, deserializeCV as deserializeCV2 } from "@secondlayer/stacks/clarity";
-function decodeClarityValue(hex) {
-  try {
-    const cleanHex = hex.startsWith("0x") ? hex.slice(2) : hex;
-    const cv = deserializeCV2(cleanHex);
-    return cvToValue(cv);
-  } catch {
-    return hex;
-  }
-}
-function decodeEventData(data) {
-  if (typeof data === "string" && data.startsWith("0x") && data.length > 10) {
-    return decodeClarityValue(data);
-  }
-  if (Array.isArray(data)) {
-    return data.map(decodeEventData);
-  }
-  if (typeof data === "object" && data !== null) {
-    const decoded = {};
-    for (const [key, value] of Object.entries(data)) {
-      decoded[key] = decodeEventData(value);
-    }
-    return decoded;
-  }
-  return data;
-}
-function decodeFunctionArgs(args) {
-  return args.map(decodeClarityValue);
-}
-
-// src/runtime/source-matcher.ts
-var patternCache = new Map;
-function matchAny(value, pattern) {
-  return Array.isArray(pattern) ? pattern.some((p) => matchPattern(value, p)) : matchPattern(value, pattern);
-}
-function matchPattern(value, pattern) {
-  if (!pattern.includes("*"))
-    return value === pattern;
-  let re = patternCache.get(pattern);
-  if (!re) {
-    const regex = pattern.replace(/[.+^${}()|[\]\\]/g, "\\$&").replace(/\*/g, ".*");
-    re = new RegExp(`^${regex}$`);
-    patternCache.set(pattern, re);
-  }
-  return re.test(value);
-}
-var EMPTY_SET = new Set;
-function factoryAllows(filter, contractId, factoryContracts) {
-  if (!filter.factory)
-    return true;
-  if (!contractId)
-    return false;
-  return (factoryContracts.get(filter.factory.from) ?? EMPTY_SET).has(contractId);
-}
-function readPath(payload, path) {
-  let cur = payload;
-  for (const key of path.split(".")) {
-    if (cur === null || typeof cur !== "object")
-      return;
-    cur = cur[key];
-  }
-  return cur;
-}
-function traitAllows(filter, contractId, traitContracts) {
-  const trait = filter.trait;
-  if (!trait)
-    return true;
-  if (!contractId)
-    return false;
-  return (traitContracts.get(trait) ?? EMPTY_SET).has(contractId);
-}
-function assetContract(assetId) {
-  return assetId?.split("::")[0];
-}
-function printContractId(data) {
-  if (!data)
-    return;
-  const id = (typeof data.contract_identifier === "string" ? data.contract_identifier : undefined) ?? (typeof data.contract_id === "string" ? data.contract_id : undefined);
-  return id || undefined;
-}
-function matchFilter(filter, transactions, eventsByTx, traitContracts, factoryContracts = new Map, vmEventsByTx = new Map) {
-  const results = [];
-  switch (filter.type) {
-    case "stx_transfer":
-    case "stx_mint":
-    case "stx_burn":
-    case "stx_lock": {
-      const eventType = `${filter.type}_event`;
-      for (const tx of transactions) {
-        const txEvents = eventsByTx.get(tx.tx_id) ?? [];
-        const matched = txEvents.filter((e) => e.type === eventType);
-        if (matched.length === 0)
-          continue;
-        const filtered = matched.filter((e) => {
-          const data = e.data;
-          if (!data)
-            return false;
-          if ("sender" in filter && filter.sender) {
-            if (!matchPattern(data.sender, filter.sender))
-              return false;
-          }
-          if ("recipient" in filter && filter.recipient) {
-            if (!matchPattern(data.recipient, filter.recipient))
-              return false;
-          }
-          if ("lockedAddress" in filter && filter.lockedAddress) {
-            if (!matchPattern(data.locked_address, filter.lockedAddress))
-              return false;
-          }
-          if ("minAmount" in filter && filter.minAmount !== undefined) {
-            const amount = BigInt(data.amount ?? data.locked_amount ?? "0");
-            if (amount < filter.minAmount)
-              return false;
-          }
-          if ("maxAmount" in filter && filter.maxAmount !== undefined) {
-            const amount = BigInt(data.amount ?? "0");
-            if (amount > filter.maxAmount)
-              return false;
-          }
-          return true;
-        });
-        if (filtered.length > 0) {
-          results.push({ tx, events: filtered });
-        }
-      }
-      break;
-    }
-    case "ft_transfer":
-    case "ft_mint":
-    case "ft_burn": {
-      const eventType = `${filter.type}_event`;
-      for (const tx of transactions) {
-        const txEvents = eventsByTx.get(tx.tx_id) ?? [];
-        const matched = txEvents.filter((e) => {
-          if (e.type !== eventType)
-            return false;
-          const data = e.data;
-          if (!data)
-            return false;
-          if (filter.assetIdentifier) {
-            const assetId = data.asset_identifier;
-            if (!assetId || !matchPattern(assetId, filter.assetIdentifier))
-              return false;
-          }
-          if (!traitAllows(filter, assetContract(data.asset_identifier), traitContracts))
-            return false;
-          if ("sender" in filter && filter.sender) {
-            if (!matchPattern(data.sender, filter.sender))
-              return false;
-          }
-          if ("recipient" in filter && filter.recipient) {
-            if (!matchPattern(data.recipient, filter.recipient))
-              return false;
-          }
-          if (filter.minAmount !== undefined) {
-            const amount = BigInt(data.amount ?? "0");
-            if (amount < filter.minAmount)
-              return false;
-          }
-          return true;
-        });
-        if (matched.length > 0) {
-          results.push({ tx, events: matched });
-        }
-      }
-      break;
-    }
-    case "nft_transfer":
-    case "nft_mint":
-    case "nft_burn": {
-      const eventType = `${filter.type}_event`;
-      for (const tx of transactions) {
-        const txEvents = eventsByTx.get(tx.tx_id) ?? [];
-        const matched = txEvents.filter((e) => {
-          if (e.type !== eventType)
-            return false;
-          const data = e.data;
-          if (!data)
-            return false;
-          if (filter.assetIdentifier) {
-            const assetId = data.asset_identifier;
-            if (!assetId || !matchPattern(assetId, filter.assetIdentifier))
-              return false;
-          }
-          if (!traitAllows(filter, assetContract(data.asset_identifier), traitContracts))
-            return false;
-          if ("sender" in filter && filter.sender) {
-            if (!matchPattern(data.sender, filter.sender))
-              return false;
-          }
-          if ("recipient" in filter && filter.recipient) {
-            if (!matchPattern(data.recipient, filter.recipient))
-              return false;
-          }
-          return true;
-        });
-        if (matched.length > 0) {
-          results.push({ tx, events: matched });
-        }
-      }
-      break;
-    }
-    case "contract_call": {
-      for (const tx of transactions) {
-        if (tx.type !== "contract_call")
-          continue;
-        if (filter.contractId) {
-          if (!tx.contract_id || !matchAny(tx.contract_id, filter.contractId))
-            continue;
-        }
-        if (!factoryAllows(filter, tx.contract_id, factoryContracts))
-          continue;
-        if (filter.functionName) {
-          if (!tx.function_name || !matchPattern(tx.function_name, filter.functionName))
-            continue;
-        }
-        if (filter.caller) {
-          if (!matchPattern(tx.sender, filter.caller))
-            continue;
-        }
-        if (!traitAllows(filter, tx.contract_id, traitContracts))
-          continue;
-        const txEvents = eventsByTx.get(tx.tx_id) ?? [];
-        results.push({ tx, events: txEvents });
-      }
-      break;
-    }
-    case "contract_deploy": {
-      for (const tx of transactions) {
-        if (tx.type !== "smart_contract")
-          continue;
-        if (filter.deployer) {
-          if (!matchPattern(tx.sender, filter.deployer))
-            continue;
-        }
-        if (filter.contractName) {
-          const name = tx.contract_id?.split(".")[1] ?? "";
-          if (!matchPattern(name, filter.contractName))
-            continue;
-        }
-        const txEvents = eventsByTx.get(tx.tx_id) ?? [];
-        results.push({ tx, events: txEvents });
-      }
-      break;
-    }
-    case "nested_contract_call":
-    case "var_set":
-    case "map_set":
-    case "map_insert":
-    case "map_delete": {
-      for (const tx of transactions) {
-        const txEvents = vmEventsByTx.get(tx.tx_id) ?? [];
-        const matched = txEvents.filter((e) => {
-          if (e.type !== filter.type)
-            return false;
-          const data = e.data;
-          if (!data)
-            return false;
-          const contractId = printContractId(data);
-          if ("contractId" in filter && filter.contractId) {
-            if (!contractId || !matchAny(contractId, filter.contractId))
-              return false;
-          }
-          if (!traitAllows(filter, contractId, traitContracts))
-            return false;
-          if (!factoryAllows(filter, contractId, factoryContracts))
-            return false;
-          if (filter.type === "nested_contract_call") {
-            if (filter.functionName) {
-              if (typeof data.function_name !== "string" || !matchPattern(data.function_name, filter.functionName))
-                return false;
-            }
-            if (filter.caller) {
-              if (typeof data.caller !== "string" || !matchPattern(data.caller, filter.caller))
-                return false;
-            }
-            if (filter.sender) {
-              if (typeof data.sender !== "string" || !matchPattern(data.sender, filter.sender))
-                return false;
-            }
-          }
-          if (filter.type === "var_set" && filter.varName) {
-            if (typeof data.var_name !== "string" || !matchPattern(data.var_name, filter.varName))
-              return false;
-          }
-          if ((filter.type === "map_set" || filter.type === "map_insert" || filter.type === "map_delete") && filter.map) {
-            if (typeof data.map_name !== "string" || !matchPattern(data.map_name, filter.map))
-              return false;
-          }
-          return true;
-        });
-        if (matched.length > 0)
-          results.push({ tx, events: matched });
-      }
-      break;
-    }
-    case "print_event": {
-      for (const tx of transactions) {
-        const txEvents = eventsByTx.get(tx.tx_id) ?? [];
-        const matched = txEvents.filter((e) => {
-          if (e.type !== "smart_contract_event" && e.type !== "contract_event")
-            return false;
-          const data = e.data;
-          if (!data)
-            return false;
-          if (data.topic !== "print")
-            return false;
-          const contractId = printContractId(data);
-          if (filter.contractId) {
-            if (!contractId || !matchAny(contractId, filter.contractId))
-              return false;
-          }
-          if (!traitAllows(filter, contractId, traitContracts))
-            return false;
-          if (!factoryAllows(filter, contractId, factoryContracts))
-            return false;
-          return true;
-        });
-        if (matched.length > 0) {
-          results.push({ tx, events: matched });
-        }
-      }
-      break;
-    }
-  }
-  return results;
-}
-function matchSources(sources, transactions, events, traitContracts = new Map, factoryContracts = new Map, vmEvents = []) {
-  const eventsByTx = new Map;
-  for (const event of events) {
-    const list = eventsByTx.get(event.tx_id) ?? [];
-    list.push(event);
-    eventsByTx.set(event.tx_id, list);
-  }
-  const vmEventsByTx = new Map;
-  for (const event of vmEvents) {
-    const list = vmEventsByTx.get(event.tx_id) ?? [];
-    list.push(event);
-    vmEventsByTx.set(event.tx_id, list);
-  }
-  const seen = new Set;
-  const results = [];
-  for (const [sourceName, filter] of Object.entries(sources)) {
-    const matches = matchFilter(filter, transactions, eventsByTx, traitContracts, factoryContracts, vmEventsByTx);
-    for (const match of matches) {
-      const dedupeKey = `${match.tx.tx_id}:${sourceName}`;
-      if (!seen.has(dedupeKey)) {
-        seen.add(dedupeKey);
-        results.push({ ...match, sourceName });
-      }
-    }
-  }
-  return results;
-}
-
-// src/runtime/runner.ts
-import { getErrorMessage } from "@secondlayer/shared";
-import { logger as logger4 } from "@secondlayer/shared/logger";
-import {
-  clarityValueToJS,
-  deserializeCV as deserializeCV4,
-  toCamelCase as toCamelCase2
-} from "@secondlayer/stacks/clarity";
-
-// src/print-schema.ts
-import {
-  deserializeCV as deserializeCV3
-} from "@secondlayer/stacks/clarity";
-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":
-    case "int":
-      return { kind: cv.type };
-    case "true":
-    case "false":
-      return { kind: "bool" };
-    case "address":
-    case "contract":
-      return { kind: "principal" };
-    case "buffer":
-      return { kind: "buffer", len: cv.value.length / 2 };
-    case "ascii":
-      return { kind: "ascii", len: cv.value.length };
-    case "utf8":
-      return { kind: "utf8", len: new TextEncoder().encode(cv.value).length };
-    case "none":
-      return { kind: "optional", inner: null };
-    case "some":
-      return { kind: "optional", inner: cvToTree(cv.value) };
-    case "ok":
-      return { kind: "response", ok: cvToTree(cv.value), err: null };
-    case "err":
-      return { kind: "response", ok: null, err: cvToTree(cv.value) };
-    case "list": {
-      let inner = null;
-      for (const el of cv.value) {
-        const t = cvToTree(el);
-        inner = inner ? unify(inner, t) : t;
-      }
-      return { kind: "list", inner };
-    }
-    case "tuple": {
-      const entries = new Map;
-      for (const [k, v] of Object.entries(cv.value)) {
-        entries.set(k, { tree: cvToTree(v), present: 1 });
-      }
-      return { kind: "tuple", count: 1, entries };
-    }
-  }
-}
-function unifyNullable(a, b) {
-  if (!a)
-    return b;
-  if (!b)
-    return a;
-  return unify(a, b);
-}
-var UNION_KIND_ORDER = {
-  uint: 0,
-  int: 1,
-  bool: 2,
-  principal: 3,
-  buffer: 4,
-  ascii: 5,
-  utf8: 6,
-  list: 7,
-  tuple: 8,
-  response: 9
-};
-function makeUnion(members) {
-  const sorted = [...members].sort((a, b) => (UNION_KIND_ORDER[a.kind] ?? 99) - (UNION_KIND_ORDER[b.kind] ?? 99));
-  return { kind: "union", members: sorted };
-}
-function unify(a, b) {
-  if (a.kind === "optional" || b.kind === "optional") {
-    const ai = a.kind === "optional" ? a.inner : a;
-    const bi = b.kind === "optional" ? b.inner : b;
-    return { kind: "optional", inner: unifyNullable(ai, bi) };
-  }
-  if (a.kind === "union")
-    return unionAdd(a.members, b);
-  if (b.kind === "union")
-    return unionAdd(b.members, a);
-  if (a.kind !== b.kind)
-    return makeUnion([a, b]);
-  switch (a.kind) {
-    case "uint":
-    case "int":
-    case "bool":
-    case "principal":
-      return a;
-    case "buffer":
-    case "ascii":
-    case "utf8":
-      return { kind: a.kind, len: Math.max(a.len, b.len) };
-    case "list":
-      return {
-        kind: "list",
-        inner: unifyNullable(a.inner, b.inner)
-      };
-    case "response": {
-      const rb = b;
-      return {
-        kind: "response",
-        ok: unifyNullable(a.ok, rb.ok),
-        err: unifyNullable(a.err, rb.err)
-      };
-    }
-    case "tuple": {
-      const tb = b;
-      const entries = new Map([...a.entries].map(([k, e]) => [k, { ...e }]));
-      for (const [k, e] of tb.entries) {
-        const existing = entries.get(k);
-        entries.set(k, existing ? {
-          tree: unify(existing.tree, e.tree),
-          present: existing.present + e.present
-        } : { ...e });
-      }
-      return { kind: "tuple", count: a.count + tb.count, entries };
-    }
-  }
-}
-function unionAdd(members, t) {
-  if (t.kind === "union") {
-    let acc = { kind: "union", members };
-    for (const m of t.members)
-      acc = unify(acc, m);
-    return acc;
-  }
-  const next = [...members];
-  for (let i = 0;i < next.length; i++) {
-    const member = next[i];
-    if (!member)
-      continue;
-    const merged = unify(member, t);
-    if (merged.kind !== "union") {
-      next[i] = merged;
-      return makeUnion(next);
-    }
-  }
-  next.push(t);
-  return makeUnion(next);
-}
-function wrapOptional(t) {
-  return t.kind === "optional" ? t : { kind: "optional", inner: t };
-}
-function renderClarity(t) {
-  if (!t)
-    return "?";
-  switch (t.kind) {
-    case "uint":
-    case "int":
-    case "bool":
-    case "principal":
-      return t.kind;
-    case "buffer":
-      return `(buff ${t.len})`;
-    case "ascii":
-      return `(string-ascii ${t.len})`;
-    case "utf8":
-      return `(string-utf8 ${t.len})`;
-    case "optional":
-      return `(optional ${renderClarity(t.inner)})`;
-    case "list":
-      return `(list ${renderClarity(t.inner)})`;
-    case "response":
-      return `(response ${renderClarity(t.ok)} ${renderClarity(t.err)})`;
-    case "tuple": {
-      const parts = [...t.entries].map(([k, e]) => {
-        const tree = e.present < t.count ? wrapOptional(e.tree) : e.tree;
-        return `(${k} ${renderClarity(tree)})`;
-      });
-      return `(tuple ${parts.join(" ")})`;
-    }
-    case "union":
-      return t.members.map(renderClarity).join(" | ");
-  }
-}
-function renderTs(t) {
-  if (!t)
-    return "unknown";
-  switch (t.kind) {
-    case "uint":
-    case "int":
-      return "bigint";
-    case "bool":
-      return "boolean";
-    case "principal":
-    case "buffer":
-    case "ascii":
-    case "utf8":
-      return "string";
-    case "optional":
-      return t.inner ? `${renderTs(t.inner)} | null` : "unknown | null";
-    case "list": {
-      const inner = renderTs(t.inner);
-      return inner.includes(" | ") ? `(${inner})[]` : `${inner}[]`;
-    }
-    case "response": {
-      const sides = [...new Set([renderTs(t.ok), renderTs(t.err)])];
-      return sides.join(" | ");
-    }
-    case "tuple": {
-      const parts = [...t.entries].map(([k, e]) => {
-        const opt = e.present < t.count ? "?" : "";
-        return `${camelizeDataKey(k)}${opt}: ${renderTs(e.tree)}`;
-      });
-      return `{ ${parts.join("; ")} }`;
-    }
-    case "union":
-      return [...new Set(t.members.map((m) => renderTs(m)))].join(" | ");
-  }
-}
-function toColumnType(t) {
-  if (!t)
-    return "jsonb";
-  switch (t.kind) {
-    case "uint":
-      return "uint";
-    case "int":
-      return "int";
-    case "bool":
-      return "boolean";
-    case "principal":
-      return "principal";
-    case "buffer":
-    case "ascii":
-    case "utf8":
-      return "text";
-    case "list":
-    case "tuple":
-      return "jsonb";
-    case "optional":
-      return toColumnType(t.inner);
-    case "response":
-      return t.ok ? toColumnType(t.ok) : "jsonb";
-    case "union":
-      return "jsonb";
-  }
-}
-var MAX_DECODED_PER_TOPIC_NEWEST = 75;
-var MAX_DECODED_PER_TOPIC_OLDEST = 25;
-function inferPrintTopics(samples) {
-  const groups = new Map;
-  for (const s of samples) {
-    const group = groups.get(s.topic);
-    if (group)
-      group.push(s);
-    else
-      groups.set(s.topic, [s]);
-  }
-  const out = [];
-  for (const [topic, rows] of groups) {
-    let first = Number.POSITIVE_INFINITY;
-    let last = Number.NEGATIVE_INFINITY;
-    for (const r of rows) {
-      if (r.blockHeight < first)
-        first = r.blockHeight;
-      if (r.blockHeight > last)
-        last = r.blockHeight;
-    }
-    const withHex = [...rows].filter((r) => r.rawHex !== null).sort((a, b) => b.blockHeight - a.blockHeight);
-    const budget = MAX_DECODED_PER_TOPIC_NEWEST + MAX_DECODED_PER_TOPIC_OLDEST;
-    const picked = withHex.length <= budget ? withHex : [
-      ...withHex.slice(0, MAX_DECODED_PER_TOPIC_NEWEST),
-      ...withHex.slice(-MAX_DECODED_PER_TOPIC_OLDEST)
-    ];
-    const tuples = [];
-    let decoded = 0;
-    for (const p of picked) {
-      try {
-        const cv = deserializeCV3(p.rawHex);
-        decoded++;
-        if (cv.type === "tuple")
-          tuples.push(cv);
-      } catch {}
-    }
-    const nonTuple = decoded > 0 && tuples.length === 0;
-    const fields = [];
-    if (!nonTuple) {
-      const stats = new Map;
-      for (const t of tuples) {
-        for (const [key, value] of Object.entries(t.value)) {
-          if (key === "topic")
-            continue;
-          const tree = cvToTree(value);
-          const existing = stats.get(key);
-          if (existing) {
-            existing.present++;
-            existing.tree = unify(existing.tree, tree);
-            if (value.type === "none")
-              existing.noneCount++;
-            if (value.type === "none" || value.type === "some") {
-              existing.optionalSeen = true;
-            }
-          } else {
-            stats.set(key, {
-              tree,
-              present: 1,
-              noneCount: value.type === "none" ? 1 : 0,
-              optionalSeen: value.type === "none" || value.type === "some"
-            });
-          }
-        }
-      }
-      for (const [name, st] of [...stats].sort(([a], [b]) => a.localeCompare(b))) {
-        const field = {
-          name,
-          camel_name: camelizeDataKey(name),
-          clarity_type: renderClarity(st.tree),
-          ts_type: renderTs(st.tree),
-          column_type: toColumnType(st.tree),
-          always_present: st.present === tuples.length
-        };
-        if (st.optionalSeen) {
-          field.optional_some_rate = (st.present - st.noneCount) / st.present;
-        }
-        fields.push(field);
-      }
-    }
-    out.push({
-      topic,
-      count: rows.length,
-      first_height: first,
-      last_height: last,
-      non_tuple: nonTuple,
-      fields
-    });
-  }
-  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",
-  "uint",
-  "int",
-  "principal",
-  "boolean",
-  "timestamp",
-  "jsonb"
-]);
-function isColumnType(field) {
-  return typeof field === "string" && COLUMN_TYPES.has(field);
-}
-function matchesField(field, value) {
-  if (isColumnType(field)) {
-    switch (field) {
-      case "uint":
-      case "int":
-        return typeof value === "bigint" || typeof value === "number";
-      case "boolean":
-        return typeof value === "boolean";
-      case "text":
-      case "principal":
-      case "timestamp":
-        return typeof value === "string" || typeof value === "number" || typeof value === "bigint";
-      case "jsonb":
-        return value !== undefined;
-    }
-  }
-  if (typeof field !== "object" || field === null)
-    return false;
-  if ("optional" in field) {
-    return value === undefined || value === null || matchesField(field.type, value);
-  }
-  if ("tuple" in field) {
-    if (typeof value !== "object" || value === null || Array.isArray(value)) {
-      return false;
-    }
-    return matchesTopic(field.tuple, value).ok;
-  }
-  if ("list" in field) {
-    return Array.isArray(value) && value.every((item) => matchesField(field.list, item));
-  }
-  return false;
-}
-function matchesTopic(declared, data) {
-  for (const [name, field] of Object.entries(declared)) {
-    const present = name in data;
-    const optional = typeof field === "object" && field !== null && "optional" in field;
-    if (!present) {
-      if (optional)
-        continue;
-      return { ok: false, reason: `missing declared field "${name}"` };
-    }
-    if (!matchesField(field, data[name])) {
-      return {
-        ok: false,
-        reason: `field "${name}" does not match its declared type (got ${describe(data[name])})`
-      };
-    }
-  }
-  return { ok: true };
-}
-function describe(value) {
-  if (value === null)
-    return "null";
-  if (Array.isArray(value))
-    return "array";
-  return typeof value;
-}
-function validatePrintPayload(prints, topic, data) {
-  if (!prints)
-    return { ok: true };
-  const declared = prints[topic];
-  if (!declared)
-    return { ok: true };
-  return matchesTopic(declared, data);
-}
-
-// 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 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") {
-    try {
-      parsed = JSON.parse(parsed);
-    } catch {
-      return [];
-    }
-  }
-  if (!Array.isArray(parsed))
-    return [];
-  return parsed.map((arg) => {
-    if (typeof arg === "string")
-      return decodeClarityValue(arg);
-    return arg;
-  });
-}
-function decodeRawResult(raw) {
-  if (typeof raw === "string" && raw.length > 2) {
-    return decodeClarityValue(raw);
-  }
-  return null;
-}
-function decodeRawHex(hex) {
-  if (hex.startsWith("0x") && hex.length > 2) {
-    return decodeClarityValue(hex);
-  }
-  return hex;
-}
-function safeBigInt(val) {
-  if (typeof val === "bigint")
-    return val;
-  if (typeof val === "number")
-    return BigInt(val);
-  if (typeof val === "string") {
-    try {
-      return BigInt(val);
-    } catch {
-      return 0n;
-    }
-  }
-  return 0n;
-}
-function buildContractCallInput(filter, tx) {
-  const abi = filter.abi;
-  const fnName = tx.function_name;
-  if (!abi || !fnName)
-    return;
-  const fn = abi.functions?.find((f) => f.name === fnName);
-  if (!fn || !Array.isArray(fn.args))
-    return;
-  let rawArgs = tx.function_args;
-  if (typeof rawArgs === "string") {
-    try {
-      rawArgs = JSON.parse(rawArgs);
-    } catch {
-      return;
-    }
-  }
-  if (!Array.isArray(rawArgs))
-    return;
-  const decodeArg = clarityValueToJS;
-  const input = {};
-  fn.args.forEach((arg, i) => {
-    const hex = rawArgs[i];
-    if (typeof hex !== "string")
-      return;
-    try {
-      const clean = hex.startsWith("0x") ? hex.slice(2) : hex;
-      input[toCamelCase2(arg.name)] = decodeArg(arg.type, deserializeCV4(clean));
-    } catch {}
-  });
-  return input;
-}
-function buildEventPayload(filter, tx, event) {
-  const txMeta = {
-    txId: tx.tx_id,
-    sender: tx.sender,
-    type: tx.type,
-    status: tx.status,
-    contractId: tx.contract_id ?? null,
-    functionName: tx.function_name ?? null
-  };
-  const decodedArgs = decodeFunctionArgs2(tx.function_args);
-  const decodedResult = decodeRawResult(tx.raw_result);
-  if (!event) {
-    switch (filter.type) {
-      case "contract_call": {
-        const input = buildContractCallInput(filter, tx);
-        return {
-          type: "contract_call",
-          contractId: tx.contract_id ?? "",
-          functionName: tx.function_name ?? "",
-          sender: tx.sender,
-          args: decodedArgs,
-          ...input !== undefined ? { input } : {},
-          result: decodedResult,
-          resultHex: tx.raw_result ?? null,
-          tx: txMeta
-        };
-      }
-      case "contract_deploy":
-        return {
-          contractId: tx.contract_id ?? "",
-          deployer: tx.sender,
-          tx: txMeta
-        };
-      default:
-        return { tx: txMeta };
-    }
-  }
-  const decoded = decodeEventData(event.data);
-  switch (filter.type) {
-    case "ft_transfer":
-      return {
-        sender: decoded.sender,
-        recipient: decoded.recipient,
-        amount: safeBigInt(decoded.amount),
-        assetIdentifier: decoded.asset_identifier,
-        tx: txMeta
-      };
-    case "ft_mint":
-      return {
-        recipient: decoded.recipient,
-        amount: safeBigInt(decoded.amount),
-        assetIdentifier: decoded.asset_identifier,
-        tx: txMeta
-      };
-    case "ft_burn":
-      return {
-        sender: decoded.sender,
-        amount: safeBigInt(decoded.amount),
-        assetIdentifier: decoded.asset_identifier,
-        tx: txMeta
-      };
-    case "nft_transfer":
-      return {
-        sender: decoded.sender,
-        recipient: decoded.recipient,
-        tokenId: decoded.raw_value ?? decoded.value,
-        assetIdentifier: decoded.asset_identifier,
-        tx: txMeta
-      };
-    case "nft_mint":
-      return {
-        recipient: decoded.recipient,
-        tokenId: decoded.raw_value ?? decoded.value,
-        assetIdentifier: decoded.asset_identifier,
-        tx: txMeta
-      };
-    case "nft_burn":
-      return {
-        sender: decoded.sender,
-        tokenId: decoded.raw_value ?? decoded.value,
-        assetIdentifier: decoded.asset_identifier,
-        tx: txMeta
-      };
-    case "stx_transfer":
-      return {
-        sender: decoded.sender,
-        recipient: decoded.recipient,
-        amount: safeBigInt(decoded.amount),
-        memo: decoded.memo ?? "",
-        tx: txMeta
-      };
-    case "stx_mint":
-      return {
-        recipient: decoded.recipient,
-        amount: safeBigInt(decoded.amount),
-        tx: txMeta
-      };
-    case "stx_burn":
-      return {
-        sender: decoded.sender,
-        amount: safeBigInt(decoded.amount),
-        tx: txMeta
-      };
-    case "stx_lock":
-      return {
-        lockedAddress: decoded.locked_address,
-        lockedAmount: safeBigInt(decoded.locked_amount),
-        unlockHeight: safeBigInt(decoded.unlock_height),
-        tx: txMeta
-      };
-    case "print_event": {
-      const rawHex = event.data?.raw_value;
-      const rawValue = typeof rawHex === "string" && rawHex.startsWith("0x") ? decodeClarityValue(rawHex) : decoded.value;
-      const clarityObj = rawValue && typeof rawValue === "object" && !Array.isArray(rawValue) ? rawValue : null;
-      const topic = clarityObj?.topic ? String(clarityObj.topic) : decoded.topic ?? "";
-      const { topic: _, ...rest } = clarityObj ?? {};
-      const data = Object.keys(rest).length > 0 ? camelizeKeys(rest) : rawValue && typeof rawValue !== "object" ? rawValue : {};
-      return {
-        contractId: printContractId(decoded) ?? tx.contract_id ?? "",
-        topic,
-        data: data ?? {},
-        tx: txMeta
-      };
-    }
-    case "contract_call": {
-      const ccRawHex = event.data?.raw_value;
-      const normalized = typeof ccRawHex === "string" && ccRawHex.startsWith("0x") ? { ...decoded, value: decodeClarityValue(ccRawHex) } : decoded;
-      const input = buildContractCallInput(filter, tx);
-      return {
-        ...normalized,
-        type: "contract_call",
-        _eventType: event.type,
-        contractId: tx.contract_id ?? "",
-        functionName: tx.function_name ?? "",
-        sender: tx.sender,
-        args: decodedArgs,
-        ...input !== undefined ? { input } : {},
-        result: decodedResult,
-        resultHex: tx.raw_result ?? null,
-        tx: txMeta
-      };
-    }
-    case "contract_deploy":
-      return {
-        contractId: tx.contract_id ?? "",
-        deployer: tx.sender,
-        tx: txMeta
-      };
-    case "nested_contract_call": {
-      const data = event.data ?? {};
-      const argsHex = Array.isArray(data.function_args) ? data.function_args.filter((a) => typeof a === "string") : [];
-      return {
-        contractId: printContractId(data) ?? "",
-        sender: typeof data.sender === "string" ? data.sender : null,
-        caller: typeof data.caller === "string" ? data.caller : "",
-        functionName: typeof data.function_name === "string" ? data.function_name : "",
-        args: decodeFunctionArgs2(argsHex),
-        arguments: argsHex,
-        rawResult: typeof data.raw_result === "string" ? data.raw_result : "",
-        result: decodeRawResult(data.raw_result),
-        tx: txMeta
-      };
-    }
-    case "var_set": {
-      const data = event.data ?? {};
-      const rawValue = typeof data.raw_value === "string" ? data.raw_value : "";
-      return {
-        contractId: printContractId(data) ?? "",
-        varName: typeof data.var_name === "string" ? data.var_name : "",
-        rawValue,
-        value: decodeRawHex(rawValue),
-        tx: txMeta
-      };
-    }
-    case "map_set":
-    case "map_insert": {
-      const data = event.data ?? {};
-      const rawKey = typeof data.raw_key === "string" ? data.raw_key : "";
-      const rawValue = typeof data.raw_value === "string" ? data.raw_value : "";
-      return {
-        contractId: printContractId(data) ?? "",
-        map: typeof data.map_name === "string" ? data.map_name : "",
-        rawKey,
-        key: decodeRawHex(rawKey),
-        rawValue,
-        value: decodeRawHex(rawValue),
-        tx: txMeta
-      };
-    }
-    case "map_delete": {
-      const data = event.data ?? {};
-      const rawKey = typeof data.raw_key === "string" ? data.raw_key : "";
-      return {
-        contractId: printContractId(data) ?? "",
-        map: typeof data.map_name === "string" ? data.map_name : "",
-        rawKey,
-        key: decodeRawHex(rawKey),
-        tx: txMeta
-      };
-    }
-    default:
-      return {
-        ...decoded,
-        _eventType: event.type,
-        tx: txMeta
-      };
-  }
-}
-async function runHandlers(subgraph, matched, ctx, opts) {
-  let processed = 0;
-  let errors = 0;
-  let skipped = 0;
-  const threshold = opts?.errorThreshold ?? DEFAULT_ERROR_THRESHOLD;
-  const filterLookup = new Map;
-  if (!Array.isArray(subgraph.sources)) {
-    for (const [name, filter] of Object.entries(subgraph.sources)) {
-      filterLookup.set(name, filter);
-    }
-  }
-  const units = [];
-  for (const { tx, events, sourceName } of matched) {
-    if (events.length === 0) {
-      units.push({ tx, sourceName, event: null });
-    } else {
-      for (const event of events)
-        units.push({ tx, sourceName, event });
-    }
-  }
-  const clockRank = (e) => e?.clock === "vm" ? 1 : 0;
-  units.sort((a, b) => (a.tx.tx_index ?? 0) - (b.tx.tx_index ?? 0) || clockRank(a.event) - clockRank(b.event) || (a.event?.event_index ?? -1) - (b.event?.event_index ?? -1));
-  for (const { tx, event, sourceName } of units) {
-    if (errors >= threshold) {
-      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 && !materialize) {
-      logger4.warn("No handler found for source", {
-        subgraph: subgraph.name,
-        sourceName,
-        txId: tx.tx_id
-      });
-      continue;
-    }
-    ctx.setTx({
-      txId: tx.tx_id,
-      sender: tx.sender,
-      type: tx.type,
-      status: tx.status,
-      contractId: tx.contract_id ?? null,
-      functionName: tx.function_name ?? null
-    });
-    const checkpoint = ctx.opsCheckpoint();
-    try {
-      let payload;
-      if (event === null) {
-        payload = filter ? buildEventPayload(filter, tx, null) : {
-          tx: {
-            txId: tx.tx_id,
-            sender: tx.sender,
-            type: tx.type,
-            status: tx.status,
-            contractId: tx.contract_id,
-            functionName: tx.function_name
-          }
-        };
-      } else if (filter) {
-        payload = buildEventPayload(filter, tx, event);
-      } else {
-        const decoded = decodeEventData(event.data);
-        payload = {
-          ...decoded,
-          _eventId: event.id,
-          _eventType: event.type,
-          _eventIndex: event.event_index,
-          tx: {
-            txId: tx.tx_id,
-            sender: tx.sender,
-            type: tx.type,
-            status: tx.status,
-            contractId: tx.contract_id,
-            functionName: tx.function_name
-          }
-        };
-      }
-      if (event !== null && filter?.type === "print_event" && filter.topic && payload.topic !== filter.topic) {
-        continue;
-      }
-      if (event !== null && filter?.type === "print_event" && filter.prints) {
-        const printPayload = payload;
-        const verdict = validatePrintPayload(filter.prints, printPayload.topic ?? "", printPayload.data ?? {});
-        if (!verdict.ok) {
-          skipped++;
-          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++;
-      }
-    } catch (err) {
-      ctx.rollbackTo(checkpoint);
-      errors++;
-      logger4.error("Subgraph handler error", {
-        subgraph: subgraph.name,
-        sourceName,
-        txId: tx.tx_id,
-        ...event !== null ? { eventId: event.id, eventType: event.type } : {},
-        error: getErrorMessage(err)
-      });
-    }
-  }
-  return { processed, errors, ...skipped > 0 ? { skipped } : {} };
-}
-
-// src/runtime/block-processor.ts
-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";
-import {
-  recordLiveError,
-  recordLiveProgress,
-  recordSubgraphProcessed,
-  rewindLiveProgress,
-  updateSubgraphStatus
-} from "@secondlayer/shared/db/queries/subgraphs";
-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 logger5 } from "@secondlayer/shared/logger";
-
-// src/runtime/batch-loader.ts
-function vmEventId(txId, vmEventIndex) {
-  return `${txId}#vm:${vmEventIndex}`;
-}
-async function loadBlockRange(db, fromHeight, toHeight) {
-  const [blocks, txs, events, vmRows] = await Promise.all([
-    db.selectFrom("blocks").selectAll().where("height", ">=", fromHeight).where("height", "<=", toHeight).where("canonical", "=", true).execute(),
-    db.selectFrom("transactions").selectAll().where("block_height", ">=", fromHeight).where("block_height", "<=", toHeight).execute(),
-    db.selectFrom("events").selectAll().where("block_height", ">=", fromHeight).where("block_height", "<=", toHeight).execute(),
-    db.selectFrom("vm_events").selectAll().where("block_height", ">=", fromHeight).where("block_height", "<=", toHeight).orderBy("ordinal", "asc").execute()
-  ]);
-  const txsByHeight = new Map;
-  for (const tx of txs) {
-    const h = Number(tx.block_height);
-    const list = txsByHeight.get(h) ?? [];
-    list.push(tx);
-    txsByHeight.set(h, list);
-  }
-  const eventsByHeight = new Map;
-  for (const evt of events) {
-    const h = Number(evt.block_height);
-    const list = eventsByHeight.get(h) ?? [];
-    list.push(evt);
-    eventsByHeight.set(h, list);
-  }
-  const vmByHeight = new Map;
-  for (const row of vmRows) {
-    const h = Number(row.block_height);
-    const list = vmByHeight.get(h) ?? [];
-    list.push({
-      id: vmEventId(row.tx_id, Number(row.ordinal)),
-      tx_id: row.tx_id,
-      block_height: h,
-      event_index: Number(row.ordinal),
-      type: row.type,
-      data: row.data,
-      created_at: row.created_at,
-      clock: "vm"
-    });
-    vmByHeight.set(h, list);
-  }
-  const result = new Map;
-  for (const block of blocks) {
-    const h = Number(block.height);
-    result.set(h, {
-      block,
-      txs: txsByHeight.get(h) ?? [],
-      events: eventsByHeight.get(h) ?? [],
-      vmEvents: vmByHeight.get(h) ?? []
-    });
-  }
-  return result;
-}
-function avgEventsPerBlock(batch) {
-  if (batch.size === 0)
-    return 0;
-  let totalEvents = 0;
-  for (const data of batch.values()) {
-    totalEvents += data.events.length;
-  }
-  return totalEvents / batch.size;
-}
-
-// src/runtime/observer-http-source.ts
-import {
-  VM_NODE_TO_STORED_TYPE
-} from "@secondlayer/shared";
-var OBSERVER_HTTP_EXPORT_PATH = "/internal/observer-events";
-function stripTrailingSlash(url) {
-  return url.replace(/\/+$/, "");
-}
-function blockTimestamp(payload) {
-  for (const value of [
-    payload.timestamp,
-    payload.block_time,
-    payload.burn_block_time,
-    payload.burn_block_timestamp
-  ]) {
-    if (typeof value === "number" && Number.isFinite(value) && value > 0) {
-      return value;
-    }
-  }
-  return 0;
-}
-function eventData(event) {
-  if (typeof event.type === "string" && event.type in event) {
-    return event[event.type] ?? {};
-  }
-  return {};
-}
-function mapNewBlockPayloadToBlockData(payload) {
-  const p = payload;
-  if (typeof p.block_height !== "number" || !Number.isFinite(p.block_height) || typeof p.index_block_hash !== "string" || p.index_block_hash.length === 0) {
-    throw new Error("observer /new_block payload missing block_height or index_block_hash");
-  }
-  const height = p.block_height;
-  const block = {
-    height,
-    hash: p.block_hash ?? "",
-    parent_hash: p.parent_block_hash ?? "",
-    burn_block_height: p.burn_block_height ?? 0,
-    burn_block_hash: p.burn_block_hash ?? null,
-    index_block_hash: p.index_block_hash,
-    timestamp: blockTimestamp(p),
-    canonical: true,
-    created_at: new Date(0)
-  };
-  const txs = (p.transactions ?? []).map((tx) => {
-    let contractId = null;
-    let functionName = null;
-    if (tx.tx_type === "contract_call" && tx.contract_call) {
-      contractId = tx.contract_call.contract_id ?? null;
-      functionName = tx.contract_call.function_name ?? null;
-    } else if (tx.tx_type === "smart_contract" && tx.smart_contract) {
-      contractId = tx.smart_contract.contract_id ?? null;
-    }
-    return {
-      tx_id: tx.txid ?? "",
-      block_height: height,
-      tx_index: tx.tx_index ?? 0,
-      type: tx.tx_type ?? "",
-      sender: tx.sender_address ?? "",
-      status: tx.status ?? "success",
-      contract_id: contractId,
-      function_name: functionName,
-      function_args: [],
-      raw_result: tx.raw_result ?? null,
-      raw_tx: tx.raw_tx ?? "",
-      created_at: new Date(0)
-    };
-  });
-  const events = (p.events ?? []).map((event) => {
-    const txId = event.txid ?? "";
-    const eventIndex = event.event_index ?? 0;
-    return {
-      id: `${txId}#${eventIndex}`,
-      tx_id: txId,
-      block_height: height,
-      event_index: eventIndex,
-      type: event.type ?? "",
-      data: eventData(event),
-      created_at: new Date(0)
-    };
-  });
-  const vmEvents = [];
-  for (const [i, trace] of (p.vm_events ?? []).entries()) {
-    const nodeType = trace.type;
-    if (typeof nodeType !== "string" || !(nodeType in VM_NODE_TO_STORED_TYPE))
-      continue;
-    const stored = VM_NODE_TO_STORED_TYPE[nodeType];
-    const body = trace[nodeType];
-    if (!body || typeof body !== "object")
-      continue;
-    const txId = trace.txid ?? "";
-    const vmIndex = i;
-    vmEvents.push({
-      id: vmEventId(txId, vmIndex),
-      tx_id: txId,
-      block_height: height,
-      event_index: vmIndex,
-      type: stored,
-      data: body,
-      created_at: new Date(0),
-      clock: "vm"
-    });
-  }
-  return { block, txs, events, vmEvents };
-}
-
-class ObserverHttpBlockSource {
-  baseUrl;
-  token;
-  fetchFn;
-  constructor(opts) {
-    this.baseUrl = stripTrailingSlash(opts.baseUrl);
-    this.token = opts.token ?? null;
-    this.fetchFn = opts.fetch ?? globalThis.fetch.bind(globalThis);
-  }
-  headers() {
-    if (!this.token)
-      return {};
-    return { Authorization: `Bearer ${this.token}` };
-  }
-  async getTip() {
-    const res = await this.fetchFn(`${this.baseUrl}${OBSERVER_HTTP_EXPORT_PATH}/tip`, { headers: this.headers() });
-    if (!res.ok) {
-      throw new Error(`observer tip HTTP ${res.status}: ${await res.text().catch(() => "")}`);
-    }
-    let body;
-    try {
-      body = await res.json();
-    } catch (err) {
-      throw new Error(`observer tip invalid JSON: ${err instanceof Error ? err.message : String(err)}`);
-    }
-    if (typeof body.block_height !== "number" || !Number.isFinite(body.block_height)) {
-      throw new Error("observer tip missing block_height");
-    }
-    return body.block_height;
-  }
-  async loadBlockRange(fromHeight, toHeight) {
-    const result = new Map;
-    let afterHeight = fromHeight > 0 ? fromHeight - 1 : undefined;
-    let afterIndexBlockHash;
-    for (;; ) {
-      const url = new URL(`${this.baseUrl}${OBSERVER_HTTP_EXPORT_PATH}`);
-      url.searchParams.set("path", "/new_block");
-      url.searchParams.set("limit", "100");
-      if (afterHeight != null) {
-        url.searchParams.set("after_height", String(afterHeight));
-      }
-      if (afterIndexBlockHash) {
-        url.searchParams.set("after_index_block_hash", afterIndexBlockHash);
-      }
-      const res = await this.fetchFn(url.toString(), {
-        headers: this.headers()
-      });
-      if (!res.ok) {
-        throw new Error(`observer events HTTP ${res.status}: ${await res.text().catch(() => "")}`);
-      }
-      let body;
-      try {
-        body = await res.json();
-      } catch (err) {
-        throw new Error(`observer events invalid JSON: ${err instanceof Error ? err.message : String(err)}`);
-      }
-      let pastTo = false;
-      for (const message of body.events ?? []) {
-        if (message.path === "/new_burn_block")
-          continue;
-        const height = message.payload?.block_height;
-        if (typeof height === "number" && height > toHeight) {
-          pastTo = true;
-          break;
-        }
-        const data = mapNewBlockPayloadToBlockData(message.payload);
-        const h = data.block.height;
-        if (h >= fromHeight && h <= toHeight) {
-          result.set(h, data);
-        }
-      }
-      if (pastTo || body.next == null)
-        break;
-      afterHeight = body.next.after_height;
-      afterIndexBlockHash = body.next.after_index_block_hash;
-    }
-    return result;
-  }
-}
-
-// src/runtime/reconstruct.ts
-function isoToUnixSeconds(iso) {
-  if (!iso)
-    return 0;
-  return Math.floor(new Date(iso).getTime() / 1000);
-}
-function reconstructBlock(b) {
-  return {
-    height: b.block_height,
-    hash: b.block_hash,
-    parent_hash: b.parent_hash,
-    burn_block_height: b.burn_block_height,
-    burn_block_hash: b.burn_block_hash,
-    index_block_hash: b.index_block_hash ?? null,
-    timestamp: isoToUnixSeconds(b.block_time),
-    canonical: true,
-    created_at: new Date(0)
-  };
-}
-function reconstructTransaction(t) {
-  return {
-    tx_id: t.tx_id,
-    block_height: t.block_height,
-    tx_index: t.tx_index,
-    type: t.tx_type,
-    sender: t.sender,
-    status: t.status,
-    contract_id: t.contract_call?.contract_id ?? t.smart_contract?.contract_id ?? null,
-    function_name: t.contract_call?.function_name ?? null,
-    function_args: t.contract_call?.function_args_hex ?? [],
-    raw_result: t.contract_call?.result_hex ?? null,
-    raw_tx: "",
-    created_at: new Date(0)
-  };
-}
-function reconstructTxFromEventRow(e) {
-  return {
-    tx_id: e.tx_id,
-    block_height: e.block_height,
-    tx_index: e.tx_index ?? 0,
-    type: e.tx_type ?? "",
-    sender: e.tx_sender ?? "",
-    status: e.tx_status ?? "success",
-    contract_id: e.tx_contract_id ?? null,
-    function_name: e.tx_function_name ?? null,
-    function_args: [],
-    raw_result: null,
-    raw_tx: "",
-    created_at: new Date(0)
-  };
-}
-function reconstructEvent(e) {
-  const base = {
-    id: `${e.tx_id}#${e.event_index}`,
-    tx_id: e.tx_id,
-    block_height: e.block_height,
-    event_index: e.event_index,
-    created_at: new Date(0)
-  };
-  switch (e.event_type) {
-    case "ft_transfer":
-    case "ft_mint":
-    case "ft_burn":
-      return {
-        ...base,
-        type: `${e.event_type}_event`,
-        data: {
-          asset_identifier: e.asset_identifier,
-          sender: e.sender,
-          recipient: e.recipient,
-          amount: e.amount
-        }
-      };
-    case "nft_transfer":
-    case "nft_mint":
-    case "nft_burn":
-      return {
-        ...base,
-        type: `${e.event_type}_event`,
-        data: {
-          asset_identifier: e.asset_identifier,
-          sender: e.sender,
-          recipient: e.recipient,
-          raw_value: e.value
-        }
-      };
-    case "stx_transfer":
-    case "stx_mint":
-    case "stx_burn":
-      return {
-        ...base,
-        type: `${e.event_type}_event`,
-        data: {
-          sender: e.sender,
-          recipient: e.recipient,
-          amount: e.amount,
-          ...e.event_type === "stx_transfer" ? { memo: e.memo ?? "" } : {}
-        }
-      };
-    case "stx_lock":
-      return {
-        ...base,
-        type: "stx_lock_event",
-        data: {
-          locked_address: e.sender,
-          locked_amount: e.amount,
-          unlock_height: e.payload.unlock_height
-        }
-      };
-    case "print":
-      return {
-        ...base,
-        type: "contract_event",
-        data: {
-          topic: e.payload.topic,
-          contract_id: e.contract_id,
-          value: e.payload.value,
-          raw_value: e.payload.raw_value
-        }
-      };
-    case "nested_contract_call":
-    case "var_set":
-    case "map_set":
-    case "map_insert":
-    case "map_delete":
-      return {
-        ...base,
-        id: vmEventId(e.tx_id, e.event_index),
-        clock: "vm",
-        type: e.event_type,
-        data: {
-          contract_identifier: e.contract_id,
-          ..."payload" in e && e.payload && typeof e.payload === "object" ? e.payload : {},
-          sender: "sender" in e ? e.sender : undefined,
-          caller: "caller" in e ? e.caller : undefined,
-          function_name: "function_name" in e ? e.function_name : undefined,
-          function_args: "function_args" in e ? e.function_args : undefined,
-          raw_result: "raw_result" in e ? e.raw_result : undefined,
-          map_name: "map" in e ? e.map : undefined,
-          var_name: "var_name" in e ? e.var_name : undefined,
-          raw_key: "raw_key" in e ? e.raw_key : undefined,
-          raw_value: "raw_value" in e ? e.raw_value : undefined
-        }
-      };
-  }
-}
-
-// src/runtime/block-source.ts
-function canSparseScan(subgraph) {
-  if (Array.isArray(subgraph.sources))
-    return false;
-  const filters = sourceFilters(subgraph);
-  if (filters.length === 0)
-    return false;
-  return filters.every((f) => Boolean(EVENT_FILTER_TO_INDEX_TYPE[f.type]));
-}
-function sparseProbeTargets(subgraph) {
-  const targets = new Map;
-  for (const f of sourceFilters(subgraph)) {
-    const eventType = EVENT_FILTER_TO_INDEX_TYPE[f.type];
-    if (!eventType)
-      continue;
-    const scoped = f;
-    const contractId = scoped.contractId ?? scoped.assetIdentifier?.split("::")[0];
-    const key = `${eventType}|${contractId ?? ""}`;
-    targets.set(key, { eventType, ...contractId ? { contractId } : {} });
-  }
-  return [...targets.values()];
-}
-
-class PostgresBlockSource {
-  async getTip() {
-    const progress = await getSourceDb2().selectFrom("index_progress").selectAll().where("network", "=", process.env.NETWORK ?? "mainnet").executeTakeFirst();
-    return progress ? Number(progress.highest_seen_block) : 0;
-  }
-  loadBlockRange(fromHeight, toHeight) {
-    return loadBlockRange(getSourceDb2(), fromHeight, toHeight);
-  }
-}
-var EVENT_FILTER_TO_INDEX_TYPE = {
-  stx_transfer: "stx_transfer",
-  stx_mint: "stx_mint",
-  stx_burn: "stx_burn",
-  stx_lock: "stx_lock",
-  ft_transfer: "ft_transfer",
-  ft_mint: "ft_mint",
-  ft_burn: "ft_burn",
-  nft_transfer: "nft_transfer",
-  nft_mint: "nft_mint",
-  nft_burn: "nft_burn",
-  print_event: "print",
-  nested_contract_call: "nested_contract_call",
-  var_set: "var_set",
-  map_set: "map_set",
-  map_insert: "map_insert",
-  map_delete: "map_delete"
-};
-var TX_SOURCE_TYPES = new Set(["contract_call", "contract_deploy"]);
-var VM_INDEX_EVENT_TYPES = new Set([
-  "nested_contract_call",
-  "var_set",
-  "map_set",
-  "map_insert",
-  "map_delete"
-]);
-var CLASSIC_INDEX_EVENT_TYPES = [
-  ...new Set(Object.values(EVENT_FILTER_TO_INDEX_TYPE))
-].filter((t) => !VM_INDEX_EVENT_TYPES.has(t));
-function sourceFilters(subgraph) {
-  const sources = subgraph.sources;
-  return Array.isArray(sources) ? sources : Object.values(sources);
-}
-function needsTransactionData(subgraph) {
-  return sourceFilters(subgraph).some((f) => TX_SOURCE_TYPES.has(f.type));
-}
-function synthesizeTxsFromEvents(events) {
-  const byId = new Map;
-  for (const e of events) {
-    if (!byId.has(e.tx_id))
-      byId.set(e.tx_id, reconstructTxFromEventRow(e));
-  }
-  return [...byId.values()];
-}
-function indexEventTypesForFilterTypes(filterTypes) {
-  const types = new Set;
-  if (filterTypes.some((t) => TX_SOURCE_TYPES.has(t))) {
-    for (const t of CLASSIC_INDEX_EVENT_TYPES)
-      types.add(t);
-  }
-  for (const t of filterTypes) {
-    const indexType = EVENT_FILTER_TO_INDEX_TYPE[t];
-    if (indexType)
-      types.add(indexType);
-  }
-  return [...types];
-}
-function referencedIndexEventTypes(subgraph) {
-  if (!subgraph.sources)
-    return [];
-  return indexEventTypesForFilterTypes(sourceFilters(subgraph).map((f) => f.type));
-}
-function isStreamsIndexEligible(subgraph) {
-  if (Array.isArray(subgraph.sources))
-    return false;
-  const filters = sourceFilters(subgraph);
-  if (filters.length === 0)
-    return false;
-  for (const f of filters) {
-    const known = EVENT_FILTER_TO_INDEX_TYPE[f.type] || TX_SOURCE_TYPES.has(f.type);
-    if (!known)
-      return false;
-  }
-  return true;
-}
-
-class PublicApiBlockSource {
-  http;
-  eventTypes;
-  probeTargets;
-  needsTransactions;
-  constructor(http2, eventTypes, probeTargets, needsTransactions = true) {
-    this.http = http2;
-    this.eventTypes = eventTypes;
-    this.probeTargets = probeTargets;
-    this.needsTransactions = needsTransactions;
-  }
-  async nextDataHeight(afterHeight, untilHeight) {
-    if (!this.probeTargets?.length)
-      return afterHeight + 1;
-    const hits = await Promise.all(this.probeTargets.map((t) => this.http.firstEventHeight(t.eventType, afterHeight + 1, untilHeight, t.contractId)));
-    const found = hits.filter((h) => h !== null);
-    return found.length ? Math.min(...found) : null;
-  }
-  getTip() {
-    if (this.eventTypes.some((t) => VM_INDEX_EVENT_TYPES.has(t))) {
-      return this.http.getIndexSourceTip();
-    }
-    return this.http.getIndexTip();
-  }
-  async loadBlockRange(fromHeight, toHeight) {
-    const withTx = !this.needsTransactions;
-    const [blocks, txRows, eventLists] = await Promise.all([
-      this.http.walkBlocks(fromHeight, toHeight),
-      this.needsTransactions ? this.http.walkTransactions(fromHeight, toHeight) : Promise.resolve([]),
-      Promise.all(this.eventTypes.map((t) => this.http.walkEvents(t, fromHeight, toHeight, withTx)))
-    ]);
-    const map = new Map;
-    for (const b of blocks) {
-      map.set(b.block_height, {
-        block: reconstructBlock(b),
-        txs: [],
-        events: []
-      });
-    }
-    const txs = this.needsTransactions ? txRows.map(reconstructTransaction) : synthesizeTxsFromEvents(eventLists.flat());
-    for (const t of txs) {
-      map.get(t.block_height)?.txs.push(t);
-    }
-    for (const list of eventLists) {
-      for (const e of list) {
-        const bd = map.get(e.block_height);
-        if (!bd)
-          continue;
-        if (VM_INDEX_EVENT_TYPES.has(e.event_type)) {
-          bd.vmEvents ??= [];
-          bd.vmEvents.push(reconstructEvent(e));
-        } else {
-          bd.events.push(reconstructEvent(e));
-        }
-      }
-    }
-    for (const bd of map.values()) {
-      bd.txs.sort((a, b) => a.tx_index - b.tx_index);
-      bd.events.sort((a, b) => a.event_index - b.event_index);
-      bd.vmEvents?.sort((a, b) => a.event_index - b.event_index);
-    }
-    return map;
-  }
-}
-
-class FallbackBlockSource {
-  primary;
-  fallback;
-  constructor(primary, fallback) {
-    this.primary = primary;
-    this.fallback = fallback;
-  }
-  async getTip() {
-    try {
-      return await this.primary.getTip();
-    } catch (err) {
-      logger5.warn("block source primary getTip failed — using DB tap", {
-        error: err instanceof Error ? err.message : String(err)
-      });
-      return this.fallback.getTip();
-    }
-  }
-  async loadBlockRange(fromHeight, toHeight) {
-    try {
-      return await this.primary.loadBlockRange(fromHeight, toHeight);
-    } catch (err) {
-      logger5.warn("block source primary loadBlockRange failed — using DB tap", {
-        from: fromHeight,
-        to: toHeight,
-        error: err instanceof Error ? err.message : String(err)
-      });
-      return this.fallback.loadBlockRange(fromHeight, toHeight);
-    }
-  }
-  async nextDataHeight(afterHeight, untilHeight) {
-    if (!this.primary.nextDataHeight)
-      return afterHeight + 1;
-    try {
-      return await this.primary.nextDataHeight(afterHeight, untilHeight);
-    } catch {
-      return afterHeight + 1;
-    }
-  }
-}
-var postgresBlockSource = new PostgresBlockSource;
-function buildHttpClient() {
-  return createInternalIndexHttpClient();
-}
-function resolveBlockSource(subgraph) {
-  if (process.env.SUBGRAPH_SOURCE === "observer-http") {
-    const baseUrl = process.env.OBSERVER_HTTP_URL;
-    if (!baseUrl) {
-      throw new Error("SUBGRAPH_SOURCE=observer-http requires OBSERVER_HTTP_URL");
-    }
-    return new ObserverHttpBlockSource({
-      baseUrl,
-      token: process.env.OBSERVER_HTTP_EXPORT_TOKEN || null
-    });
-  }
-  if (process.env.SUBGRAPH_SOURCE === "streams-index" && subgraph && isStreamsIndexEligible(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) {
-    logger5.debug("Subgraph not streams-index eligible, using DB tap", {
-      subgraph: subgraph.name
-    });
-  }
-  return postgresBlockSource;
-}
-
-// src/runtime/outbox-emit.ts
-import { createHash as createHash2 } from "node:crypto";
-import { logger as logger6 } from "@secondlayer/shared/logger";
-var loggedKillSwitch = false;
-var OP_VERB = {
-  insert: "created",
-  update: "updated",
-  delete: "deleted"
-};
-function isEmitOutboxEnabled() {
-  return process.env.SECONDLAYER_EMIT_OUTBOX !== "false";
-}
-function dedupKey(subgraphName, tableName, blockHeight, txId, rowIndex, row) {
-  const canonical = `${subgraphName}:${tableName}:${blockHeight}:${txId}:${rowIndex}:${stableStringify(row)}`;
-  return createHash2("sha256").update(canonical).digest("hex").slice(0, 32);
-}
-function stableStringify(obj) {
-  const keys = Object.keys(obj).sort();
-  return JSON.stringify(keys.reduce((acc, k) => {
-    acc[k] = obj[k];
-    return acc;
-  }, {}));
-}
-async function emitWebhookOutbox(tx, subgraphName, manifest, matcher, blockHeight) {
-  if (!isEmitOutboxEnabled()) {
-    if (!loggedKillSwitch) {
-      logger6.warn("SECONDLAYER_EMIT_OUTBOX=false — outbox emission bypassed");
-      loggedKillSwitch = true;
-    }
-    return 0;
-  }
-  loggedKillSwitch = false;
-  if (manifest.count === 0 || matcher.size() === 0)
-    return 0;
-  const rows = [];
-  for (const write of manifest.writes) {
-    const subs = matcher.match(subgraphName, write.table, write.row);
-    if (subs.length === 0)
-      continue;
-    const eventType = `${subgraphName}.${write.table}.${OP_VERB[write.op]}`;
-    for (const s of subs) {
-      rows.push({
-        webhook_id: s.id,
-        subgraph_name: subgraphName,
-        table_name: write.table,
-        block_height: blockHeight,
-        tx_id: write.pk.txId ?? null,
-        row_pk: write.pk,
-        event_type: eventType,
-        payload: write.row,
-        dedup_key: dedupKey(subgraphName, write.table, write.pk.blockHeight, write.pk.txId, write.pk.rowIndex, write.row)
-      });
-    }
-  }
-  if (rows.length === 0)
-    return 0;
-  await tx.insertInto("webhook_outbox").values(rows).onConflict((oc) => oc.columns(["webhook_id", "dedup_key"]).doNothing()).execute();
-  return rows.length;
-}
-
-// src/runtime/sandbox/flag.ts
-function sandboxWorkersGloballyEnabled() {
-  return process.env.SUBGRAPH_SANDBOX_WORKERS === "1";
-}
-function sandboxEnabled(subgraph) {
-  return sandboxWorkersGloballyEnabled() && subgraph.sandbox_workers === true;
-}
-
-// src/runtime/sandbox/host.ts
-import { tmpdir } from "node:os";
-import { fileURLToPath } from "node:url";
-import { logger as logger7 } from "@secondlayer/shared/logger";
-
-// src/runtime/sandbox/bundle.ts
-import esbuild from "esbuild";
-var ALLOWED_BARE_SPECIFIERS = new Set;
-var SUBGRAPHS_PACKAGE_SPECIFIER = "@secondlayer/subgraphs";
-var SUBGRAPHS_STUB_SOURCE = `export function defineSubgraph(def) { return def; }
-`;
-function resolverLockdownPlugin() {
-  return {
-    name: "f071-sandbox-resolver-lockdown",
-    setup(build) {
-      build.onResolve({ filter: /^@secondlayer\/subgraphs$/ }, (args) => ({
-        path: args.path,
-        namespace: "f071-sandbox-subgraphs-stub"
-      }));
-      build.onLoad({ filter: /.*/, namespace: "f071-sandbox-subgraphs-stub" }, () => ({ contents: SUBGRAPHS_STUB_SOURCE, loader: "js" }));
-      build.onResolve({ filter: /^(node:|bun:)/ }, (args) => ({
-        path: args.path,
-        namespace: "f071-sandbox-blocked"
-      }));
-      build.onResolve({ filter: /^[^./]/ }, (args) => {
-        if (args.path === SUBGRAPHS_PACKAGE_SPECIFIER)
-          return;
-        if (ALLOWED_BARE_SPECIFIERS.has(args.path))
-          return;
-        return { path: args.path, namespace: "f071-sandbox-blocked" };
-      });
-      build.onLoad({ filter: /.*/, namespace: "f071-sandbox-blocked" }, (args) => ({
-        contents: `throw new Error(${JSON.stringify(`subgraph sandbox: import of "${args.path}" is blocked in sandboxed handler code — handlers must use the injected \`ctx\` for all I/O`)});`,
-        loader: "js"
-      }));
-    }
-  };
-}
-async function bundleHandlerCode(handlerCode) {
-  const result = await esbuild.build({
-    stdin: {
-      contents: handlerCode,
-      loader: "ts",
-      resolveDir: process.cwd()
-    },
-    bundle: true,
-    platform: "neutral",
-    format: "esm",
-    write: false,
-    logLevel: "silent",
-    plugins: [resolverLockdownPlugin()]
-  });
-  const out = result.outputFiles?.[0];
-  if (!out)
-    throw new Error("esbuild produced no output for handler_code bundle");
-  return new TextDecoder().decode(out.contents);
-}
-
-// src/runtime/sandbox/host.ts
-var BLOCK_TIMEOUT_MS = Number.parseInt(process.env.SUBGRAPH_SANDBOX_BLOCK_TIMEOUT_MS ?? "60000");
-var SUBPROCESS_ENTRY_PATH = fileURLToPath(new URL("./subprocess-entry.ts", import.meta.url));
-function spawnSandboxProcess() {
-  let onMessage = null;
-  const proc = Bun.spawn({
-    cmd: [process.execPath, "--no-env-file", SUBPROCESS_ENTRY_PATH],
-    env: { PATH: process.env.PATH ?? "" },
-    cwd: tmpdir(),
-    stdio: ["ignore", "ignore", "pipe"],
-    serialization: "advanced",
-    ipc(message) {
-      onMessage?.(message);
-    }
-  });
-  (async () => {
-    const reader = proc.stderr.getReader();
-    const decoder = new TextDecoder;
-    try {
-      while (true) {
-        const { done, value } = await reader.read();
-        if (done)
-          break;
-        const text = decoder.decode(value, { stream: true });
-        if (text.trim()) {
-          logger7.warn("Sandbox subprocess stderr", { stderr: text.trim() });
-        }
-      }
-    } catch {}
-  })();
-  return {
-    send: (msg) => proc.send(msg),
-    kill: () => proc.kill(),
-    exited: proc.exited,
-    setOnMessage: (handler) => {
-      onMessage = handler;
-    }
-  };
-}
-var pool = new Map;
-
-class SandboxWorkerCrash extends Error {
-  constructor(subgraphName, cause) {
-    super(`sandbox subprocess for "${subgraphName}" failed: ${cause}`);
-    this.name = "SandboxWorkerCrash";
-  }
-}
-async function initSandboxProcess(proc, subgraphName, version, handlerCode) {
-  const bundledCode = await bundleHandlerCode(handlerCode);
-  let settled = false;
-  const ready = new Promise((resolve, reject) => {
-    proc.setOnMessage((msg) => {
-      if (msg.type === "ready" && msg.version === version) {
-        settled = true;
-        proc.setOnMessage(null);
-        resolve();
-      } else if (msg.type === "error") {
-        settled = true;
-        proc.setOnMessage(null);
-        reject(new SandboxWorkerCrash(subgraphName, msg.message));
-      }
-    });
-    const init = { type: "init", bundledCode, version };
-    proc.send(init);
-  });
-  const crashed = proc.exited.then((code) => {
-    if (settled)
-      return;
-    throw new SandboxWorkerCrash(subgraphName, `subprocess exited (code ${code}) during init`);
-  });
-  await Promise.race([ready, crashed]);
-}
-async function ensureSandboxProcess(subgraphName, version, handlerCode) {
-  if (handlerCode == null) {
-    throw new SandboxWorkerCrash(subgraphName, "subgraph has no handler_code; cannot bundle for the sandbox path");
-  }
-  const existing = pool.get(subgraphName);
-  if (existing && existing.version === version)
-    return existing;
-  if (existing) {
-    try {
-      await initSandboxProcess(existing.proc, subgraphName, version, handlerCode);
-      existing.version = version;
-      logger7.info("Sandbox subprocess handler reloaded", {
-        subgraph: subgraphName,
-        version
-      });
-      return existing;
-    } catch (err) {
-      existing.proc.kill();
-      pool.delete(subgraphName);
-      logger7.warn("Sandbox subprocess re-init failed; respawning", {
-        subgraph: subgraphName,
-        error: err instanceof Error ? err.message : String(err)
-      });
-    }
-  }
-  const proc = spawnSandboxProcess();
-  try {
-    await initSandboxProcess(proc, subgraphName, version, handlerCode);
-  } catch (err) {
-    proc.kill();
-    throw err;
-  }
-  const entry = { proc, version, chain: Promise.resolve() };
-  pool.set(subgraphName, entry);
-  return entry;
-}
-function evictSandboxWorker(subgraphName) {
-  const entry = pool.get(subgraphName);
-  if (!entry)
-    return;
-  entry.proc.kill();
-  pool.delete(subgraphName);
-}
-async function runHandlersSandboxed(params) {
-  const { subgraphName, version, handlerCode, hostCtx, block, matched } = params;
-  const entry = await ensureSandboxProcess(subgraphName, version, handlerCode);
-  const run = entry.chain.then(() => runBlockThroughProcess(entry, subgraphName, hostCtx, block, matched));
-  entry.chain = run.catch(() => {
-    return;
-  });
-  return run;
-}
-async function runBlockThroughProcess(entry, subgraphName, hostCtx, block, matched) {
-  const { proc } = entry;
-  let timeoutHandle;
-  let settled = false;
-  try {
-    const done = new Promise((resolve, reject) => {
-      proc.setOnMessage((msg) => {
-        if (msg.type === "readRequest") {
-          answerRead(hostCtx, msg).then((reply) => {
-            proc.send({ type: "readResponse", id: msg.id, reply });
-          }).catch((err) => {
-            settled = true;
-            reject(new SandboxWorkerCrash(subgraphName, `host read failed: ${err instanceof Error ? err.message : String(err)}`));
-          });
-          return;
-        }
-        if (msg.type === "blockDone") {
-          settled = true;
-          resolve({
-            ops: msg.ops,
-            result: { processed: msg.processed, errors: msg.errors }
-          });
-          return;
-        }
-        if (msg.type === "error") {
-          settled = true;
-          reject(new SandboxWorkerCrash(subgraphName, msg.message));
-        }
-      });
-      proc.send({ type: "runBlock", block, matched });
-    });
-    const crashed = proc.exited.then((code) => {
-      if (settled)
-        return;
-      throw new SandboxWorkerCrash(subgraphName, `subprocess exited unexpectedly (code ${code}) mid-block`);
-    });
-    const deadline = new Promise((_, reject) => {
-      timeoutHandle = setTimeout(() => {
-        settled = true;
-        reject(new SandboxWorkerCrash(subgraphName, `block ${block.height} exceeded ${BLOCK_TIMEOUT_MS}ms deadline`));
-      }, BLOCK_TIMEOUT_MS);
-    });
-    const { ops, result } = await Promise.race([done, crashed, deadline]);
-    for (const op of ops) {
-      hostCtx.setTx(op.tx);
-      replayOp(hostCtx, op);
-    }
-    return result;
-  } catch (err) {
-    evictSandboxWorker(subgraphName);
-    logger7.warn("Sandbox subprocess run failed; subprocess evicted", {
-      subgraph: subgraphName,
-      blockHeight: block.height,
-      error: err instanceof Error ? err.message : String(err)
-    });
-    throw err;
-  } finally {
-    if (timeoutHandle !== undefined)
-      clearTimeout(timeoutHandle);
-    proc.setOnMessage(null);
-  }
-}
-function replayOp(hostCtx, op) {
-  switch (op.method) {
-    case "insert":
-      hostCtx.insert(op.table, op.args[0]);
-      return;
-    case "upsert":
-      hostCtx.upsert(op.table, op.args[0], op.args[1]);
-      return;
-    case "increment":
-      hostCtx.increment(op.table, op.args[0], op.args[1]);
-      return;
-    case "update":
-      hostCtx.update(op.table, op.args[0], op.args[1]);
-      return;
-    case "delete":
-      hostCtx.delete(op.table, op.args[0]);
-      return;
-  }
-}
-async function answerRead(hostCtx, msg) {
-  const { method, table, where, column } = msg;
-  switch (method) {
-    case "findOne":
-      return { kind: "row", row: await hostCtx.findOne(table, where) };
-    case "findMany":
-      return { kind: "rows", rows: await hostCtx.findMany(table, where) };
-    case "count":
-      return { kind: "count", count: await hostCtx.count(table, where) };
-    case "countDistinct": {
-      if (!column)
-        throw new Error("countDistinct read missing column");
-      return {
-        kind: "count",
-        count: await hostCtx.countDistinct(table, column, where)
-      };
-    }
-    case "sum": {
-      if (!column)
-        throw new Error("sum read missing column");
-      const v = await hostCtx.sum(table, column, where);
-      return { kind: "amount", amount: v.toString() };
-    }
-    case "min": {
-      if (!column)
-        throw new Error("min read missing column");
-      const v = await hostCtx.min(table, column, where);
-      return { kind: "amount", amount: v == null ? null : v.toString() };
-    }
-    case "max": {
-      if (!column)
-        throw new Error("max read missing column");
-      const v = await hostCtx.max(table, column, where);
-      return { kind: "amount", amount: v == null ? null : v.toString() };
-    }
-  }
-}
-
-// src/runtime/webhook-state.ts
-import { listWebhooks } from "@secondlayer/shared/db/queries/webhooks";
-import { sql as sql3 } from "kysely";
-
-// src/runtime/emitter-matcher.ts
-function isPrimitive(v) {
-  const t = typeof v;
-  return t === "string" || t === "number" || t === "boolean";
-}
-function coerceBigInt(v) {
-  if (typeof v === "bigint")
-    return v;
-  if (typeof v === "number") {
-    if (!Number.isFinite(v))
-      return null;
-    if (!Number.isInteger(v))
-      return null;
-    return BigInt(v);
-  }
-  if (typeof v === "string" && /^-?\d+$/.test(v)) {
-    try {
-      return BigInt(v);
-    } catch {
-      return null;
-    }
-  }
-  return null;
-}
-function coerceFloat(v) {
-  if (typeof v === "number" && Number.isFinite(v))
-    return v;
-  if (typeof v === "bigint")
-    return Number(v);
-  if (typeof v === "string" && v !== "" && !Number.isNaN(Number(v))) {
-    return Number(v);
-  }
-  return null;
-}
-function compareNumeric(a, b) {
-  const ba = coerceBigInt(a);
-  const bb = coerceBigInt(b);
-  if (ba !== null && bb !== null) {
-    if (ba === bb)
-      return 0;
-    return ba > bb ? 1 : -1;
-  }
-  const fa = coerceFloat(a);
-  const fb = coerceFloat(b);
-  if (fa === null || fb === null)
-    return null;
-  if (fa === fb)
-    return 0;
-  return fa > fb ? 1 : -1;
-}
-function matchClause(rowValue, clause) {
-  const rowIsPrimitive = isPrimitive(rowValue) || typeof rowValue === "bigint";
-  if (isPrimitive(clause)) {
-    if (!rowIsPrimitive)
-      return false;
-    if (typeof clause === "number" || typeof rowValue === "number" || typeof rowValue === "bigint") {
-      const cmp = compareNumeric(rowValue, clause);
-      if (cmp !== null)
-        return cmp === 0;
-    }
-    return rowValue === clause || String(rowValue) === String(clause);
-  }
-  if (clause === null || typeof clause !== "object" || Array.isArray(clause)) {
-    return false;
-  }
-  const keys = Object.keys(clause);
-  if (keys.length !== 1)
-    return false;
-  const op = keys[0];
-  const c = clause;
-  switch (op) {
-    case "eq":
-      return matchClause(rowValue, c.eq);
-    case "neq":
-      return !matchClause(rowValue, c.neq);
-    case "gt":
-    case "gte":
-    case "lt":
-    case "lte": {
-      if (!rowIsPrimitive)
-        return false;
-      const cmp = compareNumeric(rowValue, c[op]);
-      if (cmp === null)
-        return false;
-      if (op === "gt")
-        return cmp > 0;
-      if (op === "gte")
-        return cmp >= 0;
-      if (op === "lt")
-        return cmp < 0;
-      return cmp <= 0;
-    }
-    case "in": {
-      const list = c.in;
-      if (!Array.isArray(list))
-        return false;
-      if (!rowIsPrimitive)
-        return false;
-      return list.some((item) => isPrimitive(item) && matchClause(rowValue, item));
-    }
-    default:
-      return false;
-  }
-}
-function matchesFilter(filter, row) {
-  if (!filter || Object.keys(filter).length === 0)
-    return true;
-  for (const [col, clause] of Object.entries(filter)) {
-    if (!matchClause(row[col], clause))
-      return false;
-  }
-  return true;
-}
-function key(subgraphName, tableName) {
-  return `${subgraphName}\x00${tableName}`;
-}
-
-class WebhookMatcher {
-  byKey = new Map;
-  byId = new Map;
-  setAll(subs) {
-    this.byKey.clear();
-    this.byId.clear();
-    for (const sub of subs) {
-      if (sub.status !== "active")
-        continue;
-      if (sub.kind !== "subgraph" || !sub.subgraph_name || !sub.table_name)
-        continue;
-      this.byId.set(sub.id, sub);
-      const k = key(sub.subgraph_name, sub.table_name);
-      const arr = this.byKey.get(k);
-      if (arr)
-        arr.push(sub);
-      else
-        this.byKey.set(k, [sub]);
-    }
-  }
-  match(subgraphName, tableName, row) {
-    const bucket = this.byKey.get(key(subgraphName, tableName));
-    if (!bucket)
-      return [];
-    const hits = [];
-    for (const sub of bucket) {
-      if (matchesFilter(sub.filter, row))
-        hits.push(sub);
-    }
-    return hits;
-  }
-  has(subgraphName, tableName) {
-    return this.byKey.has(key(subgraphName, tableName));
-  }
-  size() {
-    return this.byId.size;
-  }
-  get(id) {
-    return this.byId.get(id);
-  }
-}
-
-// src/runtime/webhook-state.ts
-var matcher = new WebhookMatcher;
-async function refreshMatcher(db) {
-  const rows = await sql3`
-		SELECT * FROM webhooks WHERE status = 'active'
-	`.execute(db);
-  matcher.setAll(rows.rows);
-  return matcher.size();
-}
-
-// src/runtime/block-processor.ts
-var routeCache = new Map;
-async function resolveRoute(subgraphName, targetDb) {
-  const cached = routeCache.get(subgraphName);
-  if (cached)
-    return cached;
-  const row = await targetDb.selectFrom("subgraphs").selectAll().where("name", "=", subgraphName).executeTakeFirst();
-  const route = {
-    schemaName: row?.schema_name ?? pgSchemaName(subgraphName),
-    dataDb: targetDb,
-    sandboxWorkers: row?.sandbox_workers === true,
-    handlerCode: row?.handler_code ?? null,
-    version: row?.version ?? ""
-  };
-  routeCache.set(subgraphName, route);
-  logger8.info("subgraph handler dispatch path resolved", {
-    subgraph: subgraphName,
-    path: sandboxEnabled({ sandbox_workers: route.sandboxWorkers }) ? "sandbox" : "in-process"
-  });
-  return route;
-}
-function invalidateSubgraphRoute(subgraphName) {
-  routeCache.delete(subgraphName);
-  evictSandboxWorker(subgraphName);
-}
-async function resolveFactoryContracts(subgraph, blockHeight, schemaName, db, txs, evts, vmEvts = []) {
-  const factories = new Map;
-  for (const source of Object.values(subgraph.sources)) {
-    const factory = source.factory;
-    if (factory)
-      factories.set(factory.from, factory);
-  }
-  const resolved = new Map;
-  const discovered = [];
-  if (factories.size === 0)
-    return { resolved, discovered };
-  for (const [discoveringSource, factory] of factories) {
-    const known = new Set;
-    try {
-      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)
-        known.add(row.address);
-    } catch {}
-    const discovering = subgraph.sources[factory.from];
-    if (discovering) {
-      const matches = matchSources({ [factory.from]: discovering }, txs, evts, new Map, new Map, vmEvts);
-      for (const match of matches) {
-        for (const event of match.events ?? []) {
-          const payload = buildEventPayload(discovering, match.tx, event);
-          const value = readPath(payload, factory.field);
-          if (typeof value === "string" && value.length > 0 && !known.has(value)) {
-            known.add(value);
-            discovered.push({ sourceName: discoveringSource, address: value });
-          }
-        }
-      }
-    }
-    resolved.set(discoveringSource, known);
-  }
-  return { resolved, discovered };
-}
-async function persistFactoryDiscoveries(schemaName, db, blockHeight, discovered) {
-  if (discovered.length === 0)
-    return;
-  for (const { sourceName, address } of discovered) {
-    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
-		`.execute(db);
-  }
-}
-async function resolveTraitContracts(subgraph, blockHeight, db) {
-  const traits = new Set;
-  for (const source of Object.values(subgraph.sources)) {
-    const trait = source.trait;
-    if (trait)
-      traits.add(trait);
-  }
-  const resolved = new Map;
-  for (const trait of traits) {
-    const ids = await resolveTraitContractIds(db, trait, blockHeight);
-    resolved.set(trait, new Set(ids));
-  }
-  return resolved;
-}
-
-class CursorRaceLostError extends Error {
-  constructor(operationId, height) {
-    super(`op ${operationId} lost cursor race at block ${height}`);
-    this.name = "CursorRaceLostError";
-  }
-}
-
-class LiveCursorRaceLostError extends Error {
-  constructor(subgraphName, height) {
-    super(`live cursor race lost for ${subgraphName} at block ${height}`);
-    this.name = "LiveCursorRaceLostError";
-  }
-}
-function opCursorMode(opts) {
-  const ap = opts?.atomicProgress;
-  return ap && "operationId" in ap ? ap : undefined;
-}
-function isReorgRewind(opts) {
-  return opts?.reorgRewind === true;
-}
-function statusMode(opts) {
-  const ap = opts?.atomicProgress;
-  return ap && "status" in ap ? ap : undefined;
-}
-var BLOCK_RETRY_DELAYS_MS = [500, 2000, 5000];
-function journalEnabled(opts) {
-  return !opts?.skipProgressUpdate;
-}
-async function processBlockWithRetry(subgraph, subgraphName, blockHeight, opts, retryDelaysMs = BLOCK_RETRY_DELAYS_MS) {
-  let lastError;
-  for (let attempt = 0;attempt <= retryDelaysMs.length; attempt++) {
-    try {
-      return await processBlock(subgraph, subgraphName, blockHeight, opts);
-    } catch (err) {
-      lastError = err;
-      const delay = retryDelaysMs[attempt];
-      if (delay === undefined)
-        break;
-      logger8.warn("Block processing failed, retrying", {
-        subgraph: subgraphName,
-        blockHeight,
-        attempt: attempt + 1,
-        retryInMs: delay,
-        error: err instanceof Error ? err.message : String(err)
-      });
-      await new Promise((r) => setTimeout(r, delay));
-    }
-  }
-  throw lastError;
-}
-async function processBlock(subgraph, subgraphName, blockHeight, opts) {
-  const targetDb = getTargetDb2();
-  const blockStart = performance.now();
-  const result = {
-    blockHeight,
-    matched: 0,
-    processed: 0,
-    errors: 0,
-    skipped: false
-  };
-  let block;
-  let txs;
-  let evts;
-  let vmEvts;
-  if (opts?.preloaded) {
-    block = opts.preloaded.block;
-    txs = opts.preloaded.txs;
-    evts = opts.preloaded.events;
-    vmEvts = opts.preloaded.vmEvents ?? [];
-  } else {
-    const data = (await resolveBlockSource(subgraph).loadBlockRange(blockHeight, blockHeight)).get(blockHeight);
-    if (!data) {
-      logger8.debug("Block not found or non-canonical for subgraph processing", {
-        subgraph: subgraphName,
-        blockHeight
-      });
-      result.skipped = true;
-      return result;
-    }
-    block = data.block;
-    txs = data.txs;
-    evts = data.events;
-    vmEvts = data.vmEvents ?? [];
-  }
-  const route = await resolveRoute(subgraphName, targetDb);
-  const schemaName = route.schemaName;
-  const traitContracts = await resolveTraitContracts(subgraph, blockHeight, targetDb);
-  const { resolved: factoryContracts, discovered } = await resolveFactoryContracts(subgraph, blockHeight, schemaName, targetDb, txs, evts, vmEvts);
-  const matched = matchSources(subgraph.sources, txs, evts, traitContracts, factoryContracts, vmEvts);
-  result.matched = matched.length;
-  if (matched.length === 0) {
-    if (!opts?.skipProgressUpdate) {
-      if (isReorgRewind(opts)) {
-        await rewindLiveProgress(targetDb, subgraphName, blockHeight);
-      } else {
-        await recordLiveProgress(targetDb, subgraphName, blockHeight);
-      }
-    }
-    return result;
-  }
-  const blockMeta = {
-    height: block.height,
-    hash: block.hash,
-    timestamp: block.timestamp,
-    burnBlockHeight: block.burn_block_height,
-    indexBlockHash: block.index_block_hash
-  };
-  const initialTx = {
-    txId: "",
-    sender: "",
-    type: "",
-    status: ""
-  };
-  let handlerMs = 0;
-  let flushMs = 0;
-  const applyProgress = async (tx, rr, flushedWrites) => {
-    if (opts?.skipProgressUpdate)
-      return;
-    const rewind = isReorgRewind(opts);
-    if (rr.errors > 0 && rr.processed === 0) {
-      if (rewind) {
-        await updateSubgraphStatus(tx, subgraphName, "error", blockHeight);
-      } else {
-        await recordLiveError(tx, subgraphName, blockHeight);
-      }
-    } else if (rewind) {
-      await rewindLiveProgress(tx, subgraphName, blockHeight);
-    } else {
-      const advanced = await recordLiveProgress(tx, subgraphName, blockHeight);
-      if (!advanced && flushedWrites) {
-        throw new LiveCursorRaceLostError(subgraphName, blockHeight);
-      }
-    }
-    if (rr.errors > 0 && !rewind) {
-      if (opts?.subgraphId) {
-        await recordGapBatch(tx, opts.subgraphId, subgraphName, [
-          { start: blockHeight, end: blockHeight, reason: "processing_error" }
-        ]);
-      } else {
-        logger8.warn("Block errors not recorded as a gap — no subgraphId", {
-          subgraph: subgraphName,
-          blockHeight,
-          errors: rr.errors
-        });
-      }
-    }
-    if (rr.processed > 0 || rr.errors > 0) {
-      const lastError = rr.errors > 0 ? `${rr.errors} error(s) at block ${blockHeight}` : undefined;
-      await recordSubgraphProcessed(tx, subgraphName, rr.processed, rr.errors, lastError);
-    }
-  };
-  try {
-    await targetDb.transaction().execute(async (tx) => {
-      const opMode = opCursorMode(opts);
-      const sm = statusMode(opts);
-      const rewind = isReorgRewind(opts);
-      if (sm) {
-        const row = await tx.selectFrom("subgraphs").select("last_processed_block").where("name", "=", subgraphName).executeTakeFirst();
-        if (row && Number(row.last_processed_block) >= blockHeight) {
-          result.skipped = true;
-          return;
-        }
-      } else if (opMode) {
-        const row = await tx.selectFrom("subgraph_operations").select("cursor_block").where("id", "=", opMode.operationId).executeTakeFirst();
-        if (row?.cursor_block != null && Number(row.cursor_block) >= blockHeight) {
-          result.skipped = true;
-          return;
-        }
-      } else if (!rewind) {
-        const row = await tx.selectFrom("subgraphs").select("last_processed_block").where("name", "=", subgraphName).executeTakeFirst();
-        if (row && Number(row.last_processed_block) >= blockHeight) {
-          result.skipped = true;
-          return;
-        }
-      }
-      const ctx = new SubgraphContext(tx, schemaName, subgraph.schema, blockMeta, initialTx, journalEnabled(opts));
-      const handlerStart = performance.now();
-      const runResult = sandboxEnabled({
-        sandbox_workers: route.sandboxWorkers
-      }) ? await runHandlersSandboxed({
-        subgraphName,
-        version: route.version,
-        handlerCode: route.handlerCode,
-        hostCtx: ctx,
-        block: blockMeta,
-        matched
-      }) : await runHandlers(subgraph, matched, ctx);
-      handlerMs = performance.now() - handlerStart;
-      result.processed = runResult.processed;
-      result.errors = runResult.errors;
-      let flushedWrites = false;
-      if (ctx.pendingOps > 0) {
-        const flushStart = performance.now();
-        const manifest = await ctx.flush();
-        flushedWrites = manifest.count > 0;
-        if (manifest.count > 0) {
-          await emitWebhookOutbox(tx, subgraphName, manifest, matcher, block.height);
-        }
-        flushMs = performance.now() - flushStart;
-      }
-      if (sm && flushedWrites) {
-        await updateSubgraphStatus(tx, subgraphName, sm.status, blockHeight);
-      } else if (opMode && flushedWrites) {
-        const advanced = await advanceOperationCursor(tx, opMode.operationId, blockHeight);
-        if (!advanced) {
-          throw new CursorRaceLostError(opMode.operationId, blockHeight);
-        }
-      }
-      await applyProgress(tx, runResult, flushedWrites);
-    });
-  } catch (err) {
-    if (err instanceof CursorRaceLostError || err instanceof LiveCursorRaceLostError) {
-      logger8.warn("cursor race lost — block already covered", {
-        subgraph: subgraphName,
-        blockHeight,
-        error: err.message
-      });
-      result.skipped = true;
-      return result;
-    }
-    throw err;
-  }
-  if (!result.skipped) {
-    await persistFactoryDiscoveries(schemaName, route.dataDb, blockHeight, discovered);
-  }
-  const totalMs = performance.now() - blockStart;
-  if (!result.skipped) {
-    result.timing = {
-      totalMs: Math.round(totalMs),
-      handlerMs: Math.round(handlerMs),
-      flushMs: Math.round(flushMs)
-    };
-  }
-  if (blockHeight % 1000 === 0) {
-    try {
-      const tables = Object.keys(subgraph.schema);
-      for (const table of tables) {
-        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) {
-          logger8.warn("Subgraph table exceeds 10M rows (estimate)", {
-            subgraph: subgraphName,
-            table,
-            count
-          });
-        }
-      }
-    } catch (err) {
-      logger8.debug("Row count sample failed", {
-        subgraph: subgraphName,
-        error: err instanceof Error ? err.message : String(err)
-      });
-    }
-    if (journalEnabled(opts)) {
-      await sql4.raw(`DELETE FROM "${schemaName}"."_journal" WHERE "block_height" < ${blockHeight - JOURNAL_RETENTION_BLOCKS}`).execute(route.dataDb).catch(() => {});
-    }
-  }
-  return result;
-}
-
-// src/runtime/stats.ts
-var FLUSH_INTERVAL_BLOCKS = 100;
-var FLUSH_INTERVAL_MS = 60000;
-
-class StatsAccumulator {
-  subgraphName;
-  isCatchup;
-  current;
-  lastFlush = Date.now();
-  constructor(subgraphName, isCatchup) {
-    this.subgraphName = subgraphName;
-    this.isCatchup = isCatchup;
-    this.current = this.newEntry();
-  }
-  record(timing, opsCount) {
-    this.current.blocksProcessed++;
-    this.current.totalTimeMs += timing.totalMs;
-    this.current.handlerTimeMs += timing.handlerMs;
-    this.current.flushTimeMs += timing.flushMs;
-    this.current.maxBlockTimeMs = Math.max(this.current.maxBlockTimeMs, timing.totalMs);
-    this.current.maxHandlerTimeMs = Math.max(this.current.maxHandlerTimeMs, timing.handlerMs);
-    this.current.totalOps += opsCount;
-  }
-  shouldFlush() {
-    return this.current.blocksProcessed >= FLUSH_INTERVAL_BLOCKS || Date.now() - this.lastFlush >= FLUSH_INTERVAL_MS;
-  }
-  async flush(db) {
-    if (this.current.blocksProcessed === 0)
-      return;
-    const entry = this.current;
-    this.current = this.newEntry();
-    this.lastFlush = Date.now();
-    const avgOpsPerBlock = entry.blocksProcessed > 0 ? entry.totalOps / entry.blocksProcessed : 0;
-    await db.insertInto("subgraph_processing_stats").values({
-      subgraph_name: entry.subgraphName,
-      bucket_start: entry.bucketStart,
-      bucket_end: new Date,
-      blocks_processed: entry.blocksProcessed,
-      total_time_ms: Math.round(entry.totalTimeMs),
-      handler_time_ms: Math.round(entry.handlerTimeMs),
-      flush_time_ms: Math.round(entry.flushTimeMs),
-      max_block_time_ms: Math.round(entry.maxBlockTimeMs),
-      max_handler_time_ms: Math.round(entry.maxHandlerTimeMs),
-      avg_ops_per_block: Number.parseFloat(avgOpsPerBlock.toFixed(2)),
-      is_catchup: entry.isCatchup
-    }).execute();
-  }
-  newEntry() {
-    return {
-      subgraphName: this.subgraphName,
-      bucketStart: new Date,
-      blocksProcessed: 0,
-      totalTimeMs: 0,
-      handlerTimeMs: 0,
-      flushTimeMs: 0,
-      maxBlockTimeMs: 0,
-      maxHandlerTimeMs: 0,
-      totalOps: 0,
-      isCatchup: this.isCatchup
-    };
-  }
-}
-
-// src/runtime/catchup.ts
-import { getTargetDb as getTargetDb3, sql as sql5 } from "@secondlayer/shared/db";
-import { getSubgraph } from "@secondlayer/shared/db/queries/subgraphs";
-import { logger as logger9 } 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/decoder-bound.ts
-import { decodeStreamsCursor, isEmptyRangeCursor } from "@secondlayer/shared";
-import { getSourceDb as getSourceDb3 } from "@secondlayer/shared/db";
-function decoderNameForEventType(indexEventType) {
-  return `decode.${indexEventType}.v1`;
-}
-function decoderNamesForIndexEventTypes(eventTypes) {
-  return eventTypes.filter((t) => !VM_INDEX_EVENT_TYPES.has(t)).map(decoderNameForEventType);
-}
-function decoderNamesForSubgraph(subgraph) {
-  return decoderNamesForIndexEventTypes(referencedIndexEventTypes(subgraph));
-}
-function usesDecodedIndexPlane(subgraph) {
-  return process.env.SUBGRAPH_SOURCE === "streams-index" && isStreamsIndexEligible(subgraph);
-}
-function committedHeight(cursor) {
-  if (!cursor)
-    return null;
-  try {
-    const decoded = decodeStreamsCursor(cursor);
-    if (isEmptyRangeCursor(decoded))
-      return decoded.block_height;
-    return Math.max(0, decoded.block_height - 1);
-  } catch {
-    return null;
-  }
-}
-async function decoderBoundTip(decoderNames, opts) {
-  if (decoderNames.length === 0)
-    return { kind: "unbounded" };
-  const sourceDb = opts?.sourceDb ?? getSourceDb3();
-  const rows = await sourceDb.selectFrom("decoder_checkpoints").select(["decoder_name", "last_cursor"]).where("decoder_name", "in", decoderNames).execute();
-  const byName = new Map(rows.map((r) => [r.decoder_name, r.last_cursor]));
-  const missing = [];
-  const heights = [];
-  for (const name of decoderNames) {
-    const height = committedHeight(byName.get(name));
-    if (height === null)
-      missing.push(name);
-    else
-      heights.push(height);
-  }
-  if (missing.length > 0)
-    return { kind: "stall", missing };
-  return { kind: "height", height: Math.min(...heights) };
-}
-async function boundSourceTip(rawTip, decoderNames, opts) {
-  const bound = await decoderBoundTip(decoderNames, opts);
-  if (bound.kind === "stall")
-    return { ok: false, missing: bound.missing };
-  if (bound.kind === "unbounded") {
-    return { ok: true, tip: rawTip, floor: null };
-  }
-  return {
-    ok: true,
-    tip: Math.min(rawTip, bound.height),
-    floor: bound.height
-  };
-}
-
-// 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 getTargetDb3().transaction().execute(async (lockTx) => {
-    await sql5`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 = getTargetDb3();
-    const subgraphRow = await getSubgraph(targetDb, subgraphName);
-    if (!subgraphRow)
-      return 0;
-    const lastProcessedBlock = Number(subgraphRow.last_processed_block);
-    const rawTip = await source.getTip();
-    if (rawTip <= 0)
-      return 0;
-    let chainTip = rawTip;
-    if (usesDecodedIndexPlane(subgraph)) {
-      const bound = await boundSourceTip(rawTip, decoderNamesForSubgraph(subgraph));
-      if (!bound.ok) {
-        logger9.warn("Subgraph catch-up stalled: missing decoder checkpoint", {
-          event: "subgraph_catchup_decoder_stall",
-          subgraph: subgraphName,
-          missing: bound.missing
-        });
-        return 0;
-      }
-      if (bound.floor !== null && bound.floor < rawTip) {
-        logger9.debug("Subgraph catch-up tip bounded by decoder progress", {
-          event: "subgraph_catchup_decoder_floor",
-          subgraph: subgraphName,
-          rawTip,
-          floor: bound.floor,
-          tip: bound.tip
-        });
-      }
-      chainTip = bound.tip;
-    }
-    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;
-    logger9.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()) {
-        logger9.info("Lost catch-up leadership, stopping catch-up", {
-          subgraph: subgraphName,
-          processed
-        });
-        break;
-      }
-      const currentRow = await getSubgraph(targetDb, subgraphName);
-      if (!currentRow || currentRow.status !== "active") {
-        logger9.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) {
-          logger9.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,
-              subgraphId: subgraphRow.id
-            });
-          });
-        } catch (err) {
-          if (err instanceof ReorgEpochChangedError) {
-            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);
-          logger9.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) {
-          logger9.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);
-    logger9.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 getTargetDb4 } from "@secondlayer/shared/db";
-import {
-  recordGapBatch as recordGapBatch2,
-  resolveGaps
-} from "@secondlayer/shared/db/queries/subgraph-gaps";
-import {
-  advanceOperationCursor as advanceOperationCursor2,
-  updateOperationProcessedEvents
-} from "@secondlayer/shared/db/queries/subgraph-operations";
-import {
-  recordSubgraphProcessed as recordSubgraphProcessed2,
-  updateSubgraphStatus as updateSubgraphStatus2
-} from "@secondlayer/shared/db/queries/subgraphs";
-import { logger as logger11 } from "@secondlayer/shared/logger";
-
-// src/runtime/reindex-notify.ts
-import { getErrorMessage as getErrorMessage2 } from "@secondlayer/shared";
-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();
-    if (!subgraph)
-      return;
-    const account = await db.selectFrom("accounts").select(["email", "notify_reindex_complete"]).where("id", "=", subgraph.account_id).executeTakeFirst();
-    if (!account?.email || !account.notify_reindex_complete)
-      return;
-    const resendKey = process.env.RESEND_API_KEY;
-    if (!resendKey) {
-      logger10.warn("RESEND_API_KEY unset — skipping reindex-complete email", {
-        subgraph: subgraphName
-      });
-      return;
-    }
-    const from = process.env.EMAIL_FROM ?? "Secondlayer <noreply@secondlayer.tools>";
-    const body = stats.errors > 0 ? `Your subgraph "${subgraphName}" finished reindexing — ${stats.blocks.toLocaleString()} blocks, ${stats.events.toLocaleString()} events, ${stats.errors.toLocaleString()} errors. Check the dashboard for details.` : `Your subgraph "${subgraphName}" finished reindexing — ${stats.blocks.toLocaleString()} blocks, ${stats.events.toLocaleString()} events processed, no errors. It's live now.`;
-    const res = await fetch("https://api.resend.com/emails", {
-      method: "POST",
-      headers: {
-        Authorization: `Bearer ${resendKey}`,
-        "Content-Type": "application/json"
-      },
-      body: JSON.stringify({
-        from,
-        to: [account.email],
-        subject: `Reindex complete: ${subgraphName}`,
-        text: body
-      })
-    });
-    if (!res.ok) {
-      const text = await res.text().catch(() => "");
-      logger10.warn("reindex-complete email failed", {
-        subgraph: subgraphName,
-        status: res.status,
-        body: text.slice(0, 200)
-      });
-    }
-  } catch (err) {
-    logger10.warn("reindex-complete email threw", {
-      subgraph: subgraphName,
-      error: getErrorMessage2(err)
-    });
-  }
-}
-
-// src/runtime/reindex.ts
-var LOG_INTERVAL2 = 1000;
-var HEALTH_FLUSH_INTERVAL = 1000;
-var PROGRESS_FLUSH_INTERVAL_MS = 5000;
-var EMPTY_BATCH_HALT_THRESHOLD = 3;
-var STANDARD_REINDEX_BATCH_CONFIG = {
-  defaultBatchSize: 500,
-  minBatchSize: 100,
-  maxBatchSize: 1000
-};
-function initialReindexProgressBlock(fromBlock) {
-  return Math.max(0, fromBlock - 1);
-}
-function resolveReindexResumeBlock(row) {
-  if (row.reindex_from_block == null || row.reindex_to_block == null) {
-    return null;
-  }
-  const lastProcessedBlock = Number(row.last_processed_block);
-  const reindexFromBlock = Number(row.reindex_from_block);
-  return Math.max(lastProcessedBlock + 1, reindexFromBlock);
-}
-function parsePositiveInt2(value) {
-  if (value == null || value.trim() === "")
-    return;
-  const parsed = Number.parseInt(value, 10);
-  return Number.isFinite(parsed) && parsed > 0 ? parsed : undefined;
-}
-function resolveReindexBatchConfig(env = process.env) {
-  const base = STANDARD_REINDEX_BATCH_CONFIG;
-  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,
-    defaultBatchSize: Math.min(Math.max(defaultBatchSize, minBatchSize), maxBatchSize)
-  };
-}
-function coalesceFailedBlocks(blocks) {
-  if (blocks.length === 0)
-    return [];
-  blocks.sort((a, b) => a.height - b.height);
-  const ranges = [];
-  let start = blocks[0].height;
-  let end = blocks[0].height;
-  let reason = blocks[0].reason;
-  for (let i = 1;i < blocks.length; i++) {
-    const b = blocks[i];
-    if (b.height === end + 1 && b.reason === reason) {
-      end = b.height;
-    } else {
-      ranges.push({ start, end, reason });
-      start = b.height;
-      end = b.height;
-      reason = b.reason;
-    }
-  }
-  ranges.push({ start, end, reason });
-  return ranges;
-}
-async function processBlockRange(def, opts) {
-  const source = resolveBlockSource(def);
-  const targetDb = getTargetDb4();
-  const subgraphName = def.name;
-  const { fromBlock, toBlock, status } = opts;
-  const totalBlocks = toBlock - fromBlock + 1;
-  const stats = new StatsAccumulator(subgraphName, opts.isCatchup);
-  let blocksProcessed = 0;
-  let blocksSkippedByCursor = 0;
-  let totalEventsProcessed = 0;
-  let totalErrors = 0;
-  let pendingEventsProcessed = 0;
-  let pendingErrors = 0;
-  let pendingLastError;
-  let lastHealthFlushBlock = 0;
-  let lastHealthFlushAt = Date.now();
-  let lastProgressFlushAt = Date.now();
-  const batchConfig = resolveReindexBatchConfig();
-  let batchSize = batchConfig.defaultBatchSize;
-  let currentHeight = fromBlock;
-  let aborted = false;
-  let consecutiveEmptyBatches = 0;
-  const sparse = Boolean(source.nextDataHeight && canSparseScan(def));
-  const flushHealth = async () => {
-    if (pendingEventsProcessed === 0 && pendingErrors === 0)
-      return;
-    await recordSubgraphProcessed2(targetDb, subgraphName, pendingEventsProcessed, pendingErrors, pendingLastError);
-    pendingEventsProcessed = 0;
-    pendingErrors = 0;
-    pendingLastError = undefined;
-    lastHealthFlushBlock = blocksProcessed;
-    lastHealthFlushAt = Date.now();
-  };
-  const haltRange = async (errorMsg, height) => {
-    pendingErrors++;
-    pendingLastError = errorMsg;
-    await flushHealth().catch(() => {});
-    await updateSubgraphStatus2(targetDb, subgraphName, "error").catch(() => {});
-    throw new Error(`${subgraphName}: halted at block ${height}: ${errorMsg}`);
-  };
-  let nextBatchEnd = Math.min(currentHeight + batchSize - 1, toBlock);
-  let nextBatchPromise = source.loadBlockRange(currentHeight, nextBatchEnd);
-  while (currentHeight <= toBlock) {
-    if (opts.signal?.aborted) {
-      aborted = true;
-      logger11.info("Block processing aborted", {
-        subgraph: subgraphName,
-        currentBlock: currentHeight,
-        reason: String(opts.signal.reason ?? "unknown")
-      });
-      break;
-    }
-    const batch = await nextBatchPromise;
-    const batchEnd = nextBatchEnd;
-    if (batch.size === 0 && batchEnd >= currentHeight) {
-      consecutiveEmptyBatches++;
-      if (consecutiveEmptyBatches >= EMPTY_BATCH_HALT_THRESHOLD) {
-        await haltRange(`block source returned ${consecutiveEmptyBatches} consecutive empty batches (ending ${currentHeight}..${batchEnd}) — source degraded`, currentHeight);
-      }
-    } else {
-      consecutiveEmptyBatches = 0;
-    }
-    const nextStart = batchEnd + 1;
-    if (nextStart <= toBlock) {
-      nextBatchEnd = Math.min(nextStart + batchSize - 1, toBlock);
-      nextBatchPromise = source.loadBlockRange(nextStart, nextBatchEnd);
-    }
-    const batchFailedBlocks = [];
-    let batchMatched = 0;
-    const opCursor = status === "active" && opts.operationId ? { operationId: opts.operationId } : undefined;
-    const atomicProgress = status === "reindexing" ? { status } : opCursor;
-    for (let height = currentHeight;height <= batchEnd; height++) {
-      let blockData = batch.get(height);
-      if (!blockData) {
-        blockData = (await source.loadBlockRange(height, height)).get(height);
-      }
-      if (!blockData) {
-        if (status === "reindexing") {
-          const errorMsg = `block ${height} missing from source — halting reindex (cursor stays at ${height - 1})`;
-          await haltRange(errorMsg, height);
-        }
-        batchFailedBlocks.push({ height, reason: "block_missing" });
-        blocksProcessed++;
-        continue;
-      }
-      let result;
-      try {
-        const mayWrite = blockData.txs.length > 0 || blockData.events.length > 0 || (blockData.vmEvents?.length ?? 0) > 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);
-        logger11.error("Block processing failed persistently", {
-          subgraph: subgraphName,
-          blockHeight: height,
-          error: errorMsg
-        });
-        if (status === "reindexing") {
-          await haltRange(`block ${height} failed persistently: ${errorMsg}`, height);
-        }
-        batchFailedBlocks.push({ height, reason: "processing_error" });
-        blocksProcessed++;
-        totalErrors++;
-        pendingErrors++;
-        pendingLastError = errorMsg;
-        continue;
-      }
-      blocksProcessed++;
-      if (result.skipped)
-        blocksSkippedByCursor++;
-      batchMatched += result.matched;
-      totalEventsProcessed += result.processed;
-      totalErrors += result.errors;
-      pendingEventsProcessed += result.processed;
-      pendingErrors += result.errors;
-      if (result.errors > 0) {
-        pendingLastError = `${result.errors} error(s) while processing block ${height}`;
-      }
-      if (result.timing) {
-        stats.record(result.timing, result.processed);
-        if (stats.shouldFlush()) {
-          await stats.flush(targetDb);
-        }
-      }
-      const now = Date.now();
-      const shouldFlushProgress = blocksProcessed % 100 === 0 || now - lastProgressFlushAt >= PROGRESS_FLUSH_INTERVAL_MS;
-      if (shouldFlushProgress) {
-        if (opCursor) {
-          await advanceOperationCursor2(targetDb, opCursor.operationId, height);
-        } else {
-          await updateSubgraphStatus2(targetDb, subgraphName, status, height);
-        }
-        if (opts.operationId) {
-          await updateOperationProcessedEvents(targetDb, opts.operationId, totalEventsProcessed).catch(() => {});
-        }
-        lastProgressFlushAt = now;
-      }
-      if (blocksProcessed % LOG_INTERVAL2 === 0) {
-        logger11.info(`${status === "reindexing" ? "Reindex" : "Backfill"} progress`, {
-          subgraph: subgraphName,
-          processed: blocksProcessed,
-          total: totalBlocks,
-          currentBlock: height,
-          pct: Math.round(blocksProcessed / totalBlocks * 100),
-          ...blocksSkippedByCursor > 0 ? { skippedByCursor: blocksSkippedByCursor } : {}
-        });
-      }
-    }
-    if (status === "reindexing" && blocksProcessed > 0) {
-      await updateSubgraphStatus2(targetDb, subgraphName, status, batchEnd);
-    }
-    const shouldFlushHealth = blocksProcessed - lastHealthFlushBlock >= HEALTH_FLUSH_INTERVAL || Date.now() - lastHealthFlushAt >= PROGRESS_FLUSH_INTERVAL_MS;
-    if (shouldFlushHealth) {
-      await flushHealth();
-    }
-    if (batchFailedBlocks.length > 0 && opts.subgraphId) {
-      const gaps = coalesceFailedBlocks(batchFailedBlocks);
-      await recordGapBatch2(targetDb, opts.subgraphId, subgraphName, gaps).catch((err) => {
-        logger11.warn("Failed to record subgraph gaps", {
-          subgraph: subgraphName,
-          error: err instanceof Error ? err.message : String(err)
-        });
-      });
-    }
-    if (sparse && batchMatched === 0 && batchEnd < toBlock && source.nextDataHeight) {
-      const next = await source.nextDataHeight(batchEnd, toBlock);
-      const jumpTo = next === null ? toBlock + 1 : Math.max(next, batchEnd + 1);
-      if (jumpTo > batchEnd + 1) {
-        const skipped = Math.min(jumpTo, toBlock + 1) - (batchEnd + 1);
-        blocksProcessed += skipped;
-        if (opCursor) {
-          await advanceOperationCursor2(targetDb, opCursor.operationId, jumpTo - 1);
-        } else {
-          await updateSubgraphStatus2(targetDb, subgraphName, status, jumpTo - 1);
-        }
-        logger11.info("Sparse skip", {
-          subgraph: subgraphName,
-          from: batchEnd + 1,
-          to: jumpTo - 1,
-          skipped
-        });
-        currentHeight = jumpTo;
-        if (currentHeight <= toBlock) {
-          nextBatchEnd = Math.min(currentHeight + batchSize - 1, toBlock);
-          nextBatchPromise = source.loadBlockRange(currentHeight, nextBatchEnd);
-        }
-        continue;
-      }
-    }
-    const avg = avgEventsPerBlock(batch);
-    if (avg > 50)
-      batchSize = Math.max(Math.round(batchSize * 0.5), batchConfig.minBatchSize);
-    else if (avg < 10)
-      batchSize = Math.min(Math.round(batchSize * 1.5), batchConfig.maxBatchSize);
-    currentHeight = batchEnd + 1;
-  }
-  await stats.flush(targetDb);
-  await flushHealth();
-  return { blocksProcessed, totalEventsProcessed, totalErrors, aborted };
-}
-async function resolveBlockRange(source, def, opts) {
-  const definitionStart = def.startBlock ?? 1;
-  const fromBlock = opts?.startBlockFloor != null ? Math.max(definitionStart, opts.startBlockFloor) : definitionStart;
-  const rawTip = await source.getTip();
-  if (!usesDecodedIndexPlane(def)) {
-    return { fromBlock, toBlock: rawTip };
-  }
-  const bound = await boundSourceTip(rawTip, decoderNamesForSubgraph(def));
-  if (!bound.ok) {
-    logger11.warn("Reindex stalled: missing decoder checkpoint", {
-      event: "subgraph_reindex_decoder_stall",
-      subgraph: def.name,
-      missing: bound.missing
-    });
-    throw new Error(`Reindex stalled: missing decoder checkpoint (${bound.missing.join(", ")})`);
-  }
-  if (bound.floor !== null && bound.floor < rawTip) {
-    logger11.debug("Reindex tip bounded by decoder progress", {
-      event: "subgraph_reindex_decoder_floor",
-      subgraph: def.name,
-      rawTip,
-      floor: bound.floor,
-      tip: bound.tip
-    });
-  }
-  return { fromBlock, toBlock: bound.tip };
-}
-async function clearReindexMetadata(db, subgraphName) {
-  await db.updateTable("subgraphs").set({ reindex_from_block: null, reindex_to_block: null }).where("name", "=", subgraphName).execute();
-}
-async function reindexSubgraph(def, opts) {
-  const source = resolveBlockSource(def);
-  const targetDb = getTargetDb4();
-  const client = getRawClient("target");
-  const subgraphName = def.name;
-  const schemaName = opts?.schemaName ?? pgSchemaName(subgraphName);
-  await updateSubgraphStatus2(targetDb, subgraphName, "reindexing");
-  logger11.info("Reindex starting", { subgraph: subgraphName });
-  try {
-    const { fromBlock, toBlock } = await resolveBlockRange(source, def, opts);
-    if (fromBlock > toBlock) {
-      logger11.info("No blocks to reindex", {
-        subgraph: subgraphName,
-        fromBlock,
-        toBlock
-      });
-      await updateSubgraphStatus2(targetDb, subgraphName, "active", 0);
-      return { processed: 0 };
-    }
-    await client.unsafe(`DROP SCHEMA IF EXISTS "${schemaName}" CASCADE`);
-    const { statements } = generateSubgraphSQL(def, schemaName);
-    for (const stmt of statements) {
-      await client.unsafe(stmt);
-    }
-    await updateSubgraphStatus2(targetDb, subgraphName, "reindexing", Math.max(0, fromBlock - 1));
-    logger11.info("Schema recreated for reindex", {
-      subgraph: subgraphName,
-      cursorResetTo: Math.max(0, fromBlock - 1)
-    });
-    await targetDb.updateTable("subgraphs").set({
-      last_processed_block: initialReindexProgressBlock(fromBlock),
-      reindex_from_block: fromBlock,
-      reindex_to_block: toBlock,
-      total_processed: 0,
-      total_errors: 0,
-      last_error: null,
-      last_error_at: null,
-      updated_at: new Date
-    }).where("name", "=", subgraphName).execute();
-    logger11.info("Reindexing blocks", {
-      subgraph: subgraphName,
-      fromBlock,
-      toBlock,
-      totalBlocks: toBlock - fromBlock + 1
-    });
-    const subgraphRow = await targetDb.selectFrom("subgraphs").select(["id"]).where("name", "=", subgraphName).executeTakeFirst();
-    const result = await processBlockRange(def, {
-      fromBlock,
-      toBlock,
-      status: "reindexing",
-      isCatchup: false,
-      apiKeyId: null,
-      subgraphId: subgraphRow?.id,
-      operationId: opts?.operationId,
-      signal: opts?.signal
-    });
-    if (result.aborted) {
-      const reason = String(opts?.signal?.reason ?? "unknown");
-      if (reason === "user-cancelled") {
-        await updateSubgraphStatus2(targetDb, subgraphName, "active");
-        await clearReindexMetadata(targetDb, subgraphName);
-        logger11.info("Reindex cancelled by user", { subgraph: subgraphName });
-      } else {
-        logger11.info("Reindex interrupted by shutdown, will resume", {
-          subgraph: subgraphName
-        });
-      }
-      return { processed: result.blocksProcessed };
-    }
-    await updateSubgraphStatus2(targetDb, subgraphName, "active", toBlock);
-    await clearReindexMetadata(targetDb, subgraphName);
-    logger11.info("Reindex complete", {
-      subgraph: subgraphName,
-      blocks: result.blocksProcessed,
-      events: result.totalEventsProcessed,
-      errors: result.totalErrors
-    });
-    notifyReindexComplete(targetDb, subgraphName, {
-      blocks: result.blocksProcessed,
-      events: result.totalEventsProcessed,
-      errors: result.totalErrors
-    });
-    return { processed: result.blocksProcessed };
-  } catch (err) {
-    logger11.error("Reindex failed", {
-      subgraph: subgraphName,
-      error: getErrorMessage3(err)
-    });
-    await updateSubgraphStatus2(targetDb, subgraphName, "error");
-    throw err;
-  }
-}
-async function resumeReindex(def, opts) {
-  const targetDb = getTargetDb4();
-  const subgraphName = def.name;
-  const row = await targetDb.selectFrom("subgraphs").select([
-    "id",
-    "last_processed_block",
-    "reindex_from_block",
-    "reindex_to_block"
-  ]).where("name", "=", subgraphName).executeTakeFirst();
-  if (!row)
-    throw new Error(`Subgraph "${subgraphName}" not found`);
-  const fromBlock = resolveReindexResumeBlock(row);
-  const toBlock = Number(row.reindex_to_block);
-  if (fromBlock == null) {
-    logger11.info("No reindex metadata, starting fresh reindex", {
-      subgraph: subgraphName
-    });
-    return reindexSubgraph(def, {
-      schemaName: opts.schemaName,
-      signal: opts.signal
-    });
-  }
-  if (fromBlock > toBlock) {
-    logger11.info("Resume: no remaining blocks", { subgraph: subgraphName });
-    await updateSubgraphStatus2(targetDb, subgraphName, "active", toBlock);
-    await clearReindexMetadata(targetDb, subgraphName);
-    return { processed: 0 };
-  }
-  logger11.info("Resuming reindex", {
-    subgraph: subgraphName,
-    fromBlock,
-    toBlock,
-    remaining: toBlock - fromBlock + 1
-  });
-  try {
-    const result = await processBlockRange(def, {
-      fromBlock,
-      toBlock,
-      status: "reindexing",
-      isCatchup: false,
-      apiKeyId: null,
-      subgraphId: row.id,
-      operationId: opts.operationId,
-      signal: opts.signal
-    });
-    if (result.aborted) {
-      const reason = String(opts.signal?.reason ?? "unknown");
-      if (reason === "user-cancelled") {
-        await updateSubgraphStatus2(targetDb, subgraphName, "active");
-        await clearReindexMetadata(targetDb, subgraphName);
-        logger11.info("Resume cancelled by user", { subgraph: subgraphName });
-      } else {
-        logger11.info("Resume interrupted by shutdown, will resume again", {
-          subgraph: subgraphName
-        });
-      }
-      return { processed: result.blocksProcessed };
-    }
-    await updateSubgraphStatus2(targetDb, subgraphName, "active", toBlock);
-    await clearReindexMetadata(targetDb, subgraphName);
-    logger11.info("Resumed reindex complete", {
-      subgraph: subgraphName,
-      blocks: result.blocksProcessed
-    });
-    return { processed: result.blocksProcessed };
-  } catch (err) {
-    logger11.error("Resumed reindex failed", {
-      subgraph: subgraphName,
-      error: getErrorMessage3(err)
-    });
-    await updateSubgraphStatus2(targetDb, subgraphName, "error");
-    throw err;
-  }
-}
-async function backfillSubgraph(def, opts) {
-  const targetDb = getTargetDb4();
-  const subgraphName = def.name;
-  logger11.info("Backfill starting", {
-    subgraph: subgraphName,
-    from: opts.fromBlock,
-    to: opts.toBlock
-  });
-  try {
-    const subgraphRow = await targetDb.selectFrom("subgraphs").select(["id"]).where("name", "=", subgraphName).executeTakeFirst();
-    const result = await processBlockRange(def, {
-      fromBlock: opts.fromBlock,
-      toBlock: opts.toBlock,
-      status: "active",
-      isCatchup: false,
-      apiKeyId: null,
-      subgraphId: subgraphRow?.id,
-      operationId: opts.operationId,
-      signal: opts.signal
-    });
-    if (result.aborted) {
-      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) {
-      logger11.info("Resolved subgraph gaps via backfill", {
-        subgraph: subgraphName,
-        resolved
-      });
-    }
-    logger11.info("Backfill complete", {
-      subgraph: subgraphName,
-      blocks: result.blocksProcessed,
-      events: result.totalEventsProcessed,
-      errors: result.totalErrors
-    });
-    return { processed: result.blocksProcessed };
-  } catch (err) {
-    logger11.error("Backfill failed", {
-      subgraph: subgraphName,
-      error: getErrorMessage3(err)
-    });
-    throw err;
-  }
-}
-export {
-  resumeReindex,
-  resolveReindexResumeBlock,
-  resolveReindexBatchConfig,
-  resolveBlockRange,
-  reindexSubgraph,
-  initialReindexProgressBlock,
-  backfillSubgraph
-};
-
-//# debugId=8D0663264E89460C64756E2164756E21
-//# sourceMappingURL=reindex.js.map