@secondlayer/sdk 13.1.0 → 13.2.0

package/dist/subgraphs/index.d.ts

@@ -603,7 +603,7 @@ type WithSinkTx<TTx> = [TTx] extends [never] ? unknown : {
 	tx: TTx;
 };
 import { VmEventType } from "@secondlayer/shared";
-import { StreamsEvent, StreamsEventType, StreamsWireEvent, VmStreamsEvent } from "@secondlayer/shared/streams-rows";
+import { RuneEventType, RuneStreamsEvent, StreamsEvent, StreamsEventType, StreamsWireEvent, VmStreamsEvent } from "@secondlayer/shared/streams-rows";
 type StreamsTip = {
 	block_height: number;
 	block_hash: string;
@@ -623,6 +623,15 @@ type StreamsTip = {
 	/** Oldest seekable cursor (`<oldest_seekable_height>:0`); `null` = unlimited. */
 	oldest_cursor?: string | null;
 };
+/** `chain=bitcoin` tip (plan 059) — no `burn_block_height`/retention fields,
+*  since Bitcoin has no burn chain of its own and Runes reads have no
+*  retention ladder. Returned by `tip({ chain: "bitcoin" })`. */
+type StreamsBitcoinTip = {
+	block_height: number;
+	block_hash: string;
+	finalized_height: number;
+	lag_seconds: number;
+};
 type StreamsCanonicalBlock = {
 	block_height: number;
 	block_hash: string;
@@ -630,6 +639,12 @@ type StreamsCanonicalBlock = {
 	burn_block_hash: string | null;
 	is_canonical: true;
 };
+/** `chain=bitcoin` canonical block (plan 059) — no burn-chain fields. */
+type StreamsBitcoinCanonicalBlock = {
+	block_height: number;
+	block_hash: string;
+	is_canonical: true;
+};
 type StreamsReorg = {
 	detected_at: string;
 	fork_point_height: number;
@@ -645,13 +660,19 @@ type StreamsReorg = {
 	*/
 	new_canonical_tip: string;
 };
-type StreamsEventsEnvelope<TEvent = StreamsEvent> = {
+type StreamsEventsEnvelope<
+	TEvent = StreamsEvent,
+	TTip = StreamsTip
+> = {
 	events: TEvent[];
 	next_cursor: string | null;
-	tip: StreamsTip;
+	tip: TTip;
 	reorgs: StreamsReorg[];
 };
-type StreamsEventsListEnvelope = Omit<StreamsEventsEnvelope, "next_cursor">;
+type StreamsEventsListEnvelope<
+	TEvent = StreamsEvent,
+	TTip = StreamsTip
+> = Omit<StreamsEventsEnvelope<TEvent, TTip>, "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, {
@@ -695,10 +716,16 @@ type StreamsEventForFilter<
 }> : Extract<StreamsEvent, {
 	event_type: T;
 }> : D extends true ? IndexEvent : StreamsEvent;
-type StreamsEventsListParams = {
+type StreamsEventsListParamsCommon = {
 	cursor?: string | null;
 	fromHeight?: number;
 	toHeight?: number;
+	limit?: number;
+};
+/** `chain: "stacks"` (default, omit `chain` entirely) — unchanged since
+*  before plan 059. */
+type StreamsEventsStacksListParams = StreamsEventsListParamsCommon & {
+	chain?: "stacks";
 	/** `vm` reads ordinal. Omit for Streams 1.0. */
 	clock?: "classic" | "vm";
 	types?: readonly (StreamsEventType | VmEventType)[];
@@ -714,27 +741,37 @@ type StreamsEventsListParams = {
 	* unrelated concerns share one page, one cursor, one checkpoint.
 	*/
 	filters?: StreamsFilterMap;
-	limit?: number;
 };
-type StreamsEventsStreamParams = {
+/**
+* `chain: "bitcoin"` (plan 059) — Runes events, own cursor space. `types` is
+* restricted to {@link RuneEventType} at the type level, so e.g.
+* `{ chain: "bitcoin", types: ["ft_transfer"] }` is a compile error rather
+* than a silent 400 at request time. `contractId`/`sender`/`recipient`/
+* `assetIdentifier`/`filters`/`clock` don't exist on this branch — they're
+* Stacks-only (the server 400s on them too).
+*/
+type StreamsEventsBitcoinListParams = StreamsEventsListParamsCommon & {
+	chain: "bitcoin";
+	types?: readonly RuneEventType[];
+	notTypes?: readonly RuneEventType[];
+	/** A RuneRef: an id (`840000:3`) or a name (`DOG•GO•TO•THE•MOON`). */
+	rune?: string;
+	/** A mainnet address. */
+	address?: string;
+};
+type StreamsEventsListParams = StreamsEventsStacksListParams | StreamsEventsBitcoinListParams;
+type StreamsEventsStreamCommon = {
 	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;
 };
-type StreamsEventsSubscribeParams = {
-	/** Resume strictly after this cursor; omit to live-tail from the tip. */
-	fromCursor?: string | null;
+/** `chain: "stacks"` (default, omit `chain` entirely) — matches
+*  {@link StreamsEventsStacksListParams}. */
+type StreamsEventsStreamStacksParams = StreamsEventsStreamCommon & {
+	chain?: "stacks";
 	types?: readonly StreamsEventType[];
 	notTypes?: readonly StreamsEventType[];
 	contractId?: StreamsFilterValue;
@@ -743,15 +780,28 @@ type StreamsEventsSubscribeParams = {
 	assetIdentifier?: string;
 	/** Labelled filter groups; see {@link StreamsEventsListParams.filters}. */
 	filters?: StreamsFilterMap;
+};
+/** `chain: "bitcoin"` (plan 059/061) — Runes events, tailed the same way as
+*  the Stacks default. `types` is restricted to {@link RuneEventType} at the
+*  type level, matching {@link StreamsEventsBitcoinListParams}.
+*  `contractId`/`sender`/`recipient`/`assetIdentifier`/`filters` don't exist
+*  on this branch — they're Stacks-only. */
+type StreamsEventsStreamBitcoinParams = StreamsEventsStreamCommon & {
+	chain: "bitcoin";
+	types?: readonly RuneEventType[];
+	notTypes?: readonly RuneEventType[];
+	/** A RuneRef: an id (`840000:3`) or a name (`DOG•GO•TO•THE•MOON`). */
+	rune?: string;
+	/** A mainnet address. */
+	address?: string;
+};
+type StreamsEventsStreamParams = StreamsEventsStreamStacksParams | StreamsEventsStreamBitcoinParams;
+type StreamsEventsSubscribeCommon = {
+	/** Resume strictly after this cursor; omit to live-tail from the tip. */
+	fromCursor?: string | null;
 	/** Abort to unsubscribe (the returned function does the same). */
 	signal?: AbortSignal;
 	/**
-	* Called for each pushed event, in order. The resume cursor advances only
-	* after this resolves, so a handler that throws sees the same event again
-	* on reconnect (at-least-once). Key durable writes by `cursor`.
-	*/
-	onEvent: (event: StreamsEvent) => void | Promise<void>;
-	/**
 	* Called on every failure. Transport errors (dropped socket, 5xx, 429, a
 	* stale connection, a throwing handler) reconnect from the last handled
 	* cursor with exponential backoff. Errors that a retry cannot fix (401,
@@ -771,6 +821,37 @@ type StreamsEventsSubscribeParams = {
 	*/
 	staleAfterMs?: number;
 };
+/** `chain: "stacks"` (default, omit `chain` entirely). */
+type StreamsEventsSubscribeStacksParams = StreamsEventsSubscribeCommon & {
+	chain?: "stacks";
+	types?: readonly StreamsEventType[];
+	notTypes?: readonly StreamsEventType[];
+	contractId?: StreamsFilterValue;
+	sender?: StreamsFilterValue;
+	recipient?: StreamsFilterValue;
+	assetIdentifier?: string;
+	/** Labelled filter groups; see {@link StreamsEventsListParams.filters}. */
+	filters?: StreamsFilterMap;
+	/**
+	* Called for each pushed event, in order. The resume cursor advances only
+	* after this resolves, so a handler that throws sees the same event again
+	* on reconnect (at-least-once). Key durable writes by `cursor`.
+	*/
+	onEvent: (event: StreamsEvent) => void | Promise<void>;
+};
+/** `chain: "bitcoin"` (plan 059/061) — Runes events pushed live, on their own
+*  cursor space. `contractId`/`sender`/`recipient`/`assetIdentifier`/`filters`
+*  don't exist on this branch — they're Stacks-only. */
+type StreamsEventsSubscribeBitcoinParams = StreamsEventsSubscribeCommon & {
+	chain: "bitcoin";
+	types?: readonly RuneEventType[];
+	notTypes?: readonly RuneEventType[];
+	/** A RuneRef: an id (`840000:3`) or a name (`DOG•GO•TO•THE•MOON`). */
+	rune?: string;
+	/** A mainnet address. */
+	address?: string;
+	onEvent: (event: RuneStreamsEvent) => void | Promise<void>;
+};
 /**
 * Handle for a live subscription: call it to unsubscribe. `done` resolves
 * after unsubscribe (or the signal aborting) and rejects with the error that
@@ -855,6 +936,10 @@ type StreamsEventsConsumeParams<
 	D extends boolean = false,
 	F extends StreamsFilterMap = Record<never, never>
 > = {
+	/** `chain: "stacks"` (default, omit `chain` entirely) — the bitcoin branch
+	*  is {@link StreamsEventsConsumeBitcoinParams}, a separate overload with
+	*  no `filters`/`on`/`decoded` (Stacks-only concepts). */
+	chain?: "stacks";
 	fromCursor?: string | null;
 	/**
 	* Deliver events pre-decoded as the flat, `event_type`-discriminated rows
@@ -963,22 +1048,74 @@ type StreamsEventsConsumeParams<
 	wake?: () => Promise<void>;
 };
 /**
+* `chain: "bitcoin"` (plan 059/061) — the checkpointed sweep over Runes
+* events. A separate, simpler type from {@link StreamsEventsConsumeParams}
+* rather than a widened union member: `filters`/`on`/`decoded` are Stacks-only
+* concepts (labelled OR-groups and Index-shaped projection have no Runes
+* equivalent yet), so `onBatch` is the only way in and is required. Reorg
+* rewind still works the same way (bitcoin reorgs carry the same
+* `fork_point_height` + `new_canonical_tip` shape as Stacks ones).
+*/
+type StreamsEventsConsumeBitcoinParams<TTx = never> = {
+	chain: "bitcoin";
+	fromCursor?: string | null;
+	sink?: ConsumerSink<TTx>;
+	onProgress?: (ctx: ConsumerBatchContext) => void;
+	mode?: "tail" | "bounded";
+	finalizedOnly?: boolean;
+	types?: readonly RuneEventType[];
+	notTypes?: readonly RuneEventType[];
+	/** A RuneRef: an id (`840000:3`) or a name (`DOG•GO•TO•THE•MOON`). */
+	rune?: string;
+	/** A mainnet address. */
+	address?: string;
+	batchSize?: number;
+	onBatch: (events: RuneStreamsEvent[], envelope: StreamsEventsEnvelope<RuneStreamsEvent, StreamsBitcoinTip>, ctx: StreamsBatchContext & WithSinkTx<TTx>) => void | string | null | undefined | Promise<void> | Promise<string | null | undefined>;
+	onReorg?: (reorg: StreamsReorg, ctx: StreamsReorgContext) => Promise<void> | void;
+	maxRollbackDepth?: number;
+	retryCount?: number;
+	retryDelay?: number;
+	onError?: (err: unknown, ctx: {
+		attempt: number;
+		retriesLeft: number;
+		delayMs: number;
+	}) => void;
+	emptyBackoffMs?: number;
+	maxPages?: number;
+	maxEmptyPolls?: number;
+	signal?: AbortSignal;
+	wake?: () => Promise<void>;
+};
+/**
 * 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<TEvent = StreamsEvent> = {
+type StreamsBatch<
+	TEvent = StreamsEvent,
+	TTip = StreamsTip
+> = {
 	/** Canonical events of this page, in cursor order. */
 	events: TEvent[];
 	/** Checkpoint after this page — pass back as `consume({ cursor })` to resume. */
 	cursor: string | null;
-	tip: StreamsTip;
+	tip: TTip;
 	/** Chain reorgs reported alongside this page; empty when none. */
 	reorgs: StreamsReorg[];
 };
-type StreamsConsumeParams = {
+type StreamsConsumeCommon = {
 	/** Resume strictly after this cursor; omit to start from the oldest seekable page. */
 	cursor?: string | null;
+	/** Events per page (the `limit` query param). Default 100. */
+	batchSize?: number;
+	/** Poll interval while caught up at the tip, in ms. Default 2000. */
+	intervalMs?: number;
+	/** Abort to end the iteration. */
+	signal?: AbortSignal;
+};
+/** `chain: "stacks"` (default, omit `chain` entirely). */
+type StreamsConsumeStacksParams = StreamsConsumeCommon & {
+	chain?: "stacks";
 	types?: readonly StreamsEventType[];
 	notTypes?: readonly StreamsEventType[];
 	contractId?: StreamsFilterValue;
@@ -988,13 +1125,20 @@ type StreamsConsumeParams = {
 	/** 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;
-	/** Poll interval while caught up at the tip, in ms. Default 2000. */
-	intervalMs?: number;
-	/** Abort to end the iteration. */
-	signal?: AbortSignal;
 };
+/** `chain: "bitcoin"` (plan 059/061) — Runes batches, own cursor space.
+*  `contractId`/`sender`/`recipient`/`assetIdentifier`/`filters` don't exist
+*  on this branch — they're Stacks-only. */
+type StreamsConsumeBitcoinParams = StreamsConsumeCommon & {
+	chain: "bitcoin";
+	types?: readonly RuneEventType[];
+	notTypes?: readonly RuneEventType[];
+	/** A RuneRef: an id (`840000:3`) or a name (`DOG•GO•TO•THE•MOON`). */
+	rune?: string;
+	/** A mainnet address. */
+	address?: string;
+};
+type StreamsConsumeParams = StreamsConsumeStacksParams | StreamsConsumeBitcoinParams;
 type StreamsEventsConsumeResult = {
 	cursor: string | null;
 	pages: number;
@@ -1098,33 +1242,44 @@ type StreamsClient = {
 	* rewound automatically — use `events.consume` with `onReorg` for managed
 	* rollback semantics.
 	*/
+	/** `chain: "bitcoin"` — batches carry Runes rows only, on the bitcoin tip
+	*  shape (plan 059/061). */
+	consume(params: StreamsConsumeBitcoinParams): AsyncIterableIterator<StreamsBatch<RuneStreamsEvent, StreamsBitcoinTip>>;
 	/** Narrowing overload: a literal `types` array narrows every batch's
 	*  event union to exactly those members. */
-	consume<const T extends readonly StreamsEventType[]>(params: StreamsConsumeParams & {
+	consume<const T extends readonly StreamsEventType[]>(params: StreamsConsumeStacksParams & {
 		types: T;
 	}): AsyncIterableIterator<StreamsBatch<StreamsEventOfTypes<T>>>;
 	consume(params?: StreamsConsumeParams): AsyncIterableIterator<StreamsBatch>;
 	events: {
 		/** `clock: "vm"` pages carry vm rows only (a parallel vocabulary,
-		*  `event_index` = `ordinal`). Never `StreamsEvent`. */
-		list(params: StreamsEventsListParams & {
+		*  `event_index` = `ordinal`). Never `StreamsEvent`. Stacks-only —
+		*  `chain: "bitcoin"` has no `clock`. */
+		list(params: StreamsEventsStacksListParams & {
 			clock: "vm";
 		}): Promise<StreamsEventsEnvelope<VmStreamsEvent>>;
 		/** Narrowing overload, matching `consume`. Classic clock only —
 		*  `clock: "vm"` is overload 1, and a general `StreamsEventsListParams`
 		*  variable (clock unresolved) is the wire-union fallback. */
-		list<const T extends readonly StreamsEventType[]>(params: Omit<StreamsEventsListParams, "clock" | "types" | "notTypes"> & {
+		list<const T extends readonly StreamsEventType[]>(params: Omit<StreamsEventsStacksListParams, "clock" | "types" | "notTypes"> & {
 			types: T;
 			notTypes?: readonly StreamsEventType[];
 			clock?: "classic";
 		}): Promise<StreamsEventsEnvelope<StreamsEventOfTypes<T>>>;
-		list(params?: Omit<StreamsEventsListParams, "clock" | "types" | "notTypes"> & {
+		list(params?: Omit<StreamsEventsStacksListParams, "clock" | "types" | "notTypes"> & {
 			types?: readonly StreamsEventType[];
 			notTypes?: readonly StreamsEventType[];
 			clock?: "classic";
 		}): Promise<StreamsEventsEnvelope>;
-		/** Unresolved `clock` on a general params variable: the wire union. */
+		/** `chain: "bitcoin"` pages carry Runes rows only, on the bitcoin tip
+		*  shape (plan 059). */
+		list(params: StreamsEventsBitcoinListParams): Promise<StreamsEventsEnvelope<RuneStreamsEvent, StreamsBitcoinTip>>;
+		/** Unresolved `chain`/`clock` on a general params variable: the wire union. */
 		list(params: StreamsEventsListParams): Promise<StreamsEventsEnvelope<StreamsWireEvent>>;
+		/** `chain: "bitcoin"` — Runes events for one transaction. */
+		byTxId(txId: string, opts: {
+			chain: "bitcoin";
+		}): Promise<StreamsEventsListEnvelope<RuneStreamsEvent, StreamsBitcoinTip>>;
 		byTxId(txId: string): Promise<StreamsEventsListEnvelope>;
 		/**
 		* Pull pages from Streams and call `onBatch` after each page.
@@ -1135,6 +1290,11 @@ type StreamsClient = {
 		* The consumer also exits when `maxPages`, `maxEmptyPolls`, or `signal`
 		* stops it.
 		*/
+		/** `chain: "bitcoin"` — the checkpointed sweep over Runes events; see
+		*  {@link StreamsEventsConsumeBitcoinParams}. */
+		consume<TTx = never>(params: StreamsEventsConsumeBitcoinParams<TTx> & {
+			sink?: ConsumerSink<TTx>;
+		}): Promise<StreamsEventsConsumeResult>;
 		consume<
 			const F extends StreamsFilterMap = Record<never, never>,
 			TTx = never,
@@ -1157,8 +1317,10 @@ type StreamsClient = {
 		* indefinitely by default and stops when its `AbortSignal`, `maxPages`, or
 		* `maxEmptyPolls` stops it.
 		*/
+		/** `chain: "bitcoin"` — Runes events only (plan 059/061). */
+		stream(params: StreamsEventsStreamBitcoinParams): AsyncIterable<RuneStreamsEvent>;
 		/** Narrowing overload, matching `consume`. */
-		stream<const T extends readonly StreamsEventType[]>(params: StreamsEventsStreamParams & {
+		stream<const T extends readonly StreamsEventType[]>(params: StreamsEventsStreamStacksParams & {
 			types: T;
 		}): AsyncIterable<StreamsEventOfTypes<T>>;
 		stream(params?: StreamsEventsStreamParams): AsyncIterable<StreamsEvent>;
@@ -1170,17 +1332,31 @@ type StreamsClient = {
 		* settles when the loop ends. Not reorg-aware: an event delivered then
 		* orphaned is never retracted. Durable writers use `consume()`.
 		*/
-		subscribe(params: StreamsEventsSubscribeParams): StreamsSubscription;
+		/** `chain: "bitcoin"` — `onEvent` receives Runes rows (plan 059/061). */
+		subscribe(params: StreamsEventsSubscribeBitcoinParams): StreamsSubscription;
+		subscribe(params: StreamsEventsSubscribeStacksParams): StreamsSubscription;
 	};
 	blocks: {
+		events(heightOrHash: number | string, opts: {
+			chain: "bitcoin";
+		}): Promise<StreamsEventsListEnvelope<RuneStreamsEvent, StreamsBitcoinTip>>;
 		events(heightOrHash: number | string): Promise<StreamsEventsListEnvelope>;
 	};
 	reorgs: {
+		list(params: StreamsReorgsListParams & {
+			chain: "bitcoin";
+		}): Promise<StreamsReorgsListEnvelope>;
 		list(params: StreamsReorgsListParams): Promise<StreamsReorgsListEnvelope>;
 	};
 	/** Bulk parquet dumps. Requires `dumpsBaseUrl` on the client. */
 	dumps: StreamsDumps;
+	canonical(height: number, opts: {
+		chain: "bitcoin";
+	}): Promise<StreamsBitcoinCanonicalBlock>;
 	canonical(height: number): Promise<StreamsCanonicalBlock>;
+	tip(opts: {
+		chain: "bitcoin";
+	}): Promise<StreamsBitcoinTip>;
 	tip(): Promise<StreamsTip>;
 };
 type Sleep = (ms: number, signal?: AbortSignal) => Promise<void>;
@@ -2318,6 +2494,185 @@ interface Pox5Resource {
 		}>;
 	};
 }
+/** A rune's `<block>:<tx>` id — the etch transaction's position, e.g. `840000:3`. */
+type RuneId = `${number}:${number}`;
+/**
+* A rune reference accepted by every Runes call: an id ({@link RuneId}) or a
+* name, with or without spacers, in any case — `DOG•GO•TO•THE•MOON`,
+* `dog.go.to.the.moon` and `doggotothemoon` all resolve to the same rune.
+* Typing every rune name is a no (178k runes and growing — a generated union
+* would be huge and stale on day one); `list({ search })` covers discovery.
+*/
+type RuneRef = RuneId | (string & {});
+/** The Bitcoin chain tip a Runes read was served against — a separate clock
+*  from the Stacks {@link IndexTip}: Runes ingest tracks Bitcoin blocks, not
+*  Stacks ones. */
+type IndexBitcoinTip = {
+	block_height: number;
+	finalized_height: number;
+	lag_seconds: number;
+};
+/** A Bitcoin fork the Runes indexer rolled back. Rows in
+*  `[orphaned_from, orphaned_to]` were replaced; undo anything you committed
+*  from them. Block-level only — a Bitcoin reorg has no Stacks-style
+*  event_index component. */
+type IndexBtcReorg = {
+	id: string;
+	detected_at: string;
+	fork_point_height: number;
+	old_hash: string;
+	new_hash: string;
+	orphaned_from: number;
+	orphaned_to: number;
+	new_tip_height: number;
+};
+/** The rune identity bundle every Runes response embeds, so a client never
+*  needs a second lookup just to show a name next to an event or a balance. */
+type IndexRuneRefSummary = {
+	id: string;
+	/** Spacers stripped, uppercase. */
+	name: string;
+	/** As etched, spacers (`•`) included. */
+	spaced_name: string;
+	symbol: string | null;
+	divisibility: number;
+};
+/** Mint terms, or `null` for a premine-only rune that was never mintable. */
+type IndexRuneTerms = {
+	amount: string | null;
+	cap: string | null;
+	height_start: string | null;
+	height_end: string | null;
+	offset_start: string | null;
+	offset_end: string | null;
+};
+/** One etched rune's full entry: identity, premine/mint/burn counters,
+*  computed supply, and mint terms. */
+type IndexRuneEntry = IndexRuneRefSummary & {
+	/** Etch sequence number (u128 decimal string) — 0 is genesis. */
+	number: string;
+	/** Premined amount, u128 decimal string. Never `Number()`. */
+	premine: string;
+	/** Computed: `premine + mints × terms.amount` (0 with no terms). u128
+	*  decimal string. */
+	supply: string;
+	burned: string;
+	mints: string;
+	turbo: boolean;
+	etching_txid: string;
+	etched_height: number;
+	etched_tx_index: number;
+	terms: IndexRuneTerms | null;
+};
+type RunesEnvelope<TRow = IndexRuneEntry> = {
+	runes: TRow[];
+	next_cursor: string | null;
+	tip: IndexBitcoinTip;
+	/** Always empty: `list` reads a reorg-corrected snapshot table, not an
+	*  append-only log — there is no stale page to reconcile. */
+	reorgs: IndexBtcReorg[];
+	/** Present only when Runes data is not configured on this instance. */
+	notes?: string;
+};
+type RunesListParams = {
+	/** Name prefix, spacers and case ignored (`dog` matches `DOG•GO•TO•THE•MOON`). */
+	search?: string;
+	/** `number` (etch order, oldest first — default) or `mints` (busiest first). */
+	sort?: "number" | "mints";
+	cursor?: string | null;
+	limit?: number;
+};
+type RuneEnvelope = {
+	rune: IndexRuneEntry;
+	tip: IndexBitcoinTip;
+};
+type IndexRuneEventKind = "rune_etch" | "rune_mint" | "rune_transfer" | "rune_burn";
+/** One etch/mint/transfer/burn event, with the rune's identity embedded so an
+*  activity feed never needs a second lookup to show a name. */
+type IndexRuneEvent = {
+	cursor: string;
+	block_height: number;
+	tx_index: number;
+	txid: string;
+	event_index: number;
+	kind: IndexRuneEventKind;
+	/** u128 decimal string. Never `Number()`. */
+	amount: string;
+	vout: number | null;
+	/** The output's mainnet address. Only ever set on a `rune_transfer` event. */
+	address: string | null;
+	rune: IndexRuneRefSummary;
+};
+type RuneActivityEnvelope<TRow = IndexRuneEvent> = {
+	events: TRow[];
+	next_cursor: string | null;
+	tip: IndexBitcoinTip;
+	reorgs: IndexBtcReorg[];
+	notes?: string;
+};
+type RuneActivityListParams = {
+	cursor?: string | null;
+	fromCursor?: string | null;
+	fromHeight?: number;
+	toHeight?: number;
+	limit?: number;
+	rune?: RuneRef;
+	address?: string;
+	kind?: readonly IndexRuneEventKind[];
+	txid?: string;
+};
+type RuneActivityWalkParams = Omit<RuneActivityListParams, "limit"> & WalkOptions;
+/** A rune's balance on one unspent output, with the rune's identity embedded. */
+type IndexRuneBalance = {
+	rune: IndexRuneRefSummary;
+	/** The output's mainnet address, or `null` for a non-standard script. */
+	address: string | null;
+	txid: string;
+	vout: number;
+	/** u128 decimal string. Never `Number()`. */
+	amount: string;
+};
+type RuneBalancesEnvelope<TRow = IndexRuneBalance> = {
+	balances: TRow[];
+	next_cursor: string | null;
+	tip: IndexBitcoinTip;
+	/** Always empty — see {@link RunesEnvelope.reorgs}. */
+	reorgs: IndexBtcReorg[];
+	notes?: string;
+};
+/** Exactly one of `address`/`outpoint` is required — enforced at the type
+*  level, not just at runtime. */
+type RuneBalancesListParams = ({
+	address: string;
+	outpoint?: never;
+} | {
+	outpoint: string;
+	address?: never;
+}) & {
+	/** Narrows the result to one rune. */
+	rune?: RuneRef;
+	cursor?: string | null;
+	limit?: number;
+};
+/** `index.runes` — the rune catalog, activity log, and balances. Runes is
+*  more data on the existing Index plane, not a new product. Not configured
+*  on hosted yet; every feed's `notes` says so when it isn't. Self-host with
+*  the `bitcoin` compose profile has data today. */
+interface RunesResource {
+	/** The rune catalog. `search` prefix-matches the name; `sort` is etch
+	*  order (default) or busiest-first. */
+	list(params?: RunesListParams): Promise<RunesEnvelope>;
+	/** One rune's full entry by id or name; `null` on 404 (no such rune, or
+	*  Runes isn't configured on this instance). */
+	get(rune: RuneRef): Promise<RuneEnvelope | null>;
+	/** Current per-outpoint rune balances by address or outpoint. */
+	balances(params: RuneBalancesListParams): Promise<RuneBalancesEnvelope>;
+	/** Etch/mint/transfer/burn events, cursor `<block_height>:<event_index>`. */
+	activity: {
+		list(params?: RuneActivityListParams): Promise<RuneActivityEnvelope>;
+		walk(params?: RuneActivityWalkParams): AsyncIterable<IndexRuneEvent>;
+	};
+}
 /**
 * `index.ftTransfers` — callable shorthand for `.list()`, with `.list`/`.walk`
 * still available: `await sl.index.ftTransfers({ contractId })`.
@@ -2505,6 +2860,9 @@ declare class Index extends BaseClient {
 	/** Decoded PoX-5 print events (SIP-045 Bitcoin Staking) — the raw pox-5
 	*  boot-contract log, all 19 topics. Distinct from `stacking` (PoX-4 era). */
 	readonly pox5: Pox5Resource;
+	/** Rune catalog, activity and balances. Separate clock/reorg source from
+	*  the Stacks feeds above — see {@link RunesResource}. */
+	readonly runes: RunesResource;
 	private listFtTransfers;
 	private listNftTransfers;
 	/** Shared keyset-pagination loop for every `walk*` feed: seed the cursor from
@@ -2555,6 +2913,11 @@ declare class Index extends BaseClient {
 	private listPoxCycles;
 	private walkPoxCycles;
 	private getPoxCycle;
+	private listRunes;
+	private getRune;
+	private listRuneActivity;
+	private walkRuneActivity;
+	private listRuneBalances;
 }
 import { CreateWebhookRequest, CreateWebhookResponse, DeadRow, DeliveryRow, ReplayResult, RotateSecretResponse, UpdateWebhookRequest, WebhookActivity, WebhookDeliveryDetail, WebhookDetail, WebhookSummary, WebhookTestResult } from "@secondlayer/shared/schemas/webhooks";
 declare class Webhooks extends BaseClient {