@secondlayer/subgraphs 3.12.0 → 3.14.0

package/dist/src/runtime/context.d.ts

@@ -43,6 +43,9 @@ type ComputedValue = RowValue | ((existing: Record<string, unknown> | null) => u
 import { Database } from "@secondlayer/shared/db";
 import { Kysely, Transaction } from "kysely";
 type AnyDb = Kysely<Database> | Transaction<Database>;
+/** Reorg journal entries older than this many blocks are prunable — far past
+*  Stacks finality (observed reorg depth is single digits). */
+declare const JOURNAL_RETENTION_BLOCKS = 300;
 interface FlushWrite {
 	op: "insert" | "update" | "delete";
 	table: string;
@@ -76,7 +79,12 @@ interface TxMeta2 {
 /**
 * Runtime context passed to subgraph handlers.
 * Batches writes and flushes them atomically at the end of a block.
-* Reads execute immediately against the DB (pre-flush state).
+*
+* Row reads (findOne/findMany) are read-your-writes: they overlay the pending
+* ops queue on the DB state, so a handler observes every write queued earlier
+* in the same block. Without this, accumulator patterns (balance = f(existing))
+* silently lose all but the last same-block delta per row (fix-f040 B1).
+* Aggregate reads (count/sum/min/max) remain pre-flush DB state.
 */
 declare class SubgraphContext2 {
 	readonly block: BlockMeta;
@@ -93,7 +101,14 @@ declare class SubgraphContext2 {
 	* Non-idempotent `update` handlers are rejected at deploy, not here.
 	*/
 	private readonly byo;
-	constructor(db: AnyDb, pgSchemaName: string, subgraphSchema: SubgraphSchema, block: BlockMeta, tx: TxMeta2, byo?: boolean);
+	/**
+	* Record pre-images of keyed mutations into the schema's `_journal` so a
+	* reorg can restore prior row states (fix-f040 B2). Enabled on the live
+	* path only — deep reindex/backfill heights are past finality, and the
+	* journal would just be churn the pruner deletes.
+	*/
+	private readonly journal;
+	constructor(db: AnyDb, pgSchemaName: string, subgraphSchema: SubgraphSchema, block: BlockMeta, tx: TxMeta2, byo?: boolean, journal?: boolean);
 	get tx(): TxMeta2;
 	/** Update the current transaction context (used by runner between events) */
 	setTx(tx: TxMeta2): void;
@@ -101,6 +116,24 @@ declare class SubgraphContext2 {
 	update(table: string, where: Record<string, unknown>, set: Record<string, unknown>): void;
 	upsert(table: string, key: Record<string, unknown>, row: Record<string, unknown>): void;
 	delete(table: string, where: Record<string, unknown>): void;
+	/**
+	* Atomic counter update — the blessed accumulator primitive. Compiles to
+	* `INSERT ... ON CONFLICT (key) DO UPDATE SET col = COALESCE(t.col,0) + delta`,
+	* so deltas commute: same-block, replayed-in-order, and concurrent updates
+	* all land correctly without read-modify-write. Missing row inserts the
+	* delta as the initial value. Requires a uniqueKeys constraint matching
+	* `key`; deltas may be negative.
+	*/
+	increment(table: string, key: Record<string, unknown>, deltas: Record<string, bigint | number>): void;
+	/** Current length of the pending-ops queue. Pair with {@link rollbackTo}. */
+	opsCheckpoint(): number;
+	/**
+	* Discard ops queued after a checkpoint. The runner wraps each handler
+	* invocation so a thrown handler contributes nothing — without this, a
+	* transfer handler that debited then threw flushes a one-sided debit
+	* (fix-f040 B6).
+	*/
+	rollbackTo(checkpoint: number): void;
 	/** Partial update — sets only specified fields, preserves everything else */
 	patch(table: string, where: Record<string, unknown>, set: Record<string, unknown>): void;
 	/**
@@ -112,6 +145,17 @@ declare class SubgraphContext2 {
 	formatUnits(value: bigint, decimals: number): string;
 	findOne(table: string, where: Record<string, unknown>): Promise<Record<string, unknown> | null>;
 	findMany(table: string, where: Record<string, unknown>): Promise<Record<string, unknown>[]>;
+	/**
+	* Replay pending ops for `table` over a single DB-read result so reads
+	* observe earlier same-block writes. Mirrors flush semantics: upserts
+	* merge non-key/non-meta columns, increments add deltas, updates/deletes
+	* apply by where-match. Overlaid rows synthesized from pending inserts
+	* lack DB-generated columns (_id, _created_at).
+	*/
+	private overlayOne;
+	private overlayMany;
+	/** Apply one pending op to a candidate row state (null = row absent). */
+	private applyOpToRow;
 	count(table: string, where?: Record<string, unknown>): Promise<number>;
 	sum(table: string, column: string, where?: Record<string, unknown>): Promise<bigint>;
 	min(table: string, column: string, where?: Record<string, unknown>): Promise<bigint | null>;
@@ -132,8 +176,26 @@ declare class SubgraphContext2 {
 	flush(): Promise<FlushManifest>;
 	/** Prepare a single insert row, returning its data, columns, upsert key for batching. */
 	private prepareInsert;
+	/**
+	* Lazily create `_journal` for schemas deployed before it existed. Cached
+	* per process only once CONFIRMED present (to_regclass) — a CREATE issued
+	* inside a block tx could roll back with it, so self-created tables are
+	* re-verified on the next flush instead of trusted.
+	*/
+	private ensureJournalTable;
+	/** SQL type of a user column (for casting journal key VALUES), if known. */
+	private columnSqlType;
+	/**
+	* Journal pre-images for a keyed batch: one `_journal` row per key with the
+	* row's current state (`prev_row`), or NULL when the key doesn't exist yet
+	* (the mutation will create it — a revert deletes it). Emitted BEFORE the
+	* mutation statement, same transaction.
+	*/
+	private journalCaptureSQL;
+	/** Journal pre-images of rows a where-clause mutation will touch, keyed by `_id`. */
+	private journalCaptureByWhereSQL;
 	/** Build SQL statements from write ops, batching compatible INSERTs. */
 	private buildStatements;
 	private validateTable;
 }
-export { TxMeta2 as TxMeta, SubgraphContext2 as SubgraphContext, FlushWrite, FlushManifest, BlockMeta };
+export { TxMeta2 as TxMeta, SubgraphContext2 as SubgraphContext, JOURNAL_RETENTION_BLOCKS, FlushWrite, FlushManifest, BlockMeta };

package/dist/src/runtime/context.js

@@ -5,6 +5,134 @@ var __require = /* @__PURE__ */ createRequire(import.meta.url);
 import { logger } 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";
+
+// src/schema/generator.ts
+var TYPE_MAP = {
+  text: "TEXT",
+  uint: "NUMERIC",
+  int: "NUMERIC",
+  principal: "TEXT",
+  boolean: "BOOLEAN",
+  timestamp: "TIMESTAMPTZ",
+  jsonb: "JSONB"
+};
+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 = `${schemaName}.${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 = `${colName} ${sqlType}${nullable}`;
+    if (col.default !== undefined) {
+      colDef += ` DEFAULT ${escapeLiteralDefault(col.default)}`;
+    }
+    if (col.type === "uint") {
+      colDef += ` CHECK (${colName} >= 0)`;
+    }
+    columnDefs.push(colDef);
+  }
+  statements.push(`CREATE TABLE IF NOT EXISTS ${qualifiedName} (
+  ${columnDefs.join(`,
+  `)}
+)`);
+  statements.push(`CREATE INDEX IF NOT EXISTS idx_${schemaName}_${tableName}_block_height ON ${qualifiedName} (_block_height)`);
+  statements.push(`CREATE INDEX IF NOT EXISTS idx_${schemaName}_${tableName}_tx_id ON ${qualifiedName} (_tx_id)`);
+  for (const [colName, col] of Object.entries(tableDef.columns)) {
+    if (col.indexed) {
+      statements.push(`CREATE INDEX IF NOT EXISTS idx_${schemaName}_${tableName}_${colName} ON ${qualifiedName} (${colName})`);
+    }
+  }
+  for (const [colName, col] of Object.entries(tableDef.columns)) {
+    if (col.search) {
+      statements.push(`CREATE INDEX IF NOT EXISTS idx_${schemaName}_${tableName}_${colName}_trgm ON ${qualifiedName} USING gin (${colName} gin_trgm_ops)`);
+    }
+  }
+  if (tableDef.indexes) {
+    for (let i = 0;i < tableDef.indexes.length; i++) {
+      const cols = tableDef.indexes[i];
+      const idxName = `idx_${schemaName}_${tableName}_composite_${i}`;
+      statements.push(`CREATE INDEX IF NOT EXISTS ${idxName} ON ${qualifiedName} (${cols.join(", ")})`);
+    }
+  }
+  if (tableDef.uniqueKeys) {
+    for (let i = 0;i < tableDef.uniqueKeys.length; i++) {
+      const cols = tableDef.uniqueKeys[i];
+      const constraintName = `uq_${schemaName}_${tableName}_${cols.join("_")}`;
+      statements.push(`ALTER TABLE ${qualifiedName} ADD CONSTRAINT ${constraintName} UNIQUE (${cols.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 emitForeignKeyDDL(schemaName, tableName, tableDef) {
+  return (tableDef.relations ?? []).map((rel) => {
+    const constraintName = `fk_${schemaName}_${tableName}_${rel.name}`;
+    return `ALTER TABLE ${schemaName}.${tableName} ADD CONSTRAINT ${constraintName} ` + `FOREIGN KEY (${rel.fields.join(", ")}) ` + `REFERENCES ${schemaName}.${rel.references} (${rel.referencedColumns.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));
+  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/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}`);
@@ -19,13 +147,15 @@ class SubgraphContext {
   subgraphSchema;
   ops = [];
   byo;
-  constructor(db, pgSchemaName, subgraphSchema, block, tx, byo = false) {
+  journal;
+  constructor(db, pgSchemaName2, subgraphSchema, block, tx, byo = false, journal = false) {
     this.db = db;
-    this.pgSchemaName = pgSchemaName;
+    this.pgSchemaName = pgSchemaName2;
     this.subgraphSchema = subgraphSchema;
     this.block = block;
     this._tx = tx;
     this.byo = byo;
+    this.journal = journal;
   }
   get tx() {
     return this._tx;
@@ -81,6 +211,43 @@ class SubgraphContext {
     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);
   }
@@ -102,7 +269,7 @@ class SubgraphContext {
     const query = `SELECT * FROM ${qualifiedTable} WHERE ${clause} LIMIT 1`;
     const { rows } = await sql.raw(query).execute(this.db);
     const row = rows[0] ?? null;
-    return row ? this.coerceRow(table, row) : null;
+    return this.overlayOne(table, where, row ? this.coerceRow(table, row) : null);
   }
   async findMany(table, where) {
     this.validateTable(table);
@@ -110,7 +277,85 @@ class SubgraphContext {
     const { clause } = buildWhereClause(where);
     const query = `SELECT * FROM ${qualifiedTable} WHERE ${clause}`;
     const { rows } = await sql.raw(query).execute(this.db);
-    return rows.map((r) => this.coerceRow(table, r));
+    const dbRows = rows.map((r) => this.coerceRow(table, r));
+    return this.overlayMany(table, where, dbRows);
+  }
+  overlayOne(table, where, 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) {
+    let result = [...dbRows];
+    for (const op of this.ops) {
+      if (op.table !== table)
+        continue;
+      if (op.kind === "update") {
+        result = result.map((r) => rowMatches(r, op.data) ? { ...r, ...op.set ?? {} } : r);
+      } 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) {
+          result[idx] = this.applyOpToRow(op, result[idx], where) ?? result[idx];
+        } 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);
@@ -171,6 +416,7 @@ class SubgraphContext {
   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);
@@ -188,12 +434,12 @@ class SubgraphContext {
     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.data, ...op.set ?? {} } : { ...op.data };
+      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,
+        op: op.kind === "increment" ? "update" : op.kind,
         table: op.table,
         row: jsonSafe(baseRow),
         pk: { blockHeight, txId, rowIndex }
@@ -218,6 +464,35 @@ class SubgraphContext {
     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 = [];
     if (this.byo) {
@@ -231,6 +506,38 @@ class SubgraphContext {
     }
     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"
+      ];
+      const valuesList = Array.from(batch.rows.values()).map((r) => {
+        const vals = [
+          ...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()"
+        ];
+        return `(${vals.join(", ")})`;
+      }).join(", ");
+      const setClauses = batch.deltaCols.map((c) => `"${c}" = COALESCE("${batch.table}"."${c}", 0) + EXCLUDED."${c}"`);
+      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])))));
+      }
+      statements.push(`INSERT INTO ${qualifiedTable} (${cols.map((c) => `"${c}"`).join(", ")}) VALUES ${valuesList} ` + `ON CONFLICT (${batch.keyCols.map((k) => `"${k}"`).join(", ")}) DO UPDATE SET ${setClauses.join(", ")}`);
+      incBatch = null;
+      incBatchKey = "";
+    };
     const flushInsertBatch = () => {
       if (!currentBatch)
         return;
@@ -252,6 +559,11 @@ class SubgraphContext {
       }
       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("_"));
@@ -269,6 +581,7 @@ class SubgraphContext {
     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);
@@ -277,22 +590,60 @@ class SubgraphContext {
           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) {
@@ -301,6 +652,36 @@ class SubgraphContext {
     }
   }
 }
+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)) {
@@ -329,8 +710,9 @@ function buildWhereClause(where) {
   return { clause: parts.join(" AND "), values: [] };
 }
 export {
-  SubgraphContext
+  SubgraphContext,
+  JOURNAL_RETENTION_BLOCKS
 };
 
-//# debugId=924018FC710F353164756E2164756E21
+//# debugId=5D4174CEFDCF4E9364756E2164756E21
 //# sourceMappingURL=context.js.map