@secondlayer/shared 13.11.0 → 13.13.0

package/dist/src/db/queries/webhook-replays.d.ts

@@ -0,0 +1,1431 @@
+import { Kysely } from "kysely";
+/** Live state of one stored replay. */
+interface ReplayProgress {
+	replayId: string;
+	webhookId: string;
+	status: "scanning" | "running" | "done" | "failed";
+	fromBlock: number;
+	toBlock: number;
+	/** Events the replay enqueued. */
+	total: number;
+	/** Delivered or gave up (`total - pending`). */
+	processed: number;
+	pending: number;
+	/** Null until the replay finishes. */
+	delivered: number | null;
+	/** Null until the replay finishes. */
+	gaveUp: number | null;
+	startedAt: string;
+	finishedAt: string | null;
+	error: string | null;
+}
+import { ColumnType, Generated, Selectable } from "kysely";
+/**
+* Coverage-kernel constraints. SQL CHECKs in migration 0116 must stay
+* identical — property tests treat this file as the spec.
+*/
+declare const STAGE_KINDS: readonly ["raw", "decode", "subgraph", "queue"];
+type StageKind = (typeof STAGE_KINDS)[number];
+declare const NATIVE_CLOCKS: readonly ["block", "cursor", "queue"];
+type NativeClock = (typeof NATIVE_CLOCKS)[number];
+declare const REPAIR_MODES: readonly ["range_safe", "full_reindex", "archive_replay", "none"];
+type RepairMode = (typeof REPAIR_MODES)[number];
+declare const RUN_STATUSES: readonly ["pending", "running", "complete", "syncing", "lagging", "gap", "stale", "failed", "unverified_import", "unanchored", "source_unavailable", "out_of_scope", "disabled", "halted"];
+type RunStatus = (typeof RUN_STATUSES)[number];
+declare const FAILURE_UNITS: readonly ["block", "range", "cursor", "queue"];
+type FailureUnit = (typeof FAILURE_UNITS)[number];
+declare const FAILURE_CLASSES: readonly ["omission", "version", "digest_mismatch", "crash", "reorg", "source_gap", "handler", "timeout", "unknown"];
+type FailureClass = (typeof FAILURE_CLASSES)[number];
+declare const RETRY_STATES: readonly ["open", "retrying", "halted", "resolved"];
+type RetryState = (typeof RETRY_STATES)[number];
+type BootstrapSource = "archive" | "genesis" | "import";
+/**
+* How far a subgraph's rows can be checked without trusting the server,
+* derived from its sources and a scan of its handler. Never configured.
+*
+* - `state`: every input is a named state write, provable from block headers.
+*   Handlers run in the deterministic realm. A deployed `state` subgraph is
+*   verifiable: one with any reason is refused at deploy.
+* - `events`: an input (events, prints, tx results, `ctx.client`) needs
+*   re-execution proofs, which are not served yet.
+* - `none`: a source can never be proven as written (trait scope, tip-first
+*   backfill).
+*/
+interface SubgraphVerification {
+	level: "state" | "events" | "none";
+	/** What stands between the subgraph and checkable rows, e.g.
+	*  `print_event source "swaps" needs event proofs` or
+	*  `subgraph.ts:41:12 Date: wall-clock time differs per run`. */
+	reasons: string[];
+	/** What stays unproven even at this level, e.g. tx attribution of writes. */
+	unproven: string[];
+}
+interface BlocksTable {
+	height: number;
+	hash: string;
+	parent_hash: string;
+	burn_block_height: number;
+	burn_block_hash: ColumnType<string | null, string | null | undefined, string | null>;
+	/** Nakamoto StacksBlockId. Null on rows ingested before it was persisted. */
+	index_block_hash: ColumnType<string | null, string | null | undefined, string | null>;
+	timestamp: number;
+	canonical: Generated<boolean>;
+	/** Tx count `persistBlock` was handed for this height. Null on rows
+	*  ingested before this column existed. */
+	tx_count: ColumnType<number | null, number | null | undefined, number | null>;
+	created_at: Generated<Date>;
+}
+interface TransactionsTable {
+	tx_id: string;
+	block_height: number;
+	tx_index: Generated<number>;
+	type: string;
+	sender: string;
+	status: string;
+	contract_id: string | null;
+	function_name: string | null;
+	function_args: Generated<unknown | null>;
+	raw_result: Generated<string | null>;
+	raw_tx: string;
+	created_at: Generated<Date>;
+}
+interface EventsTable {
+	id: Generated<string>;
+	tx_id: string;
+	block_height: number;
+	event_index: number;
+	type: string;
+	data: unknown;
+	created_at: Generated<Date>;
+}
+interface TransactionsArchiveTable {
+	archive_id: Generated<string>;
+	tx_id: string;
+	block_height: number;
+	tx_index: number;
+	type: string;
+	sender: string;
+	status: string;
+	contract_id: string | null;
+	function_name: string | null;
+	function_args: unknown | null;
+	raw_result: string | null;
+	raw_tx: string;
+	created_at: Date;
+	orphaned_block_hash: string | null;
+	archived_at: Generated<Date>;
+}
+interface EventsArchiveTable {
+	archive_id: Generated<string>;
+	id: string;
+	tx_id: string;
+	block_height: number;
+	event_index: number;
+	type: string;
+	data: unknown;
+	created_at: Date;
+	orphaned_block_hash: string | null;
+	archived_at: Generated<Date>;
+}
+interface VmEventsTable {
+	tx_id: string;
+	block_height: number;
+	ordinal: number;
+	type: string;
+	data: unknown;
+	created_at: Generated<Date>;
+}
+interface VmEventsArchiveTable {
+	archive_id: Generated<string>;
+	/** `block_height:ordinal`; rows archived before migration 0153 hold the old uuid. */
+	id: string;
+	tx_id: string;
+	block_height: number;
+	ordinal: number;
+	type: string;
+	data: unknown;
+	created_at: Date;
+	orphaned_block_hash: string | null;
+	archived_at: Generated<Date>;
+}
+interface StateWritesTable {
+	block_height: number;
+	ordinal: number;
+	tx_index: number | null;
+	key: string;
+	value_hex: string;
+}
+interface StateWritesArchiveTable {
+	archive_id: Generated<string>;
+	/** `block_height:ordinal`. */
+	id: string;
+	block_height: number;
+	ordinal: number;
+	tx_index: number | null;
+	key: string;
+	value_hex: string;
+	orphaned_block_hash: string | null;
+	archived_at: Generated<Date>;
+}
+interface DeadLetterEventsTable {
+	id: Generated<string>;
+	block_height: number;
+	tx_id: string;
+	event_index: number;
+	event_type: string;
+	data: unknown;
+	reason: string;
+	created_at: Generated<Date>;
+}
+interface MempoolTransactionsTable {
+	seq: Generated<string>;
+	tx_id: string;
+	raw_tx: string;
+	type: string;
+	sender: string;
+	contract_id: string | null;
+	function_name: string | null;
+	function_args: unknown | null;
+	received_at: Generated<Date>;
+}
+interface IndexProgressTable {
+	network: string;
+	last_indexed_block: Generated<number>;
+	last_contiguous_block: Generated<number>;
+	highest_seen_block: Generated<number>;
+	updated_at: Generated<Date>;
+}
+interface SubgraphsTable {
+	id: Generated<string>;
+	name: string;
+	version: Generated<string>;
+	status: Generated<string>;
+	definition: Record<string, unknown>;
+	schema_hash: string;
+	handler_path: string;
+	schema_name: string | null;
+	start_block: Generated<number>;
+	last_processed_block: Generated<number>;
+	reindex_from_block: number | null;
+	reindex_to_block: number | null;
+	last_error: string | null;
+	last_error_at: Date | null;
+	total_processed: Generated<number>;
+	total_errors: Generated<number>;
+	account_id: string;
+	handler_code: string | null;
+	source_code: string | null;
+	project_id: string | null;
+	/** Paid (wallet-ghost) deploys expire unless renewed or claimed; NULL = no expiry. */
+	expires_at: Date | null;
+	/** (event type, contract) probe pairs persisted at deploy for weight classification. */
+	sparse_probe_targets: unknown | null;
+	/** sha256 over everything that shapes rows (schema, handler bundle,
+	*  startBlock, network, runtime). NULL for unbundled or older deploys. */
+	pin: string | null;
+	/** The canonical JSON `pin` hashes, so a client can recompute it. NULL
+	*  wherever `pin` is, and for deploys before migration 0158. */
+	pin_preimage: string | null;
+	/** Level derived at deploy. NULL (older deploys) = not verifiable. */
+	verification: SubgraphVerification | null;
+	created_at: Generated<Date>;
+	updated_at: Generated<Date>;
+}
+interface ContractsTable {
+	contract_id: string;
+	deployer: string;
+	block_height: number;
+	canonical: Generated<boolean>;
+	abi: unknown | null;
+	declared_traits: Generated<string[]>;
+	inferred_standards: Generated<string[]>;
+	abi_status: Generated<string>;
+	abi_fetched_at: Date | null;
+	created_at: Generated<Date>;
+}
+interface SubgraphGapsTable {
+	id: Generated<string>;
+	subgraph_id: string;
+	subgraph_name: string;
+	gap_start: number;
+	gap_end: number;
+	reason: string;
+	detected_at: Generated<Date>;
+	resolved_at: Date | null;
+}
+/** Print-validate skips persisted for the authed violations GET. Cap 100/subgraph. */
+interface SubgraphViolationsTable {
+	id: Generated<string>;
+	subgraph_name: string;
+	source_name: string;
+	block_height: number;
+	tx_id: string;
+	reason: string;
+	sample_payload: Record<string, unknown>;
+	seen_at: Generated<Date>;
+}
+type SubgraphOperationKind = "reindex" | "backfill";
+type SubgraphOperationStatus = "queued" | "running" | "completed" | "failed" | "cancelled";
+interface SubgraphOperationsTable {
+	id: Generated<string>;
+	subgraph_id: string;
+	subgraph_name: string;
+	account_id: string | null;
+	kind: ColumnType<SubgraphOperationKind, SubgraphOperationKind, SubgraphOperationKind>;
+	status: ColumnType<SubgraphOperationStatus, SubgraphOperationStatus | undefined, SubgraphOperationStatus>;
+	from_block: number | null;
+	to_block: number | null;
+	cancel_requested: Generated<boolean>;
+	locked_by: string | null;
+	locked_until: Date | null;
+	started_at: Date | null;
+	finished_at: Date | null;
+	processed_blocks: number | null;
+	error: string | null;
+	created_at: Generated<Date>;
+	updated_at: Generated<Date>;
+	/** 'light' (contract-scoped sparse) | 'heavy' (broad). Claim budgets heavy. */
+	weight: Generated<string>;
+	/** Candidate-event denominator computed at enqueue (sparse ops only). */
+	estimated_events: string | number | bigint | null;
+	/** Events processed so far — written by the progress flush. */
+	processed_events: string | number | bigint | null;
+	/** Backfill ops' own crash checkpoint — advanced conditionally in-tx with
+	*  each written block; replays skip at/below it. NULL for reindex ops
+	*  (those checkpoint on subgraphs.last_processed_block). */
+	cursor_block: string | number | bigint | null;
+}
+interface ApiKeysTable {
+	id: Generated<string>;
+	key_hash: string;
+	key_prefix: string;
+	name: string | null;
+	status: Generated<string>;
+	rate_limit: Generated<number>;
+	ip_address: string;
+	account_id: string;
+	product: Generated<"account" | "streams" | "index" | "sentinel" | "docs" | "tenant">;
+	/** Sentinel permission areas; set only on `product = 'sentinel'` keys. */
+	areas: unknown | null;
+	tier: "free" | "build" | "scale" | "enterprise" | "internal" | null;
+	last_used_at: Date | null;
+	revoked_at: Date | null;
+	/** Set only on `docs` keys (24h). A key past this instant never authenticates. */
+	expires_at: Date | null;
+	created_at: Generated<Date>;
+}
+/** Singleton self-host / publisher identity. Network is immutable. */
+interface InstancesTable {
+	id: Generated<string>;
+	network: string;
+	created_at: Generated<Date>;
+}
+interface AccountsTable {
+	id: Generated<string>;
+	/** NULL for unclaimed ghost accounts (anonymous self-serve keys). */
+	email: string | null;
+	/** True for anonymous self-serve accounts until claimed via magic link. */
+	ghost: Generated<boolean>;
+	/** First-party service account: usage priced at $0, never gated on
+	*  credits. Set by ops only. */
+	internal: Generated<boolean>;
+	/** Stacks principal owning a wallet-ghost account. */
+	wallet_principal: string | null;
+	display_name: string | null;
+	bio: string | null;
+	avatar_url: string | null;
+	stripe_customer_id: string | null;
+	/** Opt-out toggle for the subgraph reindex-completion email. Defaults true. */
+	notify_reindex_complete: Generated<boolean>;
+	created_at: Generated<Date>;
+}
+interface SessionsTable {
+	id: Generated<string>;
+	token_hash: string;
+	token_prefix: string;
+	account_id: string;
+	ip_address: string;
+	expires_at: Generated<Date>;
+	revoked_at: Date | null;
+	last_used_at: Date | null;
+	created_at: Generated<Date>;
+}
+interface MagicLinksTable {
+	id: Generated<string>;
+	email: string;
+	token: string;
+	code: string | null;
+	expires_at: Date;
+	used_at: Date | null;
+	failed_attempts: Generated<number>;
+	created_at: Generated<Date>;
+}
+interface SubgraphProcessingStatsTable {
+	id: Generated<string>;
+	subgraph_name: string;
+	api_key_id: string | null;
+	bucket_start: Date | null;
+	bucket_end: Date | null;
+	blocks_processed: number | null;
+	total_time_ms: number | null;
+	handler_time_ms: number | null;
+	flush_time_ms: number | null;
+	max_block_time_ms: number | null;
+	max_handler_time_ms: number | null;
+	avg_ops_per_block: number | null;
+	is_catchup: Generated<boolean>;
+	created_at: Generated<Date>;
+}
+interface SubgraphHealthSnapshotsTable {
+	id: Generated<string>;
+	subgraph_id: string;
+	total_processed: number;
+	total_errors: number;
+	last_processed_block: number | null;
+	chain_tip: string | number | null;
+	rows_written_total: string | number | null;
+	storage_bytes: string | number | null;
+	captured_at: Generated<Date>;
+}
+/** Handler errors grouped by fingerprint. Cap 50/subgraph. */
+interface SubgraphErrorGroupsTable {
+	id: Generated<string>;
+	subgraph_name: string;
+	fingerprint: string;
+	source_name: string;
+	event_type: string | null;
+	message: string;
+	frame: string | null;
+	count: Generated<string | number>;
+	sample_tx_id: string | null;
+	sample_block_height: string | number | null;
+	first_seen: Generated<Date>;
+	last_seen: Generated<Date>;
+}
+/**
+* One ranked dashboard insight. `account_id` is NULL on tenant and self-host
+* databases. `severity` is never "recovered": that is derived on read from
+* `resolved_at`.
+*/
+interface InsightsTable {
+	id: Generated<string>;
+	account_id: string | null;
+	resource_kind: string;
+	resource_id: string;
+	rule: string;
+	severity: string;
+	impact: Generated<number>;
+	/** resource, line, meta, lead, body, evidence, handoff, how. */
+	payload: unknown;
+	first_seen_at: Generated<Date>;
+	last_seen_at: Generated<Date>;
+	clear_streak: Generated<number>;
+	resolved_at: Date | null;
+	dismissed_at: Date | null;
+	snoozed_until: Date | null;
+}
+/** "Expected": mutes one rule for one resource until removed. */
+interface InsightMutesTable {
+	account_id: string | null;
+	resource_kind: string;
+	resource_id: string;
+	rule: string;
+	created_at: Generated<Date>;
+}
+interface ProcessedStripeEventsTable {
+	event_id: string;
+	event_type: string;
+	processed_at: Generated<Date>;
+}
+interface DecodedEventsTable {
+	cursor: string;
+	block_height: number;
+	tx_id: string;
+	tx_index: number;
+	event_index: number;
+	event_type: string;
+	microblock_hash: string | null;
+	canonical: Generated<boolean>;
+	contract_id: string | null;
+	sender: string | null;
+	recipient: string | null;
+	amount: string | null;
+	asset_identifier: string | null;
+	value: string | null;
+	memo: string | null;
+	/** Decoded payload for event types that don't fit the flat columns
+	*  (e.g. `print`: { topic, value, raw_value }). Null for transfer types. */
+	payload: unknown | null;
+	source_cursor: string;
+	created_at: Generated<Date>;
+}
+interface DecoderCheckpointsTable {
+	decoder_name: string;
+	last_cursor: string | null;
+	updated_at: Generated<Date>;
+}
+interface ChainReorgsTable {
+	id: Generated<string>;
+	detected_at: Generated<Date>;
+	fork_point_height: number;
+	old_index_block_hash: string | null;
+	new_index_block_hash: string | null;
+	orphaned_from_height: number;
+	orphaned_from_event_index: number;
+	orphaned_to_height: number;
+	orphaned_to_event_index: number;
+	new_canonical_height: number;
+	new_canonical_event_index: number;
+	created_at: Generated<Date>;
+}
+type Pox4FunctionName = "stack-stx" | "delegate-stx" | "stack-extend" | "stack-increase" | "revoke-delegate-stx" | "delegate-stack-stx" | "delegate-stack-extend" | "delegate-stack-increase" | "stack-aggregation-commit" | "stack-aggregation-commit-indexed" | "stack-aggregation-increase" | "set-signer-key-authorization";
+interface Pox4CallsTable {
+	cursor: string;
+	block_height: number;
+	block_time: Date;
+	burn_block_height: number;
+	tx_id: string;
+	tx_index: number;
+	function_name: Pox4FunctionName;
+	caller: string;
+	stacker: string | null;
+	delegate_to: string | null;
+	amount_ustx: string | null;
+	lock_period: number | null;
+	pox_addr_version: number | null;
+	pox_addr_hashbytes: string | null;
+	pox_addr_btc: string | null;
+	start_cycle: number | null;
+	end_cycle: number | null;
+	signer_key: string | null;
+	signer_signature: string | null;
+	auth_id: string | null;
+	max_amount: string | null;
+	reward_cycle: number | null;
+	aggregated_amount_ustx: string | null;
+	aggregated_signer_index: number | null;
+	auth_period: number | null;
+	auth_topic: string | null;
+	auth_allowed: boolean | null;
+	result_ok: boolean;
+	result_raw: string;
+	canonical: Generated<boolean>;
+	source_cursor: string;
+	created_at: Generated<Date>;
+}
+type Pox5EventTopic = "set-bond-admin" | "set-pause-admin" | "pause-rewards" | "setup-bond" | "add-to-allowlist" | "register-for-bond" | "update-bond-registration" | "register-signer" | "stake" | "stake-update" | "announce-l1-early-exit" | "unstake-sbtc" | "unstake" | "calculate-rewards" | "bond-distribution" | "claim-rewards" | "claim-staker-rewards-for-signer" | "grant-signer-key" | "revoke-signer-grant";
+interface Pox5EventsTable {
+	cursor: string;
+	block_height: number;
+	block_time: Date;
+	tx_id: string;
+	tx_index: number;
+	event_index: number;
+	topic: Pox5EventTopic;
+	staker: string | null;
+	signer: string | null;
+	signer_manager: string | null;
+	bond_index: number | null;
+	amount_ustx: 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;
+	data: unknown;
+	canonical: Generated<boolean>;
+	source_cursor: string;
+	created_at: Generated<Date>;
+}
+interface Pox5CyclesTable {
+	reward_cycle: number;
+	start_burn_height: number;
+	prepare_start_burn_height: number;
+	end_burn_height: number;
+	total_stacked_ustx: string;
+	reward_eligible_ustx: string;
+	stakers: number;
+	signers_in_set: number;
+	/** bond index (as string) -> sats staked for this cycle. */
+	bond_sats: unknown;
+	bond_total_sats: string;
+	sbtc_custodied_sats: string;
+	rewards_allocated_stx: string;
+	rewards_allocated_bond: string;
+	reserve_deposit: string;
+	rewards_per_token_stx: string | null;
+	/** bond index (as string) -> cumulative rewards-per-sat for this cycle. */
+	rewards_per_token_bond: unknown;
+	distributions: number;
+	rewards_claimed: string;
+	computed_through_height: number;
+	updated_at: Generated<Date>;
+}
+interface Pox5CycleSignersTable {
+	reward_cycle: number;
+	signer: string;
+	delegated_ustx: string;
+	stx_only_ustx: string;
+	reward_shares_ustx: string;
+	in_set: boolean;
+	rewards_claimed: string;
+}
+interface BurnBlockRewardsTable {
+	cursor: string;
+	burn_block_height: number;
+	burn_block_hash: string;
+	reward_index: number;
+	recipient_btc: string;
+	amount_sats: string;
+	burn_amount: Generated<string>;
+	created_at: Generated<Date>;
+}
+interface BurnBlockRewardSlotsTable {
+	cursor: string;
+	burn_block_height: number;
+	burn_block_hash: string;
+	slot_index: number;
+	holder_btc: string;
+	created_at: Generated<Date>;
+}
+type SbtcEventTopic = "completed-deposit" | "withdrawal-create" | "withdrawal-accept" | "withdrawal-reject" | "key-rotation" | "update-protocol-contract";
+interface SbtcEventsTable {
+	cursor: string;
+	block_height: number;
+	block_time: Date;
+	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;
+	block_height_at_request: number | 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;
+	canonical: Generated<boolean>;
+	source_cursor: string;
+	created_at: Generated<Date>;
+}
+type SbtcTokenEventType = "transfer" | "mint" | "burn";
+interface SbtcTokenEventsTable {
+	cursor: string;
+	block_height: number;
+	block_time: Date;
+	tx_id: string;
+	tx_index: number;
+	event_index: number;
+	event_type: SbtcTokenEventType;
+	sender: string | null;
+	recipient: string | null;
+	amount: string;
+	memo: string | null;
+	canonical: Generated<boolean>;
+	source_cursor: string;
+	created_at: Generated<Date>;
+}
+/**
+* BTC L1 settlement status for sBTC withdrawal sweeps. Filled by the indexer's
+* settlement-confirmer worker, which polls our own bitcoind for confirmations of
+* each `withdrawal-accept`'s `sweep_txid` and surfaces real settlement on the
+* withdrawal lifecycle (the API's `settlement.{btc_confirmations,
+* settlement_confirmed}` placeholder). Keyed on `sweep_txid` (not `request_id`):
+* a request can produce more than one sweep over its life (RBF/rebroadcast), so
+* each broadcast keeps its own confirmation history.
+*/
+interface SbtcSettlementsTable {
+	sweep_txid: string;
+	request_id: number;
+	btc_confirmations: Generated<number>;
+	settlement_confirmed: Generated<boolean>;
+	/** Confirming Bitcoin block — null while the sweep is unconfirmed. */
+	block_hash: string | null;
+	block_height: number | null;
+	first_seen_at: Generated<Date>;
+	last_checked_at: Generated<Date>;
+	/** Set once, when `settlement_confirmed` first flips true. */
+	confirmed_at: Date | null;
+	updated_at: Generated<Date>;
+}
+type BnsNameEventTopic = "new-name" | "transfer-name" | "renew-name" | "burn-name" | "new-airdrop";
+interface BnsNameEventsTable {
+	cursor: string;
+	block_height: number;
+	block_time: Date;
+	tx_id: string;
+	tx_index: number;
+	event_index: number;
+	topic: BnsNameEventTopic;
+	namespace: string;
+	name: string;
+	fqn: string;
+	owner: string | null;
+	bns_id: string;
+	registered_at: number | null;
+	imported_at: number | null;
+	renewal_height: number | null;
+	stx_burn: string | null;
+	preordered_by: string | null;
+	hashed_salted_fqn_preorder: string | null;
+	canonical: Generated<boolean>;
+	source_cursor: string;
+	created_at: Generated<Date>;
+}
+type BnsNamespaceEventStatus = "launch" | "transfer-manager" | "freeze-manager" | "update-price-manager" | "freeze-price-manager" | "turn-off-manager-transfers";
+interface BnsNamespaceEventsTable {
+	cursor: string;
+	block_height: number;
+	block_time: Date;
+	tx_id: string;
+	tx_index: number;
+	event_index: number;
+	status: BnsNamespaceEventStatus;
+	namespace: string;
+	manager: string | null;
+	manager_frozen: boolean | null;
+	manager_transfers_disabled: boolean | null;
+	price_function: string | null;
+	price_frozen: boolean | null;
+	lifetime: number | null;
+	revealed_at: number | null;
+	launched_at: number | null;
+	canonical: Generated<boolean>;
+	source_cursor: string;
+	created_at: Generated<Date>;
+}
+type BnsMarketplaceAction = "list-in-ustx" | "unlist-in-ustx" | "buy-in-ustx";
+interface BnsMarketplaceEventsTable {
+	cursor: string;
+	block_height: number;
+	block_time: Date;
+	tx_id: string;
+	tx_index: number;
+	event_index: number;
+	action: BnsMarketplaceAction;
+	bns_id: string;
+	price_ustx: string | null;
+	commission: string | null;
+	canonical: Generated<boolean>;
+	source_cursor: string;
+	created_at: Generated<Date>;
+}
+interface BnsNamesTable {
+	fqn: string;
+	namespace: string;
+	name: string;
+	owner: string;
+	bns_id: string;
+	registered_at: number | null;
+	renewal_height: number | null;
+	last_event_cursor: string;
+	last_event_at: Date;
+	updated_at: Generated<Date>;
+}
+interface BnsNamespacesTable {
+	namespace: string;
+	manager: string | null;
+	manager_frozen: Generated<boolean>;
+	price_frozen: Generated<boolean>;
+	lifetime: number | null;
+	launched_at: number | null;
+	last_event_cursor: string;
+	last_event_at: Date;
+	name_count: Generated<number>;
+	updated_at: Generated<Date>;
+}
+/**
+* Memoized `ctx.client.readOnly()` results. Keyed on `index_block_hash` so a
+* reorg-replaced block never inherits the orphaned fork's answer; a NULL
+* `index_block_hash` marks a caller-declared contract-constant value, cached
+* once per contract+args instead of once per block.
+*/
+interface ChainReadCacheTable {
+	id: Generated<number>;
+	contract_id: string;
+	function_name: string;
+	args_hash: string;
+	index_block_hash: string | null;
+	block_height: ColumnType<number | null, number | null | undefined, number | null>;
+	result_hex: string;
+	created_at: Generated<Date>;
+}
+/**
+* A block that arrived for a height we already hold, staged until a later
+* block's `parent_hash` says which of the two the chain kept. See migration
+* 0112 — adopting on first sight picked the losing fork twice.
+*/
+interface PendingForkBlocksTable {
+	height: number;
+	block_hash: string;
+	parent_hash: string;
+	/** The canonical hash we held at this height when the contender arrived. */
+	incumbent_hash: string;
+	/** The raw observer payload, replayed verbatim if this fork wins. */
+	payload: ColumnType<unknown, unknown, unknown>;
+	received_at: Generated<Date>;
+}
+type ObserverJournalStatus = "received" | "processed" | "failed" | "retried";
+/**
+* Exact observer callback receipt. `raw_body` is immutable evidence; the
+* processing columns are updated only after the current derived-state write
+* succeeds or fails.
+*/
+interface ObserverJournalTable {
+	sequence: Generated<string>;
+	network: string;
+	path: string;
+	source: string | null;
+	received_at: Generated<Date>;
+	raw_body: ColumnType<Buffer, Buffer, Buffer>;
+	raw_body_sha256: string;
+	status: ColumnType<ObserverJournalStatus, ObserverJournalStatus | undefined, ObserverJournalStatus>;
+	semantic_sha256: string | null;
+	block_height: number | null;
+	block_hash: string | null;
+	burn_block_height: number | null;
+	burn_block_hash: string | null;
+	result: unknown | null;
+	error: string | null;
+	processed_at: Date | null;
+}
+/** Declared coverage stage. Identity is the `id` string (`raw`, `decode:stx`, …). */
+interface StageRegistryTable {
+	id: string;
+	kind: StageKind;
+	depends_on: string | null;
+	native_clock: NativeClock;
+	producer_version: string;
+	repair_mode: RepairMode;
+	enabled: Generated<boolean>;
+	created_at: Generated<Date>;
+}
+/** One versioned sweep of a stage. */
+interface StageRunsTable {
+	id: Generated<string>;
+	stage_id: string;
+	code_hash: string;
+	config_hash: string;
+	handler_hash: string | null;
+	target_height: number | null;
+	target_cursor: string | null;
+	status: RunStatus;
+	complete_through: number | null;
+	started_at: Generated<Date>;
+	finished_at: Date | null;
+}
+/** Per-block acknowledgement. Unique on (stage, height, hash). */
+interface StageBlockReceiptsTable {
+	id: Generated<string>;
+	stage_id: string;
+	run_id: string | null;
+	block_height: number;
+	block_hash: string;
+	input_count: number;
+	input_digest: string;
+	effect_digest: string;
+	finalized: Generated<boolean>;
+	compacted_at: Date | null;
+	created_at: Generated<Date>;
+}
+/** Compacted finalized range. Only sealed after receipts in the range finalize. */
+interface CoverageSegmentsTable {
+	id: Generated<string>;
+	stage_id: string;
+	from_height: number;
+	to_height: number;
+	chain_digest: string;
+	input_digest: string;
+	output_digest: string;
+	sealed_at: Generated<Date>;
+}
+/** Exact unit or range that failed, plus retry/retention state. */
+interface StageFailuresTable {
+	id: Generated<string>;
+	stage_id: string;
+	run_id: string | null;
+	unit_kind: FailureUnit;
+	from_height: number | null;
+	to_height: number | null;
+	class: FailureClass;
+	retry_state: RetryState;
+	retry_count: Generated<number>;
+	last_error: string | null;
+	created_at: Generated<Date>;
+	resolved_at: Date | null;
+	retain_until: Generated<Date>;
+}
+/**
+* The instance's declared scope — one row per network. `start_height` is what
+* makes missing history below it deliberate rather than a gap.
+*/
+interface SyncScopesTable {
+	network: string;
+	start_height: number;
+	target_height: number | null;
+	bootstrap_source: BootstrapSource;
+	bootstrap_manifest_digest: string | null;
+	genesis_hash: string | null;
+	created_at: Generated<Date>;
+	updated_at: Generated<Date>;
+}
+interface Database {
+	blocks: BlocksTable;
+	transactions: TransactionsTable;
+	events: EventsTable;
+	vm_events: VmEventsTable;
+	state_writes: StateWritesTable;
+	transactions_archive: TransactionsArchiveTable;
+	events_archive: EventsArchiveTable;
+	vm_events_archive: VmEventsArchiveTable;
+	state_writes_archive: StateWritesArchiveTable;
+	dead_letter_events: DeadLetterEventsTable;
+	mempool_transactions: MempoolTransactionsTable;
+	index_progress: IndexProgressTable;
+	contracts: ContractsTable;
+	subgraphs: SubgraphsTable;
+	api_keys: ApiKeysTable;
+	instances: InstancesTable;
+	accounts: AccountsTable;
+	sessions: SessionsTable;
+	magic_links: MagicLinksTable;
+	subgraph_health_snapshots: SubgraphHealthSnapshotsTable;
+	subgraph_processing_stats: SubgraphProcessingStatsTable;
+	subgraph_gaps: SubgraphGapsTable;
+	subgraph_violations: SubgraphViolationsTable;
+	subgraph_error_groups: SubgraphErrorGroupsTable;
+	subgraph_operations: SubgraphOperationsTable;
+	processed_stripe_events: ProcessedStripeEventsTable;
+	account_spend_caps: AccountSpendCapsTable;
+	account_credits: AccountCreditsTable;
+	webhooks: WebhooksTable;
+	webhook_outbox: WebhookOutboxTable;
+	webhook_deliveries: WebhookDeliveriesTable;
+	webhook_replays: WebhookReplaysTable;
+	trigger_evaluator_state: TriggerEvaluatorStateTable;
+	decoded_events: DecodedEventsTable;
+	decoder_checkpoints: DecoderCheckpointsTable;
+	chain_reorgs: ChainReorgsTable;
+	pox4_calls: Pox4CallsTable;
+	pox5_events: Pox5EventsTable;
+	pox5_cycles: Pox5CyclesTable;
+	pox5_cycle_signers: Pox5CycleSignersTable;
+	burn_block_rewards: BurnBlockRewardsTable;
+	burn_block_reward_slots: BurnBlockRewardSlotsTable;
+	sbtc_events: SbtcEventsTable;
+	sbtc_token_events: SbtcTokenEventsTable;
+	sbtc_settlements: SbtcSettlementsTable;
+	bns_name_events: BnsNameEventsTable;
+	bns_namespace_events: BnsNamespaceEventsTable;
+	bns_marketplace_events: BnsMarketplaceEventsTable;
+	bns_names: BnsNamesTable;
+	bns_namespaces: BnsNamespacesTable;
+	service_heartbeats: ServiceHeartbeatsTable;
+	chain_read_cache: ChainReadCacheTable;
+	pending_fork_blocks: PendingForkBlocksTable;
+	observer_journal: ObserverJournalTable;
+	sync_scopes: SyncScopesTable;
+	stage_registry: StageRegistryTable;
+	stage_runs: StageRunsTable;
+	stage_block_receipts: StageBlockReceiptsTable;
+	coverage_segments: CoverageSegmentsTable;
+	stage_failures: StageFailuresTable;
+	archive_fetches: ArchiveFetchesTable;
+	usage_ledger: UsageLedgerTable;
+	account_balance_alerts: AccountBalanceAlertsTable;
+	webhook_incident_alerts: WebhookIncidentAlertsTable;
+	cli_device_logins: CliDeviceLoginsTable;
+	oauth_clients: OauthClientsTable;
+	oauth_requests: OauthRequestsTable;
+	oauth_codes: OauthCodesTable;
+	oauth_grants: OauthGrantsTable;
+	oauth_tokens: OauthTokensTable;
+	oauth_refresh_retired: OauthRefreshRetiredTable;
+	sentinel_accounts: SentinelAccountsTable;
+	waitlists: WaitlistsTable;
+	waitlist_signups: WaitlistSignupsTable;
+	contact_requests: ContactRequestsTable;
+	api_failed_requests: ApiFailedRequestsTable;
+	api_request_log: ApiRequestLogTable;
+	insights: InsightsTable;
+	insight_mutes: InsightMutesTable;
+	feedback_tickets: FeedbackTicketsTable;
+	push_subscriptions: PushSubscriptionsTable;
+	push_prefs: PushPrefsTable;
+	push_sent: PushSentTable;
+}
+interface ServiceHeartbeatsTable {
+	name: string;
+	updated_at: Generated<Date>;
+}
+interface AccountSpendCapsTable {
+	account_id: string;
+	monthly_cap_cents: number | null;
+	compute_cap_cents: number | null;
+	storage_cap_cents: number | null;
+	alert_threshold_pct: Generated<number>;
+	alert_sent_at: Date | null;
+	frozen_at: Date | null;
+	updated_at: Generated<Date>;
+}
+/** Prepaid dev credits — card-funded balance per account. */
+interface AccountCreditsTable {
+	account_id: string;
+	balance_usd_micros: Generated<string | number | bigint>;
+	/** Month bucket ("YYYY-MM") the spend counter applies to. */
+	spent_month: string | null;
+	spent_month_usd_micros: Generated<string | number | bigint>;
+	/** Null = auto-refill off. */
+	refill_below_usd_micros: string | number | bigint | null;
+	refill_pack_usd: number | null;
+	refill_last_at: Date | null;
+	updated_at: Generated<Date>;
+}
+/**
+* Archive fetch charge log. Append-only: one row per
+* priced attempt to fetch a partition object. `usd_micros` is 0 for
+* free rows (24h re-issue, monthly repair allowance).
+*/
+interface ArchiveFetchesTable {
+	id: Generated<string>;
+	account_id: string;
+	path: string;
+	dataset: string;
+	usd_micros: string | number | bigint;
+	via_allowance: Generated<boolean>;
+	charged_at: Generated<Date>;
+}
+/**
+* One metered ledger for every billable unit (archive partitions, hosted
+* Index/Streams rows, and future hosted-stack meters). Append-only, written
+* only by `meter()`. `idempotency_key` is UNIQUE so a retried submission
+* no-ops instead of double-charging. `debited` is false when the balance
+* (or a spend cap) refused the charge — the row still exists so the gap is
+* visible, never silently dropped. `usd_micros` is negative for a Stripe
+* top-up (`unit: "topup"`).
+*/
+interface UsageLedgerTable {
+	id: Generated<string>;
+	account_id: string;
+	unit: string;
+	quantity: string | number | bigint;
+	/** Raw sampled quantity before any floor (e.g. `memory.gb_hour`'s actual
+	*  RAM, before the 0.5 GB minimum). NULL for every unit that has no
+	*  floor to observe past. */
+	observed_quantity: string | number | null;
+	usd_micros: string | number | bigint;
+	debited: Generated<boolean>;
+	source: string;
+	/** API key behind a metered read; null for non-read units and older rows. */
+	api_key_id: string | null;
+	idempotency_key: string;
+	occurred_at: Generated<Date>;
+	recorded_at: Generated<Date>;
+}
+/** Preferences + debounce state for the balance-runway email alerts. One
+*  row per account; a missing row means both alerts are on (defaults). */
+interface AccountBalanceAlertsTable {
+	account_id: string;
+	notify_7d: Generated<boolean>;
+	notify_2d: Generated<boolean>;
+	sent_7d_at: Date | null;
+	sent_2d_at: Date | null;
+	sent_stopped_at: Date | null;
+}
+/** Debounce state for the webhook-down email: one row per incident, open
+*  while `resolved_at` is null. No preference columns by design. */
+interface WebhookIncidentAlertsTable {
+	id: Generated<string>;
+	account_id: string;
+	webhook_id: string;
+	webhook_name: string;
+	failing_since: Date;
+	opened_at: Generated<Date>;
+	emailed_at: Date | null;
+	email_attempts: Generated<number>;
+	resolved_at: Date | null;
+}
+/** One browser/device push subscription; the endpoint is unique. */
+interface PushSubscriptionsTable {
+	id: Generated<string>;
+	account_id: string;
+	endpoint: string;
+	p256dh: string;
+	auth: string;
+	user_agent: string | null;
+	created_at: Generated<Date>;
+	last_success_at: Date | null;
+	failed_count: Generated<number>;
+}
+/** Per-account push toggles. A missing row means the column defaults. */
+interface PushPrefsTable {
+	account_id: string;
+	webhook_failing: Generated<boolean>;
+	subgraph_stopped: Generated<boolean>;
+	subgraph_not_serving: Generated<boolean>;
+	replay_done: Generated<boolean>;
+	spend_cap: Generated<boolean>;
+	key_repeat: Generated<boolean>;
+	updated_at: Generated<Date>;
+}
+/** A push already sent, keyed by what it was about; debounces repeat signals. */
+interface PushSentTable {
+	account_id: string;
+	key: string;
+	kind: string;
+	sent_at: Generated<Date>;
+}
+type CliDeviceLoginStatus = "pending" | "approved" | "denied" | "consumed";
+/** The product that started a CLI sign-in; null is `sl login`. */
+type CliDeviceProduct = "sentinel";
+/** One browser sign-in attempt from `sl login` (or `sentinel login`). Only the
+*  hash of the CLI's device code is stored; the session is opened when the CLI
+*  polls after approval. */
+interface CliDeviceLoginsTable {
+	id: Generated<string>;
+	device_code_hash: string;
+	user_code: string;
+	client_name: string;
+	product: CliDeviceProduct | null;
+	status: Generated<CliDeviceLoginStatus>;
+	account_id: string | null;
+	key_name: string | null;
+	created_at: Generated<Date>;
+	expires_at: Date;
+	approved_at: Date | null;
+	consumed_at: Date | null;
+}
+/** An app that registered itself (RFC 7591). Public clients only: no secret. */
+interface OauthClientsTable {
+	id: string;
+	/** The app's own claim, validated at registration; shown quoted. */
+	name: string;
+	redirect_uris: string[];
+	created_ip: string | null;
+	created_at: Generated<Date>;
+	/** Set when it first gets tokens; never-used clients are purged. */
+	last_used_at: Date | null;
+}
+type OauthRequestStatus = "pending" | "approved" | "denied";
+/** One authorize request waiting for (or answered on) the consent page. */
+interface OauthRequestsTable {
+	id: string;
+	client_id: string;
+	redirect_uri: string;
+	state: string | null;
+	code_challenge: string;
+	resource: string;
+	status: Generated<OauthRequestStatus>;
+	account_id: string | null;
+	created_at: Generated<Date>;
+	expires_at: Date;
+	answered_at: Date | null;
+}
+/** A one-time authorization code, bound to its client, redirect, PKCE
+*  challenge, resource and account. */
+interface OauthCodesTable {
+	code_hash: string;
+	client_id: string;
+	account_id: string;
+	redirect_uri: string;
+	code_challenge: string;
+	resource: string;
+	/** The grant its one use made, so a replay can revoke it. */
+	grant_id: string | null;
+	created_at: Generated<Date>;
+	expires_at: Date;
+	used_at: Date | null;
+}
+/** What a person allowed one app to do: use the hosted MCP as them. */
+interface OauthGrantsTable {
+	id: Generated<string>;
+	account_id: string;
+	client_id: string;
+	scope: Generated<string>;
+	resource: string;
+	created_at: Generated<Date>;
+	last_used_at: Date | null;
+	revoked_at: Date | null;
+}
+type OauthTokenKind = "access" | "refresh";
+interface OauthTokensTable {
+	token_hash: string;
+	grant_id: string;
+	kind: OauthTokenKind;
+	created_at: Generated<Date>;
+	expires_at: Date;
+}
+/** A refresh token a rotation replaced: presented again, it revokes the grant. */
+interface OauthRefreshRetiredTable {
+	token_hash: string;
+	grant_id: string;
+	retired_at: Generated<Date>;
+}
+/** Accounts Sentinel's service key may touch: created by Sentinel, or the
+*  owner opted in. */
+interface SentinelAccountsTable {
+	account_id: string;
+	linked_at: Generated<Date>;
+	via: "created" | "consent";
+}
+type WebhookStatus2 = "active" | "paused" | "error";
+/** Webhooks react to raw chain events matched directly off the Index/Streams
+*  clock. `chain` is the only kind since migration 0159 removed subgraph-row
+*  webhooks; the column stays as the discriminator. */
+type WebhookKind2 = "chain";
+type WebhookFormat2 = "standard-webhooks" | "inngest" | "trigger" | "cloudflare" | "cloudevents" | "raw";
+interface WebhooksTable {
+	id: Generated<string>;
+	account_id: string;
+	project_id: string | null;
+	name: string;
+	status: ColumnType<WebhookStatus2, WebhookStatus2 | undefined, WebhookStatus2>;
+	kind: ColumnType<WebhookKind2, WebhookKind2 | undefined, WebhookKind2>;
+	/** Chain-trigger filter array (the `SubgraphFilter` shape, JSON). Typed
+	*  loosely here to avoid a shared→subgraphs import cycle; the Zod schema in
+	*  schemas/webhooks.ts owns the shape. */
+	triggers: unknown;
+	format: ColumnType<WebhookFormat2, WebhookFormat2 | undefined, WebhookFormat2>;
+	url: string;
+	signing_secret_enc: Buffer;
+	auth_config: Generated<unknown>;
+	max_retries: Generated<number>;
+	timeout_ms: Generated<number>;
+	concurrency: Generated<number>;
+	circuit_failures: Generated<number>;
+	circuit_opened_at: Date | null;
+	last_delivery_at: Date | null;
+	last_success_at: Date | null;
+	last_error: string | null;
+	/** Receiver TLS leaf certificate expiry, from the emitter's periodic probe. */
+	receiver_cert_expires_at: Date | null;
+	receiver_cert_checked_at: Date | null;
+	created_at: Generated<Date>;
+	updated_at: Generated<Date>;
+}
+type OutboxStatus = "pending" | "delivered" | "dead";
+interface WebhookOutboxTable {
+	id: Generated<string>;
+	webhook_id: string;
+	kind: ColumnType<WebhookKind2, WebhookKind2 | undefined, WebhookKind2>;
+	block_height: number | bigint;
+	tx_id: string | null;
+	row_pk: unknown;
+	event_type: string;
+	payload: unknown;
+	dedup_key: string;
+	attempt: Generated<number>;
+	next_attempt_at: Generated<Date>;
+	status: ColumnType<OutboxStatus, OutboxStatus | undefined, OutboxStatus>;
+	is_replay: Generated<boolean>;
+	/** The replay that created this row; null for live rows. */
+	replay_id: string | null;
+	/** The chain block_time of the matched event/tx. Null for rows written
+	*  before this column existed, and for the settlement scan path (not yet
+	*  wired). Lets `delivered_at - block_time` measure end-to-end webhook
+	*  latency without a join to SOURCE-plane `blocks`. */
+	block_time: Date | null;
+	delivered_at: Date | null;
+	failed_at: Date | null;
+	locked_by: string | null;
+	locked_until: Date | null;
+	/** Set when a reorg marks an in-flight row `dead` instead of retrying it
+	*  into an orphaned fork. Null otherwise — delivery failures track their
+	*  history on `webhooks.last_error`, not per-row. */
+	last_error: string | null;
+	created_at: Generated<Date>;
+}
+type WebhookReplayStatus = "scanning" | "running" | "done" | "failed";
+interface WebhookReplaysTable {
+	id: string;
+	webhook_id: string;
+	from_block: number | bigint;
+	to_block: number | bigint;
+	status: WebhookReplayStatus;
+	scanned_count: Generated<number>;
+	enqueued_count: Generated<number>;
+	total: number | null;
+	delivered: number | null;
+	gave_up: number | null;
+	error: string | null;
+	started_at: Generated<Date>;
+	finished_at: Date | null;
+}
+type WebhookReplay = Selectable<WebhookReplaysTable>;
+interface WebhookDeliveriesTable {
+	id: Generated<string>;
+	/** Nullable after migration 0077 — outbox row may be cleaned up while
+	*  delivery telemetry is retained. */
+	outbox_id: string | null;
+	webhook_id: string;
+	attempt: number;
+	status_code: number | null;
+	response_headers: unknown | null;
+	response_body: string | null;
+	error_message: string | null;
+	duration_ms: number | null;
+	dispatched_at: Generated<Date>;
+}
+/** Single-row (id always TRUE) high-water mark for the chain-trigger evaluator.
+*  One loop serves all chain webhooks, so the cursor is global. */
+interface TriggerEvaluatorStateTable {
+	id: Generated<boolean>;
+	last_processed_block: ColumnType<bigint, bigint | number | undefined, bigint | number>;
+	/** Watermark for the async sBTC settlement-confirmed webhook scan; null until
+	*  the evaluator fast-forwards it on first run. */
+	last_settlement_scan_at: ColumnType<Date | null, Date | null | undefined, Date | null>;
+	/** Streams cursor (`<block_height>:<event_index>`) for the Bitcoin (Runes)
+	*  chain-trigger evaluator (plan 060) — a separate clock from
+	*  `last_processed_block` (Stacks). Null until the evaluator fast-forwards
+	*  it to the Bitcoin Streams tip on first run. */
+	bitcoin_last_cursor: ColumnType<string | null, string | null | undefined, string | null>;
+	updated_at: Generated<Date>;
+}
+/** A public waitlist page: what it is for and whether it takes signups. */
+interface WaitlistsTable {
+	slug: string;
+	title: string;
+	description: string;
+	url: string;
+	opened_at: Generated<Date>;
+	/** Null while the list is open. */
+	closed_at: Date | null;
+}
+/**
+* One signup per (list, contact, token). `answers` holds the list's own
+* questions, validated per list by the API before insert.
+*/
+interface WaitlistSignupsTable {
+	id: Generated<string>;
+	list: string;
+	contact: string;
+	answers: Record<string, unknown>;
+	created_at: Generated<Date>;
+}
+/**
+* A "Talk to us" message. Stored before the operator is emailed;
+* `notified_at` stays null until the email goes out.
+*/
+interface ContactRequestsTable {
+	id: Generated<string>;
+	name: string;
+	email: string;
+	company: string | null;
+	volume: "lt10m" | "10m-100m" | "100m-1b" | "gt1b" | "unsure" | null;
+	message: string;
+	source_page: string | null;
+	account_id: string | null;
+	/** Hex sha256 of the client IP, never the address. */
+	ip_hash: string | null;
+	notified_at: Date | null;
+	created_at: Generated<Date>;
+}
+/**
+* 24h hosted record of a failed API request, keyed by `request_id` and
+* scoped to the account that made it. `query` is redacted before insert.
+*/
+interface ApiFailedRequestsTable {
+	request_id: string;
+	account_id: string;
+	method: string;
+	path: string;
+	status: number;
+	code: string;
+	message: Generated<string>;
+	query: Record<string, unknown>;
+	origin: string | null;
+	/** Revoked account key the request presented (`KEY_REVOKED` only). */
+	api_key_id: string | null;
+	created_at: Generated<Date>;
+}
+/**
+* 7-day hosted log of account-attributed Index/Streams reads. Query values
+* are stored only as hashes; never bodies, headers or tokens.
+*/
+interface ApiRequestLogTable {
+	id: Generated<string>;
+	request_id: string | null;
+	account_id: string;
+	api_key_id: string | null;
+	method: string;
+	path: string;
+	path_template: string;
+	params_hash: string | null;
+	cursor_hash: string | null;
+	page_size: number | null;
+	rows: number | null;
+	status: number;
+	duration_ms: number;
+	created_at: Generated<Date>;
+}
+/**
+* Hosted problem report. `attempted` is the server's own copy of the failed
+* request (never caller-supplied); `status` starts `new` until classified.
+*/
+interface FeedbackTicketsTable {
+	id: Generated<string>;
+	account_id: string;
+	idempotency_key: string | null;
+	request_id: string | null;
+	intent: string;
+	expected: Record<string, unknown> | null;
+	kind_hint: string | null;
+	evidence: Record<string, unknown> | null;
+	attempted: Record<string, unknown> | null;
+	origin: string;
+	status: Generated<"new" | "classified">;
+	route: string | null;
+	classification: Record<string, unknown> | null;
+	classified_at: Date | null;
+	created_at: Generated<Date>;
+}
+/** Thrown by {@link beginReplay} when a replay is still scanning for the
+*  webhook. The route maps this to 409; `force` does not bypass it. */
+declare class ReplayInProgressError extends Error {
+	constructor();
+}
+declare function beginReplay(db: Kysely<Database>, input: {
+	id: string
+	webhookId: string
+	fromBlock: number
+	toBlock: number
+}): Promise<void>;
+declare function finishScan(db: Kysely<Database>, id: string, counts: {
+	scanned: number
+	enqueued: number
+}): Promise<void>;
+declare function failScan(db: Kysely<Database>, id: string, error: string): Promise<void>;
+/** Outbox rows of this replay still waiting to be delivered or to give up. */
+declare function pendingCount(db: Kysely<Database>, id: string): Promise<number>;
+/** Outbox rows of this replay that gave up. Finalize only; never on a poll. */
+declare function deadCount(db: Kysely<Database>, webhookId: string, id: string): Promise<number>;
+declare function progressOf(record: WebhookReplay, pending: number): ReplayProgress;
+declare function readReplay(db: Kysely<Database>, webhookId: string, id: string): Promise<ReplayProgress | null>;
+/** Replays in progress or started within `sinceHours`, newest first. */
+declare function listReplays(db: Kysely<Database>, input: {
+	webhookIds: string[]
+	sinceHours: number
+	limit: number
+}): Promise<ReplayProgress[]>;
+/** Newest replays of one webhook, finalizing any that have drained. */
+declare function listWebhookReplays(db: Kysely<Database>, webhookId: string, limit: number): Promise<ReplayProgress[]>;
+/** Retention backstop: finalize every running replay that has drained. */
+declare function finalizeReplays(db: Kysely<Database>): Promise<void>;
+declare function deadSince(db: Kysely<Database>, webhookId: string, since: Date | null): Promise<number>;
+declare function knownEventsInRange(db: Kysely<Database>, webhookId: string, from: number, to: number): Promise<number>;
+export { ReplayInProgressError, beginReplay, deadCount, deadSince, failScan, finalizeReplays, finishScan, knownEventsInRange, listReplays, listWebhookReplays, pendingCount, progressOf, readReplay };