@delali/sirannon-db 0.1.3 → 0.1.5

package/dist/types-B2byqt0B.d.ts

@@ -0,0 +1,273 @@
+import { C as ChangeTracker } from './change-tracker-CFTQ9TSn.js';
+import { a as SQLiteConnection } from './types-BFSsG77t.js';
+import { C as ClusterCoordinator, j as CoordinatorCompatibilityMetadata, c as ReplicationGroupState } from './types-BEu1I_9_.js';
+
+interface NodeInfo {
+    id: string;
+    groupId?: string;
+    role: 'primary' | 'replica';
+    primaryTerm?: bigint;
+    protocolVersion?: string;
+    joinedAt: number;
+    lastSeenAt: number;
+    lastAckedSeq: bigint;
+    metadata?: Record<string, unknown>;
+}
+interface HLCTimestamp {
+    wallMs: number;
+    logical: number;
+    nodeId: string;
+}
+interface ReplicationChange {
+    table: string;
+    operation: 'insert' | 'update' | 'delete' | 'ddl';
+    rowId: string;
+    primaryKey: Record<string, unknown>;
+    hlc: string;
+    txId: string;
+    nodeId: string;
+    newData: Record<string, unknown> | null;
+    oldData: Record<string, unknown> | null;
+    ddlStatement?: string;
+}
+interface ReplicationBatch {
+    sourceNodeId: string;
+    batchId: string;
+    fromSeq: bigint;
+    toSeq: bigint;
+    hlcRange: {
+        min: string;
+        max: string;
+    };
+    changes: ReplicationChange[];
+    checksum: string;
+    groupId?: string;
+    primaryTerm?: bigint;
+}
+interface ReplicationAck {
+    batchId: string;
+    ackedSeq: bigint;
+    nodeId: string;
+    groupId?: string;
+    primaryTerm?: bigint;
+}
+interface ForwardedTransaction {
+    statements: Array<{
+        sql: string;
+        params?: Record<string, unknown> | unknown[];
+    }>;
+    requestId: string;
+    groupId?: string;
+    primaryTerm?: bigint;
+}
+interface ForwardedTransactionResult {
+    results: Array<{
+        changes: number;
+        lastInsertRowId: number | string;
+    }>;
+    requestId: string;
+    groupId?: string;
+    primaryTerm?: bigint;
+}
+interface ConflictContext {
+    table: string;
+    rowId: string;
+    localChange: ReplicationChange | null;
+    remoteChange: ReplicationChange;
+    localHlc: string | null;
+    remoteHlc: string;
+}
+interface ConflictResolution {
+    action: 'accept_remote' | 'keep_local' | 'merge';
+    mergedData?: Record<string, unknown>;
+}
+interface ConflictResolver {
+    resolve(ctx: ConflictContext): ConflictResolution | Promise<ConflictResolution>;
+}
+type TopologyRole = 'primary' | 'replica';
+interface Topology {
+    role: TopologyRole;
+    canWrite(): boolean;
+    shouldReplicateTo(peerId: string, peerRole: TopologyRole): boolean;
+    shouldAcceptFrom(peerId: string, peerRole: TopologyRole): boolean;
+    requiresConflictResolution(): boolean;
+}
+interface TransportConfig {
+    endpoints?: string[];
+    localRole?: TopologyRole;
+    groupId?: string;
+    primaryTerm?: bigint;
+    protocolVersion?: string;
+    metadata?: Record<string, unknown>;
+}
+interface ReplicationTransport {
+    connect(localNodeId: string, config: TransportConfig): Promise<void>;
+    disconnect(): Promise<void>;
+    send(peerId: string, batch: ReplicationBatch): Promise<void>;
+    broadcast(batch: ReplicationBatch): Promise<void>;
+    sendAck(peerId: string, ack: ReplicationAck): Promise<void>;
+    forward(peerId: string, request: ForwardedTransaction): Promise<ForwardedTransactionResult>;
+    requestSync(peerId: string, request: SyncRequest): Promise<void>;
+    sendSyncBatch(peerId: string, batch: SyncBatch): Promise<void>;
+    sendSyncComplete(peerId: string, complete: SyncComplete): Promise<void>;
+    sendSyncAck(peerId: string, ack: SyncAck): Promise<void>;
+    onBatchReceived(handler: (batch: ReplicationBatch, fromPeerId: string) => Promise<void>): void;
+    onAckReceived(handler: (ack: ReplicationAck, fromPeerId: string) => void): void;
+    onForwardReceived(handler: (request: ForwardedTransaction, fromPeerId: string) => Promise<ForwardedTransactionResult>): void;
+    onSyncRequested(handler: (request: SyncRequest, fromPeerId: string) => Promise<void>): void;
+    onSyncBatchReceived(handler: (batch: SyncBatch, fromPeerId: string) => Promise<void>): void;
+    onSyncCompleteReceived(handler: (complete: SyncComplete, fromPeerId: string) => Promise<void>): void;
+    onSyncAckReceived(handler: (ack: SyncAck, fromPeerId: string) => void): void;
+    onPeerConnected(handler: (peer: NodeInfo) => void): void;
+    onPeerDisconnected(handler: (peerId: string) => void): void;
+    peers(): ReadonlyMap<string, NodeInfo>;
+}
+interface InFlightBatch {
+    batchId: string;
+    fromSeq: bigint;
+    toSeq: bigint;
+    sentAt: number;
+}
+interface PeerState {
+    nodeId: string;
+    lastAckedSeq: bigint;
+    lastSentSeq: bigint;
+    lastReceivedHlc: string;
+    connected: boolean;
+    pendingBatches: number;
+    inFlightBatches: InFlightBatch[];
+}
+interface CoordinatorControllerConfig {
+    enabled?: boolean;
+    holderId?: string;
+    leaseTtlMs?: number;
+    tickIntervalMs?: number;
+}
+interface CoordinatorModeConfig {
+    clusterId: string;
+    groupId: string;
+    endpoint?: string;
+    votingDataBearingNodeIds?: string[];
+    coordinator: ClusterCoordinator;
+    sessionTtlMs?: number;
+    controller?: boolean | CoordinatorControllerConfig;
+    compatibility?: CoordinatorCompatibilityMetadata;
+}
+interface ReplicationConfig {
+    nodeId?: string;
+    topology: Topology;
+    transport: ReplicationTransport;
+    transportConfig?: TransportConfig;
+    writeForwarding?: boolean;
+    conflictResolvers?: Record<string, ConflictResolver>;
+    defaultConflictResolver?: ConflictResolver;
+    batchSize?: number;
+    batchIntervalMs?: number;
+    maxPendingBatches?: number;
+    snapshotThreshold?: number;
+    maxClockDriftMs?: number;
+    maxBatchChanges?: number;
+    ackTimeoutMs?: number;
+    onBeforeForwardedQuery?: (sql: string, params?: unknown[] | Record<string, unknown>) => void;
+    flowControl?: {
+        maxLagSeconds?: number;
+        onLagExceeded?: (peerId: string, lagMs: number) => void;
+    };
+    initialSync?: boolean;
+    syncBatchSize?: number;
+    maxConcurrentSyncs?: number;
+    maxSyncDurationMs?: number;
+    maxSyncLagBeforeReady?: number;
+    syncAckTimeoutMs?: number;
+    catchUpDeadlineMs?: number;
+    resumeFromSeq?: bigint;
+    snapshotConnectionFactory?: () => Promise<SQLiteConnection>;
+    changeTracker?: ChangeTracker;
+    coordinator?: CoordinatorModeConfig;
+}
+interface ReplicationStatus {
+    nodeId: string;
+    role: TopologyRole;
+    peers: PeerState[];
+    localSeq: bigint;
+    replicating: boolean;
+    syncState?: SyncState;
+    coordinator?: CoordinatorRuntimeStatus;
+}
+interface CoordinatorRuntimeStatus {
+    clusterId: string;
+    groupId: string;
+    currentPrimary: ReplicationGroupState['currentPrimary'];
+    primaryTerm: bigint;
+    inSyncNodeIds: string[];
+    drainingNodeIds: string[];
+    repairingNodeIds: string[];
+    faultedNodeIds: string[];
+    votingDataBearingNodeIds: string[];
+    authority: boolean;
+    controllerState: 'disabled' | 'standby' | 'active' | 'lost';
+}
+interface ApplyResult {
+    applied: number;
+    skipped: number;
+    conflicts: number;
+    droppedTables: string[];
+}
+type SyncPhase = 'pending' | 'syncing' | 'catching-up' | 'ready';
+interface SyncState {
+    phase: SyncPhase;
+    sourcePeerId: string | null;
+    snapshotSeq: bigint | null;
+    completedTables: string[];
+    totalTables: number;
+    startedAt: number | null;
+    error: string | null;
+}
+interface SyncRequest {
+    requestId: string;
+    joinerNodeId: string;
+    completedTables: string[];
+    groupId?: string;
+    primaryTerm?: bigint;
+}
+interface SyncBatch {
+    requestId: string;
+    table: string;
+    batchIndex: number;
+    rows: Record<string, unknown>[];
+    schema?: string[];
+    checksum: string;
+    isLastBatchForTable: boolean;
+    groupId?: string;
+    primaryTerm?: bigint;
+}
+interface SyncTableManifest {
+    table: string;
+    rowCount: number;
+    pkHash: string;
+}
+interface SyncComplete {
+    requestId: string;
+    snapshotSeq: bigint;
+    manifests: SyncTableManifest[];
+    groupId?: string;
+    primaryTerm?: bigint;
+}
+interface SyncAck {
+    requestId: string;
+    joinerNodeId: string;
+    table: string;
+    batchIndex: number;
+    success: boolean;
+    error?: string;
+    groupId?: string;
+    primaryTerm?: bigint;
+}
+interface ReplicationErrorEvent {
+    error: Error;
+    operation: string;
+    peerId?: string;
+    recoverable: boolean;
+}
+
+export type { ApplyResult as A, ConflictResolver as C, ForwardedTransaction as F, HLCTimestamp as H, InFlightBatch as I, NodeInfo as N, PeerState as P, ReplicationBatch as R, SyncRequest as S, TopologyRole as T, ReplicationAck as a, ForwardedTransactionResult as b, SyncBatch as c, SyncComplete as d, SyncAck as e, ReplicationTransport as f, TransportConfig as g, ConflictContext as h, ConflictResolution as i, SyncPhase as j, SyncTableManifest as k, ReplicationConfig as l, SyncState as m, ReplicationStatus as n, ReplicationErrorEvent as o, Topology as p, ReplicationChange as q };

package/dist/types-BEu1I_9_.d.ts

@@ -0,0 +1,139 @@
+type CoordinatorLeaseKind = 'controller' | 'node-session';
+type CoordinatorWatchDisposer = () => void | Promise<void>;
+interface CoordinatorLease {
+    id: string;
+    kind: CoordinatorLeaseKind;
+    clusterId: string;
+    holderId: string;
+    ttlMs: number;
+    grantedAtMs: number;
+    expiresAtMs: number;
+    metadata?: Record<string, unknown>;
+}
+interface AcquireControllerLeaseInput {
+    clusterId: string;
+    holderId: string;
+    ttlMs: number;
+    metadata?: Record<string, unknown>;
+}
+type AcquireControllerLeaseResult = {
+    acquired: true;
+    lease: CoordinatorLease;
+} | {
+    acquired: false;
+    lease: CoordinatorLease | null;
+};
+interface CoordinatorCompatibilityMetadata {
+    packageVersion?: string;
+    specVersion?: string;
+    protocolVersion?: string;
+}
+interface RegisterNodeSessionInput {
+    clusterId: string;
+    nodeId: string;
+    ttlMs: number;
+    endpoint?: string;
+    groupIds?: string[];
+    dataBearing?: boolean;
+    voting?: boolean;
+    compatibility?: CoordinatorCompatibilityMetadata;
+    metadata?: Record<string, unknown>;
+}
+interface CoordinatorNodeSession {
+    clusterId: string;
+    nodeId: string;
+    lease: CoordinatorLease;
+    endpoint?: string;
+    groupIds: string[];
+    dataBearing: boolean;
+    voting: boolean;
+    compatibility?: CoordinatorCompatibilityMetadata;
+    metadata?: Record<string, unknown>;
+}
+interface CoordinatorPrimary {
+    nodeId: string;
+    endpoint?: string;
+}
+interface ReplicationGroupState {
+    clusterId: string;
+    groupId: string;
+    votingDataBearingNodeIds: string[];
+    currentPrimary: CoordinatorPrimary | null;
+    primaryTerm: bigint;
+    durabilityPointSeq: bigint;
+    inSyncNodeIds: string[];
+    drainingNodeIds: string[];
+    repairingNodeIds: string[];
+    faultedNodeIds: string[];
+    compatibility?: CoordinatorCompatibilityMetadata;
+    updatedAtMs: number;
+}
+interface SetReplicationGroupStateInput {
+    clusterId: string;
+    groupId: string;
+    votingDataBearingNodeIds: string[];
+    currentPrimary?: CoordinatorPrimary | null;
+    primaryTerm?: bigint;
+    durabilityPointSeq?: bigint;
+    inSyncNodeIds?: string[];
+    drainingNodeIds?: string[];
+    repairingNodeIds?: string[];
+    faultedNodeIds?: string[];
+    compatibility?: CoordinatorCompatibilityMetadata;
+}
+interface CompareAndAdvancePrimaryTermInput {
+    clusterId: string;
+    groupId: string;
+    expectedPrimaryTerm: bigint;
+    nextPrimary: CoordinatorPrimary;
+}
+interface CompareAndAdvancePrimaryTermResult {
+    advanced: boolean;
+    state: ReplicationGroupState | null;
+}
+interface UpdateInSyncSetInput {
+    clusterId: string;
+    groupId: string;
+    inSyncNodeIds: string[];
+    durabilityPointSeq?: bigint;
+}
+interface AdmitNodeToInSyncSetInput {
+    clusterId: string;
+    groupId: string;
+    nodeId: string;
+    sourceNodeId: string;
+    appliedSeq: bigint;
+}
+interface UpdateNodeMaintenanceInput {
+    clusterId: string;
+    groupId: string;
+    nodeId: string;
+    draining?: boolean;
+    repairing?: boolean;
+    faulted?: boolean;
+}
+interface PromoteEligibleReplicaInput {
+    clusterId: string;
+    groupId: string;
+    excludeNodeIds?: string[];
+}
+type ReplicationGroupWatcher = (state: ReplicationGroupState) => void;
+interface ClusterCoordinator {
+    tryAcquireControllerLease(input: AcquireControllerLeaseInput): Promise<AcquireControllerLeaseResult>;
+    renewLease(leaseId: string, ttlMs: number): Promise<boolean>;
+    releaseLease(leaseId: string): Promise<boolean>;
+    registerNodeSession(input: RegisterNodeSessionInput): Promise<CoordinatorNodeSession>;
+    getLiveNodeSession(clusterId: string, nodeId: string): Promise<CoordinatorNodeSession | null>;
+    deregisterNodeSession(clusterId: string, nodeId: string): Promise<void>;
+    setReplicationGroupState(input: SetReplicationGroupStateInput): Promise<ReplicationGroupState>;
+    getReplicationGroupState(clusterId: string, groupId: string): Promise<ReplicationGroupState | null>;
+    watchReplicationGroup(clusterId: string, groupId: string, watcher: ReplicationGroupWatcher): CoordinatorWatchDisposer | Promise<CoordinatorWatchDisposer>;
+    compareAndAdvancePrimaryTerm(input: CompareAndAdvancePrimaryTermInput): Promise<CompareAndAdvancePrimaryTermResult>;
+    updateInSyncSet(input: UpdateInSyncSetInput): Promise<ReplicationGroupState | null>;
+    admitNodeToInSyncSet(input: AdmitNodeToInSyncSetInput): Promise<ReplicationGroupState | null>;
+    updateNodeMaintenance(input: UpdateNodeMaintenanceInput): Promise<ReplicationGroupState | null>;
+    promoteEligibleReplica(input: PromoteEligibleReplicaInput): Promise<ReplicationGroupState>;
+    close?(): Promise<void>;
+}
+
+export type { AcquireControllerLeaseInput as A, ClusterCoordinator as C, PromoteEligibleReplicaInput as P, RegisterNodeSessionInput as R, SetReplicationGroupStateInput as S, UpdateInSyncSetInput as U, AcquireControllerLeaseResult as a, CoordinatorNodeSession as b, ReplicationGroupState as c, ReplicationGroupWatcher as d, CoordinatorWatchDisposer as e, CompareAndAdvancePrimaryTermInput as f, CompareAndAdvancePrimaryTermResult as g, AdmitNodeToInSyncSetInput as h, UpdateNodeMaintenanceInput as i, CoordinatorCompatibilityMetadata as j, CoordinatorLease as k, CoordinatorPrimary as l };

package/dist/types-BFSsG77t.d.ts

@@ -0,0 +1,29 @@
+interface RunResult {
+    changes: number;
+    lastInsertRowId: number | bigint;
+}
+interface SQLiteStatement {
+    all<T = unknown>(...params: unknown[]): Promise<T[]>;
+    get<T = unknown>(...params: unknown[]): Promise<T | undefined>;
+    run(...params: unknown[]): Promise<RunResult>;
+}
+interface SQLiteConnection {
+    exec(sql: string): Promise<void>;
+    prepare(sql: string): Promise<SQLiteStatement>;
+    transaction<T>(fn: (conn: SQLiteConnection) => Promise<T>): Promise<T>;
+    close(): Promise<void>;
+}
+interface OpenOptions {
+    readonly?: boolean;
+    walMode?: boolean;
+}
+interface DriverCapabilities {
+    multipleConnections: boolean;
+    extensions: boolean;
+}
+interface SQLiteDriver {
+    readonly capabilities: DriverCapabilities;
+    open(path: string, options?: OpenOptions): Promise<SQLiteConnection>;
+}
+
+export type { DriverCapabilities as D, OpenOptions as O, RunResult as R, SQLiteDriver as S, SQLiteConnection as a, SQLiteStatement as b };

package/dist/types-BeozgNPr.d.ts

@@ -0,0 +1,26 @@
+import { T as Transaction } from './types-D-74JiXb.js';
+
+interface AppliedMigration {
+    version: number;
+    name: string;
+    applied_at: number;
+}
+interface Migration {
+    version: number;
+    name: string;
+    up: string | ((tx: Transaction) => void | Promise<void>);
+    down?: string | ((tx: Transaction) => void | Promise<void>);
+}
+interface AppliedMigrationEntry {
+    version: number;
+    name: string;
+}
+interface MigrationResult {
+    applied: AppliedMigrationEntry[];
+    skipped: number;
+}
+interface RollbackResult {
+    rolledBack: AppliedMigrationEntry[];
+}
+
+export type { AppliedMigration as A, Migration as M, RollbackResult as R, MigrationResult as a, AppliedMigrationEntry as b };

package/dist/{types-DArCObcu.d.ts → types-D-74JiXb.d.ts}

@@ -1,5 +1,48 @@
+import { a as SQLiteConnection, S as SQLiteDriver } from './types-BFSsG77t.js';
+
+declare class Transaction {
+    private readonly conn;
+    private _lastInsertRowId;
+    constructor(conn: SQLiteConnection);
+    query<T = Record<string, unknown>>(sql: string, params?: Params): Promise<T[]>;
+    execute(sql: string, params?: Params): Promise<ExecuteResult>;
+    executeBatch(sql: string, paramsBatch: Params[]): Promise<ExecuteResult[]>;
+    get lastInsertRowId(): number | bigint;
+    static run<T>(conn: SQLiteConnection, fn: (tx: Transaction) => Promise<T>): Promise<T>;
+}
+
 /** Query parameter types: named (object) or positional (array). */
 type Params = Record<string, unknown> | unknown[];
+type WriteConcernLevel = 'local' | 'majority' | 'all';
+interface WriteConcern {
+    level: WriteConcernLevel;
+    timeoutMs?: number;
+}
+type ReadConcernLevel = 'local' | 'majority' | 'linearizable';
+interface ReadConcern {
+    level: ReadConcernLevel;
+}
+interface QueryOptions {
+    writeConcern?: WriteConcern;
+    readConcern?: ReadConcern;
+}
+interface ClusterReadEndpointInfo {
+    nodeId: string;
+    endpoint: string;
+    readConcerns: ReadConcernLevel[];
+}
+interface ClusterStatusInfo {
+    databaseId: string;
+    replicationGroupId?: string;
+    role?: 'primary' | 'replica';
+    currentPrimary?: {
+        nodeId: string;
+        endpoint?: string;
+    } | null;
+    primaryTerm?: bigint;
+    readEndpoints?: ClusterReadEndpointInfo[];
+    health: 'healthy' | 'degraded' | 'failing_over' | 'unavailable' | 'repairing' | 'syncing';
+}
 /** Result returned by mutation statements (INSERT, UPDATE, DELETE). */
 interface ExecuteResult {
     changes: number;
@@ -22,6 +65,8 @@ interface QueryHookContext {
     sql: string;
     params?: Params;
     metadata?: Record<string, unknown>;
+    writeConcern?: WriteConcern;
+    readConcern?: ReadConcern;
 }
 /** Hook invoked before a query is executed. Throw to deny. */
 type BeforeQueryHook = (ctx: QueryHookContext) => void | Promise<void>;
@@ -113,6 +158,7 @@ interface DatabaseOptions {
 }
 /** Top-level options for the Sirannon database registry. */
 interface SirannonOptions {
+    driver: SQLiteDriver;
     hooks?: HookConfig;
     metrics?: MetricsConfig;
     lifecycle?: LifecycleConfig;
@@ -153,12 +199,42 @@ interface RequestDenial {
 }
 /** Middleware hook for auth, rate limiting, and request validation. */
 type OnRequestHook = (ctx: RequestContext) => undefined | RequestDenial | Promise<undefined | RequestDenial>;
+interface ServerExecutionTarget {
+    query<T = Record<string, unknown>>(sql: string, params?: Params, options?: QueryOptions): Promise<T[]>;
+    execute(sql: string, params?: Params, options?: QueryOptions): Promise<ExecuteResult>;
+    transaction<T>(fn: (tx: Transaction) => Promise<T>, options?: QueryOptions): Promise<T>;
+}
+type ServerExecutionTargetResolver = (databaseId: string) => ServerExecutionTarget | null | undefined | Promise<ServerExecutionTarget | null | undefined>;
 /** Options for the standalone HTTP + WS server. */
 interface ServerOptions {
     host?: string;
     port?: number;
     cors?: boolean | CorsOptions;
     onRequest?: OnRequestHook;
+    resolveExecutionTarget?: ServerExecutionTargetResolver;
+    getReplicationStatus?: () => ReplicationStatusInfo | null;
+    getClusterStatus?: (databaseId: string) => ClusterStatusInfo | null;
+}
+interface ReplicationStatusInfo {
+    role: string;
+    writeForwarding: boolean;
+    peers: number;
+    localSeq: bigint;
+    replicationGroupId?: string;
+    primaryTerm?: bigint;
+    currentPrimary?: string;
+    coordinator?: {
+        connected: boolean;
+        authority: boolean;
+    };
+    controller?: {
+        state: 'disabled' | 'standby' | 'active' | 'lost';
+    };
+    inSyncReplicas?: string[];
+    laggingReplicas?: string[];
+    syncState?: string;
+    readAvailability?: 'available' | 'unavailable';
+    writeAvailability?: 'available' | 'unavailable';
 }
 /** CORS configuration. */
 interface CorsOptions {
@@ -170,6 +246,7 @@ interface CorsOptions {
 interface WSHandlerOptions {
     /** Maximum message size in bytes. Default: 1_048_576 (1 MB). */
     maxPayloadLength?: number;
+    resolveExecutionTarget?: ServerExecutionTargetResolver;
 }
 /** Options for the client SDK. */
 interface ClientOptions {
@@ -177,10 +254,12 @@ interface ClientOptions {
     transport?: 'websocket' | 'http';
     /** Custom headers for HTTP requests. */
     headers?: Record<string, string>;
+    /** WebSocket subprotocols sent during the browser-compatible handshake. */
+    webSocketProtocols?: string | string[];
     /** Reconnect on WebSocket disconnect. Default: true. */
     autoReconnect?: boolean;
     /** Reconnect interval in ms. Default: 1000. */
     reconnectInterval?: number;
 }
 
-export type { AfterQueryHook as A, BackupScheduleOptions as B, CDCMetrics as C, DatabaseOptions as D, ExecuteResult as E, HookConfig as H, LifecycleConfig as L, MetricsConfig as M, OnRequestHook as O, Params as P, QueryHookContext as Q, RequestContext as R, ServerOptions as S, WSHandlerOptions as W, BeforeConnectHook as a, BeforeQueryHook as b, BeforeSubscribeHook as c, ChangeEvent as d, ChangeOperation as e, ClientOptions as f, ConnectionHookContext as g, ConnectionMetrics as h, CorsOptions as i, DatabaseCloseHook as j, DatabaseOpenHook as k, QueryMetrics as l, RequestDenial as m, SirannonOptions as n, Subscription as o, SubscriptionBuilder as p };
+export { type AfterQueryHook as A, type BeforeQueryHook as B, type ChangeEvent as C, type DatabaseOptions as D, type ExecuteResult as E, type HookConfig as H, type LifecycleConfig as L, type MetricsConfig as M, type OnRequestHook as O, type Params as P, type QueryHookContext as Q, type ReadConcern as R, type SirannonOptions as S, Transaction as T, type WriteConcern as W, type BeforeConnectHook as a, type DatabaseOpenHook as b, type DatabaseCloseHook as c, type ServerOptions as d, type WSHandlerOptions as e, type ConnectionHookContext as f, type BeforeSubscribeHook as g, type QueryMetrics as h, type ConnectionMetrics as i, type CDCMetrics as j, type QueryOptions as k, type SubscriptionBuilder as l, type BackupScheduleOptions as m, type ChangeOperation as n, type ClientOptions as o, type ClusterReadEndpointInfo as p, type ClusterStatusInfo as q, type CorsOptions as r, type ReadConcernLevel as s, type ReplicationStatusInfo as t, type RequestContext as u, type RequestDenial as v, type ServerExecutionTarget as w, type ServerExecutionTargetResolver as x, type Subscription as y, type WriteConcernLevel as z };

package/dist/vfs-INWQ5DTE.mjs

@@ -0,0 +1,2 @@
+export { AccessHandlePoolVFS } from 'wa-sqlite/src/examples/AccessHandlePoolVFS.js';
+export { IDBBatchAtomicVFS } from 'wa-sqlite/src/examples/IDBBatchAtomicVFS.js';