@secondlayer/sdk 6.46.1 → 6.48.0

package/dist/subgraphs/index.d.ts

@@ -61,9 +61,9 @@ interface SubgraphRowsEnvelope<T = unknown> {
 	rows: T[];
 	next_cursor: string | null;
 	tip: {
-		block_height: number
-		subgraph_height: number
-		blocks_behind: number
+		block_height: number;
+		subgraph_height: number;
+		blocks_behind: number;
 	};
 }
 interface BundleSubgraphResponse {
@@ -79,34 +79,34 @@ interface BundleSubgraphResponse {
 }
 declare class Subgraphs extends BaseClient {
 	list(): Promise<{
-		data: SubgraphSummary[]
+		data: SubgraphSummary[];
 	}>;
 	get(name: string): Promise<SubgraphDetail>;
 	openapi(name: string, options?: SubgraphSpecOptions): Promise<Record<string, unknown>>;
 	schema(name: string, options?: SubgraphSpecOptions): Promise<SubgraphAgentSchema>;
 	markdown(name: string, options?: SubgraphSpecOptions): Promise<string>;
 	reindex(name: string, options?: {
-		fromBlock?: number
-		toBlock?: number
+		fromBlock?: number;
+		toBlock?: number;
 	}): Promise<ReindexResponse>;
 	stop(name: string): Promise<{
-		message: string
-		operationId?: string
-		status?: string
+		message: string;
+		operationId?: string;
+		status?: string;
 	}>;
 	backfill(name: string, options: {
-		fromBlock: number
-		toBlock: number
+		fromBlock: number;
+		toBlock: number;
 	}): Promise<ReindexResponse>;
 	gaps(name: string, opts?: {
-		limit?: number
-		offset?: number
-		resolved?: boolean
+		limit?: number;
+		offset?: number;
+		resolved?: boolean;
 	}): Promise<SubgraphGapsResponse>;
 	delete(name: string, options?: {
-		force?: boolean
+		force?: boolean;
 	}): Promise<{
-		message: string
+		message: string;
 	}>;
 	/**
 	* Publish: claim the name in the global public namespace and open anon
@@ -114,14 +114,14 @@ declare class Subgraphs extends BaseClient {
 	* holds the public name.
 	*/
 	publish(name: string): Promise<{
-		name: string
-		visibility: "public"
-		url: string
+		name: string;
+		visibility: "public";
+		url: string;
 	}>;
 	/** Make reads private again (owning account's bearer key required). */
 	unpublish(name: string): Promise<{
-		name: string
-		visibility: "private"
+		name: string;
+		visibility: "private";
 	}>;
 	/**
 	* Open /v1 read: cursor-paginated rows. Anon works for public subgraphs;
@@ -129,11 +129,11 @@ declare class Subgraphs extends BaseClient {
 	* `next_cursor`.
 	*/
 	rows<T = unknown>(name: string, table: string, params?: Omit<SubgraphQueryParams, "offset" | "sort"> & {
-		cursor?: string
+		cursor?: string;
 	}): Promise<SubgraphRowsEnvelope<T>>;
 	/** Recent reindex/backfill operations for a subgraph, newest first. */
 	operations(name: string): Promise<{
-		operations: SubgraphOperationStatus[]
+		operations: SubgraphOperationStatus[];
 	}>;
 	/** Status of a single operation (poll the `operationId` returned by
 	*  reindex/backfill/stop until `status` is terminal). */
@@ -145,11 +145,11 @@ declare class Subgraphs extends BaseClient {
 	* authoring loop so Vercel's serverless runtime doesn't have to run esbuild.
 	*/
 	bundle(data: {
-		code: string
+		code: string;
 	}): Promise<BundleSubgraphResponse>;
 	queryTable(name: string, table: string, params?: SubgraphQueryParams): Promise<unknown[]>;
 	queryTableCount(name: string, table: string, params?: SubgraphQueryParams): Promise<{
-		count: number
+		count: number;
 	}>;
 	queryTableAggregate(name: string, table: string, params?: SubgraphAggregateParams): Promise<SubgraphAggregateResponse>;
 	/**
@@ -165,8 +165,8 @@ declare class Subgraphs extends BaseClient {
 	* ```
 	*/
 	typed<T extends {
-		name: string
-		schema: Record<string, unknown>
+		name: string;
+		schema: Record<string, unknown>;
 	}>(def: T): InferSubgraphClient<T>;
 	private createTableClient;
 }
@@ -221,12 +221,12 @@ declare class ApiKeys extends BaseClient {
 	* account-level (owner) key or a dashboard session.
 	*/
 	list(): Promise<{
-		keys: ApiKeySummary[]
+		keys: ApiKeySummary[];
 	}>;
 	/** Revoke a key by id. Existing requests with that key stop working. */
 	revoke(id: string): Promise<{
-		revoked: true
-		id: string
+		revoked: true;
+		id: string;
 	}>;
 }
 /**
@@ -274,7 +274,7 @@ declare class Contracts extends BaseClient {
 	* Pass `{ includeAbi: true }` for the full ABI blob. Resolves null on 404.
 	*/
 	get(contractId: string, opts?: {
-		includeAbi?: boolean
+		includeAbi?: boolean;
 	}): Promise<ContractSummary | null>;
 }
 import { Pox5EventTopic } from "@secondlayer/stacks/pox5";
@@ -312,8 +312,8 @@ interface TransactionProof {
 	/** Present when consensus-level verification is available: the reward cycle and
 	*  its signer set, against which the header's signer signatures are checked. */
 	consensus?: {
-		reward_cycle: number
-		reward_set: RewardSet
+		reward_cycle: number;
+		reward_set: RewardSet;
 	};
 }
 /**
@@ -331,12 +331,83 @@ interface TransactionProof {
 * The interface is dependency-free on purpose: implementations with real
 * database drivers live behind subpath exports (`@secondlayer/sdk/sinks/*`)
 * so the root entry ships no DB dependency.
+*
+* ## The contract
+*
+* Binding on every implementation; the conformance kit
+* (`@secondlayer/sdk/sinks/testing`) probes each one. Violations are SILENT
+* in production — they surface as gaps or duplicates weeks later, never as
+* errors at the violation site — which is why they are spelled out here and
+* mechanically tested.
+*
+* What the loop guarantees the sink:
+*
+* 1. **Init-before-first-page.** `loadCursor` is called exactly once, before
+*    the first fetch — even when the caller passed an explicit `fromCursor`.
+*    It is the sink's init hook: create checkpoint storage, validate
+*    rollback preconditions.
+* 2. **Deterministic replay.** Re-reading from the same cursor yields the
+*    same rows in the same order. `cursor` is therefore a valid idempotency
+*    key: an append-only sink can dedup on it with no contract change.
+* 3. **At-least-once delivery.** A batch whose commit outcome was lost (crash
+*    after commit, before the loop observed it) is re-committed on restart
+*    with the SAME cursor and the same rows.
+*
+* What the sink must guarantee — `commitBatch`:
+*
+* 4. **Rows+cursor atomicity.** The handler's writes and `cursor` commit in
+*    ONE transaction. Committing them separately is the classic torn-batch
+*    bug: a crash between the two either re-delivers (duplicates) or skips
+*    (gap) depending on the order.
+* 5. **Abort on throw.** A throw from `write` aborts the WHOLE transaction —
+*    neither rows nor cursor land — so a crashed batch is simply re-read.
+* 6. **The lent transaction is the real one.** `write(tx)` receives the same
+*    live transaction the cursor commits in; every handler write must go
+*    through it. Writes outside `tx` escape atomicity AND rollback.
+* 7. **Replay safety.** Committing the same cursor twice must not corrupt
+*    state (per #3 the rows are identical; upsert/dedup make it exact).
+*
+* What the sink must guarantee — `rollback`:
+*
+* 8. **Delete+rewind atomicity.** Undoing rows at/above the fork and
+*    committing `rewindCursor` happen in ONE transaction. A crash between
+*    them resumes above the fork and the deleted range is never re-read —
+*    the silent-gap bug.
+* 9. **Inclusive fork point.** Undo AT OR ABOVE `forkPointHeight` (`>=`) —
+*    the new canonical chain re-supplies the fork block itself.
+* 10. **Idempotent.** The loop may re-apply the same rollback after a crash
+*     (reorgs are deduped in memory only); a second application must be a
+*     harmless no-op.
+* 11. **Scope by height, not cursor.** On a page reporting several forks the
+*     loop calls `rollback` once per fork: each call carries its own
+*     `forkPointHeight` but ALL carry the same `rewindCursor` (the lowest
+*     fork point). Derive the undo range from `forkPointHeight` only; a
+*     sink that derives it from `rewindCursor` under-deletes silently.
+*
+* Error semantics and concurrency:
+*
+* 12. **Throw, don't swallow; no internal retry.** The loop owns retry
+*     policy. A swallowed commit error advances the loop past unwritten
+*     data; an internal retry can double-apply around a partial failure.
+* 13. **Single writer per checkpoint id.** The loop assumes one live
+*     consumer per checkpoint identity. A sink that can detect a second
+*     writer (e.g. a lock) must fail loudly — never block or interleave.
 */
 interface ConsumerSink<Tx = unknown> {
 	/** Phantom marker carrying `Tx` in a directly-inferable position, so the
 	*  consume loops' `TTx` type parameter resolves from the `sink` option
 	*  (never set at runtime). */
 	readonly _tx?: Tx;
+	/** Static capabilities, read by the loop before the first fetch to fail
+	*  fast on impossible pairings. */
+	readonly capabilities?: {
+		/** This sink cannot undo committed rows (append-only store, ClickHouse,
+		*  parquet, …), so `rollback` is unimplementable and following the
+		*  unfinalized tip would corrupt it on the first fork. The loop throws
+		*  loudly unless consuming with `finalizedOnly: true` — in that mode
+		*  reorgs never reach the sink and `rollback` may simply throw. */
+		finalizedOnly?: boolean;
+	};
 	/** The committed checkpoint, or `null` on first run. Called once, before
 	*  the first page. Implementations may create their checkpoint storage
 	*  here and SHOULD validate their rollback preconditions (e.g. that every
@@ -356,6 +427,11 @@ interface ConsumerSink<Tx = unknown> {
 	* without the rewound cursor is the classic silent-gap bug: a crash
 	* between the two writes resumes above the fork and the deleted range is
 	* never re-read.
+	*
+	* On a multi-fork page this is called once PER fork, every call with the
+	* same `rewindCursor` (the lowest fork point) but its own
+	* `forkPointHeight` — scope the undo by `forkPointHeight` only (contract
+	* invariant #11), and expect re-application after a crash (#10).
 	*/
 	rollback(forkPointHeight: number, rewindCursor: string): Promise<void>;
 }
@@ -363,75 +439,75 @@ interface ConsumerSink<Tx = unknown> {
 *  is unchanged (an intersection with `unknown` is an identity, so
 *  contextual typing of `onBatch` callbacks never degrades to a union). */
 type WithSinkTx<TTx> = [TTx] extends [never] ? unknown : {
-	tx: TTx
+	tx: TTx;
 };
 import { StreamsEventType } from "@secondlayer/shared";
 /** A Clarity value as Streams serves it: the canonical hex string, a typed
 *  object carrying that hex (`{ hex }`), or a decoded Clarity-JSON object.
 *  Decode helpers (`decodeNftTransfer`, etc.) resolve it to a concrete value. */
 type StreamsClarityValue = string | {
-	hex: string
+	hex: string;
 } | Record<string, unknown>;
 type StxTransferPayload = {
-	sender: string
-	recipient: string
-	amount: string
-	memo?: string
+	sender: string;
+	recipient: string;
+	amount: string;
+	memo?: string;
 };
 type StxMintPayload = {
-	recipient: string
-	amount: string
+	recipient: string;
+	amount: string;
 };
 type StxBurnPayload = {
-	sender: string
-	amount: string
+	sender: string;
+	amount: string;
 };
 type StxLockPayload = {
-	locked_address: string
-	locked_amount: string
-	unlock_height: string
+	locked_address: string;
+	locked_amount: string;
+	unlock_height: string;
 };
 type FtTransferPayload = {
-	asset_identifier: string
-	sender: string
-	recipient: string
-	amount: string
+	asset_identifier: string;
+	sender: string;
+	recipient: string;
+	amount: string;
 };
 type FtMintPayload = {
-	asset_identifier: string
-	recipient: string
-	amount: string
+	asset_identifier: string;
+	recipient: string;
+	amount: string;
 };
 type FtBurnPayload = {
-	asset_identifier: string
-	sender: string
-	amount: string
+	asset_identifier: string;
+	sender: string;
+	amount: string;
 };
 type NftTransferPayload = {
-	asset_identifier: string
-	sender: string
-	recipient: string
-	value: StreamsClarityValue
+	asset_identifier: string;
+	sender: string;
+	recipient: string;
+	value: StreamsClarityValue;
 	/** Canonical serialized hex of `value`, when the stream carries it. */
-	raw_value?: string
+	raw_value?: string;
 };
 type NftMintPayload = {
-	asset_identifier: string
-	recipient: string
-	value: StreamsClarityValue
-	raw_value?: string
+	asset_identifier: string;
+	recipient: string;
+	value: StreamsClarityValue;
+	raw_value?: string;
 };
 type NftBurnPayload = {
-	asset_identifier: string
-	sender: string
-	value: StreamsClarityValue
-	raw_value?: string
+	asset_identifier: string;
+	sender: string;
+	value: StreamsClarityValue;
+	raw_value?: string;
 };
 type PrintPayload = {
-	contract_id?: string | null
-	topic?: string
-	value?: unknown
-	raw_value?: string
+	contract_id?: string | null;
+	topic?: string;
+	value?: unknown;
+	raw_value?: string;
 };
 type StreamsEventBase = {
 	/**
@@ -439,92 +515,97 @@ type StreamsEventBase = {
 	* it as the primary key of your projection rows — replaying a batch then
 	* upserts cleanly. Don't synthesize your own id from `tx_id`/`event_index`.
 	*/
-	cursor: string
-	block_height: number
-	block_hash: string
-	burn_block_height: number
-	tx_id: string
-	tx_index: number
-	event_index: number
-	contract_id: string | null
-	ts: string
+	cursor: string;
+	block_height: number;
+	block_hash: string;
+	burn_block_height: number;
+	tx_id: string;
+	tx_index: number;
+	event_index: number;
+	contract_id: string | null;
+	ts: string;
 	/**
 	* True when this event's block is past the finality boundary (immutable).
 	* Optional for back-compat; the API always sets it on Streams responses.
 	*/
-	finalized?: boolean
+	finalized?: boolean;
 	/**
 	* Labels whose filter group this event satisfied, present only when the
 	* request used a labelled `filters` map. The SDK dispatches on it for you
 	* (`on.<label>`), so handlers rarely read it directly.
 	*/
-	matched?: string[]
+	matched?: string[];
 };
 type StreamsEventOf<
 	T extends StreamsEventType,
 	P
 > = StreamsEventBase & {
-	event_type: T
-	payload: P
+	event_type: T;
+	payload: P;
 };
 /** A raw Streams event. Discriminated on `event_type`, so `event.payload`
 *  narrows to the matching payload shape once the type is checked. */
 type StreamsEvent = StreamsEventOf<"stx_transfer", StxTransferPayload> | StreamsEventOf<"stx_mint", StxMintPayload> | StreamsEventOf<"stx_burn", StxBurnPayload> | StreamsEventOf<"stx_lock", StxLockPayload> | StreamsEventOf<"ft_transfer", FtTransferPayload> | StreamsEventOf<"ft_mint", FtMintPayload> | StreamsEventOf<"ft_burn", FtBurnPayload> | StreamsEventOf<"nft_transfer", NftTransferPayload> | StreamsEventOf<"nft_mint", NftMintPayload> | StreamsEventOf<"nft_burn", NftBurnPayload> | StreamsEventOf<"print", PrintPayload>;
 type StreamsTip = {
-	block_height: number
-	block_hash: string
-	burn_block_height: number
+	block_height: number;
+	block_hash: string;
+	burn_block_height: number;
 	/**
 	* Highest Stacks block past the burn-confirmation finality boundary.
 	* Optional for back-compat; the API always sets it.
 	*/
-	finalized_height?: number
-	lag_seconds: number
+	finalized_height?: number;
+	lag_seconds: number;
 	/**
 	* Oldest height still seekable on the live API for the caller's tier
 	* (`tip - retention`). `null` = unlimited retention. Older reads must use the
 	* cold dumps lane. Optional for back-compat.
 	*/
-	oldest_seekable_height?: number | null
+	oldest_seekable_height?: number | null;
 	/** Oldest seekable cursor (`<oldest_seekable_height>:0`); `null` = unlimited. */
-	oldest_cursor?: string | null
+	oldest_cursor?: string | null;
 };
 type StreamsCanonicalBlock = {
-	block_height: number
-	block_hash: string
-	burn_block_height: number
-	burn_block_hash: string | null
-	is_canonical: true
+	block_height: number;
+	block_hash: string;
+	burn_block_height: number;
+	burn_block_hash: string | null;
+	is_canonical: true;
 };
 type StreamsReorg = {
-	detected_at: string
-	fork_point_height: number
+	detected_at: string;
+	fork_point_height: number;
 	orphaned_range: {
-		from: string
-		to: string
-	}
+		from: string;
+		to: string;
+	};
 	/**
 	* First position of the new canonical chain at the fork, `fork:0`
 	* (INCLUSIVE). Not an exclusive resume token — resuming directly from it
 	* skips `fork:0`. The consumer rewinds to the foot of `fork_point_height`
 	* (`Cursor.atHeight`) to re-read the new run from `fork:0` inclusive.
 	*/
-	new_canonical_tip: string
+	new_canonical_tip: string;
 };
-type StreamsEventsEnvelope = {
-	events: StreamsEvent[]
-	next_cursor: string | null
-	tip: StreamsTip
-	reorgs: StreamsReorg[]
+type StreamsEventsEnvelope<TEvent = StreamsEvent> = {
+	events: TEvent[];
+	next_cursor: string | null;
+	tip: StreamsTip;
+	reorgs: StreamsReorg[];
 };
 type StreamsEventsListEnvelope = Omit<StreamsEventsEnvelope, "next_cursor">;
+/** The StreamsEvent union narrowed to a `types` selection — what a
+*  const-generic `types: ["ft_transfer"]` buys at the type level. */
+type StreamsEventOfTypes<T extends readonly StreamsEventType[]> = Extract<StreamsEvent, {
+	event_type: T[number];
+}>;
 type StreamsReorgsListParams = {
-	since: string
-	limit?: number
+	since: string;
+	limit?: number;
 };
 type StreamsReorgsListEnvelope = {
-	reorgs: StreamsReorg[]
-	next_since: string | null
+	reorgs: StreamsReorg[];
+	next_since: string | null;
 };
 /** A filter that matches a single value or any value in a list. */
 type StreamsFilterValue = string | readonly string[];
@@ -533,11 +614,11 @@ type StreamsFilterValue = string | readonly string[];
 * map OR together server-side.
 */
 type StreamsLabelledFilter = {
-	types?: readonly StreamsEventType[]
-	contractId?: StreamsFilterValue
-	sender?: StreamsFilterValue
-	recipient?: StreamsFilterValue
-	assetIdentifier?: string
+	types?: readonly StreamsEventType[];
+	contractId?: StreamsFilterValue;
+	sender?: StreamsFilterValue;
+	recipient?: StreamsFilterValue;
+	assetIdentifier?: string;
 };
 /** A map of label → filter group. Labels are yours; the server echoes them. */
 type StreamsFilterMap = Record<string, StreamsLabelledFilter>;
@@ -550,65 +631,65 @@ type StreamsEventForFilter<
 	F,
 	D extends boolean = false
 > = F extends {
-	types: readonly (infer T extends StreamsEventType)[]
+	types: readonly (infer T extends StreamsEventType)[];
 } ? D extends true ? Extract<IndexEvent, {
-	event_type: T
+	event_type: T;
 }> : Extract<StreamsEvent, {
-	event_type: T
+	event_type: T;
 }> : D extends true ? IndexEvent : StreamsEvent;
 type StreamsEventsListParams = {
-	cursor?: string | null
-	fromHeight?: number
-	toHeight?: number
-	types?: readonly StreamsEventType[]
+	cursor?: string | null;
+	fromHeight?: number;
+	toHeight?: number;
+	types?: readonly StreamsEventType[];
 	/** Event types to exclude (applied after `types`). */
-	notTypes?: readonly StreamsEventType[]
-	contractId?: StreamsFilterValue
-	sender?: StreamsFilterValue
-	recipient?: StreamsFilterValue
-	assetIdentifier?: string
+	notTypes?: readonly StreamsEventType[];
+	contractId?: StreamsFilterValue;
+	sender?: StreamsFilterValue;
+	recipient?: StreamsFilterValue;
+	assetIdentifier?: string;
 	/**
 	* Labelled filter groups. The groups OR together in one scan and each
 	* returned event carries the labels it matched (`event.matched`) — two
 	* unrelated concerns share one page, one cursor, one checkpoint.
 	*/
-	filters?: StreamsFilterMap
-	limit?: number
+	filters?: StreamsFilterMap;
+	limit?: number;
 };
 type StreamsEventsStreamParams = {
-	fromCursor?: string | null
-	types?: readonly StreamsEventType[]
-	notTypes?: readonly StreamsEventType[]
-	contractId?: StreamsFilterValue
-	sender?: StreamsFilterValue
-	recipient?: StreamsFilterValue
-	assetIdentifier?: string
+	fromCursor?: string | null;
+	types?: readonly StreamsEventType[];
+	notTypes?: readonly StreamsEventType[];
+	contractId?: StreamsFilterValue;
+	sender?: StreamsFilterValue;
+	recipient?: StreamsFilterValue;
+	assetIdentifier?: string;
 	/** Labelled filter groups; see {@link StreamsEventsListParams.filters}. */
-	filters?: StreamsFilterMap
-	batchSize?: number
-	emptyBackoffMs?: number
-	maxPages?: number
-	maxEmptyPolls?: number
-	signal?: AbortSignal
+	filters?: StreamsFilterMap;
+	batchSize?: number;
+	emptyBackoffMs?: number;
+	maxPages?: number;
+	maxEmptyPolls?: number;
+	signal?: AbortSignal;
 };
 type StreamsEventsSubscribeParams = {
 	/** Resume strictly after this cursor; omit to live-tail from the tip. */
-	fromCursor?: string | null
-	types?: readonly StreamsEventType[]
-	notTypes?: readonly StreamsEventType[]
-	contractId?: StreamsFilterValue
-	sender?: StreamsFilterValue
-	recipient?: StreamsFilterValue
-	assetIdentifier?: string
+	fromCursor?: string | null;
+	types?: readonly StreamsEventType[];
+	notTypes?: readonly StreamsEventType[];
+	contractId?: StreamsFilterValue;
+	sender?: StreamsFilterValue;
+	recipient?: StreamsFilterValue;
+	assetIdentifier?: string;
 	/** Labelled filter groups; see {@link StreamsEventsListParams.filters}. */
-	filters?: StreamsFilterMap
+	filters?: StreamsFilterMap;
 	/** Abort to unsubscribe (the returned function does the same). */
-	signal?: AbortSignal
+	signal?: AbortSignal;
 	/** Called for each pushed event, in order. */
-	onEvent: (event: StreamsEvent) => void | Promise<void>
+	onEvent: (event: StreamsEvent) => void | Promise<void>;
 	/** Called on a connection error; the subscription auto-reconnects from the
 	*  last delivered cursor unless the signal has aborted. */
-	onError?: (err: unknown) => void
+	onError?: (err: unknown) => void;
 };
 /**
 * The checkpoint the SDK computes for a batch. Persist `cursor` inside the same
@@ -635,14 +716,14 @@ type ConsumerBatchContext<
 	TReorg = unknown
 > = {
 	/** Checkpoint to commit alongside your rows. */
-	cursor: string | null
+	cursor: string | null;
 	/** Highest canonical block the sweep has reached. `null` before the first
 	*  row of a fresh consume. */
-	height: number | null
+	height: number | null;
 	/** Chain tip as of this page's read. */
-	tipHeight: number
+	tipHeight: number;
 	/** `tipHeight - height`, floored at 0. `null` until `height` is known. */
-	blocksBehind: number | null
+	blocksBehind: number | null;
 	/**
 	* The full tip for this page — `StreamsTip` or `IndexTip` depending on the
 	* surface. Exposed here so a handler never needs the `envelope` parameter,
@@ -650,12 +731,12 @@ type ConsumerBatchContext<
 	* `finalizedOnly` mistake becomes reachable (`return envelope.next_cursor`
 	* jumps the cursor past events that were filtered out and never delivered).
 	*/
-	tip: TTip
+	tip: TTip;
 	/**
 	* Reorgs reported alongside this page; empty when none. Rollback still
 	* belongs in `onReorg` — this is for observability inside a batch.
 	*/
-	reorgs: readonly TReorg[]
+	reorgs: readonly TReorg[];
 };
 /** @deprecated Use {@link ConsumerBatchContext} — the Index and Streams loops
 *  share one shape now. Kept as an alias so existing annotations compile. */
@@ -665,20 +746,20 @@ type StreamsBatchContext = ConsumerBatchContext;
 * inside the same transaction as your rollback so the two commit atomically.
 */
 type StreamsReorgContext = {
-	cursor: string
+	cursor: string;
 };
 type StreamsEventsConsumeParams<
 	TTx = never,
 	D extends boolean = false,
 	F extends StreamsFilterMap = Record<never, never>
 > = {
-	fromCursor?: string | null
+	fromCursor?: string | null;
 	/**
 	* Deliver events pre-decoded as the flat, `event_type`-discriminated rows
 	* Index serves (`IndexEvent`), so Streams consumption reads identically
 	* to Index consumption — no guard+decode pairs in your handler.
 	*/
-	decoded?: D
+	decoded?: D;
 	/**
 	* Destination adapter that owns the checkpoint + rollback transaction
 	* (e.g. `kyselySink` from `@secondlayer/sdk/sinks/kysely`). With a sink:
@@ -687,29 +768,29 @@ type StreamsEventsConsumeParams<
 	* transaction), reorg rollback is automatic, and `onBatch`'s return value
 	* is ignored.
 	*/
-	sink?: ConsumerSink<TTx>
+	sink?: ConsumerSink<TTx>;
 	/** Fires once per page, before `onBatch` and before any early return. */
-	onProgress?: (ctx: ConsumerBatchContext) => void
-	mode?: "tail" | "bounded"
+	onProgress?: (ctx: ConsumerBatchContext) => void;
+	mode?: "tail" | "bounded";
 	/**
 	* Emit only finalized (immutable) events and never surface reorgs. The SDK
 	* checkpoints at the last finalized event and re-reads the unfinalized tail
 	* until it settles. Trades finality lag for zero reorg handling; `onReorg` is
 	* ignored.
 	*/
-	finalizedOnly?: boolean
-	types?: readonly StreamsEventType[]
-	notTypes?: readonly StreamsEventType[]
-	contractId?: StreamsFilterValue
-	sender?: StreamsFilterValue
-	recipient?: StreamsFilterValue
-	assetIdentifier?: string
+	finalizedOnly?: boolean;
+	types?: readonly StreamsEventType[];
+	notTypes?: readonly StreamsEventType[];
+	contractId?: StreamsFilterValue;
+	sender?: StreamsFilterValue;
+	recipient?: StreamsFilterValue;
+	assetIdentifier?: string;
 	/**
 	* Labelled filter groups. The groups OR together in ONE server-side scan,
 	* so two unrelated concerns share one page, one cursor, and one checkpoint
 	* instead of two consume loops. Pair with `on` to handle each label.
 	*/
-	filters?: F
+	filters?: F;
 	/**
 	* One handler per label in `filters`. Every label must be handled, so
 	* adding a label is a compile error until its handler exists.
@@ -720,8 +801,8 @@ type StreamsEventsConsumeParams<
 	* labels do not interleave within a page — add `onBatch` when you need
 	* strict global order across labels.
 	*/
-	on?: { [K in keyof F] : (events: StreamsEventForFilter<F[K], D>[], ctx: StreamsBatchContext & WithSinkTx<TTx>) => void | Promise<void> }
-	batchSize?: number
+	on?: { [K in keyof F] : (events: StreamsEventForFilter<F[K], D>[], ctx: StreamsBatchContext & WithSinkTx<TTx>) => void | Promise<void> };
+	batchSize?: number;
 	/**
 	* Apply a page of canonical events. Persist `ctx.cursor` in the same
 	* transaction as your writes. Returning a cursor overrides `ctx.cursor` as
@@ -730,7 +811,7 @@ type StreamsEventsConsumeParams<
 	* Optional only when `on` handles the page instead; a consume call with
 	* neither throws.
 	*/
-	onBatch?: (events: D extends true ? IndexEvent[] : StreamsEvent[], envelope: StreamsEventsEnvelope, ctx: StreamsBatchContext & WithSinkTx<TTx>) => void | string | null | undefined | Promise<void> | Promise<string | null | undefined>
+	onBatch?: (events: D extends true ? IndexEvent[] : StreamsEvent[], envelope: StreamsEventsEnvelope, ctx: StreamsBatchContext & WithSinkTx<TTx>) => void | string | null | undefined | Promise<void> | Promise<string | null | undefined>;
 	/**
 	* Roll your projection back to `reorg.fork_point_height`, persisting
 	* `ctx.cursor` in the same transaction. Called once per *new* reorg
@@ -738,126 +819,136 @@ type StreamsEventsConsumeParams<
 	* now-canonical events. Omit it to ignore reorgs (events stay canonical, but
 	* stale rows from an orphaned fork are left in place).
 	*/
-	onReorg?: (reorg: StreamsReorg, ctx: StreamsReorgContext) => Promise<void> | void
+	onReorg?: (reorg: StreamsReorg, ctx: StreamsReorgContext) => Promise<void> | void;
 	/** Page-fetch retries after the first failure (429/5xx/network only —
 	*  4xx and handler throws always propagate). Default 3; `0` disables. */
-	retryCount?: number
+	retryCount?: number;
 	/** Base retry delay in ms; the n-th retry waits `retryDelay * n`. A server
 	*  `Retry-After` overrides it. Default 1000. */
-	retryDelay?: number
+	retryDelay?: number;
 	/** Void observer, called before each retry sleep (metrics/logging). */
 	onError?: (err: unknown, ctx: {
-		attempt: number
-		retriesLeft: number
-		delayMs: number
-	}) => void
-	emptyBackoffMs?: number
-	maxPages?: number
-	maxEmptyPolls?: number
-	signal?: AbortSignal
+		attempt: number;
+		retriesLeft: number;
+		delayMs: number;
+	}) => void;
+	emptyBackoffMs?: number;
+	maxPages?: number;
+	maxEmptyPolls?: number;
+	signal?: AbortSignal;
 };
 /**
 * One yielded page from {@link StreamsClient.consume} — the
 * `GET /v1/streams/events` envelope verbatim, with `next_cursor` renamed to
 * `cursor` (the checkpoint to persist and resume from).
 */
-type StreamsBatch = {
+type StreamsBatch<TEvent = StreamsEvent> = {
 	/** Canonical events of this page, in cursor order. */
-	events: StreamsEvent[]
+	events: TEvent[];
 	/** Checkpoint after this page — pass back as `consume({ cursor })` to resume. */
-	cursor: string | null
-	tip: StreamsTip
+	cursor: string | null;
+	tip: StreamsTip;
 	/** Chain reorgs reported alongside this page; empty when none. */
-	reorgs: StreamsReorg[]
+	reorgs: StreamsReorg[];
 };
 type StreamsConsumeParams = {
 	/** Resume strictly after this cursor; omit to start from the oldest seekable page. */
-	cursor?: string | null
-	types?: readonly StreamsEventType[]
-	notTypes?: readonly StreamsEventType[]
-	contractId?: StreamsFilterValue
-	sender?: StreamsFilterValue
-	recipient?: StreamsFilterValue
-	assetIdentifier?: string
+	cursor?: string | null;
+	types?: readonly StreamsEventType[];
+	notTypes?: readonly StreamsEventType[];
+	contractId?: StreamsFilterValue;
+	sender?: StreamsFilterValue;
+	recipient?: StreamsFilterValue;
+	assetIdentifier?: string;
+	/** Labelled OR-groups — same semantics as `events.consume`; each returned
+	*  event echoes the labels it matched. */
+	filters?: StreamsFilterMap;
 	/** Events per page (the `limit` query param). Default 100. */
-	batchSize?: number
+	batchSize?: number;
 	/** Poll interval while caught up at the tip, in ms. Default 2000. */
-	intervalMs?: number
+	intervalMs?: number;
 	/** Abort to end the iteration. */
-	signal?: AbortSignal
+	signal?: AbortSignal;
 };
 type StreamsEventsConsumeResult = {
-	cursor: string | null
-	pages: number
-	emptyPolls: number
+	cursor: string | null;
+	pages: number;
+	emptyPolls: number;
 };
 type StreamsEventsReplayParams = {
 	/** Start point: `"genesis"` (default) or a `<block>:<index>` cursor. */
-	from?: "genesis" | string
+	from?: "genesis" | string;
 	/**
 	* Called once per finalized dump file, in block order, before live tailing.
 	* Process the parquet with your own tooling (e.g. DuckDB) — the SDK does not
 	* decode parquet. Use `client.dumps.download(file)` to fetch + verify bytes.
 	*/
-	onDumpFile: (file: StreamsDumpFile) => Promise<void> | void
+	onDumpFile: (file: StreamsDumpFile) => Promise<void> | void;
 	/** Called per live page after the dump phase, like `consume`. */
-	onBatch: (events: StreamsEvent[], envelope: StreamsEventsEnvelope) => Promise<string | null | undefined> | string | null | undefined
+	onBatch: (events: StreamsEvent[], envelope: StreamsEventsEnvelope) => Promise<string | null | undefined> | string | null | undefined;
 	/**
 	* Called when the live-tail phase (after the dump backfill) crosses a reorg,
 	* before the cursor rewinds and re-reads the now-canonical events — same
 	* contract as `consume`. The dump-backfill phase is finalized and never
 	* reorgs; omit this to leave stale rows from an orphaned fork in place.
 	*/
-	onReorg?: (reorg: StreamsReorg, ctx: StreamsReorgContext) => Promise<void> | void
-	mode?: "tail" | "bounded"
-	batchSize?: number
-	emptyBackoffMs?: number
-	maxPages?: number
-	maxEmptyPolls?: number
-	signal?: AbortSignal
+	onReorg?: (reorg: StreamsReorg, ctx: StreamsReorgContext) => Promise<void> | void;
+	mode?: "tail" | "bounded";
+	batchSize?: number;
+	emptyBackoffMs?: number;
+	maxPages?: number;
+	maxEmptyPolls?: number;
+	signal?: AbortSignal;
+	/** Narrow the LIVE TAIL after the dump phase. The dump files themselves are
+	*  always all-type (block-partitioned parquet) — filter those in your own
+	*  tooling while processing each file. */
+	types?: readonly StreamsEventType[];
+	notTypes?: readonly StreamsEventType[];
+	/** Labelled OR-groups for the live tail, like `consume`. */
+	filters?: StreamsFilterMap;
 };
 /** One bulk parquet file in the dumps manifest. `path` is the object key under
 *  the dumps base URL. */
 type StreamsDumpFile = {
-	path: string
-	from_block: number
-	to_block: number
-	min_cursor: string | null
-	max_cursor: string | null
-	row_count: number
-	byte_size: number
-	sha256: string
-	schema_version: number
-	created_at: string
+	path: string;
+	from_block: number;
+	to_block: number;
+	min_cursor: string | null;
+	max_cursor: string | null;
+	row_count: number;
+	byte_size: number;
+	sha256: string;
+	schema_version: number;
+	created_at: string;
 };
 type StreamsDumpsManifest = {
-	dataset: string
-	network: string
-	version: string
-	schema_version: number
-	generated_at: string
-	producer_version: string
-	finality_lag_blocks: number
+	dataset: string;
+	network: string;
+	version: string;
+	schema_version: number;
+	generated_at: string;
+	producer_version: string;
+	finality_lag_blocks: number;
 	/** Cursor at the end of the finalized bulk coverage — hand to live tailing. */
-	latest_finalized_cursor: string | null
+	latest_finalized_cursor: string | null;
 	coverage: {
-		from_block: number
-		to_block: number
-	}
-	files: StreamsDumpFile[]
+		from_block: number;
+		to_block: number;
+	};
+	files: StreamsDumpFile[];
 	/** ed25519 signature over the manifest's canonical bytes. Absent on legacy
 	*  unsigned manifests. Verified by `list()` when `verifyDumpsManifest` is on. */
-	signature?: string
+	signature?: string;
 	/** Short id of the signing public key. */
-	key_id?: string
+	key_id?: string;
 };
 type StreamsDumps = {
 	/** Fetch and parse the latest dumps manifest. */
-	list(): Promise<StreamsDumpsManifest>
+	list(): Promise<StreamsDumpsManifest>;
 	/** Absolute URL for a manifest file. */
-	fileUrl(file: StreamsDumpFile): string
+	fileUrl(file: StreamsDumpFile): string;
 	/** Download a parquet file and verify its sha256 against the manifest. */
-	download(file: StreamsDumpFile): Promise<Uint8Array>
+	download(file: StreamsDumpFile): Promise<Uint8Array>;
 };
 type StreamsClient = {
 	/**
@@ -874,10 +965,19 @@ type StreamsClient = {
 	* rewound automatically — use `events.consume` with `onReorg` for managed
 	* rollback semantics.
 	*/
-	consume(params?: StreamsConsumeParams): AsyncIterableIterator<StreamsBatch>
+	/** Narrowing overload: a literal `types` array narrows every batch's
+	*  event union to exactly those members. */
+	consume<const T extends readonly StreamsEventType[]>(params: StreamsConsumeParams & {
+		types: T;
+	}): AsyncIterableIterator<StreamsBatch<StreamsEventOfTypes<T>>>;
+	consume(params?: StreamsConsumeParams): AsyncIterableIterator<StreamsBatch>;
 	events: {
-		list(params?: StreamsEventsListParams): Promise<StreamsEventsEnvelope>
-		byTxId(txId: string): Promise<StreamsEventsListEnvelope>
+		/** Narrowing overload, matching `consume`. */
+		list<const T extends readonly StreamsEventType[]>(params: StreamsEventsListParams & {
+			types: T;
+		}): Promise<StreamsEventsEnvelope<StreamsEventOfTypes<T>>>;
+		list(params?: StreamsEventsListParams): Promise<StreamsEventsEnvelope>;
+		byTxId(txId: string): Promise<StreamsEventsListEnvelope>;
 		/**
 		* Pull pages from Streams and call `onBatch` after each page.
 		*
@@ -892,8 +992,8 @@ type StreamsClient = {
 			TTx = never,
 			D extends boolean = false
 		>(params: StreamsEventsConsumeParams<TTx, D, F> & {
-			sink?: ConsumerSink<TTx>
-		}): Promise<StreamsEventsConsumeResult>
+			sink?: ConsumerSink<TTx>;
+		}): Promise<StreamsEventsConsumeResult>;
 		/**
 		* Backfill from bulk dumps, then continue live from the dump→live seam in
 		* one call. Iterates finalized dump files (via `onDumpFile`) in block
@@ -901,7 +1001,7 @@ type StreamsClient = {
 		* (exclusive input → no gap or duplicate at the seam). Requires
 		* `dumpsBaseUrl`.
 		*/
-		replay(params: StreamsEventsReplayParams): Promise<StreamsEventsConsumeResult>
+		replay(params: StreamsEventsReplayParams): Promise<StreamsEventsConsumeResult>;
 		/**
 		* Follow Streams as an async iterator.
 		*
@@ -909,39 +1009,43 @@ type StreamsClient = {
 		* indefinitely by default and stops when its `AbortSignal`, `maxPages`, or
 		* `maxEmptyPolls` stops it.
 		*/
-		stream(params?: StreamsEventsStreamParams): AsyncIterable<StreamsEvent>
+		/** Narrowing overload, matching `consume`. */
+		stream<const T extends readonly StreamsEventType[]>(params: StreamsEventsStreamParams & {
+			types: T;
+		}): AsyncIterable<StreamsEventOfTypes<T>>;
+		stream(params?: StreamsEventsStreamParams): AsyncIterable<StreamsEvent>;
 		/**
 		* Subscribe to the real-time SSE push surface. Calls `onEvent` for each new
 		* canonical event as the server pushes it (chain cadence, not poll-bounded),
 		* and verifies each frame's inline ed25519 signature when the client was
 		* created with `verify`. Returns an unsubscribe function.
 		*/
-		subscribe(params: StreamsEventsSubscribeParams): () => void
-	}
+		subscribe(params: StreamsEventsSubscribeParams): () => void;
+	};
 	blocks: {
-		events(heightOrHash: number | string): Promise<StreamsEventsListEnvelope>
-	}
+		events(heightOrHash: number | string): Promise<StreamsEventsListEnvelope>;
+	};
 	reorgs: {
-		list(params: StreamsReorgsListParams): Promise<StreamsReorgsListEnvelope>
-	}
+		list(params: StreamsReorgsListParams): Promise<StreamsReorgsListEnvelope>;
+	};
 	/** Bulk parquet dumps. Requires `dumpsBaseUrl` on the client. */
-	dumps: StreamsDumps
-	canonical(height: number): Promise<StreamsCanonicalBlock>
-	tip(): Promise<StreamsTip>
+	dumps: StreamsDumps;
+	canonical(height: number): Promise<StreamsCanonicalBlock>;
+	tip(): Promise<StreamsTip>;
 	/** Your own Streams consumption (events today + this month) and tier limits. */
-	usage(): Promise<StreamsUsage>
+	usage(): Promise<StreamsUsage>;
 };
 type StreamsUsage = {
-	product: "streams"
-	tier: string
+	product: "streams";
+	tier: string;
 	limits: {
-		rate_limit_per_second: number | null
-		retention_days: number | null
-	}
+		rate_limit_per_second: number | null;
+		retention_days: number | null;
+	};
 	usage: {
-		events_today: number
-		events_this_month: number
-	}
+		events_today: number;
+		events_this_month: number;
+	};
 };
 type Sleep = (ms: number, signal?: AbortSignal) => Promise<void>;
 /** Options shared by both consume loops' page-fetch retry. Vocabulary matches
@@ -949,28 +1053,28 @@ type Sleep = (ms: number, signal?: AbortSignal) => Promise<void>;
 *  language across the family, not a third. */
 type PageRetryOptions = {
 	/** Retries after the first failure. Default 3; `0` disables. */
-	retryCount?: number
+	retryCount?: number;
 	/** Base delay in ms; the n-th retry waits `retryDelay * n` (matches the
 	*  stacks transport). A server `Retry-After` overrides it. Default 1000. */
-	retryDelay?: number
+	retryDelay?: number;
 	/** Void observer, called before each retry sleep (metrics/logging). The
 	*  retry policy owns the decision; this cannot change it. */
 	onError?: (err: unknown, ctx: {
-		attempt: number
-		retriesLeft: number
-		delayMs: number
-	}) => void
+		attempt: number;
+		retriesLeft: number;
+		delayMs: number;
+	}) => void;
 };
 /** Minimum shape a consumed Index row must expose. */
 type IndexFeedItem = {
-	cursor: string
-	block_height: number
+	cursor: string;
+	block_height: number;
 };
 /** Minimum envelope shape of a consumable Index feed page. */
 type IndexFeedEnvelope = {
-	next_cursor: string | null
-	tip: IndexTip
-	reorgs: IndexReorg[]
+	next_cursor: string | null;
+	tip: IndexTip;
+	reorgs: IndexReorg[];
 };
 /** Consumer options shared by `index.events.consume` and
 *  `index.contractCalls.consume`. Same contract as the Streams consumer:
@@ -983,18 +1087,18 @@ type IndexConsumeOptions<
 > = {
 	/** Resume from a committed checkpoint. Without it (and without
 	*  `fromHeight`) the API serves only the recent default window. */
-	fromCursor?: string | null
+	fromCursor?: string | null;
 	/** Start a fresh sweep at this height (e.g. `0` for genesis backfill).
 	*  Ignored once a cursor exists (including a sink's committed cursor). */
-	fromHeight?: number
+	fromHeight?: number;
 	/** `tail` (default) keeps polling at the tip; `bounded` returns on the
 	*  first empty page. */
-	mode?: "tail" | "bounded"
+	mode?: "tail" | "bounded";
 	/** Emit only rows at or below the tip's `finalized_height`; the
 	*  unfinalized tail is re-read each poll until it settles. Finalized data
 	*  never reorgs, so `onReorg` is skipped entirely. */
-	finalizedOnly?: boolean
-	batchSize?: number
+	finalizedOnly?: boolean;
+	batchSize?: number;
 	/**
 	* Destination adapter that owns the checkpoint + rollback transaction
 	* (e.g. `kyselySink` from `@secondlayer/sdk/sinks/kysely`). With a sink:
@@ -1003,37 +1107,37 @@ type IndexConsumeOptions<
 	* transaction — a throw aborts both), reorg rollback is automatic (no
 	* `onReorg` needed), and `onBatch`'s return value is ignored.
 	*/
-	sink?: ConsumerSink<TTx>
+	sink?: ConsumerSink<TTx>;
 	/** Fires once per page, before `onBatch` and before any early return —
 	*  an empty page still proves the loop is alive. Feed it to
 	*  `consumerHealth().record`. */
-	onProgress?: (ctx: ConsumerBatchContext) => void
-	onBatch: (items: TItem[], envelope: TEnvelope, ctx: ConsumerBatchContext & WithSinkTx<TTx>) => void | string | null | undefined | Promise<void> | Promise<string | null | undefined>
+	onProgress?: (ctx: ConsumerBatchContext) => void;
+	onBatch: (items: TItem[], envelope: TEnvelope, ctx: ConsumerBatchContext & WithSinkTx<TTx>) => void | string | null | undefined | Promise<void> | Promise<string | null | undefined>;
 	onReorg?: (reorg: IndexReorg, ctx: {
-		cursor: string
-	}) => Promise<void> | void
-	sleep?: Sleep
-	emptyBackoffMs?: number
-	maxPages?: number
-	maxEmptyPolls?: number
-	signal?: AbortSignal
+		cursor: string;
+	}) => Promise<void> | void;
+	sleep?: Sleep;
+	emptyBackoffMs?: number;
+	maxPages?: number;
+	maxEmptyPolls?: number;
+	signal?: AbortSignal;
 	/** Page-fetch retries after the first failure (429/5xx/network only —
 	*  4xx and handler throws always propagate). Default 3; `0` disables. */
-	retryCount?: number
+	retryCount?: number;
 	/** Base retry delay in ms; the n-th retry waits `retryDelay * n`. A server
 	*  `Retry-After` overrides it. Default 1000. */
-	retryDelay?: number
+	retryDelay?: number;
 	/** Void observer, called before each retry sleep. Cannot change the retry
 	*  decision — the policy owns it. */
-	onError?: PageRetryOptions["onError"]
+	onError?: PageRetryOptions["onError"];
 };
 type IndexTip = {
-	block_height: number
+	block_height: number;
 	/** Highest height treated as immutable (past the burn-confirmation
 	*  finality boundary). Rows at or below it never reorg — `finalizedOnly`
 	*  consumers gate on this, since Index rows carry no per-event flag. */
-	finalized_height: number
-	lag_seconds: number
+	finalized_height: number;
+	lag_seconds: number;
 };
 /**
 * A chain reorg overlapping a returned page's height range. Height-keyed feeds
@@ -1046,54 +1150,54 @@ type IndexTip = {
 * inclusive. Empty when the page spans no reorg.
 */
 type IndexReorg = {
-	id: string
-	detected_at: string
-	fork_point_height: number
-	old_index_block_hash: string | null
-	new_index_block_hash: string | null
+	id: string;
+	detected_at: string;
+	fork_point_height: number;
+	old_index_block_hash: string | null;
+	new_index_block_hash: string | null;
 	/** Orphaned cursor span `<block_height>:<tx_index>`, inclusive. */
 	orphaned_range: {
-		from: string
-		to: string
-	}
+		from: string;
+		to: string;
+	};
 	/**
 	* First position of the new canonical chain at the fork, `fork:0`
 	* (INCLUSIVE). Not an exclusive resume token — resuming a `(bh,ei) > cursor`
 	* read directly from it would skip `fork:0`. To re-read the new run, rewind
 	* to the foot of `fork_point_height` (`Cursor.atHeight`), not to this value.
 	*/
-	new_canonical_tip: string
+	new_canonical_tip: string;
 };
 type IndexUsage = {
-	product: "index"
-	tier: string
+	product: "index";
+	tier: string;
 	limits: {
-		rate_limit_per_second: number | null
-	}
+		rate_limit_per_second: number | null;
+	};
 	usage: {
-		decoded_events_today: number
-		decoded_events_this_month: number
-	}
+		decoded_events_today: number;
+		decoded_events_this_month: number;
+	};
 };
 type FtTransfer = {
-	cursor: string
-	block_height: number
-	block_time?: string | null
-	tx_id: string
-	tx_index: number
-	event_index: number
-	event_type: "ft_transfer"
-	contract_id: string
-	asset_identifier: string
-	sender: string
-	recipient: string
-	amount: string
+	cursor: string;
+	block_height: number;
+	block_time?: string | null;
+	tx_id: string;
+	tx_index: number;
+	event_index: number;
+	event_type: "ft_transfer";
+	contract_id: string;
+	asset_identifier: string;
+	sender: string;
+	recipient: string;
+	amount: string;
 };
 type FtTransfersEnvelope<TRow = FtTransfer> = {
-	events: TRow[]
-	next_cursor: string | null
-	tip: IndexTip
-	reorgs: IndexReorg[]
+	events: TRow[];
+	next_cursor: string | null;
+	tip: IndexTip;
+	reorgs: IndexReorg[];
 };
 /** Transfer columns that survive any projection — the consume contract
 *  (`cursor`, `block_height`) plus the `event_type` discriminant. */
@@ -1107,40 +1211,40 @@ type FtTransfersListParams = {
 	* one a compile error rather than `undefined` at runtime. Omitting
 	* `block_time` also lets the server skip the blocks join.
 	*/
-	fields?: readonly (keyof FtTransfer & string)[]
-	cursor?: string | null
-	fromCursor?: string | null
-	limit?: number
-	contractId?: string
-	assetIdentifier?: string
-	sender?: string
-	recipient?: string
-	fromHeight?: number
-	toHeight?: number
+	fields?: readonly (keyof FtTransfer & string)[];
+	cursor?: string | null;
+	fromCursor?: string | null;
+	limit?: number;
+	contractId?: string;
+	assetIdentifier?: string;
+	sender?: string;
+	recipient?: string;
+	fromHeight?: number;
+	toHeight?: number;
 };
 type FtTransfersWalkParams = Omit<FtTransfersListParams, "limit"> & {
-	batchSize?: number
-	signal?: AbortSignal
+	batchSize?: number;
+	signal?: AbortSignal;
 };
 type NftTransfer = {
-	cursor: string
-	block_height: number
-	block_time?: string | null
-	tx_id: string
-	tx_index: number
-	event_index: number
-	event_type: "nft_transfer"
-	contract_id: string
-	asset_identifier: string
-	sender: string
-	recipient: string
-	value: string
+	cursor: string;
+	block_height: number;
+	block_time?: string | null;
+	tx_id: string;
+	tx_index: number;
+	event_index: number;
+	event_type: "nft_transfer";
+	contract_id: string;
+	asset_identifier: string;
+	sender: string;
+	recipient: string;
+	value: string;
 };
 type NftTransfersEnvelope<TRow = NftTransfer> = {
-	events: TRow[]
-	next_cursor: string | null
-	tip: IndexTip
-	reorgs: IndexReorg[]
+	events: TRow[];
+	next_cursor: string | null;
+	tip: IndexTip;
+	reorgs: IndexReorg[];
 };
 /** See {@link FtTransferAlwaysFields}. */
 type NftTransferAlwaysFields = "cursor" | "block_height" | "event_type";
@@ -1148,110 +1252,110 @@ type NftTransferAlwaysFields = "cursor" | "block_height" | "event_type";
 type NftTransferFields<F extends keyof NftTransfer & string> = Pick<NftTransfer, (F | NftTransferAlwaysFields) & keyof NftTransfer>;
 type NftTransfersListParams = {
 	/** Columns to return (see {@link FtTransfersListParams.fields}). */
-	fields?: readonly (keyof NftTransfer & string)[]
-	cursor?: string | null
-	fromCursor?: string | null
-	limit?: number
-	contractId?: string
-	assetIdentifier?: string
-	sender?: string
-	recipient?: string
-	fromHeight?: number
-	toHeight?: number
+	fields?: readonly (keyof NftTransfer & string)[];
+	cursor?: string | null;
+	fromCursor?: string | null;
+	limit?: number;
+	contractId?: string;
+	assetIdentifier?: string;
+	sender?: string;
+	recipient?: string;
+	fromHeight?: number;
+	toHeight?: number;
 };
 type NftTransfersWalkParams = Omit<NftTransfersListParams, "limit"> & {
-	batchSize?: number
-	signal?: AbortSignal
+	batchSize?: number;
+	signal?: AbortSignal;
 };
 type IndexEventBase = {
-	cursor: string
-	block_height: number
-	block_time?: string | null
-	tx_id: string
-	tx_index: number
-	event_index: number
-	contract_id: string | null
+	cursor: string;
+	block_height: number;
+	block_time?: string | null;
+	tx_id: string;
+	tx_index: number;
+	event_index: number;
+	contract_id: string | null;
 	/** Submitting-transaction context, present only when `txContext: true` was
 	*  requested. `tx_sender` is the real tx sender — distinct from a transfer's
 	*  asset `sender`, and the only place a `print` event's sender is available.
 	*  Lets a consumer build per-event tx context without a `/v1/index/transactions`
 	*  call per event. */
-	tx_sender?: string | null
-	tx_type?: string | null
-	tx_status?: string | null
-	tx_contract_id?: string | null
-	tx_function_name?: string | null
+	tx_sender?: string | null;
+	tx_type?: string | null;
+	tx_status?: string | null;
+	tx_contract_id?: string | null;
+	tx_function_name?: string | null;
 };
 type IndexFtTransfer = IndexEventBase & {
-	event_type: "ft_transfer"
-	asset_identifier: string
-	sender: string
-	recipient: string
-	amount: string
+	event_type: "ft_transfer";
+	asset_identifier: string;
+	sender: string;
+	recipient: string;
+	amount: string;
 };
 type IndexNftTransfer = IndexEventBase & {
-	event_type: "nft_transfer"
-	asset_identifier: string
-	sender: string
-	recipient: string
-	value: string
+	event_type: "nft_transfer";
+	asset_identifier: string;
+	sender: string;
+	recipient: string;
+	value: string;
 };
 type IndexStxTransfer = IndexEventBase & {
-	event_type: "stx_transfer"
-	sender: string
-	recipient: string
-	amount: string
-	memo: string | null
+	event_type: "stx_transfer";
+	sender: string;
+	recipient: string;
+	amount: string;
+	memo: string | null;
 };
 type IndexStxMint = IndexEventBase & {
-	event_type: "stx_mint"
-	recipient: string
-	amount: string
+	event_type: "stx_mint";
+	recipient: string;
+	amount: string;
 };
 type IndexStxBurn = IndexEventBase & {
-	event_type: "stx_burn"
-	sender: string
-	amount: string
+	event_type: "stx_burn";
+	sender: string;
+	amount: string;
 };
 type IndexStxLock = IndexEventBase & {
-	event_type: "stx_lock"
-	sender: string
-	amount: string
+	event_type: "stx_lock";
+	sender: string;
+	amount: string;
 	payload: {
-		unlock_height: string | null
-	}
+		unlock_height: string | null;
+	};
 };
 type IndexFtMint = IndexEventBase & {
-	event_type: "ft_mint"
-	asset_identifier: string
-	recipient: string
-	amount: string
+	event_type: "ft_mint";
+	asset_identifier: string;
+	recipient: string;
+	amount: string;
 };
 type IndexFtBurn = IndexEventBase & {
-	event_type: "ft_burn"
-	asset_identifier: string
-	sender: string
-	amount: string
+	event_type: "ft_burn";
+	asset_identifier: string;
+	sender: string;
+	amount: string;
 };
 type IndexNftMint = IndexEventBase & {
-	event_type: "nft_mint"
-	asset_identifier: string
-	recipient: string
-	value: string
+	event_type: "nft_mint";
+	asset_identifier: string;
+	recipient: string;
+	value: string;
 };
 type IndexNftBurn = IndexEventBase & {
-	event_type: "nft_burn"
-	asset_identifier: string
-	sender: string
-	value: string
+	event_type: "nft_burn";
+	asset_identifier: string;
+	sender: string;
+	value: string;
 };
 type IndexPrint = IndexEventBase & {
-	event_type: "print"
+	event_type: "print";
 	payload: {
-		topic: string | null
-		value: unknown
-		raw_value: string | null
-	}
+		topic: string | null;
+		value: unknown;
+		raw_value: string | null;
+	};
 };
 /** Decoded chain event, discriminated by `event_type`. */
 type IndexEvent = IndexFtTransfer | IndexNftTransfer | IndexStxTransfer | IndexStxMint | IndexStxBurn | IndexStxLock | IndexFtMint | IndexFtBurn | IndexNftMint | IndexNftBurn | IndexPrint;
@@ -1268,39 +1372,39 @@ type EventsEnvelope<
 	T extends IndexEventType = IndexEventType,
 	TRow = IndexEventOf<T>
 > = {
-	events: TRow[]
-	next_cursor: string | null
-	tip: IndexTip
-	reorgs: IndexReorg[]
+	events: TRow[];
+	next_cursor: string | null;
+	tip: IndexTip;
+	reorgs: IndexReorg[];
 };
 /** The single decoded-event member matching one `event_type` literal.
 *  `IndexEventOf<"ft_transfer">` is `IndexFtTransfer`. */
 type IndexEventOf<T extends IndexEventType> = Extract<IndexEvent, {
-	event_type: T
+	event_type: T;
 }>;
 type EventsListParams<T extends IndexEventType = IndexEventType> = {
 	/** Required. One of the decoded event types. Passing a literal narrows the
 	*  rows every surface hands back to that event's own shape. */
-	eventType: T
-	cursor?: string | null
-	fromCursor?: string | null
-	limit?: number
+	eventType: T;
+	cursor?: string | null;
+	fromCursor?: string | null;
+	limit?: number;
 	/** One id, or several to scope the sweep to a set of contracts (max 20).
 	*  Mutually exclusive with `trait`. */
-	contractId?: string | readonly string[]
-	assetIdentifier?: string
-	sender?: string
-	recipient?: string
-	fromHeight?: number
-	toHeight?: number
+	contractId?: string | readonly string[];
+	assetIdentifier?: string;
+	sender?: string;
+	recipient?: string;
+	fromHeight?: number;
+	toHeight?: number;
 	/** Restrict to contracts conforming to a trait/standard (e.g. "sip-010").
 	*  Mutually exclusive with contractId; contract-keyed event types only. */
-	trait?: string
+	trait?: string;
 	/** Join the submitting transaction into each event — populates `tx_sender`,
 	*  `tx_type`, `tx_status`, `tx_contract_id`, `tx_function_name`. Off by default.
 	*  Avoids a `/v1/index/transactions` call per event; for `print` events it's
 	*  the only source of the submitting sender. */
-	txContext?: boolean
+	txContext?: boolean;
 	/**
 	* Return only these columns. The server projects the SELECT, so an
 	* unrequested field is physically absent — and the returned row type
@@ -1315,188 +1419,188 @@ type EventsListParams<T extends IndexEventType = IndexEventType> = {
 	* not per field. What it buys is wire bytes, plus skipping the `blocks`
 	* join when `block_time` is omitted.
 	*/
-	fields?: readonly (keyof IndexEventOf<T> & string)[]
+	fields?: readonly (keyof IndexEventOf<T> & string)[];
 };
 type EventsWalkParams<T extends IndexEventType = IndexEventType> = Omit<EventsListParams<T>, "limit"> & {
-	batchSize?: number
-	signal?: AbortSignal
+	batchSize?: number;
+	signal?: AbortSignal;
 };
 type EventsConsumeParams<
 	T extends IndexEventType = IndexEventType,
 	TTx = never
 > = Omit<EventsListParams<T>, "cursor" | "fromCursor" | "limit" | "fields"> & IndexConsumeOptions<IndexEventOf<T>, EventsEnvelope<T>, TTx>;
 type IndexContractCall = {
-	cursor: string
-	block_height: number
-	block_time?: string | null
-	tx_id: string
-	tx_index: number
-	contract_id: string
-	function_name: string
-	sender: string
-	status: string
-	args: unknown[]
-	result: unknown
-	result_hex: string | null
+	cursor: string;
+	block_height: number;
+	block_time?: string | null;
+	tx_id: string;
+	tx_index: number;
+	contract_id: string;
+	function_name: string;
+	sender: string;
+	status: string;
+	args: unknown[];
+	result: unknown;
+	result_hex: string | null;
 };
 type ContractCallsEnvelope = {
-	contract_calls: IndexContractCall[]
-	next_cursor: string | null
-	tip: IndexTip
-	reorgs: IndexReorg[]
+	contract_calls: IndexContractCall[];
+	next_cursor: string | null;
+	tip: IndexTip;
+	reorgs: IndexReorg[];
 };
 type ContractCallsListParams = {
-	cursor?: string | null
-	fromCursor?: string | null
-	limit?: number
+	cursor?: string | null;
+	fromCursor?: string | null;
+	limit?: number;
 	/** One id, or several to scope the sweep to a set of contracts (max 20).
 	*  Mutually exclusive with `trait`. */
-	contractId?: string | readonly string[]
-	functionName?: string
-	sender?: string
-	fromHeight?: number
-	toHeight?: number
+	contractId?: string | readonly string[];
+	functionName?: string;
+	sender?: string;
+	fromHeight?: number;
+	toHeight?: number;
 	/** Restrict to contracts conforming to a trait/standard (e.g. "sip-010").
 	*  Mutually exclusive with contractId. */
-	trait?: string
+	trait?: string;
 };
 type ContractCallsWalkParams = Omit<ContractCallsListParams, "limit"> & {
-	batchSize?: number
-	signal?: AbortSignal
+	batchSize?: number;
+	signal?: AbortSignal;
 };
 type ContractCallsConsumeParams<TTx = never> = Omit<ContractCallsListParams, "cursor" | "fromCursor" | "limit"> & IndexConsumeOptions<IndexContractCall, ContractCallsEnvelope, TTx>;
 /** One canonical block in the sync map. Lean by design — block + parent hash
 *  for chain linkage, burn anchor for Bitcoin confirmations. Use `blocks` for
 *  the full block resource. */
 type IndexCanonicalBlock = {
-	cursor: string
-	block_height: number
-	block_hash: string
-	parent_hash: string
-	burn_block_height: number
-	burn_block_hash: string | null
+	cursor: string;
+	block_height: number;
+	block_hash: string;
+	parent_hash: string;
+	burn_block_height: number;
+	burn_block_hash: string | null;
 };
 type CanonicalEnvelope = {
-	canonical: IndexCanonicalBlock[]
-	next_cursor: string | null
-	tip: IndexTip
+	canonical: IndexCanonicalBlock[];
+	next_cursor: string | null;
+	tip: IndexTip;
 };
 type CanonicalListParams = {
-	cursor?: string | null
-	fromCursor?: string | null
-	limit?: number
-	fromHeight?: number
-	toHeight?: number
+	cursor?: string | null;
+	fromCursor?: string | null;
+	limit?: number;
+	fromHeight?: number;
+	toHeight?: number;
 };
 type CanonicalWalkParams = Omit<CanonicalListParams, "limit"> & {
-	batchSize?: number
-	signal?: AbortSignal
+	batchSize?: number;
+	signal?: AbortSignal;
 };
 /** A block resource. Metadata is intentionally thin — only chain-linkage and
 *  burn-anchor fields are persisted (no miner / tx_count / signer). */
 type IndexBlock = {
-	cursor: string
-	block_height: number
-	block_hash: string
-	parent_hash: string
-	burn_block_height: number
-	burn_block_hash: string | null
-	block_time: string | null
-	canonical: boolean
+	cursor: string;
+	block_height: number;
+	block_hash: string;
+	parent_hash: string;
+	burn_block_height: number;
+	burn_block_hash: string | null;
+	block_time: string | null;
+	canonical: boolean;
 };
 type BlocksEnvelope = {
-	blocks: IndexBlock[]
-	next_cursor: string | null
-	tip: IndexTip
+	blocks: IndexBlock[];
+	next_cursor: string | null;
+	tip: IndexTip;
 };
 type BlockEnvelope = {
-	block: IndexBlock
-	tip: IndexTip
+	block: IndexBlock;
+	tip: IndexTip;
 };
 type BlocksListParams = {
-	cursor?: string | null
-	fromCursor?: string | null
-	limit?: number
-	fromHeight?: number
-	toHeight?: number
+	cursor?: string | null;
+	fromCursor?: string | null;
+	limit?: number;
+	fromHeight?: number;
+	toHeight?: number;
 };
 type BlocksWalkParams = Omit<BlocksListParams, "limit"> & {
-	batchSize?: number
-	signal?: AbortSignal
+	batchSize?: number;
+	signal?: AbortSignal;
 };
 type IndexPostCondition = {
-	type: "stx"
-	principal: string
-	condition_code: number
-	condition_code_name: string | null
-	amount: string
+	type: "stx";
+	principal: string;
+	condition_code: number;
+	condition_code_name: string | null;
+	amount: string;
 } | {
-	type: "ft"
-	principal: string
-	asset_identifier: string
-	condition_code: number
-	condition_code_name: string | null
-	amount: string
+	type: "ft";
+	principal: string;
+	asset_identifier: string;
+	condition_code: number;
+	condition_code_name: string | null;
+	amount: string;
 } | {
-	type: "nft"
-	principal: string
-	asset_identifier: string
-	asset_value: unknown
-	condition_code: number
-	condition_code_name: string | null
+	type: "nft";
+	principal: string;
+	asset_identifier: string;
+	asset_value: unknown;
+	condition_code: number;
+	condition_code_name: string | null;
 };
 /** Full transaction document: columnar fields plus `raw_tx`-decoded enrichment.
 *  Payload sub-objects are present only for the matching `tx_type`; enrichment
 *  fields are null when `raw_tx` isn't decodable (e.g. burnchain ops). */
 type IndexTransaction = {
-	cursor: string
-	tx_id: string
-	block_height: number
-	block_time?: string | null
-	tx_index: number
-	tx_type: string
-	sender: string
-	status: string
-	fee: string | null
-	nonce: string | null
-	sponsored: boolean | null
-	anchor_mode: string | null
-	post_condition_mode: string | null
-	post_conditions: IndexPostCondition[]
+	cursor: string;
+	tx_id: string;
+	block_height: number;
+	block_time?: string | null;
+	tx_index: number;
+	tx_type: string;
+	sender: string;
+	status: string;
+	fee: string | null;
+	nonce: string | null;
+	sponsored: boolean | null;
+	anchor_mode: string | null;
+	post_condition_mode: string | null;
+	post_conditions: IndexPostCondition[];
 	contract_call?: {
-		contract_id: string
-		function_name: string
-		function_args: unknown[]
+		contract_id: string;
+		function_name: string;
+		function_args: unknown[];
 		/** Raw hex-encoded ClarityValues; decode(function_args_hex[i]) === function_args[i]. */
-		function_args_hex: string[]
-		result: unknown
-		result_hex: string | null
-	}
+		function_args_hex: string[];
+		result: unknown;
+		result_hex: string | null;
+	};
 	token_transfer?: {
-		recipient: string
-		amount: string
-		memo: string
-	}
+		recipient: string;
+		amount: string;
+		memo: string;
+	};
 	smart_contract?: {
-		contract_id: string | null
-		clarity_version: number | null
-	}
+		contract_id: string | null;
+		clarity_version: number | null;
+	};
 	coinbase?: {
-		alt_recipient: string | null
-	}
+		alt_recipient: string | null;
+	};
 	tenure_change?: {
-		cause: number
-	}
+		cause: number;
+	};
 };
 type TransactionsEnvelope<TRow = IndexTransaction> = {
-	transactions: TRow[]
-	next_cursor: string | null
-	tip: IndexTip
-	reorgs: IndexReorg[]
+	transactions: TRow[];
+	next_cursor: string | null;
+	tip: IndexTip;
+	reorgs: IndexReorg[];
 };
 type TransactionEnvelope = {
-	transaction: IndexTransaction
-	tip: IndexTip
+	transaction: IndexTransaction;
+	tip: IndexTip;
 };
 /** Transaction columns that survive any projection. */
 type TransactionAlwaysFields = "cursor" | "block_height" | "tx_id";
@@ -1508,123 +1612,123 @@ type TransactionsListParams = {
 	* is physically absent — and the narrowing overload on `list` makes reading
 	* one a compile error rather than `undefined` at runtime.
 	*/
-	fields?: readonly (keyof IndexTransaction & string)[]
-	cursor?: string | null
-	fromCursor?: string | null
-	limit?: number
-	type?: string
-	sender?: string
-	contractId?: string
-	fromHeight?: number
-	toHeight?: number
+	fields?: readonly (keyof IndexTransaction & string)[];
+	cursor?: string | null;
+	fromCursor?: string | null;
+	limit?: number;
+	type?: string;
+	sender?: string;
+	contractId?: string;
+	fromHeight?: number;
+	toHeight?: number;
 };
 type TransactionsWalkParams = Omit<TransactionsListParams, "limit"> & {
-	batchSize?: number
-	signal?: AbortSignal
+	batchSize?: number;
+	signal?: AbortSignal;
 };
 /** A decoded PoX-4 stacking action (one per stacking contract call). */
 type IndexStackingAction = {
-	cursor: string
-	block_height: number
-	block_time?: string | null
-	burn_block_height: number
-	tx_id: string
-	tx_index: number
-	function_name: string
-	caller: string
-	stacker: string | null
-	delegate_to: string | null
-	amount_ustx: string | null
-	lock_period: number | null
+	cursor: string;
+	block_height: number;
+	block_time?: string | null;
+	burn_block_height: number;
+	tx_id: string;
+	tx_index: number;
+	function_name: string;
+	caller: string;
+	stacker: string | null;
+	delegate_to: string | null;
+	amount_ustx: string | null;
+	lock_period: number | null;
 	pox_addr: {
-		version: number | null
-		hashbytes: string | null
-		btc: string | null
-	}
-	start_cycle: number | null
-	end_cycle: number | null
-	reward_cycle: number | null
-	signer_key: string | null
-	result_ok: boolean
+		version: number | null;
+		hashbytes: string | null;
+		btc: string | null;
+	};
+	start_cycle: number | null;
+	end_cycle: number | null;
+	reward_cycle: number | null;
+	signer_key: string | null;
+	result_ok: boolean;
 };
 type StackingEnvelope = {
-	stacking: IndexStackingAction[]
-	next_cursor: string | null
-	tip: IndexTip
-	reorgs: IndexReorg[]
+	stacking: IndexStackingAction[];
+	next_cursor: string | null;
+	tip: IndexTip;
+	reorgs: IndexReorg[];
 	/** Present only when the PoX-4 decoder is disabled, explaining an empty feed. */
-	notes?: string
+	notes?: string;
 };
 type StackingListParams = {
-	cursor?: string | null
-	fromCursor?: string | null
-	limit?: number
-	functionName?: string
-	stacker?: string
-	caller?: string
-	fromHeight?: number
-	toHeight?: number
+	cursor?: string | null;
+	fromCursor?: string | null;
+	limit?: number;
+	functionName?: string;
+	stacker?: string;
+	caller?: string;
+	fromHeight?: number;
+	toHeight?: number;
 };
 type StackingWalkParams = Omit<StackingListParams, "limit"> & {
-	batchSize?: number
-	signal?: AbortSignal
+	batchSize?: number;
+	signal?: AbortSignal;
 };
 /** A pending (unconfirmed) transaction. Like a transaction document but
 *  pre-chain — no block_height/tx_index/result/events — with `received_at` and
 *  a sequence cursor instead of a block position. */
 type IndexMempoolTransaction = {
-	cursor: string
-	tx_id: string
-	tx_type: string
-	sender: string
-	received_at?: string | null
-	fee: string | null
-	nonce: string | null
-	sponsored: boolean | null
-	anchor_mode: string | null
-	post_condition_mode: string | null
-	post_conditions: IndexPostCondition[]
+	cursor: string;
+	tx_id: string;
+	tx_type: string;
+	sender: string;
+	received_at?: string | null;
+	fee: string | null;
+	nonce: string | null;
+	sponsored: boolean | null;
+	anchor_mode: string | null;
+	post_condition_mode: string | null;
+	post_conditions: IndexPostCondition[];
 	contract_call?: {
-		contract_id: string
-		function_name: string
-		function_args: unknown[]
-	}
+		contract_id: string;
+		function_name: string;
+		function_args: unknown[];
+	};
 	token_transfer?: {
-		recipient: string
-		amount: string
-		memo: string
-	}
+		recipient: string;
+		amount: string;
+		memo: string;
+	};
 	smart_contract?: {
-		clarity_version: number | null
-	}
+		clarity_version: number | null;
+	};
 	coinbase?: {
-		alt_recipient: string | null
-	}
+		alt_recipient: string | null;
+	};
 	tenure_change?: {
-		cause: number
-	}
+		cause: number;
+	};
 };
 type MempoolEnvelope = {
-	mempool: IndexMempoolTransaction[]
-	next_cursor: string | null
-	tip: IndexTip
+	mempool: IndexMempoolTransaction[];
+	next_cursor: string | null;
+	tip: IndexTip;
 };
 type MempoolTransactionEnvelope = {
-	transaction: IndexMempoolTransaction
-	tip: IndexTip
+	transaction: IndexMempoolTransaction;
+	tip: IndexTip;
 };
 type MempoolListParams = {
-	cursor?: string | null
-	fromCursor?: string | null
-	limit?: number
-	sender?: string
-	type?: string
+	cursor?: string | null;
+	fromCursor?: string | null;
+	limit?: number;
+	sender?: string;
+	type?: string;
 	/** Filter to pending calls to a single contract (e.g. `SP….contract`). */
-	contractId?: string
+	contractId?: string;
 };
 type MempoolWalkParams = Omit<MempoolListParams, "limit"> & {
-	batchSize?: number
-	signal?: AbortSignal
+	batchSize?: number;
+	signal?: AbortSignal;
 };
 /**
 * Empirical per-topic print payload schema for a contract, inferred from
@@ -1632,194 +1736,194 @@ type MempoolWalkParams = Omit<MempoolListParams, "limit"> & {
 * when the contract has more print events than the windows examined.
 */
 type PrintSchemaResponse = {
-	contract_id: string
-	topics: InferredTopicSchema[]
-	sampled: boolean
-	total_events: number
+	contract_id: string;
+	topics: InferredTopicSchema[];
+	sampled: boolean;
+	total_events: number;
 	/** True when the count hit the server-side cap (total_events is the cap). */
-	total_events_capped: boolean
+	total_events_capped: boolean;
 	sample: {
-		size: number
-		newest_height: number | null
-		oldest_height: number | null
-	}
-	tip: IndexTip
+		size: number;
+		newest_height: number | null;
+		oldest_height: number | null;
+	};
+	tip: IndexTip;
 };
 type SbtcWithdrawalStatus = "REQUESTED" | "ACCEPTED" | "REJECTED";
 /** A completed sBTC peg-in, keyed by `bitcoin_txid` (deposits carry no
 *  `request_id`). One terminal `completed-deposit` event per deposit. */
 type IndexSbtcDeposit = {
-	cursor: string
-	block_height: number
-	block_time?: string | null
-	tx_id: string
-	tx_index: number
-	event_index: number
-	amount: string | null
-	sender: string | null
-	bitcoin_txid: string | null
-	output_index: number | null
-	recipient_btc_version: number | null
-	recipient_btc_hashbytes: string | null
+	cursor: string;
+	block_height: number;
+	block_time?: string | null;
+	tx_id: string;
+	tx_index: number;
+	event_index: number;
+	amount: string | null;
+	sender: string | null;
+	bitcoin_txid: string | null;
+	output_index: number | null;
+	recipient_btc_version: number | null;
+	recipient_btc_hashbytes: string | null;
 };
 /** A deposit fetched by Bitcoin txid — always terminal, hence `status`. */
 type IndexSbtcDepositDetail = IndexSbtcDeposit & {
-	status: "COMPLETED"
+	status: "COMPLETED";
 };
 /** A peg-out collapsed to one row per `request_id`, with lifecycle `status`
 *  derived from the latest accept/reject. */
 type IndexSbtcWithdrawal = {
-	cursor: string
-	request_id: number
-	status: SbtcWithdrawalStatus
-	amount: string | null
-	sender: string | null
-	recipient_btc_version: number | null
-	recipient_btc_hashbytes: string | null
-	sweep_txid: string | null
+	cursor: string;
+	request_id: number;
+	status: SbtcWithdrawalStatus;
+	amount: string | null;
+	sender: string | null;
+	recipient_btc_version: number | null;
+	recipient_btc_hashbytes: string | null;
+	sweep_txid: string | null;
 	/** BTC L1 settlement of the committed sweep: true once confirmed, false while
 	*  pending, null when there is no sweep yet (REQUESTED). */
-	settlement_confirmed: boolean | null
+	settlement_confirmed: boolean | null;
 	/** BTC confirmations on the sweep tx, null when no settlement row yet. */
-	btc_confirmations: number | null
+	btc_confirmations: number | null;
 	/** Confirming BTC block height, null while unconfirmed / no sweep. */
-	btc_block_height: number | null
+	btc_block_height: number | null;
 	/** When the sweep crossed the confirmation threshold (ISO), null otherwise. */
-	confirmed_at: string | null
-	requested_at?: string | null
-	resolved_at?: string | null
+	confirmed_at: string | null;
+	requested_at?: string | null;
+	resolved_at?: string | null;
 };
 /** One phase of a withdrawal's lifecycle (the on-Stacks event that drove it). */
 type IndexSbtcWithdrawalPhase = {
-	block_height: number
-	block_time: string | null
-	tx_id: string
+	block_height: number;
+	block_time: string | null;
+	tx_id: string;
 };
 /** A single peg-out's full assembled lifecycle, fetched by `request_id`.
 *  `finalized` is true once terminal and past the reorg margin. */
 type IndexSbtcWithdrawalDetail = {
-	request_id: number
-	status: SbtcWithdrawalStatus
-	amount: string | null
-	sender: string | null
-	recipient_btc_version: number | null
-	recipient_btc_hashbytes: string | null
-	requested: IndexSbtcWithdrawalPhase
+	request_id: number;
+	status: SbtcWithdrawalStatus;
+	amount: string | null;
+	sender: string | null;
+	recipient_btc_version: number | null;
+	recipient_btc_hashbytes: string | null;
+	requested: IndexSbtcWithdrawalPhase;
 	accepted: (IndexSbtcWithdrawalPhase & {
-		sweep_txid: string | null
-		signer_bitmap: string | null
-	}) | null
-	rejected: IndexSbtcWithdrawalPhase | null
+		sweep_txid: string | null;
+		signer_bitmap: string | null;
+	}) | null;
+	rejected: IndexSbtcWithdrawalPhase | null;
 	settlement: {
-		sweep_txid: string | null
-		btc_confirmations: number | null
-		settlement_confirmed: boolean | null
+		sweep_txid: string | null;
+		btc_confirmations: number | null;
+		settlement_confirmed: boolean | null;
 		/** Confirming Bitcoin block height; null until the sweep confirms. */
-		btc_block_height: number | null
+		btc_block_height: number | null;
 		/** ISO timestamp the sweep first crossed the confirmation threshold. */
-		confirmed_at: string | null
-	}
-	finalized: boolean
+		confirmed_at: string | null;
+	};
+	finalized: boolean;
 };
 /** A raw decoded sBTC protocol-state event — the full `sbtc_events` row, one
 *  per event across all topics. */
 type IndexSbtcEvent = {
-	cursor: string
-	block_height: number
-	block_time?: string | null
-	tx_id: string
-	tx_index: number
-	event_index: number
-	topic: SbtcEventTopic
-	request_id: number | null
-	amount: string | null
-	sender: string | null
-	recipient_btc_version: number | null
-	recipient_btc_hashbytes: string | null
-	bitcoin_txid: string | null
-	output_index: number | null
-	sweep_txid: string | null
-	burn_hash: string | null
-	burn_height: number | null
-	signer_bitmap: string | null
-	max_fee: string | null
-	fee: string | null
-	governance_contract_type: number | null
-	governance_new_contract: string | null
-	signer_aggregate_pubkey: string | null
-	signer_threshold: number | null
-	signer_address: string | null
-	signer_keys_count: number | null
+	cursor: string;
+	block_height: number;
+	block_time?: string | null;
+	tx_id: string;
+	tx_index: number;
+	event_index: number;
+	topic: SbtcEventTopic;
+	request_id: number | null;
+	amount: string | null;
+	sender: string | null;
+	recipient_btc_version: number | null;
+	recipient_btc_hashbytes: string | null;
+	bitcoin_txid: string | null;
+	output_index: number | null;
+	sweep_txid: string | null;
+	burn_hash: string | null;
+	burn_height: number | null;
+	signer_bitmap: string | null;
+	max_fee: string | null;
+	fee: string | null;
+	governance_contract_type: number | null;
+	governance_new_contract: string | null;
+	signer_aggregate_pubkey: string | null;
+	signer_threshold: number | null;
+	signer_address: string | null;
+	signer_keys_count: number | null;
 };
 /** The peg "scoreboard" — a single all-time canonical aggregate. */
 type IndexSbtcSummary = {
-	total_deposits: number
-	total_withdrawals_requested: number
-	total_withdrawals_accepted: number
-	total_withdrawals_rejected: number
-	net_peg_flow_sats: string
-	total_locked_sats: string
-	sbtc_supply_sats: string | null
+	total_deposits: number;
+	total_withdrawals_requested: number;
+	total_withdrawals_accepted: number;
+	total_withdrawals_rejected: number;
+	net_peg_flow_sats: string;
+	total_locked_sats: string;
+	sbtc_supply_sats: string | null;
 };
 type SbtcDepositsEnvelope<TRow = IndexSbtcDeposit> = {
-	deposits: TRow[]
-	next_cursor: string | null
-	tip: IndexTip
-	reorgs: IndexReorg[]
+	deposits: TRow[];
+	next_cursor: string | null;
+	tip: IndexTip;
+	reorgs: IndexReorg[];
 	/** Present only when the sBTC decoder is disabled, explaining an empty feed. */
-	notes?: string
+	notes?: string;
 };
 type SbtcDepositEnvelope = {
-	deposit: IndexSbtcDepositDetail
-	tip: IndexTip
+	deposit: IndexSbtcDepositDetail;
+	tip: IndexTip;
 };
 type SbtcWithdrawalsEnvelope<TRow = IndexSbtcWithdrawal> = {
-	withdrawals: TRow[]
-	next_cursor: string | null
-	tip: IndexTip
-	reorgs: IndexReorg[]
-	notes?: string
+	withdrawals: TRow[];
+	next_cursor: string | null;
+	tip: IndexTip;
+	reorgs: IndexReorg[];
+	notes?: string;
 };
 type SbtcWithdrawalEnvelope = {
-	withdrawal: IndexSbtcWithdrawalDetail
-	tip: IndexTip
+	withdrawal: IndexSbtcWithdrawalDetail;
+	tip: IndexTip;
 };
 type SbtcEventsEnvelope = {
-	events: IndexSbtcEvent[]
-	next_cursor: string | null
-	tip: IndexTip
-	reorgs: IndexReorg[]
-	notes?: string
+	events: IndexSbtcEvent[];
+	next_cursor: string | null;
+	tip: IndexTip;
+	reorgs: IndexReorg[];
+	notes?: string;
 };
 type SbtcSummaryEnvelope = {
-	summary: IndexSbtcSummary
-	tip: IndexTip
-	notes?: string
+	summary: IndexSbtcSummary;
+	tip: IndexTip;
+	notes?: string;
 };
 type SbtcDepositsListParams = {
-	cursor?: string | null
-	fromCursor?: string | null
-	limit?: number
+	cursor?: string | null;
+	fromCursor?: string | null;
+	limit?: number;
 	/** Clamp to the finality boundary — only settled deposits past the reorg margin. */
-	confirmed?: boolean
-	sender?: string
-	bitcoinTxid?: string
-	fromHeight?: number
-	toHeight?: number
+	confirmed?: boolean;
+	sender?: string;
+	bitcoinTxid?: string;
+	fromHeight?: number;
+	toHeight?: number;
 	/**
 	* Columns to return. The server projects the row, so an unrequested column
 	* is physically absent — and the narrowing overload on `list` makes reading
 	* one a compile error rather than `undefined` at runtime.
 	*/
-	fields?: readonly (keyof IndexSbtcDeposit & string)[]
+	fields?: readonly (keyof IndexSbtcDeposit & string)[];
 };
 /** Deposit columns that survive any projection — pagination needs them. */
 type SbtcDepositAlwaysFields = "cursor" | "block_height";
 /** A deposit row narrowed to the requested columns plus the always-present ones. */
 type SbtcDepositFields<F extends keyof IndexSbtcDeposit & string> = Pick<IndexSbtcDeposit, (F | SbtcDepositAlwaysFields) & keyof IndexSbtcDeposit>;
 type SbtcDepositsWalkParams = Omit<SbtcDepositsListParams, "limit"> & {
-	batchSize?: number
-	signal?: AbortSignal
+	batchSize?: number;
+	signal?: AbortSignal;
 };
 /** SbtcWithdrawal columns that survive any projection. */
 type SbtcWithdrawalAlwaysFields = "cursor" | "request_id";
@@ -1831,39 +1935,39 @@ type SbtcWithdrawalsListParams = {
 	* is physically absent — and the narrowing overload on `list` makes reading
 	* one a compile error rather than `undefined` at runtime.
 	*/
-	fields?: readonly (keyof IndexSbtcWithdrawal & string)[]
-	cursor?: string | null
-	fromCursor?: string | null
-	limit?: number
-	confirmed?: boolean
-	status?: SbtcWithdrawalStatus
-	sender?: string
-	requestId?: number
+	fields?: readonly (keyof IndexSbtcWithdrawal & string)[];
+	cursor?: string | null;
+	fromCursor?: string | null;
+	limit?: number;
+	confirmed?: boolean;
+	status?: SbtcWithdrawalStatus;
+	sender?: string;
+	requestId?: number;
 	/** Filter by BTC L1 settlement: true → only confirmed sweeps; false → not
 	*  yet confirmed (pending or no sweep). */
-	settlementConfirmed?: boolean
-	fromHeight?: number
-	toHeight?: number
+	settlementConfirmed?: boolean;
+	fromHeight?: number;
+	toHeight?: number;
 };
 type SbtcWithdrawalsWalkParams = Omit<SbtcWithdrawalsListParams, "limit"> & {
-	batchSize?: number
-	signal?: AbortSignal
+	batchSize?: number;
+	signal?: AbortSignal;
 };
 type SbtcEventsListParams = {
-	cursor?: string | null
-	fromCursor?: string | null
-	limit?: number
-	confirmed?: boolean
-	topic?: SbtcEventTopic
-	sender?: string
-	requestId?: number
-	bitcoinTxid?: string
-	fromHeight?: number
-	toHeight?: number
+	cursor?: string | null;
+	fromCursor?: string | null;
+	limit?: number;
+	confirmed?: boolean;
+	topic?: SbtcEventTopic;
+	sender?: string;
+	requestId?: number;
+	bitcoinTxid?: string;
+	fromHeight?: number;
+	toHeight?: number;
 };
 type SbtcEventsWalkParams = Omit<SbtcEventsListParams, "limit"> & {
-	batchSize?: number
-	signal?: AbortSignal
+	batchSize?: number;
+	signal?: AbortSignal;
 };
 type SbtcEventsConsumeParams<TTx = never> = Omit<SbtcEventsListParams, "cursor" | "fromCursor" | "limit"> & IndexConsumeOptions<IndexSbtcEvent, SbtcEventsEnvelope, TTx>;
 type SbtcDepositsConsumeParams<TTx = never> = Omit<SbtcDepositsListParams, "cursor" | "fromCursor" | "limit"> & IndexConsumeOptions<IndexSbtcDeposit, SbtcDepositsEnvelope, TTx>;
@@ -1874,98 +1978,98 @@ interface SbtcResource {
 		/** Narrowing overload: `fields` shrinks the row type to exactly the
 		*  requested columns plus {@link SbtcDepositAlwaysFields}. */
 		list<const F extends keyof IndexSbtcDeposit & string>(params: SbtcDepositsListParams & {
-			fields: readonly F[]
-		}): Promise<SbtcDepositsEnvelope<SbtcDepositFields<F>>>
-		list(params?: SbtcDepositsListParams): Promise<SbtcDepositsEnvelope>
-		walk(params?: SbtcDepositsWalkParams): AsyncIterable<IndexSbtcDeposit>
+			fields: readonly F[];
+		}): Promise<SbtcDepositsEnvelope<SbtcDepositFields<F>>>;
+		list(params?: SbtcDepositsListParams): Promise<SbtcDepositsEnvelope>;
+		walk(params?: SbtcDepositsWalkParams): AsyncIterable<IndexSbtcDeposit>;
 		/** Checkpointed sweep of completed deposits — append-only, so safe to
 		*  mirror. See {@link IndexConsumeOptions}. */
 		consume<TTx = never>(params: SbtcDepositsConsumeParams<TTx> & {
-			sink?: ConsumerSink<TTx>
+			sink?: ConsumerSink<TTx>;
 		}): Promise<{
-			cursor: string | null
-			pages: number
-			emptyPolls: number
-		}>
+			cursor: string | null;
+			pages: number;
+			emptyPolls: number;
+		}>;
 		/** Fetch a completed deposit by Bitcoin txid; 404 → null. */
-		get(bitcoinTxid: string): Promise<SbtcDepositEnvelope | null>
+		get(bitcoinTxid: string): Promise<SbtcDepositEnvelope | null>;
 	};
 	withdrawals: {
 		/** Narrowing overload: `fields` shrinks the row type to exactly the
 		*  requested columns plus {@link SbtcWithdrawalAlwaysFields}. */
 		list<const F extends keyof IndexSbtcWithdrawal & string>(params: SbtcWithdrawalsListParams & {
-			fields: readonly F[]
-		}): Promise<SbtcWithdrawalsEnvelope<SbtcWithdrawalFields<F>>>
-		list(params?: SbtcWithdrawalsListParams): Promise<SbtcWithdrawalsEnvelope>
-		walk(params?: SbtcWithdrawalsWalkParams): AsyncIterable<IndexSbtcWithdrawal>
+			fields: readonly F[];
+		}): Promise<SbtcWithdrawalsEnvelope<SbtcWithdrawalFields<F>>>;
+		list(params?: SbtcWithdrawalsListParams): Promise<SbtcWithdrawalsEnvelope>;
+		walk(params?: SbtcWithdrawalsWalkParams): AsyncIterable<IndexSbtcWithdrawal>;
 		/** Fetch a withdrawal's full lifecycle by request id; 404 → null. */
-		get(requestId: number): Promise<SbtcWithdrawalEnvelope | null>
+		get(requestId: number): Promise<SbtcWithdrawalEnvelope | null>;
 	};
 	events: {
-		list(params?: SbtcEventsListParams): Promise<SbtcEventsEnvelope>
-		walk(params?: SbtcEventsWalkParams): AsyncIterable<IndexSbtcEvent>
+		list(params?: SbtcEventsListParams): Promise<SbtcEventsEnvelope>;
+		walk(params?: SbtcEventsWalkParams): AsyncIterable<IndexSbtcEvent>;
 		/** Checkpointed sweep of the raw peg event log — append-only across all
 		*  six topics. See {@link IndexConsumeOptions}. */
 		consume<TTx = never>(params: SbtcEventsConsumeParams<TTx> & {
-			sink?: ConsumerSink<TTx>
+			sink?: ConsumerSink<TTx>;
 		}): Promise<{
-			cursor: string | null
-			pages: number
-			emptyPolls: number
-		}>
+			cursor: string | null;
+			pages: number;
+			emptyPolls: number;
+		}>;
 	};
 	/** The peg scoreboard — a single all-time aggregate (no pagination). */
 	summary(): Promise<SbtcSummaryEnvelope>;
 }
 /** Per-function action count within a reward cycle. */
 type IndexPoxFunctionCount = {
-	function_name: string
-	count: number
+	function_name: string;
+	count: number;
 };
 /** Aggregate stats for one PoX reward cycle — distinct from `index.stacking`
 *  (decoded per-call PoX-4 actions); this is the reward-cycle rollup. */
 type IndexPoxCycle = {
-	reward_cycle: number
+	reward_cycle: number;
 	/** Total ustx locked across all stack-* calls in this cycle (bigint-safe string). */
-	total_stacked_ustx: string
-	unique_stackers: number
-	unique_delegators: number
-	action_count: number
-	start_block_height: number
-	end_block_height: number
+	total_stacked_ustx: string;
+	unique_stackers: number;
+	unique_delegators: number;
+	action_count: number;
+	start_block_height: number;
+	end_block_height: number;
 	/** True when this is the latest reward cycle (still accumulating new actions). */
-	is_current: boolean
-	function_breakdown: IndexPoxFunctionCount[]
+	is_current: boolean;
+	function_breakdown: IndexPoxFunctionCount[];
 };
 type PoxCyclesEnvelope = {
-	cycles: IndexPoxCycle[]
+	cycles: IndexPoxCycle[];
 	/** The next `reward_cycle` to page from (cycles descend), or null at the end. */
-	next_cursor: number | null
-	tip: IndexTip
+	next_cursor: number | null;
+	tip: IndexTip;
 	/** Present only when the PoX-4 decoder is disabled, explaining an empty feed. */
-	notes?: string
+	notes?: string;
 };
 type PoxCycleEnvelope = {
-	cycle: IndexPoxCycle
-	tip: IndexTip
-	notes?: string
+	cycle: IndexPoxCycle;
+	tip: IndexTip;
+	notes?: string;
 };
 type PoxCyclesListParams = {
 	/** A `reward_cycle` to page from; the page returns cycles below it (descending). */
-	cursor?: number | null
-	limit?: number
+	cursor?: number | null;
+	limit?: number;
 };
 type PoxCyclesWalkParams = Omit<PoxCyclesListParams, "limit"> & {
-	batchSize?: number
-	signal?: AbortSignal
+	batchSize?: number;
+	signal?: AbortSignal;
 };
 /** `index.pox` — PoX reward-cycle aggregates. */
 interface PoxResource {
 	cycles: {
-		list(params?: PoxCyclesListParams): Promise<PoxCyclesEnvelope>
-		walk(params?: PoxCyclesWalkParams): AsyncIterable<IndexPoxCycle>
+		list(params?: PoxCyclesListParams): Promise<PoxCyclesEnvelope>;
+		walk(params?: PoxCyclesWalkParams): AsyncIterable<IndexPoxCycle>;
 		/** Fetch one reward cycle's aggregate by number; 404 → null. */
-		get(rewardCycle: number): Promise<PoxCycleEnvelope | null>
+		get(rewardCycle: number): Promise<PoxCycleEnvelope | null>;
 	};
 }
 /** The decoded `pox-5` boot-contract print topics (SIP-045 Bitcoin Staking) —
@@ -1976,37 +2080,37 @@ type IndexPox5EventTopic = Pox5EventTopic;
 *  `data` always carries the full decoded tuple, including nested shapes
 *  (`btc-lockup`, `bond-rewards`, `bond-periods`) that have no flat column. */
 type IndexPox5Event = {
-	cursor: string
-	block_height: number
-	block_time: string | null
-	tx_id: string
-	tx_index: number
-	event_index: number
-	topic: IndexPox5EventTopic
-	staker: string | null
-	signer: string | null
-	signer_manager: string | null
-	bond_index: number | null
+	cursor: string;
+	block_height: number;
+	block_time: string | null;
+	tx_id: string;
+	tx_index: number;
+	event_index: number;
+	topic: IndexPox5EventTopic;
+	staker: string | null;
+	signer: string | null;
+	signer_manager: string | null;
+	bond_index: number | null;
 	/** ustx, bigint-safe string. */
-	amount_ustx: string | null
+	amount_ustx: string | null;
 	/** sats, bigint-safe string. */
-	amount_sats: string | null
-	reward_cycle: number | null
-	first_reward_cycle: number | null
-	unlock_cycle: number | null
-	unlock_burn_height: number | null
-	is_l1_lock: boolean | null
-	signer_key: string | null
+	amount_sats: string | null;
+	reward_cycle: number | null;
+	first_reward_cycle: number | null;
+	unlock_cycle: number | null;
+	unlock_burn_height: number | null;
+	is_l1_lock: boolean | null;
+	signer_key: string | null;
 	/** The full decoded print tuple as JSON. */
-	data: unknown
+	data: unknown;
 };
 type Pox5EventsEnvelope<TRow = IndexPox5Event> = {
-	events: TRow[]
-	next_cursor: string | null
-	tip: IndexTip
-	reorgs: IndexReorg[]
+	events: TRow[];
+	next_cursor: string | null;
+	tip: IndexTip;
+	reorgs: IndexReorg[];
 	/** Present only when the PoX-5 decoder is disabled, explaining an empty feed. */
-	notes?: string
+	notes?: string;
 };
 /** Pox5Event columns that survive any projection. */
 type Pox5EventAlwaysFields = "cursor" | "block_height" | "topic";
@@ -2018,24 +2122,24 @@ type Pox5EventsListParams = {
 	* is physically absent — and the narrowing overload on `list` makes reading
 	* one a compile error rather than `undefined` at runtime.
 	*/
-	fields?: readonly (keyof IndexPox5Event & string)[]
-	cursor?: string | null
-	fromCursor?: string | null
-	limit?: number
+	fields?: readonly (keyof IndexPox5Event & string)[];
+	cursor?: string | null;
+	fromCursor?: string | null;
+	limit?: number;
 	/** Clamp to the finality boundary — only rows past the reorg margin. */
-	confirmed?: boolean
-	topic?: IndexPox5EventTopic
-	staker?: string
-	signer?: string
-	signerManager?: string
-	bondIndex?: number
-	rewardCycle?: number
-	fromHeight?: number
-	toHeight?: number
+	confirmed?: boolean;
+	topic?: IndexPox5EventTopic;
+	staker?: string;
+	signer?: string;
+	signerManager?: string;
+	bondIndex?: number;
+	rewardCycle?: number;
+	fromHeight?: number;
+	toHeight?: number;
 };
 type Pox5EventsWalkParams = Omit<Pox5EventsListParams, "limit"> & {
-	batchSize?: number
-	signal?: AbortSignal
+	batchSize?: number;
+	signal?: AbortSignal;
 };
 /** `index.pox5` — decoded PoX-5 print events, the staking primitive from the
 *  epoch 4.0 hard fork onward (PoX-4's `index.stacking` stream ends there). */
@@ -2044,10 +2148,10 @@ interface Pox5Resource {
 		/** Narrowing overload: `fields` shrinks the row type to exactly the
 		*  requested columns plus {@link Pox5EventAlwaysFields}. */
 		list<const F extends keyof IndexPox5Event & string>(params: Pox5EventsListParams & {
-			fields: readonly F[]
-		}): Promise<Pox5EventsEnvelope<Pox5EventFields<F>>>
-		list(params?: Pox5EventsListParams): Promise<Pox5EventsEnvelope>
-		walk(params?: Pox5EventsWalkParams): AsyncIterable<IndexPox5Event>
+			fields: readonly F[];
+		}): Promise<Pox5EventsEnvelope<Pox5EventFields<F>>>;
+		list(params?: Pox5EventsListParams): Promise<Pox5EventsEnvelope>;
+		walk(params?: Pox5EventsWalkParams): AsyncIterable<IndexPox5Event>;
 	};
 }
 /**
@@ -2061,20 +2165,20 @@ interface FtTransfersResource {
 	/** Narrowing overload for the callable shorthand — same wire path as
 	*  `list`, so it must narrow identically. */
 	<const F extends keyof FtTransfer & string>(params: FtTransfersListParams & {
-		fields: readonly F[]
+		fields: readonly F[];
 	}): Promise<FtTransfersEnvelope<FtTransferFields<F>>>;
 	(params?: FtTransfersListParams): Promise<FtTransfersEnvelope>;
 	/** Narrowing overload: `fields` shrinks the row type to exactly the
 	*  requested columns plus {@link FtTransferAlwaysFields}. */
 	list<const F extends keyof FtTransfer & string>(params: FtTransfersListParams & {
-		fields: readonly F[]
+		fields: readonly F[];
 	}): Promise<FtTransfersEnvelope<FtTransferFields<F>>>;
 	list(params?: FtTransfersListParams): Promise<FtTransfersEnvelope>;
 	/** Narrowing overload, matching `list`: `walk` forwards `fields` to the
 	*  wire, so without this the yielded rows are stripped while the type
 	*  still promises every column. */
 	walk<const F extends keyof FtTransfer & string>(params: FtTransfersWalkParams & {
-		fields: readonly F[]
+		fields: readonly F[];
 	}): AsyncIterable<FtTransferFields<F>>;
 	walk(params?: FtTransfersWalkParams): AsyncIterable<FtTransfer>;
 }
@@ -2083,18 +2187,18 @@ interface NftTransfersResource {
 	/** Narrowing overload for the callable shorthand — same wire path as
 	*  `list`, so it must narrow identically. */
 	<const F extends keyof NftTransfer & string>(params: NftTransfersListParams & {
-		fields: readonly F[]
+		fields: readonly F[];
 	}): Promise<NftTransfersEnvelope<NftTransferFields<F>>>;
 	(params?: NftTransfersListParams): Promise<NftTransfersEnvelope>;
 	/** Narrowing overload: `fields` shrinks the row type to exactly the
 	*  requested columns plus {@link NftTransferAlwaysFields}. */
 	list<const F extends keyof NftTransfer & string>(params: NftTransfersListParams & {
-		fields: readonly F[]
+		fields: readonly F[];
 	}): Promise<NftTransfersEnvelope<NftTransferFields<F>>>;
 	list(params?: NftTransfersListParams): Promise<NftTransfersEnvelope>;
 	/** Narrowing overload, matching `list` (see {@link FtTransfersResource}). */
 	walk<const F extends keyof NftTransfer & string>(params: NftTransfersWalkParams & {
-		fields: readonly F[]
+		fields: readonly F[];
 	}): AsyncIterable<NftTransferFields<F>>;
 	walk(params?: NftTransfersWalkParams): AsyncIterable<NftTransfer>;
 }
@@ -2106,7 +2210,7 @@ interface IndexEventsResource {
 		T extends IndexEventType,
 		const F extends keyof IndexEventOf<T> & string
 	>(params: EventsListParams<T> & {
-		fields: readonly F[]
+		fields: readonly F[];
 	}): Promise<EventsEnvelope<T, IndexEventFields<T, F>>>;
 	<T extends IndexEventType>(params: EventsListParams<T>): Promise<EventsEnvelope<T>>;
 	/** Narrowing overload: `fields` shrinks the returned row type to exactly
@@ -2116,7 +2220,7 @@ interface IndexEventsResource {
 		T extends IndexEventType,
 		const F extends keyof IndexEventOf<T> & string
 	>(params: EventsListParams<T> & {
-		fields: readonly F[]
+		fields: readonly F[];
 	}): Promise<EventsEnvelope<T, IndexEventFields<T, F>>>;
 	list<T extends IndexEventType>(params: EventsListParams<T>): Promise<EventsEnvelope<T>>;
 	/** Narrowing overload, matching `list`: `walk` forwards `fields` to the
@@ -2126,33 +2230,33 @@ interface IndexEventsResource {
 		T extends IndexEventType,
 		const F extends keyof IndexEventOf<T> & string
 	>(params: EventsWalkParams<T> & {
-		fields: readonly F[]
+		fields: readonly F[];
 	}): AsyncIterable<IndexEventFields<T, F>>;
 	walk<T extends IndexEventType>(params: EventsWalkParams<T>): AsyncIterable<IndexEventOf<T>>;
 	consume<
 		T extends IndexEventType,
 		TTx = never
 	>(params: EventsConsumeParams<T, TTx> & {
-		sink?: ConsumerSink<TTx>
+		sink?: ConsumerSink<TTx>;
 	}): Promise<{
-		cursor: string | null
-		pages: number
-		emptyPolls: number
+		cursor: string | null;
+		pages: number;
+		emptyPolls: number;
 	}>;
 }
 /** Per-event-type filter vocabulary in the {@link IndexDiscovery} doc. */
 type IndexEventTypeFilters = {
-	columns?: string[]
-	allowed_filters?: string[]
-	equality_filters?: string[]
-	required_non_null?: string[]
+	columns?: string[];
+	allowed_filters?: string[];
+	equality_filters?: string[];
+	required_non_null?: string[];
 };
 /** The `GET /v1/index` discovery doc — live endpoint + filter vocabulary.
 *  Shape is intentionally open (the server may add fields); the agent-relevant
 *  parts are the per-type filter rules. */
 type IndexDiscovery = {
-	event_type_filters?: Record<string, IndexEventTypeFilters>
-	[key: string]: unknown
+	event_type_filters?: Record<string, IndexEventTypeFilters>;
+	[key: string]: unknown;
 };
 declare class Index extends BaseClient {
 	constructor(options?: Partial<SecondLayerOptions>);
@@ -2178,27 +2282,27 @@ declare class Index extends BaseClient {
 	*  Callable: `index.events(params)` ≡ `index.events.list(params)`. */
 	readonly events: IndexEventsResource;
 	readonly contractCalls: {
-		list: (params?: ContractCallsListParams) => Promise<ContractCallsEnvelope>
-		walk: (params?: ContractCallsWalkParams) => AsyncIterable<IndexContractCall>
+		list: (params?: ContractCallsListParams) => Promise<ContractCallsEnvelope>;
+		walk: (params?: ContractCallsWalkParams) => AsyncIterable<IndexContractCall>;
 		consume: <TTx = never>(params: ContractCallsConsumeParams<TTx> & {
-			sink?: ConsumerSink<TTx>
+			sink?: ConsumerSink<TTx>;
 		}) => Promise<{
-			cursor: string | null
-			pages: number
-			emptyPolls: number
-		}>
+			cursor: string | null;
+			pages: number;
+			emptyPolls: number;
+		}>;
 	};
 	/** Canonical block-hash map — sync only the current canonical chain. */
 	readonly canonical: {
-		list: (params?: CanonicalListParams) => Promise<CanonicalEnvelope>
-		walk: (params?: CanonicalWalkParams) => AsyncIterable<IndexCanonicalBlock>
+		list: (params?: CanonicalListParams) => Promise<CanonicalEnvelope>;
+		walk: (params?: CanonicalWalkParams) => AsyncIterable<IndexCanonicalBlock>;
 	};
 	/** Canonical blocks: paginated `list`/`walk`, plus `get` by height or hash
 	*  (resolves to null on 404). */
 	readonly blocks: {
-		list: (params?: BlocksListParams) => Promise<BlocksEnvelope>
-		walk: (params?: BlocksWalkParams) => AsyncIterable<IndexBlock>
-		get: (ref: string | number) => Promise<BlockEnvelope | null>
+		list: (params?: BlocksListParams) => Promise<BlocksEnvelope>;
+		walk: (params?: BlocksWalkParams) => AsyncIterable<IndexBlock>;
+		get: (ref: string | number) => Promise<BlockEnvelope | null>;
 	};
 	/** Full transaction documents: paginated `list`/`walk`, plus `get` by tx_id
 	*  (resolves to null on 404). */
@@ -2209,26 +2313,26 @@ declare class Index extends BaseClient {
 		*  overloads. */
 		list: {
 			<const F extends keyof IndexTransaction & string>(params: TransactionsListParams & {
-				fields: readonly F[]
-			}): Promise<TransactionsEnvelope<TransactionFields<F>>>
-			(params?: TransactionsListParams): Promise<TransactionsEnvelope>
-		}
-		walk: (params?: TransactionsWalkParams) => AsyncIterable<IndexTransaction>
-		get: (txId: string) => Promise<TransactionEnvelope | null>
-		getProof: (txId: string) => Promise<TransactionProof | null>
+				fields: readonly F[];
+			}): Promise<TransactionsEnvelope<TransactionFields<F>>>;
+			(params?: TransactionsListParams): Promise<TransactionsEnvelope>;
+		};
+		walk: (params?: TransactionsWalkParams) => AsyncIterable<IndexTransaction>;
+		get: (txId: string) => Promise<TransactionEnvelope | null>;
+		getProof: (txId: string) => Promise<TransactionProof | null>;
 	};
 	/** Decoded PoX-4 stacking actions. Empty (with a `notes` hint) when the
 	*  platform's PoX-4 decoder is disabled. */
 	readonly stacking: {
-		list: (params?: StackingListParams) => Promise<StackingEnvelope>
-		walk: (params?: StackingWalkParams) => AsyncIterable<IndexStackingAction>
+		list: (params?: StackingListParams) => Promise<StackingEnvelope>;
+		walk: (params?: StackingWalkParams) => AsyncIterable<IndexStackingAction>;
 	};
 	/** Pending (unconfirmed) transactions: paginated `list`/`walk`, plus `get` by
 	*  tx_id (resolves to null when the tx has confirmed or dropped). */
 	readonly mempool: {
-		list: (params?: MempoolListParams) => Promise<MempoolEnvelope>
-		walk: (params?: MempoolWalkParams) => AsyncIterable<IndexMempoolTransaction>
-		get: (txId: string) => Promise<MempoolTransactionEnvelope | null>
+		list: (params?: MempoolListParams) => Promise<MempoolEnvelope>;
+		walk: (params?: MempoolWalkParams) => AsyncIterable<IndexMempoolTransaction>;
+		get: (txId: string) => Promise<MempoolTransactionEnvelope | null>;
 	};
 	/** Decoded sBTC peg surface — the only productized decoded sBTC peg feed on
 	*  Stacks. `deposits`/`withdrawals`/`events` paginate; `summary` is a scalar. */
@@ -2341,7 +2445,7 @@ declare class Projects extends BaseClient {
 	constructor(options?: Partial<SecondLayerOptions>);
 	/** All projects owned by the account, newest-relevant first. */
 	list(): Promise<{
-		projects: Project[]
+		projects: Project[];
 	}>;
 	/** A single project by slug. */
 	get(slug: string): Promise<Project>;
@@ -2351,7 +2455,7 @@ declare class Projects extends BaseClient {
 	update(slug: string, patch: UpdateProjectParams): Promise<Project>;
 	/** Delete a project. The account's last remaining project cannot be deleted. */
 	delete(slug: string): Promise<{
-		ok: true
+		ok: true;
 	}>;
 	/** Team members and pending invitations for a project. */
 	team(slug: string): Promise<ProjectTeam>;
@@ -2359,7 +2463,7 @@ declare class Projects extends BaseClient {
 import { CreateSubscriptionRequest, CreateSubscriptionResponse, DeadRow, DeliveryRow, ReplayResult, RotateSecretResponse, SubscriptionDetail, SubscriptionSummary, SubscriptionTestResult, UpdateSubscriptionRequest } from "@secondlayer/shared/schemas/subscriptions";
 declare class Subscriptions extends BaseClient {
 	list(): Promise<{
-		data: SubscriptionSummary[]
+		data: SubscriptionSummary[];
 	}>;
 	get(id: string): Promise<SubscriptionDetail>;
 	create(input: CreateSubscriptionRequest): Promise<CreateSubscriptionResponse>;
@@ -2367,25 +2471,25 @@ declare class Subscriptions extends BaseClient {
 	pause(id: string): Promise<SubscriptionDetail>;
 	resume(id: string): Promise<SubscriptionDetail>;
 	delete(id: string): Promise<{
-		ok: true
+		ok: true;
 	}>;
 	rotateSecret(id: string): Promise<RotateSecretResponse>;
 	/** Send a one-off test webhook to the subscription's URL (built for its
 	*  format, SSRF-guarded). Logged as a delivery row, visible via recentDeliveries. */
 	test(id: string): Promise<SubscriptionTestResult>;
 	recentDeliveries(id: string): Promise<{
-		data: DeliveryRow[]
+		data: DeliveryRow[];
 	}>;
 	replay(id: string, range: {
-		fromBlock: number
-		toBlock: number
-		force?: string
+		fromBlock: number;
+		toBlock: number;
+		force?: string;
 	}): Promise<ReplayResult>;
 	dead(id: string): Promise<{
-		data: DeadRow[]
+		data: DeadRow[];
 	}>;
 	requeueDead(id: string, outboxId: string): Promise<{
-		ok: true
+		ok: true;
 	}>;
 }
 interface ContextAccount {
@@ -2423,8 +2527,8 @@ interface ContextSnapshot {
 	indexTip: IndexTip | null;
 	subgraphs: SubgraphSummary2[] | null;
 	subscriptions: {
-		count: number
-		byStatus: Record<string, number>
+		count: number;
+		byStatus: Record<string, number>;
 	} | null;
 	/** The account's projects (null when unreadable — e.g. a scoped key). */
 	projects: ContextProject[] | null;
@@ -2453,14 +2557,14 @@ declare class SecondLayer extends BaseClient {
 	* PAYMENT-BALANCE/SESSION) apply to every item.
 	*/
 	batch(requests: Array<{
-		path: string
-		params?: Record<string, string | number | boolean>
+		path: string;
+		params?: Record<string, string | number | boolean>;
 	}>): Promise<{
 		results: Array<{
-			path: string | null
-			status: number
-			body: unknown
-		}>
+			path: string | null;
+			status: number;
+			body: unknown;
+		}>;
 	}>;
 	context(): Promise<ContextSnapshot>;
 }
@@ -2479,8 +2583,8 @@ declare class SecondLayer extends BaseClient {
 * ```
 */
 declare function getSubgraph<T extends {
-	name: string
-	schema: Record<string, unknown>
+	name: string;
+	schema: Record<string, unknown>;
 }>(def: T, options?: Partial<SecondLayerOptions> | SecondLayer | Subgraphs): InferSubgraphClient2<T>;
 import { SubgraphAgentSchema as SubgraphAgentSchema2, SubgraphSpecFormat, SubgraphSpecOptions as SubgraphSpecOptions2 } from "@secondlayer/shared/subgraphs/spec";
 export { getSubgraph, Subgraphs, SubgraphSpecOptions2 as SubgraphSpecOptions, SubgraphSpecFormat, SubgraphAgentSchema2 as SubgraphAgentSchema, SecondLayerOptions };