@secondlayer/shared 7.9.0 → 7.11.0

package/dist/src/coverage/index.d.ts

@@ -0,0 +1,1670 @@
+/**
+* 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];
+/** Default failure retention after `created_at`. */
+declare const FAILURE_RETENTION_DAYS = 30;
+type CoverageRange = {
+	from_height: number
+	to_height: number
+};
+type ReceiptRow = {
+	block_height: number
+	input_count: number
+	finalized: boolean
+	compacted_at: Date | null
+};
+type FailureRow = {
+	from_height: number | null
+	to_height: number | null
+	retry_state: RetryState
+	retry_count: number
+	resolved_at: Date | null
+	created_at: Date
+	retain_until: Date
+};
+declare function isStageKind(value: string): value is StageKind;
+declare function isNativeClock(value: string): value is NativeClock;
+declare function isRepairMode(value: string): value is RepairMode;
+declare function isRunStatus(value: string): value is RunStatus;
+declare function isFailureUnit(value: string): value is FailureUnit;
+declare function isFailureClass(value: string): value is FailureClass;
+declare function isRetryState(value: string): value is RetryState;
+declare function isNonNegativeInt(value: number): boolean;
+declare function rangeIsOrdered(from: number, to: number): boolean;
+/** Compacted receipts must already be finalized. */
+declare function receiptRetentionHolds(row: ReceiptRow): boolean;
+declare function failureRangeHolds(row: FailureRow): boolean;
+/** Resolved rows need `resolved_at`; open rows keep `retain_until` ≥ created. */
+declare function failureRetentionHolds(row: FailureRow): boolean;
+/** Two closed ranges on the same stage must not overlap. */
+declare function segmentsOverlap(a: CoverageRange, b: CoverageRange): boolean;
+declare function defaultRetainUntil(createdAt: Date): Date;
+declare const COVERAGE_REPORT_SCHEMA_VERSION: 1;
+declare const COVERAGE_STATES: readonly ["complete", "syncing", "lagging", "gap", "stale", "failed", "unverified_import", "unanchored", "source_unavailable", "out_of_scope", "disabled"];
+type CoverageState = (typeof COVERAGE_STATES)[number];
+type BootstrapSource = "archive" | "genesis" | "import";
+type SyncScope = {
+	network: string
+	start_height: number
+	target_height: number | null
+	bootstrap: {
+		source: BootstrapSource
+		manifest_digest: string | null
+		genesis_hash: string | null
+	}
+};
+type StageDeclaration = {
+	id: string
+	kind: StageKind
+	depends_on: string | null
+	native_clock: NativeClock
+	producer_version: string
+	repair_mode: RepairMode
+	enabled: boolean
+};
+type StageRunView = {
+	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
+};
+type OpenFailure = {
+	unit_kind: FailureUnit
+	class: FailureClass
+	retry_state: Exclude<RetryState, "resolved">
+	from_height: number | null
+	to_height: number | null
+};
+type QueueCounters = {
+	accepted: number
+	decided: number
+	enqueued: number
+	delivered: number
+	dead: number
+	fence_cursor: string | null
+};
+type StageEvidence = {
+	stage_id: string
+	ranges: CoverageRange[]
+	open_failures: OpenFailure[]
+	cursor: string | null
+	queue: QueueCounters | null
+	unanchored: boolean
+	unverified_import: boolean
+	/** False when this stage's native source (node, bitcoin RPC, …) is down. */
+	source_available: boolean
+};
+type SourceClock = {
+	tip_height: number | null
+	finalized_height: number | null
+	observed_at: string | null
+};
+type EvaluatorOptions = {
+	now: Date
+	maxBlocksBehindFinalized?: number
+	maxSourceAgeSeconds?: number
+};
+type EvaluatorInput = {
+	scope: SyncScope
+	stages: StageDeclaration[]
+	runs: StageRunView[]
+	evidence: StageEvidence[]
+	source: SourceClock
+	options: EvaluatorOptions
+};
+type StageCoverage = {
+	stage_id: string
+	kind: StageKind
+	native_clock: NativeClock
+	depends_on: string | null
+	state: CoverageState
+	detail: string
+	complete_through: number | null
+	source_tip: number | null
+	finalized_height: number | null
+	recorded_target: number | null
+	declared_range: {
+		from_height: number
+		to_height: number
+	} | null
+	gaps: CoverageRange[]
+	caught_up: boolean
+	blocked_by: string | null
+};
+type CoverageReport = {
+	schema_version: typeof COVERAGE_REPORT_SCHEMA_VERSION
+	network: string
+	generated_at: string
+	source_tip: number | null
+	finalized_height: number | null
+	stages: StageCoverage[]
+	evaluation_order: string[]
+	cycles: string[][]
+};
+declare function mergeRanges(ranges: readonly CoverageRange[]): CoverageRange[];
+/** Highest height reachable from `start` without a hole. */
+declare function contiguousThrough(ranges: readonly CoverageRange[], start: number): number | null;
+declare function findRangeGaps(ranges: readonly CoverageRange[], from: number, to: number): CoverageRange[];
+declare function cursorHeight(cursor: string | null): number | null;
+declare function topoSort(stages: readonly StageDeclaration[]): {
+	order: string[]
+	cycles: string[][]
+};
+declare function evaluateCoverage(input: EvaluatorInput): CoverageReport;
+declare const RUNNER_STATUSES: readonly ["pending", "running", "complete", "failed", "halted"];
+type RunnerStatus = (typeof RUNNER_STATUSES)[number];
+declare const RUNNER_EVENT_TYPES: readonly ["start", "ack", "fail", "retry", "halt", "resume", "reorg", "version", "finish"];
+type RunnerEventType = (typeof RUNNER_EVENT_TYPES)[number];
+declare const DEFAULT_MAX_RETRIES = 3;
+type RunnerVersion = {
+	code_hash: string
+	config_hash: string
+	handler_hash: string | null
+};
+type RunnerFailure = {
+	unit_kind: FailureUnit
+	class: FailureClass
+	retry_state: Exclude<RetryState, "resolved">
+	from_height: number | null
+	to_height: number | null
+	error: string | null
+};
+type RunnerState = {
+	stage_id: string
+	status: RunnerStatus
+	version: RunnerVersion
+	start_height: number
+	target_height: number | null
+	complete_through: number | null
+	last_acked_hash: string | null
+	retry_count: number
+	open_failure: RunnerFailure | null
+};
+type RunnerEvent = {
+	type: "start"
+} | {
+	type: "ack"
+	height: number
+	hash: string
+	input_count: number
+	input_digest: string
+	effect_digest: string
+} | {
+	type: "fail"
+	unit_kind: FailureUnit
+	class: FailureClass
+	from_height: number | null
+	to_height: number | null
+	error: string | null
+} | {
+	type: "retry"
+} | {
+	type: "halt"
+} | {
+	type: "resume"
+} | {
+	type: "reorg"
+	fork_point: number
+} | {
+	type: "version"
+	version: RunnerVersion
+} | {
+	type: "finish"
+};
+type RunnerEffect = {
+	type: "invalidate_receipts"
+	range: CoverageRange
+} | {
+	type: "spawn_run"
+	version: RunnerVersion
+} | {
+	type: "open_failure"
+	failure: RunnerFailure
+} | {
+	type: "resolve_failure"
+};
+type RunnerResult = {
+	ok: true
+	state: RunnerState
+	effects: RunnerEffect[]
+} | {
+	ok: false
+	reason: string
+	state: RunnerState
+};
+type TransitionRule = {
+	from: RunnerStatus
+	event: RunnerEventType
+	to: RunnerStatus | "reject"
+};
+/**
+* Structural transition table. Guards (order, retry budget, version
+* equality, reorg overlap) are applied on top in `applyRunnerEvent`.
+*/
+declare const RUNNER_TRANSITION_TABLE: readonly TransitionRule[];
+declare function lookupTransition(from: RunnerStatus, event: RunnerEventType): TransitionRule;
+declare function versionsEqual(a: RunnerVersion, b: RunnerVersion): boolean;
+/** Next height this run must acknowledge. */
+declare function expectedAckHeight(state: RunnerState): number;
+declare function createRunnerState(init: {
+	stage_id: string
+	start_height: number
+	target_height?: number | null
+	version: RunnerVersion
+}): RunnerState;
+declare function applyRunnerEvent(state: RunnerState, event: RunnerEvent, opts?: {
+	maxRetries?: number
+}): RunnerResult;
+/**
+* Canonical Streams cursor codec, shared by every product (Streams, Index,
+* Datasets, bulk). A cursor is `"<block_height>:<event_index>"` — an opaque,
+* monotonic resume token. One implementation so encode/decode and the
+* empty-range sentinel can never drift between products.
+*
+* NOTE: this codec IS the shared piece worth centralizing. A broader "shared
+* canonical reader" across the ~10 raw-event query sites (streams-events,
+* streams-bulk/query, l2/storage) was deliberately NOT built: those sites split
+* into distinct query patterns and share only the row_number ordering *pattern*,
+* not an identical reader. The reorg-archive design (migration 0084) keeps the
+* main tables canonical-only, so each reader's `WHERE canonical` filter already
+* needs no dedup logic. Forcing one mega-reader was the wrong abstraction; this
+* codec captures the only part that actually drifts.
+*/
+type StreamsCursor = {
+	block_height: number
+	event_index: number
+};
+type CanonicalBlock = {
+	height: number
+	hash: string
+};
+type DecoderClockEvent = {
+	cursor: string
+	block_hash: string
+	matched: boolean
+};
+type DecoderClockInput = {
+	start_height: number
+	/** Exclusive. Null = before `start_height`. */
+	from_cursor: string | null
+	/** Exclusive high-water after this batch. */
+	to_cursor: string
+	blocks: readonly CanonicalBlock[]
+	events: readonly DecoderClockEvent[]
+};
+type DecoderClockReceipt = {
+	height: number
+	hash: string
+	input_count: number
+	input_cursors: string[]
+	input_digest: string
+	through_cursor: string
+	no_match: boolean
+};
+type DecoderClockResult = {
+	ok: true
+	receipts: DecoderClockReceipt[]
+	through_cursor: string
+} | {
+	ok: false
+	reason: string
+	receipts: DecoderClockReceipt[]
+};
+declare function inputDigest(cursors: readonly string[]): string;
+declare function cursorIsAfterBlock(cursor: StreamsCursor, height: number): boolean;
+/** True when `from` is strictly before the first event that can live in `height`. */
+declare function cursorIsBeforeBlock(cursor: StreamsCursor, height: number): boolean;
+declare function planDecoderReceipts(input: DecoderClockInput): DecoderClockResult;
+import { Kysely } from "kysely";
+import { ColumnType, Generated } from "kysely";
+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>;
+	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 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;
+	visibility: Generated<string>;
+	/** 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;
+	database_url_enc: ColumnType<Buffer | null, Buffer | null | undefined, Buffer | null>;
+	sandbox_workers: Generated<boolean>;
+	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;
+}
+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">;
+	tier: "free" | "build" | "scale" | "enterprise" | null;
+	last_used_at: Date | null;
+	revoked_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>;
+	/** Stacks principal owning a wallet-ghost account (x402-paid deploys). */
+	wallet_principal: string | null;
+	plan: Generated<string>;
+	display_name: string | null;
+	bio: string | null;
+	avatar_url: string | null;
+	slug: 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>;
+}
+/**
+* One-time claim tokens for ghost accounts. The raw token only ever appears in
+* the claim URL returned at mint time; we store its sha256. A used token marks
+* the account as claimed (or merged into an existing account).
+*/
+interface ClaimTokensTable {
+	id: Generated<string>;
+	account_id: string;
+	token_hash: string;
+	created_at: Generated<Date>;
+	expires_at: Date;
+	used_at: Date | null;
+}
+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 UsageDailyTable {
+	account_id: string;
+	tenant_id: string | null;
+	date: string;
+	api_requests: Generated<number>;
+	deliveries: Generated<number>;
+	streams_events_returned: Generated<number>;
+	index_decoded_events_returned: Generated<number>;
+}
+interface UsageSnapshotsTable {
+	id: Generated<string>;
+	account_id: string;
+	measured_at: Generated<Date>;
+	storage_bytes: Generated<number>;
+}
+interface AccountInsightsTable {
+	id: Generated<string>;
+	account_id: string;
+	category: string;
+	insight_type: string;
+	resource_id: string | null;
+	severity: string;
+	title: string;
+	body: string;
+	data: unknown;
+	dismissed_at: Date | null;
+	expires_at: Date | null;
+	created_at: Generated<Date>;
+}
+interface AccountAgentRunsTable {
+	id: Generated<string>;
+	account_id: string;
+	started_at: Generated<Date>;
+	completed_at: Date | null;
+	status: Generated<string>;
+	input_tokens: Generated<number>;
+	output_tokens: Generated<number>;
+	cost_usd: Generated<number>;
+	insights_created: Generated<number>;
+	error: string | null;
+}
+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 SubgraphTableSnapshotsTable {
+	id: Generated<string>;
+	subgraph_name: string;
+	api_key_id: string | null;
+	table_name: string;
+	row_count: number | null;
+	created_at: Generated<Date>;
+}
+interface SubgraphHealthSnapshotsTable {
+	id: Generated<string>;
+	subgraph_id: string;
+	total_processed: number;
+	total_errors: number;
+	last_processed_block: number | null;
+	captured_at: Generated<Date>;
+}
+interface SubgraphUsageDailyTable {
+	subgraph_id: string;
+	date: string;
+	query_count: Generated<number>;
+}
+interface ProjectsTable {
+	id: Generated<string>;
+	name: string;
+	slug: string;
+	account_id: string;
+	settings: Generated<Record<string, unknown>>;
+	network: Generated<string>;
+	node_rpc: string | null;
+	created_at: Generated<Date>;
+	updated_at: Generated<Date>;
+}
+interface TeamMembersTable {
+	id: Generated<string>;
+	project_id: string;
+	account_id: string;
+	role: Generated<string>;
+	invited_by: string | null;
+	created_at: Generated<Date>;
+}
+interface TeamInvitationsTable {
+	id: Generated<string>;
+	project_id: string;
+	email: string;
+	role: Generated<string>;
+	token: string;
+	invited_by: string | null;
+	expires_at: Date;
+	accepted_at: Date | null;
+	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>;
+}
+interface Pox4CyclesDailyTable {
+	date: string;
+	reward_cycle: number;
+	total_stacked_ustx: Generated<string>;
+	solo_stackers: Generated<number>;
+	delegated_principals: Generated<number>;
+	unique_pools: Generated<number>;
+	unique_signers: Generated<number>;
+	calls_today: Generated<number>;
+	updated_at: Generated<Date>;
+}
+interface Pox4SignersDailyTable {
+	date: string;
+	reward_cycle: number;
+	signer_key: string;
+	weight_ustx: Generated<string>;
+	stacker_count: Generated<number>;
+	aggregation_calls: Generated<number>;
+	updated_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 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>;
+}
+interface SbtcSupplySnapshotsTable {
+	date: string;
+	total_supply: Generated<string>;
+	mints_today: Generated<string>;
+	burns_today: Generated<string>;
+	deposit_count: Generated<number>;
+	withdrawal_create_count: Generated<number>;
+	withdrawal_accept_count: Generated<number>;
+	withdrawal_reject_count: Generated<number>;
+	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";
+/**
+* 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>;
+}
+interface Database {
+	blocks: BlocksTable;
+	transactions: TransactionsTable;
+	events: EventsTable;
+	transactions_archive: TransactionsArchiveTable;
+	events_archive: EventsArchiveTable;
+	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;
+	claim_tokens: ClaimTokensTable;
+	usage_daily: UsageDailyTable;
+	usage_snapshots: UsageSnapshotsTable;
+	account_insights: AccountInsightsTable;
+	account_agent_runs: AccountAgentRunsTable;
+	subgraph_health_snapshots: SubgraphHealthSnapshotsTable;
+	subgraph_processing_stats: SubgraphProcessingStatsTable;
+	subgraph_table_snapshots: SubgraphTableSnapshotsTable;
+	subgraph_gaps: SubgraphGapsTable;
+	subgraph_operations: SubgraphOperationsTable;
+	subgraph_usage_daily: SubgraphUsageDailyTable;
+	projects: ProjectsTable;
+	team_members: TeamMembersTable;
+	team_invitations: TeamInvitationsTable;
+	processed_stripe_events: ProcessedStripeEventsTable;
+	tenants: TenantsTable;
+	tenant_usage_monthly: TenantUsageMonthlyTable;
+	tenant_compute_addons: TenantComputeAddonsTable;
+	account_spend_caps: AccountSpendCapsTable;
+	account_credits: AccountCreditsTable;
+	provisioning_audit_log: ProvisioningAuditLogTable;
+	subscriptions: SubscriptionsTable;
+	subscription_outbox: SubscriptionOutboxTable;
+	subscription_deliveries: SubscriptionDeliveriesTable;
+	trigger_evaluator_state: TriggerEvaluatorStateTable;
+	decoded_events: DecodedEventsTable;
+	decoder_checkpoints: DecoderCheckpointsTable;
+	chain_reorgs: ChainReorgsTable;
+	pox4_calls: Pox4CallsTable;
+	pox4_cycles_daily: Pox4CyclesDailyTable;
+	pox4_signers_daily: Pox4SignersDailyTable;
+	pox5_events: Pox5EventsTable;
+	burn_block_rewards: BurnBlockRewardsTable;
+	burn_block_reward_slots: BurnBlockRewardSlotsTable;
+	sbtc_events: SbtcEventsTable;
+	sbtc_token_events: SbtcTokenEventsTable;
+	sbtc_settlements: SbtcSettlementsTable;
+	sbtc_supply_snapshots: SbtcSupplySnapshotsTable;
+	bns_name_events: BnsNameEventsTable;
+	bns_namespace_events: BnsNamespaceEventsTable;
+	bns_marketplace_events: BnsMarketplaceEventsTable;
+	bns_names: BnsNamesTable;
+	bns_namespaces: BnsNamespacesTable;
+	service_heartbeats: ServiceHeartbeatsTable;
+	x402_payments: X402PaymentsTable;
+	x402_balances: X402BalancesTable;
+	chain_read_cache: ChainReadCacheTable;
+	pending_fork_blocks: PendingForkBlocksTable;
+	observer_journal: ObserverJournalTable;
+	stage_registry: StageRegistryTable;
+	stage_runs: StageRunsTable;
+	stage_block_receipts: StageBlockReceiptsTable;
+	coverage_segments: CoverageSegmentsTable;
+	stage_failures: StageFailuresTable;
+}
+/** Prepaid x402 credit — one running USD-micros balance per payer principal. */
+interface X402BalancesTable {
+	principal: 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>;
+	updated_at: Generated<Date>;
+}
+interface ServiceHeartbeatsTable {
+	name: string;
+	updated_at: Generated<Date>;
+}
+/** x402 pay-per-request ledger (control plane). One row per settled payment,
+*  keyed by challenge nonce + settled txid. `state` tracks confirmed-tier
+*  settlement and post-serve reorg reversal. */
+interface X402PaymentsTable {
+	id: Generated<string>;
+	nonce: string;
+	txid: string;
+	asset: string;
+	amount: string;
+	payer: string;
+	surface: string;
+	state: Generated<"pending" | "confirmed" | "reverted">;
+	created_at: Generated<Date>;
+	updated_at: Generated<Date>;
+	/** "payment" = per-call settle; "deposit" = prepaid balance top-up. */
+	kind: Generated<string>;
+	/** Linked claimed account once the paying wallet is attached (continuity). */
+	account_id: string | null;
+	/** USD-micros to credit on confirmation, for deposit rows the reconciler
+	*  settles asynchronously. NULL for per-call settles (credit nothing). */
+	credit_usd_micros: string | null;
+	/** Idempotency key: stamped exactly once when this row's credit is applied.
+	*  NULL means never credited (or not a credit-bearing row). Pre-migration
+	*  non-pending deposit rows are backfilled to a non-null sentinel so the
+	*  reconciler's heal path can never double-credit them. */
+	credited_at: Generated<Date> | null;
+}
+type TenantStatus = "provisioning" | "active" | "limit_warning" | "paused_limit" | "suspended" | "error" | "deleted";
+interface TenantsTable {
+	id: Generated<string>;
+	account_id: string;
+	slug: string;
+	status: ColumnType<TenantStatus, TenantStatus | undefined, TenantStatus>;
+	plan: string;
+	cpus: ColumnType<number, number | string, number | string>;
+	memory_mb: number;
+	storage_limit_mb: number;
+	storage_used_mb: number | null;
+	pg_container_id: string | null;
+	api_container_id: string | null;
+	processor_container_id: string | null;
+	target_database_url_enc: Buffer;
+	tenant_jwt_secret_enc: Buffer;
+	anon_key_enc: Buffer;
+	service_key_enc: Buffer;
+	api_url_internal: string;
+	api_url_public: string;
+	suspended_at: Date | null;
+	last_health_check_at: Date | null;
+	last_active_at: Generated<Date>;
+	service_gen: Generated<number>;
+	anon_gen: Generated<number>;
+	project_id: string | null;
+	created_at: Generated<Date>;
+	updated_at: Generated<Date>;
+}
+interface TenantUsageMonthlyTable {
+	id: Generated<string>;
+	tenant_id: string;
+	period_month: Date;
+	storage_peak_mb: Generated<number>;
+	storage_avg_mb: Generated<number>;
+	storage_last_mb: Generated<number>;
+	measurements: Generated<number>;
+	first_at: Generated<Date>;
+	last_at: Generated<Date>;
+}
+interface TenantComputeAddonsTable {
+	id: Generated<string>;
+	tenant_id: string;
+	memory_mb_delta: Generated<number>;
+	cpu_delta: Generated<number | string>;
+	storage_mb_delta: Generated<number>;
+	effective_from: Generated<Date>;
+	effective_until: Date | null;
+	stripe_subscription_item_id: string | null;
+	created_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 (peer to x402_balances). */
+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>;
+	updated_at: Generated<Date>;
+}
+type ProvisioningAuditEvent = "provision.start" | "provision.success" | "provision.failure" | "suspend" | "resume" | "resize" | "keys.rotate" | "bastion.key.upload" | "bastion.key.revoke" | "teardown";
+type ProvisioningAuditStatus = "ok" | "error";
+interface ProvisioningAuditLogTable {
+	id: Generated<string>;
+	tenant_id: string | null;
+	tenant_slug: string | null;
+	account_id: string | null;
+	actor: string;
+	event: ProvisioningAuditEvent;
+	status: ProvisioningAuditStatus;
+	detail: unknown | null;
+	error: string | null;
+	created_at: Generated<Date>;
+}
+type SubscriptionStatus = "active" | "paused" | "error";
+/** Polymorphic subscription mode: `subgraph` reacts to processed table rows;
+*  `chain` reacts to raw chain events matched directly off the Index/Streams
+*  clock (no subgraph). See migration 0088. */
+type SubscriptionKind = "subgraph" | "chain";
+type SubscriptionFormat = "standard-webhooks" | "inngest" | "trigger" | "cloudflare" | "cloudevents" | "raw";
+type SubscriptionRuntime = "inngest" | "trigger" | "cloudflare" | "node";
+interface SubscriptionsTable {
+	id: Generated<string>;
+	account_id: string;
+	project_id: string | null;
+	name: string;
+	status: ColumnType<SubscriptionStatus, SubscriptionStatus | undefined, SubscriptionStatus>;
+	kind: ColumnType<SubscriptionKind, SubscriptionKind | undefined, SubscriptionKind>;
+	/** Null for chain subscriptions (CHECK subscriptions_kind_shape). */
+	subgraph_name: string | null;
+	/** Null for chain subscriptions (CHECK subscriptions_kind_shape). */
+	table_name: string | null;
+	/** Chain-trigger filter array (the `SubgraphFilter` shape, JSON). Null for
+	*  subgraph subscriptions. Typed loosely here to avoid a shared→subgraphs
+	*  import cycle; the Zod schema in schemas/subscriptions.ts owns the shape. */
+	triggers: unknown | null;
+	filter: Generated<unknown>;
+	format: ColumnType<SubscriptionFormat, SubscriptionFormat | undefined, SubscriptionFormat>;
+	runtime: SubscriptionRuntime | null;
+	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;
+	created_at: Generated<Date>;
+	updated_at: Generated<Date>;
+}
+type OutboxStatus = "pending" | "delivered" | "dead";
+interface SubscriptionOutboxTable {
+	id: Generated<string>;
+	subscription_id: string;
+	kind: ColumnType<SubscriptionKind, SubscriptionKind | undefined, SubscriptionKind>;
+	/** Null for chain-subscription rows. */
+	subgraph_name: string | null;
+	/** Null for chain-subscription rows. */
+	table_name: string | null;
+	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>;
+	delivered_at: Date | null;
+	failed_at: Date | null;
+	locked_by: string | null;
+	locked_until: Date | null;
+	created_at: Generated<Date>;
+}
+interface SubscriptionDeliveriesTable {
+	id: Generated<string>;
+	/** Nullable after migration 0077 — outbox row may be cleaned up while
+	*  delivery telemetry is retained. */
+	outbox_id: string | null;
+	subscription_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 subscriptions, 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>;
+	updated_at: Generated<Date>;
+}
+declare const DECODER_COMMIT_STEPS: readonly ["output", "checkpoint", "receipt", "failure"];
+type DecoderCommitStep = (typeof DECODER_COMMIT_STEPS)[number];
+declare class DecoderAdapterCrash extends Error {
+	readonly step: DecoderCommitStep;
+	readonly name = "DecoderAdapterCrash";
+	constructor(step: DecoderCommitStep);
+}
+type DecoderAdapterFailure = {
+	unit_kind: FailureUnit
+	class: FailureClass
+	retry_state: Exclude<RetryState, "resolved">
+	from_height: number | null
+	to_height: number | null
+	error: string | null
+	retry_count?: number
+};
+type DecoderAdapterReceipt = DecoderClockReceipt & {
+	effect_digest: string
+};
+type DecoderAdapterCommit = {
+	stage_id: string
+	run_id?: string | null
+	decoder_name: string
+	/** Null = do not move the checkpoint (empty page). */
+	checkpoint_cursor: string | null
+	receipts: readonly DecoderAdapterReceipt[]
+	failure?: DecoderAdapterFailure | null
+	writeOutput: (tx: Kysely<Database>) => Promise<void>
+	crashAfter?: DecoderCommitStep
+};
+declare function runDecoderCommitSteps(steps: Record<DecoderCommitStep, () => Promise<void>>, crashAfter?: DecoderCommitStep): Promise<void>;
+declare function applyDecoderReceipts(state: RunnerState, receipts: readonly DecoderAdapterReceipt[]): RunnerResult;
+/**
+* Persist output + checkpoint + receipts + failure in one transaction.
+* Runner validation is the caller's job (`applyDecoderReceipts`) so a
+* rejected ack never opens a transaction.
+*/
+declare function commitDecoderAdapter(db: Kysely<Database>, input: DecoderAdapterCommit): Promise<void>;
+type SealableReceipt = {
+	height: number
+	hash: string
+	input_digest: string
+	effect_digest: string
+	finalized: boolean
+};
+type SealedSegment = {
+	from_height: number
+	to_height: number
+	chain_digest: string
+	input_digest: string
+	output_digest: string
+};
+type SealResult = {
+	ok: true
+	segment: SealedSegment
+	compacted: number
+} | {
+	ok: false
+	reason: string
+};
+declare function rangeDigestOf(parts: readonly string[]): string;
+declare function sealFinalizedRange(receipts: readonly SealableReceipt[], range: CoverageRange): SealResult;
+/** After a reorg at `fork`, any sealed segment that overlaps cannot stay green. */
+declare function segmentsSurviveReorg(segments: readonly SealedSegment[], fork: number): SealedSegment[];
+declare function receiptsAfterReorg(receipts: readonly SealableReceipt[], fork: number): SealableReceipt[];
+type EffectOp = "insert" | "update" | "delete" | "increment";
+type EffectMutation = {
+	op: EffectOp
+	table: string
+	key: Record<string, string | number | boolean | null>
+	value?: Record<string, string | number | boolean | null>
+};
+declare function canonicalizeMutations(ops: readonly EffectMutation[]): EffectMutation[];
+declare function hashEffectManifest(ops: readonly EffectMutation[]): string;
+declare function manifestsEqual(a: readonly EffectMutation[], b: readonly EffectMutation[]): boolean;
+declare const SUBGRAPH_COMMIT_STEPS: readonly ["effects", "rows", "journal", "cursor", "receipt", "failure"];
+type SubgraphCommitStep = (typeof SUBGRAPH_COMMIT_STEPS)[number];
+declare class SubgraphAdapterCrash extends Error {
+	readonly step: SubgraphCommitStep;
+	readonly name = "SubgraphAdapterCrash";
+	constructor(step: SubgraphCommitStep);
+}
+type SubgraphCommitInput = {
+	stage_id: string
+	effects: readonly EffectMutation[]
+	receipts: readonly (DecoderClockReceipt & {
+		effect_digest: string
+	})[]
+	failure?: DecoderAdapterFailure | null
+	writeEffects: () => Promise<void>
+	writeRows: () => Promise<void>
+	writeJournal: () => Promise<void>
+	writeCursor: () => Promise<void>
+	writeReceipts: () => Promise<void>
+	writeFailure: () => Promise<void>
+	crashAfter?: SubgraphCommitStep
+};
+declare function runSubgraphCommitSteps(steps: Record<SubgraphCommitStep, () => Promise<void>>, crashAfter?: SubgraphCommitStep): Promise<void>;
+declare function commitSubgraphAdapter(input: SubgraphCommitInput, wrap?: (fn: () => Promise<void>) => Promise<void>): Promise<void>;
+type SparseSkip = CoverageRange & {
+	reason: "no-match" | "filtered"
+};
+type HeightDigest = {
+	height: number
+	hash: string
+	effect_digest: string
+	row_digest: string
+};
+declare function sequentialDigests(heights: readonly HeightDigest[]): {
+	chain: string
+	effect: string
+	row: string
+};
+declare function sparseDigests(executed: readonly HeightDigest[], skips: readonly {
+	skip: SparseSkip
+	hash: string
+}[]): {
+	chain: string
+	effect: string
+	row: string
+};
+declare function proofsAgree(sequential: {
+	chain: string
+	effect: string
+	row: string
+}, sparse: {
+	chain: string
+	effect: string
+	row: string
+}): boolean;
+type RowSnapshot = {
+	table: string
+	key: string
+	value: string
+};
+declare function finalRowDigest(rows: readonly RowSnapshot[]): string;
+declare function applyMutations(rows: readonly RowSnapshot[], ops: readonly EffectMutation[]): RowSnapshot[];
+type DeepVerifyResult = {
+	ok: boolean
+	live_digest: string
+	scratch_digest: string
+	found_mutation: boolean
+};
+declare function deepVerify(opts: {
+	live: readonly RowSnapshot[]
+	replay: readonly EffectMutation[]
+	seed?: EffectMutation
+}): DeepVerifyResult;
+declare const QUEUE_STAGES: readonly ["decision", "outbox", "delivery", "rollback", "dlq", "replay"];
+type QueueStage = (typeof QUEUE_STAGES)[number];
+type QueueEvent = {
+	type: "accept"
+} | {
+	type: "decide"
+	matched: boolean
+} | {
+	type: "enqueue"
+} | {
+	type: "deliver"
+} | {
+	type: "fail"
+} | {
+	type: "dead"
+} | {
+	type: "requeue"
+} | {
+	type: "rollback"
+} | {
+	type: "replay"
+	cursor: string
+};
+type QueueState = QueueCounters & {
+	stage: QueueStage
+	last_cursor: string | null
+	dedupe: Set<string>
+};
+declare function emptyQueueState(): QueueState;
+type QueueApply = {
+	ok: true
+	state: QueueState
+} | {
+	ok: false
+	reason: string
+	state: QueueState
+};
+declare function applyQueueEvent(state: QueueState, event: QueueEvent, dedupeKey?: string): QueueApply;
+declare function queueCaughtUp(state: QueueState): boolean;
+declare const SAFE_REPAIR_MODES: readonly RepairMode[];
+type RepairDefect = "gap" | "digest_mismatch" | "omission" | "version" | "reorg" | "source_gap";
+type RepairPlan = {
+	stage_id: string
+	range: CoverageRange
+	mode: RepairMode
+	defect: RepairDefect
+	safe: boolean
+	reason: string
+};
+declare function planRepair(input: {
+	stage_id: string
+	range: CoverageRange
+	mode: RepairMode
+	defect: RepairDefect
+	range_safe_proven?: boolean
+}): RepairPlan;
+type RepairApplyResult = {
+	ok: true
+	applied: boolean
+	plan: RepairPlan
+} | {
+	ok: false
+	reason: string
+	plan: RepairPlan
+};
+declare function applyRepair(plan: RepairPlan, opts?: {
+	apply?: boolean
+}): RepairApplyResult;
+/**
+* Unified verify targets — library used by CLI (and REST later).
+* Exit codes match `sl verify`: 0 clean, 1 diverged, 2 unanchored.
+*/
+declare const VERIFY_EXIT: {
+	readonly CLEAN: 0
+	readonly DIVERGED: 1
+	readonly UNANCHORED: 2
+};
+type VerifyExit = (typeof VERIFY_EXIT)[keyof typeof VERIFY_EXIT];
+type VerifyTarget = {
+	kind: "all"
+} | {
+	kind: "raw"
+} | {
+	kind: "decode"
+	name: string
+} | {
+	kind: "subgraph"
+	name: string
+};
+type VerifyMode = "quick" | "deep" | "anchor";
+declare function parseVerifyTarget(value: string | undefined): VerifyTarget;
+/** Whether an archive/coverage dataset belongs to this verify target. */
+declare function datasetMatchesTarget(dataset: string, target: VerifyTarget): boolean;
+type VerifyReport = {
+	target: VerifyTarget
+	mode: VerifyMode
+	exit: VerifyExit
+	status: "clean" | "diverged" | "unanchored"
+	detail: string
+};
+declare function reportVerify(opts: {
+	target: VerifyTarget
+	mode?: VerifyMode
+	anchored?: boolean
+	diverged?: boolean
+	detail?: string
+}): VerifyReport;
+export { versionsEqual, topoSort, sparseDigests, sequentialDigests, segmentsSurviveReorg, segmentsOverlap, sealFinalizedRange, runSubgraphCommitSteps, runDecoderCommitSteps, reportVerify, receiptsAfterReorg, receiptRetentionHolds, rangeIsOrdered, rangeDigestOf, queueCaughtUp, proofsAgree, planRepair, planDecoderReceipts, parseVerifyTarget, mergeRanges, manifestsEqual, lookupTransition, isStageKind, isRunStatus, isRetryState, isRepairMode, isNonNegativeInt, isNativeClock, isFailureUnit, isFailureClass, inputDigest, hashEffectManifest, findRangeGaps, finalRowDigest, failureRetentionHolds, failureRangeHolds, expectedAckHeight, evaluateCoverage, emptyQueueState, defaultRetainUntil, deepVerify, datasetMatchesTarget, cursorIsBeforeBlock, cursorIsAfterBlock, cursorHeight, createRunnerState, contiguousThrough, commitSubgraphAdapter, commitDecoderAdapter, canonicalizeMutations, applyRunnerEvent, applyRepair, applyQueueEvent, applyMutations, applyDecoderReceipts, VerifyTarget, VerifyReport, VerifyMode, VerifyExit, VERIFY_EXIT, TransitionRule, SyncScope, SubgraphCommitStep, SubgraphCommitInput, SubgraphAdapterCrash, StageRunView, StageKind, StageEvidence, StageDeclaration, StageCoverage, SourceClock, SealedSegment, SealableReceipt, SealResult, SUBGRAPH_COMMIT_STEPS, STAGE_KINDS, SAFE_REPAIR_MODES, RunnerVersion, RunnerStatus, RunnerState, RunnerResult, RunnerFailure, RunnerEventType, RunnerEvent, RunnerEffect, RunStatus, RowSnapshot, RetryState, RepairPlan, RepairMode, RepairDefect, RepairApplyResult, ReceiptRow, RUN_STATUSES, RUNNER_TRANSITION_TABLE, RUNNER_STATUSES, RUNNER_EVENT_TYPES, RETRY_STATES, REPAIR_MODES, QueueState, QueueStage, QueueEvent, QueueCounters, QueueApply, QUEUE_STAGES, OpenFailure, NativeClock, NATIVE_CLOCKS, FailureUnit, FailureRow, FailureClass, FAILURE_UNITS, FAILURE_RETENTION_DAYS, FAILURE_CLASSES, EvaluatorOptions, EvaluatorInput, EffectOp, EffectMutation, DeepVerifyResult, DecoderCommitStep, DecoderClockResult, DecoderClockReceipt, DecoderClockInput, DecoderClockEvent, DecoderAdapterReceipt, DecoderAdapterFailure, DecoderAdapterCrash, DecoderAdapterCommit, DEFAULT_MAX_RETRIES, DECODER_COMMIT_STEPS, CoverageState, CoverageReport, CoverageRange, CanonicalBlock, COVERAGE_STATES, COVERAGE_REPORT_SCHEMA_VERSION, BootstrapSource };