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

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

@@ -3,398 +3,529 @@
 Object.defineProperty(exports, "__esModule", {
   value: true
 });
-Object.defineProperty(exports, "TestRepository", {
+exports.makeTestRepository = exports.TestResultStorage = exports.TestRepositoryStorage = void 0;
+Object.defineProperty(exports, "tables", {
   enumerable: true,
   get: function () {
-    return _TestRepository.TestRepository;
+    return _testRepositorySchema.tables;
   }
 });
-exports.tables = exports.makeTestRepository = void 0;
-var SqlClient = /*#__PURE__*/_interopRequireWildcard(/*#__PURE__*/require("effect/sql/SqlClient"));
+var Sqlite = /*#__PURE__*/_interopRequireWildcard(/*#__PURE__*/require("@effect/sql-sqlite-node"));
 var _effect = /*#__PURE__*/require("effect");
-var _TestRepository = /*#__PURE__*/require("../Test.repository.js");
-var _TestRepositoryTypes = /*#__PURE__*/require("../Test.repository.types.js");
+var _sql = /*#__PURE__*/require("effect/sql");
+var _TestRun = /*#__PURE__*/require("../TestRun.js");
 var _RepositoryError = /*#__PURE__*/require("../RepositoryError.js");
 var _Classify = /*#__PURE__*/require("./Classify.js");
-var _Schema = /*#__PURE__*/require("./lib/Schema.js");
+var _testRepositorySchema = /*#__PURE__*/require("./test-repository-schema.js");
+var _testResultStats = /*#__PURE__*/require("./test-result-stats.js");
+var _TestSerialization = /*#__PURE__*/require("./Test.serialization.js");
 var cache;
 function _interopRequireWildcard(e, t) { if (!t && e && e.__esModule) return e; var r, c, a = Object.defineProperty, n = { __proto__: null, default: e }; if (Object(e) !== e) return n; if (cache || "function" != typeof WeakMap || (cache = new WeakMap()), cache) { if (cache.has(e)) return cache.get(e); cache.set(e, n); } for (c in e) "default" !== c && {}.hasOwnProperty.call(e, c) && ((r = a && Object.getOwnPropertyDescriptor(e, c)) && (r.get || r.set) ? a(n, c, r) : n[c] = e[c]); return n; }
-const tables = exports.tables = {
-  testResults: 'test-results',
-  testRuns: 'test-runs',
-  testRunResults: 'test-run-results'
-};
-const TestResultWriteSchema = /*#__PURE__*/_effect.Schema.Struct({
+class TestRepositoryStorage extends /*#__PURE__*/_effect.Context.Service()('@creative-introvert/tons-of-tests/internal/TestRepositoryStorage') {}
+exports.TestRepositoryStorage = TestRepositoryStorage;
+const TestResultStorage = exports.TestResultStorage = /*#__PURE__*/_effect.Schema.Struct({
   id: _effect.Schema.String,
   hashTestCase: _effect.Schema.String,
   key: _effect.Schema.String,
-  ordering: _effect.Schema.Int,
-  resultOrdering: _effect.Schema.Int,
-  input: /*#__PURE__*/_effect.Schema.fromJsonString(_effect.Schema.Unknown),
-  result: /*#__PURE__*/_effect.Schema.fromJsonString(_effect.Schema.Unknown),
-  expected: /*#__PURE__*/_effect.Schema.fromJsonString(_effect.Schema.Unknown),
-  label: _Classify.LabelSchema,
-  tags: /*#__PURE__*/(0, _Schema.split)(','),
-  timeMillis: _effect.Schema.Finite
+  input: /*#__PURE__*/_effect.Schema.fromJsonString(_effect.Schema.Json),
+  result: /*#__PURE__*/_effect.Schema.fromJsonString(_effect.Schema.Json),
+  expected: /*#__PURE__*/_effect.Schema.fromJsonString(_effect.Schema.Json),
+  label: _Classify.LabelSchema
 });
-const TestResultsSchema = /*#__PURE__*/_effect.Schema.Array(TestResultWriteSchema);
-const CountSchema = /*#__PURE__*/_effect.Schema.Tuple([_effect.Schema.Struct({
-  count: _effect.Schema.Int
-})]).pipe(/*#__PURE__*/_effect.Schema.decodeTo(_effect.Schema.Int, /*#__PURE__*/_effect.SchemaTransformation.transform({
-  decode: ([{
-    count
-  }]) => count,
-  encode: count => [{
-    count
-  }]
-})));
-const TestRunsReadSchema = /*#__PURE__*/_effect.Schema.Array(_TestRepositoryTypes.TestRun);
-const TestRunResultsSchema = /*#__PURE__*/_effect.Schema.Array(/*#__PURE__*/_effect.Schema.Struct({
-  testRun: _effect.Schema.Int,
-  testResult: _effect.Schema.String,
+const StoredResult = /*#__PURE__*/_effect.Schema.Struct({
+  ...TestResultStorage.fields,
+  input: _effect.Schema.String,
+  result: _effect.Schema.String,
+  expected: _effect.Schema.String,
   ordering: _effect.Schema.Int,
   resultOrdering: _effect.Schema.Int,
+  tags: /*#__PURE__*/_effect.Schema.fromJsonString(/*#__PURE__*/_effect.Schema.Array(_effect.Schema.String)),
   timeMillis: _effect.Schema.Finite
+});
+const RawResult = /*#__PURE__*/StoredResult.mapFields(fields => ({
+  ...fields,
+  tags: _effect.Schema.String
 }));
-const TableColumnsSchema = /*#__PURE__*/_effect.Schema.Array(/*#__PURE__*/_effect.Schema.Struct({
-  name: _effect.Schema.String
-}));
-const makeTestRepository = exports.makeTestRepository = /*#__PURE__*/_effect.Effect.gen(function* () {
-  const sql = yield* SqlClient.SqlClient;
-  yield* sql`PRAGMA auto_vacuum = FULL;`;
-  yield* sql.withTransaction(_effect.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* _effect.Schema.decodeUnknownEffect(TableColumnsSchema)(yield* sql`PRAGMA table_info(${sql(tables.testResults)});`).pipe(_effect.Effect.mapError(_RepositoryError.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__*/_effect.Schema.Union([/*#__PURE__*/_TestRun.TestRun.members[0].pipe(/*#__PURE__*/_effect.Schema.fieldsAssign({
+  executionId: _effect.Schema.String
+})), /*#__PURE__*/_TestRun.TestRun.members[1].pipe(/*#__PURE__*/_effect.Schema.fieldsAssign({
+  executionId: _effect.Schema.String
+}))]);
+const encodeResult = /*#__PURE__*/_effect.Schema.encodeEffect(StoredResult);
+const decodeRows = /*#__PURE__*/_effect.Schema.decodeUnknownEffect(/*#__PURE__*/_effect.Schema.Array(StoredResult));
+const decodeRawRows = /*#__PURE__*/_effect.Schema.decodeUnknownEffect(/*#__PURE__*/_effect.Schema.Array(RawResult));
+const decodeRuns = /*#__PURE__*/_effect.Schema.decodeUnknownEffect(/*#__PURE__*/_effect.Schema.Array(_TestRun.TestRun));
+const decodeStoredRuns = /*#__PURE__*/_effect.Schema.decodeUnknownEffect(/*#__PURE__*/_effect.Schema.Array(StoredRun));
+const decodeListedRuns = /*#__PURE__*/_effect.Schema.decodeUnknownEffect(/*#__PURE__*/_effect.Schema.Array(/*#__PURE__*/_TestRun.TestRun.members[1].pipe(/*#__PURE__*/_effect.Schema.fieldsAssign({
+  isBaseline: /*#__PURE__*/_effect.Schema.Literals([0, 1])
+}))));
+const decodeVariantBaselines = /*#__PURE__*/_effect.Schema.decodeUnknownEffect(/*#__PURE__*/_effect.Schema.Array(/*#__PURE__*/_effect.Schema.Struct({
+  variant: _effect.Schema.String,
+  id: /*#__PURE__*/_effect.Schema.NullOr(_effect.Schema.Int),
+  name: /*#__PURE__*/_effect.Schema.NullOr(_effect.Schema.String),
+  state: /*#__PURE__*/_effect.Schema.NullOr(/*#__PURE__*/_effect.Schema.Literal('Complete'))
+})));
+const decodeRunLimit = /*#__PURE__*/_effect.Schema.decodeUnknownEffect(/*#__PURE__*/_effect.Schema.Int.check(/*#__PURE__*/_effect.Schema.isBetween({
+  minimum: 1,
+  maximum: 100
+})));
+const openClient = options => _effect.Layer.build(Sqlite.SqliteClient.layer(options)).pipe(_effect.Effect.map(_effect.Context.get(_sql.SqlClient.SqlClient)));
+const makeTestRepository = exports.makeTestRepository = /*#__PURE__*/_effect.Effect.fnUntraced(function* (options) {
+  const fs = yield* _effect.FileSystem.FileSystem;
+  const path = yield* _effect.Path.Path;
+  const crypto = yield* _effect.Crypto.Crypto;
+  const lifetime = yield* _effect.Effect.scope;
+  const memoryLock = yield* _effect.TxReentrantLock.make();
+  const snapshotLock = yield* _effect.Semaphore.make(1);
+  const snapshotMemory = yield* _effect.Ref.make(_effect.Option.none());
+  const canonicalPath = filename => fs.realPath(filename).pipe(_effect.Effect.catchTag('PlatformError', error => {
+    if (error.reason._tag !== 'NotFound') return _effect.Effect.fail(error);
+    const parent = path.dirname(filename);
+    if (parent === filename) return _effect.Effect.fail(error);
+    return _effect.Effect.gen(function* () {
+      const link = yield* fs.readLink(filename).pipe(_effect.Effect.asSome, _effect.Effect.catchReason('PlatformError', 'NotFound', () => _effect.Effect.succeedNone));
+      return _effect.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.Effect.all([canonicalPath(options.dbPath), canonicalPath(options.cachePath)]);
+    const [snapshotInfo, cacheInfo] = yield* _effect.Effect.forEach([snapshotFile, cacheFile], filename => fs.stat(filename).pipe(_effect.Effect.asSome, _effect.Effect.catchReason('PlatformError', 'NotFound', () => _effect.Effect.succeedNone)));
+    const sameInode = _effect.Option.isSome(snapshotInfo) && _effect.Option.isSome(cacheInfo) && snapshotInfo.value.dev === cacheInfo.value.dev && _effect.Option.isSome(snapshotInfo.value.ino) && _effect.Option.isSome(cacheInfo.value.ino) && snapshotInfo.value.ino.value === cacheInfo.value.ino.value;
+    if (snapshotFile === cacheFile || sameInode) {
+      return yield* new _RepositoryError.RepositoryPathConflict({
+        snapshotPath: options.dbPath,
+        cachePath: options.cachePath
+      });
     }
-    const runResultColumns = yield* _effect.Schema.decodeUnknownEffect(TableColumnsSchema)(yield* sql`PRAGMA table_info(${sql(tables.testRunResults)});`).pipe(_effect.Effect.mapError(_RepositoryError.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.Effect.scoped(_effect.Effect.gen(function* () {
+        const sql = yield* openClient({
+          filename: options.cachePath,
+          readonly: true,
+          disableWAL: true
+        });
+        yield* (0, _testRepositorySchema.checkFormat)(sql, 'cache', options.cachePath);
+        return true;
+      })).pipe(_effect.Effect.catchTag('RepositoryFormatError', () => _effect.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* (0, _testRepositorySchema.initializeSchema)(cache, 'cache', options.cachePath);
+  const getMemorySnapshot = snapshotLock.withPermit(_effect.Effect.gen(function* () {
+    const existing = yield* _effect.Ref.get(snapshotMemory);
+    if (_effect.Option.isSome(existing)) return existing.value;
+    const sql = yield* _effect.Scope.provide(openClient({
+      filename: ':memory:',
+      disableWAL: true
+    }), lifetime);
+    yield* sql`PRAGMA foreign_keys = ON;`;
+    yield* (0, _testRepositorySchema.initializeSchema)(sql, 'snapshot', ':memory:');
+    yield* _effect.Ref.set(snapshotMemory, _effect.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.Effect.gen(function* () {
-    if (testResults.length === 0) return;
-    const encoded = yield* _effect.Effect.forEach(testResults, _ => _effect.Schema.encodeEffect(TestResultWriteSchema)(_).pipe(_effect.Effect.mapError(_RepositoryError.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.Effect.mapError(_RepositoryError.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.Effect.mapError(_RepositoryError.RepositoryWriteError.from('insertTestResults')));
+  const snapshotReader = _effect.Effect.gen(function* () {
+    if (options.dbPath === ':memory:') return yield* _effect.Ref.get(snapshotMemory);
+    if (!(yield* fs.exists(options.dbPath))) return _effect.Option.none();
+    const sql = yield* openClient({
+      filename: options.dbPath,
+      readonly: true,
+      disableWAL: true
+    });
+    yield* (0, _testRepositorySchema.checkFormat)(sql, 'snapshot', options.dbPath);
+    return _effect.Option.some(sql);
+  });
+  const withSnapshot = (empty, use) => _effect.Effect.scoped(_effect.Effect.gen(function* () {
+    const sql = yield* snapshotReader;
+    return _effect.Option.isSome(sql) ? yield* use(sql.value) : empty;
+  }));
+  const cacheReader = _effect.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* _effect.TxReentrantLock.readLock(memoryLock);
+      return cache;
     }
-  })).pipe(_effect.Effect.catchTag('SqlError', e => _effect.Effect.fail(_RepositoryError.RepositoryWriteError.from('insertTestResults')(e))));
-  const insertTestResult = (testResult, testRun) => insertTestResults([testResult], testRun);
-  const makeTestResultSchema = schemas => {
-    const input = schemas?.input ?? _effect.Schema.Unknown;
-    const result = schemas?.result ?? _effect.Schema.Unknown;
-    const expected = schemas?.expected ?? _effect.Schema.Unknown;
-    return _effect.Schema.Struct({
-      id: _effect.Schema.String,
-      hashTestCase: _effect.Schema.String,
-      key: _effect.Schema.String,
-      ordering: _effect.Schema.Int,
-      resultOrdering: _effect.Schema.Int,
-      input: _effect.Schema.fromJsonString(input),
-      result: _effect.Schema.fromJsonString(result),
-      expected: _effect.Schema.fromJsonString(expected),
-      label: _Classify.LabelSchema,
-      tags: (0, _Schema.split)(','),
-      timeMillis: _effect.Schema.Finite
+    const sql = yield* openClient({
+      filename: options.cachePath,
+      readonly: true,
+      disableWAL: true
     });
-  };
-  const getTestResultsStream = (testRun, schemas) => {
-    const RowSchema = makeTestResultSchema(schemas);
-    const RowsSchema = _effect.Schema.Array(RowSchema);
-    // The SQLite driver returns rows in one batch. Decode that batch once
-    // before exposing it as a stream.
-    return _effect.Stream.unwrap(_effect.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.Effect.mapError(_RepositoryError.RepositoryQueryError.fromSql('getTestResultsStream')));
-      const decoded = yield* _effect.Schema.decodeUnknownEffect(RowsSchema)(rows).pipe(_effect.Effect.mapError(_RepositoryError.RepositoryDecodeError.from('getTestResultsStream')));
-      return _effect.Stream.fromIterable(decoded);
-    }));
-  };
-  const hasResults = _effect.Effect.fnUntraced(function* (testRun) {
-    const b = yield* sql`
-                SELECT COUNT(*) count FROM ${sql(tables.testRunResults)}
-                WHERE testRun = ${testRun.id};
-            `.pipe(_effect.Effect.mapError(_RepositoryError.RepositoryQueryError.fromSql('hasResults')));
-    const r = yield* _effect.Schema.decodeUnknownEffect(CountSchema)(b).pipe(_effect.Effect.mapError(_RepositoryError.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.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.Effect.mapError(_RepositoryError.RepositoryQueryError.fromSql('getPreviousTestRun')));
-    const p = yield* _effect.Schema.decodeUnknownEffect(TestRunsReadSchema)(r).pipe(_effect.Effect.mapError(_RepositoryError.RepositoryDecodeError.from('getPreviousTestRun')));
-    return _effect.Array.head(p);
+  const writeCache = effect => options.cachePath === ':memory:' ? _effect.TxReentrantLock.withWriteLock(memoryLock, cache.withTransaction(effect)) : cache.withTransaction(effect);
+  const readRun = _effect.Effect.fnUntraced(function* (sql, run) {
+    return _effect.Array.head(yield* decodeRuns(yield* sql`
+            SELECT *, ${run.store} AS store FROM ${sql(_testRepositorySchema.tables.testRuns)}
+            WHERE id = ${run.id}
+                AND ${run.store === 'cache' ? sql`snapshotIdentity = ${options.snapshotIdentity}` : sql`1 = 1`};
+        `));
   });
-  const getAllTestRuns = _effect.Effect.gen(function* () {
-    const results = yield* sql`
-            SELECT * from ${sql(tables.testRuns)};
-        `.pipe(_effect.Effect.mapError(_RepositoryError.RepositoryQueryError.fromSql('getAllTestRuns')));
-    return yield* _effect.Schema.decodeUnknownEffect(TestRunsReadSchema)(results).pipe(_effect.Effect.mapError(_RepositoryError.RepositoryDecodeError.from('getAllTestRuns')));
+  const getTestRun = run => run.store === 'cache' ? readRun(cache, run) : withSnapshot(_effect.Option.none(), sql => readRun(sql, run));
+  const requireRun = _effect.Effect.fnUntraced(function* (sql, run) {
+    const found = yield* readRun(sql, run);
+    if (_effect.Option.isNone(found) || found.value.name !== run.name || found.value.variant !== run.variant) {
+      return yield* new _RepositoryError.TestRunNotFound({
+        testRunId: run.id
+      });
+    }
+    return found.value;
   });
-  const getAllTestRunResults = _effect.Effect.gen(function* () {
-    const results = yield* sql`
-            SELECT * from ${sql(tables.testRunResults)};
-        `.pipe(_effect.Effect.mapError(_RepositoryError.RepositoryQueryError.fromSql('getAllTestRunResults')));
-    return yield* _effect.Schema.decodeUnknownEffect(TestRunResultsSchema)(results).pipe(_effect.Effect.mapError(_RepositoryError.RepositoryDecodeError.from('getAllTestRunResults')));
+  const writeRows = _effect.Effect.fnUntraced(function* (sql, runId, rows) {
+    if (rows.length === 0) return;
+    yield* sql`
+            INSERT INTO ${sql(_testRepositorySchema.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(_testRepositorySchema.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.Effect.gen(function* () {
-    const results = yield* sql`
-            SELECT * from ${sql(tables.testResults)};
-        `.pipe(_effect.Effect.mapError(_RepositoryError.RepositoryQueryError.fromSql('getAllTestResults')));
-    return yield* _effect.Schema.decodeUnknownEffect(TestResultsSchema)(results).pipe(_effect.Effect.mapError(_RepositoryError.RepositoryDecodeError.from('getAllTestResults')));
+  const insertTestResults = _effect.Effect.fnUntraced(function* (results, run, schemas) {
+    if (run.store !== 'cache') {
+      return yield* _effect.Effect.die(new Error('Only cached Running attempts accept result writes.'));
+    }
+    const codec = (0, _TestSerialization.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.Effect.forEach(results.slice(offset, offset + 50), _effect.Effect.fnUntraced(function* (result) {
+        const encoded = yield* codec.encode(result);
+        return yield* encodeResult({
+          ...encoded,
+          input: (0, _TestSerialization.stringifyJson)(encoded.input),
+          result: (0, _TestSerialization.stringifyJson)(encoded.result),
+          expected: (0, _TestSerialization.stringifyJson)(encoded.expected)
+        });
+      }));
+      yield* writeCache(_effect.Effect.gen(function* () {
+        const saved = yield* requireRun(cache, run);
+        if (saved.state !== 'Running') {
+          return yield* _effect.Effect.die(new Error('Only Running test runs accept result writes.'));
+        }
+        yield* writeRows(cache, run.id, encoded);
+      }));
+    }
   });
-  const getLastTestRunHash = _effect.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.Effect.mapError(_RepositoryError.RepositoryQueryError.fromSql('getLastTestRunHash')));
-    const runs = yield* _effect.Schema.decodeUnknownEffect(TestRunsReadSchema)(rows).pipe(_effect.Effect.mapError(_RepositoryError.RepositoryDecodeError.from('getLastTestRunHash')));
-    return _effect.Array.head(runs).pipe(_effect.Option.flatMap(run => _effect.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(_testRepositorySchema.tables.testRunResults)} runres JOIN ${sql(_testRepositorySchema.tables.testResults)} res ON res.id = runres.testResult` : sql`${sql(_testRepositorySchema.tables.testResults)} res CROSS JOIN ${sql(_testRepositorySchema.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 _effect.Stream.die(new Error('Match at most 50 case/key pairs per query.'));
+    const codec = (0, _TestSerialization.makeResultCodec)(schemas, run.name);
+    return _effect.Stream.unwrap(_effect.Effect.gen(function* () {
+      const selected = run.store === 'cache' ? _effect.Option.some(yield* cacheReader) : yield* snapshotReader;
+      if (_effect.Option.isNone(selected)) return yield* new _RepositoryError.TestRunNotFound({
+        testRunId: run.id
+      });
+      const sql = selected.value;
+      yield* requireRun(sql, run);
+      return _effect.Stream.paginate(undefined, _effect.Effect.fnUntraced(function* (after) {
+        const rows = yield* decodeRows(yield* readResultPage(sql, run.id, after, matching));
+        const decoded = yield* _effect.Effect.forEach(rows, codec.decode);
+        return [decoded, rows.length < 100 ? _effect.Option.none() : _effect.Option.some(rows[rows.length - 1])];
+      }));
+    }));
+  };
+  const getLatestTestRun = _effect.Effect.fnUntraced(function* ({
+    name,
+    variant
+  }) {
+    return _effect.Array.head(yield* decodeRuns(yield* cache`
+            SELECT *, 'cache' AS store FROM ${cache(_testRepositorySchema.tables.testRuns)}
+            WHERE snapshotIdentity = ${options.snapshotIdentity} AND name = ${name} AND variant = ${variant}
+            ORDER BY id DESC LIMIT 1;
+        `));
   });
-  const getOrCreateCurrentTestRun = name => sql.withTransaction(_effect.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.Effect.mapError(_RepositoryError.RepositoryQueryError.fromSql('getOrCreateCurrentTestRun')));
-    const current = yield* _effect.Schema.decodeUnknownEffect(TestRunsReadSchema)(currentRaw).pipe(_effect.Effect.mapError(_RepositoryError.RepositoryDecodeError.from('getOrCreateCurrentTestRun')));
-    const existing = _effect.Array.head(current);
-    if (_effect.Option.isSome(existing)) {
-      return existing.value;
-    }
-    const insertedRaw = yield* sql`
-                    INSERT INTO ${sql(tables.testRuns)}
-                    ${sql.insert({
-      name
-    })}
-                    RETURNING *;
-                `.pipe(_effect.Effect.mapError(_RepositoryError.RepositoryWriteError.from('getOrCreateCurrentTestRun')));
-    const inserted = yield* _effect.Schema.decodeUnknownEffect(TestRunsReadSchema)(insertedRaw).pipe(_effect.Effect.mapError(_RepositoryError.RepositoryDecodeError.from('getOrCreateCurrentTestRun')));
-    return yield* _effect.Effect.fromOption(_effect.Array.head(inserted)).pipe(_effect.Effect.mapError(() => new _RepositoryError.TestRunNotCreated({
-      testSuiteName: name
-    })));
-  })).pipe(_effect.Effect.catchTag('SqlError', e => _effect.Effect.fail(_RepositoryError.RepositoryQueryError.fromSql('getOrCreateCurrentTestRun')(e))));
-  const clearStale = ({
+  const getBaselineTestRun = ({
     name,
-    keep = 1
-  }) => sql.withTransaction(_effect.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.Effect.mapError(_RepositoryError.RepositoryQueryError.fromSql('clearStale')));
-    const staleTestRuns = yield* _effect.Schema.decodeUnknownEffect(TestRunsReadSchema)(raw).pipe(_effect.Effect.mapError(_RepositoryError.RepositoryDecodeError.from('clearStale')));
-    if (staleTestRuns.length === 0) {
-      return;
+    variant
+  }) => withSnapshot(_effect.Option.none(), _effect.Effect.fnUntraced(function* (sql) {
+    return _effect.Array.head(yield* decodeRuns(yield* sql`
+                SELECT run.*, 'snapshot' AS store FROM ${sql(_testRepositorySchema.tables.testBaselines)} baseline
+                JOIN ${sql(_testRepositorySchema.tables.testRuns)} run ON run.id = baseline.testRun
+                WHERE baseline.name = ${name} AND baseline.variant = ${variant};
+            `));
+  }));
+  const createTestRun = _effect.Effect.fnUntraced(function* (input) {
+    const executionId = yield* crypto.randomUUIDv4();
+    return yield* writeCache(_effect.Effect.gen(function* () {
+      yield* cache`
+                DELETE FROM ${cache(_testRepositorySchema.tables.testRuns)}
+                WHERE snapshotIdentity = ${options.snapshotIdentity} AND name = ${input.name} AND variant = ${input.variant};
+            `;
+      yield* cache`
+                DELETE FROM ${cache(_testRepositorySchema.tables.testResults)} WHERE NOT EXISTS (
+                    SELECT 1 FROM ${cache(_testRepositorySchema.tables.testRunResults)} links WHERE links.testResult = ${cache(_testRepositorySchema.tables.testResults)}.id
+                );
+            `;
+      const inserted = yield* decodeRuns(yield* cache`
+                INSERT INTO ${cache(_testRepositorySchema.tables.testRuns)} ${cache.insert({
+        name: input.name,
+        variant: input.variant,
+        executionId,
+        snapshotIdentity: options.snapshotIdentity,
+        state: 'Running'
+      })}
+                RETURNING *, 'cache' AS store;
+            `);
+      return yield* _effect.Effect.fromOption(_effect.Array.head(inserted)).pipe(_effect.Effect.mapError(() => new _RepositoryError.TestRunNotCreated({
+        testSuiteName: input.name
+      })));
+    }));
+  });
+  const finishTestRun = (run, state) => writeCache(_effect.Effect.gen(function* () {
+    const updated = yield* decodeRuns(yield* cache`
+            UPDATE ${cache(_testRepositorySchema.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 _RepositoryError.TestRunNotFound({
+      testRunId: run.id
+    });
+  }));
+  const withTestRun = (input, execute) => _effect.Effect.acquireUseRelease(createTestRun(input), run => _effect.Effect.suspend(() => execute(run)).pipe(_effect.Effect.map(value => ({
+    run,
+    value
+  }))), (run, exit) => finishTestRun(run, _effect.Exit.isSuccess(exit) ? 'Complete' : 'Failed')).pipe(_effect.Effect.map(({
+    run,
+    value
+  }) => ({
+    run: _TestRun.TestRun.make({
+      ...run,
+      state: 'Complete'
+    }),
+    value
+  })));
+  const snapshotWriter = _effect.Effect.gen(function* () {
+    if (options.dbPath === ':memory:') return yield* getMemorySnapshot;
+    const exists = yield* fs.exists(options.dbPath);
+    if (exists) {
+      yield* _effect.Effect.scoped(_effect.Effect.gen(function* () {
+        const sql = yield* openClient({
+          filename: options.dbPath,
+          readonly: true,
+          disableWAL: true
+        });
+        yield* (0, _testRepositorySchema.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.Effect.mapError(_RepositoryError.RepositoryWriteError.from('clearStale')));
-    yield* sql`
-                    DELETE FROM ${sql(tables.testRuns)}
-                    WHERE id IN ${sql.in(ids)};
-                `.pipe(_effect.Effect.mapError(_RepositoryError.RepositoryWriteError.from('clearStale')));
-    yield* sql`
-                    DELETE FROM ${sql(tables.testResults)}
-                    WHERE id NOT IN (
-                        SELECT DISTINCT testResult FROM ${sql(tables.testRunResults)}
-                    );
-                `.pipe(_effect.Effect.mapError(_RepositoryError.RepositoryWriteError.from('clearStale')));
-    yield* _effect.Console.log('Cleared stale test runs.');
-  })).pipe(_effect.Effect.catchTag('SqlError', e => _effect.Effect.fail(_RepositoryError.RepositoryWriteError.from('clearStale')(e))));
-  const clearUncommitedTestResults = ({
-    name
-  }) => sql.withTransaction(_effect.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.Effect.mapError(_RepositoryError.RepositoryQueryError.fromSql('clearUncommitedTestResults')));
-    const current = yield* _effect.Schema.decodeUnknownEffect(TestRunsReadSchema)(currentRaw).pipe(_effect.Effect.mapError(_RepositoryError.RepositoryDecodeError.from('clearUncommitedTestResults')));
-    const currentTestRun = _effect.Array.head(current);
-    if (_effect.Option.isNone(currentTestRun)) {
-      return;
+    const sql = yield* openClient({
+      filename: options.dbPath,
+      disableWAL: true
+    });
+    if (exists) yield* (0, _testRepositorySchema.checkFormat)(sql, 'snapshot', options.dbPath);else yield* (0, _testRepositorySchema.initializeSchema)(sql, 'snapshot', options.dbPath);
+    yield* sql`PRAGMA journal_mode = DELETE;`;
+    yield* sql`PRAGMA foreign_keys = ON;`;
+    return sql;
+  });
+  const commitTestRuns = runs => _effect.Effect.scoped(_effect.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 _RepositoryError.TestRunDuplicate({
+        testSuiteName: run.name,
+        variant: run.variant
+      });
+      selectedVariants.add(key);
     }
-    yield* sql`
-                    DELETE FROM ${sql(tables.testRunResults)}
-                    WHERE testRun = ${currentTestRun.value.id};
-                `.pipe(_effect.Effect.mapError(_RepositoryError.RepositoryWriteError.from('clearUncommitedTestResults')));
-    yield* sql`
-                    DELETE FROM ${sql(tables.testResults)}
-                    WHERE id NOT IN (
-                        SELECT DISTINCT testResult FROM ${sql(tables.testRunResults)}
-                    );
-                `.pipe(_effect.Effect.mapError(_RepositoryError.RepositoryWriteError.from('clearUncommitedTestResults')));
-  })).pipe(_effect.Effect.catchTag('SqlError', e => _effect.Effect.fail(_RepositoryError.RepositoryWriteError.from('clearUncommitedTestResults')(e))));
-  const commitCurrentTestRun = _effect.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.Effect.forEach(runs, run => _effect.Effect.gen(function* () {
+      const saved = run.store === 'cache' && reader !== undefined ? yield* requireRun(reader, run) : yield* getTestRun(run).pipe(_effect.Effect.flatMap(_effect.Option.match({
+        onNone: () => _effect.Effect.fail(new _RepositoryError.TestRunNotFound({
+          testRunId: run.id
+        })),
+        onSome: _effect.Effect.succeed
+      })));
+      if (saved.name !== run.name || saved.variant !== run.variant) return yield* new _RepositoryError.TestRunNotFound({
+        testRunId: run.id
+      });
+      if (saved.state !== 'Complete') return yield* new _RepositoryError.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(_testRepositorySchema.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.Effect.forEach(selected, ({
+      run,
+      executionId
+    }) => _effect.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(_testRepositorySchema.tables.testRuns)} WHERE executionId = ${executionId};
+                `);
+        if (existing.length > 0) {
+          snapshot = existing[0];
+        } else {
+          const inserted = yield* decodeRuns(yield* sql`
+                        INSERT INTO ${sql(_testRepositorySchema.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(_testRepositorySchema.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.Effect.fnUntraced(function* ({
     name,
-    hash
+    variant,
+    before,
+    limit
   }) {
-    const currentTestRunResults = yield* _effect.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.Effect.mapError(_RepositoryError.RepositoryQueryError.fromSql('commitCurrentTestRun')))).pipe(_effect.Effect.mapError(_RepositoryError.RepositoryDecodeError.from('commitCurrentTestRun')));
-    if (currentTestRunResults === 0) {
-      yield* _effect.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.Effect.mapError(_RepositoryError.RepositoryWriteError.from('commitCurrentTestRun')));
-    yield* sql`
-                INSERT INTO ${sql(tables.testRuns)}
-                ${sql.insert({
-      name
-    })};
-            `.pipe(_effect.Effect.mapError(_RepositoryError.RepositoryWriteError.from('commitCurrentTestRun')));
-    yield* _effect.Console.log('Commited test run.');
+    const parsedLimit = yield* decodeRunLimit(limit);
+    return yield* withSnapshot([], _effect.Effect.fnUntraced(function* (sql) {
+      const rows = yield* decodeListedRuns(yield* sql`
+                SELECT run.*, 'snapshot' AS store, EXISTS (
+                    SELECT 1 FROM ${sql(_testRepositorySchema.tables.testBaselines)} baseline
+                    WHERE baseline.name = run.name AND baseline.variant = run.variant AND baseline.testRun = run.id
+                ) AS isBaseline FROM ${sql(_testRepositorySchema.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.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(_testRepositorySchema.tables.testRuns)} WHERE name = ${name}
+            ) variants LEFT JOIN ${sql(_testRepositorySchema.tables.testBaselines)} baseline
+                ON baseline.name = ${name} AND baseline.variant = variants.variant
+            LEFT JOIN ${sql(_testRepositorySchema.tables.testRuns)} run ON run.id = baseline.testRun ORDER BY variants.variant;
+        `);
+    return rows.map(({
+      variant,
+      id,
+      name
+    }) => ({
+      variant,
+      baseline: id === null || name === null ? _effect.Option.none() : _effect.Option.some(_TestRun.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 => (0, _testResultStats.withStats)(use).pipe(_effect.Effect.provideService(_sql.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