@minnowdb/core 0.10.0 → 0.10.2

package/dist/testing/interaction-simulator.js

@@ -0,0 +1,1631 @@
+import { MinnowDatabase } from "../engine/database.js";
+import { FaultInjectingBlockStore } from "./index.js";
+class InteractionFailure extends Error {
+  index;
+  interaction;
+  trace;
+  constructor(message, index, interaction, trace, options) {
+    super(`${message}
+  at interaction ${String(index)} (${interaction.kind})
+  recent SQL:
+    ${trace.join("\n    ")}`, options);
+    this.index = index;
+    this.interaction = interaction;
+    this.trace = trace;
+    this.name = "InteractionFailure";
+  }
+}
+const TEXT_POOL = [
+  "alpha",
+  "bravo",
+  "charlie",
+  "delta",
+  "echo",
+  "fox trot",
+  "Golf",
+  "hotel",
+  "o'clock",
+  "zulu",
+  "",
+  "42"
+];
+const FAULT_POINTS = [
+  "beforeBlockWrite",
+  "afterBlockWrite",
+  "beforeTransactionCommit",
+  "afterTransactionCommit",
+  "crash"
+];
+function createRandom(seed) {
+  const next = mulberry32(seed);
+  return {
+    next,
+    int: (maximum) => Math.floor(next() * maximum),
+    pick: (values) => {
+      const value = values[Math.floor(next() * values.length)];
+      if (value === void 0)
+        throw new Error("pick from an empty list");
+      return value;
+    },
+    chance: (probability) => next() < probability
+  };
+}
+function generateInteractionPlan(seed, options = {}) {
+  if (!Number.isSafeInteger(seed))
+    throw new RangeError("Plan seed must be a whole number");
+  const length = options.length ?? 120;
+  const connections = options.connections ?? 3;
+  const tableLimit = options.tables ?? 2;
+  const keySpace = options.keySpace ?? 24;
+  const faultPoints = options.faultPoints ?? FAULT_POINTS;
+  if (faultPoints.length === 0 || faultPoints.some((point) => !FAULT_POINTS.includes(point))) {
+    throw new RangeError("Plan faultPoints must name at least one known fault point");
+  }
+  checkRange("length", length, 1, 1e5);
+  checkRange("connections", connections, 1, 16);
+  checkRange("tables", tableLimit, 1, 8);
+  checkRange("keySpace", keySpace, 2, 1e4);
+  const random = createRandom(seed);
+  const interactions = [];
+  const live = /* @__PURE__ */ new Map();
+  const indexCount = /* @__PURE__ */ new Map();
+  let tableSerial = 0;
+  const connection = () => random.int(connections);
+  const anyTable = () => {
+    const tables = [...live.values()];
+    return tables.length === 0 ? void 0 : random.pick(tables);
+  };
+  const createTable = () => {
+    const columns = [];
+    const count = 2 + random.int(3);
+    for (let index = 0; index < count; index++) {
+      columns.push({
+        name: `c${String(index)}`,
+        type: random.pick(["integer", "real", "text", "boolean"]),
+        nullable: random.chance(0.5)
+      });
+    }
+    const table = { name: `t${String(tableSerial++)}`, columns };
+    live.set(table.name, table);
+    interactions.push({
+      kind: "createTable",
+      connection: connection(),
+      table,
+      expectExisting: false
+    });
+    if (random.chance(0.3)) {
+      interactions.push({
+        kind: "createTable",
+        connection: connection(),
+        table,
+        expectExisting: true
+      });
+    }
+  };
+  createTable();
+  for (let step = 0; step < length; step++) {
+    const table = anyTable();
+    if (table === void 0 || live.size < tableLimit && random.chance(0.04)) {
+      createTable();
+      continue;
+    }
+    const roll = random.next();
+    if (roll < 0.2) {
+      const rows = Array.from({ length: 1 + random.int(4) }, () => generateRow(random, table, keySpace));
+      interactions.push({
+        kind: "insert",
+        connection: connection(),
+        table: table.name,
+        rows: distinctIds(rows),
+        viaParameters: random.chance(0.5)
+      });
+    } else if (roll < 0.3) {
+      interactions.push({
+        kind: "update",
+        connection: connection(),
+        table: table.name,
+        predicate: generatePredicate(random, table, keySpace, 2),
+        assignments: generateAssignments(random, table)
+      });
+    } else if (roll < 0.37) {
+      interactions.push({
+        kind: "delete",
+        connection: connection(),
+        table: table.name,
+        predicate: generatePredicate(random, table, keySpace, 2)
+      });
+    } else if (roll < 0.52) {
+      interactions.push({
+        kind: "select",
+        connection: connection(),
+        table: table.name,
+        predicate: generatePredicate(random, table, keySpace, 3),
+        limit: random.chance(0.4) ? random.int(6) : null,
+        descending: random.chance(0.3)
+      });
+    } else if (roll < 0.6) {
+      interactions.push({
+        kind: "partition",
+        connection: connection(),
+        table: table.name,
+        predicate: generatePredicate(random, table, keySpace, 3)
+      });
+    } else if (roll < 0.65) {
+      interactions.push({
+        kind: "unionAll",
+        connection: connection(),
+        table: table.name,
+        left: generatePredicate(random, table, keySpace, 2),
+        right: generatePredicate(random, table, keySpace, 2)
+      });
+    } else if (roll < 0.69) {
+      const serial = (indexCount.get(table.name) ?? 0) + 1;
+      indexCount.set(table.name, serial);
+      const first = random.pick(table.columns).name;
+      const columns = random.chance(0.4) ? [
+        first,
+        random.pick(table.columns.filter((column) => column.name !== first).map((column) => column.name).concat("id"))
+      ] : [first];
+      interactions.push({
+        kind: "createIndex",
+        connection: connection(),
+        table: table.name,
+        name: `${table.name}_ix${String(serial)}`,
+        columns
+      });
+    } else if (roll < 0.72 && live.size > 1) {
+      live.delete(table.name);
+      interactions.push({
+        kind: "dropTable",
+        connection: connection(),
+        table: table.name,
+        expectMissing: false
+      });
+      if (random.chance(0.4)) {
+        interactions.push({
+          kind: "dropTable",
+          connection: connection(),
+          table: table.name,
+          expectMissing: true
+        });
+      }
+    } else if (roll < 0.79) {
+      const statements = [];
+      const count = 1 + random.int(3);
+      for (let index = 0; index < count; index++) {
+        const inner = random.next();
+        if (inner < 0.5) {
+          statements.push({
+            kind: "insert",
+            rows: distinctIds(Array.from({ length: 1 + random.int(2) }, () => generateRow(random, table, keySpace)))
+          });
+        } else if (inner < 0.8) {
+          statements.push({
+            kind: "update",
+            predicate: generatePredicate(random, table, keySpace, 2),
+            assignments: generateAssignments(random, table)
+          });
+        } else {
+          statements.push({
+            kind: "delete",
+            predicate: generatePredicate(random, table, keySpace, 1)
+          });
+        }
+      }
+      const owner = connection();
+      interactions.push({
+        kind: "transaction",
+        connection: owner,
+        observer: connections === 1 ? owner : (owner + 1 + random.int(connections - 1)) % connections,
+        table: table.name,
+        statements,
+        outcome: random.chance(0.5) ? "commit" : "rollback"
+      });
+    } else if (roll < 0.89 && connections > 1) {
+      const operations = [];
+      const used = /* @__PURE__ */ new Set();
+      const count = Math.min(connections * 2, 2 + random.int(connections * 2));
+      for (let index = 0; index < count; index++) {
+        const id = 1 + random.int(keySpace);
+        if (used.has(id))
+          continue;
+        used.add(id);
+        operations.push({
+          connection: index % connections,
+          mutation: generateKeyedMutation(random, table, id)
+        });
+      }
+      const readers = Array.from({ length: connections }, (_, index) => index).filter(() => random.chance(0.4));
+      interactions.push({ kind: "concurrent", table: table.name, operations, readers });
+    } else if (roll < 0.92) {
+      interactions.push({
+        kind: "fault",
+        connection: connection(),
+        table: table.name,
+        mutation: generateKeyedMutation(random, table, 1 + random.int(keySpace)),
+        point: random.pick(faultPoints)
+      });
+    } else if (roll < 0.95) {
+      interactions.push({ kind: "reopen", connection: connection() });
+    } else if (roll < 0.97) {
+      interactions.push({ kind: "maintenance", connection: connection(), table: table.name });
+    } else {
+      interactions.push({ kind: "checkpoint" });
+    }
+    if (step % 25 === 24)
+      interactions.push({ kind: "checkpoint" });
+  }
+  interactions.push({ kind: "checkpoint" });
+  return { version: 1, seed, connections, interactions };
+}
+function checkRange(name, value, minimum, maximum) {
+  if (!Number.isSafeInteger(value) || value < minimum || value > maximum) {
+    throw new RangeError(`Plan ${name} must be a whole number from ${String(minimum)} through ${String(maximum)}`);
+  }
+}
+function distinctIds(rows) {
+  const seen = /* @__PURE__ */ new Set();
+  return rows.filter((row) => {
+    const id = idOf(row);
+    if (seen.has(id))
+      return false;
+    seen.add(id);
+    return true;
+  });
+}
+function generateValue(random, column) {
+  if (column.nullable && random.chance(0.15))
+    return null;
+  switch (column.type) {
+    case "integer":
+      return random.int(101) - 50;
+    case "real":
+      return (random.int(161) - 80) / 4;
+    case "text":
+      return random.pick(TEXT_POOL);
+    case "boolean":
+      return random.chance(0.5);
+  }
+}
+function generateRow(random, table, keySpace) {
+  const row = { id: 1 + random.int(keySpace) };
+  for (const column of table.columns)
+    row[column.name] = generateValue(random, column);
+  return row;
+}
+function generatePredicate(random, table, keySpace, depth) {
+  const roll = random.next();
+  if (depth > 0 && roll < 0.25) {
+    return {
+      kind: random.chance(0.5) ? "and" : "or",
+      left: generatePredicate(random, table, keySpace, depth - 1),
+      right: generatePredicate(random, table, keySpace, depth - 1)
+    };
+  }
+  if (depth > 0 && roll < 0.35) {
+    return { kind: "not", inner: generatePredicate(random, table, keySpace, depth - 1) };
+  }
+  if (roll < 0.4)
+    return { kind: "literal", value: random.chance(0.5) };
+  if (roll < 0.55) {
+    return { kind: "isNull", column: random.pick(table.columns).name, negated: random.chance(0.5) };
+  }
+  if (roll < 0.7) {
+    return {
+      kind: "compare",
+      column: "id",
+      op: random.pick(["=", "<>", "<", "<=", ">", ">="]),
+      value: 1 + random.int(keySpace)
+    };
+  }
+  const column = random.pick(table.columns);
+  const value = random.chance(0.05) ? null : generateValue(random, { ...column, nullable: false });
+  const operators = column.type === "boolean" ? ["=", "<>"] : ["=", "<>", "<", "<=", ">", ">="];
+  return { kind: "compare", column: column.name, op: random.pick(operators), value };
+}
+function generateAssignments(random, table) {
+  const count = 1 + random.int(Math.min(2, table.columns.length));
+  const chosen = /* @__PURE__ */ new Set();
+  const assignments = [];
+  while (assignments.length < count) {
+    const column = random.pick(table.columns);
+    if (chosen.has(column.name))
+      continue;
+    chosen.add(column.name);
+    if (column.type === "integer" && random.chance(0.5)) {
+      assignments.push({ kind: "increment", column: column.name, by: random.int(21) - 10 });
+    } else {
+      assignments.push({ kind: "set", column: column.name, value: generateValue(random, column) });
+    }
+  }
+  return assignments;
+}
+function generateKeyedMutation(random, table, id) {
+  const roll = random.next();
+  if (roll < 0.35)
+    return { kind: "insert", row: { ...generateRow(random, table, 1), id } };
+  if (roll < 0.6)
+    return { kind: "upsert", row: { ...generateRow(random, table, 1), id } };
+  if (roll < 0.85)
+    return { kind: "updateKey", id, assignments: generateAssignments(random, table) };
+  return { kind: "deleteKey", id };
+}
+function parseInteractionPlan(source) {
+  const value = JSON.parse(source);
+  if (!isRecord(value))
+    throw new TypeError("Interaction plan must be an object");
+  if (value.version !== 1)
+    throw new TypeError("Interaction plan version must be 1");
+  if (!Number.isSafeInteger(value.seed))
+    throw new TypeError("Interaction plan seed must be a whole number");
+  const connections = value.connections;
+  if (typeof connections !== "number" || !Number.isSafeInteger(connections) || connections < 1 || connections > 16) {
+    throw new TypeError("Interaction plan connection count is invalid");
+  }
+  const interactions = value.interactions;
+  if (!Array.isArray(interactions) || interactions.length > 5e5) {
+    throw new TypeError("Interaction plan interactions must be a bounded array");
+  }
+  interactions.forEach((interaction, index) => {
+    validateInteraction(interaction, connections, index);
+  });
+  return value;
+}
+function isRecord(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function validateInteraction(value, connections, index) {
+  const where = `interaction ${String(index)}`;
+  if (!isRecord(value))
+    throw new TypeError(`${where} must be an object`);
+  const kind = value.kind;
+  const checkConnection = (field) => {
+    const number = value[field];
+    if (typeof number !== "number" || !Number.isSafeInteger(number) || number < 0 || number >= connections) {
+      throw new TypeError(`${where} has an invalid ${field}`);
+    }
+  };
+  const checkTableName = (field = "table") => {
+    if (typeof value[field] !== "string" || !/^[a-z][a-z0-9_]*$/u.test(value[field])) {
+      throw new TypeError(`${where} has an invalid ${field}`);
+    }
+  };
+  switch (kind) {
+    case "createTable": {
+      checkConnection("connection");
+      validateTable(value.table, where);
+      if (typeof value.expectExisting !== "boolean")
+        throw new TypeError(`${where} expectExisting must be boolean`);
+      return;
+    }
+    case "insert": {
+      checkConnection("connection");
+      checkTableName();
+      if (!Array.isArray(value.rows) || value.rows.length > 1e3)
+        throw new TypeError(`${where} rows are unbounded`);
+      value.rows.forEach((row) => {
+        validateRow(row, where);
+      });
+      if (typeof value.viaParameters !== "boolean")
+        throw new TypeError(`${where} viaParameters must be boolean`);
+      return;
+    }
+    case "update": {
+      checkConnection("connection");
+      checkTableName();
+      validatePredicate(value.predicate, where, 0);
+      validateAssignments(value.assignments, where);
+      return;
+    }
+    case "delete":
+    case "partition": {
+      checkConnection("connection");
+      checkTableName();
+      validatePredicate(value.predicate, where, 0);
+      return;
+    }
+    case "select": {
+      checkConnection("connection");
+      checkTableName();
+      validatePredicate(value.predicate, where, 0);
+      const limit = value.limit;
+      if (limit !== null && (typeof limit !== "number" || !Number.isSafeInteger(limit) || limit < 0)) {
+        throw new TypeError(`${where} limit is invalid`);
+      }
+      if (typeof value.descending !== "boolean")
+        throw new TypeError(`${where} descending must be boolean`);
+      return;
+    }
+    case "unionAll": {
+      checkConnection("connection");
+      checkTableName();
+      validatePredicate(value.left, where, 0);
+      validatePredicate(value.right, where, 0);
+      return;
+    }
+    case "createIndex": {
+      checkConnection("connection");
+      checkTableName();
+      checkTableName("name");
+      if (!Array.isArray(value.columns) || value.columns.length === 0 || value.columns.length > 4) {
+        throw new TypeError(`${where} index columns are invalid`);
+      }
+      return;
+    }
+    case "dropTable": {
+      checkConnection("connection");
+      checkTableName();
+      if (typeof value.expectMissing !== "boolean")
+        throw new TypeError(`${where} expectMissing must be boolean`);
+      return;
+    }
+    case "transaction": {
+      checkConnection("connection");
+      checkConnection("observer");
+      checkTableName();
+      if (!Array.isArray(value.statements) || value.statements.length === 0 || value.statements.length > 100) {
+        throw new TypeError(`${where} statements are invalid`);
+      }
+      for (const statement of value.statements) {
+        if (!isRecord(statement))
+          throw new TypeError(`${where} statement must be an object`);
+        if (statement.kind === "insert") {
+          if (!Array.isArray(statement.rows))
+            throw new TypeError(`${where} insert rows are invalid`);
+          statement.rows.forEach((row) => {
+            validateRow(row, where);
+          });
+        } else if (statement.kind === "update") {
+          validatePredicate(statement.predicate, where, 0);
+          validateAssignments(statement.assignments, where);
+        } else if (statement.kind === "delete") {
+          validatePredicate(statement.predicate, where, 0);
+        } else
+          throw new TypeError(`${where} statement kind is invalid`);
+      }
+      if (value.outcome !== "commit" && value.outcome !== "rollback") {
+        throw new TypeError(`${where} outcome is invalid`);
+      }
+      return;
+    }
+    case "concurrent": {
+      checkTableName();
+      if (!Array.isArray(value.operations) || value.operations.length > connections * 8) {
+        throw new TypeError(`${where} operations are unbounded`);
+      }
+      const ids = /* @__PURE__ */ new Set();
+      for (const operation of value.operations) {
+        if (!isRecord(operation))
+          throw new TypeError(`${where} operation must be an object`);
+        const target = operation.connection;
+        if (typeof target !== "number" || !Number.isSafeInteger(target) || target < 0 || target >= connections) {
+          throw new TypeError(`${where} operation connection is invalid`);
+        }
+        const id = validateKeyedMutation(operation.mutation, where);
+        if (ids.has(id))
+          throw new TypeError(`${where} concurrent operations must target distinct keys`);
+        ids.add(id);
+      }
+      if (!Array.isArray(value.readers))
+        throw new TypeError(`${where} readers must be an array`);
+      for (const reader of value.readers) {
+        if (typeof reader !== "number" || !Number.isSafeInteger(reader) || reader < 0 || reader >= connections) {
+          throw new TypeError(`${where} reader is invalid`);
+        }
+      }
+      return;
+    }
+    case "fault": {
+      checkConnection("connection");
+      checkTableName();
+      validateKeyedMutation(value.mutation, where);
+      if (typeof value.point !== "string" || !FAULT_POINTS.includes(value.point)) {
+        throw new TypeError(`${where} fault point is invalid`);
+      }
+      return;
+    }
+    case "reopen": {
+      checkConnection("connection");
+      return;
+    }
+    case "maintenance": {
+      checkConnection("connection");
+      checkTableName();
+      return;
+    }
+    case "checkpoint":
+      return;
+    default:
+      throw new TypeError(`${where} kind is invalid: ${String(kind)}`);
+  }
+}
+function validateTable(value, where) {
+  if (!isRecord(value) || typeof value.name !== "string" || !/^[a-z][a-z0-9_]*$/u.test(value.name)) {
+    throw new TypeError(`${where} table is invalid`);
+  }
+  if (!Array.isArray(value.columns) || value.columns.length === 0 || value.columns.length > 32) {
+    throw new TypeError(`${where} table columns are invalid`);
+  }
+  for (const column of value.columns) {
+    if (!isRecord(column) || typeof column.name !== "string" || !/^[a-z][a-z0-9_]*$/u.test(column.name) || column.name === "id" || !["integer", "real", "text", "boolean"].includes(column.type) || typeof column.nullable !== "boolean") {
+      throw new TypeError(`${where} table column is invalid`);
+    }
+  }
+}
+function validateRow(value, where) {
+  if (!isRecord(value))
+    throw new TypeError(`${where} row must be an object`);
+  if (typeof value.id !== "number" || !Number.isSafeInteger(value.id)) {
+    throw new TypeError(`${where} row id must be a whole number`);
+  }
+  for (const cell of Object.values(value))
+    validateValue(cell, where);
+}
+function validateValue(value, where) {
+  if (value === null || typeof value === "string" || typeof value === "boolean")
+    return;
+  if (typeof value === "number" && Number.isFinite(value))
+    return;
+  throw new TypeError(`${where} has an invalid value`);
+}
+function validatePredicate(value, where, depth) {
+  if (depth > 32)
+    throw new TypeError(`${where} predicate is too deep`);
+  if (!isRecord(value))
+    throw new TypeError(`${where} predicate must be an object`);
+  switch (value.kind) {
+    case "compare":
+      if (typeof value.column !== "string")
+        throw new TypeError(`${where} predicate column is invalid`);
+      if (!["=", "<>", "<", "<=", ">", ">="].includes(value.op)) {
+        throw new TypeError(`${where} predicate operator is invalid`);
+      }
+      validateValue(value.value, where);
+      return;
+    case "isNull":
+      if (typeof value.column !== "string" || typeof value.negated !== "boolean") {
+        throw new TypeError(`${where} IS NULL predicate is invalid`);
+      }
+      return;
+    case "and":
+    case "or":
+      validatePredicate(value.left, where, depth + 1);
+      validatePredicate(value.right, where, depth + 1);
+      return;
+    case "not":
+      validatePredicate(value.inner, where, depth + 1);
+      return;
+    case "literal":
+      if (typeof value.value !== "boolean")
+        throw new TypeError(`${where} literal predicate is invalid`);
+      return;
+    default:
+      throw new TypeError(`${where} predicate kind is invalid`);
+  }
+}
+function validateAssignments(value, where) {
+  if (!Array.isArray(value) || value.length === 0 || value.length > 32) {
+    throw new TypeError(`${where} assignments are invalid`);
+  }
+  for (const assignment of value) {
+    if (!isRecord(assignment) || typeof assignment.column !== "string" || assignment.column === "id") {
+      throw new TypeError(`${where} assignment is invalid`);
+    }
+    if (assignment.kind === "set")
+      validateValue(assignment.value, where);
+    else if (assignment.kind === "increment") {
+      if (typeof assignment.by !== "number" || !Number.isSafeInteger(assignment.by)) {
+        throw new TypeError(`${where} increment is invalid`);
+      }
+    } else
+      throw new TypeError(`${where} assignment kind is invalid`);
+  }
+}
+function validateKeyedMutation(value, where) {
+  if (!isRecord(value))
+    throw new TypeError(`${where} mutation must be an object`);
+  if (value.kind === "insert" || value.kind === "upsert") {
+    validateRow(value.row, where);
+    return value.row.id;
+  }
+  if (value.kind === "updateKey" || value.kind === "deleteKey") {
+    if (typeof value.id !== "number" || !Number.isSafeInteger(value.id)) {
+      throw new TypeError(`${where} mutation id is invalid`);
+    }
+    if (value.kind === "updateKey")
+      validateAssignments(value.assignments, where);
+    return value.id;
+  }
+  throw new TypeError(`${where} mutation kind is invalid`);
+}
+class ShadowModel {
+  tables = /* @__PURE__ */ new Map();
+  clone() {
+    const copy = new ShadowModel();
+    for (const [name, table] of this.tables) {
+      copy.tables.set(name, { definition: table.definition, rows: new Map(table.rows) });
+    }
+    return copy;
+  }
+  table(name) {
+    const table = this.tables.get(name);
+    if (table === void 0)
+      throw new Error(`Model has no table ${name}`);
+    return table;
+  }
+  columns(name) {
+    return ["id", ...this.table(name).definition.columns.map((column) => column.name)];
+  }
+  matching(name, predicate) {
+    return this.sorted(name).filter((row) => evaluate(predicate, row) === true);
+  }
+  sorted(name) {
+    return [...this.table(name).rows.values()].sort((left, right) => idOf(left) - idOf(right));
+  }
+  insert(name, rows) {
+    const table = this.table(name);
+    const staged = /* @__PURE__ */ new Set();
+    for (const row of rows) {
+      const id = idOf(row);
+      if (table.rows.has(id) || staged.has(id))
+        return false;
+      staged.add(id);
+    }
+    for (const row of rows)
+      table.rows.set(idOf(row), completeRow(table.definition, row));
+    return true;
+  }
+  update(name, predicate, assignments) {
+    const table = this.table(name);
+    let count = 0;
+    for (const row of this.matching(name, predicate)) {
+      table.rows.set(idOf(row), assign(row, assignments));
+      count++;
+    }
+    return count;
+  }
+  delete(name, predicate) {
+    const table = this.table(name);
+    let count = 0;
+    for (const row of this.matching(name, predicate)) {
+      table.rows.delete(idOf(row));
+      count++;
+    }
+    return count;
+  }
+  applyKeyed(name, mutation) {
+    const table = this.table(name);
+    switch (mutation.kind) {
+      case "insert":
+        return this.insert(name, [mutation.row]);
+      case "upsert":
+        table.rows.set(idOf(mutation.row), completeRow(table.definition, mutation.row));
+        return true;
+      case "updateKey": {
+        const row = table.rows.get(mutation.id);
+        if (row !== void 0)
+          table.rows.set(mutation.id, assign(row, mutation.assignments));
+        return true;
+      }
+      case "deleteKey":
+        table.rows.delete(mutation.id);
+        return true;
+    }
+  }
+}
+function idOf(row) {
+  const id = row.id;
+  if (typeof id !== "number")
+    throw new Error("Row without a numeric id");
+  return id;
+}
+function completeRow(definition, row) {
+  const complete = { id: idOf(row) };
+  for (const column of definition.columns)
+    complete[column.name] = row[column.name] ?? null;
+  return complete;
+}
+function assign(row, assignments) {
+  const next = { ...row };
+  for (const assignment of assignments) {
+    if (assignment.kind === "set")
+      next[assignment.column] = assignment.value;
+    else {
+      const current = row[assignment.column];
+      next[assignment.column] = typeof current === "number" ? current + assignment.by : null;
+    }
+  }
+  return next;
+}
+function compareValues(left, right) {
+  if (typeof left === "number" && typeof right === "number")
+    return left < right ? -1 : left > right ? 1 : 0;
+  if (typeof left === "string" && typeof right === "string")
+    return compareCodepoints(left, right);
+  if (typeof left === "boolean" && typeof right === "boolean")
+    return Number(left) - Number(right);
+  throw new Error(`Model cannot compare ${typeof left} with ${typeof right}`);
+}
+function compareCodepoints(left, right) {
+  let leftIndex = 0;
+  let rightIndex = 0;
+  while (leftIndex < left.length && rightIndex < right.length) {
+    const leftPoint = left.codePointAt(leftIndex) ?? 0;
+    const rightPoint = right.codePointAt(rightIndex) ?? 0;
+    if (leftPoint !== rightPoint)
+      return leftPoint - rightPoint;
+    leftIndex += leftPoint > 65535 ? 2 : 1;
+    rightIndex += rightPoint > 65535 ? 2 : 1;
+  }
+  return left.length - leftIndex - (right.length - rightIndex);
+}
+function evaluate(predicate, row) {
+  switch (predicate.kind) {
+    case "literal":
+      return predicate.value;
+    case "isNull": {
+      const isNull = (row[predicate.column] ?? null) === null;
+      return predicate.negated ? !isNull : isNull;
+    }
+    case "compare": {
+      const value = row[predicate.column] ?? null;
+      if (value === null || predicate.value === null)
+        return null;
+      const order = compareValues(value, predicate.value);
+      switch (predicate.op) {
+        case "=":
+          return order === 0;
+        case "<>":
+          return order !== 0;
+        case "<":
+          return order < 0;
+        case "<=":
+          return order <= 0;
+        case ">":
+          return order > 0;
+        case ">=":
+          return order >= 0;
+      }
+    }
+    case "not": {
+      const inner = evaluate(predicate.inner, row);
+      return inner === null ? null : !inner;
+    }
+    case "and": {
+      const left = evaluate(predicate.left, row);
+      const right = evaluate(predicate.right, row);
+      if (left === false || right === false)
+        return false;
+      if (left === null || right === null)
+        return null;
+      return true;
+    }
+    case "or": {
+      const left = evaluate(predicate.left, row);
+      const right = evaluate(predicate.right, row);
+      if (left === true || right === true)
+        return true;
+      if (left === null || right === null)
+        return null;
+      return false;
+    }
+  }
+}
+function quote(identifier) {
+  return `"${identifier.replaceAll('"', '""')}"`;
+}
+function renderLiteral(value) {
+  if (value === null)
+    return "NULL";
+  if (typeof value === "boolean")
+    return value ? "TRUE" : "FALSE";
+  if (typeof value === "number") {
+    if (Number.isInteger(value))
+      return String(value);
+    const text = value.toFixed(2).replace(/0$/u, "");
+    return text;
+  }
+  return `'${value.replaceAll("'", "''")}'`;
+}
+function renderPredicate(predicate) {
+  switch (predicate.kind) {
+    case "literal":
+      return predicate.value ? "TRUE" : "FALSE";
+    case "isNull":
+      return `${quote(predicate.column)} IS ${predicate.negated ? "NOT " : ""}NULL`;
+    case "compare":
+      return `${quote(predicate.column)} ${predicate.op} ${renderLiteral(predicate.value)}`;
+    case "not":
+      return `NOT (${renderPredicate(predicate.inner)})`;
+    case "and":
+      return `(${renderPredicate(predicate.left)} AND ${renderPredicate(predicate.right)})`;
+    case "or":
+      return `(${renderPredicate(predicate.left)} OR ${renderPredicate(predicate.right)})`;
+  }
+}
+function renderAssignments(assignments) {
+  return assignments.map((assignment) => assignment.kind === "set" ? `${quote(assignment.column)} = ${renderLiteral(assignment.value)}` : `${quote(assignment.column)} = ${quote(assignment.column)} + ${renderLiteral(assignment.by)}`).join(", ");
+}
+function sqlType(type) {
+  switch (type) {
+    case "integer":
+      return "INTEGER";
+    case "real":
+      return "DOUBLE PRECISION";
+    case "text":
+      return "TEXT";
+    case "boolean":
+      return "BOOLEAN";
+  }
+}
+function renderCreateTable(table) {
+  const columns = table.columns.map((column) => `${quote(column.name)} ${sqlType(column.type)}${column.nullable ? "" : " NOT NULL"}`);
+  return `CREATE TABLE ${quote(table.name)} (id INTEGER PRIMARY KEY, ${columns.join(", ")})`;
+}
+function renderInsert(table, columns, rows, viaParameters) {
+  const params = [];
+  const tuples = rows.map((row) => {
+    const cells = columns.map((column) => {
+      const value = row[column] ?? null;
+      if (!viaParameters)
+        return renderLiteral(value);
+      params.push(value);
+      return "?";
+    });
+    return `(${cells.join(", ")})`;
+  });
+  return {
+    sql: `INSERT INTO ${quote(table)} (${columns.map(quote).join(", ")}) VALUES ${tuples.join(", ")}`,
+    params
+  };
+}
+function renderKeyed(table, columns, mutation) {
+  switch (mutation.kind) {
+    case "insert":
+      return renderInsert(table, columns, [mutation.row], false).sql;
+    case "upsert": {
+      const insert = renderInsert(table, columns, [mutation.row], false).sql;
+      const updates = columns.filter((column) => column !== "id").map((column) => `${quote(column)} = excluded.${quote(column)}`).join(", ");
+      return `${insert} ON CONFLICT (id) DO UPDATE SET ${updates}`;
+    }
+    case "updateKey":
+      return `UPDATE ${quote(table)} SET ${renderAssignments(mutation.assignments)} WHERE id = ${String(mutation.id)}`;
+    case "deleteKey":
+      return `DELETE FROM ${quote(table)} WHERE id = ${String(mutation.id)}`;
+  }
+}
+async function runInteractionPlan(plan, driver, options = {}) {
+  parseInteractionPlan(JSON.stringify(plan));
+  const runner = new PlanRunner(plan, driver, options.traceLength ?? 40);
+  try {
+    return await runner.run();
+  } finally {
+    await driver.close?.();
+  }
+}
+class PlanRunner {
+  #plan;
+  #driver;
+  #traceLength;
+  #trace = [];
+  #connections = [];
+  #model = new ShadowModel();
+  #index = 0;
+  #statements = 0;
+  #queries = 0;
+  #acceptedWrites = 0;
+  #rejectedConflicts = 0;
+  #expectedFailures = 0;
+  #faultsInjected = 0;
+  #faultsSkipped = 0;
+  #reopens = 0;
+  #checkpoints = 0;
+  constructor(plan, driver, traceLength) {
+    this.#plan = plan;
+    this.#driver = driver;
+    this.#traceLength = traceLength;
+  }
+  async run() {
+    for (let index = 0; index < this.#plan.connections; index++) {
+      this.#connections.push(await this.#driver.open(index));
+    }
+    let judged = 0;
+    let stoppedBy;
+    for (const [index, interaction] of this.#plan.interactions.entries()) {
+      this.#index = index;
+      try {
+        await this.#step(interaction);
+      } catch (error) {
+        if (!isStoreUnresponsive(error))
+          throw error;
+        stoppedBy = describeError(error);
+        break;
+      }
+      judged += 1;
+    }
+    let rows = 0;
+    for (const table of this.#model.tables.values())
+      rows += table.rows.size;
+    return {
+      seed: this.#plan.seed,
+      interactions: judged,
+      statements: this.#statements,
+      queries: this.#queries,
+      acceptedWrites: this.#acceptedWrites,
+      rejectedConflicts: this.#rejectedConflicts,
+      expectedFailures: this.#expectedFailures,
+      faultsInjected: this.#faultsInjected,
+      faultsSkipped: this.#faultsSkipped,
+      reopens: this.#reopens,
+      checkpoints: this.#checkpoints,
+      tablesAtEnd: this.#model.tables.size,
+      rowsAtEnd: rows,
+      transientsAccepted: stoppedBy === void 0 ? 0 : 1,
+      stoppedBy
+    };
+  }
+  #connection(index) {
+    const connection = this.#connections[index];
+    if (connection === void 0)
+      throw new Error(`No connection ${String(index)}`);
+    return connection;
+  }
+  #record(sql) {
+    this.#trace.push(sql);
+    if (this.#trace.length > this.#traceLength)
+      this.#trace.shift();
+  }
+  #fail(message, cause) {
+    const interaction = this.#plan.interactions[this.#index];
+    if (interaction === void 0)
+      throw new Error(message, { cause });
+    throw new InteractionFailure(message, this.#index, interaction, this.#trace, { cause });
+  }
+  async #execute(connection, sql, params) {
+    this.#record(`[${String(connection)}] ${sql}${params === void 0 ? "" : ` -- ${JSON.stringify(params)}`}`);
+    this.#statements++;
+    return this.#connection(connection).execute(sql, params);
+  }
+  async #query(connection, sql) {
+    this.#record(`[${String(connection)}] ${sql}`);
+    this.#queries++;
+    return this.#connection(connection).query(sql);
+  }
+  async #step(interaction) {
+    switch (interaction.kind) {
+      case "createTable":
+        return this.#createTable(interaction);
+      case "insert":
+        return this.#insert(interaction);
+      case "update":
+        return this.#update(interaction);
+      case "delete":
+        return this.#delete(interaction);
+      case "select":
+        return this.#select(interaction);
+      case "partition":
+        return this.#partition(interaction);
+      case "unionAll":
+        return this.#unionAll(interaction);
+      case "createIndex":
+        return this.#createIndex(interaction);
+      case "dropTable":
+        return this.#dropTable(interaction);
+      case "transaction":
+        return this.#transaction(interaction);
+      case "concurrent":
+        return this.#concurrent(interaction);
+      case "fault":
+        return this.#fault(interaction);
+      case "reopen":
+        return this.#reopen(interaction.connection);
+      case "maintenance":
+        return this.#maintenance(interaction);
+      case "checkpoint":
+        return this.#checkpoint();
+    }
+  }
+  async #createTable(interaction) {
+    const sql = renderCreateTable(interaction.table);
+    const exists = this.#model.tables.has(interaction.table.name);
+    if (interaction.expectExisting !== exists) {
+      this.#fail(`Plan expects table ${interaction.table.name} ${exists ? "absent" : "present"}`);
+    }
+    const outcome = await this.#attempt(interaction.connection, sql);
+    if (exists) {
+      if (outcome.error === void 0)
+        this.#fail("double-create-failure: creating an existing table succeeded");
+      this.#expectedFailures++;
+      return;
+    }
+    if (outcome.error !== void 0)
+      this.#fail(`CREATE TABLE failed: ${describeError(outcome.error)}`, outcome.error);
+    this.#model.tables.set(interaction.table.name, {
+      definition: interaction.table,
+      rows: /* @__PURE__ */ new Map()
+    });
+  }
+  async #insert(interaction) {
+    const columns = this.#model.columns(interaction.table);
+    const rendered = renderInsert(interaction.table, columns, interaction.rows, interaction.viaParameters);
+    const before = this.#model.clone();
+    const accepted = this.#model.insert(interaction.table, interaction.rows);
+    const outcome = await this.#attempt(interaction.connection, rendered.sql, rendered.params);
+    if (!accepted) {
+      this.#model = before;
+      if (outcome.error === void 0)
+        this.#fail("insert-select: a duplicate primary key was accepted");
+      if (!isUniqueViolation(outcome.error)) {
+        this.#fail(`duplicate insert failed with the wrong error: ${describeError(outcome.error)}`, outcome.error);
+      }
+      this.#expectedFailures++;
+      await this.#expectRows(interaction.connection, interaction.table, this.#model.sorted(interaction.table), "after a rejected insert");
+      return;
+    }
+    if (outcome.error !== void 0)
+      this.#fail(`INSERT failed: ${describeError(outcome.error)}`, outcome.error);
+    if (outcome.result?.rowCount !== interaction.rows.length) {
+      this.#fail(`INSERT reported ${String(outcome.result?.rowCount)} rows, expected ${String(interaction.rows.length)}`);
+    }
+    this.#acceptedWrites++;
+    const ids = interaction.rows.map((row) => String(idOf(row))).join(", ");
+    const predicate = `id IN (${ids})`;
+    const expected = this.#model.sorted(interaction.table).filter((row) => interaction.rows.some((inserted) => idOf(inserted) === idOf(row)));
+    await this.#expectRows(interaction.connection, interaction.table, expected, "insert-select", predicate);
+  }
+  async #update(interaction) {
+    const before = this.#model.sorted(interaction.table);
+    const expected = this.#model.update(interaction.table, interaction.predicate, interaction.assignments);
+    const sql = `UPDATE ${quote(interaction.table)} SET ${renderAssignments(interaction.assignments)} WHERE ${renderPredicate(interaction.predicate)}`;
+    const result = await this.#execute(interaction.connection, sql).catch((error) => this.#fail(`UPDATE failed: ${describeError(error)}`, error));
+    if (result.rowCount !== expected) {
+      this.#fail(`update-count: UPDATE reported ${String(result.rowCount)} rows, model matched ${String(expected)}
+  model rows before: ${canonicalRows(before, this.#model.columns(interaction.table))}`);
+    }
+    this.#acceptedWrites++;
+    await this.#expectRows(interaction.connection, interaction.table, this.#model.sorted(interaction.table), "after UPDATE");
+  }
+  async #delete(interaction) {
+    const before = this.#model.sorted(interaction.table);
+    const expected = this.#model.delete(interaction.table, interaction.predicate);
+    const where = renderPredicate(interaction.predicate);
+    const result = await this.#execute(interaction.connection, `DELETE FROM ${quote(interaction.table)} WHERE ${where}`).catch((error) => this.#fail(`DELETE failed: ${describeError(error)}`, error));
+    if (result.rowCount !== expected) {
+      this.#fail(`delete-count: DELETE reported ${String(result.rowCount)} rows, model matched ${String(expected)}
+  model rows before: ${canonicalRows(before, this.#model.columns(interaction.table))}`);
+    }
+    this.#acceptedWrites++;
+    const survivors = await this.#count(interaction.connection, interaction.table, where);
+    if (survivors !== 0)
+      this.#fail(`delete-select: ${String(survivors)} rows still match ${where}`);
+  }
+  async #select(interaction) {
+    const matching = this.#model.matching(interaction.table, interaction.predicate);
+    if (interaction.descending)
+      matching.reverse();
+    const expected = interaction.limit === null ? matching : matching.slice(0, interaction.limit);
+    const order = `ORDER BY id${interaction.descending ? " DESC" : ""}`;
+    const limit = interaction.limit === null ? "" : ` LIMIT ${String(interaction.limit)}`;
+    const sql = `SELECT * FROM ${quote(interaction.table)} WHERE ${renderPredicate(interaction.predicate)} ${order}${limit}`;
+    const result = await this.#query(interaction.connection, sql).catch((error) => this.#fail(`SELECT failed: ${describeError(error)}`, error));
+    this.#compareRows(result, expected, this.#model.columns(interaction.table), interaction.limit === null ? "select" : "select-limit");
+  }
+  async #partition(interaction) {
+    const where = renderPredicate(interaction.predicate);
+    const total = await this.#count(interaction.connection, interaction.table, "TRUE");
+    const positive = await this.#count(interaction.connection, interaction.table, where);
+    const negative = await this.#count(interaction.connection, interaction.table, `NOT (${where})`);
+    const unknown = await this.#count(interaction.connection, interaction.table, `(${where}) IS NULL`);
+    if (positive + negative + unknown !== total) {
+      this.#fail(`where-true-false-null: ${String(positive)} + ${String(negative)} + ${String(unknown)} != ${String(total)} for ${where}`);
+    }
+    const rows = this.#model.sorted(interaction.table);
+    const modelPositive = rows.filter((row) => evaluate(interaction.predicate, row) === true).length;
+    const modelUnknown = rows.filter((row) => evaluate(interaction.predicate, row) === null).length;
+    if (total !== rows.length || positive !== modelPositive || unknown !== modelUnknown) {
+      this.#fail(`where-true-false-null: engine ${String(positive)}/${String(negative)}/${String(unknown)} of ${String(total)}, model ${String(modelPositive)}/${String(rows.length - modelPositive - modelUnknown)}/${String(modelUnknown)} of ${String(rows.length)} for ${where}`);
+    }
+  }
+  async #unionAll(interaction) {
+    const left = renderPredicate(interaction.left);
+    const right = renderPredicate(interaction.right);
+    const table = quote(interaction.table);
+    const sql = `SELECT id FROM ${table} WHERE ${left} UNION ALL SELECT id FROM ${table} WHERE ${right}`;
+    const result = await this.#query(interaction.connection, sql).catch((error) => this.#fail(`UNION ALL failed: ${describeError(error)}`, error));
+    const expected = this.#model.matching(interaction.table, interaction.left).length + this.#model.matching(interaction.table, interaction.right).length;
+    if (result.rows.length !== expected) {
+      this.#fail(`union-all-cardinality: ${String(result.rows.length)} rows, expected ${String(expected)}
+  received ids: ${result.rows.map((row) => String(row.id)).join(", ")}
+  model rows: ${canonicalRows(this.#model.sorted(interaction.table), this.#model.columns(interaction.table))}`);
+    }
+  }
+  async #createIndex(interaction) {
+    const sql = `CREATE INDEX ${quote(interaction.name)} ON ${quote(interaction.table)} (${interaction.columns.map(quote).join(", ")})`;
+    await this.#execute(interaction.connection, sql).catch((error) => this.#fail(`CREATE INDEX failed: ${describeError(error)}`, error));
+    await this.#expectRows(interaction.connection, interaction.table, this.#model.sorted(interaction.table), "after CREATE INDEX");
+  }
+  async #dropTable(interaction) {
+    const exists = this.#model.tables.has(interaction.table);
+    if (interaction.expectMissing === exists) {
+      this.#fail(`Plan expects table ${interaction.table} ${exists ? "absent" : "present"}`);
+    }
+    const outcome = await this.#attempt(interaction.connection, `DROP TABLE ${quote(interaction.table)}`);
+    if (!exists) {
+      if (outcome.error === void 0)
+        this.#fail("dropping a missing table succeeded");
+      this.#expectedFailures++;
+      return;
+    }
+    if (outcome.error !== void 0)
+      this.#fail(`DROP TABLE failed: ${describeError(outcome.error)}`, outcome.error);
+    this.#model.tables.delete(interaction.table);
+    const select = await this.#attemptQuery(interaction.connection, `SELECT * FROM ${quote(interaction.table)}`);
+    if (select.error === void 0)
+      this.#fail("drop-select: a dropped table still answers queries");
+  }
+  async #transaction(interaction) {
+    const committed = this.#model.clone();
+    try {
+      await this.#runTransaction(interaction, committed);
+      return;
+    } catch (error) {
+      if (!(error instanceof RefusedTransaction))
+        throw error;
+      this.#model = committed;
+      if (error.expired) {
+        this.#expectedFailures++;
+        await this.#execute(interaction.connection, "ROLLBACK").catch((rollback) => this.#fail(`ROLLBACK after an expired transaction failed: ${describeError(rollback)}`, rollback));
+      } else {
+        this.#rejectedConflicts++;
+      }
+      await this.#expectRows(interaction.connection, interaction.table, this.#model.sorted(interaction.table), `after a refused transaction (${error.reason})`);
+    }
+  }
+  #refuseTransaction(step, error) {
+    if (isExpiredTransaction(error))
+      throw new RefusedTransaction("idle rollback", error);
+    if (isConflict(error))
+      throw new RefusedTransaction("lost commit race", error);
+    this.#fail(`${step} failed: ${describeError(error)}`, error);
+  }
+  async #expectRowsInTransaction(connection, table, expected, context) {
+    try {
+      await this.#expectRows(connection, table, expected, context);
+    } catch (error) {
+      if (isExpiredTransaction(error) || isConflict(error))
+        this.#refuseTransaction(context, error);
+      throw error;
+    }
+  }
+  async #runTransaction(interaction, committed) {
+    const columns = this.#model.columns(interaction.table);
+    await this.#execute(interaction.connection, "BEGIN").catch((error) => this.#refuseTransaction("BEGIN", error));
+    let poisoned = false;
+    for (const statement of interaction.statements) {
+      if (statement.kind === "insert") {
+        const accepted = this.#model.insert(interaction.table, statement.rows);
+        const rendered = renderInsert(interaction.table, columns, statement.rows, true);
+        const outcome = await this.#attempt(interaction.connection, rendered.sql, rendered.params);
+        if (accepted && outcome.error !== void 0)
+          this.#refuseTransaction("INSERT inside a transaction", outcome.error);
+        if (!accepted) {
+          if (outcome.error === void 0)
+            this.#fail("a duplicate primary key was accepted inside a transaction");
+          this.#expectedFailures++;
+          poisoned = true;
+          break;
+        }
+      } else if (statement.kind === "update") {
+        this.#model.update(interaction.table, statement.predicate, statement.assignments);
+        const sql = `UPDATE ${quote(interaction.table)} SET ${renderAssignments(statement.assignments)} WHERE ${renderPredicate(statement.predicate)}`;
+        await this.#execute(interaction.connection, sql).catch((error) => this.#refuseTransaction("UPDATE inside a transaction", error));
+      } else {
+        this.#model.delete(interaction.table, statement.predicate);
+        await this.#execute(interaction.connection, `DELETE FROM ${quote(interaction.table)} WHERE ${renderPredicate(statement.predicate)}`).catch((error) => this.#refuseTransaction("DELETE inside a transaction", error));
+      }
+    }
+    if (!poisoned) {
+      await this.#expectRowsInTransaction(interaction.connection, interaction.table, this.#model.sorted(interaction.table), "inside an open transaction (owner)");
+      if (interaction.observer !== interaction.connection) {
+        await this.#expectRows(interaction.observer, interaction.table, committed.sorted(interaction.table), "inside an open transaction (observer)");
+      }
+    }
+    const end = poisoned ? "ROLLBACK" : interaction.outcome === "commit" ? "COMMIT" : "ROLLBACK";
+    await this.#execute(interaction.connection, end).catch((error) => this.#refuseTransaction(end, error));
+    if (end === "ROLLBACK")
+      this.#model = committed;
+    else
+      this.#acceptedWrites++;
+    await this.#expectRows(interaction.connection, interaction.table, this.#model.sorted(interaction.table), `after ${end}`);
+    if (interaction.observer !== interaction.connection) {
+      await this.#expectRows(interaction.observer, interaction.table, this.#model.sorted(interaction.table), `after ${end} (observer)`);
+    }
+  }
+  async #concurrent(interaction) {
+    const columns = this.#model.columns(interaction.table);
+    const before = this.#model.clone();
+    const writes = interaction.operations.map(async (operation) => {
+      const sql = renderKeyed(interaction.table, columns, operation.mutation);
+      const outcome = await this.#attempt(operation.connection, sql);
+      return { operation, outcome };
+    });
+    const reads = interaction.readers.map(async (reader) => ({
+      reader,
+      outcome: await this.#attemptQuery(reader, `SELECT * FROM ${quote(interaction.table)} ORDER BY id`)
+    }));
+    const [writeOutcomes, readOutcomes] = await Promise.all([
+      Promise.all(writes),
+      Promise.all(reads)
+    ]);
+    const touched = /* @__PURE__ */ new Set();
+    for (const { operation, outcome } of writeOutcomes) {
+      const id = keyOf(operation.mutation);
+      touched.add(id);
+      const wouldAccept = before.clone().applyKeyed(interaction.table, operation.mutation);
+      if (outcome.error === void 0) {
+        if (!wouldAccept)
+          this.#fail(`concurrent insert of an existing key ${String(id)} was accepted`);
+        this.#model.applyKeyed(interaction.table, operation.mutation);
+        this.#acceptedWrites++;
+      } else if (isUniqueViolation(outcome.error)) {
+        if (wouldAccept)
+          this.#fail(`concurrent write on key ${String(id)} was refused as a duplicate: ${describeError(outcome.error)}`);
+        this.#expectedFailures++;
+      } else if (isConflict(outcome.error)) {
+        this.#rejectedConflicts++;
+      } else {
+        this.#fail(`concurrent write on key ${String(id)} failed unexpectedly: ${describeError(outcome.error)}`);
+      }
+    }
+    for (const { reader, outcome } of readOutcomes) {
+      if (outcome.error !== void 0)
+        this.#fail(`a read during concurrent writes failed on connection ${String(reader)}: ${describeError(outcome.error)}`);
+      const seen = /* @__PURE__ */ new Map();
+      for (const row of outcome.result?.rows ?? []) {
+        const id = row.id;
+        if (typeof id !== "number")
+          this.#fail("a concurrent read returned a row without a numeric id");
+        seen.set(id, canonical(row, columns));
+      }
+      const beforeRows = new Map(before.sorted(interaction.table).map((row) => [idOf(row), canonical(row, columns)]));
+      const afterRows = new Map(this.#model.sorted(interaction.table).map((row) => [idOf(row), canonical(row, columns)]));
+      const ids = /* @__PURE__ */ new Set([...beforeRows.keys(), ...afterRows.keys(), ...seen.keys()]);
+      for (const id of ids) {
+        const observed = seen.get(id);
+        if (touched.has(id)) {
+          const allowed = [beforeRows.get(id), afterRows.get(id)];
+          if (!allowed.includes(observed)) {
+            this.#fail(`concurrent-explicability: reader ${String(reader)} saw key ${String(id)} as ${observed ?? "absent"}, neither before (${beforeRows.get(id) ?? "absent"}) nor after (${afterRows.get(id) ?? "absent"})`);
+          }
+        } else if (observed !== beforeRows.get(id)) {
+          this.#fail(`concurrent-explicability: reader ${String(reader)} saw untouched key ${String(id)} as ${observed ?? "absent"}, expected ${beforeRows.get(id) ?? "absent"}`);
+        }
+      }
+    }
+    for (let connection = 0; connection < this.#plan.connections; connection++) {
+      await this.#expectRows(connection, interaction.table, this.#model.sorted(interaction.table), "after a concurrent round");
+    }
+  }
+  async #fault(interaction) {
+    const connection = this.#connection(interaction.connection);
+    const columns = this.#model.columns(interaction.table);
+    const sql = renderKeyed(interaction.table, columns, interaction.mutation);
+    const before = this.#model.clone();
+    const after = this.#model.clone();
+    const accepted = after.applyKeyed(interaction.table, interaction.mutation);
+    if (!accepted) {
+      const outcome2 = await this.#attempt(interaction.connection, sql);
+      if (outcome2.error === void 0)
+        this.#fail("a duplicate insert was accepted during a fault step");
+      this.#expectedFailures++;
+      return;
+    }
+    let outcome;
+    if (interaction.point === "crash") {
+      if (connection.crash === void 0) {
+        this.#faultsSkipped++;
+        return;
+      }
+      const pending = this.#attempt(interaction.connection, sql);
+      await connection.crash();
+      outcome = await pending;
+      if (outcome.error === void 0) {
+        this.#model = after;
+      }
+    } else {
+      const faults = this.#driver.faults;
+      if (faults === void 0) {
+        this.#faultsSkipped++;
+        return;
+      }
+      faults.arm(interaction.point, 1);
+      try {
+        outcome = await this.#attempt(interaction.connection, sql);
+      } finally {
+        faults.disarm();
+      }
+      if (!faults.fired()) {
+        if (outcome.error !== void 0)
+          this.#fail(`mutation failed without its fault firing: ${describeError(outcome.error)}`, outcome.error);
+        this.#model = after;
+        this.#acceptedWrites++;
+        return;
+      }
+    }
+    this.#faultsInjected++;
+    if (outcome.error !== void 0 && !isUnknownOutcome(outcome.error) && !isInjectedFault(outcome.error) && !isConflict(outcome.error)) {
+      this.#fail(`fault ${interaction.point} surfaced an unexpected error: ${describeError(outcome.error)}`);
+    }
+    await this.#reopenConnection(interaction.connection);
+    const actual = await this.#read(interaction.connection, interaction.table);
+    const beforeRows = canonicalRows(before.sorted(interaction.table), columns);
+    const afterRows = canonicalRows(after.sorted(interaction.table), columns);
+    const observed = canonicalRows(actual, columns);
+    if (observed === afterRows)
+      this.#model = after;
+    else if (observed === beforeRows) {
+      if (outcome.error === void 0)
+        this.#fail(`fault-atomicity: ${interaction.point} reported success but the mutation is not durable`);
+      this.#model = before;
+    } else {
+      this.#fail(`fault-atomicity: after ${interaction.point} the table is neither before nor after the mutation
+  observed ${observed}
+  before   ${beforeRows}
+  after    ${afterRows}`);
+    }
+  }
+  async #reopenConnection(index) {
+    this.#record(`[${String(index)}] -- reopen`);
+    await this.#connection(index).reopen();
+    this.#reopens++;
+  }
+  async #reopen(index) {
+    await this.#reopenConnection(index);
+    for (const table of this.#model.tables.keys()) {
+      await this.#expectRows(index, table, this.#model.sorted(table), "after reopen");
+    }
+  }
+  async #maintenance(interaction) {
+    const connection = this.#connection(interaction.connection);
+    if (connection.maintain === void 0)
+      return;
+    this.#record(`[${String(interaction.connection)}] -- maintenance ${interaction.table}`);
+    await connection.maintain(interaction.table).catch((error) => this.#fail(`maintenance failed: ${describeError(error)}`, error));
+    await this.#expectRows(interaction.connection, interaction.table, this.#model.sorted(interaction.table), "after maintenance");
+  }
+  async #checkpoint() {
+    this.#checkpoints++;
+    for (let connection = 0; connection < this.#plan.connections; connection++) {
+      for (const table of this.#model.tables.keys()) {
+        await this.#expectRows(connection, table, this.#model.sorted(table), "at checkpoint");
+      }
+    }
+  }
+  async #count(connection, table, where) {
+    const result = await this.#query(connection, `SELECT COUNT(*) AS n FROM ${quote(table)} WHERE ${where}`).catch((error) => this.#fail(`COUNT failed: ${describeError(error)}`, error));
+    const value = result.rows[0]?.n;
+    if (typeof value === "number")
+      return value;
+    if (typeof value === "bigint")
+      return Number(value);
+    this.#fail(`COUNT(*) returned ${JSON.stringify(value)}`);
+  }
+  async #read(connection, table, where = "TRUE") {
+    const result = await this.#query(connection, `SELECT * FROM ${quote(table)} WHERE ${where} ORDER BY id`).catch((error) => this.#fail(`SELECT failed: ${describeError(error)}`, error));
+    return [...result.rows];
+  }
+  async #expectRows(connection, table, expected, context, where = "TRUE") {
+    const actual = await this.#read(connection, table, where);
+    const columns = this.#model.columns(table);
+    const observed = canonicalRows(actual, columns);
+    const wanted = canonicalRows(expected, columns);
+    if (observed !== wanted) {
+      this.#fail(`${context}: connection ${String(connection)} disagrees with the model for ${table}
+  observed ${observed}
+  expected ${wanted}`);
+    }
+  }
+  #compareRows(result, expected, columns, property) {
+    const missing = columns.filter((column) => !result.columns.includes(column));
+    if (missing.length > 0)
+      this.#fail(`${property}: result lacks columns ${missing.join(", ")}`);
+    const observed = result.rows.map((row) => canonical(row, columns)).join("\n");
+    const wanted = expected.map((row) => canonical(row, columns)).join("\n");
+    if (observed !== wanted) {
+      this.#fail(`${property}: rows differ
+  observed ${observed.replaceAll("\n", " | ")}
+  expected ${wanted.replaceAll("\n", " | ")}`);
+    }
+  }
+  async #attempt(connection, sql, params) {
+    try {
+      return { result: await this.#execute(connection, sql, params) };
+    } catch (error) {
+      return { error };
+    }
+  }
+  async #attemptQuery(connection, sql) {
+    try {
+      return { result: await this.#query(connection, sql) };
+    } catch (error) {
+      return { error };
+    }
+  }
+}
+function keyOf(mutation) {
+  return mutation.kind === "insert" || mutation.kind === "upsert" ? idOf(mutation.row) : mutation.id;
+}
+function canonical(row, columns) {
+  return columns.map((column) => `${column}=${canonicalValue(row[column])}`).join(",");
+}
+function canonicalValue(value) {
+  if (value === null || value === void 0)
+    return "NULL";
+  if (typeof value === "bigint")
+    return String(value);
+  if (typeof value === "number")
+    return Object.is(value, -0) ? "0" : String(value);
+  if (typeof value === "boolean")
+    return value ? "true" : "false";
+  if (typeof value === "string")
+    return JSON.stringify(value);
+  return `?${typeof value}`;
+}
+function canonicalRows(rows, columns) {
+  return rows.map((row) => canonical(row, columns)).join(" | ");
+}
+function describeError(error) {
+  if (error instanceof Error)
+    return `${error.name}: ${error.message}`;
+  if (isRecord(error) && typeof error.message === "string") {
+    return `${typeof error.name === "string" ? error.name : "Error"}: ${error.message}`;
+  }
+  return String(error);
+}
+function errorText(error) {
+  return describeError(error);
+}
+function isUniqueViolation(error) {
+  return /UniqueConstraint|duplicate value|unique/iu.test(errorText(error));
+}
+function isConflict(error) {
+  return /WriteConflict|Manifest changed|conflict/iu.test(errorText(error));
+}
+function isExpiredTransaction(error) {
+  return /TransactionExpired|transaction expired/iu.test(errorText(error));
+}
+class RefusedTransaction extends Error {
+  reason;
+  constructor(reason, cause) {
+    super(`SQL transaction refused: ${reason}`, { cause });
+    this.reason = reason;
+    this.name = "RefusedTransaction";
+  }
+  get expired() {
+    return this.reason === "idle rollback";
+  }
+}
+function isUnknownOutcome(error) {
+  return /OutcomeUnknown|UnknownOutcome|ConnectionLost|Worker.*(terminated|failed|closed)|is closed/iu.test(errorText(error));
+}
+function isInjectedFault(error) {
+  return /injected/iu.test(errorText(error));
+}
+function isStoreUnresponsive(error) {
+  for (let current = error, depth = 0; current !== void 0 && depth < 8; depth += 1) {
+    if (errorText(current).includes("StorageUnresponsive"))
+      return true;
+    current = isRecord(current) ? current.cause : void 0;
+  }
+  return false;
+}
+function mulberry32(seed) {
+  let state = seed >>> 0;
+  return () => {
+    state = state + 1831565813 >>> 0;
+    let mixed = state;
+    mixed = Math.imul(mixed ^ mixed >>> 15, mixed | 1);
+    mixed ^= mixed + Math.imul(mixed ^ mixed >>> 7, mixed | 61);
+    return ((mixed ^ mixed >>> 14) >>> 0) / 4294967296;
+  };
+}
+function createDatabaseDriver(source, options = {}) {
+  const controller = new InjectedFaultController();
+  const owned = /* @__PURE__ */ new Set();
+  const wrap = (store) => new FaultInjectingBlockStore(store, (point) => {
+    controller.inject(point);
+  });
+  const shared = typeof source === "function" ? void 0 : wrap(source);
+  const acquire = async () => {
+    if (shared !== void 0)
+      return shared;
+    const store = await source();
+    owned.add(store);
+    return store;
+  };
+  const release = (store) => {
+    if (store === void 0)
+      return;
+    owned.delete(store);
+    store.close();
+  };
+  const databases = /* @__PURE__ */ new Set();
+  const open = async () => {
+    const store = await acquire();
+    const database = new MinnowDatabase(shared === void 0 ? wrap(store) : store, {
+      ...options.databaseOptions
+    });
+    databases.add(database);
+    return { database, store: shared === void 0 ? store : void 0 };
+  };
+  return {
+    faults: controller,
+    open: async () => {
+      let { database, store } = await open();
+      return {
+        execute: async (sql, params) => {
+          const result = await database.execute(sql, params);
+          return "rowCount" in result ? { kind: result.kind, rowCount: result.rowCount } : { kind: result.kind };
+        },
+        query: async (sql, params) => {
+          const result = await database.query(sql, params === void 0 ? { memoize: false } : { memoize: false, params: [...params] });
+          return { columns: result.columns, rows: result.rows };
+        },
+        reopen: async () => {
+          await database.close();
+          databases.delete(database);
+          release(store);
+          ({ database, store } = await open());
+        },
+        maintain: async (table) => {
+          await database.compactTable(table);
+          await database.collectGarbage();
+        }
+      };
+    },
+    close: async () => {
+      await Promise.allSettled([...databases].map((database) => database.close()));
+      for (const store of owned)
+        store.close();
+      owned.clear();
+    }
+  };
+}
+class InjectedFaultController {
+  #point;
+  #occurrence = 0;
+  #seen = 0;
+  #fired = false;
+  arm(point, occurrence) {
+    this.#point = point;
+    this.#occurrence = occurrence;
+    this.#seen = 0;
+    this.#fired = false;
+  }
+  disarm() {
+    this.#point = void 0;
+  }
+  fired() {
+    return this.#fired;
+  }
+  inject(point) {
+    if (point !== this.#point || this.#fired)
+      return;
+    this.#seen++;
+    if (this.#seen !== this.#occurrence)
+      return;
+    this.#fired = true;
+    throw new Error(`injected ${point} #${String(this.#occurrence)}`);
+  }
+}
+export {
+  InteractionFailure,
+  createDatabaseDriver,
+  describeError,
+  evaluate,
+  generateInteractionPlan,
+  parseInteractionPlan,
+  renderLiteral,
+  renderPredicate,
+  runInteractionPlan
+};