@secondlayer/subgraphs 7.1.0 → 7.3.0

package/dist/testing/index.js

@@ -170,9 +170,17 @@ function generateSubgraphSQL(def, schemaNameOverride) {
 }
 
 // src/runtime/chain-read.ts
+import { getErrorMessage } from "@secondlayer/shared";
+import { chainReadArgsHash } from "@secondlayer/shared/chain-read";
 import { getSourceDb } from "@secondlayer/shared/db";
+import { hasNoLocalChain } from "@secondlayer/shared/db/queries/instance";
 import { logger } from "@secondlayer/shared/logger";
-import { http, createPublicClient } from "@secondlayer/stacks";
+import {
+  http,
+  HttpRequestError,
+  ReadContractError,
+  createPublicClient
+} from "@secondlayer/stacks";
 import {
   ContractResponseError,
   buildFunctionArgs,
@@ -186,1747 +194,1803 @@ import {
   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 })
-  });
-}
+// src/runtime/realm.ts
+import vm from "node:vm";
 
-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 value = await readContract(nodeClient(rpcUrl), {
-        contract: contractId,
-        functionName: fn.name,
-        args: clarityArgs,
-        tip: ctx.indexBlockHash ?? undefined
-      });
-      return serializeCV(value);
-    });
-    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/verification.ts
+import { createHash as createHash2 } from "node:crypto";
+// package.json
+var package_default = {
+  name: "@secondlayer/subgraphs",
+  version: "7.3.0",
+  description: "Describe the Stacks data you want as one TypeScript file; it fills itself and survives reorgs.",
+  license: "MIT",
+  repository: {
+    type: "git",
+    url: "git+https://github.com/ryanwaits/secondlayer.git",
+    directory: "packages/subgraphs"
+  },
+  homepage: "https://github.com/ryanwaits/secondlayer/tree/main/packages/subgraphs#readme",
+  type: "module",
+  main: "./dist/index.js",
+  types: "./dist/index.d.ts",
+  exports: {
+    ".": {
+      types: "./dist/index.d.ts",
+      import: "./dist/index.js"
+    },
+    "./types": {
+      types: "./dist/types.d.ts",
+      import: "./dist/types.js"
+    },
+    "./schema": {
+      types: "./dist/schema/index.d.ts",
+      import: "./dist/schema/index.js"
+    },
+    "./validate": {
+      types: "./dist/validate.d.ts",
+      import: "./dist/validate.js"
+    },
+    "./verification": {
+      types: "./dist/verification.d.ts",
+      import: "./dist/verification.js"
+    },
+    "./runtime/replay": {
+      types: "./dist/runtime/replay.d.ts",
+      import: "./dist/runtime/replay.js"
+    },
+    "./runtime/emitter": {
+      types: "./dist/runtime/emitter.d.ts",
+      import: "./dist/runtime/emitter.js"
+    },
+    "./testing": {
+      types: "./dist/testing/index.d.ts",
+      import: "./dist/testing/index.js"
+    },
+    "./verify": {
+      types: "./dist/verify/index.d.ts",
+      import: "./dist/verify/index.js"
     }
-  };
-}
-
-// src/runtime/context.ts
-var journalEnsured = new Set;
-function validateColumnName(name) {
-  if (!/^[a-z_][a-z0-9_]*$/i.test(name)) {
-    throw new Error(`Invalid column name: ${name}`);
+  },
+  files: ["dist"],
+  scripts: {
+    build: "bunup",
+    dev: "bunup --watch",
+    test: "bun test",
+    typecheck: "tsc --noEmit",
+    openpkg: "bun scripts/sync-openpkg.ts",
+    prepublishOnly: "bun run build"
+  },
+  dependencies: {
+    "@secondlayer/shared": "^13.2.0",
+    "@secondlayer/stacks": "^6.4.0",
+    "@secondlayer/verify": "^0.6.0",
+    esbuild: "^0.28.2",
+    kysely: "0.28.17",
+    zod: "^4.3.6"
+  },
+  devDependencies: {
+    "@types/bun": "latest",
+    bunup: "0.16.32",
+    typescript: "^5"
+  },
+  publishConfig: {
+    access: "public"
   }
-}
+};
 
-class SubgraphContext {
-  block;
-  _tx;
-  db;
-  pgSchemaName;
-  subgraphSchema;
-  ops = [];
-  journal;
-  _client;
-  constructor(db, pgSchemaName, subgraphSchema, block, tx, journal = false) {
-    this.db = db;
-    this.pgSchemaName = pgSchemaName;
-    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`);
-      }
+// src/verification.ts
+var SUBGRAPHS_RUNTIME = `@secondlayer/subgraphs@${package_default.version}`;
+var FORBIDDEN_GLOBALS = {
+  Date: "wall-clock time differs per run",
+  performance: "timers differ per run",
+  process: "host environment differs per run",
+  fetch: "network reads are not chain inputs",
+  crypto: "randomness differs per run",
+  setTimeout: "scheduling order differs per run",
+  setInterval: "scheduling order differs per run",
+  setImmediate: "scheduling order differs per run",
+  clearTimeout: "scheduling order differs per run",
+  clearInterval: "scheduling order differs per run",
+  queueMicrotask: "scheduling order differs per run",
+  WeakRef: "garbage collection timing differs per run",
+  FinalizationRegistry: "garbage collection timing differs per run",
+  Atomics: "shared memory is not single-threaded",
+  SharedArrayBuffer: "shared memory is not single-threaded",
+  Intl: "locale and time zone data differ per host",
+  Temporal: "locale and time zone data differ per host",
+  eval: "generated code hides inputs from the scan",
+  WebAssembly: "compiled code hides inputs from the scan",
+  ShadowRealm: "a nested realm escapes the allow-list",
+  require: "imports must be bundled into the handler"
+};
+var ALLOWED_GLOBALS = [
+  "undefined",
+  "NaN",
+  "Infinity",
+  "globalThis",
+  "isNaN",
+  "isFinite",
+  "parseInt",
+  "parseFloat",
+  "decodeURI",
+  "decodeURIComponent",
+  "encodeURI",
+  "encodeURIComponent",
+  "escape",
+  "unescape",
+  "Object",
+  "Function",
+  "Array",
+  "Number",
+  "Boolean",
+  "String",
+  "Symbol",
+  "BigInt",
+  "Math",
+  "JSON",
+  "Reflect",
+  "Proxy",
+  "Promise",
+  "Map",
+  "Set",
+  "WeakMap",
+  "WeakSet",
+  "RegExp",
+  "Iterator",
+  "DisposableStack",
+  "AsyncDisposableStack",
+  "Error",
+  "AggregateError",
+  "SuppressedError",
+  "EvalError",
+  "RangeError",
+  "ReferenceError",
+  "SyntaxError",
+  "TypeError",
+  "URIError",
+  "ArrayBuffer",
+  "DataView",
+  "Int8Array",
+  "Uint8Array",
+  "Uint8ClampedArray",
+  "Int16Array",
+  "Uint16Array",
+  "Int32Array",
+  "Uint32Array",
+  "Float16Array",
+  "Float32Array",
+  "Float64Array",
+  "BigInt64Array",
+  "BigUint64Array",
+  "TextEncoder",
+  "TextDecoder",
+  "atob",
+  "btoa",
+  "console"
+];
+var ALLOWED_MATH = [
+  "abs",
+  "min",
+  "max",
+  "floor",
+  "ceil",
+  "trunc",
+  "sign",
+  "round",
+  "E",
+  "LN10",
+  "LN2",
+  "LOG10E",
+  "LOG2E",
+  "PI",
+  "SQRT1_2",
+  "SQRT2"
+];
+var LOCALE_METHODS = [
+  "toLocaleString",
+  "toLocaleDateString",
+  "toLocaleTimeString",
+  "toLocaleUpperCase",
+  "toLocaleLowerCase",
+  "localeCompare"
+];
+function formatFinding(f) {
+  return `${f.file}:${f.line}:${f.column} ${f.name}: ${f.reason}`;
+}
+var STATE_SOURCE_TYPES = new Set([
+  "var_set",
+  "map_set",
+  "map_delete"
+]);
+var LEVEL_RANK = { state: 0, events: 1, none: 2 };
+var MAX_LISTED_FINDINGS = 10;
+function deriveVerification(def, findings = []) {
+  let level = "state";
+  const raise = (to) => {
+    if (LEVEL_RANK[to] > LEVEL_RANK[level])
+      level = to;
+  };
+  const reasons = [];
+  for (const [name, source] of Object.entries(def.sources ?? {})) {
+    const filter = source;
+    if (filter.trait) {
+      raise("none");
+      reasons.push(`source "${name}": trait scope needs a proven contract registry`);
+    } else if (filter.type === "map_insert") {
+      raise("events");
+      reasons.push(`map_insert source "${name}": map_insert vs map_set needs event proofs`);
+    } else if (!STATE_SOURCE_TYPES.has(filter.type)) {
+      raise("events");
+      reasons.push(`${filter.type} source "${name}" needs event proofs`);
     }
-    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;
-  }
-  async readRows(table, where, limit) {
-    const qualifiedTable = `"${this.pgSchemaName}"."${table}"`;
-    const { clause } = buildWhereClause(where);
-    const query = `SELECT * FROM ${qualifiedTable} WHERE ${clause} ORDER BY "_id"${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));
+  if (def.backfillMode === "concurrent") {
+    raise("none");
+    reasons.push("backfillMode concurrent: tip-first order is not chain order");
   }
-  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;
+  if (findings.some((f) => f.kind === "needs-events"))
+    raise("events");
+  for (const f of findings.slice(0, MAX_LISTED_FINDINGS)) {
+    reasons.push(f.kind === "needs-events" ? `${formatFinding(f)} (needs event proofs)` : formatFinding(f));
   }
-  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;
+  if (findings.length > MAX_LISTED_FINDINGS) {
+    reasons.push(`…and ${findings.length - MAX_LISTED_FINDINGS} more handler findings`);
   }
-  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) && !isSystemColumn(k))
-                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;
-    }
+  return {
+    level,
+    reasons,
+    unproven: reasons.length === 0 ? [
+      "tx attribution of writes: event.tx, _tx_id (needs event proofs)",
+      "intermediate writes within a block (needs event proofs)"
+    ] : []
+  };
+}
+function isDeterminismViolation(v) {
+  return v.level === "state" && v.reasons.length > 0;
+}
+function sha256(input) {
+  return createHash2("sha256").update(input).digest("hex");
+}
+function pinPreimage(input) {
+  const fields = {
+    handlerHash: sha256(input.handlerCode),
+    network: input.network,
+    runtime: input.runtime ?? SUBGRAPHS_RUNTIME,
+    schemaHash: input.schemaHash,
+    startBlock: input.startBlock ?? null
+  };
+  return JSON.stringify(fields);
+}
+function computePin(input) {
+  return sha256(pinPreimage(input));
+}
+
+// src/runtime/realm.ts
+class NondeterminismError extends Error {
+  name = "NondeterminismError";
+}
+
+class HandlerReadError extends Error {
+  name = "HandlerReadError";
+}
+function abortsBlock(err) {
+  return err instanceof NondeterminismError || err instanceof HandlerReadError;
+}
+var HOST_GLOBALS = [
+  "ArrayBuffer",
+  "DataView",
+  "Int8Array",
+  "Uint8Array",
+  "Uint8ClampedArray",
+  "Int16Array",
+  "Uint16Array",
+  "Int32Array",
+  "Uint32Array",
+  "Float16Array",
+  "Float32Array",
+  "Float64Array",
+  "BigInt64Array",
+  "BigUint64Array",
+  "TextEncoder",
+  "TextDecoder",
+  "atob",
+  "btoa"
+];
+function forbid(name, reason) {
+  return () => {
+    throw new NondeterminismError(`${name}: ${reason}`);
+  };
+}
+function createRealm() {
+  const host = globalThis;
+  const sandbox = Object.create(null);
+  for (const name of HOST_GLOBALS) {
+    if (host[name] !== undefined)
+      sandbox[name] = host[name];
   }
-  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;
+  const context = vm.createContext(sandbox, {
+    name: "subgraph-handler",
+    codeGeneration: { strings: false, wasm: false }
+  });
+  const g = vm.runInContext("globalThis", context);
+  const allowed = new Set(ALLOWED_GLOBALS);
+  for (const name of Object.getOwnPropertyNames(g)) {
+    if (!allowed.has(name))
+      delete g[name];
   }
-  get pendingOps() {
-    return this.ops.length;
+  for (const [name, reason] of Object.entries(FORBIDDEN_GLOBALS)) {
+    Object.defineProperty(g, name, { get: forbid(name, reason) });
   }
-  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 realmMath = g.Math;
+  const safeMath = {};
+  const allowedMath = new Set(ALLOWED_MATH);
+  for (const key of Object.getOwnPropertyNames(realmMath)) {
+    if (allowedMath.has(key))
+      safeMath[key] = realmMath[key];
+    else
+      Object.defineProperty(safeMath, key, {
+        get: forbid(`Math.${key}`, key === "random" ? "randomness differs per run" : "result is engine-approximated")
       });
-    }
-    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`);
+  Object.defineProperty(g, "Math", { value: Object.freeze(safeMath) });
+  for (const ctor of ["String", "Number", "BigInt", "Array", "Object"]) {
+    const proto = g[ctor].prototype;
+    for (const method of LOCALE_METHODS) {
+      if (Object.prototype.hasOwnProperty.call(proto, method)) {
+        Object.defineProperty(proto, method, {
+          value: forbid(method, "output depends on the host's locale data")
+        });
       }
     }
   }
-  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 };
+  Object.preventExtensions(g);
+  return context;
+}
+function checkRowValues(where, values) {
+  for (const [col, value] of Object.entries(values)) {
+    checkValue(value, `${where}.${col}`);
   }
-  async ensureJournalTable() {
-    if (!this.journal || journalEnsured.has(this.pgSchemaName))
+}
+function checkValue(value, path) {
+  switch (typeof value) {
+    case "number":
+      if (!Number.isSafeInteger(value)) {
+        throw new TypeError(`${path}: ${value} is not a safe integer; verifiable subgraphs store bigint or integers only`);
+      }
       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);
+    case "function":
+    case "symbol":
+      throw new TypeError(`${path}: a ${typeof value} is not a row value`);
+    case "object":
+      if (value === null || ArrayBuffer.isView(value))
+        return;
+      if (Array.isArray(value)) {
+        value.forEach((v, i) => checkValue(v, `${path}[${i}]`));
+        return;
+      }
+      for (const [k, v] of Object.entries(value))
+        checkValue(v, `${path}.${k}`);
+      return;
+    default:
       return;
+  }
+}
+function deterministicContext(ctx, schema) {
+  let pendingReads = 0;
+  const knownTable = (table) => {
+    if (!Object.prototype.hasOwnProperty.call(schema, table)) {
+      throw new Error(`Table "${table}" not found in subgraph schema`);
     }
-    for (const stmt of emitJournalDDL(this.pgSchemaName)) {
-      await sql.raw(stmt).execute(this.db);
+  };
+  const guard = (op) => {
+    if (pendingReads > 0) {
+      throw new NondeterminismError(`ctx.${op} while a ctx read is pending: concurrent ctx calls order writes by database latency; await each read before the next call`);
     }
+  };
+  const read = async (op, run) => {
+    guard(op);
+    pendingReads++;
+    try {
+      return await run();
+    } catch (err) {
+      if (err instanceof NondeterminismError)
+        throw err;
+      throw new HandlerReadError(`ctx.${op} failed: ${err instanceof Error ? err.message : String(err)}`, { cause: err });
+    } finally {
+      pendingReads--;
+    }
+  };
+  return {
+    get block() {
+      return ctx.block;
+    },
+    get tx() {
+      return ctx.tx;
+    },
+    get client() {
+      throw new NondeterminismError("ctx.client: contract reads need re-execution proofs");
+    },
+    insert(table, row) {
+      guard("insert");
+      checkRowValues(`insert ${table}`, row);
+      ctx.insert(table, row);
+    },
+    update(table, where, set) {
+      guard("update");
+      checkRowValues(`update ${table}`, where);
+      checkRowValues(`update ${table}`, set);
+      ctx.update(table, where, set);
+    },
+    upsert(table, key, row) {
+      guard("upsert");
+      checkRowValues(`upsert ${table}`, key);
+      checkRowValues(`upsert ${table}`, row);
+      ctx.upsert(table, key, row);
+    },
+    delete(table, where) {
+      guard("delete");
+      ctx.delete(table, where);
+    },
+    increment(table, key, deltas) {
+      guard("increment");
+      checkRowValues(`increment ${table}`, key);
+      checkRowValues(`increment ${table}`, deltas);
+      ctx.increment(table, key, deltas);
+    },
+    findOne: (table, where) => {
+      knownTable(table);
+      return read("findOne", () => ctx.findOne(table, where));
+    },
+    findMany: (table, ...rest) => {
+      knownTable(table);
+      return read("findMany", () => ctx.findMany(table, ...rest));
+    }
+  };
+}
+var realmDefinitions = new WeakSet;
+async function loadDeterministicDefinition(handlerCode) {
+  const { transform } = await import("esbuild");
+  const { code } = await transform(handlerCode, {
+    format: "cjs",
+    loader: "js",
+    logLevel: "silent"
+  });
+  const context = createRealm();
+  const evaluate = vm.runInContext(`(function (module, exports) {
+${code}
+})`, context, { filename: "handler.js" });
+  const mod = { exports: {} };
+  evaluate(mod, mod.exports);
+  const def = mod.exports.default ?? mod.exports;
+  const sources = structuredClone(def.sources);
+  const schema = structuredClone(def.schema);
+  const facades = new WeakMap;
+  const handlers = {};
+  for (const [name, handler] of Object.entries(def.handlers ?? {})) {
+    handlers[name] = (event, ctx) => {
+      let facade = facades.get(ctx);
+      if (!facade) {
+        facade = deterministicContext(ctx, schema);
+        facades.set(ctx, facade);
+      }
+      return handler(event, facade);
+    };
   }
-  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}`;
+  const loaded = { ...def, sources, schema, handlers };
+  realmDefinitions.add(loaded);
+  return loaded;
+}
+
+// src/runtime/chain-read.ts
+function readContractAt(ctx, contractId, abi, options) {
+  return ctx.client.contract(contractId, abi, options);
+}
+
+class ChainReadError extends Error {
+  name = "ChainReadError";
+}
+var NO_NODE_MESSAGE = "ctx.client needs a Stacks node: set STACKS_NODE_RPC_URL on the subgraph processor.";
+async function resolveReadTarget(rpcUrl, db) {
+  if (rpcUrl)
+    return { kind: "node", rpcUrl };
+  const apiUrl = process.env.SUBGRAPH_INDEX_API_URL;
+  if (!apiUrl || !await hasNoLocalChain(db)) {
+    throw new HandlerReadError(NO_NODE_MESSAGE);
   }
-  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})`
-        });
+  const apiKey = process.env.INDEX_INTERNAL_API_KEY?.trim();
+  if (!apiKey) {
+    throw new HandlerReadError("Hosted contract reads need the processor's key (INDEX_INTERNAL_API_KEY), and none is set. Set STACKS_NODE_RPC_URL to read a node directly instead.");
+  }
+  return { kind: "hosted", apiUrl, apiKey };
+}
+function hostedReadError(err, label) {
+  if (!(err instanceof HttpRequestError))
+    return;
+  if (err.status === 400) {
+    return new ChainReadError(`${label} was refused as invalid: ${err.details ?? err.message}`);
+  }
+  if (err.status === 403) {
+    return new HandlerReadError(`${label}: hosted contract reads serve hosted subgraphs only. ${NO_NODE_MESSAGE}`, { cause: err });
+  }
+  return;
+}
+function isChainAnswer(err) {
+  return err instanceof ContractResponseError || err instanceof ReadContractError;
+}
+function readClient(target) {
+  if (target.kind === "node") {
+    return createPublicClient({
+      transport: http(target.rpcUrl, { retryCount: 0, timeout: 1e4 })
+    });
+  }
+  return createPublicClient({
+    transport: http(`${target.apiUrl.replace(/\/+$/, "")}/v1/chain-read`, {
+      retryCount: 3,
+      timeout: 1e4,
+      fetchOptions: {
+        headers: { authorization: `Bearer ${target.apiKey}` }
       }
-      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 keyIndices = batch.upsertKeys.map((k) => batch.cols.indexOf(k));
-        const byKey = new Map;
-        for (const row of rows) {
-          const key = keyIndices.map((ki) => row[ki]).join("\x00");
-          const first = byKey.get(key);
-          if (!first) {
-            byKey.set(key, [...row]);
-            continue;
-          }
-          batch.cols.forEach((c, ci) => {
-            if (!isSystemColumn(c))
-              first[ci] = row[ci];
+    })
+  });
+}
+
+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) {
+  return chainReadArgsHash(args.map((arg) => serializeCV(arg)));
+}
+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 db = ctx.db ?? getSourceDb();
+    const rpcUrl = ctx.rpcUrl || process.env.STACKS_NODE_RPC_URL || undefined;
+    if (!rpcUrl && !process.env.SUBGRAPH_INDEX_API_URL) {
+      throw new HandlerReadError(NO_NODE_MESSAGE);
+    }
+    const constant = options.cache === "contract-constant";
+    if (!constant && !ctx.indexBlockHash) {
+      throw new HandlerReadError(`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 argsHash = hashArgs(clarityArgs);
+    const pinnedTo = constant ? null : ctx.indexBlockHash;
+    let resultHex;
+    try {
+      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();
+      resultHex = cached?.result_hex ?? await gate.run(async () => {
+        const target = await resolveReadTarget(rpcUrl, db);
+        if (!ctx.indexBlockHash && target.kind === "hosted") {
+          throw new HandlerReadError(`Block ${ctx.blockHeight} has no index_block_hash, so a hosted contract read cannot be pinned to it. Reindex the subgraph from this block once the block is re-ingested.`);
+        }
+        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'
           });
         }
-        rows = [...byKey.values()];
-      }
-      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) && !isSystemColumn(c));
-        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`;
+        try {
+          const value = await readContract(readClient(target), {
+            contract: contractId,
+            functionName: fn.name,
+            args: clarityArgs,
+            tip: ctx.indexBlockHash ?? undefined
+          });
+          return serializeCV(value);
+        } catch (err) {
+          throw target.kind === "hosted" && hostedReadError(err, `Chain read ${contractId}::${fn.name}`) || err;
         }
+      });
+      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();
       }
-      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}`);
-        }
+    } catch (err) {
+      if (isChainAnswer(err) || err instanceof ChainReadError || err instanceof HandlerReadError) {
+        throw err;
       }
+      throw new HandlerReadError(`Chain read ${contractId}::${fn.name} at block ${ctx.blockHeight} failed: ${getErrorMessage(err)}`, { cause: err });
     }
-    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(", ")}]`);
+    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);
     }
-  }
-}
-function isSystemColumn(col) {
-  return col.startsWith("_");
-}
-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: [] };
+    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/memory-store.ts
-import { normalizeAbi as normalizeAbi2, toCamelCase as toCamelCase2 } from "@secondlayer/stacks/clarity";
-class MemoryStore {
-  tables = new Map;
+// src/runtime/context.ts
+var journalEnsured = new Set;
+function validateColumnName(name) {
+  if (!/^[a-z_][a-z0-9_]*$/i.test(name)) {
+    throw new Error(`Invalid column name: ${name}`);
+  }
 }
 
-class MemorySubgraphContext extends SubgraphContext {
-  store;
-  tables;
-  constructor(store, schema, block, tx) {
-    super(undefined, "memory", schema, block, tx, false);
-    this.store = store;
-    this.tables = schema;
+class SubgraphContext {
+  block;
+  _tx;
+  db;
+  pgSchemaName;
+  subgraphSchema;
+  ops = [];
+  journal;
+  _client;
+  constructor(db, pgSchemaName, subgraphSchema, block, tx, journal = false) {
+    this.db = db;
+    this.pgSchemaName = pgSchemaName;
+    this.subgraphSchema = subgraphSchema;
+    this.block = block;
+    this._tx = tx;
+    this.journal = journal;
   }
-  async readRows(table, where, limit) {
-    const rows = (this.store.tables.get(table) ?? []).filter((row) => Object.entries(where).every(([k, v]) => sameValue(row[k], v)));
-    return limit === undefined ? rows : rows.slice(0, limit);
+  get client() {
+    this._client ??= createChainReadClient({
+      blockHeight: this.block.height,
+      indexBlockHash: this.block.indexBlockHash
+    });
+    return this._client;
   }
-  readDependent = null;
-  dependsOnPrior(what) {
-    this.readDependent ??= what;
+  get tx() {
+    return this._tx;
   }
-  findOne(table, where) {
-    this.dependsOnPrior(`findOne("${table}")`);
-    return super.findOne(table, where);
+  setTx(tx) {
+    this._tx = tx;
   }
-  findMany(table, where) {
-    this.dependsOnPrior(`findMany("${table}")`);
-    return super.findMany(table, where);
+  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.dependsOnPrior(`update("${table}")`);
-    super.update(table, where, set);
-  }
-  delete(table, where) {
-    this.dependsOnPrior(`delete("${table}")`);
-    super.delete(table, where);
-  }
-  increment(table, key, deltas) {
-    this.dependsOnPrior(`increment("${table}")`);
-    super.increment(table, key, deltas);
+    this.validateTable(table);
+    this.ops.push({ kind: "update", table, data: where, set });
   }
   upsert(table, key, row) {
-    const def = this.tables[table];
-    if (def) {
-      const keyCols = Object.keys(key);
-      const keyed = def.uniqueKeys?.some((uk) => uk.length === keyCols.length && uk.every((c) => keyCols.includes(c)));
-      const omitted = Object.keys(def.columns).find((c) => !(c in key) && !(c in row));
-      if (!keyed)
-        this.dependsOnPrior(`upsert("${table}") without a unique key`);
-      else if (omitted)
-        this.dependsOnPrior(`upsert("${table}") leaves "${omitted}" as it was`);
-    }
-    super.upsert(table, key, row);
-  }
-  async rowsOf(table) {
-    return this.overlayMany(table, {}, await this.readRows(table, {}));
-  }
-  setReads(reads) {
-    this._client = {
-      contract(contractId, abi) {
-        const camelToKebab = new Map;
-        for (const fn of normalizeAbi2(abi).functions) {
-          camelToKebab.set(toCamelCase2(fn.name), fn.name);
-        }
-        const read = new Proxy({}, {
-          get(_target, prop) {
-            const fnName = camelToKebab.get(prop) ?? prop;
-            const key = `${contractId}.${fnName}`;
-            return async () => {
-              if (!(key in reads)) {
-                throw new Error(`No stubbed chain read for "${key}" — pass it via createTestContext(schema, { reads: { "${key}": … } }).`);
-              }
-              return reads[key];
-            };
-          }
-        });
-        return { read };
-      }
-    };
-  }
-  async commitOps() {
-    const tables = new Set;
-    for (const op of this.ops)
-      tables.add(op.table);
-    for (const table of tables) {
-      this.store.tables.set(table, await this.rowsOf(table));
-    }
-    this.ops.length = 0;
-  }
-  insertsSince(checkpoint) {
-    const out = [];
-    for (const op of this.ops.slice(Math.max(0, checkpoint))) {
-      if (op.kind !== "insert")
-        continue;
-      const row = { ...op.data };
-      out.push({
-        table: op.table,
-        keys: Object.keys(row).filter((k) => !k.startsWith("_")),
-        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
+        }
       });
     }
-    return out;
-  }
-}
-function sameValue(a, b) {
-  if (a === b)
-    return true;
-  if ((typeof a === "bigint" || typeof a === "number") && (typeof b === "bigint" || typeof b === "number")) {
-    return BigInt(a) === BigInt(b);
   }
-  return String(a) === String(b);
-}
-
-// src/runtime/runner.ts
-import { getErrorMessage } from "@secondlayer/shared";
-import { logger as logger4 } from "@secondlayer/shared/logger";
-import {
-  clarityValueToJS,
-  deserializeCV as deserializeCV4,
-  toCamelCase as toCamelCase3
-} from "@secondlayer/stacks/clarity";
-
-// src/print-schema.ts
-import {
-  deserializeCV as deserializeCV2
-} 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);
+  delete(table, where) {
+    this.validateTable(table);
+    this.ops.push({ kind: "delete", table, data: where });
   }
-  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 };
+  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(", ")}]`);
     }
-    case "tuple": {
-      const entries = new Map;
-      for (const [k, v] of Object.entries(cv.value)) {
-        entries.set(k, { tree: cvToTree(v), present: 1 });
+    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`);
       }
-      return { kind: "tuple", count: 1, entries };
     }
+    this.ops.push({
+      kind: "increment",
+      table,
+      data: {
+        ...key,
+        _block_height: this.block.height,
+        _tx_id: this._tx.txId,
+        _upsert_keys: keyColumns
+      },
+      set: { ...deltas }
+    });
   }
-}
-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) };
+  opsCheckpoint() {
+    return this.ops.length;
   }
-  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 };
-    }
+  rollbackTo(checkpoint) {
+    if (checkpoint < 0 || checkpoint > this.ops.length)
+      return;
+    this.ops.length = checkpoint;
   }
-}
-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;
+  async readRows(table, where, limit) {
+    const qualifiedTable = `"${this.pgSchemaName}"."${table}"`;
+    const { clause } = buildWhereClause(where);
+    const query = `SELECT * FROM ${qualifiedTable} WHERE ${clause} ORDER BY "_id"${limit !== undefined ? ` LIMIT ${limit}` : ""}`;
+    const { rows } = await sql.raw(query).execute(this.db);
+    return rows.map((r) => this.coerceRow(table, r));
   }
-  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);
-    }
+  async findOne(table, where) {
+    this.validateTable(table);
+    const row = (await this.readRows(table, where, 1))[0] ?? null;
+    return this.overlayOne(table, where, row);
   }
-  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(" | ");
+  async findMany(table, where) {
+    this.validateTable(table);
+    return this.overlayMany(table, where, await this.readRows(table, where));
   }
-}
-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("; ")} }`;
+  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);
     }
-    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]);
+    return row;
   }
-  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 = deserializeCV2(p.rawHex);
-        decoded++;
-        if (cv.type === "tuple")
-          tuples.push(cv);
-      } catch {}
+  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);
+        }
+      }
     }
-    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;
+    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) && !isSystemColumn(k))
+                merged[k] = v;
             }
-          } else {
-            stats.set(key, {
-              tree,
-              present: 1,
-              noneCount: value.type === "none" ? 1 : 0,
-              optionalSeen: value.type === "none" || value.type === "some"
-            });
+            return merged;
           }
+          return row;
         }
+        return rowMatches(clean, where) ? { ...clean } : null;
       }
-      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;
+      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;
         }
-        fields.push(field);
+        if (!rowMatches(clean, where))
+          return null;
+        const created = { ...clean };
+        for (const [col, d] of Object.entries(deltas)) {
+          created[col] = toBigIntOr0(d);
+        }
+        return created;
       }
-    }
-    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/clarity.ts
-import { cvToValue, deserializeCV as deserializeCV3 } from "@secondlayer/stacks/clarity";
-function decodeClarityValue(hex) {
-  try {
-    const cleanHex = hex.startsWith("0x") ? hex.slice(2) : hex;
-    const cv = deserializeCV3(cleanHex);
-    return cvToValue(cv);
-  } catch {
-    return hex;
+      case "update":
+        return row && rowMatches(row, op.data) ? { ...row, ...op.set ?? {} } : row;
+      case "delete":
+        return row && rowMatches(row, op.data) ? null : row;
+    }
   }
-}
-function decodeEventData(data) {
-  if (typeof data === "string" && data.startsWith("0x") && data.length > 10) {
-    return decodeClarityValue(data);
+  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;
   }
-  if (Array.isArray(data)) {
-    return data.map(decodeEventData);
+  get pendingOps() {
+    return this.ops.length;
   }
-  if (typeof data === "object" && data !== null) {
-    const decoded = {};
-    for (const [key, value] of Object.entries(data)) {
-      decoded[key] = decodeEventData(value);
+  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);
+      });
     }
-    return decoded;
+    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 };
   }
-  return data;
-}
-
-// 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;
+  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`);
+      }
     }
   }
-  if (typeof field !== "object" || field === null)
-    return false;
-  if ("optional" in field) {
-    return value === undefined || value === null || matchesField(field.type, value);
+  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 };
   }
-  if ("tuple" in field) {
-    if (typeof value !== "object" || value === null || Array.isArray(value)) {
-      return false;
+  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);
     }
-    return matchesTopic(field.tuple, value).ok;
   }
-  if ("list" in field) {
-    return Array.isArray(value) && value.every((item) => matchesField(field.list, item));
+  columnSqlType(table, col) {
+    const def = this.subgraphSchema[table]?.columns?.[col];
+    return def ? TYPE_MAP[def.type] : undefined;
   }
-  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])})`
-      };
-    }
+  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}`;
   }
-  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/realm.ts
-import vm from "node:vm";
-
-// src/verification.ts
-import { createHash as createHash2 } from "node:crypto";
-// package.json
-var package_default = {
-  name: "@secondlayer/subgraphs",
-  version: "7.1.0",
-  description: "Describe the Stacks data you want as one TypeScript file; it fills itself and survives reorgs.",
-  license: "MIT",
-  repository: {
-    type: "git",
-    url: "git+https://github.com/ryanwaits/secondlayer.git",
-    directory: "packages/subgraphs"
-  },
-  homepage: "https://github.com/ryanwaits/secondlayer/tree/main/packages/subgraphs#readme",
-  type: "module",
-  main: "./dist/index.js",
-  types: "./dist/index.d.ts",
-  exports: {
-    ".": {
-      types: "./dist/index.d.ts",
-      import: "./dist/index.js"
-    },
-    "./types": {
-      types: "./dist/types.d.ts",
-      import: "./dist/types.js"
-    },
-    "./schema": {
-      types: "./dist/schema/index.d.ts",
-      import: "./dist/schema/index.js"
-    },
-    "./validate": {
-      types: "./dist/validate.d.ts",
-      import: "./dist/validate.js"
-    },
-    "./verification": {
-      types: "./dist/verification.d.ts",
-      import: "./dist/verification.js"
-    },
-    "./runtime/replay": {
-      types: "./dist/runtime/replay.d.ts",
-      import: "./dist/runtime/replay.js"
-    },
-    "./runtime/emitter": {
-      types: "./dist/runtime/emitter.d.ts",
-      import: "./dist/runtime/emitter.js"
-    },
-    "./testing": {
-      types: "./dist/testing/index.d.ts",
-      import: "./dist/testing/index.js"
-    },
-    "./verify": {
-      types: "./dist/verify/index.d.ts",
-      import: "./dist/verify/index.js"
+  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 keyIndices = batch.upsertKeys.map((k) => batch.cols.indexOf(k));
+        const byKey = new Map;
+        for (const row of rows) {
+          const key = keyIndices.map((ki) => row[ki]).join("\x00");
+          const first = byKey.get(key);
+          if (!first) {
+            byKey.set(key, [...row]);
+            continue;
+          }
+          batch.cols.forEach((c, ci) => {
+            if (!isSystemColumn(c))
+              first[ci] = row[ci];
+          });
+        }
+        rows = [...byKey.values()];
+      }
+      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) && !isSystemColumn(c));
+        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}`);
+        }
+      }
     }
-  },
-  files: ["dist"],
-  scripts: {
-    build: "bunup",
-    dev: "bunup --watch",
-    test: "bun test",
-    typecheck: "tsc --noEmit",
-    openpkg: "bun scripts/sync-openpkg.ts",
-    prepublishOnly: "bun run build"
-  },
-  dependencies: {
-    "@secondlayer/shared": "^13.0.0",
-    "@secondlayer/stacks": "^6.3.0",
-    "@secondlayer/verify": "^0.6.0",
-    esbuild: "^0.28.2",
-    kysely: "0.28.17",
-    zod: "^4.3.6"
-  },
-  devDependencies: {
-    "@types/bun": "latest",
-    bunup: "0.16.32",
-    typescript: "^5"
-  },
-  publishConfig: {
-    access: "public"
+    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 isSystemColumn(col) {
+  return col.startsWith("_");
+}
+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/verification.ts
-var SUBGRAPHS_RUNTIME = `@secondlayer/subgraphs@${package_default.version}`;
-var FORBIDDEN_GLOBALS = {
-  Date: "wall-clock time differs per run",
-  performance: "timers differ per run",
-  process: "host environment differs per run",
-  fetch: "network reads are not chain inputs",
-  crypto: "randomness differs per run",
-  setTimeout: "scheduling order differs per run",
-  setInterval: "scheduling order differs per run",
-  setImmediate: "scheduling order differs per run",
-  clearTimeout: "scheduling order differs per run",
-  clearInterval: "scheduling order differs per run",
-  queueMicrotask: "scheduling order differs per run",
-  WeakRef: "garbage collection timing differs per run",
-  FinalizationRegistry: "garbage collection timing differs per run",
-  Atomics: "shared memory is not single-threaded",
-  SharedArrayBuffer: "shared memory is not single-threaded",
-  Intl: "locale and time zone data differ per host",
-  Temporal: "locale and time zone data differ per host",
-  eval: "generated code hides inputs from the scan",
-  WebAssembly: "compiled code hides inputs from the scan",
-  ShadowRealm: "a nested realm escapes the allow-list",
-  require: "imports must be bundled into the handler"
-};
-var ALLOWED_GLOBALS = [
-  "undefined",
-  "NaN",
-  "Infinity",
-  "globalThis",
-  "isNaN",
-  "isFinite",
-  "parseInt",
-  "parseFloat",
-  "decodeURI",
-  "decodeURIComponent",
-  "encodeURI",
-  "encodeURIComponent",
-  "escape",
-  "unescape",
-  "Object",
-  "Function",
-  "Array",
-  "Number",
-  "Boolean",
-  "String",
-  "Symbol",
-  "BigInt",
-  "Math",
-  "JSON",
-  "Reflect",
-  "Proxy",
-  "Promise",
-  "Map",
-  "Set",
-  "WeakMap",
-  "WeakSet",
-  "RegExp",
-  "Iterator",
-  "DisposableStack",
-  "AsyncDisposableStack",
-  "Error",
-  "AggregateError",
-  "SuppressedError",
-  "EvalError",
-  "RangeError",
-  "ReferenceError",
-  "SyntaxError",
-  "TypeError",
-  "URIError",
-  "ArrayBuffer",
-  "DataView",
-  "Int8Array",
-  "Uint8Array",
-  "Uint8ClampedArray",
-  "Int16Array",
-  "Uint16Array",
-  "Int32Array",
-  "Uint32Array",
-  "Float16Array",
-  "Float32Array",
-  "Float64Array",
-  "BigInt64Array",
-  "BigUint64Array",
-  "TextEncoder",
-  "TextDecoder",
-  "atob",
-  "btoa",
-  "console"
-];
-var ALLOWED_MATH = [
-  "abs",
-  "min",
-  "max",
-  "floor",
-  "ceil",
-  "trunc",
-  "sign",
-  "round",
-  "E",
-  "LN10",
-  "LN2",
-  "LOG10E",
-  "LOG2E",
-  "PI",
-  "SQRT1_2",
-  "SQRT2"
-];
-var LOCALE_METHODS = [
-  "toLocaleString",
-  "toLocaleDateString",
-  "toLocaleTimeString",
-  "toLocaleUpperCase",
-  "toLocaleLowerCase",
-  "localeCompare"
-];
-function formatFinding(f) {
-  return `${f.file}:${f.line}:${f.column} ${f.name}: ${f.reason}`;
+// src/runtime/memory-store.ts
+import { normalizeAbi as normalizeAbi2, toCamelCase as toCamelCase2 } from "@secondlayer/stacks/clarity";
+class MemoryStore {
+  tables = new Map;
 }
-var STATE_SOURCE_TYPES = new Set([
-  "var_set",
-  "map_set",
-  "map_delete"
-]);
-var LEVEL_RANK = { state: 0, events: 1, none: 2 };
-var MAX_LISTED_FINDINGS = 10;
-function deriveVerification(def, findings = []) {
-  let level = "state";
-  const raise = (to) => {
-    if (LEVEL_RANK[to] > LEVEL_RANK[level])
-      level = to;
-  };
-  const reasons = [];
-  for (const [name, source] of Object.entries(def.sources ?? {})) {
-    const filter = source;
-    if (filter.trait) {
-      raise("none");
-      reasons.push(`source "${name}": trait scope needs a proven contract registry`);
-    } else if (filter.type === "map_insert") {
-      raise("events");
-      reasons.push(`map_insert source "${name}": map_insert vs map_set needs event proofs`);
-    } else if (!STATE_SOURCE_TYPES.has(filter.type)) {
-      raise("events");
-      reasons.push(`${filter.type} source "${name}" needs event proofs`);
+
+class MemorySubgraphContext extends SubgraphContext {
+  store;
+  tables;
+  constructor(store, schema, block, tx) {
+    super(undefined, "memory", schema, block, tx, false);
+    this.store = store;
+    this.tables = schema;
+  }
+  async readRows(table, where, limit) {
+    const rows = (this.store.tables.get(table) ?? []).filter((row) => Object.entries(where).every(([k, v]) => sameValue(row[k], v)));
+    return limit === undefined ? rows : rows.slice(0, limit);
+  }
+  readDependent = null;
+  dependsOnPrior(what) {
+    this.readDependent ??= what;
+  }
+  findOne(table, where) {
+    this.dependsOnPrior(`findOne("${table}")`);
+    return super.findOne(table, where);
+  }
+  findMany(table, where) {
+    this.dependsOnPrior(`findMany("${table}")`);
+    return super.findMany(table, where);
+  }
+  update(table, where, set) {
+    this.dependsOnPrior(`update("${table}")`);
+    super.update(table, where, set);
+  }
+  delete(table, where) {
+    this.dependsOnPrior(`delete("${table}")`);
+    super.delete(table, where);
+  }
+  increment(table, key, deltas) {
+    this.dependsOnPrior(`increment("${table}")`);
+    super.increment(table, key, deltas);
+  }
+  upsert(table, key, row) {
+    const def = this.tables[table];
+    if (def) {
+      const keyCols = Object.keys(key);
+      const keyed = def.uniqueKeys?.some((uk) => uk.length === keyCols.length && uk.every((c) => keyCols.includes(c)));
+      const omitted = Object.keys(def.columns).find((c) => !(c in key) && !(c in row));
+      if (!keyed)
+        this.dependsOnPrior(`upsert("${table}") without a unique key`);
+      else if (omitted)
+        this.dependsOnPrior(`upsert("${table}") leaves "${omitted}" as it was`);
     }
+    super.upsert(table, key, row);
   }
-  if (def.backfillMode === "concurrent") {
-    raise("none");
-    reasons.push("backfillMode concurrent: tip-first order is not chain order");
+  async rowsOf(table) {
+    return this.overlayMany(table, {}, await this.readRows(table, {}));
   }
-  if (findings.some((f) => f.kind === "needs-events"))
-    raise("events");
-  for (const f of findings.slice(0, MAX_LISTED_FINDINGS)) {
-    reasons.push(f.kind === "needs-events" ? `${formatFinding(f)} (needs event proofs)` : formatFinding(f));
+  setReads(reads) {
+    this._client = {
+      contract(contractId, abi) {
+        const camelToKebab = new Map;
+        for (const fn of normalizeAbi2(abi).functions) {
+          camelToKebab.set(toCamelCase2(fn.name), fn.name);
+        }
+        const read = new Proxy({}, {
+          get(_target, prop) {
+            const fnName = camelToKebab.get(prop) ?? prop;
+            const key = `${contractId}.${fnName}`;
+            return async () => {
+              if (!(key in reads)) {
+                throw new Error(`No stubbed chain read for "${key}" — pass it via createTestContext(schema, { reads: { "${key}": … } }).`);
+              }
+              return reads[key];
+            };
+          }
+        });
+        return { read };
+      }
+    };
   }
-  if (findings.length > MAX_LISTED_FINDINGS) {
-    reasons.push(`…and ${findings.length - MAX_LISTED_FINDINGS} more handler findings`);
+  async commitOps() {
+    const tables = new Set;
+    for (const op of this.ops)
+      tables.add(op.table);
+    for (const table of tables) {
+      this.store.tables.set(table, await this.rowsOf(table));
+    }
+    this.ops.length = 0;
+  }
+  insertsSince(checkpoint) {
+    const out = [];
+    for (const op of this.ops.slice(Math.max(0, checkpoint))) {
+      if (op.kind !== "insert")
+        continue;
+      const row = { ...op.data };
+      out.push({
+        table: op.table,
+        keys: Object.keys(row).filter((k) => !k.startsWith("_")),
+        row
+      });
+    }
+    return out;
   }
-  return {
-    level,
-    reasons,
-    unproven: reasons.length === 0 ? [
-      "tx attribution of writes: event.tx, _tx_id (needs event proofs)",
-      "intermediate writes within a block (needs event proofs)"
-    ] : []
-  };
 }
-function isDeterminismViolation(v) {
-  return v.level === "state" && v.reasons.length > 0;
+function sameValue(a, b) {
+  if (a === b)
+    return true;
+  if ((typeof a === "bigint" || typeof a === "number") && (typeof b === "bigint" || typeof b === "number")) {
+    return BigInt(a) === BigInt(b);
+  }
+  return String(a) === String(b);
 }
-function sha256(input) {
-  return createHash2("sha256").update(input).digest("hex");
+
+// src/runtime/runner.ts
+import { getErrorMessage as getErrorMessage2 } from "@secondlayer/shared";
+import { logger as logger4 } from "@secondlayer/shared/logger";
+import {
+  clarityValueToJS,
+  deserializeCV as deserializeCV4,
+  toCamelCase as toCamelCase3
+} from "@secondlayer/stacks/clarity";
+
+// src/print-schema.ts
+import {
+  deserializeCV as deserializeCV2
+} from "@secondlayer/stacks/clarity";
+function camelizeDataKey(str) {
+  return str.replace(/-([a-z0-9])/g, (_, c) => c.toUpperCase());
 }
-function pinPreimage(input) {
-  const fields = {
-    handlerHash: sha256(input.handlerCode),
-    network: input.network,
-    runtime: input.runtime ?? SUBGRAPHS_RUNTIME,
-    schemaHash: input.schemaHash,
-    startBlock: input.startBlock ?? null
-  };
-  return JSON.stringify(fields);
+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 computePin(input) {
-  return sha256(pinPreimage(input));
+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 };
+    }
+  }
 }
-
-// src/runtime/realm.ts
-class NondeterminismError extends Error {
-  name = "NondeterminismError";
+function unifyNullable(a, b) {
+  if (!a)
+    return b;
+  if (!b)
+    return a;
+  return unify(a, b);
 }
-
-class HandlerReadError extends Error {
-  name = "HandlerReadError";
+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 abortsBlock(err) {
-  return err instanceof NondeterminismError || err instanceof HandlerReadError;
+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);
 }
-var HOST_GLOBALS = [
-  "ArrayBuffer",
-  "DataView",
-  "Int8Array",
-  "Uint8Array",
-  "Uint8ClampedArray",
-  "Int16Array",
-  "Uint16Array",
-  "Int32Array",
-  "Uint32Array",
-  "Float16Array",
-  "Float32Array",
-  "Float64Array",
-  "BigInt64Array",
-  "BigUint64Array",
-  "TextEncoder",
-  "TextDecoder",
-  "atob",
-  "btoa"
-];
-function forbid(name, reason) {
-  return () => {
-    throw new NondeterminismError(`${name}: ${reason}`);
-  };
+function wrapOptional(t) {
+  return t.kind === "optional" ? t : { kind: "optional", inner: t };
 }
-function createRealm() {
-  const host = globalThis;
-  const sandbox = Object.create(null);
-  for (const name of HOST_GLOBALS) {
-    if (host[name] !== undefined)
-      sandbox[name] = host[name];
+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(" | ");
   }
-  const context = vm.createContext(sandbox, {
-    name: "subgraph-handler",
-    codeGeneration: { strings: false, wasm: false }
-  });
-  const g = vm.runInContext("globalThis", context);
-  const allowed = new Set(ALLOWED_GLOBALS);
-  for (const name of Object.getOwnPropertyNames(g)) {
-    if (!allowed.has(name))
-      delete g[name];
+}
+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(" | ");
   }
-  for (const [name, reason] of Object.entries(FORBIDDEN_GLOBALS)) {
-    Object.defineProperty(g, name, { get: forbid(name, reason) });
+}
+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";
   }
-  const realmMath = g.Math;
-  const safeMath = {};
-  const allowedMath = new Set(ALLOWED_MATH);
-  for (const key of Object.getOwnPropertyNames(realmMath)) {
-    if (allowedMath.has(key))
-      safeMath[key] = realmMath[key];
+}
+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
-      Object.defineProperty(safeMath, key, {
-        get: forbid(`Math.${key}`, key === "random" ? "randomness differs per run" : "result is engine-approximated")
-      });
+      groups.set(s.topic, [s]);
   }
-  Object.defineProperty(g, "Math", { value: Object.freeze(safeMath) });
-  for (const ctor of ["String", "Number", "BigInt", "Array", "Object"]) {
-    const proto = g[ctor].prototype;
-    for (const method of LOCALE_METHODS) {
-      if (Object.prototype.hasOwnProperty.call(proto, method)) {
-        Object.defineProperty(proto, method, {
-          value: forbid(method, "output depends on the host's locale data")
-        });
+  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 = deserializeCV2(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
+    });
   }
-  Object.preventExtensions(g);
-  return context;
+  return out.sort((a, b) => b.count - a.count);
 }
-function checkRowValues(where, values) {
-  for (const [col, value] of Object.entries(values)) {
-    checkValue(value, `${where}.${col}`);
+
+// src/runtime/clarity.ts
+import { cvToValue, deserializeCV as deserializeCV3 } from "@secondlayer/stacks/clarity";
+function decodeClarityValue(hex) {
+  try {
+    const cleanHex = hex.startsWith("0x") ? hex.slice(2) : hex;
+    const cv = deserializeCV3(cleanHex);
+    return cvToValue(cv);
+  } catch {
+    return hex;
   }
 }
-function checkValue(value, path) {
-  switch (typeof value) {
-    case "number":
-      if (!Number.isSafeInteger(value)) {
-        throw new TypeError(`${path}: ${value} is not a safe integer; verifiable subgraphs store bigint or integers only`);
-      }
-      return;
-    case "function":
-    case "symbol":
-      throw new TypeError(`${path}: a ${typeof value} is not a row value`);
-    case "object":
-      if (value === null || ArrayBuffer.isView(value))
-        return;
-      if (Array.isArray(value)) {
-        value.forEach((v, i) => checkValue(v, `${path}[${i}]`));
-        return;
-      }
-      for (const [k, v] of Object.entries(value))
-        checkValue(v, `${path}.${k}`);
-      return;
-    default:
-      return;
+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 deterministicContext(ctx, schema) {
-  let pendingReads = 0;
-  const knownTable = (table) => {
-    if (!Object.prototype.hasOwnProperty.call(schema, table)) {
-      throw new Error(`Table "${table}" not found in subgraph schema`);
+
+// 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;
     }
-  };
-  const guard = (op) => {
-    if (pendingReads > 0) {
-      throw new NondeterminismError(`ctx.${op} while a ctx read is pending: concurrent ctx calls order writes by database latency; await each read before the next call`);
+  }
+  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;
     }
-  };
-  const read = async (op, run) => {
-    guard(op);
-    pendingReads++;
-    try {
-      return await run();
-    } catch (err) {
-      if (err instanceof NondeterminismError)
-        throw err;
-      throw new HandlerReadError(`ctx.${op} failed: ${err instanceof Error ? err.message : String(err)}`, { cause: err });
-    } finally {
-      pendingReads--;
+    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}"` };
     }
-  };
-  return {
-    get block() {
-      return ctx.block;
-    },
-    get tx() {
-      return ctx.tx;
-    },
-    get client() {
-      throw new NondeterminismError("ctx.client: contract reads need re-execution proofs");
-    },
-    insert(table, row) {
-      guard("insert");
-      checkRowValues(`insert ${table}`, row);
-      ctx.insert(table, row);
-    },
-    update(table, where, set) {
-      guard("update");
-      checkRowValues(`update ${table}`, where);
-      checkRowValues(`update ${table}`, set);
-      ctx.update(table, where, set);
-    },
-    upsert(table, key, row) {
-      guard("upsert");
-      checkRowValues(`upsert ${table}`, key);
-      checkRowValues(`upsert ${table}`, row);
-      ctx.upsert(table, key, row);
-    },
-    delete(table, where) {
-      guard("delete");
-      ctx.delete(table, where);
-    },
-    increment(table, key, deltas) {
-      guard("increment");
-      checkRowValues(`increment ${table}`, key);
-      checkRowValues(`increment ${table}`, deltas);
-      ctx.increment(table, key, deltas);
-    },
-    findOne: (table, where) => {
-      knownTable(table);
-      return read("findOne", () => ctx.findOne(table, where));
-    },
-    findMany: (table, ...rest) => {
-      knownTable(table);
-      return read("findMany", () => ctx.findMany(table, ...rest));
+    if (!matchesField(field, data[name])) {
+      return {
+        ok: false,
+        reason: `field "${name}" does not match its declared type (got ${describe(data[name])})`
+      };
     }
-  };
-}
-var realmDefinitions = new WeakSet;
-async function loadDeterministicDefinition(handlerCode) {
-  const { transform } = await import("esbuild");
-  const { code } = await transform(handlerCode, {
-    format: "cjs",
-    loader: "js",
-    logLevel: "silent"
-  });
-  const context = createRealm();
-  const evaluate = vm.runInContext(`(function (module, exports) {
-${code}
-})`, context, { filename: "handler.js" });
-  const mod = { exports: {} };
-  evaluate(mod, mod.exports);
-  const def = mod.exports.default ?? mod.exports;
-  const sources = structuredClone(def.sources);
-  const schema = structuredClone(def.schema);
-  const facades = new WeakMap;
-  const handlers = {};
-  for (const [name, handler] of Object.entries(def.handlers ?? {})) {
-    handlers[name] = (event, ctx) => {
-      let facade = facades.get(ctx);
-      if (!facade) {
-        facade = deterministicContext(ctx, schema);
-        facades.set(ctx, facade);
-      }
-      return handler(event, facade);
-    };
   }
-  const loaded = { ...def, sources, schema, handlers };
-  realmDefinitions.add(loaded);
-  return loaded;
+  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/source-matcher.ts
@@ -1970,6 +2034,41 @@ function printContractId(data) {
   const id = (typeof data.contract_identifier === "string" ? data.contract_identifier : undefined) ?? (typeof data.contract_id === "string" ? data.contract_id : undefined);
   return id || undefined;
 }
+var decodedPrints = new WeakMap;
+function decodedPrintTuple(event, data) {
+  if (decodedPrints.has(event))
+    return decodedPrints.get(event) ?? null;
+  const raw = data.raw_value;
+  const value = typeof raw === "string" && raw.startsWith("0x") ? decodeClarityValue(raw) : null;
+  const tuple = value && typeof value === "object" && !Array.isArray(value) ? value : null;
+  decodedPrints.set(event, tuple);
+  return tuple;
+}
+function printFieldEquals(decoded, key, expected) {
+  const value = decoded[key];
+  let actual;
+  if (typeof value === "string")
+    actual = value;
+  else if (typeof value === "bigint" || typeof value === "boolean")
+    actual = String(value);
+  else
+    return false;
+  return typeof expected === "string" ? actual === expected : expected.includes(actual);
+}
+function printFieldsAllow(filter, event, data) {
+  if (!filter.topic && !filter.where)
+    return true;
+  const decoded = decodedPrintTuple(event, data);
+  if (!decoded)
+    return false;
+  if (filter.topic && !printFieldEquals(decoded, "topic", filter.topic))
+    return false;
+  for (const [key, expected] of Object.entries(filter.where ?? {})) {
+    if (!printFieldEquals(decoded, key, expected))
+      return false;
+  }
+  return true;
+}
 function matchFilter(filter, transactions, eventsByTx, traitContracts, factoryContracts = new Map, vmEventsByTx = new Map) {
   const results = [];
   switch (filter.type) {
@@ -2206,7 +2305,7 @@ function matchFilter(filter, transactions, eventsByTx, traitContracts, factoryCo
             return false;
           if (!factoryAllows(filter, contractId, factoryContracts))
             return false;
-          return true;
+          return printFieldsAllow(filter, e, data);
         });
         if (matched.length > 0) {
           results.push({ tx, events: matched });
@@ -2735,7 +2834,7 @@ async function runHandlers(subgraph, matched, ctx, opts) {
         sourceName,
         txId: tx.tx_id,
         ...event !== null ? { eventId: event.id, eventType: event.type } : {},
-        error: getErrorMessage(err)
+        error: getErrorMessage2(err)
       });
     }
   }
@@ -2803,6 +2902,14 @@ function txFromRow(row) {
     ...typeof r.function_name === "string" ? { functionName: r.function_name } : {}
   };
 }
+function indexPrintWhereAllows(where, row) {
+  if (!where)
+    return true;
+  const value = row.payload?.value;
+  if (!value || typeof value !== "object" || Array.isArray(value))
+    return false;
+  return Object.entries(where).every(([key, expected]) => printFieldEquals(value, key, expected));
+}
 function toHandlerPayload(_filter, row) {
   const tx = defaultTx(txFromRow(row));
   if (row.event_type === "print") {
@@ -2960,7 +3067,7 @@ async function runSubgraphTest(input) {
       continue;
     for (const row of rows) {
       const payload = filter?.type === "contract_call" ? toContractCallPayload(row) : toHandlerPayload(filter, row);
-      if (filter?.type === "print_event" && filter.topic && payload.topic !== filter.topic) {
+      if (filter?.type === "print_event" && (filter.topic && payload.topic !== filter.topic || !indexPrintWhereAllows(filter.where, row))) {
         continue;
       }
       if (!firstEvent) {
@@ -3099,5 +3206,5 @@ export {
   toHandlerPayload
 };
 
-//# debugId=80779D350271083F64756E2164756E21
+//# debugId=1050D35A53F758C264756E2164756E21
 //# sourceMappingURL=index.js.map