@nomix-ai/nomix-harness 0.2.6 → 0.2.7

package/dist/kernel/session-persistence-sqlite/lib/types/store.d.ts

@@ -1,66 +0,0 @@
-/**
- * SQLite storage primitives: transactional append-batch packing, physical
- * reads, schema validation, revisions, repair, and lifecycle closure.
- * @module @nomix-ai/nomix-session-persistence-sqlite/store
- */
-import { type SessionEvent, type SessionHeader, type SessionId } from '../../../session/lib/index.js';
-import { type PersistenceBackend, type SessionPersistenceRevision as PersistenceRevision, type SessionPersistenceSnapshot, type StoredPrefix, type StoredSuffix } from '../../../session-persistence/lib/index.js';
-import { type JournalMode } from './schema.ts';
-/** Storage options resolved by the service provider. */
-export interface SqliteStoreOptions {
-    readonly path: string;
-    readonly journalMode: JournalMode;
-    readonly busyTimeoutMs: number;
-}
-/** SQLite implementation of the coordinator's physical backend hooks. */
-export declare class SqliteStore implements PersistenceBackend<number> {
-    private readonly options;
-    readonly name = "session-persistence-sqlite";
-    private db;
-    private databaseConstructor;
-    private storeIdentity;
-    private databasePath;
-    private opened;
-    private pathReady;
-    private ready;
-    constructor(options: SqliteStoreOptions);
-    /**
-     * Validate filesystem ownership without importing or opening Node SQLite.
-     * @returns settlement of the store's one path-validation operation.
-     */
-    validatePath(): Promise<void>;
-    /**
-     * Lazily open and validate the database on first persistence use.
-     * @returns settlement of the store's one database-open operation.
-     */
-    open(): Promise<void>;
-    private preparePath;
-    private openDb;
-    loadStored(id: SessionId, signal?: AbortSignal): Promise<StoredPrefix<number> | undefined>;
-    readStoredRevision(id: SessionId, signal?: AbortSignal): Promise<PersistenceRevision | undefined>;
-    loadStoredFrom(id: SessionId, fromSeq: number, signal?: AbortSignal): Promise<StoredSuffix | undefined>;
-    appendBatch(meta: SessionHeader, events: readonly SessionEvent[], isMaterialized: boolean): Promise<void>;
-    commitRepair(meta: SessionHeader, tornMarker: number | undefined, closers: readonly SessionEvent[]): Promise<void>;
-    list(signal?: AbortSignal): Promise<SessionHeader[]>;
-    /**
-     * Return every materialized header with its source-qualified revision.
-     * @param signal - optional cancellation before or after the metadata query.
-     * @returns stored headers and revisions without loading event rows.
-     */
-    listSnapshots(signal?: AbortSignal): Promise<SessionPersistenceSnapshot[]>;
-    close(): Promise<void>;
-    private rowFor;
-    private observe;
-    private readTransaction;
-    private sessionRows;
-    private rollback;
-    private incrementRevision;
-    private tailRows;
-    /** Select the bounded physical span that may represent `fromSeq`. */
-    private physicalSpanFrom;
-    private logicalLastEvent;
-    private insertStatement;
-    private insertRecord;
-    private writeRow;
-}
-//# sourceMappingURL=store.d.ts.map

package/dist/kernel/session-persistence-sqlite/lib/types/store.js

@@ -1,394 +0,0 @@
-/**
- * SQLite storage primitives: transactional append-batch packing, physical
- * reads, schema validation, revisions, repair, and lifecycle closure.
- * @module @nomix-ai/nomix-session-persistence-sqlite/store
- */
-import { randomUUID } from 'node:crypto';
-import { statSync } from 'node:fs';
-import { lstat, mkdir, open } from 'node:fs/promises';
-import { dirname, resolve } from 'node:path';
-import { SessionPersistenceRevision, } from '../../../session-persistence/lib/index.js';
-import { MAX_PACKED_ROW_MEMBERS, packChunkRuns, } from "./codec.js";
-import { bindRecord, decodeRow, scanRows, } from "./compression.js";
-import { decodeEventRow, decodeSessionRow, decodeStoreIdentity, openDatabase, validateSchemaForMutation, rowToMeta, } from "./schema.js";
-import { sql } from "./sql.js";
-/** SQLite implementation of the coordinator's physical backend hooks. */
-export class SqliteStore {
-    options;
-    name = 'session-persistence-sqlite';
-    db;
-    databaseConstructor;
-    storeIdentity;
-    databasePath;
-    opened = false;
-    pathReady;
-    ready;
-    constructor(options) {
-        this.options = options;
-    }
-    /**
-     * Validate filesystem ownership without importing or opening Node SQLite.
-     * @returns settlement of the store's one path-validation operation.
-     */
-    validatePath() {
-        this.pathReady ??= this.preparePath(this.options.path);
-        return this.pathReady;
-    }
-    /**
-     * Lazily open and validate the database on first persistence use.
-     * @returns settlement of the store's one database-open operation.
-     */
-    open() {
-        this.ready ??= this.openDb();
-        return this.ready;
-    }
-    async preparePath(path) {
-        const actual = path === ':memory:' ? path : resolve(path);
-        if (actual !== ':memory:') {
-            await mkdir(dirname(actual), { recursive: true, mode: 0o700 });
-            await validateParentDirectory(dirname(actual));
-            await validateDatabaseFileIfPresent(actual);
-        }
-        this.databasePath = actual;
-    }
-    async openDb() {
-        await this.validatePath();
-        if (this.databasePath !== ':memory:') {
-            await createDatabaseFile(this.databasePath);
-            await validateDatabaseFile(this.databasePath);
-        }
-        const { DatabaseSync } = await loadNodeSqlite();
-        this.databaseConstructor = DatabaseSync;
-        this.db = await openDatabase(DatabaseSync, this.databasePath, this.options.journalMode, this.options.busyTimeoutMs);
-        try {
-            const row = this.db.prepare(sql('select-store-id')).get();
-            if (row === undefined) {
-                throw new Error(`session database at "${this.databasePath}" has no valid store identity`);
-            }
-            let storeId;
-            try {
-                storeId = decodeStoreIdentity(row);
-            }
-            catch (error) {
-                throw new Error(`session database at "${this.databasePath}" has no valid store identity`, { cause: error });
-            }
-            if (this.databasePath === ':memory:') {
-                this.storeIdentity = `memory:store:${storeId}`;
-            }
-            else {
-                const identity = statSync(this.databasePath, { bigint: true });
-                this.storeIdentity = `file:${identity.dev}:${identity.ino}:${identity.birthtimeNs}:store:${storeId}`;
-            }
-            this.opened = true;
-        }
-        catch (error) {
-            this.db.close();
-            throw error;
-        }
-    }
-    async loadStored(id, signal) {
-        await this.observe(signal);
-        const snapshot = this.readTransaction(() => {
-            const row = this.rowFor(id);
-            if (row === undefined)
-                return undefined;
-            const eventRows = this.db.prepare(sql('select-events')).all(id).map(decodeEventRow);
-            return { row, eventRows };
-        });
-        signal?.throwIfAborted();
-        if (snapshot === undefined)
-            return undefined;
-        const scanned = scanRows(snapshot.eventRows);
-        return {
-            meta: rowToMeta(snapshot.row),
-            events: scanned.preserved,
-            revision: sqliteRevision(this.storeIdentity, snapshot.row),
-            ...scanned.tornFrom === undefined ? {} : { tornMarker: scanned.tornFrom },
-        };
-    }
-    async readStoredRevision(id, signal) {
-        await this.observe(signal);
-        const row = this.rowFor(id);
-        signal?.throwIfAborted();
-        return row === undefined ? undefined : sqliteRevision(this.storeIdentity, row);
-    }
-    async loadStoredFrom(id, fromSeq, signal) {
-        await this.observe(signal);
-        const snapshot = this.readTransaction(() => {
-            const row = this.rowFor(id);
-            if (row === undefined)
-                return undefined;
-            return { row, ...this.physicalSpanFrom(id, fromSeq) };
-        });
-        signal?.throwIfAborted();
-        if (snapshot === undefined)
-            return undefined;
-        const { preserved } = scanRows(snapshot.eventRows, snapshot.base);
-        return { meta: rowToMeta(snapshot.row), events: preserved.filter(event => event.seq >= fromSeq) };
-    }
-    async appendBatch(meta, events, isMaterialized) {
-        await this.open();
-        if (events.length === 0)
-            return;
-        this.db.exec(sql('begin-immediate'));
-        try {
-            validateSchemaForMutation(this.databaseConstructor, this.db, this.databasePath);
-            const tailRows = this.tailRows(meta.id);
-            const currentLast = this.logicalLastEvent(meta.id, tailRows);
-            const expected = currentLast === undefined ? 0 : currentLast.seq + 1;
-            const first = events[0];
-            if (first.seq !== expected) {
-                throw new Error(`session ${meta.id} append starts at seq ${first.seq}, stored next seq is ${expected}`);
-            }
-            if (!isMaterialized)
-                this.writeRow(meta);
-            const insert = this.insertStatement();
-            for (const record of packChunkRuns(events))
-                this.insertRecord(insert, meta.id, bindRecord(record));
-            this.incrementRevision(meta.id);
-            this.db.exec(sql('commit'));
-        }
-        catch (error) {
-            this.rollback(error, 'append');
-        }
-    }
-    async commitRepair(meta, tornMarker, closers) {
-        await this.open();
-        if (tornMarker === undefined && closers.length === 0)
-            return;
-        this.db.exec(sql('begin-immediate'));
-        try {
-            validateSchemaForMutation(this.databaseConstructor, this.db, this.databasePath);
-            const row = this.rowFor(meta.id);
-            if (row === undefined)
-                throw new Error(`session ${meta.id} metadata row is missing`);
-            const currentRows = this.db.prepare(sql('select-events')).all(meta.id).map(decodeEventRow);
-            const current = scanRows(currentRows);
-            if (tornMarker !== undefined) {
-                if (current.tornFrom !== tornMarker) {
-                    throw new Error(`session ${meta.id} repair is stale: physical tail no longer starts at seq ${tornMarker}`);
-                }
-                this.db.prepare(sql('delete-events-from'))
-                    .run(meta.id, tornMarker);
-            }
-            else if (current.tornFrom !== undefined) {
-                throw new Error(`session ${meta.id} repair omitted current torn tail at seq ${current.tornFrom}`);
-            }
-            if (closers.length > 0) {
-                const expected = current.preserved.at(-1)?.seq === undefined
-                    ? 0
-                    : current.preserved.at(-1).seq + 1;
-                if (closers[0]?.seq !== expected) {
-                    throw new Error(`session ${meta.id} repair is stale: closer starts at seq ${closers[0]?.seq}, stored next seq is ${expected}`);
-                }
-                const insert = this.insertStatement();
-                for (const closer of closers)
-                    this.insertRecord(insert, meta.id, bindRecord(closer));
-            }
-            this.incrementRevision(meta.id);
-            this.db.exec(sql('commit'));
-        }
-        catch (error) {
-            this.rollback(error, 'repair');
-        }
-    }
-    async list(signal) {
-        await this.observe(signal);
-        const rows = this.sessionRows();
-        signal?.throwIfAborted();
-        return rows.map(rowToMeta);
-    }
-    /**
-     * Return every materialized header with its source-qualified revision.
-     * @param signal - optional cancellation before or after the metadata query.
-     * @returns stored headers and revisions without loading event rows.
-     */
-    async listSnapshots(signal) {
-        await this.observe(signal);
-        const rows = this.sessionRows();
-        signal?.throwIfAborted();
-        return rows.map(row => ({
-            header: rowToMeta(row),
-            revision: sqliteRevision(this.storeIdentity, row),
-        }));
-    }
-    async close() {
-        if (this.ready === undefined) {
-            if (this.pathReady !== undefined)
-                await Promise.allSettled([this.pathReady]);
-            return;
-        }
-        await Promise.allSettled([this.ready]);
-        if (!this.opened)
-            return;
-        this.opened = false;
-        this.db.close();
-    }
-    rowFor(id) {
-        const value = this.db.prepare(sql('select-session')).get(id);
-        return value === undefined ? undefined : decodeSessionRow(value);
-    }
-    async observe(signal) {
-        signal?.throwIfAborted();
-        await this.open();
-        signal?.throwIfAborted();
-    }
-    readTransaction(read) {
-        this.db.exec(sql('begin'));
-        try {
-            const value = read();
-            this.db.exec(sql('commit'));
-            return value;
-        }
-        catch (error) {
-            this.rollback(error, 'read');
-        }
-    }
-    sessionRows() {
-        return this.db.prepare(sql('select-sessions')).all().map(decodeSessionRow);
-    }
-    rollback(error, operation) {
-        try {
-            this.db.exec(sql('rollback'));
-        }
-        catch (rollbackError) {
-            /* v8 ignore next -- requires SQLite to fail both an operation and its immediate rollback. */
-            throw new AggregateError([error, rollbackError], `${this.name} ${operation} failed and rollback also failed`);
-        }
-        throw error;
-    }
-    incrementRevision(id) {
-        const updated = this.db.prepare(sql('update-session-revision'))
-            .run(id);
-        /* v8 ignore next -- materialized writes follow coordinator create(); other writes upsert in this transaction. */
-        if (Number(updated.changes) !== 1)
-            throw new Error(`session ${id} metadata row is missing`);
-    }
-    tailRows(id) {
-        const tail = this.db.prepare(sql('select-tail-events')).all(id, 2).map(decodeEventRow).reverse();
-        if (tail.length === 0)
-            return [];
-        return this.physicalSpanFrom(id, tail[0].seq).eventRows;
-    }
-    /** Select the bounded physical span that may represent `fromSeq`. */
-    physicalSpanFrom(id, fromSeq) {
-        const packedFloor = Math.max(0, fromSeq - MAX_PACKED_ROW_MEMBERS + 1);
-        const packedPredecessors = this.db.prepare(sql('select-packed-predecessors'))
-            .all(id, packedFloor, fromSeq)
-            .map(decodeEventRow);
-        let base = fromSeq;
-        for (const predecessor of packedPredecessors) {
-            try {
-                const last = decodeRow(predecessor).at(-1);
-                if (last !== undefined && last.seq >= fromSeq)
-                    base = Math.min(base, predecessor.seq);
-            }
-            catch {
-                // A malformed bounded predecessor may cover fromSeq; include it so the scanner fails closed.
-                base = Math.min(base, predecessor.seq);
-            }
-        }
-        const eventRows = this.db.prepare(sql('select-events-from')).all(id, base).map(decodeEventRow);
-        return { base, eventRows };
-    }
-    logicalLastEvent(id, tailRows) {
-        if (tailRows.length === 0)
-            return undefined;
-        const { preserved, tornFrom } = scanRows(tailRows, tailRows[0].seq);
-        if (tornFrom !== undefined)
-            throw new Error(`session ${id} has an invalid physical tail at seq ${tornFrom}`);
-        return preserved.at(-1);
-    }
-    insertStatement() {
-        return this.db.prepare(sql('insert-event'));
-    }
-    insertRecord(insert, id, record) {
-        insert.run(id, record.seq, record.type, record.time, record.data, record.sourceEventSeqs, record.surfaceOp, record.ignorable);
-    }
-    writeRow(meta) {
-        this.db.prepare(sql('upsert-session')).run(meta.id, meta.version, meta.createdAt, meta.cwd ?? null, meta.parentSession ?? null, meta.seedLength ?? null, meta.origin ?? null, meta.delegationDepth ?? null, meta.agentPreset ?? null, randomUUID());
-    }
-}
-function sqliteRevision(storeIdentity, row) {
-    return SessionPersistenceRevision(`${storeIdentity}:incarnation:${row.incarnation}:revision:${row.revision}`);
-}
-async function createDatabaseFile(path) {
-    try {
-        const handle = await open(path, 'wx', 0o600);
-        await handle.close();
-    }
-    catch (error) {
-        if (error.code !== 'EEXIST')
-            throw error;
-    }
-}
-async function validateParentDirectory(path) {
-    const parent = await lstat(path);
-    if (parent.isSymbolicLink() || !parent.isDirectory()) {
-        throw new Error(`session database parent "${path}" must be a real directory`);
-    }
-    const uid = process.getuid?.();
-    /* v8 ignore start -- Windows exposes neither process.getuid nor meaningful
-     * uid/mode bits; POSIX tests cover owner and mode rejection. */
-    if (uid !== undefined && (parent.uid !== uid || (parent.mode & 0o022) !== 0)) {
-        throw new Error(`session database parent "${path}" must be owned by the current user and not group/world-writable`);
-    }
-    /* v8 ignore stop */
-}
-async function validateDatabaseFile(path) {
-    const file = await lstat(path);
-    if (file.isSymbolicLink() || !file.isFile()) {
-        throw new Error(`session database "${path}" must be a regular file, not a symbolic link`);
-    }
-    const uid = process.getuid?.();
-    /* v8 ignore start -- Windows exposes neither process.getuid nor meaningful
-     * uid/mode bits; POSIX tests cover owner and mode rejection. */
-    if (uid !== undefined && (file.uid !== uid || (file.mode & 0o077) !== 0)) {
-        throw new Error(`session database "${path}" must be owned by the current user and accessible only by that user`);
-    }
-    /* v8 ignore stop */
-}
-async function validateDatabaseFileIfPresent(path) {
-    try {
-        await validateDatabaseFile(path);
-    }
-    catch (error) {
-        if (error.code !== 'ENOENT')
-            throw error;
-    }
-}
-let nodeSqlite;
-/** Load Node SQLite once so concurrent stores share one warning-filter lifetime. */
-function loadNodeSqlite() {
-    nodeSqlite ??= importNodeSqlite();
-    return nodeSqlite;
-}
-/** Import Node 22's SQLite dependency without its process-wide experimental warning. */
-async function importNodeSqlite() {
-    const emitWarning = Reflect.get(process, 'emitWarning');
-    /* v8 ignore start -- Node 22 alone emits this warning; primary coverage runs on Node 24. */
-    const filteredEmitWarning = (warning, ...args) => {
-        const message = warning instanceof Error ? warning.message : warning;
-        const first = args[0];
-        const type = warning instanceof Error
-            ? warning.name
-            : typeof first === 'string'
-                ? first
-                : typeof first === 'object' && first !== null && 'type' in first
-                    ? first.type
-                    : undefined;
-        if (message === 'SQLite is an experimental feature and might change at any time'
-            && type === 'ExperimentalWarning')
-            return;
-        Reflect.apply(emitWarning, process, [warning, ...args]);
-    };
-    Reflect.set(process, 'emitWarning', filteredEmitWarning);
-    try {
-        return await import('node:sqlite');
-    }
-    finally {
-        Reflect.set(process, 'emitWarning', emitWarning);
-    }
-    /* v8 ignore stop */
-}
-//# sourceMappingURL=store.js.map

package/dist/kernel/session-persistence-sqlite/package.json

@@ -1,55 +0,0 @@
-{
-  "name": "@nomix-ai/nomix-session-persistence-sqlite",
-  "description": "SQLite durable session persistence with physical chunk-row packing",
-  "version": "0.2.6",
-  "publishConfig": {
-    "access": "public"
-  },
-  "repository": {
-    "type": "git",
-    "url": "git+https://github.com/ditgaldev/nomix-harness.git",
-    "directory": "packages/session/session-persistence-sqlite"
-  },
-  "type": "module",
-  "main": "lib/index.js",
-  "types": "lib/types/index.d.ts",
-  "exports": {
-    ".": {
-      "types": "./lib/types/index.d.ts",
-      "default": "./lib/index.js"
-    },
-    "./invariant": {
-      "types": "./lib/types/invariant.d.ts",
-      "default": "./lib/invariant.js"
-    },
-    "./src/*": "./src/*",
-    "./package.json": "./package.json"
-  },
-  "files": [
-    "lib/index.js",
-    "lib/invariant.js",
-    "resources/sql/**/*.sql",
-    "lib/types/**/*.d.ts"
-  ],
-  "license": "MIT",
-  "peerDependencies": {
-    "@nomix-ai/nomix-invariants": "workspace:^",
-    "@nomix-ai/nomix-llm": "workspace:^",
-    "@nomix-ai/nomix-session": "workspace:^",
-    "@nomix-ai/nomix-session-persistence": "workspace:^",
-    "@nomix-ai/cordis": "workspace:^"
-  },
-  "dependencies": {
-    "@nomix-ai/schemastery": "workspace:^"
-  },
-  "devDependencies": {
-    "@nomix-ai/cordis-plugin-include": "workspace:^",
-    "@nomix-ai/cordis-plugin-loader": "workspace:^",
-    "@nomix-ai/nomix-invariants": "workspace:^",
-    "@nomix-ai/nomix-llm": "workspace:^",
-    "@nomix-ai/nomix-session": "workspace:^",
-    "@nomix-ai/nomix-session-persistence": "workspace:^",
-    "@nomix-ai/cordis": "workspace:^",
-    "typescript": "^6.0.3"
-  }
-}