@delali/sirannon-db 0.2.0 → 0.2.1

package/dist/types-rVZKnKN-.d.ts

@@ -0,0 +1,591 @@
+import { P as Params, W as WriteConcern, R as ReadConcern, b as ChangeOperation, E as ExecuteResult, a as ReadConcernLevel } from './query-types-DL3LtPvY.js';
+
+/** Context passed to query hooks.
+ * @public
+ */
+interface QueryHookContext {
+    /** Identifier of the database the statement runs against. */
+    databaseId: string;
+    /** The statement about to run, or the one that just ran. */
+    sql: string;
+    /** Parameters bound to the statement. */
+    params?: Params;
+    /** Values a caller attached to the request for its own hooks to read. */
+    metadata?: Record<string, unknown>;
+    /** Acknowledgements this write waits for. */
+    writeConcern?: WriteConcern;
+    /** Currency this read requires. */
+    readConcern?: ReadConcern;
+}
+/** Hook invoked before a query is executed. Throw to deny.
+ * @public
+ */
+type BeforeQueryHook = (ctx: QueryHookContext) => void | Promise<void>;
+/** Hook invoked after a query is executed.
+ * @public
+ */
+type AfterQueryHook = (ctx: QueryHookContext & {
+    durationMs: number;
+}) => void | Promise<void>;
+/** Context passed to connection hooks.
+ * @public
+ */
+interface ConnectionHookContext {
+    /** Identifier of the database being opened or closed. */
+    databaseId: string;
+    /** File path of the SQLite database. */
+    path: string;
+}
+/** Hook invoked before a database connection is established.
+ * @public
+ */
+type BeforeConnectHook = (ctx: ConnectionHookContext) => void | Promise<void>;
+/** Hook invoked when a database is opened.
+ * @public
+ */
+type DatabaseOpenHook = (ctx: ConnectionHookContext) => void | Promise<void>;
+/** Hook invoked when a database is closed.
+ * @public
+ */
+type DatabaseCloseHook = (ctx: ConnectionHookContext) => void | Promise<void>;
+/** Hook invoked before a subscription is created. Throw to deny.
+ * @public
+ */
+type BeforeSubscribeHook = (ctx: {
+    databaseId: string;
+    table: string;
+    filter?: Record<string, unknown>;
+}) => void | Promise<void>;
+/** Aggregated hook configuration.
+ * @public
+ */
+interface HookConfig {
+    /** Runs before each statement. Throw to refuse it. */
+    onBeforeQuery?: BeforeQueryHook | BeforeQueryHook[];
+    /** Runs after each statement, with the time it took. */
+    onAfterQuery?: AfterQueryHook | AfterQueryHook[];
+    /** Runs before a database connection opens. */
+    onBeforeConnect?: BeforeConnectHook | BeforeConnectHook[];
+    /** Runs once a database is open. */
+    onDatabaseOpen?: DatabaseOpenHook | DatabaseOpenHook[];
+    /** Runs once a database is closed. */
+    onDatabaseClose?: DatabaseCloseHook | DatabaseCloseHook[];
+    /** Runs before a change subscription starts. Throw to refuse it. */
+    onBeforeSubscribe?: BeforeSubscribeHook | BeforeSubscribeHook[];
+}
+
+/** Metrics emitted after a query completes.
+ * @public
+ */
+interface QueryMetrics {
+    /** Identifier of the database the statement ran against. */
+    databaseId: string;
+    /** The statement that ran. */
+    sql: string;
+    /** How long the statement took, in milliseconds. */
+    durationMs: number;
+    /** Number of rows a read returned. */
+    rowsReturned?: number;
+    /** Number of rows a write changed. */
+    changes?: number;
+    /** Set when the statement threw. */
+    error?: boolean;
+}
+/** Metrics emitted when a connection opens or closes.
+ * @public
+ */
+interface ConnectionMetrics {
+    /** Identifier of the database whose connection opened or closed. */
+    databaseId: string;
+    /** File path of the SQLite database. */
+    path: string;
+    /** Number of read connections the pool holds. */
+    readerCount: number;
+    /** Whether the connection opened or closed. */
+    event: 'open' | 'close';
+}
+/** Metrics emitted when a CDC event is dispatched.
+ * @public
+ */
+interface CDCMetrics {
+    /** Identifier of the database the change came from. */
+    databaseId: string;
+    /** Table the changed row belongs to. */
+    table: string;
+    /** Whether the row was inserted, updated, or deleted. */
+    operation: ChangeOperation;
+    /** Number of subscribers the event reached. */
+    subscriberCount: number;
+}
+/** Callbacks for metrics collection.
+ * @public
+ */
+interface MetricsConfig {
+    /** Called once each statement finishes, whether it succeeded or threw. */
+    onQueryComplete?: (metrics: QueryMetrics) => void;
+    /** Called when a database connection opens. */
+    onConnectionOpen?: (metrics: ConnectionMetrics) => void;
+    /** Called when a database connection closes. */
+    onConnectionClose?: (metrics: ConnectionMetrics) => void;
+    /** Called each time a change event reaches its subscribers. */
+    onCDCEvent?: (metrics: CDCMetrics) => void;
+}
+
+/**
+ * Runs statements inside one transaction. A function passed to {@link Database.transaction} receives it.
+ *
+ * @public
+ */
+declare class Transaction {
+    private readonly conn;
+    private _lastInsertRowId;
+    constructor(conn: SQLiteConnection);
+    /**
+     * Runs a read inside this transaction.
+     *
+     * @param sql - The statement to run.
+     * @param params - Values bound to the statement, named or positional.
+     * @returns The rows the statement produced.
+     */
+    query<T = Record<string, unknown>>(sql: string, params?: Params): Promise<T[]>;
+    /**
+     * Runs one write inside this transaction.
+     *
+     * @param sql - The statement to run.
+     * @param params - Values bound to the statement, named or positional.
+     * @returns How many rows changed, and the last inserted row id.
+     */
+    execute(sql: string, params?: Params): Promise<ExecuteResult>;
+    /**
+     * Runs one statement over many parameter sets inside this transaction.
+     *
+     * @param sql - The statement to run for each parameter set.
+     * @param paramsBatch - One parameter set per run.
+     * @returns One result per parameter set, in order.
+     */
+    executeBatch(sql: string, paramsBatch: Params[]): Promise<ExecuteResult[]>;
+    /**
+     * Row id SQLite assigned to the last row this transaction inserted.
+     */
+    get lastInsertRowId(): number | bigint;
+    /** @internal */
+    static run<T>(conn: SQLiteConnection, fn: (tx: Transaction) => Promise<T>): Promise<T>;
+}
+
+/** Characters a migration name may use: letters, digits, and underscores.
+ * @public
+ */
+declare const MIGRATION_NAME_RE: RegExp;
+/** One migration a database has already applied, as recorded in its catalogue.
+ * @public
+ */
+interface AppliedMigration {
+    /** Version number of the migration. */
+    version: number;
+    /** Name of the migration. */
+    name: string;
+    /** Milliseconds since the Unix epoch, taken when the migration was applied. */
+    applied_at: number;
+}
+/**
+ * Marks a migration as the point an existing database starts from, so the
+ * runner records every earlier version as applied without running it.
+ *
+ * @public
+ */
+interface MigrationBaseline {
+    /** Highest version this baseline covers. */
+    through: number;
+}
+/** One schema change, with the statements that apply it and the statements that undo it.
+ * @public
+ */
+interface Migration {
+    /** Version number. The runner applies migrations in ascending order. */
+    version: number;
+    /** Name of the migration, using letters, digits, and underscores. */
+    name: string;
+    /** SQL that applies the change, or a function that runs it inside the migration's transaction. */
+    up: string | ((tx: Transaction) => void | Promise<void>);
+    /** SQL that undoes the change, or a function that runs it. A migration without this cannot roll back. */
+    down?: string | ((tx: Transaction) => void | Promise<void>);
+    /** Marks this migration as the point an existing database starts from. */
+    baseline?: MigrationBaseline;
+}
+/** Migrations to apply, either as an array or as a function that produces one.
+ * @public
+ */
+type MigrationSource = Migration[] | (() => Migration[] | Promise<Migration[]>);
+/** One migration named in a migration or rollback result.
+ * @public
+ */
+interface AppliedMigrationEntry {
+    /** Version number of the migration. */
+    version: number;
+    /** Name of the migration. */
+    name: string;
+}
+/** What one call to migrate did.
+ * @public
+ */
+interface MigrationResult {
+    /** Migrations this call applied, in the order it applied them. */
+    applied: AppliedMigrationEntry[];
+    /** Number of migrations the database had already applied. */
+    skipped: number;
+}
+/** What one call to roll back did.
+ * @public
+ */
+interface RollbackResult {
+    /** Migrations this call undid, newest first. */
+    rolledBack: AppliedMigrationEntry[];
+}
+
+/** One node a client can read from, and the read concerns it currently serves.
+ * @public
+ */
+interface ClusterReadEndpointInfo {
+    /** Identifier of the node behind this endpoint. */
+    nodeId: string;
+    /** Address a client sends its reads to. */
+    endpoint: string;
+    /** Read concerns this node meets right now. */
+    readConcerns: ReadConcernLevel[];
+}
+/** The single word describing what a node can do right now.
+ * @public
+ */
+type NodeHealthState = 'healthy' | 'degraded' | 'failing_over' | 'repairing' | 'syncing' | 'unavailable';
+/** The condition that produced a {@link NodeHealthState}.
+ * @public
+ */
+type NodeHealthReason = 'in-sync' | 'lagging' | 'coordinator-unreachable' | 'draining' | 'repairing' | 'faulted' | 'sync-pending' | 'no-group-state';
+/**
+ * The health of one node, covering only the node that reports it.
+ *
+ * `canRead` and `canWrite` are what that node will accept at this moment;
+ * `state` and `reason` name the condition behind them.
+ *
+ * @public
+ */
+interface NodeHealth {
+    /** What the node can do right now. */
+    state: NodeHealthState;
+    /** The condition behind that state. */
+    reason: NodeHealthReason;
+    /** Whether the node serves reads at this moment. */
+    canRead: boolean;
+    /** Whether the node accepts writes at this moment. */
+    canWrite: boolean;
+}
+/** What one node reports about its replication group, as served by `GET /db/{id}/cluster`.
+ * @public
+ */
+interface ClusterStatusInfo {
+    /** Identifier of the database this status describes. */
+    databaseId: string;
+    /** Identifier of the replication group the node belongs to. */
+    replicationGroupId?: string;
+    /** Whether this node accepts writes or serves reads. */
+    role?: 'primary' | 'replica';
+    /** The primary this node reports as current, or null when it has none. */
+    currentPrimary?: {
+        nodeId: string;
+        endpoint?: string;
+    } | null;
+    /** The primary term this node reports as current. */
+    primaryTerm?: bigint;
+    /** Every node a client can read from, with the read concerns each one serves. */
+    readEndpoints?: ClusterReadEndpointInfo[];
+    /** What this node can do right now. */
+    health: NodeHealthState;
+    /** The condition behind that health. */
+    healthReason: NodeHealthReason;
+}
+/** Configuration for automatic database lifecycle management.
+ * @public
+ */
+interface LifecycleConfig {
+    /** Opens a database the first time someone asks for an identifier the registry has not seen. */
+    autoOpen?: {
+        resolver: (id: string) => {
+            path: string;
+            options?: DatabaseOptions;
+        } | undefined;
+    };
+    /** Milliseconds before an idle database is closed. 0 = disabled. */
+    idleTimeout?: number;
+    /** Maximum number of concurrently open databases. 0 = unlimited. */
+    maxOpen?: number;
+}
+/** Options for opening a single database.
+ * @public
+ */
+interface DatabaseOptions {
+    /** Open the database in read-only mode. */
+    readOnly?: boolean;
+    /** Number of read connections in the pool. Default: 4. */
+    readPoolSize?: number;
+    /** Enable WAL mode. Default: true. */
+    walMode?: boolean;
+    /**
+     * Writer durability (`PRAGMA synchronous`). Default: 'normal'. This is the
+     * level restored after every bulk load, whatever the load relaxed it to.
+     */
+    synchronous?: SynchronousLevel;
+    /** CDC polling interval in milliseconds. Default: 50. */
+    cdcPollInterval?: number;
+    /** CDC retention period in milliseconds. Default: 3_600_000 (1 hour). */
+    cdcRetention?: number;
+    /**
+     * Run writes on a dedicated worker thread so disk flushes never block the
+     * thread serving connections; reads stay on the calling thread. Requires a
+     * driver with a worker entry (the `better-sqlite3` and `node` drivers have
+     * one), otherwise opening throws. Default: off.
+     */
+    writerWorker?: boolean | WriterWorkerOptions;
+}
+/** Limits and recovery settings for the thread that runs writes.
+ * @public
+ */
+interface WriterWorkerOptions {
+    /** Writes allowed in flight before new writes are rejected with a busy signal. Default: 1024. */
+    maxPendingWrites?: number;
+    /** Per-operation deadline in ms; when an operation stalls past it, its caller is rejected loudly while the worker keeps running, so a stalled write's outcome is indeterminate. 0 disables it. Default: 30000. */
+    writeTimeoutMs?: number;
+    /** Restarts the worker this many times after it crashes on its own before writes fail permanently. Default: 5. */
+    maxRestarts?: number;
+}
+/** Top-level options for the Sirannon database registry.
+ * @public
+ */
+interface SirannonOptions {
+    /** SQLite driver every database in this registry opens through. */
+    driver: SQLiteDriver;
+    /** Lifecycle hooks that run for every database in this registry. */
+    hooks?: HookConfig;
+    /** Callbacks that receive statement, connection, and change-capture metrics. */
+    metrics?: MetricsConfig;
+    /** Automatic opening, idle eviction, and the limit on concurrently open databases. */
+    lifecycle?: LifecycleConfig;
+    /** Migrations every database in this registry applies when it opens. */
+    migrations?: MigrationSource;
+    /** Default writer-worker setting for the databases this registry opens. */
+    writerWorker?: boolean | WriterWorkerOptions;
+}
+/** Options for scheduled backups.
+ * @public
+ */
+interface BackupScheduleOptions {
+    /** Cron expression (e.g., '0 * * * *' for hourly). */
+    cron: string;
+    /** Directory to store backup files. */
+    destDir: string;
+    /** Maximum number of backup files to keep. Default: 5. */
+    maxFiles?: number;
+    /**
+     * Sirannon evaluates the cron expression in this IANA time zone (e.g. 'America/New_York').
+     * When omitted, it uses the host's local time zone, which also sets the daylight saving rules that apply.
+     */
+    timezone?: string;
+    /** Called when a scheduled backup fails. Without this, errors are silently discarded. */
+    onError?: (error: Error) => void;
+}
+
+interface WorkerHostOptions {
+    writeTimeoutMs?: number;
+    maxRestarts?: number;
+}
+
+/** What one write reports back through the driver.
+ * @public
+ */
+interface RunResult {
+    /** Number of rows the statement inserted, updated, or deleted. */
+    changes: number;
+    /** Row id SQLite assigned to the last inserted row. */
+    lastInsertRowId: number | bigint;
+}
+/**
+ * Tells a caller running inside the operation that holds the writer from one
+ * merely waiting on it. A runtime without async context tracking cannot answer
+ * this, and answering it wrongly runs one caller's writes inside another
+ * caller's transaction.
+ */
+interface WriterContext {
+    /** Runs an operation marked as the one holding the writer. */
+    run<T>(operation: () => T): T;
+    /** Reports whether the caller is the operation holding the writer. */
+    isActive(): boolean;
+    /** Runs an operation outside the held writer, so its writes stay out of that transaction. */
+    exit<T>(operation: () => T): T;
+}
+/**
+ * Copies a database to a file, and repeats that copy on a schedule.
+ *
+ * @internal
+ */
+interface BackupEngine {
+    /** Copies the database behind a connection to a destination path. */
+    backup(conn: SQLiteConnection, destPath: string): Promise<void>;
+    /** Starts a repeating backup and returns a function that stops it. */
+    schedule(conn: SQLiteConnection, options: BackupScheduleOptions, runExclusive: (op: () => Promise<void>) => Promise<void>): () => void;
+}
+/** Totals for one statement applied over many parameter sets.
+ * @public
+ */
+interface BatchSummary {
+    /** Number of parameter sets the driver applied. */
+    rowsLoaded: number;
+    /** Number of rows those statements inserted, updated, or deleted. */
+    changes: number;
+}
+/** One prepared statement a driver hands back, ready to run many times.
+ * @public
+ */
+interface SQLiteStatement {
+    /** Runs the statement and returns every row. */
+    all<T = unknown>(...params: unknown[]): Promise<T[]>;
+    /** Runs the statement and returns the first row, or undefined when there is none. */
+    get<T = unknown>(...params: unknown[]): Promise<T | undefined>;
+    /** Runs the statement as a write and reports what it changed. */
+    run(...params: unknown[]): Promise<RunResult>;
+    /**
+     * Like {@link SQLiteStatement.all} but skips the safe-range BigInt narrowing, leaving every
+     * integer as a BigInt. The server wire path narrows and tags in one pass, so
+     * feeding it raw rows avoids a second walk. Optional: a driver that omits it
+     * falls back to {@link SQLiteStatement.all}, still correct but with the extra narrowing walk.
+     */
+    allRaw?<T = unknown>(...params: unknown[]): Promise<T[]>;
+}
+/**
+ * Why one unit of a grouped run failed.
+ *
+ * @internal
+ */
+interface GroupRunError {
+    /** Message SQLite or the driver raised. */
+    message: string;
+    /** Name of the error class. */
+    name?: string;
+    /** Machine-readable code, where the driver supplies one. */
+    code?: string;
+}
+/**
+ * What one unit of a grouped run produced.
+ *
+ * @internal
+ */
+type GroupRunOutcome = {
+    ok: true;
+    results: RunResult[];
+} | {
+    ok: false;
+    error: GroupRunError;
+};
+/** One open connection to a SQLite database.
+ * @public
+ */
+interface SQLiteConnection {
+    /** Runs one or more statements and returns no rows. */
+    exec(sql: string): Promise<void>;
+    /** Compiles a statement so the caller can run it many times. */
+    prepare(sql: string): Promise<SQLiteStatement>;
+    /** Runs a function inside one transaction, committing when it returns and rolling back when it throws. */
+    transaction<T>(fn: (conn: SQLiteConnection) => Promise<T>): Promise<T>;
+    /** Closes the connection. */
+    close(): Promise<void>;
+    /** Optional fast path that applies one statement over many parameter sets. */
+    runBatch?(sql: string, paramsBatch: readonly unknown[][]): Promise<RunResult[]>;
+    /** Optional fast path that applies one statement over many parameter sets and returns only the totals. */
+    runBatchSummary?(sql: string, paramsBatch: readonly unknown[][]): Promise<BatchSummary>;
+    /**
+     * Runs several independent units in one transaction, one outcome per unit in
+     * order. A unit is one write or one whole transaction, and a unit that fails
+     * must not disturb the others.
+     */
+    runGroup?(units: readonly {
+        statements: readonly {
+            sql: string;
+            params?: readonly unknown[];
+            trusted?: boolean;
+        }[];
+    }[]): Promise<GroupRunOutcome[]>;
+}
+/**
+ * SQLite `PRAGMA synchronous` level applied to a connection. `normal` is safe
+ * from corruption in WAL mode but can lose the most recent commits on power
+ * loss; `full` fsyncs every commit; `extra` adds a directory sync after the
+ * rollback journal is unlinked in DELETE journal mode and equals `full` in
+ * WAL mode; `off` hands writes to the OS without syncing and is sanctioned
+ * only for re-runnable bulk loads.
+ *
+ * @public
+ */
+type SynchronousLevel = 'off' | 'normal' | 'full' | 'extra';
+/** How a driver opens one database file.
+ * @public
+ */
+interface OpenOptions {
+    /** Opens the file for reads only. */
+    readonly?: boolean;
+    /** Puts the database in write-ahead logging mode. */
+    walMode?: boolean;
+    /** Writer durability the connection runs at. */
+    synchronous?: SynchronousLevel;
+}
+/** What a driver's runtime supports.
+ * @public
+ */
+interface DriverCapabilities {
+    /** Whether the runtime opens more than one connection to the same file. */
+    multipleConnections: boolean;
+    /** Whether the runtime loads SQLite extensions. */
+    extensions: boolean;
+}
+/**
+ * Lets a worker thread rebuild the driver, since the driver's `open` function
+ * cannot cross the thread boundary. `specifier` must be importable from the
+ * worker and `config` must survive a structured clone; the worker imports the
+ * module and calls its `exportName` factory (default export otherwise) with it.
+ *
+ * @public
+ */
+interface DriverWorkerEntry {
+    /** Module the worker imports to rebuild the driver. */
+    specifier: string;
+    /** Named export the worker calls, or the default export when absent. */
+    exportName?: string;
+    /** Value passed to that factory, which must survive a structured clone. */
+    config?: unknown;
+}
+/** How Sirannon opens SQLite on one runtime.
+ * @public
+ */
+interface SQLiteDriver {
+    /** What this driver's runtime supports. */
+    readonly capabilities: DriverCapabilities;
+    /** Opens a database file and returns a connection to it. */
+    open(path: string, options?: OpenOptions): Promise<SQLiteConnection>;
+    /** How a worker thread rebuilds this driver. */
+    readonly worker?: DriverWorkerEntry;
+    /**
+     * Offloads writes to a worker thread. Only a driver whose runtime has
+     * threads implements this, which is what keeps the thread machinery out of
+     * bundles built for runtimes that do not.
+     */
+    startWriterHost?(path: string, options: OpenOptions, hostOptions?: WorkerHostOptions): Promise<SQLiteConnection>;
+    /** Builds the tracker that tells the caller holding the writer from one waiting on it. */
+    createWriterContext?(): WriterContext;
+    /** Builds the engine that copies a database to a file. */
+    createBackupEngine?(): BackupEngine;
+    /**
+     * Makes an extension path absolute. Passing a bare name to `load_extension`
+     * would let the dynamic linker search its own paths and open a different
+     * library than the operator named.
+     */
+    resolveExtensionPath?(extensionPath: string): string;
+}
+
+export { type AfterQueryHook as A, type BeforeQueryHook as B, type ClusterStatusInfo as C, type DatabaseOptions as D, type SQLiteStatement as E, type WriterWorkerOptions as F, type HookConfig as H, type LifecycleConfig as L, type Migration as M, type NodeHealth as N, type OpenOptions as O, type QueryHookContext as Q, type RollbackResult as R, type SirannonOptions as S, Transaction as T, type WorkerHostOptions as W, type SQLiteDriver as a, type BeforeConnectHook as b, type DatabaseOpenHook as c, type DatabaseCloseHook as d, type SQLiteConnection as e, type BackupScheduleOptions as f, type ConnectionHookContext as g, type BeforeSubscribeHook as h, type MetricsConfig as i, type QueryMetrics as j, type ConnectionMetrics as k, type CDCMetrics as l, type MigrationResult as m, type SynchronousLevel as n, type AppliedMigration as o, type AppliedMigrationEntry as p, type BatchSummary as q, type ClusterReadEndpointInfo as r, type DriverCapabilities as s, type DriverWorkerEntry as t, MIGRATION_NAME_RE as u, type MigrationBaseline as v, type MigrationSource as w, type NodeHealthReason as x, type NodeHealthState as y, type RunResult as z };

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@delali/sirannon-db",
   "type": "module",
-  "version": "0.2.0",
+  "version": "0.2.1",
   "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",
@@ -41,6 +41,7 @@
       "import": "./dist/driver/node.mjs"
     },
     "./driver/bun": {
+      "types": "./dist/driver/bun.d.ts",
       "import": "./dist/driver/bun.mjs"
     },
     "./driver/wa-sqlite": {
@@ -48,6 +49,7 @@
       "import": "./dist/driver/wa-sqlite.mjs"
     },
     "./driver/expo": {
+      "types": "./dist/driver/expo.d.ts",
       "import": "./dist/driver/expo.mjs"
     },
     "./file-migrations": {
@@ -162,6 +164,7 @@
   "devDependencies": {
     "@bufbuild/protobuf": "2.11.0",
     "@grpc/grpc-js": "1.14.4",
+    "@microsoft/api-extractor": "7.58.12",
     "@types/better-sqlite3": "7.6.13",
     "@types/node": "26.1.2",
     "@types/react": "19.2.15",
@@ -169,6 +172,7 @@
     "@vitest/coverage-v8": "4.0.18",
     "better-sqlite3": "13.0.2",
     "etcd3": "1.1.2",
+    "expo-sqlite": "55.0.10",
     "grpc-health-check": "2.1.0",
     "grpc-tools": "1.13.1",
     "jsdom": "29.1.1",
@@ -186,6 +190,8 @@
     "build": "rm -rf dist && tsup",
     "check:bundle": "node scripts/assert-browser-bundle.mjs",
     "check:types": "node scripts/assert-consumer-types.mjs",
+    "check:api": "node scripts/assert-api-reports.mjs",
+    "api:update": "node scripts/assert-api-reports.mjs --update",
     "test": "vitest run",
     "test:coverage": "vitest run --coverage",
     "test:e2e": "vitest run --config vitest.e2e.config.ts",

package/dist/baseline-Br77Fnhb.d.ts

@@ -1,6 +0,0 @@
-interface BaselineFileOption {
-    version: number;
-    through: number;
-}
-
-export type { BaselineFileOption as B };