@creative-introvert/tons-of-tests 2.1.0 → 3.0.0-rc.1

package/dist/esm/internal/Test.repository.sqlite.js

@@ -1,387 +1,517 @@
-import * as SqlClient from 'effect/sql/SqlClient';
-import { Array as A, Console, Effect, Option, Schema, SchemaTransformation, Stream } from 'effect';
-import { TestRepository } from '../Test.repository.js';
-import { TestRun } from '../Test.repository.types.js';
-export { TestRepository };
-import { RepositoryDecodeError, RepositoryQueryError, RepositoryWriteError, TestRunNotCreated } from '../RepositoryError.js';
+import * as Sqlite from '@effect/sql-sqlite-node';
+import { Array as A, Context, Crypto, Effect, Exit, FileSystem, Layer, Option, Path, Ref, Schema, Scope, Semaphore, Stream, TxReentrantLock } from 'effect';
+import { SqlClient } from 'effect/sql';
+import { TestRun } from '../TestRun.js';
+import { RepositoryPathConflict, TestRunDuplicate, TestRunIncomplete, TestRunNotCreated, TestRunNotFound } from '../RepositoryError.js';
 import { LabelSchema } from './Classify.js';
-import { split } from './lib/Schema.js';
-export const tables = {
-  testResults: 'test-results',
-  testRuns: 'test-runs',
-  testRunResults: 'test-run-results'
-};
-const TestResultWriteSchema = /*#__PURE__*/Schema.Struct({
+import { checkFormat, initializeSchema, tables } from './test-repository-schema.js';
+import { withStats } from './test-result-stats.js';
+import { makeResultCodec, stringifyJson } from './Test.serialization.js';
+export { tables } from './test-repository-schema.js';
+export class TestRepositoryStorage extends /*#__PURE__*/Context.Service()('@creative-introvert/tons-of-tests/internal/TestRepositoryStorage') {}
+export const TestResultStorage = /*#__PURE__*/Schema.Struct({
   id: Schema.String,
   hashTestCase: Schema.String,
   key: Schema.String,
-  ordering: Schema.Int,
-  resultOrdering: Schema.Int,
-  input: /*#__PURE__*/Schema.fromJsonString(Schema.Unknown),
-  result: /*#__PURE__*/Schema.fromJsonString(Schema.Unknown),
-  expected: /*#__PURE__*/Schema.fromJsonString(Schema.Unknown),
-  label: LabelSchema,
-  tags: /*#__PURE__*/split(','),
-  timeMillis: Schema.Finite
+  input: /*#__PURE__*/Schema.fromJsonString(Schema.Json),
+  result: /*#__PURE__*/Schema.fromJsonString(Schema.Json),
+  expected: /*#__PURE__*/Schema.fromJsonString(Schema.Json),
+  label: LabelSchema
 });
-const TestResultsSchema = /*#__PURE__*/Schema.Array(TestResultWriteSchema);
-const CountSchema = /*#__PURE__*/Schema.Tuple([Schema.Struct({
-  count: Schema.Int
-})]).pipe(/*#__PURE__*/Schema.decodeTo(Schema.Int, /*#__PURE__*/SchemaTransformation.transform({
-  decode: ([{
-    count
-  }]) => count,
-  encode: count => [{
-    count
-  }]
-})));
-const TestRunsReadSchema = /*#__PURE__*/Schema.Array(TestRun);
-const TestRunResultsSchema = /*#__PURE__*/Schema.Array(/*#__PURE__*/Schema.Struct({
-  testRun: Schema.Int,
-  testResult: Schema.String,
+const StoredResult = /*#__PURE__*/Schema.Struct({
+  ...TestResultStorage.fields,
+  input: Schema.String,
+  result: Schema.String,
+  expected: Schema.String,
   ordering: Schema.Int,
   resultOrdering: Schema.Int,
+  tags: /*#__PURE__*/Schema.fromJsonString(/*#__PURE__*/Schema.Array(Schema.String)),
   timeMillis: Schema.Finite
+});
+const RawResult = /*#__PURE__*/StoredResult.mapFields(fields => ({
+  ...fields,
+  tags: Schema.String
 }));
-const TableColumnsSchema = /*#__PURE__*/Schema.Array(/*#__PURE__*/Schema.Struct({
-  name: Schema.String
-}));
-export const makeTestRepository = /*#__PURE__*/Effect.gen(function* () {
-  const sql = yield* SqlClient.SqlClient;
-  yield* sql`PRAGMA auto_vacuum = FULL;`;
-  yield* sql.withTransaction(Effect.gen(function* () {
-    yield* sql`
-        CREATE TABLE IF NOT EXISTS ${sql(tables.testRuns)}(
-            id INTEGER PRIMARY KEY AUTOINCREMENT,
-            name TEXT NOT NULL,
-            hash TEXT
-        );
-    `;
-    yield* sql`CREATE INDEX IF NOT EXISTS idx_name_hash ON ${sql(tables.testRuns)}(name, hash)`;
-    // At most one "current" (hash IS NULL) row per suite name. Partial index
-    // so committed rows are unaffected.
-    yield* sql`
-        CREATE UNIQUE INDEX IF NOT EXISTS idx_current_per_name
-        ON ${sql(tables.testRuns)}(name)
-        WHERE hash IS NULL;
-    `;
-    yield* sql`
-        CREATE TABLE IF NOT EXISTS ${sql(tables.testResults)}(
-            id TEXT PRIMARY KEY,
-            hashTestCase TEXT NOT NULL,
-            key TEXT NOT NULL DEFAULT 'result',
-            ordering INTEGER NOT NULL,
-            resultOrdering INTEGER NOT NULL DEFAULT 0,
-            input TEXT,
-            result TEXT,
-            expected TEXT,
-            label TEXT NOT NULL,
-            tags TEXT NOT NULL,
-            timeMillis INTEGER NOT NULL
-        );
-    `;
-    yield* sql`
-        CREATE TABLE IF NOT EXISTS ${sql(tables.testRunResults)}(
-            testRun INTEGER NOT NULL,
-            testResult TEXT NOT NULL,
-            ordering INTEGER NOT NULL,
-            resultOrdering INTEGER NOT NULL,
-            timeMillis INTEGER NOT NULL,
-            FOREIGN KEY (testRun) REFERENCES ${sql(tables.testRuns)}(id),
-            FOREIGN KEY (testResult) REFERENCES ${sql(tables.testResults)}(id),
-            UNIQUE (testRun, testResult)
-        );
-    `;
-    const resultColumns = yield* Schema.decodeUnknownEffect(TableColumnsSchema)(yield* sql`PRAGMA table_info(${sql(tables.testResults)});`).pipe(Effect.mapError(RepositoryDecodeError.from('migrateTestResults')));
-    if (!resultColumns.some(column => column.name === 'key')) {
-      yield* sql`
-            ALTER TABLE ${sql(tables.testResults)}
-            ADD COLUMN key TEXT NOT NULL DEFAULT 'result';
-        `;
-    }
-    if (!resultColumns.some(column => column.name === 'resultOrdering')) {
-      yield* sql`
-            ALTER TABLE ${sql(tables.testResults)}
-            ADD COLUMN resultOrdering INTEGER NOT NULL DEFAULT 0;
-        `;
+const StoredRun = /*#__PURE__*/Schema.Union([/*#__PURE__*/TestRun.members[0].pipe(/*#__PURE__*/Schema.fieldsAssign({
+  executionId: Schema.String
+})), /*#__PURE__*/TestRun.members[1].pipe(/*#__PURE__*/Schema.fieldsAssign({
+  executionId: Schema.String
+}))]);
+const encodeResult = /*#__PURE__*/Schema.encodeEffect(StoredResult);
+const decodeRows = /*#__PURE__*/Schema.decodeUnknownEffect(/*#__PURE__*/Schema.Array(StoredResult));
+const decodeRawRows = /*#__PURE__*/Schema.decodeUnknownEffect(/*#__PURE__*/Schema.Array(RawResult));
+const decodeRuns = /*#__PURE__*/Schema.decodeUnknownEffect(/*#__PURE__*/Schema.Array(TestRun));
+const decodeStoredRuns = /*#__PURE__*/Schema.decodeUnknownEffect(/*#__PURE__*/Schema.Array(StoredRun));
+const decodeListedRuns = /*#__PURE__*/Schema.decodeUnknownEffect(/*#__PURE__*/Schema.Array(/*#__PURE__*/TestRun.members[1].pipe(/*#__PURE__*/Schema.fieldsAssign({
+  isBaseline: /*#__PURE__*/Schema.Literals([0, 1])
+}))));
+const decodeVariantBaselines = /*#__PURE__*/Schema.decodeUnknownEffect(/*#__PURE__*/Schema.Array(/*#__PURE__*/Schema.Struct({
+  variant: Schema.String,
+  id: /*#__PURE__*/Schema.NullOr(Schema.Int),
+  name: /*#__PURE__*/Schema.NullOr(Schema.String),
+  state: /*#__PURE__*/Schema.NullOr(/*#__PURE__*/Schema.Literal('Complete'))
+})));
+const decodeRunLimit = /*#__PURE__*/Schema.decodeUnknownEffect(/*#__PURE__*/Schema.Int.check(/*#__PURE__*/Schema.isBetween({
+  minimum: 1,
+  maximum: 100
+})));
+const openClient = options => Layer.build(Sqlite.SqliteClient.layer(options)).pipe(Effect.map(Context.get(SqlClient.SqlClient)));
+export const makeTestRepository = /*#__PURE__*/Effect.fnUntraced(function* (options) {
+  const fs = yield* FileSystem.FileSystem;
+  const path = yield* Path.Path;
+  const crypto = yield* Crypto.Crypto;
+  const lifetime = yield* Effect.scope;
+  const memoryLock = yield* TxReentrantLock.make();
+  const snapshotLock = yield* Semaphore.make(1);
+  const snapshotMemory = yield* Ref.make(Option.none());
+  const canonicalPath = filename => fs.realPath(filename).pipe(Effect.catchTag('PlatformError', error => {
+    if (error.reason._tag !== 'NotFound') return Effect.fail(error);
+    const parent = path.dirname(filename);
+    if (parent === filename) return Effect.fail(error);
+    return Effect.gen(function* () {
+      const link = yield* fs.readLink(filename).pipe(Effect.asSome, Effect.catchReason('PlatformError', 'NotFound', () => Effect.succeedNone));
+      return Option.isSome(link) ? yield* canonicalPath(path.resolve(parent, link.value)) : path.join(yield* canonicalPath(parent), path.basename(filename));
+    });
+  }));
+  if (options.dbPath !== ':memory:' && options.cachePath !== ':memory:') {
+    const [snapshotFile, cacheFile] = yield* Effect.all([canonicalPath(options.dbPath), canonicalPath(options.cachePath)]);
+    const [snapshotInfo, cacheInfo] = yield* Effect.forEach([snapshotFile, cacheFile], filename => fs.stat(filename).pipe(Effect.asSome, Effect.catchReason('PlatformError', 'NotFound', () => Effect.succeedNone)));
+    const sameInode = Option.isSome(snapshotInfo) && Option.isSome(cacheInfo) && snapshotInfo.value.dev === cacheInfo.value.dev && Option.isSome(snapshotInfo.value.ino) && Option.isSome(cacheInfo.value.ino) && snapshotInfo.value.ino.value === cacheInfo.value.ino.value;
+    if (snapshotFile === cacheFile || sameInode) {
+      return yield* new RepositoryPathConflict({
+        snapshotPath: options.dbPath,
+        cachePath: options.cachePath
+      });
     }
-    const runResultColumns = yield* Schema.decodeUnknownEffect(TableColumnsSchema)(yield* sql`PRAGMA table_info(${sql(tables.testRunResults)});`).pipe(Effect.mapError(RepositoryDecodeError.from('migrateTestRunResults')));
-    for (const column of ['ordering', 'resultOrdering', 'timeMillis']) {
-      if (runResultColumns.some(existing => existing.name === column)) {
-        continue;
+  }
+  let initializeCache = options.cachePath === ':memory:';
+  if (options.cachePath !== ':memory:') {
+    yield* fs.makeDirectory(path.dirname(options.cachePath), {
+      recursive: true
+    });
+    initializeCache = !(yield* fs.exists(options.cachePath));
+    if (!initializeCache) {
+      const compatible = yield* Effect.scoped(Effect.gen(function* () {
+        const sql = yield* openClient({
+          filename: options.cachePath,
+          readonly: true,
+          disableWAL: true
+        });
+        yield* checkFormat(sql, 'cache', options.cachePath);
+        return true;
+      })).pipe(Effect.catchTag('RepositoryFormatError', () => Effect.succeed(false)));
+      if (!compatible) {
+        for (const suffix of ['', '-wal', '-shm']) {
+          yield* fs.remove(`${options.cachePath}${suffix}`, {
+            force: true
+          });
+        }
+        initializeCache = true;
       }
-      yield* sql`
-            ALTER TABLE ${sql(tables.testRunResults)}
-            ADD COLUMN ${sql(column)} INTEGER NOT NULL DEFAULT 0;
-        `;
-      yield* sql`
-            UPDATE ${sql(tables.testRunResults)} AS runres
-            SET ${sql(column)} = (
-                SELECT ${sql(column)} FROM ${sql(tables.testResults)} res
-                WHERE res.id = runres.testResult
-            );
-        `;
     }
-    // Lookup by the junction's `testResult` column: the existing
-    // UNIQUE(testRun, testResult) index is keyed on testRun first, so orphan
-    // cleanup (`... NOT IN (SELECT testResult ...)`) and stream joins
-    // (`res.id = runres.testResult`) would otherwise full-scan the junction.
-    yield* sql`CREATE INDEX IF NOT EXISTS idx_trr_testresult ON ${sql(tables.testRunResults)}(testResult)`;
-    yield* sql`CREATE INDEX IF NOT EXISTS idx_tr_hashtestcase ON ${sql(tables.testResults)}(hashTestCase)`;
+  }
+  const cache = yield* openClient({
+    filename: options.cachePath
+  });
+  yield* cache`PRAGMA foreign_keys = ON;`;
+  if (initializeCache) yield* initializeSchema(cache, 'cache', options.cachePath);
+  const getMemorySnapshot = snapshotLock.withPermit(Effect.gen(function* () {
+    const existing = yield* Ref.get(snapshotMemory);
+    if (Option.isSome(existing)) return existing.value;
+    const sql = yield* Scope.provide(openClient({
+      filename: ':memory:',
+      disableWAL: true
+    }), lifetime);
+    yield* sql`PRAGMA foreign_keys = ON;`;
+    yield* initializeSchema(sql, 'snapshot', ':memory:');
+    yield* Ref.set(snapshotMemory, Option.some(sql));
+    return sql;
   }));
-  // With 11 result columns and 5 junction columns, batches of 50 rows stay below
-  // SQLite's lowest default limit of 999 bound values per statement.
-  const INSERT_BATCH_SIZE = 50;
-  const insertTestResults = (testResults, testRun) => sql.withTransaction(Effect.gen(function* () {
-    if (testResults.length === 0) return;
-    const encoded = yield* Effect.forEach(testResults, _ => Schema.encodeEffect(TestResultWriteSchema)(_).pipe(Effect.mapError(RepositoryDecodeError.from('insertTestResults'))));
-    for (let i = 0; i < encoded.length; i += INSERT_BATCH_SIZE) {
-      const chunk = encoded.slice(i, i + INSERT_BATCH_SIZE);
-      yield* sql`
-                        INSERT INTO ${sql(tables.testResults)}
-                        ${sql.insert(chunk)}
-                        ON CONFLICT(id) DO NOTHING;
-                    `.pipe(Effect.mapError(RepositoryWriteError.from('insertTestResults')));
-    }
-    // Junction rows reference the resolved testRun.id directly,
-    // so no correlated subquery.
-    const junction = encoded.map(_ => ({
-      testRun: testRun.id,
-      testResult: _.id,
-      ordering: _.ordering,
-      resultOrdering: _.resultOrdering,
-      timeMillis: _.timeMillis
-    }));
-    for (let i = 0; i < junction.length; i += INSERT_BATCH_SIZE) {
-      const chunk = junction.slice(i, i + INSERT_BATCH_SIZE);
-      yield* sql`
-                        INSERT INTO ${sql(tables.testRunResults)}
-                        ${sql.insert(chunk)}
-                        ON CONFLICT(testRun, testResult) DO UPDATE SET
-                            ordering = excluded.ordering,
-                            resultOrdering = excluded.resultOrdering,
-                            timeMillis = excluded.timeMillis;
-                    `.pipe(Effect.mapError(RepositoryWriteError.from('insertTestResults')));
+  const snapshotReader = Effect.gen(function* () {
+    if (options.dbPath === ':memory:') return yield* Ref.get(snapshotMemory);
+    if (!(yield* fs.exists(options.dbPath))) return Option.none();
+    const sql = yield* openClient({
+      filename: options.dbPath,
+      readonly: true,
+      disableWAL: true
+    });
+    yield* checkFormat(sql, 'snapshot', options.dbPath);
+    return Option.some(sql);
+  });
+  const withSnapshot = (empty, use) => Effect.scoped(Effect.gen(function* () {
+    const sql = yield* snapshotReader;
+    return Option.isSome(sql) ? yield* use(sql.value) : empty;
+  }));
+  const cacheReader = Effect.gen(function* () {
+    if (options.cachePath === ':memory:') {
+      // A memory store has one connection. Block writes to attempts while
+      // readers page through them; temporary statistics remain writable.
+      yield* TxReentrantLock.readLock(memoryLock);
+      return cache;
     }
-  })).pipe(Effect.catchTag('SqlError', e => Effect.fail(RepositoryWriteError.from('insertTestResults')(e))));
-  const insertTestResult = (testResult, testRun) => insertTestResults([testResult], testRun);
-  const makeTestResultSchema = schemas => {
-    const input = schemas?.input ?? Schema.Unknown;
-    const result = schemas?.result ?? Schema.Unknown;
-    const expected = schemas?.expected ?? Schema.Unknown;
-    return Schema.Struct({
-      id: Schema.String,
-      hashTestCase: Schema.String,
-      key: Schema.String,
-      ordering: Schema.Int,
-      resultOrdering: Schema.Int,
-      input: Schema.fromJsonString(input),
-      result: Schema.fromJsonString(result),
-      expected: Schema.fromJsonString(expected),
-      label: LabelSchema,
-      tags: split(','),
-      timeMillis: Schema.Finite
+    const sql = yield* openClient({
+      filename: options.cachePath,
+      readonly: true,
+      disableWAL: true
     });
-  };
-  const getTestResultsStream = (testRun, schemas) => {
-    const RowSchema = makeTestResultSchema(schemas);
-    const RowsSchema = Schema.Array(RowSchema);
-    // The SQLite driver returns rows in one batch. Decode that batch once
-    // before exposing it as a stream.
-    return Stream.unwrap(Effect.gen(function* () {
-      const rows = yield* sql`
-                    SELECT res.id, res.hashTestCase, res.key,
-                        runres.ordering, runres.resultOrdering,
-                        res.input, res.result, res.expected, res.label, res.tags,
-                        runres.timeMillis
-                    FROM ${sql(tables.testResults)} res
-                    JOIN ${sql(tables.testRunResults)} runres ON res.id = runres.testResult
-                    JOIN ${sql(tables.testRuns)} runs ON runs.id = runres.testRun
-                    WHERE runs.id = ${testRun.id}
-                    ORDER BY runres.ordering ASC, runres.resultOrdering ASC;
-                `.pipe(Effect.mapError(RepositoryQueryError.fromSql('getTestResultsStream')));
-      const decoded = yield* Schema.decodeUnknownEffect(RowsSchema)(rows).pipe(Effect.mapError(RepositoryDecodeError.from('getTestResultsStream')));
-      return Stream.fromIterable(decoded);
-    }));
-  };
-  const hasResults = Effect.fnUntraced(function* (testRun) {
-    const b = yield* sql`
-                SELECT COUNT(*) count FROM ${sql(tables.testRunResults)}
-                WHERE testRun = ${testRun.id};
-            `.pipe(Effect.mapError(RepositoryQueryError.fromSql('hasResults')));
-    const r = yield* Schema.decodeUnknownEffect(CountSchema)(b).pipe(Effect.mapError(RepositoryDecodeError.from('hasResults')));
-    return r > 0;
+    // Keep the selected rows stable until the scoped connection closes,
+    // including when reading is interrupted.
+    yield* sql`BEGIN;`;
+    return sql;
   });
-  const getPreviousTestRun = Effect.fnUntraced(function* (name) {
-    const r = yield* sql`
-                SELECT * FROM ${sql(tables.testRuns)}
-                WHERE hash IS NOT NULL AND name = ${name}
-                ORDER BY id DESC
-                LIMIT 1;
-            `.pipe(Effect.mapError(RepositoryQueryError.fromSql('getPreviousTestRun')));
-    const p = yield* Schema.decodeUnknownEffect(TestRunsReadSchema)(r).pipe(Effect.mapError(RepositoryDecodeError.from('getPreviousTestRun')));
-    return A.head(p);
+  const writeCache = effect => options.cachePath === ':memory:' ? TxReentrantLock.withWriteLock(memoryLock, cache.withTransaction(effect)) : cache.withTransaction(effect);
+  const readRun = Effect.fnUntraced(function* (sql, run) {
+    return A.head(yield* decodeRuns(yield* sql`
+            SELECT *, ${run.store} AS store FROM ${sql(tables.testRuns)}
+            WHERE id = ${run.id}
+                AND ${run.store === 'cache' ? sql`snapshotIdentity = ${options.snapshotIdentity}` : sql`1 = 1`};
+        `));
   });
-  const getAllTestRuns = Effect.gen(function* () {
-    const results = yield* sql`
-            SELECT * from ${sql(tables.testRuns)};
-        `.pipe(Effect.mapError(RepositoryQueryError.fromSql('getAllTestRuns')));
-    return yield* Schema.decodeUnknownEffect(TestRunsReadSchema)(results).pipe(Effect.mapError(RepositoryDecodeError.from('getAllTestRuns')));
+  const getTestRun = run => run.store === 'cache' ? readRun(cache, run) : withSnapshot(Option.none(), sql => readRun(sql, run));
+  const requireRun = Effect.fnUntraced(function* (sql, run) {
+    const found = yield* readRun(sql, run);
+    if (Option.isNone(found) || found.value.name !== run.name || found.value.variant !== run.variant) {
+      return yield* new TestRunNotFound({
+        testRunId: run.id
+      });
+    }
+    return found.value;
   });
-  const getAllTestRunResults = Effect.gen(function* () {
-    const results = yield* sql`
-            SELECT * from ${sql(tables.testRunResults)};
-        `.pipe(Effect.mapError(RepositoryQueryError.fromSql('getAllTestRunResults')));
-    return yield* Schema.decodeUnknownEffect(TestRunResultsSchema)(results).pipe(Effect.mapError(RepositoryDecodeError.from('getAllTestRunResults')));
+  const writeRows = Effect.fnUntraced(function* (sql, runId, rows) {
+    if (rows.length === 0) return;
+    yield* sql`
+            INSERT INTO ${sql(tables.testResults)} ${sql.insert(rows.map(row => ({
+      id: row.id,
+      hashTestCase: row.hashTestCase,
+      key: row.key,
+      input: row.input,
+      result: row.result,
+      expected: row.expected,
+      label: row.label
+    })))} ON CONFLICT(id) DO NOTHING;
+        `;
+    yield* sql`
+            INSERT INTO ${sql(tables.testRunResults)} ${sql.insert(rows.map(row => ({
+      testRun: runId,
+      testResult: row.id,
+      ordering: row.ordering,
+      resultOrdering: row.resultOrdering,
+      timeMillis: row.timeMillis,
+      tags: row.tags
+    })))} ON CONFLICT(testRun, testResult) DO UPDATE SET
+                ordering = excluded.ordering, resultOrdering = excluded.resultOrdering,
+                timeMillis = excluded.timeMillis, tags = excluded.tags;
+        `;
   });
-  const getAllTestResults = Effect.gen(function* () {
-    const results = yield* sql`
-            SELECT * from ${sql(tables.testResults)};
-        `.pipe(Effect.mapError(RepositoryQueryError.fromSql('getAllTestResults')));
-    return yield* Schema.decodeUnknownEffect(TestResultsSchema)(results).pipe(Effect.mapError(RepositoryDecodeError.from('getAllTestResults')));
+  const insertTestResults = Effect.fnUntraced(function* (results, run, schemas) {
+    if (run.store !== 'cache') {
+      return yield* Effect.die(new Error('Only cached Running attempts accept result writes.'));
+    }
+    const codec = makeResultCodec(schemas, run.name);
+    // Fifty rows keep every statement below SQLite's 999-parameter minimum.
+    for (let offset = 0; offset < Math.max(1, results.length); offset += 50) {
+      const encoded = yield* Effect.forEach(results.slice(offset, offset + 50), Effect.fnUntraced(function* (result) {
+        const encoded = yield* codec.encode(result);
+        return yield* encodeResult({
+          ...encoded,
+          input: stringifyJson(encoded.input),
+          result: stringifyJson(encoded.result),
+          expected: stringifyJson(encoded.expected)
+        });
+      }));
+      yield* writeCache(Effect.gen(function* () {
+        const saved = yield* requireRun(cache, run);
+        if (saved.state !== 'Running') {
+          return yield* Effect.die(new Error('Only Running test runs accept result writes.'));
+        }
+        yield* writeRows(cache, run.id, encoded);
+      }));
+    }
   });
-  const getLastTestRunHash = Effect.fnUntraced(function* (name) {
-    const rows = yield* sql`
-            SELECT *
-            FROM ${sql(tables.testRuns)}
-            WHERE hash IS NOT NULL AND name = ${name}
-            ORDER BY id DESC
-            LIMIT 1;
-        `.pipe(Effect.mapError(RepositoryQueryError.fromSql('getLastTestRunHash')));
-    const runs = yield* Schema.decodeUnknownEffect(TestRunsReadSchema)(rows).pipe(Effect.mapError(RepositoryDecodeError.from('getLastTestRunHash')));
-    return A.head(runs).pipe(Option.flatMap(run => Option.fromNullishOr(run.hash)));
+  const readResultPage = (sql, runId, after, matching, limit = 100) => {
+    const filter = matching === undefined ? sql`1 = 1` : matching.length === 0 ? sql`1 = 0` : sql.or(matching.map(key => sql`res.hashTestCase = ${key.hashTestCase} AND res.key = ${key.key}`));
+    // CROSS JOIN makes matching batches use the case/key index first.
+    const from = matching === undefined ? sql`${sql(tables.testRunResults)} runres JOIN ${sql(tables.testResults)} res ON res.id = runres.testResult` : sql`${sql(tables.testResults)} res CROSS JOIN ${sql(tables.testRunResults)} runres ON res.id = runres.testResult`;
+    return sql`
+            SELECT res.id, res.hashTestCase, res.key, runres.ordering, runres.resultOrdering,
+                res.input, res.result, res.expected, res.label, runres.tags, runres.timeMillis
+            FROM ${from}
+            WHERE runres.testRun = ${runId} AND ${filter}
+                AND ${after === undefined ? sql`1 = 1` : sql`
+                    (runres.ordering, runres.resultOrdering, runres.testResult) >
+                    (${after.ordering}, ${after.resultOrdering}, ${after.id})`}
+            ORDER BY runres.ordering, runres.resultOrdering, runres.testResult LIMIT ${limit};
+        `;
+  };
+  const getTestResultsStream = (run, schemas, matching) => {
+    if (matching !== undefined && matching.length > 50) return Stream.die(new Error('Match at most 50 case/key pairs per query.'));
+    const codec = makeResultCodec(schemas, run.name);
+    return Stream.unwrap(Effect.gen(function* () {
+      const selected = run.store === 'cache' ? Option.some(yield* cacheReader) : yield* snapshotReader;
+      if (Option.isNone(selected)) return yield* new TestRunNotFound({
+        testRunId: run.id
+      });
+      const sql = selected.value;
+      yield* requireRun(sql, run);
+      return Stream.paginate(undefined, Effect.fnUntraced(function* (after) {
+        const rows = yield* decodeRows(yield* readResultPage(sql, run.id, after, matching));
+        const decoded = yield* Effect.forEach(rows, codec.decode);
+        return [decoded, rows.length < 100 ? Option.none() : Option.some(rows[rows.length - 1])];
+      }));
+    }));
+  };
+  const getLatestTestRun = Effect.fnUntraced(function* ({
+    name,
+    variant
+  }) {
+    return A.head(yield* decodeRuns(yield* cache`
+            SELECT *, 'cache' AS store FROM ${cache(tables.testRuns)}
+            WHERE snapshotIdentity = ${options.snapshotIdentity} AND name = ${name} AND variant = ${variant}
+            ORDER BY id DESC LIMIT 1;
+        `));
   });
-  const getOrCreateCurrentTestRun = name => sql.withTransaction(Effect.gen(function* () {
-    const currentRaw = yield* sql`
-                    SELECT *
-                    FROM ${sql(tables.testRuns)}
-                    WHERE hash IS NULL AND name = ${name}
-                    ORDER BY id DESC
-                    LIMIT 1;
-                `.pipe(Effect.mapError(RepositoryQueryError.fromSql('getOrCreateCurrentTestRun')));
-    const current = yield* Schema.decodeUnknownEffect(TestRunsReadSchema)(currentRaw).pipe(Effect.mapError(RepositoryDecodeError.from('getOrCreateCurrentTestRun')));
-    const existing = A.head(current);
-    if (Option.isSome(existing)) {
-      return existing.value;
-    }
-    const insertedRaw = yield* sql`
-                    INSERT INTO ${sql(tables.testRuns)}
-                    ${sql.insert({
-      name
-    })}
-                    RETURNING *;
-                `.pipe(Effect.mapError(RepositoryWriteError.from('getOrCreateCurrentTestRun')));
-    const inserted = yield* Schema.decodeUnknownEffect(TestRunsReadSchema)(insertedRaw).pipe(Effect.mapError(RepositoryDecodeError.from('getOrCreateCurrentTestRun')));
-    return yield* Effect.fromOption(A.head(inserted)).pipe(Effect.mapError(() => new TestRunNotCreated({
-      testSuiteName: name
-    })));
-  })).pipe(Effect.catchTag('SqlError', e => Effect.fail(RepositoryQueryError.fromSql('getOrCreateCurrentTestRun')(e))));
-  const clearStale = ({
+  const getBaselineTestRun = ({
     name,
-    keep = 1
-  }) => sql.withTransaction(Effect.gen(function* () {
-    const raw = yield* sql`
-                    SELECT *
-                    FROM ${sql(tables.testRuns)}
-                    WHERE hash IS NOT NULL AND name = ${name}
-                    ORDER BY id DESC
-                    LIMIT -1 OFFSET ${keep};
-                `.pipe(Effect.mapError(RepositoryQueryError.fromSql('clearStale')));
-    const staleTestRuns = yield* Schema.decodeUnknownEffect(TestRunsReadSchema)(raw).pipe(Effect.mapError(RepositoryDecodeError.from('clearStale')));
-    if (staleTestRuns.length === 0) {
-      return;
+    variant
+  }) => withSnapshot(Option.none(), Effect.fnUntraced(function* (sql) {
+    return A.head(yield* decodeRuns(yield* sql`
+                SELECT run.*, 'snapshot' AS store FROM ${sql(tables.testBaselines)} baseline
+                JOIN ${sql(tables.testRuns)} run ON run.id = baseline.testRun
+                WHERE baseline.name = ${name} AND baseline.variant = ${variant};
+            `));
+  }));
+  const createTestRun = Effect.fnUntraced(function* (input) {
+    const executionId = yield* crypto.randomUUIDv4();
+    return yield* writeCache(Effect.gen(function* () {
+      yield* cache`
+                DELETE FROM ${cache(tables.testRuns)}
+                WHERE snapshotIdentity = ${options.snapshotIdentity} AND name = ${input.name} AND variant = ${input.variant};
+            `;
+      yield* cache`
+                DELETE FROM ${cache(tables.testResults)} WHERE NOT EXISTS (
+                    SELECT 1 FROM ${cache(tables.testRunResults)} links WHERE links.testResult = ${cache(tables.testResults)}.id
+                );
+            `;
+      const inserted = yield* decodeRuns(yield* cache`
+                INSERT INTO ${cache(tables.testRuns)} ${cache.insert({
+        name: input.name,
+        variant: input.variant,
+        executionId,
+        snapshotIdentity: options.snapshotIdentity,
+        state: 'Running'
+      })}
+                RETURNING *, 'cache' AS store;
+            `);
+      return yield* Effect.fromOption(A.head(inserted)).pipe(Effect.mapError(() => new TestRunNotCreated({
+        testSuiteName: input.name
+      })));
+    }));
+  });
+  const finishTestRun = (run, state) => writeCache(Effect.gen(function* () {
+    const updated = yield* decodeRuns(yield* cache`
+            UPDATE ${cache(tables.testRuns)} SET state = ${state}
+            WHERE id = ${run.id} AND snapshotIdentity = ${options.snapshotIdentity} AND state = 'Running'
+            RETURNING *, 'cache' AS store;
+        `);
+    if (updated.length === 0) return yield* new TestRunNotFound({
+      testRunId: run.id
+    });
+  }));
+  const withTestRun = (input, execute) => Effect.acquireUseRelease(createTestRun(input), run => Effect.suspend(() => execute(run)).pipe(Effect.map(value => ({
+    run,
+    value
+  }))), (run, exit) => finishTestRun(run, Exit.isSuccess(exit) ? 'Complete' : 'Failed')).pipe(Effect.map(({
+    run,
+    value
+  }) => ({
+    run: TestRun.make({
+      ...run,
+      state: 'Complete'
+    }),
+    value
+  })));
+  const snapshotWriter = Effect.gen(function* () {
+    if (options.dbPath === ':memory:') return yield* getMemorySnapshot;
+    const exists = yield* fs.exists(options.dbPath);
+    if (exists) {
+      yield* Effect.scoped(Effect.gen(function* () {
+        const sql = yield* openClient({
+          filename: options.dbPath,
+          readonly: true,
+          disableWAL: true
+        });
+        yield* checkFormat(sql, 'snapshot', options.dbPath);
+      }));
+    } else {
+      yield* fs.makeDirectory(path.dirname(options.dbPath), {
+        recursive: true
+      });
     }
-    const ids = staleTestRuns.map(r => r.id);
-    yield* sql`
-                    DELETE FROM ${sql(tables.testRunResults)}
-                    WHERE testRun IN ${sql.in(ids)};
-                `.pipe(Effect.mapError(RepositoryWriteError.from('clearStale')));
-    yield* sql`
-                    DELETE FROM ${sql(tables.testRuns)}
-                    WHERE id IN ${sql.in(ids)};
-                `.pipe(Effect.mapError(RepositoryWriteError.from('clearStale')));
-    yield* sql`
-                    DELETE FROM ${sql(tables.testResults)}
-                    WHERE id NOT IN (
-                        SELECT DISTINCT testResult FROM ${sql(tables.testRunResults)}
-                    );
-                `.pipe(Effect.mapError(RepositoryWriteError.from('clearStale')));
-    yield* Console.log('Cleared stale test runs.');
-  })).pipe(Effect.catchTag('SqlError', e => Effect.fail(RepositoryWriteError.from('clearStale')(e))));
-  const clearUncommitedTestResults = ({
-    name
-  }) => sql.withTransaction(Effect.gen(function* () {
-    const currentRaw = yield* sql`
-                    SELECT *
-                    FROM ${sql(tables.testRuns)}
-                    WHERE hash IS NULL AND name = ${name}
-                    ORDER BY id DESC
-                    LIMIT 1;
-                `.pipe(Effect.mapError(RepositoryQueryError.fromSql('clearUncommitedTestResults')));
-    const current = yield* Schema.decodeUnknownEffect(TestRunsReadSchema)(currentRaw).pipe(Effect.mapError(RepositoryDecodeError.from('clearUncommitedTestResults')));
-    const currentTestRun = A.head(current);
-    if (Option.isNone(currentTestRun)) {
-      return;
+    const sql = yield* openClient({
+      filename: options.dbPath,
+      disableWAL: true
+    });
+    if (exists) yield* checkFormat(sql, 'snapshot', options.dbPath);else yield* initializeSchema(sql, 'snapshot', options.dbPath);
+    yield* sql`PRAGMA journal_mode = DELETE;`;
+    yield* sql`PRAGMA foreign_keys = ON;`;
+    return sql;
+  });
+  const commitTestRuns = runs => Effect.scoped(Effect.gen(function* () {
+    if (runs.length === 0) return [];
+    const selectedVariants = new Set();
+    for (const run of runs) {
+      const key = JSON.stringify([run.name, run.variant]);
+      if (selectedVariants.has(key)) return yield* new TestRunDuplicate({
+        testSuiteName: run.name,
+        variant: run.variant
+      });
+      selectedVariants.add(key);
     }
-    yield* sql`
-                    DELETE FROM ${sql(tables.testRunResults)}
-                    WHERE testRun = ${currentTestRun.value.id};
-                `.pipe(Effect.mapError(RepositoryWriteError.from('clearUncommitedTestResults')));
-    yield* sql`
-                    DELETE FROM ${sql(tables.testResults)}
-                    WHERE id NOT IN (
-                        SELECT DISTINCT testResult FROM ${sql(tables.testRunResults)}
-                    );
-                `.pipe(Effect.mapError(RepositoryWriteError.from('clearUncommitedTestResults')));
-  })).pipe(Effect.catchTag('SqlError', e => Effect.fail(RepositoryWriteError.from('clearUncommitedTestResults')(e))));
-  const commitCurrentTestRun = Effect.fnUntraced(function* ({
+    const reader = runs.some(run => run.store === 'cache') ? yield* cacheReader : undefined;
+    // Check every selected run before opening a writer, so a missing or
+    // incomplete attempt cannot create a snapshot file.
+    const selected = yield* Effect.forEach(runs, run => Effect.gen(function* () {
+      const saved = run.store === 'cache' && reader !== undefined ? yield* requireRun(reader, run) : yield* getTestRun(run).pipe(Effect.flatMap(Option.match({
+        onNone: () => Effect.fail(new TestRunNotFound({
+          testRunId: run.id
+        })),
+        onSome: Effect.succeed
+      })));
+      if (saved.name !== run.name || saved.variant !== run.variant) return yield* new TestRunNotFound({
+        testRunId: run.id
+      });
+      if (saved.state !== 'Complete') return yield* new TestRunIncomplete({
+        testSuiteName: saved.name,
+        testRunId: saved.id,
+        variant: saved.variant
+      });
+      if (saved.store === 'snapshot' || reader === undefined) return {
+        run: saved,
+        executionId: undefined
+      };
+      const stored = yield* decodeStoredRuns(yield* reader`
+                SELECT *, 'cache' AS store FROM ${reader(tables.testRuns)}
+                WHERE id = ${saved.id} AND snapshotIdentity = ${options.snapshotIdentity};
+            `);
+      return {
+        run: saved,
+        executionId: stored[0].executionId
+      };
+    }));
+    const sql = yield* snapshotWriter;
+    return yield* sql.withTransaction(Effect.forEach(selected, ({
+      run,
+      executionId
+    }) => Effect.gen(function* () {
+      let snapshot;
+      if (run.store === 'snapshot') {
+        snapshot = yield* requireRun(sql, run);
+      } else {
+        const existing = yield* decodeRuns(yield* sql`
+                    SELECT *, 'snapshot' AS store FROM ${sql(tables.testRuns)} WHERE executionId = ${executionId};
+                `);
+        if (existing.length > 0) {
+          snapshot = existing[0];
+        } else {
+          const inserted = yield* decodeRuns(yield* sql`
+                        INSERT INTO ${sql(tables.testRuns)} ${sql.insert({
+            name: run.name,
+            variant: run.variant,
+            executionId,
+            snapshotIdentity: options.snapshotIdentity,
+            state: 'Complete'
+          })} RETURNING *, 'snapshot' AS store;
+                    `);
+          snapshot = inserted[0];
+          let after;
+          if (reader !== undefined) {
+            while (true) {
+              const rows = yield* decodeRawRows(yield* readResultPage(reader, run.id, after, undefined, 50));
+              yield* writeRows(sql, snapshot.id, rows);
+              if (rows.length < 50) break;
+              after = rows[rows.length - 1];
+            }
+          }
+        }
+      }
+      yield* sql`
+                INSERT INTO ${sql(tables.testBaselines)} ${sql.insert({
+        name: snapshot.name,
+        variant: snapshot.variant,
+        testRun: snapshot.id
+      })}
+                ON CONFLICT(name, variant) DO UPDATE SET testRun = excluded.testRun;
+            `;
+      return snapshot;
+    })));
+  }));
+  const listTestRuns = Effect.fnUntraced(function* ({
     name,
-    hash
+    variant,
+    before,
+    limit
   }) {
-    const currentTestRunResults = yield* Schema.decodeUnknownEffect(CountSchema)(yield* sql`
-                    SELECT COUNT(*) count FROM ${sql(tables.testRunResults)}
-                    WHERE testRun = (
-                        SELECT id
-                        FROM ${sql(tables.testRuns)}
-                        WHERE hash IS NULL AND name = ${name}
-                    );
-                `.pipe(Effect.mapError(RepositoryQueryError.fromSql('commitCurrentTestRun')))).pipe(Effect.mapError(RepositoryDecodeError.from('commitCurrentTestRun')));
-    if (currentTestRunResults === 0) {
-      yield* Console.log('Current run has no test results, not commiting.');
-      return;
-    }
-    yield* sql`
-                UPDATE ${sql(tables.testRuns)}
-                SET hash = ${hash}
-                WHERE id = (
-                    SELECT id
-                    FROM ${sql(tables.testRuns)}
-                    WHERE hash IS NULL AND name = ${name}
-                );
-            `.pipe(Effect.mapError(RepositoryWriteError.from('commitCurrentTestRun')));
-    yield* sql`
-                INSERT INTO ${sql(tables.testRuns)}
-                ${sql.insert({
-      name
-    })};
-            `.pipe(Effect.mapError(RepositoryWriteError.from('commitCurrentTestRun')));
-    yield* Console.log('Commited test run.');
+    const parsedLimit = yield* decodeRunLimit(limit);
+    return yield* withSnapshot([], Effect.fnUntraced(function* (sql) {
+      const rows = yield* decodeListedRuns(yield* sql`
+                SELECT run.*, 'snapshot' AS store, EXISTS (
+                    SELECT 1 FROM ${sql(tables.testBaselines)} baseline
+                    WHERE baseline.name = run.name AND baseline.variant = run.variant AND baseline.testRun = run.id
+                ) AS isBaseline FROM ${sql(tables.testRuns)} run
+                WHERE run.name = ${name}
+                    AND ${variant === undefined ? sql`1 = 1` : sql`run.variant = ${variant}`}
+                    AND ${before === undefined ? sql`1 = 1` : sql`run.id < ${before}`}
+                ORDER BY run.id DESC LIMIT ${parsedLimit};
+            `);
+      return rows.map(({
+        isBaseline,
+        ...run
+      }) => ({
+        ...run,
+        isBaseline: isBaseline === 1
+      }));
+    }));
   });
-  const service = {
-    clearStale,
-    clearUncommitedTestResults,
-    commitCurrentTestRun,
-    getAllTestResults,
-    getAllTestRuns,
-    getOrCreateCurrentTestRun,
-    getLastTestRunHash,
-    getPreviousTestRun,
+  const listVariantBaselines = name => withSnapshot([], Effect.fnUntraced(function* (sql) {
+    const rows = yield* decodeVariantBaselines(yield* sql`
+            SELECT variants.variant, run.id, run.name, run.state FROM (
+                SELECT DISTINCT variant FROM ${sql(tables.testRuns)} WHERE name = ${name}
+            ) variants LEFT JOIN ${sql(tables.testBaselines)} baseline
+                ON baseline.name = ${name} AND baseline.variant = variants.variant
+            LEFT JOIN ${sql(tables.testRuns)} run ON run.id = baseline.testRun ORDER BY variants.variant;
+        `);
+    return rows.map(({
+      variant,
+      id,
+      name
+    }) => ({
+      variant,
+      baseline: id === null || name === null ? Option.none() : Option.some(TestRun.make({
+        id,
+        name,
+        variant,
+        store: 'snapshot',
+        state: 'Complete'
+      }))
+    }));
+  }));
+  const repository = {
+    commitTestRuns,
+    getTestRun,
+    getLatestTestRun,
+    getBaselineTestRun,
+    listTestRuns,
+    listVariantBaselines,
     getTestResultsStream,
-    hasResults,
-    insertTestResult,
-    insertTestResults,
-    getAllTestRunResults
+    withTestRun,
+    withStats: use => withStats(use).pipe(Effect.provideService(SqlClient.SqlClient, cache)),
+    insertTestResult: (result, run, schemas) => insertTestResults([result], run, schemas),
+    insertTestResults
+  };
+  return {
+    repository,
+    cache,
+    snapshot: getMemorySnapshot
   };
-  return service;
 });
 //# sourceMappingURL=Test.repository.sqlite.js.map