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

package/dist/types-DqODKeOq.d.ts

@@ -0,0 +1,123 @@
+/** Describes a hybrid logical clock reading, decoded into its three parts.
+ * @public
+ */
+interface HLCTimestamp {
+    /** The wall-clock milliseconds since the Unix epoch. */
+    wallMs: number;
+    /** The counter that orders events within one wall-clock millisecond. */
+    logical: number;
+    /** The ID of the node that took the reading, which orders two readings with the same time and counter. */
+    nodeId: string;
+}
+/** Describes one replicated row change or one replicated schema statement.
+ * @public
+ */
+interface ReplicationChange {
+    /** The table that the change modifies. */
+    table: string;
+    /** The row operation, or `'ddl'` for a schema statement. */
+    operation: 'insert' | 'update' | 'delete' | 'ddl';
+    /** The primary key of the changed row, encoded as a string. */
+    rowId: string;
+    /** The primary key of the changed row, keyed by column. */
+    primaryKey: Record<string, unknown>;
+    /** The hybrid logical clock stamp that the authoring node gave this change. */
+    hlc: string;
+    /** The ID of the transaction that made this change. */
+    txId: string;
+    /** The ID of the node that wrote the change. */
+    nodeId: string;
+    /** The row after the change, or null for a delete. */
+    newData: Record<string, unknown> | null;
+    /** The row before the change, or null for an insert. */
+    oldData: Record<string, unknown> | null;
+    /** The schema statement to replay, set only when the operation is `'ddl'`. */
+    ddlStatement?: string;
+}
+/** Describes a checksummed run of changes that one node sends to another.
+ * @public
+ */
+interface ReplicationBatch {
+    /** The ID of the node that sent the batch. */
+    sourceNodeId: string;
+    /** The batch ID, which the receiving node acknowledges. */
+    batchId: string;
+    /** The change-log sequence number of the first change in the batch. */
+    fromSeq: bigint;
+    /** The change-log sequence number of the last change in the batch. */
+    toSeq: bigint;
+    /** The lowest and highest hybrid logical clock stamps among the batch's changes. */
+    hlcRange: {
+        min: string;
+        max: string;
+    };
+    /** The changes, in ascending sequence order. */
+    changes: ReplicationChange[];
+    /** The checksum of the changes, which the receiving node verifies before it applies them. */
+    checksum: string;
+    /** The ID of the sending node's replication group. */
+    groupId?: string;
+    /** The sending node's primary term at the time it built the batch. */
+    primaryTerm?: bigint;
+}
+/** The local and incoming versions of one row, which Sirannon passes to a conflict resolver.
+ * @public
+ */
+interface ConflictContext {
+    /** The table that holds the row. */
+    table: string;
+    /** The row's primary key, encoded as a string. */
+    rowId: string;
+    /** The local version of the row as a change, or null when the receiving node has none. */
+    localChange: ReplicationChange | null;
+    /** The change from the sending node. */
+    remoteChange: ReplicationChange;
+    /** The hybrid logical clock stamp of the local version, or null when the local row has no stamp. */
+    localHlc: string | null;
+    /** The hybrid logical clock stamp of the incoming version. */
+    remoteHlc: string;
+}
+/** Describes a conflict resolver's decision for one row.
+ * @public
+ */
+interface ConflictResolution {
+    /** Whether to take the incoming row, keep the local one, or write the merged row. */
+    action: 'accept_remote' | 'keep_local' | 'merge';
+    /** The row to write, which a `'merge'` action requires. */
+    mergedData?: Record<string, unknown>;
+}
+/** Chooses the version of a row to keep when an incoming change targets a row that already exists locally.
+ * @public
+ */
+interface ConflictResolver {
+    /** Chooses between the local and the incoming version of one row. */
+    resolve(ctx: ConflictContext): ConflictResolution | Promise<ConflictResolution>;
+}
+/** Describes the outcome of applying one batch of changes.
+ * @public
+ */
+interface ApplyResult {
+    /** The number of changes that the receiving node applied. */
+    applied: number;
+    /** The number of changes that the receiving node skipped, such as the changes of an already applied batch, an update to a missing row, or a change that lost to the local row. */
+    skipped: number;
+    /** The number of changes that a conflict resolver settled. */
+    conflicts: number;
+    /** The tables that the batch's `DROP TABLE` statements removed, so that the caller can prune them from the change tracker. */
+    droppedTables: string[];
+}
+/** Describes what a source node reports about one table at the end of the first sync, so that the joining node can verify the table.
+ * @public
+ */
+interface SyncTableManifest {
+    /** The table name. */
+    table: string;
+    /** The number of rows in that table on the source node. */
+    rowCount: number;
+    /** A hash of every primary key in the table, in order. */
+    pkHash?: string;
+    /** The chained digest of the batches that the source node streamed for this table. */
+    batchDigest?: string;
+}
+
+export type { ApplyResult as A, ConflictResolver as C, HLCTimestamp as H, ReplicationBatch as R, SyncTableManifest as S, ConflictContext as a, ConflictResolution as b, ReplicationChange as c };

package/dist/types-guEKSzMr.d.ts

@@ -0,0 +1,367 @@
+/**
+ * Names what a lease grants, which is either the controller role or one node's membership session.
+ *
+ * @public
+ */
+type CoordinatorLeaseKind = 'controller' | 'node-session';
+/**
+ * Stops a coordinator watch. Every watch method returns one of these functions.
+ *
+ * @public
+ */
+type CoordinatorWatchDisposer = () => void | Promise<void>;
+/**
+ * Describes a time-limited claim that one node holds, which expires unless the node renews it.
+ *
+ * @public
+ */
+interface CoordinatorLease {
+    /** Identifies the lease, and the holder passes this ID to renew or release it. */
+    id: string;
+    /** Names what the lease grants. */
+    kind: CoordinatorLeaseKind;
+    /** Identifies the cluster that the lease covers. */
+    clusterId: string;
+    /** Identifies the node that holds the lease. */
+    holderId: string;
+    /** Holds how many milliseconds the lease lasts after each renewal. */
+    ttlMs: number;
+    /** Holds the time, in milliseconds since the Unix epoch, at which the coordinator granted or last renewed the lease. */
+    grantedAtMs: number;
+    /** Holds the time, in milliseconds since the Unix epoch, after which the lease expires. */
+    expiresAtMs: number;
+    /** Holds any other data that the holder attaches. */
+    metadata?: Record<string, unknown>;
+}
+/**
+ * Describes a node's request for the controller lease.
+ *
+ * @public
+ */
+interface AcquireControllerLeaseInput {
+    /** Identifies the cluster that the lease covers. */
+    clusterId: string;
+    /** Sets the ID that the node holds the lease under. */
+    holderId: string;
+    /** Sets how many milliseconds the lease lasts. */
+    ttlMs: number;
+    /** Holds any other data to record with the lease. */
+    metadata?: Record<string, unknown>;
+}
+/**
+ * Reports whether the request acquired the controller lease, along with the current lease either way.
+ *
+ * @public
+ */
+type AcquireControllerLeaseResult = {
+    /** Is true when this request acquired the lease. */
+    acquired: true;
+    /** Holds the lease that this request acquired, with its holder and expiry. */
+    lease: CoordinatorLease;
+} | {
+    /** Is false when another lease on the controller role is still live. */
+    acquired: false;
+    /** Holds the current holder's lease, or null when no node holds the lease. */
+    lease: CoordinatorLease | null;
+};
+/**
+ * Holds the versions that a node publishes. A node can be promoted, or accept writes as primary, only when its major
+ * versions match every version that the group requires.
+ *
+ * @public
+ */
+interface CoordinatorCompatibilityMetadata {
+    /** Holds the version of the package that the node has installed. */
+    packageVersion?: string;
+    /** Holds the version of the specification that the node implements. */
+    specVersion?: string;
+    /** Holds the version of the replication protocol that the node uses. */
+    protocolVersion?: string;
+}
+/**
+ * Describes a node to the coordinator when the node registers its session.
+ *
+ * @public
+ */
+interface RegisterNodeSessionInput {
+    /** Identifies the cluster that the node joins. */
+    clusterId: string;
+    /** Identifies the node. */
+    nodeId: string;
+    /** Sets how many milliseconds the session lasts after each renewal. */
+    ttlMs: number;
+    /** Sets the address that clients use to reach this node. */
+    endpoint?: string;
+    /** Lists the replication groups that the node serves. */
+    groupIds?: string[];
+    /** Is true when the node stores a copy of the data. */
+    dataBearing?: boolean;
+    /** Is true when the node counts towards the majority. */
+    voting?: boolean;
+    /** Holds the versions that the node publishes. */
+    compatibility?: CoordinatorCompatibilityMetadata;
+    /** Holds any other data to record with the session. */
+    metadata?: Record<string, unknown>;
+}
+/**
+ * Describes one node's live membership of a cluster, which ends when its lease expires.
+ *
+ * @public
+ */
+interface CoordinatorNodeSession {
+    /** Identifies the cluster that the node is a member of. */
+    clusterId: string;
+    /** Identifies the node. */
+    nodeId: string;
+    /** Holds the lease whose expiry ends this session. */
+    lease: CoordinatorLease;
+    /** Holds the address that clients use to reach this node. */
+    endpoint?: string;
+    /** Lists the replication groups that the node serves. */
+    groupIds: string[];
+    /** Is true when the node stores a copy of the data. */
+    dataBearing: boolean;
+    /** Is true when the node counts towards the majority. */
+    voting: boolean;
+    /** Holds the versions that the node publishes. */
+    compatibility?: CoordinatorCompatibilityMetadata;
+    /** Holds any other data that the node records with the session. */
+    metadata?: Record<string, unknown>;
+}
+/**
+ * Identifies a group's primary node and its address.
+ *
+ * @public
+ */
+interface CoordinatorPrimary {
+    /** Identifies the primary. */
+    nodeId: string;
+    /** Holds the address that clients use to reach the primary. */
+    endpoint?: string;
+}
+/**
+ * Records which node writes for the group, which nodes are in sync, and how
+ * far the data is durable. The controller reads and updates this record during
+ * failover.
+ *
+ * @public
+ */
+interface ReplicationGroupState {
+    /** Identifies the cluster that contains the group. */
+    clusterId: string;
+    /** Identifies the group. */
+    groupId: string;
+    /** Lists the nodes that count towards the majority. */
+    votingDataBearingNodeIds: string[];
+    /** Identifies the current primary, or is null when the group has none. */
+    currentPrimary: CoordinatorPrimary | null;
+    /** Holds the current primary's term, which rises by one with each promotion. */
+    primaryTerm: bigint;
+    /** Holds the change-log position up to which a majority of voting nodes stores the data durably. */
+    durabilityPointSeq: 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[];
+    /** Holds the versions that the group requires of its members. */
+    compatibility?: CoordinatorCompatibilityMetadata;
+    /** Holds the time, in milliseconds since the Unix epoch, of the last change to this state. */
+    updatedAtMs: number;
+}
+/**
+ * Describes the group state to write, which creates a new group or replaces an existing one.
+ *
+ * @public
+ */
+interface SetReplicationGroupStateInput {
+    /** Identifies the cluster that contains the group. */
+    clusterId: string;
+    /** Identifies the group. */
+    groupId: string;
+    /** Lists the nodes that count towards the majority. */
+    votingDataBearingNodeIds: string[];
+    /** Identifies the node to make primary, or null to leave the group without a primary. */
+    currentPrimary?: CoordinatorPrimary | null;
+    /** Sets the term to record for that primary, which defaults to 0. */
+    primaryTerm?: bigint;
+    /** Sets the change-log position up to which a majority stores the data durably. */
+    durabilityPointSeq?: bigint;
+    /** Lists the nodes to record as in sync. */
+    inSyncNodeIds?: string[];
+    /** Lists the nodes to record as draining. */
+    drainingNodeIds?: string[];
+    /** Lists the nodes to record as repairing. */
+    repairingNodeIds?: string[];
+    /** Lists the nodes to record as faulted. */
+    faultedNodeIds?: string[];
+    /** Sets the versions that the group requires of its members. */
+    compatibility?: CoordinatorCompatibilityMetadata;
+}
+/**
+ * Describes a promotion that takes effect only while the group is still at the
+ * term that the caller expects, so that two candidates cannot both promote
+ * themselves.
+ *
+ * @public
+ */
+interface CompareAndAdvancePrimaryTermInput {
+    /** Identifies the cluster that contains the group. */
+    clusterId: string;
+    /** Identifies the group. */
+    groupId: string;
+    /** Holds the term that the caller last read. The promotion fails when the group's term differs. */
+    expectedPrimaryTerm: bigint;
+    /** Identifies the node to promote. */
+    nextPrimary: CoordinatorPrimary;
+}
+/**
+ * Reports whether the promotion took effect, along with the group state afterwards.
+ *
+ * @public
+ */
+interface CompareAndAdvancePrimaryTermResult {
+    /** Is true when the group moves to the next term under the new primary. */
+    advanced: boolean;
+    /** Holds the current group state, or null when the coordinator has no state for the group. */
+    state: ReplicationGroupState | null;
+}
+/**
+ * Describes a new in-sync set for the group, and optionally a new durability point. To add a node, call
+ * {@link ClusterCoordinator.admitNodeToInSyncSet}, because this update throws a `RangeError` for any node outside the
+ * current set.
+ *
+ * @public
+ */
+interface UpdateInSyncSetInput {
+    /** Identifies the cluster that contains the group. */
+    clusterId: string;
+    /** Identifies the group. */
+    groupId: string;
+    /** Lists the nodes to record as in sync. */
+    inSyncNodeIds: string[];
+    /** Sets the change-log position up to which a majority stores the data durably, and the coordinator keeps the higher of this value and the current one. */
+    durabilityPointSeq?: bigint;
+}
+/**
+ * Describes one caught-up node to add to the in-sync set, with the progress
+ * that qualifies it. The coordinator admits the node only when `sourceNodeId`
+ * is the current primary, `appliedSeq` reaches the group's durability point,
+ * and the node is neither draining nor faulted.
+ *
+ * @public
+ */
+interface AdmitNodeToInSyncSetInput {
+    /** Identifies the cluster that contains the group. */
+    clusterId: string;
+    /** Identifies the group. */
+    groupId: string;
+    /** Identifies the node to admit. */
+    nodeId: string;
+    /** Identifies the node whose changes the admitted node applied. */
+    sourceNodeId: string;
+    /** Holds the change-log position up to which the node applied those changes. */
+    appliedSeq: bigint;
+}
+/**
+ * Sets or clears one node's draining, repairing, and faulted flags. A flag left
+ * undefined keeps its current value, and when any flag turns on, the
+ * coordinator removes the node from the in-sync set.
+ *
+ * @public
+ */
+interface UpdateNodeMaintenanceInput {
+    /** Identifies the cluster that contains the group. */
+    clusterId: string;
+    /** Identifies the group. */
+    groupId: string;
+    /** Identifies the node to update. */
+    nodeId: string;
+    /** Sets whether the node is draining, which takes it out of service. */
+    draining?: boolean;
+    /** Sets whether the node is repairing, which means that it rebuilds its copy of the data. */
+    repairing?: boolean;
+    /** Sets whether the node is faulted, which keeps it out of service. */
+    faulted?: boolean;
+}
+/**
+ * Describes a request to promote an eligible in-sync replica, which is one with
+ * a live, compatible session that is neither draining, repairing, nor faulted.
+ *
+ * @public
+ */
+interface PromoteEligibleReplicaInput {
+    /** Identifies the cluster that contains the group. */
+    clusterId: string;
+    /** Identifies the group. */
+    groupId: string;
+    /** Lists the nodes to skip, such as the primary that has just failed. */
+    excludeNodeIds?: string[];
+}
+/**
+ * Receives the group state each time it changes.
+ *
+ * @public
+ */
+type ReplicationGroupWatcher = (state: ReplicationGroupState) => void;
+/**
+ * Receives the IDs of every node that holds a live session, when the watch starts and after each session change.
+ *
+ * @public
+ */
+type NodeSessionWatcher = (liveNodeIds: readonly string[]) => void;
+/**
+ * Receives the controller lease when the watch starts and after each change, or null while no node holds the lease.
+ *
+ * @public
+ */
+type ControllerLeaseWatcher = (lease: CoordinatorLease | null) => void;
+/**
+ * Stores primary authority, node sessions, group state, and the in-sync set
+ * outside the database nodes, so that the record stays intact when any one
+ * database node fails. Sirannon includes an etcd coordinator, and you can
+ * implement this interface to store the record elsewhere.
+ *
+ * @public
+ */
+interface ClusterCoordinator {
+    /** Tries to acquire the controller lease, and returns whether it succeeded along with the current lease. */
+    tryAcquireControllerLease(input: AcquireControllerLeaseInput): Promise<AcquireControllerLeaseResult>;
+    /** Calls `watcher` with the current controller lease when the watch starts and after each change, and returns a function that stops the watch. A coordinator without this watch can omit the method, and every node's controller loop then tries to acquire the lease on each tick. */
+    watchControllerLease?(clusterId: string, watcher: ControllerLeaseWatcher): CoordinatorWatchDisposer | Promise<CoordinatorWatchDisposer>;
+    /** Extends a lease, and returns false for a lease that is expired or unknown to this coordinator. */
+    renewLease(leaseId: string, ttlMs: number): Promise<boolean>;
+    /** Releases a lease at once, and returns whether the release succeeded. */
+    releaseLease(leaseId: string): Promise<boolean>;
+    /** Records one node as a live member of the cluster. */
+    registerNodeSession(input: RegisterNodeSessionInput): Promise<CoordinatorNodeSession>;
+    /** Returns one node's session, or null once its lease expires. */
+    getLiveNodeSession(clusterId: string, nodeId: string): Promise<CoordinatorNodeSession | null>;
+    /** Ends one node's session at once. */
+    deregisterNodeSession(clusterId: string, nodeId: string): Promise<void>;
+    /** Calls `watcher` with the IDs of every node that holds a live session, and returns a function that stops the watch. A coordinator without this watch can omit the method, and a node then lists read endpoints from the group state alone. */
+    watchNodeSessions?(clusterId: string, watcher: NodeSessionWatcher): CoordinatorWatchDisposer | Promise<CoordinatorWatchDisposer>;
+    /** Writes the group's state, which creates a new group or replaces an existing one. */
+    setReplicationGroupState(input: SetReplicationGroupStateInput): Promise<ReplicationGroupState>;
+    /** Returns the group's state, or null when the coordinator has no state for the group. */
+    getReplicationGroupState(clusterId: string, groupId: string): Promise<ReplicationGroupState | null>;
+    /** Calls `watcher` with the new state after each change to the group, and returns a function that stops the watch. */
+    watchReplicationGroup(clusterId: string, groupId: string, watcher: ReplicationGroupWatcher): CoordinatorWatchDisposer | Promise<CoordinatorWatchDisposer>;
+    /** Makes a node primary and advances the term, but only while the group is still at the term that the caller expects. */
+    compareAndAdvancePrimaryTerm(input: CompareAndAdvancePrimaryTermInput): Promise<CompareAndAdvancePrimaryTermResult>;
+    /** Replaces the group's in-sync set with a subset of it, and can advance the durability point. */
+    updateInSyncSet(input: UpdateInSyncSetInput): Promise<ReplicationGroupState | null>;
+    /** Adds one caught-up node to the in-sync set. */
+    admitNodeToInSyncSet(input: AdmitNodeToInSyncSetInput): Promise<ReplicationGroupState | null>;
+    /** Sets or clears one node's draining, repairing, and faulted flags. */
+    updateNodeMaintenance(input: UpdateNodeMaintenanceInput): Promise<ReplicationGroupState | null>;
+    /** Promotes an eligible in-sync replica, and throws a `NoSafePrimaryError` when no replica qualifies. */
+    promoteEligibleReplica(input: PromoteEligibleReplicaInput): Promise<ReplicationGroupState>;
+    /** Releases every connection, watch, and lease that the coordinator keeps open. */
+    close?(): Promise<void>;
+}
+
+export type { AcquireControllerLeaseInput as A, ClusterCoordinator as C, NodeSessionWatcher as N, PromoteEligibleReplicaInput as P, RegisterNodeSessionInput as R, SetReplicationGroupStateInput as S, UpdateInSyncSetInput as U, AcquireControllerLeaseResult as a, ControllerLeaseWatcher as b, CoordinatorWatchDisposer as c, CoordinatorNodeSession as d, ReplicationGroupState as e, ReplicationGroupWatcher as f, CompareAndAdvancePrimaryTermInput as g, CompareAndAdvancePrimaryTermResult as h, AdmitNodeToInSyncSetInput as i, UpdateNodeMaintenanceInput as j, CoordinatorCompatibilityMetadata as k, CoordinatorLease as l, CoordinatorPrimary as m };

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@delali/sirannon-db",
   "type": "module",
-  "version": "0.3.4-next.62",
+  "version": "0.3.4",
   "description": "A production-grade library that turns SQLite databases into a networked data layer with real-time subscriptions.",
   "author": "Delali (https://sondelali.com)",
   "license": "Apache-2.0",
@@ -210,11 +210,11 @@
     "vitest": "4.0.18"
   },
   "optionalDependencies": {
-    "@delali/sirannon-vfs-darwin-arm64": "0.3.4-next.62",
-    "@delali/sirannon-vfs-darwin-x64": "0.3.4-next.62",
-    "@delali/sirannon-vfs-linux-arm64": "0.3.4-next.62",
-    "@delali/sirannon-vfs-linux-x64": "0.3.4-next.62",
-    "@delali/sirannon-vfs-win32-arm64": "0.3.4-next.62",
-    "@delali/sirannon-vfs-win32-x64": "0.3.4-next.62"
+    "@delali/sirannon-vfs-darwin-arm64": "0.3.4",
+    "@delali/sirannon-vfs-darwin-x64": "0.3.4",
+    "@delali/sirannon-vfs-linux-arm64": "0.3.4",
+    "@delali/sirannon-vfs-linux-x64": "0.3.4",
+    "@delali/sirannon-vfs-win32-arm64": "0.3.4",
+    "@delali/sirannon-vfs-win32-x64": "0.3.4"
   }
 }

package/dist/baseline-D93hcIEE.d.ts

@@ -1,17 +0,0 @@
-/**
- * Marks the migration an existing database starts from, so earlier versions are recorded without running.
- *
- * @public
- */
-interface BaselineFileOption {
-    /**
-     * Version of the migration carrying the baseline.
-     */
-    version: number;
-    /**
-     * Highest version this baseline covers.
-     */
-    through: number;
-}
-
-export type { BaselineFileOption as B };

package/dist/change-tracker-CjRFuZdB.d.ts

@@ -1,144 +0,0 @@
-import { I as SQLiteConnection } from './types-DPSmjU54.js';
-import { C as ChangeEvent } from './query-types-p1liOP-b.js';
-
-/**
- * How long a change tracker keeps changes, and how much it reads at a time.
- *
- * @public
- */
-interface ChangeTrackerOptions {
-    /**
-     * Milliseconds a change stays readable before it is pruned. Default: 3_600_000 (one hour).
-     */
-    retention?: number;
-    /**
-     * Name of the table changes are recorded in.
-     */
-    changesTable?: string;
-    /**
-     * Changes read in one poll. Default: 1000.
-     */
-    pollBatchSize?: number;
-}
-
-/**
- * Records every change to the tables you watch so that subscribers and replication can read them in order.
- *
- * Construct one, watch the tables you want captured, and pass it to a replication engine or leave it to the database that owns it.
- *
- * @public
- */
-declare class ChangeTracker {
-    private readonly watched;
-    private lastSeq;
-    private readonly retentionMs;
-    private readonly changesTable;
-    private readonly pollBatchSize;
-    private changesTableReady;
-    private changesTableEnsured;
-    private watchedTablesCache;
-    private readonly stmtCache;
-    private pruneBoundary;
-    private lastPollAtTxBoundary;
-    constructor(options?: ChangeTrackerOptions);
-    /**
-     * Starts recording changes to a table by installing its change-capture triggers.
-     *
-     * @param conn - Writer connection the triggers are created on.
-     * @param table - Name of the table to watch.
-     */
-    watch(conn: SQLiteConnection, table: string): Promise<void>;
-    /**
-     * Stops recording changes to a table and drops its triggers.
-     *
-     * @param conn - Writer connection the triggers are dropped from.
-     * @param table - Name of the table to stop watching.
-     */
-    unwatch(conn: SQLiteConnection, table: string): Promise<void>;
-    /**
-     * Rebuilds CDC triggers for every watched table directly on the supplied
-     * connection, without opening a nested transaction.
-     *
-     * Required when a caller has already issued `BEGIN` on `conn` and runs a
-     * DDL statement that changes a watched table's column list: the next DML
-     * inside the same transaction must see triggers compiled against the new
-     * columns, otherwise CDC `new_data` silently omits them. Callers that are
-     * not inside an active transaction may also use this method; CREATE
-     * TRIGGER and DROP TRIGGER statements are committed individually by the
-     * driver in that case.
-     *
-     * Failure semantics:
-     * - If a watched table no longer exists (e.g. it was just dropped by the
-     *   DDL), it is skipped. The watched-map entry is left alone so a separate
-     *   cleanup path can handle it; throwing here would roll back the user's
-     *   transaction over a benign condition.
-     * - If reading column metadata succeeds but the column list is unchanged,
-     *   no triggers are touched.
-     * - If reading column metadata succeeds and the column list differs from
-     *   the cached one, the existing triggers are dropped and reinstalled on
-     *   `conn`. The cached column list is updated on success.
-     * - Any other error (driver failure, identifier validation failure) is
-     *   rethrown so the caller's transaction can roll back deterministically.
-     *
-     * @internal
-     */
-    refreshAllTriggersUsingConnection(conn: SQLiteConnection): Promise<void>;
-    /**
-     * Removes the supplied tables from the watched map and drops any leftover
-     * CDC triggers carrying their identifier on the supplied connection.
-     *
-     * Intended to be called after a DDL transaction that dropped one or more
-     * watched tables has committed. On rollback the caller must not invoke
-     * this method; the rollback semantics rely on the caller discarding its
-     * captured drop list before reaching this call.
-     *
-     * Idempotent: tables not currently in the watched map are silently
-     * skipped. `dropCdcTriggers` issues `DROP TRIGGER IF EXISTS` so calling
-     * twice in succession produces the same state.
-     *
-     * Defence in depth: even after a `DROP TABLE`, the in-transaction trigger
-     * refresh path may have observed a freshly-created table of the same name
-     * (the DROP and CREATE happened inside the same transaction) and
-     * re-installed triggers compiled against the new schema. Those triggers
-     * are dropped here so the recreated table starts with a clean slate and
-     * the caller must explicitly `watch` it again.
-     *
-     * @internal
-     */
-    pruneDroppedTables(conn: SQLiteConnection, tables: readonly string[]): Promise<void>;
-    /** @internal */
-    poll(conn: SQLiteConnection): Promise<ChangeEvent[]>;
-    /** @internal */
-    get pollEndedAtTxBoundary(): boolean;
-    /**
-     * The highest seq already polled; live subscribers receive events beyond it.
-     *
-     * @internal
-     */
-    get cursor(): bigint;
-    /** @internal */
-    readSinceTables(conn: SQLiteConnection, tables: readonly string[], afterSeq: bigint, upToSeq: bigint, limit: number): Promise<ChangeEvent[]>;
-    /**
-     * The lowest retained seq, or `null` when the change log is empty.
-     *
-     * @internal
-     */
-    getMinSeq(conn: SQLiteConnection): Promise<bigint | null>;
-    /** @internal */
-    advanceToLatest(conn: SQLiteConnection): Promise<void>;
-    /** @internal */
-    cleanup(conn: SQLiteConnection): Promise<number>;
-    /** @internal */
-    setPruneBoundary(seq: bigint): void;
-    /** @internal */
-    clearPruneBoundary(): void;
-    /** @internal */
-    get watchedTables(): ReadonlySet<string>;
-    private computeSeqBound;
-    private assertIdentifier;
-    private detectChangesTable;
-    private ensureChangesTable;
-    private installTriggers;
-}
-
-export { ChangeTracker as C, type ChangeTrackerOptions as a };