@opensip-cli/datastore 0.1.0

package/dist/data-store.d.ts

@@ -0,0 +1,78 @@
+import type { BetterSQLite3Database } from 'drizzle-orm/better-sqlite3';
+export type DrizzleHandle<TSchema extends Record<string, unknown> = Record<string, unknown>> = BetterSQLite3Database<TSchema>;
+/** Public persistence handle: lifecycle plus transaction, but no raw query escape hatch. */
+export interface DataStore<TSchema extends Record<string, unknown> = Record<string, unknown>> {
+    close(): void;
+    transaction<T>(fn: (tx: DrizzleHandle<TSchema>) => T): T;
+}
+/**
+ * Persistence-layer handle that exposes the raw Drizzle DB. Repository modules
+ * can narrow to this shape when they own the table boundary; general consumers
+ * should stay on {@link DataStore}.
+ *
+ * Direct query calls must stay inside `src/persistence/`, `session-store`, or
+ * `datastore`. Cross-module business code should go through the owning
+ * repository/API; `restrict-raw-db-access` guards that boundary.
+ */
+export interface DrizzleDataStore<TSchema extends Record<string, unknown> = Record<string, unknown>> extends DataStore<TSchema> {
+    readonly db: DrizzleHandle<TSchema>;
+}
+/**
+ * A SQLite-backed {@link DrizzleDataStore} that also exposes its built-in
+ * `PRAGMA user_version` schema-stamp. Internal to the datastore package — the
+ * factory uses it to read/write the version guard before and after migrating.
+ * General consumers stay on {@link DataStore} / {@link DrizzleDataStore}.
+ */
+export interface SqliteBackendHandle<TSchema extends Record<string, unknown> = Record<string, unknown>> extends DrizzleDataStore<TSchema> {
+    /** Read SQLite's `PRAGMA user_version` (0 on a fresh or pre-guard database). */
+    readUserVersion(): number;
+    /** Write SQLite's `PRAGMA user_version` schema-stamp. */
+    writeUserVersion(version: number): void;
+}
+export declare function isDrizzleDataStore(value: unknown): value is DrizzleDataStore;
+/**
+ * Narrow a {@link DataStore} to a {@link DrizzleDataStore}, requiring the raw
+ * Drizzle handle to be present.
+ *
+ * @throws {Error} when `datastore` is not Drizzle-backed (general callers should
+ *   use repository APIs instead of the raw datastore handle).
+ */
+export declare function requireDrizzleDataStore(datastore: DataStore): DrizzleDataStore;
+/** Options for opening a {@link DataStore}: backend choice and optional file path. */
+export interface DataStoreOpenOptions {
+    backend: 'sqlite' | 'memory';
+    path?: string;
+}
+/** Thrown when a Drizzle schema migration fails to apply; carries the offending file name. */
+export declare class DataStoreMigrationError extends Error {
+    readonly migrationFile: string | undefined;
+    constructor(message: string, options?: {
+        migrationFile?: string;
+        cause?: unknown;
+    });
+}
+/** Inputs describing an incompatible (future) on-disk database. */
+export interface DataStoreVersionMismatch {
+    readonly path: string;
+    /** The `user_version` stamp found on disk. */
+    readonly dbVersion: number;
+    /** The highest schema version this CLI supports. */
+    readonly supportedVersion: number;
+}
+/**
+ * Thrown when the on-disk SQLite cache was written by a NEWER opensip-cli than
+ * the one now opening it (`dbVersion > supportedVersion`). Drizzle's migrator
+ * cannot detect this direction — the older CLI's migrations are all a prefix of
+ * what was applied, so `migrate()` would no-op and later queries would hit
+ * missing/renamed columns with a confusing error. This guard fails fast instead,
+ * with an actionable message symmetric to the config-schema "upgrade your CLI"
+ * bailout. The `.runtime/` cache is disposable, so deleting it is offered as the
+ * fallback for users who intend to stay on the older CLI.
+ */
+export declare class DataStoreVersionError extends Error {
+    readonly path: string;
+    readonly dbVersion: number;
+    readonly supportedVersion: number;
+    constructor(mismatch: DataStoreVersionMismatch);
+}
+//# sourceMappingURL=data-store.d.ts.map

package/dist/data-store.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"data-store.d.ts","sourceRoot":"","sources":["../src/data-store.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,qBAAqB,EAAE,MAAM,4BAA4B,CAAC;AAExE,MAAM,MAAM,aAAa,CAAC,OAAO,SAAS,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,IACzF,qBAAqB,CAAC,OAAO,CAAC,CAAC;AAEjC,4FAA4F;AAC5F,MAAM,WAAW,SAAS,CAAC,OAAO,SAAS,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC;IAC1F,KAAK,IAAI,IAAI,CAAC;IACd,WAAW,CAAC,CAAC,EAAE,EAAE,EAAE,CAAC,EAAE,EAAE,aAAa,CAAC,OAAO,CAAC,KAAK,CAAC,GAAG,CAAC,CAAC;CAC1D;AAED;;;;;;;;GAQG;AACH,MAAM,WAAW,gBAAgB,CAC/B,OAAO,SAAS,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CACjE,SAAQ,SAAS,CAAC,OAAO,CAAC;IAC1B,QAAQ,CAAC,EAAE,EAAE,aAAa,CAAC,OAAO,CAAC,CAAC;CACrC;AAED;;;;;GAKG;AACH,MAAM,WAAW,mBAAmB,CAClC,OAAO,SAAS,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CACjE,SAAQ,gBAAgB,CAAC,OAAO,CAAC;IACjC,gFAAgF;IAChF,eAAe,IAAI,MAAM,CAAC;IAC1B,yDAAyD;IACzD,gBAAgB,CAAC,OAAO,EAAE,MAAM,GAAG,IAAI,CAAC;CACzC;AAED,wBAAgB,kBAAkB,CAAC,KAAK,EAAE,OAAO,GAAG,KAAK,IAAI,gBAAgB,CAU5E;AAED;;;;;;GAMG;AACH,wBAAgB,uBAAuB,CAAC,SAAS,EAAE,SAAS,GAAG,gBAAgB,CAK9E;AAED,sFAAsF;AACtF,MAAM,WAAW,oBAAoB;IACnC,OAAO,EAAE,QAAQ,GAAG,QAAQ,CAAC;IAC7B,IAAI,CAAC,EAAE,MAAM,CAAC;CACf;AAED,8FAA8F;AAC9F,qBAAa,uBAAwB,SAAQ,KAAK;IAChD,QAAQ,CAAC,aAAa,EAAE,MAAM,GAAG,SAAS,CAAC;gBAE/B,OAAO,EAAE,MAAM,EAAE,OAAO,GAAE;QAAE,aAAa,CAAC,EAAE,MAAM,CAAC;QAAC,KAAK,CAAC,EAAE,OAAO,CAAA;KAAO;CAQvF;AAED,mEAAmE;AACnE,MAAM,WAAW,wBAAwB;IACvC,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IACtB,8CAA8C;IAC9C,QAAQ,CAAC,SAAS,EAAE,MAAM,CAAC;IAC3B,oDAAoD;IACpD,QAAQ,CAAC,gBAAgB,EAAE,MAAM,CAAC;CACnC;AAED;;;;;;;;;GASG;AACH,qBAAa,qBAAsB,SAAQ,KAAK;IAC9C,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IACtB,QAAQ,CAAC,SAAS,EAAE,MAAM,CAAC;IAC3B,QAAQ,CAAC,gBAAgB,EAAE,MAAM,CAAC;gBAEtB,QAAQ,EAAE,wBAAwB;CAO/C"}

package/dist/data-store.js

@@ -0,0 +1,71 @@
+export function isDrizzleDataStore(value) {
+    return (typeof value === 'object' &&
+        value !== null &&
+        'db' in value &&
+        'transaction' in value &&
+        typeof value.transaction === 'function' &&
+        'close' in value &&
+        typeof value.close === 'function');
+}
+/**
+ * Narrow a {@link DataStore} to a {@link DrizzleDataStore}, requiring the raw
+ * Drizzle handle to be present.
+ *
+ * @throws {Error} when `datastore` is not Drizzle-backed (general callers should
+ *   use repository APIs instead of the raw datastore handle).
+ */
+export function requireDrizzleDataStore(datastore) {
+    if (isDrizzleDataStore(datastore))
+        return datastore;
+    throw new Error('A Drizzle-backed DataStore is required for repository access. General callers should use repository APIs instead of the raw datastore handle.');
+}
+/** Thrown when a Drizzle schema migration fails to apply; carries the offending file name. */
+export class DataStoreMigrationError extends Error {
+    migrationFile;
+    constructor(message, options = {}) {
+        // Pass cause to super so it lands on the standard Error.cause slot
+        // (ES2022). Don't redeclare the field — that would shadow it with a
+        // writable class-field property and bypass native engine handling.
+        super(message, options.cause === undefined ? undefined : { cause: options.cause });
+        this.name = 'DataStoreMigrationError';
+        this.migrationFile = options.migrationFile;
+    }
+}
+/**
+ * Thrown when the on-disk SQLite cache was written by a NEWER opensip-cli than
+ * the one now opening it (`dbVersion > supportedVersion`). Drizzle's migrator
+ * cannot detect this direction — the older CLI's migrations are all a prefix of
+ * what was applied, so `migrate()` would no-op and later queries would hit
+ * missing/renamed columns with a confusing error. This guard fails fast instead,
+ * with an actionable message symmetric to the config-schema "upgrade your CLI"
+ * bailout. The `.runtime/` cache is disposable, so deleting it is offered as the
+ * fallback for users who intend to stay on the older CLI.
+ */
+export class DataStoreVersionError extends Error {
+    path;
+    dbVersion;
+    supportedVersion;
+    constructor(mismatch) {
+        super(formatVersionErrorMessage(mismatch));
+        this.name = 'DataStoreVersionError';
+        this.path = mismatch.path;
+        this.dbVersion = mismatch.dbVersion;
+        this.supportedVersion = mismatch.supportedVersion;
+    }
+}
+function formatVersionErrorMessage(mismatch) {
+    return [
+        `This project's opensip-cli cache was written by a newer version of opensip-cli than this CLI supports.`,
+        ``,
+        `  Cache:          ${mismatch.path}`,
+        `  Cache schema:   v${mismatch.dbVersion}`,
+        `  CLI supports:   v${mismatch.supportedVersion}`,
+        ``,
+        `  Update your CLI to continue:`,
+        `    curl -fsSL https://opensip.ai/cli/install.sh | bash`,
+        ``,
+        `  (Or delete ${mismatch.path} to discard the local cache and continue with`,
+        `  this older CLI — session history will be lost; the cache rebuilds on next run.)`,
+    ].join('\n');
+}
+//# sourceMappingURL=data-store.js.map

package/dist/data-store.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"data-store.js","sourceRoot":"","sources":["../src/data-store.ts"],"names":[],"mappings":"AAyCA,MAAM,UAAU,kBAAkB,CAAC,KAAc;IAC/C,OAAO,CACL,OAAO,KAAK,KAAK,QAAQ;QACzB,KAAK,KAAK,IAAI;QACd,IAAI,IAAI,KAAK;QACb,aAAa,IAAI,KAAK;QACtB,OAAO,KAAK,CAAC,WAAW,KAAK,UAAU;QACvC,OAAO,IAAI,KAAK;QAChB,OAAO,KAAK,CAAC,KAAK,KAAK,UAAU,CAClC,CAAC;AACJ,CAAC;AAED;;;;;;GAMG;AACH,MAAM,UAAU,uBAAuB,CAAC,SAAoB;IAC1D,IAAI,kBAAkB,CAAC,SAAS,CAAC;QAAE,OAAO,SAAS,CAAC;IACpD,MAAM,IAAI,KAAK,CACb,+IAA+I,CAChJ,CAAC;AACJ,CAAC;AAQD,8FAA8F;AAC9F,MAAM,OAAO,uBAAwB,SAAQ,KAAK;IACvC,aAAa,CAAqB;IAE3C,YAAY,OAAe,EAAE,UAAuD,EAAE;QACpF,mEAAmE;QACnE,oEAAoE;QACpE,mEAAmE;QACnE,KAAK,CAAC,OAAO,EAAE,OAAO,CAAC,KAAK,KAAK,SAAS,CAAC,CAAC,CAAC,SAAS,CAAC,CAAC,CAAC,EAAE,KAAK,EAAE,OAAO,CAAC,KAAK,EAAE,CAAC,CAAC;QACnF,IAAI,CAAC,IAAI,GAAG,yBAAyB,CAAC;QACtC,IAAI,CAAC,aAAa,GAAG,OAAO,CAAC,aAAa,CAAC;IAC7C,CAAC;CACF;AAWD;;;;;;;;;GASG;AACH,MAAM,OAAO,qBAAsB,SAAQ,KAAK;IACrC,IAAI,CAAS;IACb,SAAS,CAAS;IAClB,gBAAgB,CAAS;IAElC,YAAY,QAAkC;QAC5C,KAAK,CAAC,yBAAyB,CAAC,QAAQ,CAAC,CAAC,CAAC;QAC3C,IAAI,CAAC,IAAI,GAAG,uBAAuB,CAAC;QACpC,IAAI,CAAC,IAAI,GAAG,QAAQ,CAAC,IAAI,CAAC;QAC1B,IAAI,CAAC,SAAS,GAAG,QAAQ,CAAC,SAAS,CAAC;QACpC,IAAI,CAAC,gBAAgB,GAAG,QAAQ,CAAC,gBAAgB,CAAC;IACpD,CAAC;CACF;AAED,SAAS,yBAAyB,CAAC,QAAkC;IACnE,OAAO;QACL,wGAAwG;QACxG,EAAE;QACF,qBAAqB,QAAQ,CAAC,IAAI,EAAE;QACpC,sBAAsB,QAAQ,CAAC,SAAS,EAAE;QAC1C,sBAAsB,QAAQ,CAAC,gBAAgB,EAAE;QACjD,EAAE;QACF,gCAAgC;QAChC,yDAAyD;QACzD,EAAE;QACF,gBAAgB,QAAQ,CAAC,IAAI,+CAA+C;QAC5E,mFAAmF;KACpF,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC;AACf,CAAC"}

package/dist/factory.d.ts

@@ -0,0 +1,47 @@
+import type { DataStoreOpenOptions, DrizzleDataStore } from './data-store.js';
+export declare const DataStoreFactory: {
+    /**
+     * Open a DataStore (SQLite or in-memory) and run pending migrations.
+     *
+     * For SQLite, a version guard runs first: if the file was stamped by a NEWER
+     * CLI than this one (`PRAGMA user_version` ahead of the bundled migration
+     * count), it throws {@link DataStoreVersionError} instead of letting Drizzle
+     * silently no-op into a runtime column error. After a successful migrate, the
+     * stamp is refreshed to this CLI's supported version.
+     *
+     * @throws {DataStoreVersionError} When the SQLite file was written by a newer
+     *   opensip-cli than this CLI supports (the downgrade direction).
+     * @throws {DataStoreMigrationError} When the SQLite file cannot be opened
+     *   (corrupt header, missing parent directory, permission errors), when the
+     *   native `better-sqlite3` binding fails to load (an ABI mismatch — the file
+     *   is fine, the addon was built for a different Node.js version), or when
+     *   running the migrations folder fails. The original cause is preserved via
+     *   the `cause` field; the message distinguishes the binding case so callers
+     *   are not told to delete a healthy data store.
+     */
+    open(opts: DataStoreOpenOptions & {
+        migrationsFolder?: string;
+    }): DrizzleDataStore;
+};
+/**
+ * Detect a native-binding load failure: `better-sqlite3`'s compiled addon was
+ * built for a different Node.js ABI than the one now running (e.g. the binding
+ * was compiled under Node 22 and the CLI is run under Node 24). This is NOT a
+ * data problem — the SQLite file is intact and must not be deleted; the fix is
+ * to rebuild the native module for the current Node.js.
+ *
+ * Identified by the Node loader's `ERR_DLOPEN_FAILED` code or the
+ * `NODE_MODULE_VERSION` / "compiled against a different Node.js version" text,
+ * scanned across the whole `cause` chain (the error may be wrapped).
+ */
+export declare function isNativeBindingError(error: unknown): boolean;
+/**
+ * Build the user-facing message for a data-store open failure, choosing the
+ * remediation that matches the actual cause: a native-binding ABI mismatch
+ * (rebuild the addon — the data is fine) vs a genuine corrupt/permission/
+ * non-writable SQLite file (delete to start fresh) vs an in-memory programming
+ * error. Separated from the throw site so the cause→message mapping is unit
+ * testable without exercising the real binding.
+ */
+export declare function openFailureMessage(opts: DataStoreOpenOptions, error: unknown): string;
+//# sourceMappingURL=factory.d.ts.map

package/dist/factory.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"factory.d.ts","sourceRoot":"","sources":["../src/factory.ts"],"names":[],"mappings":"AAWA,OAAO,KAAK,EAAE,oBAAoB,EAAE,gBAAgB,EAAE,MAAM,iBAAiB,CAAC;AAM9E,eAAO,MAAM,gBAAgB;IAC3B;;;;;;;;;;;;;;;;;;OAkBG;eACQ,oBAAoB,GAAG;QAAE,gBAAgB,CAAC,EAAE,MAAM,CAAA;KAAE,GAAG,gBAAgB;CAwCnF,CAAC;AA8BF;;;;;;;;;;GAUG;AACH,wBAAgB,oBAAoB,CAAC,KAAK,EAAE,OAAO,GAAG,OAAO,CAU5D;AAED;;;;;;;GAOG;AACH,wBAAgB,kBAAkB,CAAC,IAAI,EAAE,oBAAoB,EAAE,KAAK,EAAE,OAAO,GAAG,MAAM,CAWrF"}

package/dist/factory.js

@@ -0,0 +1,151 @@
+import { join } from 'node:path';
+import { fileURLToPath } from 'node:url';
+import { ConfigurationError } from '@opensip-cli/core';
+import { migrate } from 'drizzle-orm/better-sqlite3/migrator';
+import { openMemoryBackend } from './backends/memory.js';
+import { openSqliteBackend } from './backends/sqlite.js';
+import { DataStoreMigrationError, DataStoreVersionError } from './data-store.js';
+import { isDbNewerThanCli, readSupportedDbVersion } from './schema-version.js';
+function defaultMigrationsFolder() {
+    return join(fileURLToPath(new URL('.', import.meta.url)), '..', 'migrations');
+}
+export const DataStoreFactory = {
+    /**
+     * Open a DataStore (SQLite or in-memory) and run pending migrations.
+     *
+     * For SQLite, a version guard runs first: if the file was stamped by a NEWER
+     * CLI than this one (`PRAGMA user_version` ahead of the bundled migration
+     * count), it throws {@link DataStoreVersionError} instead of letting Drizzle
+     * silently no-op into a runtime column error. After a successful migrate, the
+     * stamp is refreshed to this CLI's supported version.
+     *
+     * @throws {DataStoreVersionError} When the SQLite file was written by a newer
+     *   opensip-cli than this CLI supports (the downgrade direction).
+     * @throws {DataStoreMigrationError} When the SQLite file cannot be opened
+     *   (corrupt header, missing parent directory, permission errors), when the
+     *   native `better-sqlite3` binding fails to load (an ABI mismatch — the file
+     *   is fine, the addon was built for a different Node.js version), or when
+     *   running the migrations folder fails. The original cause is preserved via
+     *   the `cause` field; the message distinguishes the binding case so callers
+     *   are not told to delete a healthy data store.
+     */
+    open(opts) {
+        const migrationsFolder = opts.migrationsFolder ?? defaultMigrationsFolder();
+        if (opts.backend === 'memory') {
+            return openAndMigrate(opts, migrationsFolder, () => openMemoryBackend());
+        }
+        const path = requireSqlitePath(opts);
+        let handle;
+        try {
+            handle = openSqliteBackend({ path });
+        }
+        catch (error) {
+            // Corrupted file (bad SQLite header), missing dir, permission errors, or a
+            // native-binding ABI mismatch (better-sqlite3 built for another Node.js).
+            throw new DataStoreMigrationError(openFailureMessage(opts, error), { cause: error });
+        }
+        // `undefined` (unreadable journal) means "skip the guard" — migrate() reads
+        // the same journal and will surface the canonical failure loudly.
+        const supportedVersion = readSupportedDbVersion(migrationsFolder);
+        if (supportedVersion !== undefined) {
+            const dbVersion = handle.readUserVersion();
+            if (isDbNewerThanCli(dbVersion, supportedVersion)) {
+                handle.close();
+                throw new DataStoreVersionError({ path, dbVersion, supportedVersion });
+            }
+        }
+        try {
+            migrate(handle.db, { migrationsFolder });
+        }
+        catch (error) {
+            handle.close();
+            throw new DataStoreMigrationError(migrateFailureMessage(opts), { cause: error });
+        }
+        // Re-stamp on every successful open: a fresh (0) or pre-guard "legacy" DB
+        // gets adopted to the current version; an already-current DB is a no-op write.
+        if (supportedVersion !== undefined)
+            handle.writeUserVersion(supportedVersion);
+        return handle;
+    },
+};
+/**
+ * Open a backend and run migrations, mapping both failures to
+ * {@link DataStoreMigrationError}. Used for the in-memory path (which needs no
+ * version guard — it is ephemeral) and shared message handling.
+ *
+ * @throws {DataStoreMigrationError} When the backend cannot be opened or the
+ *   migrations folder fails to apply; the original cause is preserved.
+ */
+function openAndMigrate(opts, migrationsFolder, openBackend) {
+    let datastore;
+    try {
+        datastore = openBackend();
+    }
+    catch (error) {
+        throw new DataStoreMigrationError(openFailureMessage(opts, error), { cause: error });
+    }
+    try {
+        migrate(datastore.db, { migrationsFolder });
+    }
+    catch (error) {
+        datastore.close();
+        throw new DataStoreMigrationError(migrateFailureMessage(opts), { cause: error });
+    }
+    return datastore;
+}
+/**
+ * Detect a native-binding load failure: `better-sqlite3`'s compiled addon was
+ * built for a different Node.js ABI than the one now running (e.g. the binding
+ * was compiled under Node 22 and the CLI is run under Node 24). This is NOT a
+ * data problem — the SQLite file is intact and must not be deleted; the fix is
+ * to rebuild the native module for the current Node.js.
+ *
+ * Identified by the Node loader's `ERR_DLOPEN_FAILED` code or the
+ * `NODE_MODULE_VERSION` / "compiled against a different Node.js version" text,
+ * scanned across the whole `cause` chain (the error may be wrapped).
+ */
+export function isNativeBindingError(error) {
+    for (let current = error; current instanceof Error; current = current.cause) {
+        if (current.code === 'ERR_DLOPEN_FAILED')
+            return true;
+        if (/NODE_MODULE_VERSION|compiled against a different Node\.js version/i.test(current.message)) {
+            return true;
+        }
+    }
+    return false;
+}
+/**
+ * Build the user-facing message for a data-store open failure, choosing the
+ * remediation that matches the actual cause: a native-binding ABI mismatch
+ * (rebuild the addon — the data is fine) vs a genuine corrupt/permission/
+ * non-writable SQLite file (delete to start fresh) vs an in-memory programming
+ * error. Separated from the throw site so the cause→message mapping is unit
+ * testable without exercising the real binding.
+ */
+export function openFailureMessage(opts, error) {
+    // A native-binding ABI mismatch is not a corrupt/missing file — telling the
+    // user to delete the data store would destroy healthy session history for no
+    // reason. Steer them to rebuild the addon instead, regardless of backend.
+    if (isNativeBindingError(error)) {
+        return `Failed to load the native SQLite module (better-sqlite3): its compiled binding was built for a different Node.js version than the one now running. Your data store is NOT corrupt — do not delete it. Rebuild the native module for your current Node.js with \`pnpm rebuild better-sqlite3\`, and run opensip on the Node.js version this project targets (see \`.nvmrc\` / the package.json \`engines\` field).`;
+    }
+    if (opts.backend === 'sqlite' && opts.path) {
+        return `Failed to open SQLite data store at \`${opts.path}\` — the file may be corrupted, missing permissions, or in a non-writable directory. Delete \`${opts.path}\` to start fresh (cache will rebuild on next run; session history will be lost).`;
+    }
+    return 'Failed to open in-memory data store; this is likely a programming error.';
+}
+function migrateFailureMessage(opts) {
+    if (opts.backend === 'sqlite' && opts.path) {
+        return `Schema migration failed against \`${opts.path}\`; the local cache may be from an incompatible version. Delete \`${opts.path}\` to start fresh (cache will rebuild on next run; session history will be lost).`;
+    }
+    return 'Schema migration failed against the in-memory backend; this is likely a programming error.';
+}
+function requireSqlitePath(opts) {
+    if (!opts.path) {
+        throw new ConfigurationError('DataStoreFactory.open: SQLite backend requires a `path` option', {
+            code: 'CONFIGURATION.DATASTORE.MISSING_PATH',
+        });
+    }
+    return opts.path;
+}
+//# sourceMappingURL=factory.js.map

package/dist/factory.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"factory.js","sourceRoot":"","sources":["../src/factory.ts"],"names":[],"mappings":"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"}

package/dist/index.d.ts

@@ -0,0 +1,10 @@
+export type { DataStore, DataStoreOpenOptions, DataStoreVersionMismatch, DrizzleDataStore, DrizzleHandle, SqliteBackendHandle, } from './data-store.js';
+export { DataStoreMigrationError, DataStoreVersionError, isDrizzleDataStore, requireDrizzleDataStore, } from './data-store.js';
+export { DataStoreFactory } from './factory.js';
+export { isDbNewerThanCli, readSupportedDbVersion } from './schema-version.js';
+export { toolBaselineEntries, toolBaselineMeta } from './schema/baseline.js';
+export { BaselineRepo } from './baseline-repo.js';
+export { toolState } from './schema/tool-state.js';
+export { ToolStateRepo, TOOL_STATE_MAX_PAYLOAD_BYTES } from './tool-state-repo.js';
+export type { BaselineEntry, BaselineRow } from './baseline-repo.js';
+//# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,YAAY,EACV,SAAS,EACT,oBAAoB,EACpB,wBAAwB,EACxB,gBAAgB,EAChB,aAAa,EACb,mBAAmB,GACpB,MAAM,iBAAiB,CAAC;AACzB,OAAO,EACL,uBAAuB,EACvB,qBAAqB,EACrB,kBAAkB,EAClB,uBAAuB,GACxB,MAAM,iBAAiB,CAAC;AACzB,OAAO,EAAE,gBAAgB,EAAE,MAAM,cAAc,CAAC;AAChD,OAAO,EAAE,gBAAgB,EAAE,sBAAsB,EAAE,MAAM,qBAAqB,CAAC;AAG/E,OAAO,EAAE,mBAAmB,EAAE,gBAAgB,EAAE,MAAM,sBAAsB,CAAC;AAC7E,OAAO,EAAE,YAAY,EAAE,MAAM,oBAAoB,CAAC;AAElD,OAAO,EAAE,SAAS,EAAE,MAAM,wBAAwB,CAAC;AACnD,OAAO,EAAE,aAAa,EAAE,4BAA4B,EAAE,MAAM,sBAAsB,CAAC;AACnF,YAAY,EAAE,aAAa,EAAE,WAAW,EAAE,MAAM,oBAAoB,CAAC"}

package/dist/index.js

@@ -0,0 +1,11 @@
+export { DataStoreMigrationError, DataStoreVersionError, isDrizzleDataStore, requireDrizzleDataStore, } from './data-store.js';
+export { DataStoreFactory } from './factory.js';
+export { isDbNewerThanCli, readSupportedDbVersion } from './schema-version.js';
+// Generic host-owned baseline/ratchet plane (ADR-0036): the shared table pair
+// + the per-tool repo over them.
+export { toolBaselineEntries, toolBaselineMeta } from './schema/baseline.js';
+export { BaselineRepo } from './baseline-repo.js';
+// ADR-0042: the generic keyed tool-state table + repo (the cli.toolState seams).
+export { toolState } from './schema/tool-state.js';
+export { ToolStateRepo, TOOL_STATE_MAX_PAYLOAD_BYTES } from './tool-state-repo.js';
+//# sourceMappingURL=index.js.map

package/dist/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAQA,OAAO,EACL,uBAAuB,EACvB,qBAAqB,EACrB,kBAAkB,EAClB,uBAAuB,GACxB,MAAM,iBAAiB,CAAC;AACzB,OAAO,EAAE,gBAAgB,EAAE,MAAM,cAAc,CAAC;AAChD,OAAO,EAAE,gBAAgB,EAAE,sBAAsB,EAAE,MAAM,qBAAqB,CAAC;AAC/E,8EAA8E;AAC9E,iCAAiC;AACjC,OAAO,EAAE,mBAAmB,EAAE,gBAAgB,EAAE,MAAM,sBAAsB,CAAC;AAC7E,OAAO,EAAE,YAAY,EAAE,MAAM,oBAAoB,CAAC;AAClD,iFAAiF;AACjF,OAAO,EAAE,SAAS,EAAE,MAAM,wBAAwB,CAAC;AACnD,OAAO,EAAE,aAAa,EAAE,4BAA4B,EAAE,MAAM,sBAAsB,CAAC"}

package/dist/schema/baseline.d.ts

@@ -0,0 +1,178 @@
+/**
+ * Generic host-owned baseline entries (ADR-0036). ONE table pair replaces the
+ * per-tool baseline tables (`graph_baseline_signals`, `fit_baseline`, …): each
+ * row is one finding's fingerprint + its full `Signal` payload, scoped by the
+ * `tool` column so tools share the table but never see each other's rows.
+ *
+ * The composite primary key `(tool, fingerprint)` makes save a per-tool
+ * delete-all + bulk-insert (atomic replace), and the `payload` column supplies
+ * the full-object `resolved` diff bucket AND the SARIF re-render
+ * (synthetic envelope → `formatSignalSarif`).
+ */
+export declare const toolBaselineEntries: import("drizzle-orm/sqlite-core").SQLiteTableWithColumns<{
+    name: "tool_baseline_entries";
+    schema: undefined;
+    columns: {
+        tool: import("drizzle-orm/sqlite-core").SQLiteColumn<{
+            name: "tool";
+            tableName: "tool_baseline_entries";
+            dataType: "string";
+            columnType: "SQLiteText";
+            data: string;
+            driverParam: string;
+            notNull: true;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: [string, ...string[]];
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {
+            length: number | undefined;
+        }>;
+        stableId: import("drizzle-orm/sqlite-core").SQLiteColumn<{
+            name: "stable_id";
+            tableName: "tool_baseline_entries";
+            dataType: "string";
+            columnType: "SQLiteText";
+            data: string;
+            driverParam: string;
+            notNull: false;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: [string, ...string[]];
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {
+            length: number | undefined;
+        }>;
+        fingerprint: import("drizzle-orm/sqlite-core").SQLiteColumn<{
+            name: "fingerprint";
+            tableName: "tool_baseline_entries";
+            dataType: "string";
+            columnType: "SQLiteText";
+            data: string;
+            driverParam: string;
+            notNull: true;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: [string, ...string[]];
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {
+            length: number | undefined;
+        }>;
+        payload: import("drizzle-orm/sqlite-core").SQLiteColumn<{
+            name: "payload";
+            tableName: "tool_baseline_entries";
+            dataType: "json";
+            columnType: "SQLiteTextJson";
+            data: unknown;
+            driverParam: string;
+            notNull: false;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        capturedAt: import("drizzle-orm/sqlite-core").SQLiteColumn<{
+            name: "captured_at";
+            tableName: "tool_baseline_entries";
+            dataType: "number";
+            columnType: "SQLiteInteger";
+            data: number;
+            driverParam: number;
+            notNull: true;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+    };
+    dialect: "sqlite";
+}>;
+/**
+ * Per-tool baseline existence marker + capture timestamp (ADR-0036). Keyed by
+ * `tool`, separate from the entries so an empty-but-saved baseline (a clean
+ * codebase) still reports `exists() === true` — distinguishing "saved, no
+ * findings" from "never saved". `capturedAt` feeds the JSON export's timestamp.
+ */
+export declare const toolBaselineMeta: import("drizzle-orm/sqlite-core").SQLiteTableWithColumns<{
+    name: "tool_baseline_meta";
+    schema: undefined;
+    columns: {
+        tool: import("drizzle-orm/sqlite-core").SQLiteColumn<{
+            name: "tool";
+            tableName: "tool_baseline_meta";
+            dataType: "string";
+            columnType: "SQLiteText";
+            data: string;
+            driverParam: string;
+            notNull: true;
+            hasDefault: false;
+            isPrimaryKey: true;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: [string, ...string[]];
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {
+            length: number | undefined;
+        }>;
+        stableId: import("drizzle-orm/sqlite-core").SQLiteColumn<{
+            name: "stable_id";
+            tableName: "tool_baseline_meta";
+            dataType: "string";
+            columnType: "SQLiteText";
+            data: string;
+            driverParam: string;
+            notNull: false;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: [string, ...string[]];
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {
+            length: number | undefined;
+        }>;
+        capturedAt: import("drizzle-orm/sqlite-core").SQLiteColumn<{
+            name: "captured_at";
+            tableName: "tool_baseline_meta";
+            dataType: "number";
+            columnType: "SQLiteInteger";
+            data: number;
+            driverParam: number;
+            notNull: true;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+    };
+    dialect: "sqlite";
+}>;
+//# sourceMappingURL=baseline.d.ts.map

package/dist/schema/baseline.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"baseline.d.ts","sourceRoot":"","sources":["../../src/schema/baseline.ts"],"names":[],"mappings":"AAEA;;;;;;;;;;GAUG;AACH,eAAO,MAAM,mBAAmB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAU/B,CAAC;AAEF;;;;;GAKG;AACH,eAAO,MAAM,gBAAgB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAI3B,CAAC"}

package/dist/schema/baseline.js

@@ -0,0 +1,31 @@
+import { integer, primaryKey, sqliteTable, text } from 'drizzle-orm/sqlite-core';
+/**
+ * Generic host-owned baseline entries (ADR-0036). ONE table pair replaces the
+ * per-tool baseline tables (`graph_baseline_signals`, `fit_baseline`, …): each
+ * row is one finding's fingerprint + its full `Signal` payload, scoped by the
+ * `tool` column so tools share the table but never see each other's rows.
+ *
+ * The composite primary key `(tool, fingerprint)` makes save a per-tool
+ * delete-all + bulk-insert (atomic replace), and the `payload` column supplies
+ * the full-object `resolved` diff bucket AND the SARIF re-render
+ * (synthetic envelope → `formatSignalSarif`).
+ */
+export const toolBaselineEntries = sqliteTable('tool_baseline_entries', {
+    tool: text('tool').notNull(), // human `name` value (for compat + current queries)
+    stableId: text('stable_id'), // tool stable UUID (additive per ADR-0048; null for legacy rows)
+    fingerprint: text('fingerprint').notNull(),
+    payload: text('payload', { mode: 'json' }), // the Signal as JSON
+    capturedAt: integer('captured_at').notNull(),
+}, (t) => [primaryKey({ columns: [t.tool, t.fingerprint] })]);
+/**
+ * Per-tool baseline existence marker + capture timestamp (ADR-0036). Keyed by
+ * `tool`, separate from the entries so an empty-but-saved baseline (a clean
+ * codebase) still reports `exists() === true` — distinguishing "saved, no
+ * findings" from "never saved". `capturedAt` feeds the JSON export's timestamp.
+ */
+export const toolBaselineMeta = sqliteTable('tool_baseline_meta', {
+    tool: text('tool').primaryKey(), // human `name` value (for compat)
+    stableId: text('stable_id'), // tool stable UUID (additive)
+    capturedAt: integer('captured_at').notNull(),
+});
+//# sourceMappingURL=baseline.js.map

package/dist/schema/baseline.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"baseline.js","sourceRoot":"","sources":["../../src/schema/baseline.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,OAAO,EAAE,UAAU,EAAE,WAAW,EAAE,IAAI,EAAE,MAAM,yBAAyB,CAAC;AAEjF;;;;;;;;;;GAUG;AACH,MAAM,CAAC,MAAM,mBAAmB,GAAG,WAAW,CAC5C,uBAAuB,EACvB;IACE,IAAI,EAAE,IAAI,CAAC,MAAM,CAAC,CAAC,OAAO,EAAE,EAAE,oDAAoD;IAClF,QAAQ,EAAE,IAAI,CAAC,WAAW,CAAC,EAAE,iEAAiE;IAC9F,WAAW,EAAE,IAAI,CAAC,aAAa,CAAC,CAAC,OAAO,EAAE;IAC1C,OAAO,EAAE,IAAI,CAAC,SAAS,EAAE,EAAE,IAAI,EAAE,MAAM,EAAE,CAAC,EAAE,qBAAqB;IACjE,UAAU,EAAE,OAAO,CAAC,aAAa,CAAC,CAAC,OAAO,EAAE;CAC7C,EACD,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,UAAU,CAAC,EAAE,OAAO,EAAE,CAAC,CAAC,CAAC,IAAI,EAAE,CAAC,CAAC,WAAW,CAAC,EAAE,CAAC,CAAC,CAC1D,CAAC;AAEF;;;;;GAKG;AACH,MAAM,CAAC,MAAM,gBAAgB,GAAG,WAAW,CAAC,oBAAoB,EAAE;IAChE,IAAI,EAAE,IAAI,CAAC,MAAM,CAAC,CAAC,UAAU,EAAE,EAAE,kCAAkC;IACnE,QAAQ,EAAE,IAAI,CAAC,WAAW,CAAC,EAAE,8BAA8B;IAC3D,UAAU,EAAE,OAAO,CAAC,aAAa,CAAC,CAAC,OAAO,EAAE;CAC7C,CAAC,CAAC"}