@delali/sirannon-db 0.3.4-next.62 → 0.3.4

package/dist/types-BrAiDGOb.d.ts

@@ -0,0 +1,505 @@
+import { C as ChangeTracker } from './change-tracker-DqCdeEyx.js';
+import { I as SQLiteConnection, N as NodeHealth } from './types-Dc8oWlxj.js';
+import { S as SyncTableManifest, R as ReplicationBatch, C as ConflictResolver } from './types-DqODKeOq.js';
+import { C as ClusterCoordinator, k as CoordinatorCompatibilityMetadata, e as ReplicationGroupState } from './types-guEKSzMr.js';
+import { W as WriteConcern } from './query-types-5B02ixH0.js';
+
+/**
+ * Describes a connected peer, as the transport records it.
+ *
+ * @public
+ */
+interface NodeInfo {
+    /** Identifies the peer. */
+    id: string;
+    /** Identifies the peer's replication group. */
+    groupId?: string;
+    /** Records whether the peer is the primary or a replica. */
+    role: 'primary' | 'replica';
+    /** Holds the primary term that the peer reports. */
+    primaryTerm?: bigint;
+    /** Holds the replication protocol version that the peer uses. */
+    protocolVersion?: string;
+    /** Holds the time, in milliseconds since the Unix epoch, at which the peer connected. */
+    joinedAt: number;
+    /** Holds the time, in milliseconds since the Unix epoch, of the last message from the peer. The bundled transports set it only when the peer connects. */
+    lastSeenAt: number;
+    /** Holds the highest change-log position that the peer acknowledges. The bundled transports set it to `0n` only when the peer connects, while {@link PeerState.lastAckedSeq} follows each acknowledgement. */
+    lastAckedSeq: bigint;
+    /** Holds any other data that the transport attaches about the peer. */
+    metadata?: Record<string, unknown>;
+}
+/**
+ * Confirms that a node applied one batch.
+ *
+ * @public
+ */
+interface ReplicationAck {
+    /** Identifies the batch that the node acknowledges. */
+    batchId: string;
+    /** Holds the highest change-log position that the sender applied. */
+    ackedSeq: bigint;
+    /** Identifies the node that sends the acknowledgement. */
+    nodeId: string;
+    /** Identifies the sender's replication group. */
+    groupId?: string;
+    /** Holds the primary term that the sender reports as current. */
+    primaryTerm?: bigint;
+}
+/**
+ * Describes a write that a replica sends to the primary, because the replica cannot accept writes itself.
+ *
+ * @public
+ */
+interface ForwardedTransaction {
+    /** Lists the statements to execute, in order, each with its own parameters. */
+    statements: Array<{
+        sql: string;
+        params?: Record<string, unknown> | unknown[];
+    }>;
+    /** Identifies this forwarded request. */
+    requestId: string;
+    /** Identifies the forwarding replica's replication group. */
+    groupId?: string;
+    /** Holds the primary term that the replica reports as current. */
+    primaryTerm?: bigint;
+    /** The write concern that the caller states, which the primary waits for before it replies; without one, the primary applies its own default. */
+    writeConcern?: WriteConcern;
+}
+/**
+ * Describes the result that the primary returns for a forwarded write.
+ *
+ * @public
+ */
+interface ForwardedTransactionResult {
+    /** Holds one result per statement, in the order that the primary executed them. */
+    results: Array<{
+        changes: number;
+        lastInsertRowId: number | string;
+    }>;
+    /** Holds the request ID that the primary generates for this execution, which differs from the ID in the forwarded request. */
+    requestId: string;
+    /** Identifies the primary's replication group. */
+    groupId?: string;
+    /** Holds the term under which the primary executed the write. */
+    primaryTerm?: bigint;
+}
+/**
+ * Describes one batch that this node sent and that its peer has yet to acknowledge.
+ *
+ * @public
+ */
+interface InFlightBatch {
+    /** Identifies the batch. */
+    batchId: string;
+    /** Holds the change-log position of the batch's first change. */
+    fromSeq: bigint;
+    /** Holds the change-log position of the batch's last change. */
+    toSeq: bigint;
+    /** Holds the time, in milliseconds since the Unix epoch, at which this node sent the batch. */
+    sentAt: number;
+}
+/**
+ * Describes one peer's replication progress, as this node tracks it.
+ *
+ * @public
+ */
+interface PeerState {
+    /** Identifies the peer. */
+    nodeId: string;
+    /** Holds the highest change-log position among the peer's acknowledgements. */
+    lastAckedSeq: bigint;
+    /** Holds the change-log position up to which this node sends batches to the peer. A timeout or a failed send moves it back. */
+    lastSentSeq: bigint;
+    /** Holds the highest hybrid logical clock stamp in any batch that this node has applied from the peer, and an empty string until the first such batch. */
+    lastReceivedHlc: string;
+    /** Is true while the transport has an open connection to the peer. */
+    connected: boolean;
+    /** Counts the batches that this node sent to the peer and that await acknowledgement. */
+    pendingBatches: number;
+    /** Lists the batches that this node sent to the peer and that the peer has yet to acknowledge. */
+    inFlightBatches: InFlightBatch[];
+}
+
+/**
+ * Names how far a joining node is through first sync.
+ *
+ * @public
+ */
+type SyncPhase = 'pending' | 'syncing' | 'catching-up' | 'ready';
+/**
+ * Describes a joining node's progress through first sync.
+ *
+ * @public
+ */
+interface SyncState {
+    /** Names how far the node is through first sync. */
+    phase: SyncPhase;
+    /** Identifies the peer that streams the copy, or is null when no sync is in progress. */
+    sourcePeerId: string | null;
+    /** Holds the change-log position at which the source took the copy. */
+    snapshotSeq: bigint | null;
+    /** Lists the tables that the node already holds in full. */
+    completedTables: string[];
+    /** Counts the tables that the copy covers. */
+    totalTables: number;
+    /** Holds the time, in milliseconds since the Unix epoch, at which the sync started. */
+    startedAt: number | null;
+    /** Holds the reason that the last sync request failed, or null when no failure is recorded. */
+    error: string | null;
+}
+/**
+ * Asks a peer to stream a full copy of the database.
+ *
+ * @public
+ */
+interface SyncRequest {
+    /** Identifies this sync, and every message of the sync repeats it. */
+    requestId: string;
+    /** Identifies the node that asks for the copy. */
+    joinerNodeId: string;
+    /** Lists the tables that the joiner already holds in full, so that the source skips them when the sync resumes. */
+    completedTables: string[];
+    /** Is true when the joiner can verify the stream with chained batch digests. */
+    supportsStreamVerification?: boolean;
+    /** Identifies the joiner's replication group. */
+    groupId?: string;
+    /** Holds the primary term that the joiner reports as current. */
+    primaryTerm?: bigint;
+}
+/**
+ * Holds one page of first-sync table data.
+ *
+ * @public
+ */
+interface SyncBatch {
+    /** Identifies the sync that this page is part of. */
+    requestId: string;
+    /** Names the table that the rows come from. */
+    table: string;
+    /** Holds the position of this page in the table's stream, counting from zero. */
+    batchIndex: number;
+    /** Holds the rows. */
+    rows: Record<string, unknown>[];
+    /** Holds the schema statements, which the source sends in a `__schema__` page before any table, so that the joiner can create the tables. */
+    schema?: string[];
+    /** Holds the checksum of the rows, which the joiner verifies before it writes them. */
+    checksum: string;
+    /** Is true on the last page of a table. */
+    isLastBatchForTable: boolean;
+    /** Counts the tables that the whole copy covers. */
+    totalTables?: number;
+    /** Identifies the source's replication group. */
+    groupId?: string;
+    /** Holds the source's primary term. */
+    primaryTerm?: bigint;
+}
+/**
+ * Tells a joining node that first sync is complete, and gives it the manifests that it checks the copy against.
+ *
+ * @public
+ */
+interface SyncComplete {
+    /** Identifies the sync that finished. */
+    requestId: string;
+    /** Holds the change-log position at which the source took the copy, which the joiner resumes replication from. */
+    snapshotSeq: bigint;
+    /** Holds one manifest per table, so that the joiner can check the rows that it received. */
+    manifests: SyncTableManifest[];
+    /** Identifies the source's replication group. */
+    groupId?: string;
+    /** Holds the source's primary term. */
+    primaryTerm?: bigint;
+}
+/**
+ * Tells the source whether a joining node stored one first-sync page, and gives the reason for a failure.
+ *
+ * @public
+ */
+interface SyncAck {
+    /** Identifies the sync that this acknowledgement is part of. */
+    requestId: string;
+    /** Identifies the joining node. */
+    joinerNodeId: string;
+    /** Names the table that the page came from. */
+    table: string;
+    /** Holds the position of the page in that table's stream. */
+    batchIndex: number;
+    /** Is true when the joiner stored the page. */
+    success: boolean;
+    /** Holds the reason that the joiner could not store the page. */
+    error?: string;
+    /** Identifies the joiner's replication group. */
+    groupId?: string;
+    /** Holds the primary term that the joiner reports as current. */
+    primaryTerm?: bigint;
+}
+
+/**
+ * Names a node's role: 'primary' accepts writes, and 'replica' serves reads.
+ *
+ * @public
+ */
+type TopologyRole = 'primary' | 'replica';
+/**
+ * Sets the rules for which peers exchange changes with this node, and whether this node writes.
+ *
+ * @public
+ */
+interface Topology {
+    /** Records whether this node is the primary or a replica. */
+    role: TopologyRole;
+    /** Reports whether this node accepts writes. */
+    canWrite(): boolean;
+    /** Reports whether this node sends its changes to a given peer. */
+    shouldReplicateTo(peerId: string, peerRole: TopologyRole): boolean;
+    /** Reports whether this node applies the changes that a given peer sends. */
+    shouldAcceptFrom(peerId: string, peerRole: TopologyRole): boolean;
+    /** Reports whether an incoming change can conflict with a local write, so that the engine has to resolve it. */
+    requiresConflictResolution(): boolean;
+}
+/**
+ * Sets what the transport announces about this node when it connects, and the endpoints that it dials.
+ *
+ * @public
+ */
+interface TransportConfig {
+    /** Lists the addresses of the peers that this node dials. */
+    endpoints?: string[];
+    /** Sets the role that this node announces. The replication engine fills it in when it starts. */
+    localRole?: TopologyRole;
+    /** Sets the replication group that this node announces. */
+    groupId?: string;
+    /** Sets the primary term that this node announces. */
+    primaryTerm?: bigint;
+    /** Sets the replication protocol version that this node announces. */
+    protocolVersion?: string;
+    /** Holds any other data for the transport to announce about this node. The bundled transports ignore it. */
+    metadata?: Record<string, unknown>;
+}
+/**
+ * Sends change batches, acknowledgements, forwarded writes, and first-sync
+ * messages between nodes. Implement this interface to replicate over a
+ * protocol other than the bundled gRPC and in-memory transports.
+ *
+ * @public
+ */
+interface ReplicationTransport {
+    /** Connects to the configured peers and announces this node. */
+    connect(localNodeId: string, config: TransportConfig): Promise<void>;
+    /** Closes every peer connection. */
+    disconnect(): Promise<void>;
+    /** Sends one batch of changes to one peer. */
+    send(peerId: string, batch: ReplicationBatch): Promise<void>;
+    /** Sends one batch of changes to every connected peer. */
+    broadcast(batch: ReplicationBatch): Promise<void>;
+    /** Confirms to a peer that this node applied one of its batches. */
+    sendAck(peerId: string, ack: ReplicationAck): Promise<void>;
+    /** Sends a write to the primary and waits for its result. */
+    forward(peerId: string, request: ForwardedTransaction): Promise<ForwardedTransactionResult>;
+    /** Asks a peer to stream a full copy of the database. */
+    requestSync(peerId: string, request: SyncRequest): Promise<void>;
+    /** Sends one page of first-sync table data. */
+    sendSyncBatch(peerId: string, batch: SyncBatch): Promise<void>;
+    /** Tells a joining node that first sync is complete, and sends the manifests that the node checks its copy against. */
+    sendSyncComplete(peerId: string, complete: SyncComplete): Promise<void>;
+    /** Tells the source whether this joining node stored one first-sync page. */
+    sendSyncAck(peerId: string, ack: SyncAck): Promise<void>;
+    /** Registers the handler that applies incoming change batches. */
+    onBatchReceived(handler: (batch: ReplicationBatch, fromPeerId: string) => Promise<void>): void;
+    /** Registers the handler that records incoming acknowledgements. */
+    onAckReceived(handler: (ack: ReplicationAck, fromPeerId: string) => void): void;
+    /** Registers the handler that executes a write that a replica forwards. */
+    onForwardReceived(handler: (request: ForwardedTransaction, fromPeerId: string) => Promise<ForwardedTransactionResult>): void;
+    /** Registers the handler that serves a first-sync request. */
+    onSyncRequested(handler: (request: SyncRequest, fromPeerId: string) => Promise<void>): void;
+    /** Registers the handler that stores an incoming first-sync page. */
+    onSyncBatchReceived(handler: (batch: SyncBatch, fromPeerId: string) => Promise<void>): void;
+    /** Registers the handler that finishes first sync and verifies the manifests. */
+    onSyncCompleteReceived(handler: (complete: SyncComplete, fromPeerId: string) => Promise<void>): void;
+    /** Registers the handler that records first-sync page acknowledgements. */
+    onSyncAckReceived(handler: (ack: SyncAck, fromPeerId: string) => void): void;
+    /** Registers the handler that the transport calls when a peer connects. */
+    onPeerConnected(handler: (peer: NodeInfo) => void): void;
+    /** Registers the handler that the transport calls when a peer disconnects. */
+    onPeerDisconnected(handler: (peerId: string) => void): void;
+    /** Returns every connected peer, keyed by node ID. */
+    peers(): ReadonlyMap<string, NodeInfo>;
+}
+/**
+ * Configures this node's part in the group's controller loop and the lease that makes a node the controller.
+ *
+ * @public
+ */
+interface CoordinatorControllerConfig {
+    /** Is true when this node competes for the controller lease, which it does by default. */
+    enabled?: boolean;
+    /** Sets the ID that this node holds the lease under. Defaults to the node ID. */
+    holderId?: string;
+    /** Sets how many milliseconds the lease lasts before the holder has to renew it. */
+    leaseTtlMs?: number;
+    /** Sets how many milliseconds pass between controller loop ticks. */
+    tickIntervalMs?: number;
+}
+/**
+ * Configures coordinator-backed failover: the coordinator that stores group state, the nodes that vote, and how this
+ * node registers.
+ *
+ * @public
+ */
+interface CoordinatorModeConfig {
+    /** Identifies the cluster that contains this group. */
+    clusterId: string;
+    /** Identifies the replication group. */
+    groupId: string;
+    /** Sets the address that clients use to reach this node, which the coordinator stores with the node's session. */
+    endpoint?: string;
+    /** Lists the nodes that count towards the majority, which the engine uses to create the group when the coordinator has no state for it. Automatic failover requires at least three. */
+    votingDataBearingNodeIds?: string[];
+    /** Holds the coordinator that stores primary authority, node sessions, group state, and the in-sync set. */
+    coordinator: ClusterCoordinator;
+    /** Sets how many milliseconds this node's session lasts before the node has to renew it. */
+    sessionTtlMs?: number;
+    /** Turns this node's controller loop on or off, or configures it. The loop is on by default. */
+    controller?: boolean | CoordinatorControllerConfig;
+    /** Sets the versions that this node publishes, which the engine also records as the group's requirement when it creates the group. */
+    compatibility?: CoordinatorCompatibilityMetadata;
+}
+/**
+ * Configures how one node replicates: its identity, topology, transport,
+ * batching, first sync, and coordinator-backed failover.
+ *
+ * @public
+ */
+interface ReplicationConfig {
+    /** Identifies this node, and defaults to a random ID. Coordinator mode requires one, so keep it the same across restarts. */
+    nodeId?: string;
+    /** Sets which peers exchange changes with this node, and whether this node writes. */
+    topology: Topology;
+    /** Sends batches, acknowledgements, forwarded writes, and first-sync messages between nodes. */
+    transport: ReplicationTransport;
+    /** Sets what the transport announces about this node, and the endpoints that it dials. */
+    transportConfig?: TransportConfig;
+    /** Makes a node that cannot accept writes forward `execute` and `executeBatch` calls to the primary. */
+    writeForwarding?: boolean;
+    /** Maps table names to the resolvers that replace the default for those tables. */
+    conflictResolvers?: Record<string, ConflictResolver>;
+    /** Sets the resolver for every table that has no resolver of its own. Defaults to last-writer-wins. */
+    defaultConflictResolver?: ConflictResolver;
+    /** Sets the most changes that one outgoing batch holds. */
+    batchSize?: number;
+    /** Sets how many milliseconds the sender loop waits between passes. */
+    batchIntervalMs?: number;
+    /** Sets how many unacknowledged batches one peer can have before this node pauses sending to it. */
+    maxPendingBatches?: number;
+    /** Reserved, and the engine ignores it. */
+    snapshotThreshold?: number;
+    /** Sets the largest difference, in milliseconds, between this node's clock and the newest timestamp in an incoming batch. This node rejects a batch that exceeds it. */
+    maxClockDriftMs?: number;
+    /** Sets the most changes that this node accepts in one incoming batch. This node rejects a larger batch. */
+    maxBatchChanges?: number;
+    /** Sets how many milliseconds this node waits for a batch acknowledgement before it resends the batch. */
+    ackTimeoutMs?: number;
+    /** Receives each forwarded statement on the primary before the primary executes it. Throw to refuse the whole forwarded write. */
+    onBeforeForwardedQuery?: (sql: string, params?: unknown[] | Record<string, unknown>) => void;
+    /** Sets how far a peer can fall behind before this node calls `onLagExceeded`. */
+    flowControl?: {
+        maxLagSeconds?: number;
+        onLagExceeded?: (peerId: string, lagMs: number) => void;
+    };
+    /** Makes a replica copy the full database from a source peer before it serves reads. Defaults to true. */
+    initialSync?: boolean;
+    /** Sets how many rows the source sends in each first-sync page. */
+    syncBatchSize?: number;
+    /** Sets how many first syncs this node serves at once. */
+    maxConcurrentSyncs?: number;
+    /** Sets how many milliseconds this node waits for the joiner to acknowledge each first-sync page before it aborts the sync. */
+    maxSyncDurationMs?: number;
+    /** Sets how many change-log positions a joining node can trail its source by when the node marks itself ready. */
+    maxSyncLagBeforeReady?: number;
+    /** Sets how many milliseconds the source waits for the acknowledgement of one first-sync page. */
+    syncAckTimeoutMs?: number;
+    /** Sets how many milliseconds a joining node spends catching up before it marks itself ready anyway. */
+    catchUpDeadlineMs?: number;
+    /** Sets the change-log position to start from, for a node that you seed by copying the database file. The engine uses it only when `initialSync` is false. */
+    resumeFromSeq?: bigint;
+    /** Opens the read-only connection that this node streams first-sync data from, so that writes continue while the node serves a joiner. */
+    snapshotConnectionFactory?: () => Promise<SQLiteConnection>;
+    /** Records the local changes that this node replicates. */
+    changeTracker?: ChangeTracker;
+    /** Turns on coordinator-backed failover and names the coordinator that stores the group state. */
+    coordinator?: CoordinatorModeConfig;
+}
+/**
+ * Reports one node's role, peers, progress, and health.
+ *
+ * @public
+ */
+interface ReplicationStatus {
+    /** Identifies this node. */
+    nodeId: string;
+    /** Records whether this node is the primary or a replica. */
+    role: TopologyRole;
+    /** Describes each peer's progress, as this node tracks it. */
+    peers: PeerState[];
+    /** Holds this node's local change-log position as of the sender loop's last pass. */
+    localSeq: bigint;
+    /** Is true between the engine's `start` and `stop` calls. */
+    replicating: boolean;
+    /** Reports what this node can do at the moment, and the reason. */
+    health: NodeHealth;
+    /** Describes this node's progress through first sync. */
+    syncState?: SyncState;
+    /** Holds the group state that this node last read from the coordinator. */
+    coordinator?: CoordinatorRuntimeStatus;
+}
+/**
+ * Holds the group state that one node last read from the cluster coordinator.
+ *
+ * @public
+ */
+interface CoordinatorRuntimeStatus {
+    /** Identifies the cluster. */
+    clusterId: string;
+    /** Identifies the replication group. */
+    groupId: string;
+    /** Identifies the group's current primary. */
+    currentPrimary: ReplicationGroupState['currentPrimary'];
+    /** Holds the current primary's term. */
+    primaryTerm: bigint;
+    /** Lists the nodes that are in sync with the primary. */
+    inSyncNodeIds: string[];
+    /** Lists the draining nodes, which are leaving service. */
+    drainingNodeIds: string[];
+    /** Lists the repairing nodes, which are rebuilding their copy of the data. */
+    repairingNodeIds: string[];
+    /** Lists the faulted nodes, which stay out of service until an `updateNodeMaintenance` call clears the flag. */
+    faultedNodeIds: string[];
+    /** Lists the nodes that count towards the majority. */
+    votingDataBearingNodeIds: string[];
+    /** Lists the nodes that hold a live session with the coordinator. The field is present only while this node is connected to the coordinator and the coordinator supports session watches. */
+    liveNodeIds?: string[];
+    /** Is true when the group state names this node as the current primary. */
+    authority: boolean;
+    /** Is true when this node heard from the coordinator within the last session TTL. */
+    connected: boolean;
+    /** Names the state of this node's controller loop: 'disabled', 'standby' while it waits for the lease, 'active' while it holds the lease, or 'lost' after a failed renewal or a controller failure. */
+    controllerState: 'disabled' | 'standby' | 'active' | 'lost';
+}
+/**
+ * Describes a replication failure, which the engine emits as its `replication-error` event.
+ *
+ * @public
+ */
+interface ReplicationErrorEvent {
+    /** Holds the error. */
+    error: Error;
+    /** Names the operation that failed. */
+    operation: string;
+    /** Identifies the peer that the operation involved, if any. */
+    peerId?: string;
+    /** Is true when the engine keeps working after this failure. */
+    recoverable: boolean;
+}
+
+export type { CoordinatorRuntimeStatus as C, ForwardedTransaction as F, InFlightBatch as I, NodeInfo as N, PeerState as P, ReplicationAck as R, SyncRequest as S, TransportConfig as T, ForwardedTransactionResult as a, SyncBatch as b, SyncComplete as c, SyncAck as d, ReplicationTransport as e, TopologyRole as f, ReplicationStatus as g, SyncPhase as h, ReplicationConfig as i, SyncState as j, ReplicationErrorEvent as k, Topology as l };

package/dist/types-CEJG0eFS.d.ts

@@ -0,0 +1,88 @@
+/** Describes a live query's state, which is pending until the first read returns, ready with the current rows, or an error after a failure.
+ * @public
+ */
+type LiveQueryState<T> = {
+    /** `'pending'` while the first read is in flight, `'ready'` once the rows are available, or `'error'` after a failure. */
+    status: 'pending';
+} | {
+    /** Marks the state that has rows. */
+    status: 'ready';
+    /** The current rows of the query, in its result order. */
+    rows: readonly T[];
+    /** `true` while Sirannon re-reads the query, in which case `rows` is the previous result until the re-read finishes. */
+    revalidating: boolean;
+} | {
+    /** Marks the state after a failure. */
+    status: 'error';
+    /** The error that the read or its change subscription threw. */
+    error: Error;
+};
+/** Describes one edit to a live query's result set, as a position and the row at that position.
+ * @public
+ */
+type ResultOp<T> = {
+    /** `'insert'` for an added row, `'update'` for a row that changed in place, or `'delete'` for a removed row. */
+    op: 'insert';
+    /** The zero-based position of the inserted row in the result set. */
+    index: number;
+    /** The row at that position after the edit. */
+    row: T;
+} | {
+    /** Marks an edit to a row that changed in place. */
+    op: 'update';
+    /** The zero-based position of the row that changed. */
+    index: number;
+    /** The row after the change. */
+    row: T;
+} | {
+    /** Marks the removal of a row. */
+    op: 'delete';
+    /** The zero-based position of the removed row before the edit. */
+    index: number;
+};
+/** Describes an update that a live query sends to its listeners, for a replaced result set, edits to apply, a re-read in progress, or a failure.
+ * @public
+ */
+type LiveUpdate<T> = {
+    /** `'rows'` for a replaced result set, `'ops'` for edits to apply, `'revalidating'` while Sirannon re-reads the query, or `'error'` after a failure. */
+    kind: 'rows';
+} | {
+    /** Marks an update with edits to apply. */
+    kind: 'ops';
+    /** The edits, in the order in which to apply them to reach the new result set. */
+    ops: readonly ResultOp<T>[];
+} | {
+    /** Marks the start of a re-read. */
+    kind: 'revalidating';
+} | {
+    /** Marks a failure, whose error {@link LiveQuery.getState} returns. */
+    kind: 'error';
+};
+/** A registered read whose rows Sirannon updates as the underlying tables change.
+ * @public
+ */
+interface LiveQuery<T = Record<string, unknown>> {
+    /** Returns the query's current state, with the rows when the state is ready. */
+    getState(): LiveQueryState<T>;
+    /** Registers a listener for each update, and returns a function that removes it. */
+    subscribe(listener: (update: LiveUpdate<T>) => void): () => void;
+    /** Closes the query and releases its change subscription. */
+    close(): Promise<void>;
+}
+/** Settings for one live query.
+ * @public
+ */
+interface LiveQueryOptions {
+    /** The upper bound in milliseconds of a random delay before each re-read, so that many queries affected by one change re-read at different moments. */
+    rereadJitterMs?: number;
+    /** The largest number of changes in one transaction that Sirannon applies to the result one by one. For a larger transaction, Sirannon re-reads the whole query. */
+    maxTransactionChanges?: number;
+    /**
+     * Receives the error from any listener of this query that throws or returns a rejected promise.
+     * Sirannon calls each listener without awaiting it, so the other listeners still receive the
+     * update. Sirannon discards any error that `onError` itself throws.
+     */
+    onError?: (error: Error) => void;
+}
+
+export type { LiveQueryOptions as L, ResultOp as R, LiveQuery as a, LiveQueryState as b, LiveUpdate as c };