@secondlayer/sdk 10.4.3 → 10.6.0

package/dist/index.js

@@ -1,3 +1,10 @@
+// src/archive/client.ts
+import { createHash } from "node:crypto";
+import {
+  checkSignature,
+  loadReference
+} from "@secondlayer/shared/archive/reference";
+
 // src/errors.ts
 var DOCS_BASE = "https://www.secondlayer.tools";
 
@@ -156,6 +163,30 @@ function parseRetryAfter(value) {
 }
 
 // src/base.ts
+class MemoryEtagCache {
+  limit;
+  entries = new Map;
+  constructor(limit = 64) {
+    this.limit = limit;
+  }
+  get(key) {
+    const entry = this.entries.get(key);
+    if (entry) {
+      this.entries.delete(key);
+      this.entries.set(key, entry);
+    }
+    return entry;
+  }
+  set(key, entry) {
+    this.entries.delete(key);
+    this.entries.set(key, entry);
+    if (this.entries.size > this.limit) {
+      const oldest = this.entries.keys().next().value;
+      if (oldest !== undefined)
+        this.entries.delete(oldest);
+    }
+  }
+}
 var DEFAULT_REQUEST_TIMEOUT_MS = 30000;
 function abortError() {
   return new DOMException("This operation was aborted", "AbortError");
@@ -266,12 +297,14 @@ class BaseClient {
   origin;
   fetchImpl;
   requestTimeoutMs;
+  etagCache;
   constructor(options = {}) {
     this.baseUrl = resolveBaseUrl(options.baseUrl);
     this.apiKey = resolveApiKey(options.apiKey);
     this.origin = options.origin ?? "cli";
     this.requestTimeoutMs = options.requestTimeoutMs ?? DEFAULT_REQUEST_TIMEOUT_MS;
     this.fetchImpl = options.fetchImpl ?? ((...args) => fetch(...args));
+    this.etagCache = options.etagCache === false ? null : options.etagCache ?? new MemoryEtagCache;
   }
   static authHeaders(apiKey) {
     const headers = {
@@ -284,11 +317,25 @@ class BaseClient {
   }
   async request(method, path, body, opts = {}) {
     return this.withRequestBudget(opts.signal, async (signal) => {
-      const response = await this.fetchResponse(method, path, body, signal);
+      const cacheKey = method === "GET" && this.etagCache ? `${this.baseUrl}${path}` : null;
+      const cached = cacheKey ? await this.etagCache?.get(cacheKey) : undefined;
+      const response = await this.fetchResponse(method, path, body, signal, cached ? { "If-None-Match": cached.etag } : undefined);
       if (response.status === 204) {
         return;
       }
-      return await raceAbort(response.json(), signal);
+      if (response.status === 304) {
+        if (!cached) {
+          throw new ApiError(304, "Not Modified without a cached copy");
+        }
+        return JSON.parse(cached.body);
+      }
+      const etag = cacheKey ? response.headers.get("ETag") : null;
+      if (!cacheKey || !etag) {
+        return await raceAbort(response.json(), signal);
+      }
+      const text = await raceAbort(response.text(), signal);
+      await this.etagCache?.set(cacheKey, { etag, body: text });
+      return JSON.parse(text);
     });
   }
   async requestOrNull(method, path, body, opts = {}) {
@@ -331,9 +378,12 @@ class BaseClient {
       callerSignal?.removeEventListener("abort", forward);
     }
   }
-  async fetchResponse(method, path, body, signal) {
+  async fetchResponse(method, path, body, signal, extraHeaders) {
     const url = `${this.baseUrl}${path}`;
-    const headers = BaseClient.authHeaders(this.apiKey);
+    const headers = {
+      ...BaseClient.authHeaders(this.apiKey),
+      ...extraHeaders
+    };
     headers["x-sl-origin"] = this.origin;
     let serializedBody;
     if (body !== undefined && body !== null) {
@@ -358,6 +408,8 @@ class BaseClient {
         throw err;
       throw new ApiError(0, `Cannot reach API at ${this.baseUrl}. Check your connection or try again.`, undefined, undefined, { retryable: true, cause: err instanceof Error ? err : undefined });
     }
+    if (response.status === 304)
+      return response;
     if (!response.ok) {
       const errorBody = signal ? await raceAbort(response.text(), signal) : await response.text();
       const envelope = parseErrorEnvelope(errorBody);
@@ -379,604 +431,109 @@ class BaseClient {
   }
 }
 
-// src/streams/subscribe.ts
-import { ed25519 } from "@secondlayer/shared";
-
-// src/streams/errors.ts
-class StreamsServerError extends ApiError {
-  constructor(message, status, body, code) {
-    super(status, message, body, code, { retryable: true });
-    this.name = "StreamsServerError";
-  }
+// src/archive/client.ts
+var OFFICIAL_ARCHIVE_HOST = "archive.secondlayer.tools";
+var DEFAULT_ARCHIVE_BASE_URL = "https://archive.secondlayer.tools";
+var DEFAULT_ARCHIVE_OPS_URL = "https://api.secondlayer.tools";
+var MAX_FETCH_BATCH = 64;
+var ARCHIVE_CREDENTIAL_RE = /^s[ks]-sl_/;
+function quoteFromBody(body) {
+  return {
+    partitions: body.partitions,
+    bundles: body.bundles,
+    usdMicros: body.usd_micros,
+    usd: body.usd,
+    freeAllowanceAppliedMicros: body.free_allowance_applied_micros,
+    allowanceRemainingBundles: body.allowance_remaining_bundles,
+    balanceUsdMicros: body.balance_usd_micros,
+    sufficient: body.sufficient
+  };
 }
-
-class StreamsSignatureError extends SecondLayerError {
-  constructor(message = "Streams response signature verification failed.") {
-    super(message);
-    this.name = "StreamsSignatureError";
-  }
+function stripSlash(url) {
+  return url.replace(/\/+$/, "");
 }
-async function mapStreamsError(response) {
-  const { message, code, body } = parseErrorEnvelope(await response.text());
-  if (response.status === 401) {
-    throw new AuthError(message ?? "API key invalid or expired.", body, code);
-  }
-  if (response.status === 429) {
-    const retryAfter = response.headers.get("Retry-After") ?? undefined;
-    throw new RateLimitError(message ?? "Rate limited. Try again later.", retryAfter, body, code);
-  }
-  if (response.status >= 500) {
-    throw new StreamsServerError(message ?? `Streams server returned ${response.status}.`, response.status, body, code);
+function createArchiveClient(options = {}) {
+  const accountKey = resolveAccountKey(options.accountKey ?? options.apiKey);
+  const fetchImpl = options.fetchImpl ?? ((input, init) => fetch(input, init));
+  const archiveBaseUrl = stripSlash(options.archiveBaseUrl ?? DEFAULT_ARCHIVE_BASE_URL);
+  const archiveOpsUrl = stripSlash(options.archiveOpsUrl ?? DEFAULT_ARCHIVE_OPS_URL);
+  const verifyManifest = options.verifyManifest ?? true;
+  const pinnedPem = options.publicKeyPem;
+  let keyPromise = null;
+  async function fetchSigningKey() {
+    if (pinnedPem)
+      return pinnedPem;
+    if (keyPromise)
+      return keyPromise;
+    const pending = (async () => {
+      const res = await fetchImpl(`${archiveOpsUrl}/public/streams/signing-key`);
+      if (!res.ok) {
+        throw new ArchiveSignatureError(`Could not fetch archive signing key (${res.status}).`);
+      }
+      const body = await res.json();
+      if (typeof body.public_key_pem !== "string") {
+        throw new ArchiveSignatureError("Signing key response missing key.");
+      }
+      return body.public_key_pem;
+    })();
+    keyPromise = pending;
+    pending.catch(() => {
+      if (keyPromise === pending)
+        keyPromise = null;
+    });
+    return pending;
   }
-  throw new ValidationError(message ?? `Streams request returned ${response.status}.`, response.status, body, code);
-}
-
-// src/streams/subscribe.ts
-var SUBSCRIBE_MAX_RECONNECT_DELAY_MS = 30000;
-var SUBSCRIBE_DEFAULT_STALE_AFTER_MS = 60000;
-function reconnectDelay(attempt, baseMs, retryAfterSeconds, random = Math.random) {
-  const capped = Math.min(baseMs * 2 ** Math.max(0, attempt), SUBSCRIBE_MAX_RECONNECT_DELAY_MS);
-  const jittered = capped * (0.5 + random() * 0.5);
-  const floor = (retryAfterSeconds ?? 0) * 1000;
-  return Math.max(jittered, floor);
-}
-function isTerminal(err) {
-  if (err instanceof StreamsSignatureError)
-    return true;
-  return err?.retryable === false;
-}
-function subscribeStreamsEvents(opts) {
-  const { params } = opts;
-  const controller = new AbortController;
-  const external = params.signal;
-  if (external) {
-    if (external.aborted)
-      controller.abort();
-    else
-      external.addEventListener("abort", () => controller.abort(), {
-        once: true
-      });
+  async function throwOpsError(response) {
+    const envelope = parseErrorEnvelope(await response.text());
+    if (response.status === 401) {
+      throw new ArchiveAuthError(envelope.message ?? "Archive ops request was not authenticated.");
+    }
+    if (response.status === 402) {
+      const raw = envelope.body && typeof envelope.body === "object" && "shortfall_usd_micros" in envelope.body ? Number(envelope.body.shortfall_usd_micros) : undefined;
+      throw new InsufficientArchiveCreditsError(envelope.message ?? "Insufficient archive credits.", Number.isFinite(raw) ? raw : undefined);
+    }
+    if (response.status === 503) {
+      throw new ArchiveGateNotConfiguredError(envelope.message ?? "The archive gate is not configured on the server.");
+    }
+    throw new ApiError(response.status, envelope.message ?? `Archive ops returned ${response.status}.`, envelope.body, envelope.code);
   }
-  let cursor = params.fromCursor ?? null;
-  const baseDelayMs = opts.reconnectDelayMs ?? params.reconnectDelayMs ?? 1000;
-  const staleAfterMs = opts.staleAfterMs ?? params.staleAfterMs ?? SUBSCRIBE_DEFAULT_STALE_AFTER_MS;
-  let attempt = 0;
-  const run = async () => {
-    while (!controller.signal.aborted) {
-      try {
-        const url = `${opts.baseUrl}/v1/streams/events/stream${buildQuery({
-          from_cursor: cursor ?? undefined,
-          types: params.types,
-          not_types: params.notTypes,
-          contract_id: params.contractId,
-          sender: params.sender,
-          recipient: params.recipient,
-          asset_identifier: params.assetIdentifier,
-          filters: params.filters ? JSON.stringify(params.filters) : undefined
-        })}`;
-        await readSse({
-          url,
-          headers: opts.headers ?? {},
-          signal: controller.signal,
-          fetchImpl: opts.fetchImpl,
-          staleAfterMs,
-          mapError: mapStreamsError,
-          onFrame: async (frame) => {
-            attempt = 0;
-            if (frame.event === "ping" || !frame.data)
-              return;
-            let parsed;
-            try {
-              parsed = JSON.parse(frame.data);
-            } catch {
-              return;
-            }
-            if (!parsed.event)
-              return;
-            if (opts.verify !== "off") {
-              if (!parsed.sig) {
-                if (opts.verify === "strict") {
-                  throw new StreamsSignatureError("Streams SSE frame signature is missing.");
-                }
-              } else {
-                const key = await opts.loadKey(parsed.key_id);
-                if (!ed25519.verifyEd25519(JSON.stringify(parsed.event), parsed.sig, key.publicKey)) {
-                  throw new StreamsSignatureError("Streams SSE frame signature is invalid.");
-                }
-              }
-            }
-            await params.onEvent(parsed.event);
-            cursor = parsed.event.cursor ?? cursor;
-          }
-        });
-        await sleep(reconnectDelay(attempt, baseDelayMs, undefined, opts.random), controller.signal);
-        attempt += 1;
-      } catch (err) {
-        if (controller.signal.aborted)
-          return;
-        params.onError?.(err);
-        if (isTerminal(err))
-          throw err;
-        const retryAfterSeconds = err.retryAfterSeconds;
-        await sleep(reconnectDelay(attempt, baseDelayMs, retryAfterSeconds, opts.random), controller.signal);
-        attempt += 1;
+  async function opsRequest(method, path, body, authed = true) {
+    const headers = {
+      "Content-Type": "application/json"
+    };
+    if (authed && accountKey) {
+      if (!ARCHIVE_CREDENTIAL_RE.test(accountKey)) {
+        throw new ArchiveAuthError("archive ops need SECONDLAYER_API_KEY (sk-sl_*), not INSTANCE_TOKEN");
       }
+      headers.Authorization = `Bearer ${accountKey}`;
     }
-  };
-  const done = run();
-  done.catch(() => {});
-  const unsubscribe = () => controller.abort();
-  return Object.assign(unsubscribe, { done });
-}
-async function readSse(opts) {
-  const res = await opts.fetchImpl(opts.url, {
-    headers: { ...opts.headers ?? {}, Accept: "text/event-stream" },
-    signal: opts.signal
-  });
-  if (!res.ok) {
-    if (opts.mapError)
-      await opts.mapError(res);
-    throw new StreamsServerError(`Streams SSE returned ${res.status}.`, res.status);
+    const response = await fetchImpl(`${archiveOpsUrl}${path}`, {
+      method,
+      headers,
+      body: body !== undefined ? JSON.stringify(body) : undefined
+    });
+    if (!response.ok)
+      await throwOpsError(response);
+    return await response.json();
   }
-  if (!res.body) {
-    throw new StreamsServerError("Streams SSE response has no body.", 0);
+  async function load(against, opts = {}) {
+    if (!/^https?:\/\//i.test(against)) {
+      throw new ValidationError("archive.load() accepts only http(s) URLs; local paths stay on the CLI.", 400);
+    }
+    const insecure = opts.insecure === true;
+    const publicKeyPem = pinnedPem ?? (verifyManifest && !insecure ? await fetchSigningKey() : undefined);
+    const ref = await loadReference(against, {
+      publicKeyPem,
+      fetchImpl
+    });
+    const signature = checkSignature(ref.manifest, publicKeyPem, insecure);
+    if (verifyManifest && !insecure && !signature.verified) {
+      throw new ArchiveSignatureError(signature.reason ?? "Archive manifest signature is missing or invalid.");
+    }
+    return { ...ref, signature };
   }
-  for await (const frame of parseSseFrames(res.body, opts.signal, opts.staleAfterMs)) {
-    await opts.onFrame(frame);
-  }
-}
-function sleep(ms, signal) {
-  return new Promise((resolve) => {
-    if (signal.aborted)
-      return resolve();
-    const onAbort = () => {
-      clearTimeout(timer);
-      resolve();
-    };
-    const timer = setTimeout(() => {
-      signal.removeEventListener("abort", onAbort);
-      resolve();
-    }, ms);
-    signal.addEventListener("abort", onAbort, { once: true });
-  });
-}
-async function readWithStaleTimer(reader, staleAfterMs) {
-  if (staleAfterMs === undefined || !Number.isFinite(staleAfterMs)) {
-    return reader.read();
-  }
-  let timer;
-  const stale = new Promise((_, reject) => {
-    timer = setTimeout(() => reject(new StreamsServerError(`Streams SSE went quiet for ${staleAfterMs} ms; reconnecting.`, 0, undefined, "STREAM_STALE")), staleAfterMs);
-  });
-  try {
-    return await Promise.race([reader.read(), stale]);
-  } finally {
-    clearTimeout(timer);
-  }
-}
-async function* parseSseFrames(body, signal, staleAfterMs) {
-  const reader = body.getReader();
-  const decoder = new TextDecoder;
-  let buffer = "";
-  try {
-    while (!signal.aborted) {
-      const { value, done } = await readWithStaleTimer(reader, staleAfterMs);
-      if (done)
-        break;
-      buffer += decoder.decode(value, { stream: true });
-      let sep = buffer.indexOf(`
-
-`);
-      while (sep !== -1) {
-        yield parseFrame(buffer.slice(0, sep));
-        buffer = buffer.slice(sep + 2);
-        sep = buffer.indexOf(`
-
-`);
-      }
-    }
-  } finally {
-    try {
-      await reader.cancel();
-    } catch {}
-  }
-}
-function parseFrame(raw) {
-  let event;
-  const data = [];
-  for (const line of raw.split(`
-`)) {
-    if (line.startsWith("data:")) {
-      data.push(line.slice(line.startsWith("data: ") ? 6 : 5));
-    } else if (line.startsWith("event:")) {
-      event = line.slice(line.startsWith("event: ") ? 7 : 6).trim();
-    }
-  }
-  return { event, data: data.length > 0 ? data.join(`
-`) : undefined };
-}
-
-// src/subgraphs/serialize.ts
-var SYSTEM_COLUMN_MAP = {
-  _blockHeight: "_block_height",
-  _txId: "_tx_id",
-  _createdAt: "_created_at",
-  _id: "_id"
-};
-var SYSTEM_COLUMN_ALIASES = {
-  blockHeight: "_block_height",
-  txId: "_tx_id",
-  createdAt: "_created_at",
-  id: "_id"
-};
-function resolveColumn(col, columns) {
-  const canonical = SYSTEM_COLUMN_MAP[col];
-  if (canonical)
-    return canonical;
-  if (columns?.has(col))
-    return col;
-  return SYSTEM_COLUMN_ALIASES[col] ?? col;
-}
-function serializeWhere(where, columns) {
-  const filters = {};
-  for (const [column, value] of Object.entries(where)) {
-    if (value === null || value === undefined)
-      continue;
-    const col = resolveColumn(column, columns);
-    if (typeof value === "object" && !Array.isArray(value)) {
-      const ops = value;
-      for (const [op, opValue] of Object.entries(ops)) {
-        if (opValue === null || opValue === undefined)
-          continue;
-        if (op === "eq") {
-          filters[col] = String(opValue);
-        } else if (op === "in" || op === "notIn") {
-          const arr = Array.isArray(opValue) ? opValue : [opValue];
-          filters[`${col}.${op}`] = arr.map((v) => String(v)).join(",");
-        } else if (["neq", "gt", "gte", "lt", "lte", "like"].includes(op)) {
-          filters[`${col}.${op}`] = String(opValue);
-        }
-      }
-    } else {
-      filters[col] = String(value);
-    }
-  }
-  return filters;
-}
-function resolveOrderByColumn(col, columns) {
-  return resolveColumn(col, columns);
-}
-
-// src/subgraphs/client.ts
-var SUBSCRIBE_RECONNECT_DELAY_MS = 1000;
-function declaredColumns(table) {
-  if (!table || typeof table !== "object")
-    return;
-  const columns = table.columns;
-  if (!columns || typeof columns !== "object")
-    return;
-  return new Set(Object.keys(columns));
-}
-function rowBlockHeight(row) {
-  const r = row;
-  const raw = r._block_height ?? r._blockHeight;
-  if (typeof raw !== "number" && typeof raw !== "string")
-    return;
-  const height = Number(raw);
-  return Number.isFinite(height) ? height : undefined;
-}
-function sleep2(ms, signal) {
-  return new Promise((resolve) => {
-    if (signal.aborted)
-      return resolve();
-    const onAbort = () => {
-      clearTimeout(timer);
-      resolve();
-    };
-    const timer = setTimeout(() => {
-      signal.removeEventListener("abort", onAbort);
-      resolve();
-    }, ms);
-    signal.addEventListener("abort", onAbort, { once: true });
-  });
-}
-function buildSubgraphQueryString(params) {
-  return buildQuery({
-    _sort: params.sort,
-    _order: params.order,
-    _limit: params.limit,
-    _offset: params.offset,
-    _fields: params.fields,
-    ...params.filters
-  });
-}
-function buildAggregateQueryString(params) {
-  return buildQuery({
-    ...params.filters,
-    _count: params.count ? "true" : undefined,
-    _countDistinct: params.countDistinct,
-    _sum: params.sum,
-    _min: params.min,
-    _max: params.max
-  });
-}
-function buildSpecQueryString(options) {
-  return buildQuery({ server: options?.serverUrl });
-}
-
-class Subgraphs extends BaseClient {
-  async list() {
-    return this.request("GET", "/api/subgraphs");
-  }
-  async status(name) {
-    return this.request("GET", `/api/subgraphs/${seg(name)}`);
-  }
-  async openapi(name, options) {
-    return this.request("GET", `/api/subgraphs/${seg(name)}/openapi.json${buildSpecQueryString(options)}`);
-  }
-  async schema(name, options) {
-    return this.request("GET", `/api/subgraphs/${seg(name)}/schema.json${buildSpecQueryString(options)}`);
-  }
-  async markdown(name, options) {
-    return this.requestText("GET", `/api/subgraphs/${seg(name)}/docs.md${buildSpecQueryString(options)}`);
-  }
-  async reindex(name) {
-    return this.request("POST", `/api/subgraphs/${seg(name)}/reindex`);
-  }
-  async stop(name) {
-    return this.request("POST", `/api/subgraphs/${seg(name)}/stop`);
-  }
-  async backfill(name, options) {
-    return this.request("POST", `/api/subgraphs/${seg(name)}/backfill`, options);
-  }
-  async gaps(name, opts) {
-    const qs = buildQuery({
-      _limit: opts?.limit,
-      _offset: opts?.offset,
-      resolved: opts?.resolved
-    });
-    return this.request("GET", `/api/subgraphs/${seg(name)}/gaps${qs}`);
-  }
-  async delete(name, options) {
-    const qs = buildQuery({ force: options?.force ? true : undefined });
-    return this.request("DELETE", `/api/subgraphs/${seg(name)}${qs}`);
-  }
-  async rows(name, table, params = {}) {
-    const { cursor, ...rest } = params;
-    const qs = buildSubgraphQueryString(rest);
-    const sep = qs ? "&" : "?";
-    const cursorQs = cursor ? `${sep}cursor=${encodeURIComponent(cursor)}` : "";
-    return this.request("GET", `/v1/subgraphs/${seg(name)}/${seg(table)}${qs}${cursorQs}`);
-  }
-  async operations(name) {
-    return this.request("GET", `/api/subgraphs/${seg(name)}/operations`);
-  }
-  async getOperation(name, operationId) {
-    return this.request("GET", `/api/subgraphs/${seg(name)}/operations/${seg(operationId)}`);
-  }
-  async deploy(data) {
-    return this.request("POST", "/api/subgraphs", data);
-  }
-  async getSource(name) {
-    return this.request("GET", `/api/subgraphs/${seg(name)}/source`);
-  }
-  async bundle(data) {
-    return this.request("POST", "/api/subgraphs/bundle", data);
-  }
-  async queryTable(name, table, params = {}) {
-    const result = await this.request("GET", `/api/subgraphs/${seg(name)}/${seg(table)}${buildSubgraphQueryString(params)}`);
-    return Array.isArray(result) ? result : result.data;
-  }
-  async queryTableCount(name, table, params = {}) {
-    return this.request("GET", `/api/subgraphs/${seg(name)}/${seg(table)}/count${buildSubgraphQueryString(params)}`);
-  }
-  async queryTableAggregate(name, table, params = {}) {
-    return this.request("GET", `/api/subgraphs/${seg(name)}/${seg(table)}/aggregate${buildAggregateQueryString(params)}`);
-  }
-  typed(def) {
-    const result = {};
-    for (const [tableName, table] of Object.entries(def.schema)) {
-      result[tableName] = this.createTableClient(def.name, tableName, declaredColumns(table));
-    }
-    return result;
-  }
-  createTableClient(subgraphName, tableName, columns) {
-    const self = this;
-    return {
-      async findMany(options = {}) {
-        const filters = options.where ? serializeWhere(options.where, columns) : undefined;
-        let sort;
-        let order;
-        if (options.orderBy) {
-          const entries = Array.isArray(options.orderBy) ? options.orderBy : Object.entries(options.orderBy);
-          if (entries.length > 0) {
-            sort = entries.map(([col]) => resolveOrderByColumn(col, columns)).join(",");
-            order = entries.map(([, dir]) => dir ?? "asc").join(",");
-          }
-        }
-        const params = {
-          sort,
-          order,
-          limit: options.limit,
-          offset: options.offset,
-          fields: options.fields?.join(","),
-          filters
-        };
-        return self.queryTable(subgraphName, tableName, params);
-      },
-      async count(where) {
-        const filters = where ? serializeWhere(where, columns) : undefined;
-        const result = await self.queryTableCount(subgraphName, tableName, {
-          filters
-        });
-        return result.count;
-      },
-      async aggregate(spec) {
-        const filters = spec.where ? serializeWhere(spec.where, columns) : undefined;
-        const result = await self.queryTableAggregate(subgraphName, tableName, {
-          filters,
-          count: spec.count,
-          countDistinct: spec.countDistinct,
-          sum: spec.sum,
-          min: spec.min,
-          max: spec.max
-        });
-        return result;
-      },
-      subscribe(onRow, options = {}) {
-        const filters = options.where ? serializeWhere(options.where, columns) : {};
-        const controller = new AbortController;
-        let since = options.since ?? undefined;
-        const run = async () => {
-          while (!controller.signal.aborted) {
-            try {
-              const qs = buildQuery({ ...filters, since });
-              await readSse({
-                url: `${self.baseUrl}/v1/subgraphs/${seg(subgraphName)}/${seg(tableName)}/stream${qs}`,
-                headers: {
-                  ...BaseClient.authHeaders(self.apiKey),
-                  "x-sl-origin": self.origin
-                },
-                signal: controller.signal,
-                fetchImpl: self.fetchImpl,
-                onFrame: (frame) => {
-                  if (frame.event === "ping" || !frame.data)
-                    return;
-                  let row;
-                  try {
-                    row = JSON.parse(frame.data);
-                  } catch {
-                    return;
-                  }
-                  const height = rowBlockHeight(row);
-                  if (height !== undefined)
-                    since = height;
-                  onRow(row);
-                }
-              });
-              await sleep2(SUBSCRIBE_RECONNECT_DELAY_MS, controller.signal);
-            } catch (err) {
-              if (controller.signal.aborted)
-                return;
-              options.onError?.(err);
-              await sleep2(SUBSCRIBE_RECONNECT_DELAY_MS, controller.signal);
-            }
-          }
-        };
-        run();
-        return () => controller.abort();
-      }
-    };
-  }
-}
-// src/archive/client.ts
-import { createHash } from "node:crypto";
-import {
-  checkSignature,
-  loadReference
-} from "@secondlayer/shared/archive/reference";
-var OFFICIAL_ARCHIVE_HOST = "archive.secondlayer.tools";
-var DEFAULT_ARCHIVE_BASE_URL = "https://archive.secondlayer.tools";
-var DEFAULT_ARCHIVE_OPS_URL = "https://api.secondlayer.tools";
-var MAX_FETCH_BATCH = 64;
-var ARCHIVE_CREDENTIAL_RE = /^s[ks]-sl_/;
-function quoteFromBody(body) {
-  return {
-    partitions: body.partitions,
-    bundles: body.bundles,
-    usdMicros: body.usd_micros,
-    usd: body.usd,
-    freeAllowanceAppliedMicros: body.free_allowance_applied_micros,
-    allowanceRemainingBundles: body.allowance_remaining_bundles,
-    balanceUsdMicros: body.balance_usd_micros,
-    sufficient: body.sufficient
-  };
-}
-function stripSlash(url) {
-  return url.replace(/\/+$/, "");
-}
-function createArchiveClient(options = {}) {
-  const accountKey = resolveAccountKey(options.accountKey ?? options.apiKey);
-  const fetchImpl = options.fetchImpl ?? ((input, init) => fetch(input, init));
-  const archiveBaseUrl = stripSlash(options.archiveBaseUrl ?? DEFAULT_ARCHIVE_BASE_URL);
-  const archiveOpsUrl = stripSlash(options.archiveOpsUrl ?? DEFAULT_ARCHIVE_OPS_URL);
-  const verifyManifest = options.verifyManifest ?? true;
-  const pinnedPem = options.publicKeyPem;
-  let keyPromise = null;
-  async function fetchSigningKey() {
-    if (pinnedPem)
-      return pinnedPem;
-    if (keyPromise)
-      return keyPromise;
-    const pending = (async () => {
-      const res = await fetchImpl(`${archiveOpsUrl}/public/streams/signing-key`);
-      if (!res.ok) {
-        throw new ArchiveSignatureError(`Could not fetch archive signing key (${res.status}).`);
-      }
-      const body = await res.json();
-      if (typeof body.public_key_pem !== "string") {
-        throw new ArchiveSignatureError("Signing key response missing key.");
-      }
-      return body.public_key_pem;
-    })();
-    keyPromise = pending;
-    pending.catch(() => {
-      if (keyPromise === pending)
-        keyPromise = null;
-    });
-    return pending;
-  }
-  async function throwOpsError(response) {
-    const envelope = parseErrorEnvelope(await response.text());
-    if (response.status === 401) {
-      throw new ArchiveAuthError(envelope.message ?? "Archive ops request was not authenticated.");
-    }
-    if (response.status === 402) {
-      const raw = envelope.body && typeof envelope.body === "object" && "shortfall_usd_micros" in envelope.body ? Number(envelope.body.shortfall_usd_micros) : undefined;
-      throw new InsufficientArchiveCreditsError(envelope.message ?? "Insufficient archive credits.", Number.isFinite(raw) ? raw : undefined);
-    }
-    if (response.status === 503) {
-      throw new ArchiveGateNotConfiguredError(envelope.message ?? "The archive gate is not configured on the server.");
-    }
-    throw new ApiError(response.status, envelope.message ?? `Archive ops returned ${response.status}.`, envelope.body, envelope.code);
-  }
-  async function opsRequest(method, path, body, authed = true) {
-    const headers = {
-      "Content-Type": "application/json"
-    };
-    if (authed && accountKey) {
-      if (!ARCHIVE_CREDENTIAL_RE.test(accountKey)) {
-        throw new ArchiveAuthError("archive ops need SECONDLAYER_API_KEY (sk-sl_*), not INSTANCE_TOKEN");
-      }
-      headers.Authorization = `Bearer ${accountKey}`;
-    }
-    const response = await fetchImpl(`${archiveOpsUrl}${path}`, {
-      method,
-      headers,
-      body: body !== undefined ? JSON.stringify(body) : undefined
-    });
-    if (!response.ok)
-      await throwOpsError(response);
-    return await response.json();
-  }
-  async function load(against, opts = {}) {
-    if (!/^https?:\/\//i.test(against)) {
-      throw new ValidationError("archive.load() accepts only http(s) URLs; local paths stay on the CLI.", 400);
-    }
-    const insecure = opts.insecure === true;
-    const publicKeyPem = pinnedPem ?? (verifyManifest && !insecure ? await fetchSigningKey() : undefined);
-    const ref = await loadReference(against, {
-      publicKeyPem,
-      fetchImpl
-    });
-    const signature = checkSignature(ref.manifest, publicKeyPem, insecure);
-    if (verifyManifest && !insecure && !signature.verified) {
-      throw new ArchiveSignatureError(signature.reason ?? "Archive manifest signature is missing or invalid.");
-    }
-    return { ...ref, signature };
-  }
-  async function latest(against, opts = {}) {
-    return load(against ?? `${archiveBaseUrl}/latest.json`, opts);
+  async function latest(against, opts = {}) {
+    return load(against ?? `${archiveBaseUrl}/latest.json`, opts);
   }
   async function status() {
     const response = await fetchImpl(`${archiveBaseUrl}/status.json`);
@@ -1133,6 +690,37 @@ import {
   decodeStreamsCursor,
   encodeStreamsCursor
 } from "@secondlayer/shared";
+
+// src/streams/errors.ts
+class StreamsServerError extends ApiError {
+  constructor(message, status, body, code) {
+    super(status, message, body, code, { retryable: true });
+    this.name = "StreamsServerError";
+  }
+}
+
+class StreamsSignatureError extends SecondLayerError {
+  constructor(message = "Streams response signature verification failed.") {
+    super(message);
+    this.name = "StreamsSignatureError";
+  }
+}
+async function mapStreamsError(response) {
+  const { message, code, body } = parseErrorEnvelope(await response.text());
+  if (response.status === 401) {
+    throw new AuthError(message ?? "API key invalid or expired.", body, code);
+  }
+  if (response.status === 429) {
+    const retryAfter = response.headers.get("Retry-After") ?? undefined;
+    throw new RateLimitError(message ?? "Rate limited. Try again later.", retryAfter, body, code);
+  }
+  if (response.status >= 500) {
+    throw new StreamsServerError(message ?? `Streams server returned ${response.status}.`, response.status, body, code);
+  }
+  throw new ValidationError(message ?? `Streams request returned ${response.status}.`, response.status, body, code);
+}
+
+// src/streams/cursor.ts
 var Cursor = {
   atHeight(height) {
     if (height <= 0)
@@ -1280,7 +868,7 @@ async function defaultSleep(ms, signal) {
   });
 }
 async function consumeStreamsEvents(opts) {
-  const sleep3 = opts.sleep ?? defaultSleep;
+  const sleep = opts.sleep ?? defaultSleep;
   const mode = opts.mode ?? "tail";
   const finalizedOnly = opts.finalizedOnly ?? false;
   const emptyBackoffMs = opts.emptyBackoffMs ?? 500;
@@ -1310,7 +898,7 @@ async function consumeStreamsEvents(opts) {
       retryCount: opts.retryCount,
       retryDelay: opts.retryDelay,
       onError: opts.onError,
-      sleep: sleep3,
+      sleep,
       signal: opts.signal
     });
     pages++;
@@ -1342,7 +930,7 @@ async function consumeStreamsEvents(opts) {
           retryCount: opts.retryCount,
           retryDelay: opts.retryDelay,
           onError: opts.onError,
-          sleep: sleep3,
+          sleep,
           signal: opts.signal
         });
         if (listed.next_since !== null)
@@ -1405,7 +993,7 @@ async function consumeStreamsEvents(opts) {
       if (mode === "bounded") {
         return { cursor, pages, emptyPolls };
       }
-      await sleep3(emptyBackoffMs, opts.signal);
+      await sleep(emptyBackoffMs, opts.signal);
       continue;
     }
     return { cursor, pages, emptyPolls };
@@ -1413,7 +1001,7 @@ async function consumeStreamsEvents(opts) {
   return { cursor, pages, emptyPolls };
 }
 async function* iterateStreamsBatches(opts) {
-  const sleep3 = opts.sleep ?? defaultSleep;
+  const sleep = opts.sleep ?? defaultSleep;
   let cursor = opts.fromCursor ?? null;
   while (!opts.signal?.aborted) {
     const envelope = await opts.fetchEvents({
@@ -1441,12 +1029,12 @@ async function* iterateStreamsBatches(opts) {
     if (!advanced && envelope.events.length === 0) {
       if (opts.signal?.aborted)
         return;
-      await sleep3(opts.intervalMs, opts.signal);
+      await sleep(opts.intervalMs, opts.signal);
     }
   }
 }
 async function* streamStreamsEvents(opts) {
-  const sleep3 = opts.sleep ?? defaultSleep;
+  const sleep = opts.sleep ?? defaultSleep;
   const emptyBackoffMs = opts.emptyBackoffMs ?? 500;
   const maxPages = opts.maxPages ?? Number.POSITIVE_INFINITY;
   const maxEmptyPolls = opts.maxEmptyPolls ?? Number.POSITIVE_INFINITY;
@@ -1481,7 +1069,7 @@ async function* streamStreamsEvents(opts) {
       emptyPolls++;
       if (emptyPolls >= maxEmptyPolls || pages >= maxPages)
         return;
-      await sleep3(emptyBackoffMs, opts.signal);
+      await sleep(emptyBackoffMs, opts.signal);
       continue;
     }
     return;
@@ -1490,7 +1078,7 @@ async function* streamStreamsEvents(opts) {
 
 // src/index-api/consumer.ts
 async function consumeIndexFeed(opts) {
-  const sleep3 = opts.sleep ?? defaultSleep;
+  const sleep = opts.sleep ?? defaultSleep;
   const mode = opts.mode ?? "tail";
   const finalizedOnly = opts.finalizedOnly ?? false;
   const batchSize = opts.batchSize ?? 200;
@@ -1514,7 +1102,7 @@ async function consumeIndexFeed(opts) {
       retryCount: opts.retryCount,
       retryDelay: opts.retryDelay,
       onError: opts.onError,
-      sleep: sleep3,
+      sleep,
       signal: opts.signal
     });
     pages++;
@@ -1577,7 +1165,7 @@ async function consumeIndexFeed(opts) {
       if (mode === "bounded") {
         return { cursor, pages, emptyPolls };
       }
-      await sleep3(emptyBackoffMs, opts.signal);
+      await sleep(emptyBackoffMs, opts.signal);
       continue;
     }
     return { cursor, pages, emptyPolls };
@@ -2164,9 +1752,195 @@ function createStreamsDumps(opts) {
       bytes.set(chunk, offset);
       offset += chunk.byteLength;
     }
-    return bytes;
+    return bytes;
+  }
+  return { list, fileUrl, download };
+}
+
+// src/streams/subscribe.ts
+import { ed25519 } from "@secondlayer/shared";
+var SUBSCRIBE_MAX_RECONNECT_DELAY_MS = 30000;
+var SUBSCRIBE_DEFAULT_STALE_AFTER_MS = 60000;
+function reconnectDelay(attempt, baseMs, retryAfterSeconds, random = Math.random) {
+  const capped = Math.min(baseMs * 2 ** Math.max(0, attempt), SUBSCRIBE_MAX_RECONNECT_DELAY_MS);
+  const jittered = capped * (0.5 + random() * 0.5);
+  const floor = (retryAfterSeconds ?? 0) * 1000;
+  return Math.max(jittered, floor);
+}
+function isTerminal(err) {
+  if (err instanceof StreamsSignatureError)
+    return true;
+  return err?.retryable === false;
+}
+function subscribeStreamsEvents(opts) {
+  const { params } = opts;
+  const controller = new AbortController;
+  const external = params.signal;
+  if (external) {
+    if (external.aborted)
+      controller.abort();
+    else
+      external.addEventListener("abort", () => controller.abort(), {
+        once: true
+      });
+  }
+  let cursor = params.fromCursor ?? null;
+  const baseDelayMs = opts.reconnectDelayMs ?? params.reconnectDelayMs ?? 1000;
+  const staleAfterMs = opts.staleAfterMs ?? params.staleAfterMs ?? SUBSCRIBE_DEFAULT_STALE_AFTER_MS;
+  let attempt = 0;
+  const run = async () => {
+    while (!controller.signal.aborted) {
+      try {
+        const url = `${opts.baseUrl}/v1/streams/events/stream${buildQuery({
+          from_cursor: cursor ?? undefined,
+          types: params.types,
+          not_types: params.notTypes,
+          contract_id: params.contractId,
+          sender: params.sender,
+          recipient: params.recipient,
+          asset_identifier: params.assetIdentifier,
+          filters: params.filters ? JSON.stringify(params.filters) : undefined
+        })}`;
+        await readSse({
+          url,
+          headers: opts.headers ?? {},
+          signal: controller.signal,
+          fetchImpl: opts.fetchImpl,
+          staleAfterMs,
+          mapError: mapStreamsError,
+          onFrame: async (frame) => {
+            attempt = 0;
+            if (frame.event === "ping" || !frame.data)
+              return;
+            let parsed;
+            try {
+              parsed = JSON.parse(frame.data);
+            } catch {
+              return;
+            }
+            if (!parsed.event)
+              return;
+            if (opts.verify !== "off") {
+              if (!parsed.sig) {
+                if (opts.verify === "strict") {
+                  throw new StreamsSignatureError("Streams SSE frame signature is missing.");
+                }
+              } else {
+                const key = await opts.loadKey(parsed.key_id);
+                if (!ed25519.verifyEd25519(JSON.stringify(parsed.event), parsed.sig, key.publicKey)) {
+                  throw new StreamsSignatureError("Streams SSE frame signature is invalid.");
+                }
+              }
+            }
+            await params.onEvent(parsed.event);
+            cursor = parsed.event.cursor ?? cursor;
+          }
+        });
+        await sleep(reconnectDelay(attempt, baseDelayMs, undefined, opts.random), controller.signal);
+        attempt += 1;
+      } catch (err) {
+        if (controller.signal.aborted)
+          return;
+        params.onError?.(err);
+        if (isTerminal(err))
+          throw err;
+        const retryAfterSeconds = err.retryAfterSeconds;
+        await sleep(reconnectDelay(attempt, baseDelayMs, retryAfterSeconds, opts.random), controller.signal);
+        attempt += 1;
+      }
+    }
+  };
+  const done = run();
+  done.catch(() => {});
+  const unsubscribe = () => controller.abort();
+  return Object.assign(unsubscribe, { done });
+}
+async function readSse(opts) {
+  const res = await opts.fetchImpl(opts.url, {
+    headers: { ...opts.headers ?? {}, Accept: "text/event-stream" },
+    signal: opts.signal
+  });
+  if (!res.ok) {
+    if (opts.mapError)
+      await opts.mapError(res);
+    throw new StreamsServerError(`Streams SSE returned ${res.status}.`, res.status);
+  }
+  if (!res.body) {
+    throw new StreamsServerError("Streams SSE response has no body.", 0);
+  }
+  for await (const frame of parseSseFrames(res.body, opts.signal, opts.staleAfterMs)) {
+    await opts.onFrame(frame);
+  }
+}
+function sleep(ms, signal) {
+  return new Promise((resolve) => {
+    if (signal.aborted)
+      return resolve();
+    const onAbort = () => {
+      clearTimeout(timer);
+      resolve();
+    };
+    const timer = setTimeout(() => {
+      signal.removeEventListener("abort", onAbort);
+      resolve();
+    }, ms);
+    signal.addEventListener("abort", onAbort, { once: true });
+  });
+}
+async function readWithStaleTimer(reader, staleAfterMs) {
+  if (staleAfterMs === undefined || !Number.isFinite(staleAfterMs)) {
+    return reader.read();
+  }
+  let timer;
+  const stale = new Promise((_, reject) => {
+    timer = setTimeout(() => reject(new StreamsServerError(`Streams SSE went quiet for ${staleAfterMs} ms; reconnecting.`, 0, undefined, "STREAM_STALE")), staleAfterMs);
+  });
+  try {
+    return await Promise.race([reader.read(), stale]);
+  } finally {
+    clearTimeout(timer);
+  }
+}
+async function* parseSseFrames(body, signal, staleAfterMs) {
+  const reader = body.getReader();
+  const decoder = new TextDecoder;
+  let buffer = "";
+  try {
+    while (!signal.aborted) {
+      const { value, done } = await readWithStaleTimer(reader, staleAfterMs);
+      if (done)
+        break;
+      buffer += decoder.decode(value, { stream: true });
+      let sep = buffer.indexOf(`
+
+`);
+      while (sep !== -1) {
+        yield parseFrame(buffer.slice(0, sep));
+        buffer = buffer.slice(sep + 2);
+        sep = buffer.indexOf(`
+
+`);
+      }
+    }
+  } finally {
+    try {
+      await reader.cancel();
+    } catch {}
   }
-  return { list, fileUrl, download };
+}
+function parseFrame(raw) {
+  let event;
+  const data = [];
+  for (const line of raw.split(`
+`)) {
+    if (line.startsWith("data:")) {
+      data.push(line.slice(line.startsWith("data: ") ? 6 : 5));
+    } else if (line.startsWith("event:")) {
+      event = line.slice(line.startsWith("event: ") ? 7 : 6).trim();
+    }
+  }
+  return { event, data: data.length > 0 ? data.join(`
+`) : undefined };
 }
 
 // src/streams/client.ts
@@ -2437,21 +2211,295 @@ function createStreamsClient(options) {
           signal: params.signal
         });
       }
-    },
-    blocks: {
-      events(heightOrHash) {
-        return request(`/v1/streams/blocks/${encodeURIComponent(String(heightOrHash))}/events`);
-      }
-    },
-    reorgs: { list: listReorgs },
-    dumps,
-    canonical(height) {
-      return request(`/v1/streams/canonical/${height}`);
-    },
-    tip() {
-      return request("/v1/streams/tip");
-    }
-  };
+    },
+    blocks: {
+      events(heightOrHash) {
+        return request(`/v1/streams/blocks/${encodeURIComponent(String(heightOrHash))}/events`);
+      }
+    },
+    reorgs: { list: listReorgs },
+    dumps,
+    canonical(height) {
+      return request(`/v1/streams/canonical/${height}`);
+    },
+    tip() {
+      return request("/v1/streams/tip");
+    }
+  };
+}
+
+// src/subgraphs/serialize.ts
+var SYSTEM_COLUMN_MAP = {
+  _blockHeight: "_block_height",
+  _txId: "_tx_id",
+  _createdAt: "_created_at",
+  _id: "_id"
+};
+var SYSTEM_COLUMN_ALIASES = {
+  blockHeight: "_block_height",
+  txId: "_tx_id",
+  createdAt: "_created_at",
+  id: "_id"
+};
+function resolveColumn(col, columns) {
+  const canonical = SYSTEM_COLUMN_MAP[col];
+  if (canonical)
+    return canonical;
+  if (columns?.has(col))
+    return col;
+  return SYSTEM_COLUMN_ALIASES[col] ?? col;
+}
+function serializeWhere(where, columns) {
+  const filters = {};
+  for (const [column, value] of Object.entries(where)) {
+    if (value === null || value === undefined)
+      continue;
+    const col = resolveColumn(column, columns);
+    if (typeof value === "object" && !Array.isArray(value)) {
+      const ops = value;
+      for (const [op, opValue] of Object.entries(ops)) {
+        if (opValue === null || opValue === undefined)
+          continue;
+        if (op === "eq") {
+          filters[col] = String(opValue);
+        } else if (op === "in" || op === "notIn") {
+          const arr = Array.isArray(opValue) ? opValue : [opValue];
+          filters[`${col}.${op}`] = arr.map((v) => String(v)).join(",");
+        } else if (["neq", "gt", "gte", "lt", "lte", "like"].includes(op)) {
+          filters[`${col}.${op}`] = String(opValue);
+        }
+      }
+    } else {
+      filters[col] = String(value);
+    }
+  }
+  return filters;
+}
+function resolveOrderByColumn(col, columns) {
+  return resolveColumn(col, columns);
+}
+
+// src/subgraphs/client.ts
+var SUBSCRIBE_RECONNECT_DELAY_MS = 1000;
+function declaredColumns(table) {
+  if (!table || typeof table !== "object")
+    return;
+  const columns = table.columns;
+  if (!columns || typeof columns !== "object")
+    return;
+  return new Set(Object.keys(columns));
+}
+function rowBlockHeight(row) {
+  const r = row;
+  const raw = r._block_height ?? r._blockHeight;
+  if (typeof raw !== "number" && typeof raw !== "string")
+    return;
+  const height = Number(raw);
+  return Number.isFinite(height) ? height : undefined;
+}
+function sleep2(ms, signal) {
+  return new Promise((resolve) => {
+    if (signal.aborted)
+      return resolve();
+    const onAbort = () => {
+      clearTimeout(timer);
+      resolve();
+    };
+    const timer = setTimeout(() => {
+      signal.removeEventListener("abort", onAbort);
+      resolve();
+    }, ms);
+    signal.addEventListener("abort", onAbort, { once: true });
+  });
+}
+function buildSubgraphQueryString(params) {
+  return buildQuery({
+    _sort: params.sort,
+    _order: params.order,
+    _limit: params.limit,
+    _offset: params.offset,
+    _fields: params.fields,
+    ...params.filters
+  });
+}
+function buildAggregateQueryString(params) {
+  return buildQuery({
+    ...params.filters,
+    _count: params.count ? "true" : undefined,
+    _countDistinct: params.countDistinct,
+    _sum: params.sum,
+    _min: params.min,
+    _max: params.max
+  });
+}
+function buildSpecQueryString(options) {
+  return buildQuery({ server: options?.serverUrl });
+}
+
+class Subgraphs extends BaseClient {
+  async list() {
+    return this.request("GET", "/api/subgraphs");
+  }
+  async status(name) {
+    return this.request("GET", `/api/subgraphs/${seg(name)}`);
+  }
+  async openapi(name, options) {
+    return this.request("GET", `/api/subgraphs/${seg(name)}/openapi.json${buildSpecQueryString(options)}`);
+  }
+  async schema(name, options) {
+    return this.request("GET", `/api/subgraphs/${seg(name)}/schema.json${buildSpecQueryString(options)}`);
+  }
+  async markdown(name, options) {
+    return this.requestText("GET", `/api/subgraphs/${seg(name)}/docs.md${buildSpecQueryString(options)}`);
+  }
+  async reindex(name) {
+    return this.request("POST", `/api/subgraphs/${seg(name)}/reindex`);
+  }
+  async stop(name) {
+    return this.request("POST", `/api/subgraphs/${seg(name)}/stop`);
+  }
+  async backfill(name, options) {
+    return this.request("POST", `/api/subgraphs/${seg(name)}/backfill`, options);
+  }
+  async gaps(name, opts) {
+    const qs = buildQuery({
+      _limit: opts?.limit,
+      _offset: opts?.offset,
+      resolved: opts?.resolved
+    });
+    return this.request("GET", `/api/subgraphs/${seg(name)}/gaps${qs}`);
+  }
+  async delete(name, options) {
+    const qs = buildQuery({ force: options?.force ? true : undefined });
+    return this.request("DELETE", `/api/subgraphs/${seg(name)}${qs}`);
+  }
+  async rows(name, table, params = {}) {
+    const { cursor, ...rest } = params;
+    const qs = buildSubgraphQueryString(rest);
+    const sep = qs ? "&" : "?";
+    const cursorQs = cursor ? `${sep}cursor=${encodeURIComponent(cursor)}` : "";
+    return this.request("GET", `/v1/subgraphs/${seg(name)}/${seg(table)}${qs}${cursorQs}`);
+  }
+  async operations(name) {
+    return this.request("GET", `/api/subgraphs/${seg(name)}/operations`);
+  }
+  async getOperation(name, operationId) {
+    return this.request("GET", `/api/subgraphs/${seg(name)}/operations/${seg(operationId)}`);
+  }
+  async deploy(data) {
+    return this.request("POST", "/api/subgraphs", data);
+  }
+  async getSource(name) {
+    return this.request("GET", `/api/subgraphs/${seg(name)}/source`);
+  }
+  async bundle(data) {
+    return this.request("POST", "/api/subgraphs/bundle", data);
+  }
+  async queryTable(name, table, params = {}) {
+    const result = await this.request("GET", `/api/subgraphs/${seg(name)}/${seg(table)}${buildSubgraphQueryString(params)}`);
+    return Array.isArray(result) ? result : result.data;
+  }
+  async queryTableCount(name, table, params = {}) {
+    return this.request("GET", `/api/subgraphs/${seg(name)}/${seg(table)}/count${buildSubgraphQueryString(params)}`);
+  }
+  async queryTableAggregate(name, table, params = {}) {
+    return this.request("GET", `/api/subgraphs/${seg(name)}/${seg(table)}/aggregate${buildAggregateQueryString(params)}`);
+  }
+  typed(def) {
+    const result = {};
+    for (const [tableName, table] of Object.entries(def.schema)) {
+      result[tableName] = this.createTableClient(def.name, tableName, declaredColumns(table));
+    }
+    return result;
+  }
+  createTableClient(subgraphName, tableName, columns) {
+    const self = this;
+    return {
+      async findMany(options = {}) {
+        const filters = options.where ? serializeWhere(options.where, columns) : undefined;
+        let sort;
+        let order;
+        if (options.orderBy) {
+          const entries = Array.isArray(options.orderBy) ? options.orderBy : Object.entries(options.orderBy);
+          if (entries.length > 0) {
+            sort = entries.map(([col]) => resolveOrderByColumn(col, columns)).join(",");
+            order = entries.map(([, dir]) => dir ?? "asc").join(",");
+          }
+        }
+        const params = {
+          sort,
+          order,
+          limit: options.limit,
+          offset: options.offset,
+          fields: options.fields?.join(","),
+          filters
+        };
+        return self.queryTable(subgraphName, tableName, params);
+      },
+      async count(where) {
+        const filters = where ? serializeWhere(where, columns) : undefined;
+        const result = await self.queryTableCount(subgraphName, tableName, {
+          filters
+        });
+        return result.count;
+      },
+      async aggregate(spec) {
+        const filters = spec.where ? serializeWhere(spec.where, columns) : undefined;
+        const result = await self.queryTableAggregate(subgraphName, tableName, {
+          filters,
+          count: spec.count,
+          countDistinct: spec.countDistinct,
+          sum: spec.sum,
+          min: spec.min,
+          max: spec.max
+        });
+        return result;
+      },
+      subscribe(onRow, options = {}) {
+        const filters = options.where ? serializeWhere(options.where, columns) : {};
+        const controller = new AbortController;
+        let since = options.since ?? undefined;
+        const run = async () => {
+          while (!controller.signal.aborted) {
+            try {
+              const qs = buildQuery({ ...filters, since });
+              await readSse({
+                url: `${self.baseUrl}/v1/subgraphs/${seg(subgraphName)}/${seg(tableName)}/stream${qs}`,
+                headers: {
+                  ...BaseClient.authHeaders(self.apiKey),
+                  "x-sl-origin": self.origin
+                },
+                signal: controller.signal,
+                fetchImpl: self.fetchImpl,
+                onFrame: (frame) => {
+                  if (frame.event === "ping" || !frame.data)
+                    return;
+                  let row;
+                  try {
+                    row = JSON.parse(frame.data);
+                  } catch {
+                    return;
+                  }
+                  const height = rowBlockHeight(row);
+                  if (height !== undefined)
+                    since = height;
+                  onRow(row);
+                }
+              });
+              await sleep2(SUBSCRIBE_RECONNECT_DELAY_MS, controller.signal);
+            } catch (err) {
+              if (controller.signal.aborted)
+                return;
+              options.onError?.(err);
+              await sleep2(SUBSCRIBE_RECONNECT_DELAY_MS, controller.signal);
+            }
+          }
+        };
+        run();
+        return () => controller.abort();
+      }
+    };
+  }
 }
 
 // src/webhooks/client.ts
@@ -2627,7 +2675,6 @@ class SecondLayer extends BaseClient {
     };
   }
 }
-
 // src/subgraphs/get-subgraph.ts
 function getSubgraph(def, options = {}) {
   if (options instanceof Subgraphs) {
@@ -2638,36 +2685,6 @@ function getSubgraph(def, options = {}) {
   }
   return new Subgraphs(options).typed(def);
 }
-// src/streams/index.ts
-import {
-  decodeFtTransfer,
-  isFtTransfer,
-  decodeNftTransfer,
-  isNftTransfer,
-  decodeStxBurn,
-  decodeStxLock,
-  decodeStxMint,
-  decodeStxTransfer,
-  isStxBurn,
-  isStxLock,
-  isStxMint,
-  isStxTransfer,
-  decodeFtBurn,
-  decodeFtMint,
-  decodeNftBurn,
-  decodeNftMint,
-  isFtBurn,
-  isFtMint,
-  isNftBurn,
-  isNftMint,
-  decodePrint,
-  isPrint
-} from "@secondlayer/shared/streams-rows";
-
-// src/streams/types.ts
-import {
-  STREAMS_EVENT_TYPES
-} from "@secondlayer/shared/streams-rows";
 // src/consumer-ops.ts
 function consumerHealth(options = {}) {
   const staleAfterMs = options.staleAfterMs ?? 120000;
@@ -2719,12 +2736,12 @@ import {
 } from "@secondlayer/shared/crypto/standard-webhooks";
 function pickHeader(headers, name) {
   if (typeof headers === "function") {
-    const v2 = headers(name);
-    return typeof v2 === "string" ? v2 : undefined;
+    const v = headers(name);
+    return typeof v === "string" ? v : undefined;
   }
   if (typeof headers.get === "function" && !(name in headers)) {
-    const v2 = headers.get(name);
-    return typeof v2 === "string" ? v2 : undefined;
+    const v = headers.get(name);
+    return typeof v === "string" ? v : undefined;
   }
   const bag = headers;
   let v = bag[name] ?? bag[name.toLowerCase()];
@@ -2861,78 +2878,109 @@ function verifyTransactionProof(proof, opts) {
     errors
   };
 }
+// src/streams/index.ts
+import {
+  decodeFtTransfer,
+  isFtTransfer,
+  decodeNftTransfer,
+  isNftTransfer,
+  decodeStxBurn,
+  decodeStxLock,
+  decodeStxMint,
+  decodeStxTransfer,
+  isStxBurn,
+  isStxLock,
+  isStxMint,
+  isStxTransfer,
+  decodeFtBurn,
+  decodeFtMint,
+  decodeNftBurn,
+  decodeNftMint,
+  isFtBurn,
+  isFtMint,
+  isNftBurn,
+  isNftMint,
+  decodePrint,
+  isPrint
+} from "@secondlayer/shared/streams-rows";
+
+// src/streams/types.ts
+import {
+  STREAMS_EVENT_TYPES
+} from "@secondlayer/shared/streams-rows";
 // src/clarity.ts
 import {
   decodeClarityValue,
   toJsonSafe
 } from "@secondlayer/shared/streams-rows";
 export {
-  verifyWebhookSignature,
-  verifyTransactionProof,
-  verify2 as verifyStandardWebhooksHeaders,
-  verifySecondlayerSignature,
-  trigger,
-  toJsonSafe,
-  shutdownSignal,
-  resolveBaseUrl,
-  resolveApiKey,
-  resolveAccountKey,
-  parseRetryAfter,
-  isStxTransfer,
-  isStxMint,
-  isStxLock,
-  isStxBurn,
-  isPrint,
-  isNftTransfer,
-  isNftMint,
-  isNftBurn,
-  isFtTransfer,
-  isFtMint,
-  isFtBurn,
-  getSubgraph,
-  fetchRewardSet,
-  decodeStxTransfer,
-  decodeStxMint,
-  decodeStxLock,
-  decodeStxBurn,
-  decodePrint,
-  decodeNftTransfer,
-  decodeNftMint,
-  decodeNftBurn,
-  decodeFtTransfer,
-  decodeFtMint,
-  decodeFtBurn,
-  decodeClarityValue,
-  decodeChainWebhook,
-  decode,
-  createStreamsClient,
-  createArchiveClient,
-  contextField,
-  consumerHealth,
-  consumeIndexFeed,
-  Webhooks,
-  ValidationError,
-  Subgraphs,
-  StreamsSignatureError,
-  StreamsServerError,
-  SecondLayerError,
-  SecondLayer,
-  RateLimitError,
-  LOCAL_API_URL,
-  InsufficientArchiveCreditsError,
-  Index,
-  INSTANCE_TOKEN_ENV,
-  INDEX_MAX_PAGE_SIZE,
-  DEFAULT_REQUEST_TIMEOUT_MS,
-  Cursor,
-  Contracts,
-  AuthError,
-  ArchiveSignatureError,
-  ArchiveGateNotConfiguredError,
-  ArchiveAuthError,
+  ACCOUNT_KEY_ENV,
   ApiError,
-  ACCOUNT_KEY_ENV
+  ArchiveAuthError,
+  ArchiveGateNotConfiguredError,
+  ArchiveSignatureError,
+  AuthError,
+  Contracts,
+  Cursor,
+  DEFAULT_REQUEST_TIMEOUT_MS,
+  INDEX_MAX_PAGE_SIZE,
+  INSTANCE_TOKEN_ENV,
+  Index,
+  InsufficientArchiveCreditsError,
+  LOCAL_API_URL,
+  MemoryEtagCache,
+  RateLimitError,
+  SecondLayer,
+  SecondLayerError,
+  StreamsServerError,
+  StreamsSignatureError,
+  Subgraphs,
+  ValidationError,
+  Webhooks,
+  consumeIndexFeed,
+  consumerHealth,
+  contextField,
+  createArchiveClient,
+  createStreamsClient,
+  decode,
+  decodeChainWebhook,
+  decodeClarityValue,
+  decodeFtBurn,
+  decodeFtMint,
+  decodeFtTransfer,
+  decodeNftBurn,
+  decodeNftMint,
+  decodeNftTransfer,
+  decodePrint,
+  decodeStxBurn,
+  decodeStxLock,
+  decodeStxMint,
+  decodeStxTransfer,
+  fetchRewardSet,
+  getSubgraph,
+  isFtBurn,
+  isFtMint,
+  isFtTransfer,
+  isNftBurn,
+  isNftMint,
+  isNftTransfer,
+  isPrint,
+  isStxBurn,
+  isStxLock,
+  isStxMint,
+  isStxTransfer,
+  parseRetryAfter,
+  resolveAccountKey,
+  resolveApiKey,
+  resolveBaseUrl,
+  shutdownSignal,
+  toJsonSafe,
+  trigger,
+  verifySecondlayerSignature,
+  verify2 as verifyStandardWebhooksHeaders,
+  verifyTransactionProof,
+  verifyWebhookSignature
 };
 
-//# debugId=1A9F98DFDABD122264756E2164756E21
+//# debugId=92280D2ABC3CFA6364756E2164756E21
 //# sourceMappingURL=index.js.map