@creative-introvert/tons-of-tests 3.0.0-rc.0 → 3.0.0-rc.2

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

@@ -3,21 +3,26 @@
 Object.defineProperty(exports, "__esModule", {
   value: true
 });
-exports.makeTestRepository = exports.TestResultStorage = void 0;
+exports.makeTestRepository = exports.TestResultStorage = exports.TestRepositoryStorage = void 0;
 Object.defineProperty(exports, "tables", {
   enumerable: true,
   get: function () {
-    return _testRepositoryMigrations.tables;
+    return _testRepositorySchema.tables;
   }
 });
+var Sqlite = /*#__PURE__*/_interopRequireWildcard(/*#__PURE__*/require("@effect/sql-sqlite-node"));
 var _effect = /*#__PURE__*/require("effect");
 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 _testRepositoryMigrations = /*#__PURE__*/require("./test-repository-migrations.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; }
+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,
@@ -37,33 +42,187 @@ const StoredResult = /*#__PURE__*/_effect.Schema.Struct({
   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 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 decodeListedRuns = /*#__PURE__*/_effect.Schema.decodeUnknownEffect(/*#__PURE__*/_effect.Schema.Array(/*#__PURE__*/_effect.Schema.Struct({
-  ..._TestRun.TestRun.fields,
+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(_TestRun.TestRun.fields.id),
-  name: /*#__PURE__*/_effect.Schema.NullOr(_TestRun.TestRun.fields.name),
-  state: /*#__PURE__*/_effect.Schema.NullOr(_TestRun.TestRun.fields.state)
+  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 makeTestRepository = exports.makeTestRepository = /*#__PURE__*/_effect.Effect.gen(function* () {
-  const sql = yield* _sql.SqlClient.SqlClient;
-  yield* sql`PRAGMA auto_vacuum = FULL;`;
-  yield* _testRepositoryMigrations.migrate;
-  const getTestRun = _effect.Effect.fnUntraced(function* (id) {
-    return _effect.Array.head(yield* decodeRuns(yield* sql`SELECT * FROM ${sql(_testRepositoryMigrations.tables.testRuns)} WHERE id = ${id};`));
+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
+      });
+    }
+  }
+  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;
+      }
+    }
+  }
+  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;
+  }));
+  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;
+    }
+    const sql = yield* openClient({
+      filename: options.cachePath,
+      readonly: true,
+      disableWAL: true
+    });
+    // Keep the selected rows stable until the scoped connection closes,
+    // including when reading is interrupted.
+    yield* sql`BEGIN;`;
+    return sql;
+  });
+  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 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 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 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);
-    // Each statement stays below SQLite's lowest default limit of 999 parameters.
+    // 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);
@@ -74,127 +233,104 @@ const makeTestRepository = exports.makeTestRepository = /*#__PURE__*/_effect.Eff
           expected: (0, _TestSerialization.stringifyJson)(encoded.expected)
         });
       }));
-      yield* sql.withTransaction(_effect.Effect.gen(function* () {
-        const saved = yield* getTestRun(run.id);
-        if (_effect.Option.isNone(saved)) {
-          return yield* new _RepositoryError.TestRunNotFound({
-            testRunId: run.id
-          });
-        }
-        if (saved.value.state !== 'Running') {
+      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.'));
         }
-        if (encoded.length === 0) return;
-        const content = encoded.map(result => ({
-          id: result.id,
-          hashTestCase: result.hashTestCase,
-          key: result.key,
-          input: result.input,
-          result: result.result,
-          expected: result.expected,
-          label: result.label
-        }));
-        yield* sql`
-                        INSERT INTO ${sql(_testRepositoryMigrations.tables.testResults)} ${sql.insert(content)}
-                        ON CONFLICT(id) DO NOTHING;
-                    `;
-        const links = encoded.map(result => ({
-          testRun: run.id,
-          testResult: result.id,
-          ordering: result.ordering,
-          resultOrdering: result.resultOrdering,
-          timeMillis: result.timeMillis,
-          tags: result.tags
-        }));
-        yield* sql`
-                        INSERT INTO ${sql(_testRepositoryMigrations.tables.testRunResults)} ${sql.insert(links)}
-                        ON CONFLICT(testRun, testResult) DO UPDATE SET
-                            ordering = excluded.ordering,
-                            resultOrdering = excluded.resultOrdering,
-                            timeMillis = excluded.timeMillis,
-                            tags = excluded.tags;
-                    `;
+        yield* writeRows(cache, run.id, encoded);
       }));
     }
   });
+  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.'));
-    }
+    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);
-    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}`));
-    // Match case/key pairs first, so each batch avoids scanning the whole prior run.
-    // CROSS JOIN keeps SQLite from choosing the run-order index for that lookup.
-    const from = matching === undefined ? sql`${sql(_testRepositoryMigrations.tables.testRunResults)} runres
-                JOIN ${sql(_testRepositoryMigrations.tables.testResults)} res ON res.id = runres.testResult` : sql`${sql(_testRepositoryMigrations.tables.testResults)} res
-                CROSS JOIN ${sql(_testRepositoryMigrations.tables.testRunResults)} runres ON res.id = runres.testResult`;
-    // The driver cannot stream a query. Keyset pages keep decoded rows bounded.
-    return _effect.Stream.paginate(undefined, _effect.Effect.fnUntraced(function* (after) {
-      const rows = yield* decodeRows(yield* 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 = ${run.id} 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 100;
-            `);
-      const last = rows[rows.length - 1];
-      const decoded = yield* _effect.Effect.forEach(rows, codec.decode);
-      return [decoded, rows.length < 100 ? _effect.Option.none() : _effect.Option.some({
-        ordering: last.ordering,
-        resultOrdering: last.resultOrdering,
-        id: last.id
-      })];
+    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* sql`
-                    SELECT * FROM ${sql(_testRepositoryMigrations.tables.testRuns)}
-                    WHERE name = ${name} AND variant = ${variant}
-                    ORDER BY id DESC LIMIT 1;
-                `));
+    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 getBaselineTestRun = _effect.Effect.fnUntraced(function* ({
+  const getBaselineTestRun = ({
     name,
     variant
-  }) {
+  }) => withSnapshot(_effect.Option.none(), _effect.Effect.fnUntraced(function* (sql) {
     return _effect.Array.head(yield* decodeRuns(yield* sql`
-                    SELECT run.* FROM ${sql(_testRepositoryMigrations.tables.testBaselines)} baseline
-                    JOIN ${sql(_testRepositoryMigrations.tables.testRuns)} run ON run.id = baseline.testRun
-                    WHERE baseline.name = ${name} AND baseline.variant = ${variant};
-                `));
-  });
+                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 inserted = yield* decodeRuns(yield* sql`
-                INSERT INTO ${sql(_testRepositoryMigrations.tables.testRuns)}
-                ${sql.insert({
-      ...input,
-      state: 'Running'
-    })} RETURNING *;
+    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
-    })));
-  }, sql.withTransaction);
-  const finishTestRun = _effect.Effect.fnUntraced(function* (run, state) {
-    const updated = _effect.Array.head(yield* decodeRuns(yield* sql`
-                    UPDATE ${sql(_testRepositoryMigrations.tables.testRuns)} SET state = ${state}
-                    WHERE id = ${run.id} AND state = 'Running' RETURNING *;
-                `));
-    if (_effect.Option.isNone(updated)) {
-      return yield* new _RepositoryError.TestRunNotFound({
-        testRunId: run.id
-      });
-    }
-  }, sql.withTransaction);
+      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
@@ -202,39 +338,127 @@ const makeTestRepository = exports.makeTestRepository = /*#__PURE__*/_effect.Eff
     run,
     value
   }) => ({
-    run: new _TestRun.TestRun({
-      id: run.id,
-      name: run.name,
-      variant: run.variant,
+    run: _TestRun.TestRun.make({
+      ...run,
       state: 'Complete'
     }),
     value
   })));
-  const commitTestRun = _effect.Effect.fnUntraced(function* (id) {
-    const found = yield* getTestRun(id);
-    if (_effect.Option.isNone(found)) {
-      return yield* new _RepositoryError.TestRunNotFound({
-        testRunId: id
+  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 run = found.value;
-    if (run.state !== 'Complete') {
-      return yield* new _RepositoryError.TestRunIncomplete({
+    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,
-        testRunId: run.id,
         variant: run.variant
       });
+      selectedVariants.add(key);
     }
-    yield* sql`
-            INSERT INTO ${sql(_testRepositoryMigrations.tables.testBaselines)}
-            ${sql.insert({
-      name: run.name,
-      variant: run.variant,
-      testRun: run.id
-    })}
-            ON CONFLICT(name, variant) DO UPDATE SET testRun = excluded.testRun;
-        `;
-  }, sql.withTransaction);
+    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,
     variant,
@@ -242,54 +466,51 @@ const makeTestRepository = exports.makeTestRepository = /*#__PURE__*/_effect.Eff
     limit
   }) {
     const parsedLimit = yield* decodeRunLimit(limit);
-    const runs = yield* decodeListedRuns(yield* sql`
-                SELECT run.*, EXISTS(
-                    SELECT 1 FROM ${sql(_testRepositoryMigrations.tables.testBaselines)} baseline
-                    WHERE baseline.name = run.name AND baseline.variant = run.variant
-                        AND baseline.testRun = run.id
-                ) AS isBaseline
-                FROM ${sql(_testRepositoryMigrations.tables.testRuns)} run
+    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 runs.map(({
-      isBaseline,
-      ...run
-    }) => Object.assign(new _TestRun.TestRun(run), {
-      isBaseline: isBaseline === 1
+      return rows.map(({
+        isBaseline,
+        ...run
+      }) => ({
+        ...run,
+        isBaseline: isBaseline === 1
+      }));
     }));
   });
-  const listVariantBaselines = _effect.Effect.fnUntraced(function* (name) {
-    const variants = yield* decodeVariantBaselines(yield* sql`
-                SELECT variants.variant, run.id, run.name, run.state
-                FROM (
-                    SELECT DISTINCT variant FROM ${sql(_testRepositoryMigrations.tables.testRuns)}
-                    WHERE name = ${name}
-                ) variants
-                LEFT JOIN ${sql(_testRepositoryMigrations.tables.testBaselines)} baseline
-                    ON baseline.name = ${name} AND baseline.variant = variants.variant
-                LEFT JOIN ${sql(_testRepositoryMigrations.tables.testRuns)} run ON run.id = baseline.testRun
-                ORDER BY variants.variant;
-            `);
-    return variants.map(({
+  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,
-      state
+      name
     }) => ({
       variant,
-      baseline: id === null || name === null || state === null ? _effect.Option.none() : _effect.Option.some(new _TestRun.TestRun({
+      baseline: id === null || name === null ? _effect.Option.none() : _effect.Option.some(_TestRun.TestRun.make({
         id,
         name,
         variant,
-        state
+        store: 'snapshot',
+        state: 'Complete'
       }))
     }));
-  });
-  return {
-    commitTestRun,
+  }));
+  const repository = {
+    commitTestRuns,
     getTestRun,
     getLatestTestRun,
     getBaselineTestRun,
@@ -297,9 +518,14 @@ const makeTestRepository = exports.makeTestRepository = /*#__PURE__*/_effect.Eff
     listVariantBaselines,
     getTestResultsStream,
     withTestRun,
-    withStats: use => (0, _testResultStats.withStats)(use).pipe(_effect.Effect.provideService(_sql.SqlClient.SqlClient, sql)),
+    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
+  };
 });
 //# sourceMappingURL=Test.repository.sqlite.js.map