@secondlayer/subgraphs 6.3.6 → 6.5.0

package/dist/verify/index.js

@@ -0,0 +1,3341 @@
+// src/verify/replay.ts
+import { createHash as createHash3 } from "node:crypto";
+import { decodeRawTx } from "@secondlayer/shared/node/tx-summary";
+import {
+  BlockVerifier,
+  MAINNET_CHECKPOINT,
+  hex
+} from "@secondlayer/verify";
+
+// src/runtime/runner.ts
+import { getErrorMessage } from "@secondlayer/shared";
+import { logger as logger2 } from "@secondlayer/shared/logger";
+import {
+  clarityValueToJS,
+  deserializeCV as deserializeCV3,
+  toCamelCase
+} from "@secondlayer/stacks/clarity";
+
+// src/print-schema.ts
+import {
+  deserializeCV
+} from "@secondlayer/stacks/clarity";
+function camelizeDataKey(str) {
+  return str.replace(/-([a-z0-9])/g, (_, c) => c.toUpperCase());
+}
+function camelizeKeys(obj) {
+  if (obj === null || obj === undefined)
+    return obj;
+  if (typeof obj !== "object")
+    return obj;
+  if (Array.isArray(obj))
+    return obj.map(camelizeKeys);
+  const result = {};
+  for (const [k, v] of Object.entries(obj)) {
+    result[camelizeDataKey(k)] = camelizeKeys(v);
+  }
+  return result;
+}
+function cvToTree(cv) {
+  switch (cv.type) {
+    case "uint":
+    case "int":
+      return { kind: cv.type };
+    case "true":
+    case "false":
+      return { kind: "bool" };
+    case "address":
+    case "contract":
+      return { kind: "principal" };
+    case "buffer":
+      return { kind: "buffer", len: cv.value.length / 2 };
+    case "ascii":
+      return { kind: "ascii", len: cv.value.length };
+    case "utf8":
+      return { kind: "utf8", len: new TextEncoder().encode(cv.value).length };
+    case "none":
+      return { kind: "optional", inner: null };
+    case "some":
+      return { kind: "optional", inner: cvToTree(cv.value) };
+    case "ok":
+      return { kind: "response", ok: cvToTree(cv.value), err: null };
+    case "err":
+      return { kind: "response", ok: null, err: cvToTree(cv.value) };
+    case "list": {
+      let inner = null;
+      for (const el of cv.value) {
+        const t = cvToTree(el);
+        inner = inner ? unify(inner, t) : t;
+      }
+      return { kind: "list", inner };
+    }
+    case "tuple": {
+      const entries = new Map;
+      for (const [k, v] of Object.entries(cv.value)) {
+        entries.set(k, { tree: cvToTree(v), present: 1 });
+      }
+      return { kind: "tuple", count: 1, entries };
+    }
+  }
+}
+function unifyNullable(a, b) {
+  if (!a)
+    return b;
+  if (!b)
+    return a;
+  return unify(a, b);
+}
+var UNION_KIND_ORDER = {
+  uint: 0,
+  int: 1,
+  bool: 2,
+  principal: 3,
+  buffer: 4,
+  ascii: 5,
+  utf8: 6,
+  list: 7,
+  tuple: 8,
+  response: 9
+};
+function makeUnion(members) {
+  const sorted = [...members].sort((a, b) => (UNION_KIND_ORDER[a.kind] ?? 99) - (UNION_KIND_ORDER[b.kind] ?? 99));
+  return { kind: "union", members: sorted };
+}
+function unify(a, b) {
+  if (a.kind === "optional" || b.kind === "optional") {
+    const ai = a.kind === "optional" ? a.inner : a;
+    const bi = b.kind === "optional" ? b.inner : b;
+    return { kind: "optional", inner: unifyNullable(ai, bi) };
+  }
+  if (a.kind === "union")
+    return unionAdd(a.members, b);
+  if (b.kind === "union")
+    return unionAdd(b.members, a);
+  if (a.kind !== b.kind)
+    return makeUnion([a, b]);
+  switch (a.kind) {
+    case "uint":
+    case "int":
+    case "bool":
+    case "principal":
+      return a;
+    case "buffer":
+    case "ascii":
+    case "utf8":
+      return { kind: a.kind, len: Math.max(a.len, b.len) };
+    case "list":
+      return {
+        kind: "list",
+        inner: unifyNullable(a.inner, b.inner)
+      };
+    case "response": {
+      const rb = b;
+      return {
+        kind: "response",
+        ok: unifyNullable(a.ok, rb.ok),
+        err: unifyNullable(a.err, rb.err)
+      };
+    }
+    case "tuple": {
+      const tb = b;
+      const entries = new Map([...a.entries].map(([k, e]) => [k, { ...e }]));
+      for (const [k, e] of tb.entries) {
+        const existing = entries.get(k);
+        entries.set(k, existing ? {
+          tree: unify(existing.tree, e.tree),
+          present: existing.present + e.present
+        } : { ...e });
+      }
+      return { kind: "tuple", count: a.count + tb.count, entries };
+    }
+  }
+}
+function unionAdd(members, t) {
+  if (t.kind === "union") {
+    let acc = { kind: "union", members };
+    for (const m of t.members)
+      acc = unify(acc, m);
+    return acc;
+  }
+  const next = [...members];
+  for (let i = 0;i < next.length; i++) {
+    const member = next[i];
+    if (!member)
+      continue;
+    const merged = unify(member, t);
+    if (merged.kind !== "union") {
+      next[i] = merged;
+      return makeUnion(next);
+    }
+  }
+  next.push(t);
+  return makeUnion(next);
+}
+function wrapOptional(t) {
+  return t.kind === "optional" ? t : { kind: "optional", inner: t };
+}
+function renderClarity(t) {
+  if (!t)
+    return "?";
+  switch (t.kind) {
+    case "uint":
+    case "int":
+    case "bool":
+    case "principal":
+      return t.kind;
+    case "buffer":
+      return `(buff ${t.len})`;
+    case "ascii":
+      return `(string-ascii ${t.len})`;
+    case "utf8":
+      return `(string-utf8 ${t.len})`;
+    case "optional":
+      return `(optional ${renderClarity(t.inner)})`;
+    case "list":
+      return `(list ${renderClarity(t.inner)})`;
+    case "response":
+      return `(response ${renderClarity(t.ok)} ${renderClarity(t.err)})`;
+    case "tuple": {
+      const parts = [...t.entries].map(([k, e]) => {
+        const tree = e.present < t.count ? wrapOptional(e.tree) : e.tree;
+        return `(${k} ${renderClarity(tree)})`;
+      });
+      return `(tuple ${parts.join(" ")})`;
+    }
+    case "union":
+      return t.members.map(renderClarity).join(" | ");
+  }
+}
+function renderTs(t) {
+  if (!t)
+    return "unknown";
+  switch (t.kind) {
+    case "uint":
+    case "int":
+      return "bigint";
+    case "bool":
+      return "boolean";
+    case "principal":
+    case "buffer":
+    case "ascii":
+    case "utf8":
+      return "string";
+    case "optional":
+      return t.inner ? `${renderTs(t.inner)} | null` : "unknown | null";
+    case "list": {
+      const inner = renderTs(t.inner);
+      return inner.includes(" | ") ? `(${inner})[]` : `${inner}[]`;
+    }
+    case "response": {
+      const sides = [...new Set([renderTs(t.ok), renderTs(t.err)])];
+      return sides.join(" | ");
+    }
+    case "tuple": {
+      const parts = [...t.entries].map(([k, e]) => {
+        const opt = e.present < t.count ? "?" : "";
+        return `${camelizeDataKey(k)}${opt}: ${renderTs(e.tree)}`;
+      });
+      return `{ ${parts.join("; ")} }`;
+    }
+    case "union":
+      return [...new Set(t.members.map((m) => renderTs(m)))].join(" | ");
+  }
+}
+function toColumnType(t) {
+  if (!t)
+    return "jsonb";
+  switch (t.kind) {
+    case "uint":
+      return "uint";
+    case "int":
+      return "int";
+    case "bool":
+      return "boolean";
+    case "principal":
+      return "principal";
+    case "buffer":
+    case "ascii":
+    case "utf8":
+      return "text";
+    case "list":
+    case "tuple":
+      return "jsonb";
+    case "optional":
+      return toColumnType(t.inner);
+    case "response":
+      return t.ok ? toColumnType(t.ok) : "jsonb";
+    case "union":
+      return "jsonb";
+  }
+}
+var MAX_DECODED_PER_TOPIC_NEWEST = 75;
+var MAX_DECODED_PER_TOPIC_OLDEST = 25;
+function inferPrintTopics(samples) {
+  const groups = new Map;
+  for (const s of samples) {
+    const group = groups.get(s.topic);
+    if (group)
+      group.push(s);
+    else
+      groups.set(s.topic, [s]);
+  }
+  const out = [];
+  for (const [topic, rows] of groups) {
+    let first = Number.POSITIVE_INFINITY;
+    let last = Number.NEGATIVE_INFINITY;
+    for (const r of rows) {
+      if (r.blockHeight < first)
+        first = r.blockHeight;
+      if (r.blockHeight > last)
+        last = r.blockHeight;
+    }
+    const withHex = [...rows].filter((r) => r.rawHex !== null).sort((a, b) => b.blockHeight - a.blockHeight);
+    const budget = MAX_DECODED_PER_TOPIC_NEWEST + MAX_DECODED_PER_TOPIC_OLDEST;
+    const picked = withHex.length <= budget ? withHex : [
+      ...withHex.slice(0, MAX_DECODED_PER_TOPIC_NEWEST),
+      ...withHex.slice(-MAX_DECODED_PER_TOPIC_OLDEST)
+    ];
+    const tuples = [];
+    let decoded = 0;
+    for (const p of picked) {
+      try {
+        const cv = deserializeCV(p.rawHex);
+        decoded++;
+        if (cv.type === "tuple")
+          tuples.push(cv);
+      } catch {}
+    }
+    const nonTuple = decoded > 0 && tuples.length === 0;
+    const fields = [];
+    if (!nonTuple) {
+      const stats = new Map;
+      for (const t of tuples) {
+        for (const [key, value] of Object.entries(t.value)) {
+          if (key === "topic")
+            continue;
+          const tree = cvToTree(value);
+          const existing = stats.get(key);
+          if (existing) {
+            existing.present++;
+            existing.tree = unify(existing.tree, tree);
+            if (value.type === "none")
+              existing.noneCount++;
+            if (value.type === "none" || value.type === "some") {
+              existing.optionalSeen = true;
+            }
+          } else {
+            stats.set(key, {
+              tree,
+              present: 1,
+              noneCount: value.type === "none" ? 1 : 0,
+              optionalSeen: value.type === "none" || value.type === "some"
+            });
+          }
+        }
+      }
+      for (const [name, st] of [...stats].sort(([a], [b]) => a.localeCompare(b))) {
+        const field = {
+          name,
+          camel_name: camelizeDataKey(name),
+          clarity_type: renderClarity(st.tree),
+          ts_type: renderTs(st.tree),
+          column_type: toColumnType(st.tree),
+          always_present: st.present === tuples.length
+        };
+        if (st.optionalSeen) {
+          field.optional_some_rate = (st.present - st.noneCount) / st.present;
+        }
+        fields.push(field);
+      }
+    }
+    out.push({
+      topic,
+      count: rows.length,
+      first_height: first,
+      last_height: last,
+      non_tuple: nonTuple,
+      fields
+    });
+  }
+  return out.sort((a, b) => b.count - a.count);
+}
+
+// src/runtime/clarity.ts
+import { cvToValue, deserializeCV as deserializeCV2 } from "@secondlayer/stacks/clarity";
+function decodeClarityValue(hex) {
+  try {
+    const cleanHex = hex.startsWith("0x") ? hex.slice(2) : hex;
+    const cv = deserializeCV2(cleanHex);
+    return cvToValue(cv);
+  } catch {
+    return hex;
+  }
+}
+function decodeEventData(data) {
+  if (typeof data === "string" && data.startsWith("0x") && data.length > 10) {
+    return decodeClarityValue(data);
+  }
+  if (Array.isArray(data)) {
+    return data.map(decodeEventData);
+  }
+  if (typeof data === "object" && data !== null) {
+    const decoded = {};
+    for (const [key, value] of Object.entries(data)) {
+      decoded[key] = decodeEventData(value);
+    }
+    return decoded;
+  }
+  return data;
+}
+
+// src/runtime/print-validate.ts
+var COLUMN_TYPES = new Set([
+  "text",
+  "uint",
+  "int",
+  "principal",
+  "boolean",
+  "timestamp",
+  "jsonb"
+]);
+function isColumnType(field) {
+  return typeof field === "string" && COLUMN_TYPES.has(field);
+}
+function matchesField(field, value) {
+  if (isColumnType(field)) {
+    switch (field) {
+      case "uint":
+      case "int":
+        return typeof value === "bigint" || typeof value === "number";
+      case "boolean":
+        return typeof value === "boolean";
+      case "text":
+      case "principal":
+      case "timestamp":
+        return typeof value === "string" || typeof value === "number" || typeof value === "bigint";
+      case "jsonb":
+        return value !== undefined;
+    }
+  }
+  if (typeof field !== "object" || field === null)
+    return false;
+  if ("optional" in field) {
+    return value === undefined || value === null || matchesField(field.type, value);
+  }
+  if ("tuple" in field) {
+    if (typeof value !== "object" || value === null || Array.isArray(value)) {
+      return false;
+    }
+    return matchesTopic(field.tuple, value).ok;
+  }
+  if ("list" in field) {
+    return Array.isArray(value) && value.every((item) => matchesField(field.list, item));
+  }
+  return false;
+}
+function matchesTopic(declared, data) {
+  for (const [name, field] of Object.entries(declared)) {
+    const present = name in data;
+    const optional = typeof field === "object" && field !== null && "optional" in field;
+    if (!present) {
+      if (optional)
+        continue;
+      return { ok: false, reason: `missing declared field "${name}"` };
+    }
+    if (!matchesField(field, data[name])) {
+      return {
+        ok: false,
+        reason: `field "${name}" does not match its declared type (got ${describe(data[name])})`
+      };
+    }
+  }
+  return { ok: true };
+}
+function describe(value) {
+  if (value === null)
+    return "null";
+  if (Array.isArray(value))
+    return "array";
+  return typeof value;
+}
+function validatePrintPayload(prints, topic, data) {
+  if (!prints)
+    return { ok: true };
+  const declared = prints[topic];
+  if (!declared)
+    return { ok: true };
+  return matchesTopic(declared, data);
+}
+
+// src/runtime/realm.ts
+import vm from "node:vm";
+
+// src/verification.ts
+import { createHash } from "node:crypto";
+// package.json
+var package_default = {
+  name: "@secondlayer/subgraphs",
+  version: "6.5.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"
+    }
+  },
+  files: ["dist"],
+  scripts: {
+    build: "bunup",
+    dev: "bunup --watch",
+    test: "bun test",
+    typecheck: "tsc --noEmit",
+    prepublishOnly: "bun run build"
+  },
+  dependencies: {
+    "@secondlayer/shared": "^11.23.0",
+    "@secondlayer/stacks": "^6.2.0",
+    "@secondlayer/verify": "^0.3.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"
+  }
+};
+
+// 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`);
+    }
+  }
+  if (def.backfillMode === "concurrent") {
+    raise("none");
+    reasons.push("backfillMode concurrent: tip-first order is not chain order");
+  }
+  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));
+  }
+  if (findings.length > MAX_LISTED_FINDINGS) {
+    reasons.push(`…and ${findings.length - MAX_LISTED_FINDINGS} more handler findings`);
+  }
+  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 createHash("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];
+  }
+  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];
+  }
+  for (const [name, reason] of Object.entries(FORBIDDEN_GLOBALS)) {
+    Object.defineProperty(g, name, { get: forbid(name, reason) });
+  }
+  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")
+      });
+  }
+  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")
+        });
+      }
+    }
+  }
+  Object.preventExtensions(g);
+  return context;
+}
+function checkRowValues(where, values) {
+  for (const [col, value] of Object.entries(values)) {
+    checkValue(value, `${where}.${col}`);
+  }
+}
+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 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`);
+    }
+  };
+  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);
+    };
+  }
+  const loaded = { ...def, sources, schema, handlers };
+  realmDefinitions.add(loaded);
+  return loaded;
+}
+
+// src/runtime/source-matcher.ts
+var patternCache = new Map;
+function matchAny(value, pattern) {
+  return Array.isArray(pattern) ? pattern.some((p) => matchPattern(value, p)) : matchPattern(value, pattern);
+}
+function matchPattern(value, pattern) {
+  if (!pattern.includes("*"))
+    return value === pattern;
+  let re = patternCache.get(pattern);
+  if (!re) {
+    const regex = pattern.replace(/[.+^${}()|[\]\\]/g, "\\$&").replace(/\*/g, ".*");
+    re = new RegExp(`^${regex}$`);
+    patternCache.set(pattern, re);
+  }
+  return re.test(value);
+}
+var EMPTY_SET = new Set;
+function factoryAllows(filter, contractId, factoryContracts) {
+  if (!filter.factory)
+    return true;
+  if (!contractId)
+    return false;
+  return (factoryContracts.get(filter.factory.from) ?? EMPTY_SET).has(contractId);
+}
+function traitAllows(filter, contractId, traitContracts) {
+  const trait = filter.trait;
+  if (!trait)
+    return true;
+  if (!contractId)
+    return false;
+  return (traitContracts.get(trait) ?? EMPTY_SET).has(contractId);
+}
+function assetContract(assetId) {
+  return assetId?.split("::")[0];
+}
+function printContractId(data) {
+  if (!data)
+    return;
+  const id = (typeof data.contract_identifier === "string" ? data.contract_identifier : undefined) ?? (typeof data.contract_id === "string" ? data.contract_id : undefined);
+  return id || undefined;
+}
+function matchFilter(filter, transactions, eventsByTx, traitContracts, factoryContracts = new Map, vmEventsByTx = new Map) {
+  const results = [];
+  switch (filter.type) {
+    case "stx_transfer":
+    case "stx_mint":
+    case "stx_burn":
+    case "stx_lock": {
+      const eventType = `${filter.type}_event`;
+      for (const tx of transactions) {
+        const txEvents = eventsByTx.get(tx.tx_id) ?? [];
+        const matched = txEvents.filter((e) => e.type === eventType);
+        if (matched.length === 0)
+          continue;
+        const filtered = matched.filter((e) => {
+          const data = e.data;
+          if (!data)
+            return false;
+          if ("sender" in filter && filter.sender) {
+            if (!matchPattern(data.sender, filter.sender))
+              return false;
+          }
+          if ("recipient" in filter && filter.recipient) {
+            if (!matchPattern(data.recipient, filter.recipient))
+              return false;
+          }
+          if ("lockedAddress" in filter && filter.lockedAddress) {
+            if (!matchPattern(data.locked_address, filter.lockedAddress))
+              return false;
+          }
+          if ("minAmount" in filter && filter.minAmount !== undefined) {
+            const amount = BigInt(data.amount ?? data.locked_amount ?? "0");
+            if (amount < filter.minAmount)
+              return false;
+          }
+          if ("maxAmount" in filter && filter.maxAmount !== undefined) {
+            const amount = BigInt(data.amount ?? "0");
+            if (amount > filter.maxAmount)
+              return false;
+          }
+          return true;
+        });
+        if (filtered.length > 0) {
+          results.push({ tx, events: filtered });
+        }
+      }
+      break;
+    }
+    case "ft_transfer":
+    case "ft_mint":
+    case "ft_burn": {
+      const eventType = `${filter.type}_event`;
+      for (const tx of transactions) {
+        const txEvents = eventsByTx.get(tx.tx_id) ?? [];
+        const matched = txEvents.filter((e) => {
+          if (e.type !== eventType)
+            return false;
+          const data = e.data;
+          if (!data)
+            return false;
+          if (filter.assetIdentifier) {
+            const assetId = data.asset_identifier;
+            if (!assetId || !matchPattern(assetId, filter.assetIdentifier))
+              return false;
+          }
+          if (!traitAllows(filter, assetContract(data.asset_identifier), traitContracts))
+            return false;
+          if ("sender" in filter && filter.sender) {
+            if (!matchPattern(data.sender, filter.sender))
+              return false;
+          }
+          if ("recipient" in filter && filter.recipient) {
+            if (!matchPattern(data.recipient, filter.recipient))
+              return false;
+          }
+          if (filter.minAmount !== undefined) {
+            const amount = BigInt(data.amount ?? "0");
+            if (amount < filter.minAmount)
+              return false;
+          }
+          return true;
+        });
+        if (matched.length > 0) {
+          results.push({ tx, events: matched });
+        }
+      }
+      break;
+    }
+    case "nft_transfer":
+    case "nft_mint":
+    case "nft_burn": {
+      const eventType = `${filter.type}_event`;
+      for (const tx of transactions) {
+        const txEvents = eventsByTx.get(tx.tx_id) ?? [];
+        const matched = txEvents.filter((e) => {
+          if (e.type !== eventType)
+            return false;
+          const data = e.data;
+          if (!data)
+            return false;
+          if (filter.assetIdentifier) {
+            const assetId = data.asset_identifier;
+            if (!assetId || !matchPattern(assetId, filter.assetIdentifier))
+              return false;
+          }
+          if (!traitAllows(filter, assetContract(data.asset_identifier), traitContracts))
+            return false;
+          if ("sender" in filter && filter.sender) {
+            if (!matchPattern(data.sender, filter.sender))
+              return false;
+          }
+          if ("recipient" in filter && filter.recipient) {
+            if (!matchPattern(data.recipient, filter.recipient))
+              return false;
+          }
+          return true;
+        });
+        if (matched.length > 0) {
+          results.push({ tx, events: matched });
+        }
+      }
+      break;
+    }
+    case "contract_call": {
+      for (const tx of transactions) {
+        if (tx.type !== "contract_call")
+          continue;
+        if (filter.contractId) {
+          if (!tx.contract_id || !matchAny(tx.contract_id, filter.contractId))
+            continue;
+        }
+        if (!factoryAllows(filter, tx.contract_id, factoryContracts))
+          continue;
+        if (filter.functionName) {
+          if (!tx.function_name || !matchPattern(tx.function_name, filter.functionName))
+            continue;
+        }
+        if (filter.caller) {
+          if (!matchPattern(tx.sender, filter.caller))
+            continue;
+        }
+        if (!traitAllows(filter, tx.contract_id, traitContracts))
+          continue;
+        const txEvents = eventsByTx.get(tx.tx_id) ?? [];
+        results.push({ tx, events: txEvents });
+      }
+      break;
+    }
+    case "contract_deploy": {
+      for (const tx of transactions) {
+        if (tx.type !== "smart_contract")
+          continue;
+        if (filter.deployer) {
+          if (!matchPattern(tx.sender, filter.deployer))
+            continue;
+        }
+        if (filter.contractName) {
+          const name = tx.contract_id?.split(".")[1] ?? "";
+          if (!matchPattern(name, filter.contractName))
+            continue;
+        }
+        const txEvents = eventsByTx.get(tx.tx_id) ?? [];
+        results.push({ tx, events: txEvents });
+      }
+      break;
+    }
+    case "nested_contract_call":
+    case "var_set":
+    case "map_set":
+    case "map_insert":
+    case "map_delete": {
+      for (const tx of transactions) {
+        const txEvents = vmEventsByTx.get(tx.tx_id) ?? [];
+        const matched = txEvents.filter((e) => {
+          if (e.type !== filter.type)
+            return false;
+          const data = e.data;
+          if (!data)
+            return false;
+          const contractId = printContractId(data);
+          if ("contractId" in filter && filter.contractId) {
+            if (!contractId || !matchAny(contractId, filter.contractId))
+              return false;
+          }
+          if (!traitAllows(filter, contractId, traitContracts))
+            return false;
+          if (!factoryAllows(filter, contractId, factoryContracts))
+            return false;
+          if (filter.type === "nested_contract_call") {
+            if (filter.functionName) {
+              if (typeof data.function_name !== "string" || !matchPattern(data.function_name, filter.functionName))
+                return false;
+            }
+            if (filter.caller) {
+              if (typeof data.caller !== "string" || !matchPattern(data.caller, filter.caller))
+                return false;
+            }
+            if (filter.sender) {
+              if (typeof data.sender !== "string" || !matchPattern(data.sender, filter.sender))
+                return false;
+            }
+          }
+          if (filter.type === "var_set" && filter.varName) {
+            if (typeof data.var_name !== "string" || !matchPattern(data.var_name, filter.varName))
+              return false;
+          }
+          if ((filter.type === "map_set" || filter.type === "map_insert" || filter.type === "map_delete") && filter.map) {
+            if (typeof data.map_name !== "string" || !matchPattern(data.map_name, filter.map))
+              return false;
+          }
+          return true;
+        });
+        if (matched.length > 0)
+          results.push({ tx, events: matched });
+      }
+      break;
+    }
+    case "print_event": {
+      for (const tx of transactions) {
+        const txEvents = eventsByTx.get(tx.tx_id) ?? [];
+        const matched = txEvents.filter((e) => {
+          if (e.type !== "smart_contract_event" && e.type !== "contract_event")
+            return false;
+          const data = e.data;
+          if (!data)
+            return false;
+          if (data.topic !== "print")
+            return false;
+          const contractId = printContractId(data);
+          if (filter.contractId) {
+            if (!contractId || !matchAny(contractId, filter.contractId))
+              return false;
+          }
+          if (!traitAllows(filter, contractId, traitContracts))
+            return false;
+          if (!factoryAllows(filter, contractId, factoryContracts))
+            return false;
+          return true;
+        });
+        if (matched.length > 0) {
+          results.push({ tx, events: matched });
+        }
+      }
+      break;
+    }
+  }
+  return results;
+}
+function matchSources(sources, transactions, events, traitContracts = new Map, factoryContracts = new Map, vmEvents = []) {
+  const eventsByTx = new Map;
+  for (const event of events) {
+    const list = eventsByTx.get(event.tx_id) ?? [];
+    list.push(event);
+    eventsByTx.set(event.tx_id, list);
+  }
+  const vmEventsByTx = new Map;
+  for (const event of vmEvents) {
+    const list = vmEventsByTx.get(event.tx_id) ?? [];
+    list.push(event);
+    vmEventsByTx.set(event.tx_id, list);
+  }
+  const seen = new Set;
+  const results = [];
+  for (const [sourceName, filter] of Object.entries(sources)) {
+    const matches = matchFilter(filter, transactions, eventsByTx, traitContracts, factoryContracts, vmEventsByTx);
+    for (const match of matches) {
+      const dedupeKey = `${match.tx.tx_id}:${sourceName}`;
+      if (!seen.has(dedupeKey)) {
+        seen.add(dedupeKey);
+        results.push({ ...match, sourceName });
+      }
+    }
+  }
+  return results;
+}
+
+// src/runtime/violations.ts
+import { getTargetDb } from "@secondlayer/shared/db";
+import { logger } from "@secondlayer/shared/logger";
+import { sql } from "kysely";
+var VIOLATIONS_CAP_PER_SUBGRAPH = 100;
+function jsonSafe(value) {
+  if (typeof value === "bigint")
+    return value.toString();
+  if (value === null || value === undefined)
+    return value;
+  if (Array.isArray(value))
+    return value.map(jsonSafe);
+  if (typeof value === "object") {
+    const out = {};
+    for (const [k, v] of Object.entries(value)) {
+      out[k] = jsonSafe(v);
+    }
+    return out;
+  }
+  return value;
+}
+async function defaultRecordPrintViolation(input) {
+  try {
+    const db = getTargetDb();
+    const sample = jsonSafe(input.samplePayload);
+    await db.insertInto("subgraph_violations").values({
+      subgraph_name: input.subgraphName,
+      source_name: input.sourceName,
+      block_height: input.blockHeight,
+      tx_id: input.txId,
+      reason: input.reason,
+      sample_payload: sample
+    }).execute();
+    await sql`
+			DELETE FROM subgraph_violations
+			WHERE id IN (
+				SELECT id FROM subgraph_violations
+				WHERE subgraph_name = ${input.subgraphName}
+				ORDER BY seen_at DESC
+				OFFSET ${VIOLATIONS_CAP_PER_SUBGRAPH}
+			)
+		`.execute(db);
+  } catch (err) {
+    logger.warn("Failed to record print violation", {
+      subgraph: input.subgraphName,
+      error: err instanceof Error ? err.message : String(err)
+    });
+  }
+}
+var recorder = defaultRecordPrintViolation;
+async function recordPrintViolation(input) {
+  await recorder(input);
+}
+
+// src/runtime/runner.ts
+var DEFAULT_ERROR_THRESHOLD = 50;
+function decodeFunctionArgs(args) {
+  let parsed = args;
+  if (typeof parsed === "string") {
+    try {
+      parsed = JSON.parse(parsed);
+    } catch {
+      return [];
+    }
+  }
+  if (!Array.isArray(parsed))
+    return [];
+  return parsed.map((arg) => {
+    if (typeof arg === "string")
+      return decodeClarityValue(arg);
+    return arg;
+  });
+}
+function decodeRawResult(raw) {
+  if (typeof raw === "string" && raw.length > 2) {
+    return decodeClarityValue(raw);
+  }
+  return null;
+}
+function decodeRawHex(hex) {
+  if (hex.startsWith("0x") && hex.length > 2) {
+    return decodeClarityValue(hex);
+  }
+  return hex;
+}
+function safeBigInt(val) {
+  if (typeof val === "bigint")
+    return val;
+  if (typeof val === "number")
+    return BigInt(val);
+  if (typeof val === "string") {
+    try {
+      return BigInt(val);
+    } catch {
+      return 0n;
+    }
+  }
+  return 0n;
+}
+function buildContractCallInput(filter, tx) {
+  const abi = filter.abi;
+  const fnName = tx.function_name;
+  if (!abi || !fnName)
+    return;
+  const fn = abi.functions?.find((f) => f.name === fnName);
+  if (!fn || !Array.isArray(fn.args))
+    return;
+  let rawArgs = tx.function_args;
+  if (typeof rawArgs === "string") {
+    try {
+      rawArgs = JSON.parse(rawArgs);
+    } catch {
+      return;
+    }
+  }
+  if (!Array.isArray(rawArgs))
+    return;
+  const decodeArg = clarityValueToJS;
+  const input = {};
+  fn.args.forEach((arg, i) => {
+    const hex = rawArgs[i];
+    if (typeof hex !== "string")
+      return;
+    try {
+      const clean = hex.startsWith("0x") ? hex.slice(2) : hex;
+      input[toCamelCase(arg.name)] = decodeArg(arg.type, deserializeCV3(clean));
+    } catch {}
+  });
+  return input;
+}
+function buildEventPayload(filter, tx, event) {
+  const txMeta = {
+    txId: tx.tx_id,
+    sender: tx.sender,
+    type: tx.type,
+    status: tx.status,
+    contractId: tx.contract_id ?? null,
+    functionName: tx.function_name ?? null
+  };
+  const decodedArgs = decodeFunctionArgs(tx.function_args);
+  const decodedResult = decodeRawResult(tx.raw_result);
+  if (!event) {
+    switch (filter.type) {
+      case "contract_call": {
+        const input = buildContractCallInput(filter, tx);
+        return {
+          type: "contract_call",
+          contractId: tx.contract_id ?? "",
+          functionName: tx.function_name ?? "",
+          sender: tx.sender,
+          args: decodedArgs,
+          ...input !== undefined ? { input } : {},
+          result: decodedResult,
+          resultHex: tx.raw_result ?? null,
+          tx: txMeta
+        };
+      }
+      case "contract_deploy":
+        return {
+          contractId: tx.contract_id ?? "",
+          deployer: tx.sender,
+          tx: txMeta
+        };
+      default:
+        return { tx: txMeta };
+    }
+  }
+  const decoded = decodeEventData(event.data);
+  switch (filter.type) {
+    case "ft_transfer":
+      return {
+        sender: decoded.sender,
+        recipient: decoded.recipient,
+        amount: safeBigInt(decoded.amount),
+        assetIdentifier: decoded.asset_identifier,
+        tx: txMeta
+      };
+    case "ft_mint":
+      return {
+        recipient: decoded.recipient,
+        amount: safeBigInt(decoded.amount),
+        assetIdentifier: decoded.asset_identifier,
+        tx: txMeta
+      };
+    case "ft_burn":
+      return {
+        sender: decoded.sender,
+        amount: safeBigInt(decoded.amount),
+        assetIdentifier: decoded.asset_identifier,
+        tx: txMeta
+      };
+    case "nft_transfer":
+      return {
+        sender: decoded.sender,
+        recipient: decoded.recipient,
+        tokenId: decoded.raw_value ?? decoded.value,
+        assetIdentifier: decoded.asset_identifier,
+        tx: txMeta
+      };
+    case "nft_mint":
+      return {
+        recipient: decoded.recipient,
+        tokenId: decoded.raw_value ?? decoded.value,
+        assetIdentifier: decoded.asset_identifier,
+        tx: txMeta
+      };
+    case "nft_burn":
+      return {
+        sender: decoded.sender,
+        tokenId: decoded.raw_value ?? decoded.value,
+        assetIdentifier: decoded.asset_identifier,
+        tx: txMeta
+      };
+    case "stx_transfer":
+      return {
+        sender: decoded.sender,
+        recipient: decoded.recipient,
+        amount: safeBigInt(decoded.amount),
+        memo: decoded.memo ?? "",
+        tx: txMeta
+      };
+    case "stx_mint":
+      return {
+        recipient: decoded.recipient,
+        amount: safeBigInt(decoded.amount),
+        tx: txMeta
+      };
+    case "stx_burn":
+      return {
+        sender: decoded.sender,
+        amount: safeBigInt(decoded.amount),
+        tx: txMeta
+      };
+    case "stx_lock":
+      return {
+        lockedAddress: decoded.locked_address,
+        lockedAmount: safeBigInt(decoded.locked_amount),
+        unlockHeight: safeBigInt(decoded.unlock_height),
+        tx: txMeta
+      };
+    case "print_event": {
+      const rawHex = event.data?.raw_value;
+      const rawValue = typeof rawHex === "string" && rawHex.startsWith("0x") ? decodeClarityValue(rawHex) : decoded.value;
+      const clarityObj = rawValue && typeof rawValue === "object" && !Array.isArray(rawValue) ? rawValue : null;
+      const topic = clarityObj?.topic ? String(clarityObj.topic) : decoded.topic ?? "";
+      const { topic: _, ...rest } = clarityObj ?? {};
+      const data = Object.keys(rest).length > 0 ? camelizeKeys(rest) : rawValue && typeof rawValue !== "object" ? rawValue : {};
+      return {
+        contractId: printContractId(decoded) ?? tx.contract_id ?? "",
+        topic,
+        data: data ?? {},
+        tx: txMeta
+      };
+    }
+    case "contract_call": {
+      const ccRawHex = event.data?.raw_value;
+      const normalized = typeof ccRawHex === "string" && ccRawHex.startsWith("0x") ? { ...decoded, value: decodeClarityValue(ccRawHex) } : decoded;
+      const input = buildContractCallInput(filter, tx);
+      return {
+        ...normalized,
+        type: "contract_call",
+        _eventType: event.type,
+        contractId: tx.contract_id ?? "",
+        functionName: tx.function_name ?? "",
+        sender: tx.sender,
+        args: decodedArgs,
+        ...input !== undefined ? { input } : {},
+        result: decodedResult,
+        resultHex: tx.raw_result ?? null,
+        tx: txMeta
+      };
+    }
+    case "contract_deploy":
+      return {
+        contractId: tx.contract_id ?? "",
+        deployer: tx.sender,
+        tx: txMeta
+      };
+    case "nested_contract_call": {
+      const data = event.data ?? {};
+      const argsHex = Array.isArray(data.function_args) ? data.function_args.filter((a) => typeof a === "string") : [];
+      return {
+        contractId: printContractId(data) ?? "",
+        sender: typeof data.sender === "string" ? data.sender : null,
+        caller: typeof data.caller === "string" ? data.caller : "",
+        functionName: typeof data.function_name === "string" ? data.function_name : "",
+        args: decodeFunctionArgs(argsHex),
+        arguments: argsHex,
+        rawResult: typeof data.raw_result === "string" ? data.raw_result : "",
+        result: decodeRawResult(data.raw_result),
+        tx: txMeta
+      };
+    }
+    case "var_set": {
+      const data = event.data ?? {};
+      const rawValue = typeof data.raw_value === "string" ? data.raw_value : "";
+      return {
+        contractId: printContractId(data) ?? "",
+        varName: typeof data.var_name === "string" ? data.var_name : "",
+        rawValue,
+        value: decodeRawHex(rawValue),
+        tx: txMeta
+      };
+    }
+    case "map_set":
+    case "map_insert": {
+      const data = event.data ?? {};
+      const rawKey = typeof data.raw_key === "string" ? data.raw_key : "";
+      const rawValue = typeof data.raw_value === "string" ? data.raw_value : "";
+      return {
+        contractId: printContractId(data) ?? "",
+        map: typeof data.map_name === "string" ? data.map_name : "",
+        rawKey,
+        key: decodeRawHex(rawKey),
+        rawValue,
+        value: decodeRawHex(rawValue),
+        tx: txMeta
+      };
+    }
+    case "map_delete": {
+      const data = event.data ?? {};
+      const rawKey = typeof data.raw_key === "string" ? data.raw_key : "";
+      return {
+        contractId: printContractId(data) ?? "",
+        map: typeof data.map_name === "string" ? data.map_name : "",
+        rawKey,
+        key: decodeRawHex(rawKey),
+        tx: txMeta
+      };
+    }
+    default:
+      return {
+        ...decoded,
+        _eventType: event.type,
+        tx: txMeta
+      };
+  }
+}
+async function runHandlers(subgraph, matched, ctx, opts) {
+  let processed = 0;
+  let errors = 0;
+  let skipped = 0;
+  let delivered = 0;
+  const threshold = opts?.errorThreshold ?? DEFAULT_ERROR_THRESHOLD;
+  const filterLookup = new Map;
+  if (!Array.isArray(subgraph.sources)) {
+    for (const [name, filter] of Object.entries(subgraph.sources)) {
+      filterLookup.set(name, filter);
+    }
+  }
+  const units = [];
+  for (const { tx, events, sourceName } of matched) {
+    if (events.length === 0) {
+      units.push({ tx, sourceName, event: null });
+    } else {
+      for (const event of events)
+        units.push({ tx, sourceName, event });
+    }
+  }
+  const clockRank = (e) => e?.clock === "vm" ? 1 : 0;
+  units.sort((a, b) => (a.tx.tx_index ?? 0) - (b.tx.tx_index ?? 0) || clockRank(a.event) - clockRank(b.event) || (a.event?.event_index ?? -1) - (b.event?.event_index ?? -1));
+  for (const { tx, event, sourceName } of units) {
+    if (errors >= threshold) {
+      logger2.error("Subgraph error threshold reached, skipping remaining events", {
+        subgraph: subgraph.name,
+        errors,
+        threshold
+      });
+      return {
+        processed,
+        errors,
+        delivered,
+        ...skipped > 0 ? { skipped } : {}
+      };
+    }
+    const filter = filterLookup.get(sourceName);
+    const handler = subgraph.handlers[sourceName] ?? null;
+    if (!handler) {
+      logger2.warn("No handler found for source", {
+        subgraph: subgraph.name,
+        sourceName,
+        txId: tx.tx_id
+      });
+      continue;
+    }
+    ctx.setTx({
+      txId: tx.tx_id,
+      sender: tx.sender,
+      type: tx.type,
+      status: tx.status,
+      contractId: tx.contract_id ?? null,
+      functionName: tx.function_name ?? null
+    });
+    const checkpoint = ctx.opsCheckpoint();
+    try {
+      let payload;
+      if (event === null) {
+        payload = filter ? buildEventPayload(filter, tx, null) : {
+          tx: {
+            txId: tx.tx_id,
+            sender: tx.sender,
+            type: tx.type,
+            status: tx.status,
+            contractId: tx.contract_id,
+            functionName: tx.function_name
+          }
+        };
+      } else if (filter) {
+        payload = buildEventPayload(filter, tx, event);
+      } else {
+        const decoded = decodeEventData(event.data);
+        payload = {
+          ...decoded,
+          _eventId: event.id,
+          _eventType: event.type,
+          _eventIndex: event.event_index,
+          tx: {
+            txId: tx.tx_id,
+            sender: tx.sender,
+            type: tx.type,
+            status: tx.status,
+            contractId: tx.contract_id,
+            functionName: tx.function_name
+          }
+        };
+      }
+      if (event !== null && filter?.type === "print_event" && filter.topic && payload.topic !== filter.topic) {
+        continue;
+      }
+      delivered++;
+      if (event !== null && filter?.type === "print_event" && filter.prints) {
+        const printPayload = payload;
+        const verdict = validatePrintPayload(filter.prints, printPayload.topic ?? "", printPayload.data ?? {});
+        if (!verdict.ok) {
+          skipped++;
+          logger2.warn("Print payload does not match declared prints schema", {
+            subgraph: subgraph.name,
+            sourceName,
+            topic: printPayload.topic,
+            txId: tx.tx_id,
+            reason: verdict.reason
+          });
+          recordPrintViolation({
+            subgraphName: subgraph.name,
+            sourceName,
+            blockHeight: ctx.block.height,
+            txId: tx.tx_id,
+            reason: verdict.reason,
+            samplePayload: {
+              topic: printPayload.topic ?? "",
+              data: printPayload.data ?? {}
+            }
+          });
+          continue;
+        }
+      }
+      await handler(payload, ctx);
+      processed++;
+    } catch (err) {
+      if (abortsBlock(err))
+        throw err;
+      ctx.rollbackTo(checkpoint);
+      errors++;
+      logger2.error("Subgraph handler error", {
+        subgraph: subgraph.name,
+        sourceName,
+        txId: tx.tx_id,
+        ...event !== null ? { eventId: event.id, eventType: event.type } : {},
+        error: getErrorMessage(err)
+      });
+    }
+  }
+  return { processed, errors, delivered, ...skipped > 0 ? { skipped } : {} };
+}
+
+// src/runtime/apply-block.ts
+function matchBlock(def, data, scopes = {}) {
+  return matchSources(def.sources, data.txs, data.events, scopes.trait ?? new Map, scopes.factory ?? new Map, data.vmEvents ?? []);
+}
+async function applyBlock(def, data, ctx, scopes = {}) {
+  const matched = matchBlock(def, data, scopes);
+  if (matched.length === 0) {
+    return { matched: 0, processed: 0, errors: 0, delivered: 0 };
+  }
+  return { matched: matched.length, ...await runHandlers(def, matched, ctx) };
+}
+
+// src/runtime/memory-store.ts
+import { normalizeAbi as normalizeAbi2, toCamelCase as toCamelCase3 } from "@secondlayer/stacks/clarity";
+
+// src/runtime/context.ts
+import { logger as logger4 } from "@secondlayer/shared/logger";
+import { sql as sql2 } from "kysely";
+
+// src/schema/generator.ts
+import { createHash as createHash2 } from "node:crypto";
+
+// src/schema/utils.ts
+import { pgSchemaName } from "@secondlayer/shared/db/queries/subgraphs";
+function quotePgIdent(name) {
+  if (/^[a-z_][a-z0-9_]*$/i.test(name))
+    return name;
+  return `"${name.replace(/"/g, '""')}"`;
+}
+function snakeToCamel(name) {
+  return name.replace(/_([a-z0-9])/g, (_, c) => c.toUpperCase());
+}
+function pascalCase(name) {
+  const camel = snakeToCamel(name);
+  return camel.charAt(0).toUpperCase() + camel.slice(1);
+}
+
+// src/schema/generator.ts
+var TYPE_MAP = {
+  text: "TEXT",
+  uint: "NUMERIC",
+  int: "NUMERIC",
+  principal: "TEXT",
+  boolean: "BOOLEAN",
+  timestamp: "TIMESTAMPTZ",
+  jsonb: "JSONB"
+};
+var MAX_IDENT_BYTES = 63;
+function safeIndexName(name) {
+  if (name.length <= MAX_IDENT_BYTES)
+    return name;
+  const hash = createHash2("sha256").update(name).digest("hex").slice(0, 8);
+  return `${name.slice(0, MAX_IDENT_BYTES - hash.length - 1)}_${hash}`;
+}
+function emitIndexedColumnIndexDDL(schemaName, tableName, colName, opts) {
+  const concurrently = opts?.concurrently ? " CONCURRENTLY" : "";
+  const qualified = `${quotePgIdent(schemaName)}.${quotePgIdent(tableName)}`;
+  const plain = `idx_${schemaName}_${tableName}_${colName}`;
+  const composite = safeIndexName(`idx_${schemaName}_${tableName}_${colName}_id`);
+  const col = quotePgIdent(colName);
+  const id = quotePgIdent("_id");
+  return {
+    create: [
+      `CREATE INDEX${concurrently} IF NOT EXISTS ${quotePgIdent(plain)} ON ${qualified} (${col})`,
+      `CREATE INDEX${concurrently} IF NOT EXISTS ${quotePgIdent(composite)} ON ${qualified} (${col}, ${id})`
+    ],
+    drop: [
+      `DROP INDEX${concurrently} IF EXISTS ${quotePgIdent(schemaName)}.${quotePgIdent(plain)}`,
+      `DROP INDEX${concurrently} IF EXISTS ${quotePgIdent(schemaName)}.${quotePgIdent(composite)}`
+    ]
+  };
+}
+function escapeLiteralDefault(value) {
+  if (value === null || value === undefined)
+    return "NULL";
+  if (typeof value === "number" || typeof value === "bigint")
+    return String(value);
+  if (typeof value === "boolean")
+    return value ? "TRUE" : "FALSE";
+  return `'${String(value).replace(/'/g, "''")}'`;
+}
+function tableNeedsTrgm(tableDef) {
+  return Object.values(tableDef.columns).some((col) => col.search);
+}
+function emitTableDDL(schemaName, tableName, tableDef) {
+  const qualifiedName = `${quotePgIdent(schemaName)}.${quotePgIdent(tableName)}`;
+  const statements = [];
+  const columnDefs = [
+    "_id BIGSERIAL PRIMARY KEY",
+    "_block_height BIGINT NOT NULL",
+    "_tx_id TEXT NOT NULL",
+    "_created_at TIMESTAMPTZ NOT NULL DEFAULT NOW()"
+  ];
+  for (const [colName, col] of Object.entries(tableDef.columns)) {
+    const sqlType = TYPE_MAP[col.type];
+    const nullable = col.nullable ? "" : " NOT NULL";
+    let colDef = `${quotePgIdent(colName)} ${sqlType}${nullable}`;
+    if (col.default !== undefined) {
+      colDef += ` DEFAULT ${escapeLiteralDefault(col.default)}`;
+    }
+    if (col.type === "uint") {
+      colDef += ` CHECK (${quotePgIdent(colName)} >= 0)`;
+    }
+    columnDefs.push(colDef);
+  }
+  statements.push(`CREATE TABLE IF NOT EXISTS ${qualifiedName} (
+  ${columnDefs.join(`,
+  `)}
+)`);
+  statements.push(`CREATE INDEX IF NOT EXISTS ${quotePgIdent(`idx_${schemaName}_${tableName}_block_height`)} ON ${qualifiedName} (_block_height)`);
+  statements.push(`CREATE INDEX IF NOT EXISTS ${quotePgIdent(`idx_${schemaName}_${tableName}_tx_id`)} ON ${qualifiedName} (_tx_id)`);
+  for (const [colName, col] of Object.entries(tableDef.columns)) {
+    if (col.indexed) {
+      statements.push(...emitIndexedColumnIndexDDL(schemaName, tableName, colName).create);
+    }
+  }
+  for (const [colName, col] of Object.entries(tableDef.columns)) {
+    if (col.search) {
+      statements.push(`CREATE INDEX IF NOT EXISTS ${quotePgIdent(`idx_${schemaName}_${tableName}_${colName}_trgm`)} ON ${qualifiedName} USING gin (${quotePgIdent(colName)} gin_trgm_ops)`);
+    }
+  }
+  if (tableDef.indexes) {
+    for (let i = 0;i < tableDef.indexes.length; i++) {
+      const cols = tableDef.indexes[i];
+      const idxName = quotePgIdent(`idx_${schemaName}_${tableName}_composite_${i}`);
+      statements.push(`CREATE INDEX IF NOT EXISTS ${idxName} ON ${qualifiedName} (${cols.map(quotePgIdent).join(", ")})`);
+    }
+  }
+  if (tableDef.uniqueKeys) {
+    for (let i = 0;i < tableDef.uniqueKeys.length; i++) {
+      const cols = tableDef.uniqueKeys[i];
+      const constraintName = quotePgIdent(`uq_${schemaName}_${tableName}_${cols.join("_")}`);
+      statements.push(`ALTER TABLE ${qualifiedName} ADD CONSTRAINT ${constraintName} UNIQUE (${cols.map(quotePgIdent).join(", ")})`);
+    }
+  }
+  return statements;
+}
+function emitJournalDDL(schemaName) {
+  return [
+    `CREATE TABLE IF NOT EXISTS ${schemaName}._journal (
+  _jid BIGSERIAL PRIMARY KEY,
+  block_height BIGINT NOT NULL,
+  table_name TEXT NOT NULL,
+  row_key JSONB NOT NULL,
+  prev_row JSONB,
+  _created_at TIMESTAMPTZ NOT NULL DEFAULT NOW()
+)`,
+    `CREATE INDEX IF NOT EXISTS idx_${schemaName}_journal_height ON ${schemaName}._journal (block_height)`
+  ];
+}
+function emitFactoryDDL(schemaName) {
+  return [
+    `CREATE TABLE IF NOT EXISTS ${schemaName}._factory_addresses (
+  source_name TEXT NOT NULL,
+  address TEXT NOT NULL,
+  block_height BIGINT NOT NULL,
+  _created_at TIMESTAMPTZ NOT NULL DEFAULT NOW(),
+  PRIMARY KEY (source_name, address)
+)`,
+    `CREATE INDEX IF NOT EXISTS idx_${schemaName}_factory_height ON ${schemaName}._factory_addresses (block_height)`
+  ];
+}
+function generateSubgraphSQL(def, schemaNameOverride) {
+  const schemaName = schemaNameOverride ?? pgSchemaName(def.name);
+  const statements = [];
+  const needsTrgm = Object.values(def.schema).some((table) => Object.values(table.columns).some((col) => col.search));
+  if (needsTrgm) {
+    statements.push("CREATE EXTENSION IF NOT EXISTS pg_trgm");
+  }
+  statements.push(`CREATE SCHEMA IF NOT EXISTS ${schemaName}`);
+  for (const [tableName, tableDef] of Object.entries(def.schema)) {
+    statements.push(...emitTableDDL(schemaName, tableName, tableDef));
+  }
+  statements.push(...emitJournalDDL(schemaName));
+  if (Object.values(def.sources ?? {}).some((src) => src.factory !== undefined)) {
+    statements.push(...emitFactoryDDL(schemaName));
+  }
+  const hashInput = JSON.stringify({
+    name: def.name,
+    schema: def.schema,
+    sources: def.sources
+  }, (_key, value) => typeof value === "bigint" ? value.toString() : value);
+  const hash = createHash2("sha256").update(hashInput).digest("hex");
+  return { statements, hash };
+}
+
+// src/runtime/chain-read.ts
+import { getSourceDb } from "@secondlayer/shared/db";
+import { logger as logger3 } from "@secondlayer/shared/logger";
+import { http, createPublicClient } from "@secondlayer/stacks";
+import {
+  ContractResponseError,
+  buildFunctionArgs,
+  isResponseOutput,
+  readContract
+} from "@secondlayer/stacks/actions";
+import {
+  clarityValueToJSUntyped,
+  deserializeCV as deserializeCV4,
+  normalizeAbi,
+  serializeCV,
+  toCamelCase as toCamelCase2
+} from "@secondlayer/stacks/clarity";
+function readContractAt(ctx, contractId, abi, options) {
+  return ctx.client.contract(contractId, abi, options);
+}
+
+class ChainReadError extends Error {
+  name = "ChainReadError";
+}
+function nodeClient(rpcUrl) {
+  return createPublicClient({
+    transport: http(rpcUrl, { retryCount: 0, timeout: 1e4 })
+  });
+}
+
+class ConcurrencyGate {
+  limit;
+  active = 0;
+  queue = [];
+  constructor(limit) {
+    this.limit = limit;
+  }
+  async run(fn) {
+    if (this.active >= this.limit) {
+      await new Promise((resolve) => this.queue.push(resolve));
+    }
+    this.active++;
+    try {
+      return await fn();
+    } finally {
+      this.active--;
+      this.queue.shift()?.();
+    }
+  }
+}
+var DEFAULT_MAX_CONCURRENT_READS = 4;
+function maxConcurrentReads() {
+  const raw = process.env.SUBGRAPH_CHAIN_READ_CONCURRENCY;
+  const parsed = raw ? Number.parseInt(raw, 10) : Number.NaN;
+  return Number.isFinite(parsed) && parsed > 0 ? parsed : DEFAULT_MAX_CONCURRENT_READS;
+}
+var gate = new ConcurrencyGate(maxConcurrentReads());
+function hashArgs(args) {
+  const serialized = args.map((arg) => serializeCV(arg)).join(",");
+  return Bun.hash(serialized).toString(16);
+}
+function findFunction(abi, name) {
+  const fn = abi.functions.find((f) => f.name === name);
+  if (!fn) {
+    throw new ChainReadError(`No function "${name}" in the supplied ABI.`);
+  }
+  if (fn.access !== "read-only") {
+    throw new ChainReadError(`"${name}" is ${fn.access}, not read-only — a handler cannot call it.`);
+  }
+  return fn;
+}
+function createChainReadClient(ctx) {
+  const readValue = async (contractId, abi, functionName, args, options) => {
+    const rpcUrl = ctx.rpcUrl ?? process.env.STACKS_NODE_RPC_URL;
+    if (!rpcUrl) {
+      throw new ChainReadError("ctx.client needs a Stacks node: set STACKS_NODE_RPC_URL on the subgraph processor.");
+    }
+    const constant = options.cache === "contract-constant";
+    if (!constant && !ctx.indexBlockHash) {
+      throw new ChainReadError(`Block ${ctx.blockHeight} has no index_block_hash, so a read cannot be pinned to it. Reading at the node's tip would make this handler non-deterministic (the same reindex would produce different rows). Re-ingest the block, or pass cache: "contract-constant" if the value genuinely cannot change.`);
+    }
+    const fn = findFunction(abi, functionName);
+    const clarityArgs = buildFunctionArgs(fn, args);
+    const db = ctx.db ?? getSourceDb();
+    const argsHash = hashArgs(clarityArgs);
+    const pinnedTo = constant ? null : ctx.indexBlockHash;
+    const cached = await db.selectFrom("chain_read_cache").select("result_hex").where("contract_id", "=", contractId).where("function_name", "=", fn.name).where("args_hash", "=", argsHash).where((eb) => pinnedTo === null ? eb("index_block_hash", "is", null) : eb("index_block_hash", "=", pinnedTo)).executeTakeFirst();
+    const resultHex = cached?.result_hex ?? await gate.run(async () => {
+      if (!ctx.indexBlockHash) {
+        logger3.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 = deserializeCV4(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(toCamelCase2(fn.name), fn.name);
+      }
+      const read = new Proxy({}, {
+        get(_target, prop) {
+          const fnName = camelToKebab.get(prop) ?? prop;
+          return (args = {}) => readValue(contractId, abi, fnName, args, options);
+        }
+      });
+      return { read };
+    }
+  };
+}
+
+// src/runtime/context.ts
+var journalEnsured = new Set;
+function validateColumnName(name) {
+  if (!/^[a-z_][a-z0-9_]*$/i.test(name)) {
+    throw new Error(`Invalid column name: ${name}`);
+  }
+}
+
+class SubgraphContext {
+  block;
+  _tx;
+  db;
+  pgSchemaName;
+  subgraphSchema;
+  ops = [];
+  journal;
+  _client;
+  constructor(db, 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 {
+      logger4.warn("upsert called without matching uniqueKeys constraint, using fallback", {
+        table,
+        keys: keyColumns
+      });
+      this.ops.push({
+        kind: "insert",
+        table,
+        data: {
+          ...key,
+          ...row,
+          ...meta,
+          _upsert_fallback_keys: keyColumns,
+          _upsert_fallback_set: row
+        }
+      });
+    }
+  }
+  delete(table, where) {
+    this.validateTable(table);
+    this.ops.push({ kind: "delete", table, data: where });
+  }
+  increment(table, key, deltas) {
+    this.validateTable(table);
+    const tableDef = this.subgraphSchema[table];
+    const keyColumns = Object.keys(key);
+    const hasUniqueConstraint = tableDef?.uniqueKeys?.some((uk) => uk.length === keyColumns.length && uk.every((c) => keyColumns.includes(c)));
+    if (!hasUniqueConstraint) {
+      throw new Error(`increment("${table}") requires a uniqueKeys constraint on [${keyColumns.join(", ")}]`);
+    }
+    for (const [col, v] of Object.entries(deltas)) {
+      validateColumnName(col);
+      if (keyColumns.includes(col)) {
+        throw new Error(`increment("${table}"): "${col}" is a key column`);
+      }
+      if (typeof v !== "bigint" && typeof v !== "number") {
+        throw new Error(`increment("${table}"): delta for "${col}" must be bigint or number`);
+      }
+    }
+    this.ops.push({
+      kind: "increment",
+      table,
+      data: {
+        ...key,
+        _block_height: this.block.height,
+        _tx_id: this._tx.txId,
+        _upsert_keys: keyColumns
+      },
+      set: { ...deltas }
+    });
+  }
+  opsCheckpoint() {
+    return this.ops.length;
+  }
+  rollbackTo(checkpoint) {
+    if (checkpoint < 0 || checkpoint > this.ops.length)
+      return;
+    this.ops.length = checkpoint;
+  }
+  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 sql2.raw(query).execute(this.db);
+    return rows.map((r) => this.coerceRow(table, r));
+  }
+  async findOne(table, where) {
+    this.validateTable(table);
+    const row = (await this.readRows(table, where, 1))[0] ?? null;
+    return this.overlayOne(table, where, row);
+  }
+  async findMany(table, where) {
+    this.validateTable(table);
+    return this.overlayMany(table, where, await this.readRows(table, where));
+  }
+  overlayOne(table, where, dbRow) {
+    if (this.ops.length === 0)
+      return dbRow;
+    let row = dbRow;
+    for (const op of this.ops) {
+      if (op.table !== table)
+        continue;
+      row = this.applyOpToRow(op, row, where);
+    }
+    return row;
+  }
+  overlayMany(table, where, dbRows) {
+    if (this.ops.length === 0)
+      return [...dbRows];
+    let result = [...dbRows];
+    for (const op of this.ops) {
+      if (op.table !== table)
+        continue;
+      if (op.kind === "update") {
+        for (let i = 0;i < result.length; i++) {
+          if (rowMatches(result[i], op.data))
+            result[i] = { ...result[i], ...op.set ?? {} };
+        }
+      } else if (op.kind === "delete") {
+        result = result.filter((r) => !rowMatches(r, op.data));
+      } else {
+        const upsertKeys = op.data._upsert_keys;
+        const clean = stripControlKeys(op.data);
+        const idx = upsertKeys ? result.findIndex((r) => upsertKeys.every((k) => valEq(r[k], clean[k]))) : -1;
+        if (idx >= 0) {
+          const existing = result[idx];
+          result[idx] = this.applyOpToRow(op, existing, where) ?? existing;
+        } else {
+          const created = this.applyOpToRow(op, null, where);
+          if (created)
+            result.push(created);
+        }
+      }
+    }
+    return result;
+  }
+  applyOpToRow(op, row, where) {
+    const upsertKeys = op.data._upsert_keys;
+    const clean = stripControlKeys(op.data);
+    switch (op.kind) {
+      case "insert": {
+        if (row) {
+          if (upsertKeys?.every((k) => valEq(row[k], clean[k]))) {
+            const merged = { ...row };
+            for (const [k, v] of Object.entries(clean)) {
+              if (!upsertKeys.includes(k) && !k.startsWith("_"))
+                merged[k] = v;
+            }
+            return merged;
+          }
+          return row;
+        }
+        return rowMatches(clean, where) ? { ...clean } : null;
+      }
+      case "increment": {
+        const deltas = op.set ?? {};
+        if (row) {
+          if (upsertKeys.every((k) => valEq(row[k], clean[k]))) {
+            const merged = { ...row };
+            for (const [col, d] of Object.entries(deltas)) {
+              merged[col] = toBigIntOr0(merged[col]) + toBigIntOr0(d);
+            }
+            return merged;
+          }
+          return row;
+        }
+        if (!rowMatches(clean, where))
+          return null;
+        const created = { ...clean };
+        for (const [col, d] of Object.entries(deltas)) {
+          created[col] = toBigIntOr0(d);
+        }
+        return created;
+      }
+      case "update":
+        return row && rowMatches(row, op.data) ? { ...row, ...op.set ?? {} } : row;
+      case "delete":
+        return row && rowMatches(row, op.data) ? null : row;
+    }
+  }
+  coerceRow(table, row) {
+    const tableDef = this.subgraphSchema[table];
+    if (!tableDef)
+      return row;
+    const result = { ...row };
+    for (const [col, def] of Object.entries(tableDef.columns)) {
+      if ((def.type === "uint" || def.type === "int") && typeof result[col] === "string") {
+        result[col] = BigInt(result[col]);
+      }
+    }
+    return result;
+  }
+  get pendingOps() {
+    return this.ops.length;
+  }
+  async flush() {
+    if (this.ops.length === 0)
+      return { count: 0, writes: [] };
+    await this.ensureJournalTable();
+    const opsToFlush = [...this.ops];
+    this.ops.length = 0;
+    const statements = this.buildStatements(opsToFlush);
+    if ("isTransaction" in this.db) {
+      await this.execStatements(this.db, statements);
+    } else {
+      await this.db.transaction().execute(async (tx) => {
+        await this.execStatements(tx, statements);
+      });
+    }
+    const writes = opsToFlush.map((op, rowIndex) => {
+      const blockHeight = op.data._block_height ?? this.block.height;
+      const txId = op.data._tx_id ?? this._tx.txId;
+      const baseRow = op.kind === "update" || op.kind === "increment" ? { ...op.data, ...op.set ?? {} } : { ...op.data };
+      baseRow._upsert_keys = undefined;
+      baseRow._upsert_fallback_keys = undefined;
+      baseRow._upsert_fallback_set = undefined;
+      return {
+        op: op.kind === "increment" ? "update" : op.kind,
+        table: op.table,
+        row: jsonSafe2(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 sql2.raw(stmt).execute(executor);
+        continue;
+      }
+      const updated = await sql2.raw(stmt.update).execute(executor);
+      if (affected(updated) > 0n)
+        continue;
+      const inserted = await sql2.raw(stmt.insert).execute(executor);
+      if (affected(inserted) > 0n)
+        continue;
+      const retried = await sql2.raw(stmt.update).execute(executor);
+      if (affected(retried) === 0n) {
+        throw new Error(`increment could not be applied to ${this.pgSchemaName}.${stmt.table} where ${stmt.keyPred}: row neither updated nor inserted`);
+      }
+    }
+  }
+  prepareInsert(op) {
+    const upsertKeys = op.data._upsert_keys;
+    const data = { ...op.data };
+    delete data._upsert_keys;
+    delete data._upsert_fallback_keys;
+    delete data._upsert_fallback_set;
+    if (!data._block_height)
+      data._block_height = this.block.height;
+    if (!data._tx_id)
+      data._tx_id = this._tx.txId;
+    data._created_at = "NOW()";
+    const cols = Object.keys(data);
+    cols.forEach(validateColumnName);
+    const vals = cols.map((c) => data[c] === "NOW()" ? "NOW()" : escapeLiteral(data[c]));
+    const batchKey = `${op.table}:${[...cols].sort().join(",")}:${upsertKeys ? [...upsertKeys].sort().join(",") : ""}`;
+    return { data, cols, vals, upsertKeys, batchKey };
+  }
+  async ensureJournalTable() {
+    if (!this.journal || journalEnsured.has(this.pgSchemaName))
+      return;
+    const { rows } = await sql2.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 sql2.raw(stmt).execute(this.db);
+    }
+  }
+  columnSqlType(table, col) {
+    const def = this.subgraphSchema[table]?.columns?.[col];
+    return def ? TYPE_MAP[def.type] : undefined;
+  }
+  journalCaptureSQL(table, keyCols, keyLiteralRows) {
+    const cast = (col, expr) => {
+      const t = this.columnSqlType(table, col);
+      return t ? `CAST(${expr} AS ${t})` : expr;
+    };
+    const keyObj = keyCols.map((k) => `'${k}', ${cast(k, `v."${k}"`)}`).join(", ");
+    const joinCond = keyCols.map((k) => `t."${k}" = ${cast(k, `v."${k}"`)}`).join(" AND ");
+    const valuesList = keyLiteralRows.map((r) => `(${r.join(", ")})`).join(", ");
+    return `INSERT INTO "${this.pgSchemaName}"."_journal" ("block_height", "table_name", "row_key", "prev_row") ` + `SELECT ${this.block.height}, '${table}', jsonb_build_object(${keyObj}), to_jsonb(t.*) ` + `FROM (VALUES ${valuesList}) AS v(${keyCols.map((k) => `"${k}"`).join(", ")}) ` + `LEFT JOIN "${this.pgSchemaName}"."${table}" t ON ${joinCond}`;
+  }
+  journalCaptureByWhereSQL(table, clause) {
+    return `INSERT INTO "${this.pgSchemaName}"."_journal" ("block_height", "table_name", "row_key", "prev_row") ` + `SELECT ${this.block.height}, '${table}', jsonb_build_object('_id', t."_id"), to_jsonb(t.*) ` + `FROM "${this.pgSchemaName}"."${table}" t WHERE ${clause}`;
+  }
+  buildStatements(ops) {
+    const statements = [];
+    let currentBatch = null;
+    let currentBatchKey = "";
+    let incBatch = null;
+    let incBatchKey = "";
+    const flushIncrementBatch = () => {
+      if (!incBatch)
+        return;
+      const batch = incBatch;
+      const qualifiedTable = `"${this.pgSchemaName}"."${batch.table}"`;
+      const cols = [
+        ...batch.keyCols,
+        ...batch.deltaCols,
+        "_block_height",
+        "_tx_id",
+        "_created_at"
+      ];
+      if (this.journal) {
+        statements.push(this.journalCaptureSQL(batch.table, batch.keyCols, Array.from(batch.rows.values()).map((r) => batch.keyCols.map((k) => escapeLiteral(r.keys[k])))));
+      }
+      for (const r of batch.rows.values()) {
+        const keyPred = batch.keyCols.map((k) => `"${k}" = ${escapeLiteral(r.keys[k])}`).join(" AND ");
+        const updSet = batch.deltaCols.map((c) => `"${c}" = COALESCE("${c}", 0) + (${String(r.deltas[c] ?? 0n)})`).join(", ");
+        const insertVals = [
+          ...batch.keyCols.map((k) => escapeLiteral(r.keys[k])),
+          ...batch.deltaCols.map((c) => String(r.deltas[c] ?? 0n)),
+          escapeLiteral(r.meta.blockHeight),
+          escapeLiteral(r.meta.txId),
+          "NOW()"
+        ];
+        statements.push({
+          kind: "increment",
+          table: batch.table,
+          keyPred,
+          update: `UPDATE ${qualifiedTable} SET ${updSet} WHERE ${keyPred}`,
+          insert: `INSERT INTO ${qualifiedTable} (${cols.map((c) => `"${c}"`).join(", ")}) ` + `SELECT ${insertVals.join(", ")} ` + `WHERE NOT EXISTS (SELECT 1 FROM ${qualifiedTable} WHERE ${keyPred})`
+        });
+      }
+      incBatch = null;
+      incBatchKey = "";
+    };
+    const flushInsertBatch = () => {
+      if (!currentBatch)
+        return;
+      const batch = currentBatch;
+      const qualifiedTable = `"${this.pgSchemaName}"."${batch.table}"`;
+      const colList = batch.cols.map((c) => `"${c}"`).join(", ");
+      let rows = batch.rows;
+      if (batch.upsertKeys && batch.upsertKeys.length > 0) {
+        const uKeys = batch.upsertKeys;
+        const keyIndices = uKeys.map((k) => batch.cols.indexOf(k));
+        const seen = new Map;
+        for (let i = 0;i < rows.length; i++) {
+          const key = keyIndices.map((ki) => rows[i][ki]).join("\x00");
+          seen.set(key, i);
+        }
+        if (seen.size < rows.length) {
+          rows = Array.from(seen.values()).map((i) => rows[i]);
+        }
+      }
+      const valuesList = rows.map((r) => `(${r.join(", ")})`).join(", ");
+      let stmt = `INSERT INTO ${qualifiedTable} (${colList}) VALUES ${valuesList}`;
+      if (this.journal && batch.upsertKeys && batch.upsertKeys.length > 0) {
+        const uKeys = batch.upsertKeys;
+        const keyIndices = uKeys.map((k) => batch.cols.indexOf(k));
+        statements.push(this.journalCaptureSQL(batch.table, uKeys, rows.map((r) => keyIndices.map((ki) => r[ki]))));
+      }
+      if (batch.upsertKeys && batch.upsertKeys.length > 0) {
+        const batchKeys = batch.upsertKeys;
+        const updateCols = batch.cols.filter((c) => !batchKeys.includes(c) && !c.startsWith("_"));
+        if (updateCols.length > 0) {
+          const setClauses = updateCols.map((c) => `"${c}" = EXCLUDED."${c}"`);
+          stmt += ` ON CONFLICT (${batchKeys.map((k) => `"${k}"`).join(", ")}) DO UPDATE SET ${setClauses.join(", ")}`;
+        } else {
+          stmt += ` ON CONFLICT (${batchKeys.map((k) => `"${k}"`).join(", ")}) DO NOTHING`;
+        }
+      }
+      statements.push(stmt);
+      currentBatch = null;
+      currentBatchKey = "";
+    };
+    for (const op of ops) {
+      const qualifiedTable = `"${this.pgSchemaName}"."${op.table}"`;
+      if (op.kind === "insert") {
+        flushIncrementBatch();
+        const { cols, vals, upsertKeys, batchKey } = this.prepareInsert(op);
+        if (batchKey === currentBatchKey && currentBatch) {
+          currentBatch.rows.push(vals);
+        } else {
+          flushInsertBatch();
+          currentBatch = { table: op.table, cols, rows: [vals], upsertKeys };
+          currentBatchKey = batchKey;
+        }
+      } else if (op.kind === "increment") {
+        flushInsertBatch();
+        const keyCols = [...op.data._upsert_keys].sort();
+        const deltaCols = Object.keys(op.set ?? {}).sort();
+        const batchKey = `inc:${op.table}:${keyCols.join(",")}:${deltaCols.join(",")}`;
+        if (batchKey !== incBatchKey || !incBatch) {
+          flushIncrementBatch();
+          incBatch = { table: op.table, keyCols, deltaCols, rows: new Map };
+          incBatchKey = batchKey;
+        }
+        const clean = stripControlKeys(op.data);
+        const keySig = keyCols.map((k) => escapeLiteral(clean[k])).join("\x00");
+        const existing = incBatch.rows.get(keySig);
+        if (existing) {
+          for (const c of deltaCols) {
+            existing.deltas[c] = (existing.deltas[c] ?? 0n) + toBigIntOr0(op.set?.[c]);
+          }
+        } else {
+          const deltas = {};
+          for (const c of deltaCols)
+            deltas[c] = toBigIntOr0(op.set?.[c]);
+          incBatch.rows.set(keySig, {
+            keys: clean,
+            deltas,
+            meta: {
+              blockHeight: op.data._block_height ?? this.block.height,
+              txId: op.data._tx_id ?? this._tx.txId
+            }
+          });
+        }
+      } else {
+        flushInsertBatch();
+        flushIncrementBatch();
+        if (op.kind === "update") {
+          const setEntries = Object.entries(op.set ?? {});
+          for (const [k] of setEntries)
+            validateColumnName(k);
+          const setClauses = setEntries.map(([k, v]) => `"${k}" = ${escapeLiteral(v)}`);
+          const { clause } = buildWhereClause(op.data);
+          if (this.journal) {
+            statements.push(this.journalCaptureByWhereSQL(op.table, clause));
+          }
+          statements.push(`UPDATE ${qualifiedTable} SET ${setClauses.join(", ")} WHERE ${clause}`);
+        } else if (op.kind === "delete") {
+          const { clause } = buildWhereClause(op.data);
+          if (this.journal) {
+            statements.push(this.journalCaptureByWhereSQL(op.table, clause));
+          }
+          statements.push(`DELETE FROM ${qualifiedTable} WHERE ${clause}`);
+        }
+      }
+    }
+    flushInsertBatch();
+    flushIncrementBatch();
+    return statements;
+  }
+  validateTable(table) {
+    if (!this.subgraphSchema[table]) {
+      throw new Error(`Table "${table}" not found in subgraph schema. Available: [${Object.keys(this.subgraphSchema).join(", ")}]`);
+    }
+  }
+}
+function stripControlKeys(data) {
+  const {
+    _upsert_keys: _a,
+    _upsert_fallback_keys: _b,
+    _upsert_fallback_set: _c,
+    ...clean
+  } = data;
+  return clean;
+}
+function valEq(a, b) {
+  if (a === b)
+    return true;
+  if (a == null || b == null)
+    return false;
+  return String(a) === String(b);
+}
+function rowMatches(row, where) {
+  return Object.entries(where).every(([k, v]) => valEq(row[k], v));
+}
+function toBigIntOr0(v) {
+  if (typeof v === "bigint")
+    return v;
+  if (v == null)
+    return 0n;
+  try {
+    return BigInt(String(v));
+  } catch {
+    return 0n;
+  }
+}
+function jsonSafe2(row) {
+  const out = {};
+  for (const [k, v] of Object.entries(row)) {
+    out[k] = typeof v === "bigint" ? v.toString() : v;
+  }
+  return out;
+}
+function escapeLiteral(value) {
+  if (value === null || value === undefined)
+    return "NULL";
+  if (typeof value === "number" || typeof value === "bigint")
+    return String(value);
+  if (typeof value === "boolean")
+    return value ? "TRUE" : "FALSE";
+  if (typeof value === "object")
+    return `'${JSON.stringify(value, (_k, v) => typeof v === "bigint" ? v.toString() : v).replace(/'/g, "''")}'::jsonb`;
+  return `'${String(value).replace(/'/g, "''")}'`;
+}
+function buildWhereClause(where) {
+  const entries = Object.entries(where);
+  if (entries.length === 0)
+    return { clause: "TRUE", values: [] };
+  for (const [k] of entries)
+    validateColumnName(k);
+  const parts = entries.map(([k, v]) => `"${k}" = ${escapeLiteral(v)}`);
+  return { clause: parts.join(" AND "), values: [] };
+}
+
+// src/runtime/memory-store.ts
+class MemoryStore {
+  tables = new Map;
+}
+
+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);
+  }
+  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(toCamelCase3(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
+      });
+    }
+    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/batch-loader.ts
+import { sql as sql3 } from "kysely";
+function stateWriteBlocks(writesByHeight, txsByHeight) {
+  const out = new Map;
+  for (const [height, writes] of writesByHeight) {
+    const txByIndex = new Map;
+    for (const tx of txsByHeight.get(height) ?? []) {
+      if (tx.tx_index !== undefined)
+        txByIndex.set(tx.tx_index, tx);
+    }
+    out.set(height, stateWriteEvents(writes, txByIndex));
+  }
+  return out;
+}
+function vmEventId(txId, vmEventIndex) {
+  return `${txId}#vm:${vmEventIndex}`;
+}
+async function loadBlockRange(db, fromHeight, toHeight, opts = {}) {
+  const feed = opts.stateWrites;
+  const [blocks, txs, events, vmRows, writeRows] = await Promise.all([
+    db.selectFrom("blocks").selectAll().where("height", ">=", fromHeight).where("height", "<=", toHeight).where("canonical", "=", true).execute(),
+    db.selectFrom("transactions").selectAll().where("block_height", ">=", fromHeight).where("block_height", "<=", toHeight).execute(),
+    db.selectFrom("events").selectAll().where("block_height", ">=", fromHeight).where("block_height", "<=", toHeight).execute(),
+    feed ? Promise.resolve([]) : db.selectFrom("vm_events").selectAll().where("block_height", ">=", fromHeight).where("block_height", "<=", toHeight).orderBy("ordinal", "asc").execute(),
+    feed ? loadStateWrites(db, fromHeight, toHeight, feed) : Promise.resolve([])
+  ]);
+  const txsByHeight = new Map;
+  for (const tx of txs) {
+    const h = Number(tx.block_height);
+    const list = txsByHeight.get(h) ?? [];
+    list.push(tx);
+    txsByHeight.set(h, list);
+  }
+  const eventsByHeight = new Map;
+  for (const evt of events) {
+    const h = Number(evt.block_height);
+    const list = eventsByHeight.get(h) ?? [];
+    list.push(evt);
+    eventsByHeight.set(h, list);
+  }
+  const vmByHeight = new Map;
+  for (const row of vmRows) {
+    const h = Number(row.block_height);
+    const list = vmByHeight.get(h) ?? [];
+    list.push({
+      id: vmEventId(row.tx_id, Number(row.ordinal)),
+      tx_id: row.tx_id,
+      block_height: h,
+      event_index: Number(row.ordinal),
+      type: row.type,
+      data: row.data,
+      created_at: row.created_at,
+      clock: "vm"
+    });
+    vmByHeight.set(h, list);
+  }
+  const writesByHeight = new Map;
+  for (const row of writeRows) {
+    const h = Number(row.block_height);
+    const list = writesByHeight.get(h) ?? [];
+    list.push({
+      ordinal: Number(row.ordinal),
+      tx_index: row.tx_index === null ? null : Number(row.tx_index),
+      key: row.key,
+      value_hex: row.value_hex
+    });
+    writesByHeight.set(h, list);
+  }
+  const named = stateWriteBlocks(writesByHeight, txsByHeight);
+  const result = new Map;
+  for (const block of blocks) {
+    const h = Number(block.height);
+    const fed = named.get(h);
+    result.set(h, {
+      block,
+      txs: feed ? fed?.txs ?? [] : txsByHeight.get(h) ?? [],
+      events: eventsByHeight.get(h) ?? [],
+      vmEvents: feed ? fed?.vmEvents ?? [] : vmByHeight.get(h) ?? []
+    });
+  }
+  return result;
+}
+async function loadStateWrites(db, fromHeight, toHeight, feed) {
+  const scope = feed.contracts ? sql3`AND (${sql3.join(feed.contracts.map((c) => sql3`starts_with(key, ${`vm::${c}::`})`), sql3` OR `)})` : sql3``;
+  const { rows } = await sql3`
+		SELECT block_height, ordinal, tx_index, key, value_hex
+		FROM state_writes
+		WHERE block_height >= ${fromHeight} AND block_height <= ${toHeight} ${scope}
+		ORDER BY block_height, ordinal
+	`.execute(db);
+  return rows;
+}
+
+// src/runtime/state-writes.ts
+var DATA_MAP = "0";
+var VARIABLE = "1";
+var HEX = /^(?:[0-9a-f]{2})+$/;
+function parseStateWriteKey(key) {
+  if (!key.startsWith("vm::"))
+    return null;
+  const parts = key.slice(4).split("::");
+  const [contractId, store] = parts;
+  if (!contractId?.includes("."))
+    return null;
+  if (store === DATA_MAP && parts.length === 4) {
+    const [, , map, rawKey] = parts;
+    if (!map || !rawKey || !HEX.test(rawKey))
+      return null;
+    return { contractId, kind: "map", map, rawKey };
+  }
+  if (store === VARIABLE && parts.length === 3 && parts[2]) {
+    return { contractId, kind: "var", varName: parts[2] };
+  }
+  return null;
+}
+var utf8 = new TextDecoder("utf-8", { fatal: true });
+function storedValue(w) {
+  const h = w.value_hex.startsWith("0x") ? w.value_hex.slice(2) : w.value_hex;
+  const bytes = new Uint8Array(h.length / 2);
+  for (let i = 0;i < bytes.length; i++) {
+    bytes[i] = Number.parseInt(h.slice(i * 2, i * 2 + 2), 16);
+  }
+  let value;
+  try {
+    value = utf8.decode(bytes);
+  } catch {
+    throw new Error(`state write ${w.ordinal} value is not UTF-8 hex`);
+  }
+  value = value.toLowerCase();
+  if (!HEX.test(value)) {
+    throw new Error(`state write ${w.ordinal} value is not a Clarity value`);
+  }
+  return value;
+}
+function writeEvent(w) {
+  const key = parseStateWriteKey(w.key);
+  if (!key)
+    return null;
+  const value = storedValue(w);
+  if (key.kind === "var") {
+    return {
+      type: "var_set",
+      data: {
+        contract_identifier: key.contractId,
+        var_name: key.varName,
+        raw_value: `0x${value}`
+      }
+    };
+  }
+  const base = {
+    contract_identifier: key.contractId,
+    map_name: key.map,
+    raw_key: `0x${key.rawKey}`
+  };
+  if (value === "09")
+    return { type: "map_delete", data: base };
+  if (value.startsWith("0a")) {
+    return {
+      type: "map_set",
+      data: { ...base, raw_value: `0x${value.slice(2)}` }
+    };
+  }
+  throw new Error(`state write ${w.ordinal} map value is neither (some v) nor none`);
+}
+function stateWriteEvents(writes, txByIndex) {
+  const txs = new Map;
+  const vmEvents = [];
+  for (const w of [...writes].sort((a, b) => a.ordinal - b.ordinal)) {
+    const event = writeEvent(w);
+    if (!event)
+      continue;
+    let tx = txs.get(w.tx_index);
+    if (!tx) {
+      if (w.tx_index === null) {
+        tx = { tx_id: "", type: "block", sender: "", status: "success" };
+      } else {
+        const real = txByIndex.get(w.tx_index);
+        if (!real) {
+          throw new Error(`state write ${w.ordinal} names tx_index ${w.tx_index} the block does not have`);
+        }
+        tx = real;
+      }
+      tx = { ...tx, tx_index: 0 };
+      txs.set(w.tx_index, tx);
+    }
+    vmEvents.push({
+      id: vmEventId(tx.tx_id || "block", w.ordinal),
+      tx_id: tx.tx_id,
+      type: event.type,
+      event_index: w.ordinal,
+      data: event.data,
+      clock: "vm"
+    });
+  }
+  return { txs: [...txs.values()], vmEvents };
+}
+
+// src/verify/replay.ts
+var REPLAY_WINDOW = 512;
+var STEP_OF = {
+  ancestry: "blocks",
+  block: "blocks",
+  bitcoin: "blocks",
+  burn: "blocks",
+  "signer-set": "blocks",
+  signatures: "blocks",
+  witness: "blocks",
+  txs: "txs",
+  names: "inputs"
+};
+var EMPTY_TX = { txId: "", sender: "", type: "", status: "" };
+function replayContracts(def) {
+  const out = new Set;
+  for (const [name, source] of Object.entries(def.sources)) {
+    const f = source;
+    const ids = Array.isArray(f.contractId) ? f.contractId : f.contractId ? [f.contractId] : [];
+    if (f.factory || ids.length === 0 || ids.some((id) => id.includes("*")))
+      return {
+        error: `source "${name}": wildcard contract ids need a full-block name check per contract`
+      };
+    for (const id of ids)
+      out.add(id);
+  }
+  return [...out];
+}
+var sha2562 = (s) => createHash3("sha256").update(s).digest("hex");
+function checkPin(served, def) {
+  if (!served.pin || !served.pinPreimage)
+    return { status: "unchecked", notes: [] };
+  const failed = (message) => ({
+    status: "failed",
+    failure: { step: "pin", message },
+    notes: []
+  });
+  if (sha2562(served.pinPreimage) !== served.pin)
+    return failed(`pin ${served.pin} is not the sha256 of its preimage`);
+  let fields;
+  try {
+    fields = JSON.parse(served.pinPreimage);
+  } catch {
+    return failed("pin preimage is not JSON");
+  }
+  if (fields.handlerHash !== sha2562(served.handlerCode))
+    return failed("the served handler code is not the bundle the pin names");
+  const schemaHash = generateSubgraphSQL(def).hash;
+  if (fields.schemaHash !== schemaHash)
+    return failed(`the pin names schema ${fields.schemaHash}, the served bundle defines ${schemaHash}`);
+  if (fields.startBlock !== (def.startBlock ?? null))
+    return failed(`the pin names startBlock ${fields.startBlock}, the served bundle ${def.startBlock ?? null}`);
+  const notes = [];
+  if (fields.runtime !== SUBGRAPHS_RUNTIME)
+    notes.push(`deployed on ${fields.runtime}, replayed on ${SUBGRAPHS_RUNTIME}`);
+  if (fields.network !== "mainnet")
+    notes.push(`pinned to network ${fields.network}`);
+  return { status: "ok", notes };
+}
+function decodeTxs(v) {
+  return (v.transactions ?? []).map((t, i) => {
+    const d = decodeRawTx(hex(t.raw), t.txid);
+    return {
+      tx_id: `0x${t.txid}`,
+      tx_index: i,
+      type: d?.txType ?? "unknown",
+      sender: d?.sender ?? "unknown",
+      status: "success",
+      contract_id: d?.contractId ?? null,
+      function_name: d?.functionName ?? null,
+      function_args: d?.functionArgs ?? null,
+      raw_result: null
+    };
+  });
+}
+async function replayBlocks(deps, opts) {
+  const out = {
+    ok: false,
+    from: opts.from,
+    to: opts.to,
+    blocks: 0,
+    txs: 0,
+    writes: 0,
+    events: 0,
+    handlerErrors: 0,
+    marfProofs: 0,
+    tables: new Map,
+    notes: [],
+    failures: []
+  };
+  const done = () => {
+    out.ok = out.failures.length === 0 && !out.inconclusive;
+    return out;
+  };
+  let def;
+  try {
+    def = await loadDeterministicDefinition(opts.handlerCode);
+  } catch (err) {
+    out.failures.push({
+      step: "handlers",
+      message: `the bundle does not load in the deterministic realm: ${err.message}`
+    });
+    return done();
+  }
+  const level = deriveVerification(def);
+  if (level.level !== "state") {
+    out.failures.push({
+      step: "handlers",
+      message: `level ${level.level}, not state: ${level.reasons.join("; ")}`
+    });
+    return done();
+  }
+  const contracts = replayContracts(def);
+  if (!Array.isArray(contracts)) {
+    out.failures.push({ step: "inputs", message: contracts.error });
+    return done();
+  }
+  const ours = (key) => contracts.some((c) => key.startsWith(`vm::${c}::`));
+  const startBlock = opts.startBlock ?? def.startBlock ?? 0;
+  const midHistory = opts.from > startBlock;
+  const store = new MemoryStore;
+  const burnHints = new Map;
+  let notedBurn = false;
+  for (let a = opts.from;a <= opts.to; a += REPLAY_WINDOW) {
+    const b = Math.min(a + REPLAY_WINDOW - 1, opts.to);
+    const proven = new Map;
+    for (let h = b;h >= a; h--) {
+      const v = await deps.verify(h);
+      const first = v.failures[0];
+      if (first) {
+        out.failures.push({
+          step: STEP_OF[first.step] ?? "blocks",
+          message: `block ${h}: ${first.message}`,
+          height: h,
+          ...first.code === "unavailable" ? { unavailable: true } : {}
+        });
+        return done();
+      }
+      if (v.ancestry?.via === "marf")
+        out.marfProofs++;
+      if (!v.blockHash || !v.blockId) {
+        out.failures.push({
+          step: "blocks",
+          message: `block ${h}: epoch 2.x; replay needs Nakamoto blocks`,
+          height: h,
+          unavailable: true
+        });
+        return done();
+      }
+      if (!v.transactions) {
+        out.failures.push({
+          step: "txs",
+          message: `block ${h}: the source served no transactions`,
+          height: h,
+          unavailable: true
+        });
+        return done();
+      }
+      if (!v.diff?.named || !v.writes) {
+        out.failures.push({
+          step: "inputs",
+          message: `block ${h}: the source serves no state_writes for it (its node does not deliver them yet), so its writes cannot be named and the subgraph cannot be verified here`,
+          height: h,
+          unavailable: true
+        });
+        return done();
+      }
+      let burnHeight = v.burnHeight;
+      if (burnHeight === undefined) {
+        const ch = v.consensusHash;
+        burnHeight = burnHints.get(ch);
+        if (burnHeight === undefined) {
+          burnHeight = await deps.burnHeightHint(ch);
+          burnHints.set(ch, burnHeight);
+        }
+        if (!notedBurn) {
+          out.notes.push(`burn height unproven below Bitcoin ${opts.bitcoinCheckpoint ?? "checkpoint"}: ctx.block.burnBlockHeight is the source's claim`);
+          notedBurn = true;
+        }
+      }
+      proven.set(h, {
+        meta: {
+          height: h,
+          hash: `0x${v.blockHash}`,
+          timestamp: v.timestamp ?? 0,
+          burnBlockHeight: burnHeight,
+          indexBlockHash: `0x${v.blockId}`
+        },
+        txs: decodeTxs(v),
+        writes: v.writes.filter((w) => ours(w.key))
+      });
+    }
+    for (let h = a;h <= b; h++) {
+      const block = proven.get(h);
+      const byIndex = new Map(block.txs.map((t) => [t.tx_index, t]));
+      let fed;
+      try {
+        fed = stateWriteEvents(block.writes, byIndex);
+      } catch (err) {
+        out.failures.push({
+          step: "inputs",
+          message: `block ${h}: ${err.message}`,
+          height: h
+        });
+        return done();
+      }
+      const ctx = new MemorySubgraphContext(store, def.schema, block.meta, EMPTY_TX);
+      try {
+        const r = await applyBlock(def, { txs: fed.txs, events: [], vmEvents: fed.vmEvents }, ctx);
+        out.events += r.delivered;
+        out.handlerErrors += r.errors;
+      } catch (err) {
+        if (!abortsBlock(err))
+          throw err;
+        out.failures.push({
+          step: "handlers",
+          message: `block ${h} ${err.name}: ${err.message}`,
+          height: h
+        });
+        return done();
+      }
+      await ctx.commitOps();
+      if (midHistory && ctx.readDependent && !out.inconclusive) {
+        out.inconclusive = `block ${h}: ${ctx.readDependent} depends on rows written before ${opts.from}; replay from startBlock ${startBlock}`;
+      }
+      out.blocks++;
+      out.txs += block.txs.length;
+      out.writes += block.writes.length;
+      opts.onProgress?.(h);
+    }
+  }
+  out.tables = store.tables;
+  return done();
+}
+function cacheWitnesses(source) {
+  const recent = new Map;
+  const out = {
+    getBlock: (ref) => source.getBlock(ref),
+    getMarfProof: (path, tip) => source.getMarfProof(path, tip),
+    getBurnPreimage: (ch) => source.getBurnPreimage(ch),
+    getBitcoinHeaders: (from, count) => source.getBitcoinHeaders(from, count),
+    getWitness: (id) => {
+      let w = recent.get(id);
+      if (!w) {
+        w = source.getWitness(id);
+        w.catch(() => recent.delete(id));
+        recent.set(id, w);
+        while (recent.size > 2)
+          recent.delete(recent.keys().next().value);
+      }
+      return w;
+    }
+  };
+  const { getEpoch2Header, getStateWrites } = source;
+  if (getEpoch2Header)
+    out.getEpoch2Header = (id) => getEpoch2Header.call(source, id);
+  if (getStateWrites)
+    out.getStateWrites = (height) => getStateWrites.call(source, height);
+  return out;
+}
+async function replaySubgraph(opts) {
+  const checkpoint = opts.checkpoint ?? MAINNET_CHECKPOINT;
+  const source = cacheWitnesses(opts.source);
+  const verifier = new BlockVerifier({ source, checkpoint });
+  return replayBlocks({
+    verify: (h) => verifier.verify(h),
+    burnHeightHint: async (ch) => (await source.getBurnPreimage(ch)).burnHeight
+  }, { ...opts, bitcoinCheckpoint: checkpoint.bitcoin.height });
+}
+// src/verify/compare.ts
+import { createHash as createHash4 } from "node:crypto";
+function canonicalJson(value) {
+  if (typeof value === "bigint")
+    return value.toString();
+  if (Array.isArray(value))
+    return value.map(canonicalJson);
+  if (value && typeof value === "object" && !(value instanceof Date)) {
+    const out = {};
+    for (const k of Object.keys(value).sort()) {
+      out[k] = canonicalJson(value[k]);
+    }
+    return out;
+  }
+  return value ?? null;
+}
+function canonicalValue(type, value) {
+  if (value === undefined || value === null)
+    return null;
+  switch (type) {
+    case "uint":
+    case "int":
+      return typeof value === "string" ? BigInt(value).toString() : String(value);
+    case "boolean":
+      return value === true || value === "true" || value === "t" ? "true" : "false";
+    case "timestamp": {
+      const ms = value instanceof Date ? value.getTime() : typeof value === "number" ? value : Date.parse(String(value));
+      return String(ms);
+    }
+    case "jsonb":
+      return JSON.stringify(canonicalJson(typeof value === "string" ? JSON.parse(value) : value));
+    default:
+      return value instanceof Uint8Array ? Buffer.from(value).toString("hex") : String(value);
+  }
+}
+function canonicalRow(def, row, columns = Object.keys(def.columns).sort()) {
+  const out = {};
+  for (const c of columns)
+    out[c] = canonicalValue(def.columns[c]?.type, row[c]);
+  out._block_height = canonicalValue("uint", row._block_height);
+  return out;
+}
+var line = (r) => JSON.stringify(r);
+function digest(lines) {
+  return createHash4("sha256").update([...lines].sort().join(`
+`)).digest("hex");
+}
+var heightOf = (row) => Number(row._block_height);
+function firstDifference(a, b) {
+  return Object.keys(a).find((k) => a[k] !== b[k]);
+}
+function compareRows(schema, replayed, served) {
+  const { from, to } = replayed;
+  const inWindow = (row) => heightOf(row) >= from && heightOf(row) <= to;
+  const failures = [];
+  const tables = [];
+  const fail = (table, message, key) => failures.push({
+    step: "rows",
+    table,
+    message: `${table} ${message}`,
+    ...key ? { key } : {}
+  });
+  for (const [table, def] of Object.entries(schema)) {
+    const mine = (replayed.tables.get(table) ?? []).filter(inWindow);
+    const theirs = served.get(table) ?? [];
+    const theirsInWindow = theirs.filter(inWindow);
+    const mineLines = mine.map((r) => line(canonicalRow(def, r)));
+    const theirLines = theirsInWindow.map((r) => line(canonicalRow(def, r)));
+    const summary = {
+      table,
+      equal: 0,
+      superseded: 0,
+      digest: digest(mineLines),
+      servedDigest: digest(theirLines)
+    };
+    tables.push(summary);
+    const keyCols = def.uniqueKeys?.[0];
+    if (!keyCols?.length) {
+      const counts = new Map;
+      for (const l of mineLines)
+        counts.set(l, (counts.get(l) ?? 0) + 1);
+      for (const l of theirLines)
+        counts.set(l, (counts.get(l) ?? 0) - 1);
+      const diff = [...counts].find(([, n]) => n !== 0);
+      if (diff) {
+        const [l, n] = diff;
+        const at = JSON.parse(l);
+        fail(table, `row at block ${at._block_height}: ${n > 0 ? "replayed but not served" : "served but no proven input produces it"}`);
+      } else
+        summary.equal = mine.length;
+      continue;
+    }
+    const keyOf = (row) => JSON.stringify(keyCols.map((c) => canonicalValue(def.columns[c]?.type, row[c])));
+    const keyRow = (row) => Object.fromEntries(keyCols.map((c) => [c, row[c]]));
+    const servedByKey = new Map(theirs.map((r) => [keyOf(r), r]));
+    const replayedKeys = new Set;
+    const columns = Object.keys(def.columns).sort();
+    for (const row of mine) {
+      const key = keyOf(row);
+      replayedKeys.add(key);
+      const s = servedByKey.get(key);
+      if (!s) {
+        fail(table, `${key}: missing (dropped, or deleted after --to)`, keyRow(row));
+        continue;
+      }
+      if (heightOf(s) > to) {
+        summary.superseded++;
+        continue;
+      }
+      const a = canonicalRow(def, s, columns);
+      const b = canonicalRow(def, row, columns);
+      if (heightOf(s) < from) {
+        a._block_height = b._block_height;
+      }
+      const col = firstDifference(a, b);
+      if (col === undefined)
+        summary.equal++;
+      else
+        fail(table, `${key}: ${col} served ${String(a[col])}, replayed ${String(b[col])}`, keyRow(row));
+    }
+    for (const s of theirsInWindow) {
+      if (!replayedKeys.has(keyOf(s)))
+        fail(table, `${keyOf(s)}: extra: no proven input produces it`, keyRow(s));
+    }
+  }
+  return { failures, tables };
+}
+export {
+  REPLAY_WINDOW,
+  checkPin,
+  compareRows,
+  loadDeterministicDefinition,
+  replayBlocks,
+  replayContracts,
+  replaySubgraph
+};
+
+//# debugId=2078A9B6D93D428264756E2164756E21
+//# sourceMappingURL=index.js.map