@secondlayer/shared 13.4.0 → 13.6.0

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

@@ -0,0 +1,1554 @@
+/**
+* The insight contract. The tenant (`/api/insights`) and platform
+* (`/api/accounts/insights`) routes serve `Insight` verbatim. The web app keeps
+* a field-for-field copy in `apps/web/src/lib/insights.ts`; change both
+* together.
+*
+* The types are written out and the schemas annotated with them, rather than
+* inferred: the bundled `.d.ts` loses inferred zod types (they come out as
+* `unknown`), the same reason `schemas/webhooks.ts` annotates its schemas.
+*/
+declare const INSIGHT_SEVERITIES: readonly ["losing", "will_fail", "costs", "recovered"];
+type InsightSeverity = (typeof INSIGHT_SEVERITIES)[number];
+type InsightResourceKind = "webhook" | "subgraph" | "account";
+type InsightEvidence = {
+	kind: "series"
+	title: string
+	series: {
+		name: string
+		role: "a" | "context" | "mark"
+		points: number[]
+	}[]
+	labels: [number, string][]
+	unit?: string
+} | {
+	kind: "table"
+	title: string
+	columns: string[]
+	rows: (string | number)[][]
+	markRow?: number
+} | {
+	kind: "shapes"
+	title: string
+	shapes: {
+		code: string
+		body: string
+		count: number
+		isNew: boolean
+	}[]
+} | {
+	kind: "timeline"
+	title: string
+	steps: {
+		what: string
+		at: string
+		note?: string
+		failed: boolean
+	}[]
+};
+interface Insight {
+	id: string;
+	rule: string;
+	severity: InsightSeverity;
+	impact: number;
+	resource: {
+		kind: InsightResourceKind
+		id: string
+		name: string
+	};
+	line: string;
+	meta?: string;
+	lead: string;
+	body: string;
+	evidence: InsightEvidence[];
+	handoff: {
+		prompt: string
+		commands: string[]
+	};
+	how: {
+		detector: string
+		facts: [string, string][]
+		label?: {
+			cause: string
+			confidence: number
+		}
+	};
+	createdAt: string;
+	resolvedAt?: string | null;
+}
+/** Severity, then impact (desc), then createdAt (desc). Returns a new array. */
+declare function rankInsights(insights: readonly Insight[]): Insight[];
+declare const RATE_LIMITED_MIN_ATTEMPTS = 10;
+declare const RATE_LIMITED_MIN_RATIO = .5;
+declare const DOWN_MIN_CONSECUTIVE = 5;
+declare const REJECTS_MIN_CONSECUTIVE = 5;
+declare const SLOW_WINDOW = 20;
+declare const SLOW_MIN_SAMPLES = 5;
+declare const SLOW_TIMEOUT_RATIO = .5;
+declare const LAG_WINDOW = 20;
+declare const LAG_MIN_SAMPLES = 5;
+declare const LAG_THRESHOLD_MS = 6e4;
+/** Consecutive newest 2xx HTML responses that mean a login wall. */
+declare const LOGIN_WALL_MIN_CONSECUTIVE = 20;
+/** Share of prior-week 2xx responses that must have been JSON. */
+declare const LOGIN_WALL_PRIOR_JSON_RATIO = .8;
+/** Prior-week successful responses needed before a baseline counts. */
+declare const LOGIN_WALL_MIN_PRIOR = 10;
+declare const SLOWING_DAYS = 14;
+declare const SLOWING_MIN_RISING_DAYS = 10;
+declare const SLOWING_MIN_R2 = .8;
+declare const TLS_WARN_DAYS = 14;
+/** Dead outbox rows are deleted at 90 days; warn at 83. */
+declare const DEAD_LETTER_WARN_AGE_DAYS = 83;
+declare const DEAD_LETTER_DELETE_AGE_DAYS = 90;
+declare const TEST_ENDPOINT_MIN_AGE_DAYS = 7;
+declare const HANDLER_ERRORS_MIN_24H = 10;
+/** Blocks behind tip, for 3 consecutive snapshots. */
+declare const SUBGRAPH_LAG_BLOCKS = 20;
+declare const SUBGRAPH_LAG_SNAPSHOTS = 3;
+declare const SUBGRAPH_LAG_LOSING_BLOCKS = 500;
+/**
+* Index and Streams cap one page at 1000 rows
+* (`packages/api/src/index/_shared.ts` `Math.min(1000, parsed)`,
+* `packages/api/src/routes/streams.ts` `limit: Math.min(1000, limit)`).
+*/
+declare const PAGE_CAP_ROWS = 1e3;
+declare const DUPLICATE_READS_MIN_PAGES = 3;
+declare const DUPLICATE_READS_WINDOW_MS = 36e5;
+/** Only repeats that started within this long ago count as current. */
+declare const DUPLICATE_READS_LOOKBACK_MS: number;
+declare const POLLING_MIN_DURATION_MS = 36e5;
+/** Requests needed in the window before an interval means anything. */
+declare const POLLING_MIN_REQUESTS = 5;
+declare const POLLING_LOOKBACK_MS: number;
+declare const POLLING_MAX_STDDEV_RATIO = .2;
+declare const POLLING_MIN_EMPTY_RATIO = .8;
+declare const SERVER_ERRORS_MIN_5XX = 3;
+declare const BACKFILL_DAY_SHARE = .25;
+declare const BACKFILL_FULL_PAGE_RATIO = .9;
+/** A day under this many rows is never called a backfill, however full its pages. */
+declare const BACKFILL_MIN_DAY_ROWS = 1e5;
+declare const CREDITS_RUNWAY_WARN_DAYS = 7;
+/** A resolved insight stays visible as "recovered" for this long. */
+declare const RECOVERED_VISIBLE_MS: number;
+/** Consecutive clean evaluations before an open insight resolves. */
+declare const CLEAR_STREAK_TO_RESOLVE = 2;
+/**
+* Hand-off prompt helpers. A prompt tells the developer's coding agent what we
+* saw (names, times, counts, error text) and what to look at, in plain words.
+* It never contains code and never asks the agent to read the user's source.
+*/
+declare function handoffPrompt(parts: {
+	/** `My Secondlayer webhook "mint-alerts"` */
+	subject: string
+	/** Plain facts with numbers and UTC times. The first one continues the
+	*  subject ("has been failing since 16:06 UTC"); the rest are sentences. */
+	observed: string[]
+	/** What to check, in words. */
+	lookAt: string
+	/** Optional follow-up naming an `sl` command. */
+	followUp?: string
+}): string;
+/**
+* Receiver and handler text is untrusted and often JSON or HTML. Collapse it
+* to one plain line with no braces, backticks or arrows so it can sit inside
+* a prompt or a body sentence.
+*/
+declare function plainSnippet(text: string | null | undefined, max?: number): string;
+/** "16:06 UTC" */
+declare function utcTime(date: Date): string;
+/** "Oct 15 16:06 UTC" */
+declare function utcDateTime(date: Date): string;
+/** "Oct 15" */
+declare function utcDay(date: Date): string;
+declare function plural(n: number, one: string, many?: string): string;
+/** The host of a URL, or the input when it does not parse. */
+declare function hostOf(url: string): string;
+import { Kysely } from "kysely";
+import { ColumnType, Generated } 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>;
+	/** 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;
+}
+/** "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;
+	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;
+	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;
+}
+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;
+}
+/** 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 WebhookStatus = "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 WebhookKind = "chain";
+type WebhookFormat = "standard-webhooks" | "inngest" | "trigger" | "cloudflare" | "cloudevents" | "raw";
+interface WebhooksTable {
+	id: Generated<string>;
+	account_id: string;
+	project_id: string | null;
+	name: string;
+	status: ColumnType<WebhookStatus, WebhookStatus | undefined, WebhookStatus>;
+	kind: ColumnType<WebhookKind, WebhookKind | undefined, WebhookKind>;
+	/** 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<WebhookFormat, WebhookFormat | undefined, WebhookFormat>;
+	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<WebhookKind, WebhookKind | undefined, WebhookKind>;
+	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 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>;
+}
+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;
+	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>;
+}
+/** What a rule returns: an `Insight` before the store assigns identity and time. */
+type DetectedInsight = Omit<Insight, "id" | "createdAt" | "resolvedAt">;
+/** One (resource, rule) pair a pass actually looked at. */
+interface EvaluatedKey {
+	kind: Insight["resource"]["kind"];
+	id: string;
+	rule: string;
+}
+/** `null` on tenant and self-host databases, the account id on the platform. */
+interface InsightScope {
+	accountId: string | null;
+}
+/**
+* A pure rule over plain inputs. Returns null when it does not fire.
+* `skip` returns true when the input lacks the data the rule needs (a failed
+* ABI fetch, no health snapshots yet): a skipped rule fires nothing and does
+* not count toward clearing an open insight.
+*/
+interface InsightRule<Input> {
+	id: string;
+	skip?(input: Input): boolean;
+	evaluate(input: Input): DetectedInsight | null;
+}
+/**
+* Persist one evaluation pass.
+*
+* Fired insights upsert on the open (resource, rule) row. Every key in
+* `evaluatedKeys` that has an open row and did not fire gains a clear streak,
+* and resolves once the streak reaches `CLEAR_STREAK_TO_RESOLVE`. A rule that
+* was skipped (missing data) must stay out of `evaluatedKeys` so it never
+* counts toward clearing.
+*/
+declare function recordEvaluation(db: Kysely<Database>, scope: InsightScope, fired: DetectedInsight[], evaluatedKeys: EvaluatedKey[], now?: Date): Promise<void>;
+/** (kind, id) pairs that have an open insight in this scope. */
+declare function listOpenResources(db: Kysely<Database>, scope: InsightScope): Promise<{
+	kind: Insight["resource"]["kind"]
+	id: string
+	rule: string
+}[]>;
+/**
+* Open rows plus rows resolved within `RECOVERED_VISIBLE_MS`, minus dismissed
+* and muted ones. Resolved rows come back as `recovered`. Ranked.
+*/
+declare function listInsights(db: Kysely<Database>, scope: InsightScope, now?: Date, filter?: {
+	kind?: string
+	id?: string
+}): Promise<Insight[]>;
+/** Hide the current incident. Returns false when the id is not in scope. */
+declare function dismissInsight(db: Kysely<Database>, scope: InsightScope, id: string, now?: Date): Promise<boolean>;
+/** Mute the insight's rule for its resource until un-muted. */
+declare function muteRule(db: Kysely<Database>, scope: InsightScope, id: string): Promise<boolean>;
+declare function unmuteRule(db: Kysely<Database>, scope: InsightScope, id: string): Promise<boolean>;
+/** Delete resolved or dismissed-and-resolved rows older than `olderThanDays`. */
+declare function purgeResolved(db: Kysely<Database>, scope: InsightScope, olderThanDays?: number, now?: Date): Promise<void>;
+type ClassifierName = "jev" | "kev" | "clef" | "rules";
+type Question = {
+	type: "choice"
+	instructions: string
+	criteria: Record<string, string>
+} | {
+	type: "score"
+	instructions: string
+	criteria: readonly string[]
+} | {
+	type: "boolean"
+	instructions: string
+	criteria: {
+		true: string
+		false: string
+	}
+};
+type Answer = {
+	type: "choice"
+	choice: string
+	probabilities: Record<string, number>
+	confidence: number
+} | {
+	type: "score"
+	score: number
+	probabilities: Record<string, number>
+	confidence: number
+} | {
+	type: "boolean"
+	probability: number
+	confidence: number
+} | {
+	type: "refusal"
+};
+type Answers<Q extends Record<string, Question>> = { [K in keyof Q] : Answer };
+type ClassifyResult<Q extends Record<string, Question>> = {
+	provider: ClassifierName
+	/** response.modelId when the backend reports one. */
+	modelId: string
+	answers: Answers<Q>
+};
+/** Deterministic answers for the offline provider. Return a value per question
+*  it can decide; omitted questions come back as `{ type: "refusal" }`. */
+type RuleValue = string | number | boolean;
+type RulesFn<Q extends Record<string, Question>> = (state: string | Record<string, unknown>) => { [K in keyof Q]? : RuleValue } | null;
+/**
+* One classifier call over jev, kev, clef or offline rules.
+* Returns null on any provider failure (fail-open: callers decide what null
+* means). Only ClassifierInputError, a bad question definition, escapes.
+* Never logs state or response bodies.
+*/
+declare function classify<const Q extends Record<string, Question>>(input: {
+	state: string | Record<string, unknown>
+	questions: Q
+	rules?: RulesFn<Q>
+	/** Overrides resolveProvider(); used by classifier-compare. */
+	provider?: ClassifierName
+	/** Overrides CLASSIFIER_MODEL / the provider default. */
+	modelId?: string
+	/** Default 5000. */
+	timeoutMs?: number
+	env?: Record<string, string | undefined>
+	/** Tests only (kev/clef). */
+	fetchImpl?: typeof fetch
+}): Promise<ClassifyResult<Q> | null>;
+type LabelOutcome = {
+	cause: string
+	confidence: number
+} | null;
+type LabelCache = Map<string, {
+	at: number
+	outcome: LabelOutcome
+}>;
+interface LabelDeps {
+	classifyFn?: typeof classify;
+	env?: Record<string, string | undefined>;
+	now?: number;
+	cache?: LabelCache;
+}
+declare function maybeLabel(insight: DetectedInsight, deps?: LabelDeps): Promise<DetectedInsight>;
+import { Kysely as Kysely3 } from "kysely";
+interface AbiCache {
+	get(contractId: string, now: number): string[] | undefined;
+	set(contractId: string, names: string[], now: number): void;
+}
+/**
+* Run one resource's rules. A rule that throws or reports `skip` is left out
+* of `evaluated`, so missing data can never clear an open insight.
+*/
+declare function runRules<Input>(rules: InsightRule<Input>[], input: Input, resource: {
+	kind: EvaluatedKey["kind"]
+	id: string
+}, opts?: {
+	active?: boolean
+}): {
+	fired: DetectedInsight[]
+	evaluated: EvaluatedKey[]
+};
+interface TenantEvaluateDeps extends Omit<LabelDeps, "now"> {
+	now?: Date;
+	fetchImpl?: typeof fetch;
+	abiCache?: AbiCache;
+}
+/**
+* One tenant (or self-host) pass: webhook rules, subgraph rules, optional
+* cause labels, then persist. Open insights for resources that no longer
+* exist resolve through the normal two-pass clear.
+*/
+declare function evaluateTenantInsights(db: Kysely3<Database>, deps?: TenantEvaluateDeps): Promise<void>;
+export { BACKFILL_DAY_SHARE, BACKFILL_FULL_PAGE_RATIO, BACKFILL_MIN_DAY_ROWS, CLEAR_STREAK_TO_RESOLVE, CREDITS_RUNWAY_WARN_DAYS, DEAD_LETTER_DELETE_AGE_DAYS, DEAD_LETTER_WARN_AGE_DAYS, DOWN_MIN_CONSECUTIVE, DUPLICATE_READS_LOOKBACK_MS, DUPLICATE_READS_MIN_PAGES, DUPLICATE_READS_WINDOW_MS, DetectedInsight, EvaluatedKey, HANDLER_ERRORS_MIN_24H, InsightRule, InsightScope, LAG_MIN_SAMPLES, LAG_THRESHOLD_MS, LAG_WINDOW, LOGIN_WALL_MIN_CONSECUTIVE, LOGIN_WALL_MIN_PRIOR, LOGIN_WALL_PRIOR_JSON_RATIO, PAGE_CAP_ROWS, POLLING_LOOKBACK_MS, POLLING_MAX_STDDEV_RATIO, POLLING_MIN_DURATION_MS, POLLING_MIN_EMPTY_RATIO, POLLING_MIN_REQUESTS, RATE_LIMITED_MIN_ATTEMPTS, RATE_LIMITED_MIN_RATIO, RECOVERED_VISIBLE_MS, REJECTS_MIN_CONSECUTIVE, SERVER_ERRORS_MIN_5XX, SLOWING_DAYS, SLOWING_MIN_R2, SLOWING_MIN_RISING_DAYS, SLOW_MIN_SAMPLES, SLOW_TIMEOUT_RATIO, SLOW_WINDOW, SUBGRAPH_LAG_BLOCKS, SUBGRAPH_LAG_LOSING_BLOCKS, SUBGRAPH_LAG_SNAPSHOTS, TEST_ENDPOINT_MIN_AGE_DAYS, TLS_WARN_DAYS, TenantEvaluateDeps, dismissInsight, evaluateTenantInsights, handoffPrompt, hostOf, listInsights, listOpenResources, maybeLabel, muteRule, plainSnippet, plural, purgeResolved, rankInsights, recordEvaluation, runRules, unmuteRule, utcDateTime, utcDay, utcTime };