@bjnstnkvc/db 0.1.0

package/dist/main.js

@@ -0,0 +1,4349 @@
+// src/exceptions/CheckConstraintViolationException.ts
+var CheckConstraintViolationException = class extends Error {
+  /**
+   * Create a new exception for a value the column does not accept.
+   */
+  constructor(table, column, value, accepted) {
+    super(`Column [${column}] of table [${table}] does not accept [${String(value)}]. It accepts [${accepted.join(", ")}].`);
+    this.name = "CheckConstraintViolationException";
+  }
+};
+
+// src/exceptions/ConnectionNotConfiguredException.ts
+var ConnectionNotConfiguredException = class extends Error {
+  /**
+   * Create a new exception for an unconfigured connection.
+   */
+  constructor(connection) {
+    super(`Database connection [${connection}] is not configured.`);
+    this.name = "ConnectionNotConfiguredException";
+  }
+};
+
+// src/exceptions/DatabaseBlockedException.ts
+var DatabaseBlockedException = class extends Error {
+  /**
+   * Create a new exception for a database blocked by another connection.
+   */
+  constructor(database) {
+    super(`Database [${database}] is blocked by a connection in another tab holding an older version. Close the other tabs and try again.`);
+    this.name = "DatabaseBlockedException";
+  }
+};
+
+// src/exceptions/MigrationMismatchException.ts
+var MigrationMismatchException = class extends Error {
+  /**
+   * Create a new exception for a migration list that diverged from what has run.
+   */
+  constructor(ran, registered) {
+    super(`Registered migrations [${registered.join(", ")}] do not match the migrations already run [${ran.join(", ")}]. Migrations are forward-only, so they may only be appended, never reordered or removed. If your bundler mangles class names, override name() on each migration.`);
+    this.name = "MigrationMismatchException";
+  }
+};
+
+// src/exceptions/MigrationTransactionClosedException.ts
+var MigrationTransactionClosedException = class extends Error {
+  /**
+   * Create a new exception for a migration that outlived its transaction.
+   */
+  constructor(migration) {
+    super(`Migration [${migration}] continued after its transaction closed. A migration may only await database operations from this package - awaiting a fetch, a timer or any other promise ends the transaction.`);
+    this.name = "MigrationTransactionClosedException";
+  }
+};
+
+// src/exceptions/MultipleRecordsFoundException.ts
+var MultipleRecordsFoundException = class extends Error {
+  /**
+   * Create a new exception for a query that matched more records than it should.
+   */
+  constructor(table) {
+    super(`More than one record found in table [${table}], where exactly one was expected.`);
+    this.name = "MultipleRecordsFoundException";
+  }
+};
+
+// src/exceptions/NotNullConstraintViolationException.ts
+var NotNullConstraintViolationException = class extends Error {
+  /**
+   * Create a new exception for a null value in a non-nullable column.
+   */
+  constructor(table, column) {
+    super(`Column [${column}] of table [${table}] may not be null.`);
+    this.name = "NotNullConstraintViolationException";
+  }
+};
+
+// src/exceptions/QuotaExceededException.ts
+var QuotaExceededException = class extends Error {
+  /**
+   * Create a new exception for storage the browser refused to grant.
+   */
+  constructor(message = "The storage quota for this origin is full. Free some space, or ask the user to, before writing again.") {
+    super(message);
+    this.name = "QuotaExceededException";
+  }
+};
+
+// src/exceptions/RecordsNotFoundException.ts
+var RecordsNotFoundException = class extends Error {
+  /**
+   * Create a new exception for a query that matched no records.
+   */
+  constructor(message = "No records found.") {
+    super(message);
+    this.name = "RecordsNotFoundException";
+  }
+};
+
+// src/exceptions/ReservedTableException.ts
+var ReservedTableException = class extends Error {
+  /**
+   * Create a new exception for a table name reserved by the database layer.
+   */
+  constructor(table) {
+    super(`Table name [${table}] is reserved by the database layer.`);
+    this.name = "ReservedTableException";
+  }
+};
+
+// src/exceptions/SchemaException.ts
+var SchemaException = class extends Error {
+  /**
+   * Create a new exception for a failed schema operation.
+   */
+  constructor(message = "Schema operation failed.") {
+    super(message);
+    this.name = "SchemaException";
+  }
+};
+
+// src/exceptions/TableNotFoundException.ts
+var TableNotFoundException = class extends Error {
+  /**
+   * Create a new exception for a missing table.
+   */
+  constructor(table) {
+    super(`Table [${table}] does not exist.`);
+    this.name = "TableNotFoundException";
+  }
+};
+
+// src/exceptions/UniqueConstraintViolationException.ts
+var UniqueConstraintViolationException = class extends Error {
+  /**
+   * Create a new exception for a violated unique index.
+   */
+  constructor(table, index) {
+    super(`Unique constraint violated on index [${index}] of table [${table}].`);
+    this.name = "UniqueConstraintViolationException";
+  }
+};
+
+// src/schema/ColumnDefinition.ts
+var ColumnDefinition = class {
+  /**
+   * The name of the column.
+   */
+  #name;
+  /**
+   * The declared type of the column.
+   */
+  #type;
+  /**
+   * Whether the column accepts a null value.
+   */
+  #nullable = false;
+  /**
+   * The default value applied when the column is absent.
+   */
+  #default = void 0;
+  /**
+   * Whether a default value has been declared.
+   */
+  #hasDefault = false;
+  /**
+   * Whether the column is the key path of its table.
+   */
+  #primary = false;
+  /**
+   * Whether the column is generated by the database.
+   */
+  #increments = false;
+  /**
+   * The number of decimal places a scaled column carries.
+   */
+  #places = null;
+  /**
+   * The values an enumerated column accepts.
+   */
+  #values = null;
+  /**
+   * The indexes requested for the column.
+   */
+  #requested = [];
+  /**
+   * Create a new column definition.
+   */
+  constructor(name, type) {
+    this.#name = name;
+    this.#type = type;
+  }
+  /**
+   * Get the name of the column.
+   */
+  get name() {
+    return this.#name;
+  }
+  /**
+   * Get the declared type of the column.
+   */
+  get type() {
+    return this.#type;
+  }
+  /**
+   * Record the scale of a decimal column.
+   */
+  scaled(places) {
+    this.#places = places;
+    return this;
+  }
+  /**
+   * Record the values an enumerated column accepts.
+   */
+  accepts(values) {
+    this.#values = values;
+    return this;
+  }
+  /**
+   * Allow the column to hold a null value.
+   */
+  nullable(value = true) {
+    this.#nullable = value;
+    return this;
+  }
+  /**
+   * Set the value applied when the column is absent.
+   */
+  default(value) {
+    this.#default = value;
+    this.#hasDefault = true;
+    return this;
+  }
+  /**
+   * Make the column the key path of its table.
+   */
+  primary() {
+    this.#primary = true;
+    return this;
+  }
+  /**
+   * Let the database generate the column value.
+   */
+  increments() {
+    this.#increments = true;
+    return this;
+  }
+  /**
+   * Request an index over the column.
+   */
+  index(name = null) {
+    this.#requested.push({ name, unique: false, multiEntry: false });
+    return this;
+  }
+  /**
+   * Request a unique index over the column.
+   */
+  unique(name = null) {
+    this.#requested.push({ name, unique: true, multiEntry: false });
+    return this;
+  }
+  /**
+   * Index each element of the column's array value, requesting an index when none was.
+   */
+  multiEntry() {
+    if (this.#requested.length === 0) {
+      this.index();
+    }
+    for (const requested of this.#requested) {
+      requested.multiEntry = true;
+    }
+    return this;
+  }
+  /**
+   * Get the indexes requested for the column.
+   */
+  requested() {
+    return this.#requested;
+  }
+  /**
+   * Get the schema describing the column.
+   */
+  toSchema() {
+    return {
+      name: this.#name,
+      type: this.#type,
+      nullable: this.#nullable,
+      default: this.#default,
+      hasDefault: this.#hasDefault,
+      primary: this.#primary,
+      increments: this.#increments,
+      places: this.#places,
+      values: this.#values
+    };
+  }
+};
+
+// src/schema/Blueprint.ts
+var Blueprint = class {
+  /**
+   * The name of the table.
+   */
+  #table;
+  /**
+   * The schema of the table as it already exists, when altering.
+   */
+  #existing;
+  /**
+   * The columns declared on the blueprint.
+   */
+  #columns = [];
+  /**
+   * The indexes declared at table level on the blueprint.
+   */
+  #indexes = [];
+  /**
+   * The names of the columns to drop.
+   */
+  #dropped = [];
+  /**
+   * The columns to rename.
+   */
+  #renamed = [];
+  /**
+   * The names of the indexes to drop.
+   */
+  #unindexed = [];
+  /**
+   * Whether the table manages timestamps.
+   */
+  #timestamps;
+  /**
+   * Create a new blueprint for a table.
+   */
+  constructor(table, existing = null) {
+    this.#table = table;
+    this.#existing = existing;
+    this.#timestamps = existing !== null && existing.timestamps;
+  }
+  /**
+   * Get the name of the table.
+   */
+  get table() {
+    return this.#table;
+  }
+  /**
+   * Add an auto incrementing primary key column.
+   */
+  id(column = "id") {
+    return this.integer(column).primary().increments();
+  }
+  /**
+   * Add a string column holding a universally unique identifier.
+   */
+  uuid(column) {
+    return this.string(column);
+  }
+  /**
+   * Add a string column.
+   */
+  string(column) {
+    return this.#add(column, "string");
+  }
+  /**
+   * Add an integer column.
+   */
+  integer(column) {
+    return this.#add(column, "integer");
+  }
+  /**
+   * Add a floating point column.
+   */
+  float(column) {
+    return this.#add(column, "float");
+  }
+  /**
+   * Add a boolean column.
+   */
+  boolean(column) {
+    return this.#add(column, "boolean");
+  }
+  /**
+   * Add a date column.
+   */
+  date(column) {
+    return this.#add(column, "date");
+  }
+  /**
+   * Add a date and time column.
+   */
+  datetime(column) {
+    return this.#add(column, "datetime");
+  }
+  /**
+   * Add a column holding an arbitrary structure.
+   */
+  json(column) {
+    return this.#add(column, "json");
+  }
+  /**
+   * Add a fixed point column, stored as an integer number of its smallest unit.
+   */
+  decimal(column, places = 2) {
+    return this.#add(column, "decimal").scaled(places);
+  }
+  /**
+   * Add a column accepting only one of the given values.
+   */
+  enum(column, values) {
+    const accepted = this.#enumerated(column, values);
+    if (accepted.length === 0) {
+      throw new SchemaException(`Column [${column}] of table [${this.#table}] is enumerated over no values, so nothing could ever be written to it.`);
+    }
+    return this.#add(column, "enum").accepts(accepted);
+  }
+  /**
+   * Add nullable creation and update timestamp columns.
+   */
+  timestamps() {
+    this.#timestamps = true;
+    this.datetime("created_at").nullable();
+    this.datetime("updated_at").nullable();
+  }
+  /**
+   * Add an index over the given columns.
+   */
+  index(columns, name = null) {
+    return this.#indexed(columns, name, false);
+  }
+  /**
+   * Add a unique index over the given columns.
+   */
+  unique(columns, name = null) {
+    return this.#indexed(columns, name, true);
+  }
+  /**
+   * Drop the given columns from the table.
+   */
+  dropColumn(...columns) {
+    for (const column of columns) {
+      if (!this.#has(column)) {
+        throw new SchemaException(`Column [${column}] does not exist on table [${this.#table}].`);
+      }
+      this.#dropped.push(column);
+    }
+  }
+  /**
+   * Rename a column of the table.
+   */
+  renameColumn(from, to) {
+    if (!this.#has(from)) {
+      throw new SchemaException(`Column [${from}] does not exist on table [${this.#table}].`);
+    }
+    this.#renamed.push({ from, to });
+  }
+  /**
+   * Drop an index from the table.
+   */
+  dropIndex(name) {
+    const exists = this.#indexesOf().some((index) => index.name === name);
+    if (!exists) {
+      throw new SchemaException(`Index [${name}] does not exist on table [${this.#table}].`);
+    }
+    this.#unindexed.push(name);
+  }
+  /**
+   * Get the schema describing the table once the blueprint is applied.
+   */
+  toSchema() {
+    const columns = this.#resolved();
+    const indexes = this.#resolvedIndexes();
+    const primary = columns.filter((column) => column.primary);
+    if (primary.length > 1) {
+      throw new SchemaException(`Table [${this.#table}] declares more than one primary column [${primary.map((column) => column.name).join(", ")}].`);
+    }
+    const key = primary[0];
+    return {
+      table: this.#table,
+      key: key === void 0 ? null : key.name,
+      increments: key === void 0 ? true : key.increments,
+      timestamps: this.#timestamps,
+      columns,
+      indexes
+    };
+  }
+  /**
+   * Get the operations the blueprint performs against the existing table.
+   */
+  operations() {
+    return {
+      added: this.#columns.map((column) => column.toSchema()),
+      dropped: this.#dropped,
+      renamed: this.#renamed,
+      indexed: this.#declaredIndexes(),
+      unindexed: this.#unindexed
+    };
+  }
+  /**
+   * Add a column of the given type to the blueprint.
+   */
+  #add(column, type) {
+    const definition = new ColumnDefinition(column, type);
+    this.#columns.push(definition);
+    return definition;
+  }
+  /**
+   * Reduce a list, an enum or a constant object to the values a column accepts.
+   */
+  #enumerated(column, values) {
+    const listed = Array.isArray(values) ? [...values] : Object.values(values);
+    if (listed.some((value) => typeof value !== "string")) {
+      throw new SchemaException(`Column [${column}] of table [${this.#table}] is enumerated over a numeric enum, which has no string form to store. Give the enum string values, or use integer() instead.`);
+    }
+    return [...new Set(listed)];
+  }
+  /**
+   * Record an index over the given columns.
+   */
+  #indexed(columns, name, unique) {
+    const over = Array.isArray(columns) ? columns : [columns];
+    const index = {
+      name: name ?? `${this.#table}_${over.join("_")}_${unique ? "unique" : "index"}`,
+      columns: over,
+      unique,
+      multiEntry: false
+    };
+    this.#indexes.push(index);
+    return index;
+  }
+  /**
+   * Get the columns the table already has.
+   */
+  #columnsOf() {
+    return this.#existing === null ? [] : this.#existing.columns;
+  }
+  /**
+   * Get the indexes the table already has.
+   */
+  #indexesOf() {
+    return this.#existing === null ? [] : this.#existing.indexes;
+  }
+  /**
+   * Determine whether the column exists on the table, declared or already present.
+   */
+  #has(column) {
+    return this.#columnsOf().some((existing) => existing.name === column) || this.#columns.some((declared) => declared.name === column);
+  }
+  /**
+   * Get the columns of the table once the blueprint is applied.
+   */
+  #resolved() {
+    const renamed = new Map(this.#renamed.map((rename) => [rename.from, rename.to]));
+    const kept = this.#columnsOf().filter((column) => !this.#dropped.includes(column.name)).map((column) => {
+      const to = renamed.get(column.name);
+      return to === void 0 ? column : { ...column, name: to };
+    });
+    const added = this.#columns.map((column) => column.toSchema());
+    const columns = [...kept, ...added];
+    const seen = /* @__PURE__ */ new Set();
+    for (const column of columns) {
+      if (seen.has(column.name)) {
+        throw new SchemaException(`Column [${column.name}] is declared more than once on table [${this.#table}].`);
+      }
+      seen.add(column.name);
+    }
+    return columns;
+  }
+  /**
+   * Get the indexes declared by this blueprint, at table level and on columns.
+   */
+  #declaredIndexes() {
+    const indexes = [...this.#indexes];
+    for (const column of this.#columns) {
+      for (const requested of column.requested()) {
+        indexes.push(this.#requested(column.name, requested));
+      }
+    }
+    return indexes;
+  }
+  /**
+   * Build the index schema for a column level request.
+   */
+  #requested(column, requested) {
+    return {
+      name: requested.name ?? `${this.#table}_${column}_${requested.unique ? "unique" : "index"}`,
+      columns: [column],
+      unique: requested.unique,
+      multiEntry: requested.multiEntry
+    };
+  }
+  /**
+   * Get the indexes of the table once the blueprint is applied.
+   */
+  #resolvedIndexes() {
+    const kept = this.#indexesOf().filter((index) => !this.#unindexed.includes(index.name));
+    const indexes = [...kept, ...this.#declaredIndexes()];
+    const seen = /* @__PURE__ */ new Set();
+    for (const index of indexes) {
+      if (seen.has(index.name)) {
+        throw new SchemaException(`Index [${index.name}] is declared more than once on table [${this.#table}].`);
+      }
+      seen.add(index.name);
+    }
+    return indexes;
+  }
+};
+
+// src/events/DatabaseBlocked.ts
+var DatabaseBlocked = class extends Event {
+  /**
+   * The name of the database.
+   */
+  #database;
+  /**
+   * Create a new Database Blocked event instance.
+   */
+  constructor(database) {
+    super("db:database-blocked");
+    this.#database = database;
+  }
+  /**
+   * Get the name of the database.
+   */
+  get database() {
+    return this.#database;
+  }
+};
+
+// src/events/MigrationEnded.ts
+var MigrationEnded = class extends Event {
+  /**
+   * The name of the migration.
+   */
+  #migration;
+  /**
+   * Create a new Migration Ended event instance.
+   */
+  constructor(migration) {
+    super("db:migration-ended");
+    this.#migration = migration;
+  }
+  /**
+   * Get the name of the migration.
+   */
+  get migration() {
+    return this.#migration;
+  }
+};
+
+// src/events/MigrationsEnded.ts
+var MigrationsEnded = class extends Event {
+  /**
+   * The name of the connection.
+   */
+  #connection;
+  /**
+   * The names of the migrations.
+   */
+  #migrations;
+  /**
+   * Create a new Migrations Ended event instance.
+   */
+  constructor(connection, migrations) {
+    super("db:migrations-ended");
+    this.#connection = connection;
+    this.#migrations = migrations;
+  }
+  /**
+   * Get the name of the connection.
+   */
+  get connection() {
+    return this.#connection;
+  }
+  /**
+   * Get the names of the migrations.
+   */
+  get migrations() {
+    return this.#migrations;
+  }
+};
+
+// src/events/MigrationsStarted.ts
+var MigrationsStarted = class extends Event {
+  /**
+   * The name of the connection.
+   */
+  #connection;
+  /**
+   * The names of the migrations.
+   */
+  #migrations;
+  /**
+   * Create a new Migrations Started event instance.
+   */
+  constructor(connection, migrations) {
+    super("db:migrations-started");
+    this.#connection = connection;
+    this.#migrations = migrations;
+  }
+  /**
+   * Get the name of the connection.
+   */
+  get connection() {
+    return this.#connection;
+  }
+  /**
+   * Get the names of the migrations.
+   */
+  get migrations() {
+    return this.#migrations;
+  }
+};
+
+// src/events/MigrationStarted.ts
+var MigrationStarted = class extends Event {
+  /**
+   * The name of the migration.
+   */
+  #migration;
+  /**
+   * Create a new Migration Started event instance.
+   */
+  constructor(migration) {
+    super("db:migration-started");
+    this.#migration = migration;
+  }
+  /**
+   * Get the name of the migration.
+   */
+  get migration() {
+    return this.#migration;
+  }
+};
+
+// src/events/NoPendingMigrations.ts
+var NoPendingMigrations = class extends Event {
+  /**
+   * The name of the connection.
+   */
+  #connection;
+  /**
+   * Create a new No Pending Migrations event instance.
+   */
+  constructor(connection) {
+    super("db:no-pending-migrations");
+    this.#connection = connection;
+  }
+  /**
+   * Get the name of the connection.
+   */
+  get connection() {
+    return this.#connection;
+  }
+};
+
+// src/events/QueryExecuted.ts
+var QueryExecuted = class extends Event {
+  /**
+   * The name of the connection the query ran on.
+   */
+  #connection;
+  /**
+   * The name of the table the query ran against.
+   */
+  #table;
+  /**
+   * The description of the plan the query ran under.
+   */
+  #plan;
+  /**
+   * The constraints the query was compiled from.
+   */
+  #constraints;
+  /**
+   * The orders the query was compiled from.
+   */
+  #orders;
+  /**
+   * The maximum number of records the query was allowed to return.
+   */
+  #limit;
+  /**
+   * The time the query took in milliseconds.
+   */
+  #duration;
+  /**
+   * The number of records the query returned or affected.
+   */
+  #records;
+  /**
+   * Create a new Query Executed event instance.
+   */
+  constructor(connection, table, plan, constraints, orders, limit, duration, records) {
+    super("db:query");
+    this.#connection = connection;
+    this.#table = table;
+    this.#plan = plan;
+    this.#constraints = constraints;
+    this.#orders = orders;
+    this.#limit = limit;
+    this.#duration = duration;
+    this.#records = records;
+  }
+  /**
+   * Get the name of the connection the query ran on.
+   */
+  get connection() {
+    return this.#connection;
+  }
+  /**
+   * Get the name of the table the query ran against.
+   */
+  get table() {
+    return this.#table;
+  }
+  /**
+   * Get the description of the plan the query ran under.
+   */
+  get plan() {
+    return this.#plan;
+  }
+  /**
+   * Get the constraints the query was compiled from.
+   */
+  get constraints() {
+    return this.#constraints;
+  }
+  /**
+   * Get the orders the query was compiled from.
+   */
+  get orders() {
+    return this.#orders;
+  }
+  /**
+   * Get the maximum number of records the query was allowed to return.
+   */
+  get limit() {
+    return this.#limit;
+  }
+  /**
+   * Get the time the query took in milliseconds.
+   */
+  get duration() {
+    return this.#duration;
+  }
+  /**
+   * Get the number of records the query returned or affected.
+   */
+  get records() {
+    return this.#records;
+  }
+};
+
+// src/events/SeederEnded.ts
+var SeederEnded = class extends Event {
+  /**
+   * The name of the seeder.
+   */
+  #seeder;
+  /**
+   * Create a new Seeder Ended event instance.
+   */
+  constructor(seeder) {
+    super("db:seeder-ended");
+    this.#seeder = seeder;
+  }
+  /**
+   * Get the name of the seeder.
+   */
+  get seeder() {
+    return this.#seeder;
+  }
+};
+
+// src/events/SeederStarted.ts
+var SeederStarted = class extends Event {
+  /**
+   * The name of the seeder.
+   */
+  #seeder;
+  /**
+   * Create a new Seeder Started event instance.
+   */
+  constructor(seeder) {
+    super("db:seeder-started");
+    this.#seeder = seeder;
+  }
+  /**
+   * Get the name of the seeder.
+   */
+  get seeder() {
+    return this.#seeder;
+  }
+};
+
+// src/events/SeedingEnded.ts
+var SeedingEnded = class extends Event {
+  /**
+   * The name of the connection.
+   */
+  #connection;
+  /**
+   * The names of the seeders.
+   */
+  #seeders;
+  /**
+   * Create a new Seeding Ended event instance.
+   */
+  constructor(connection, seeders) {
+    super("db:seeding-ended");
+    this.#connection = connection;
+    this.#seeders = seeders;
+  }
+  /**
+   * Get the name of the connection.
+   */
+  get connection() {
+    return this.#connection;
+  }
+  /**
+   * Get the names of the seeders.
+   */
+  get seeders() {
+    return this.#seeders;
+  }
+};
+
+// src/events/SeedingStarted.ts
+var SeedingStarted = class extends Event {
+  /**
+   * The name of the connection.
+   */
+  #connection;
+  /**
+   * The names of the seeders.
+   */
+  #seeders;
+  /**
+   * Create a new Seeding Started event instance.
+   */
+  constructor(connection, seeders) {
+    super("db:seeding-started");
+    this.#connection = connection;
+    this.#seeders = seeders;
+  }
+  /**
+   * Get the name of the connection.
+   */
+  get connection() {
+    return this.#connection;
+  }
+  /**
+   * Get the names of the seeders.
+   */
+  get seeders() {
+    return this.#seeders;
+  }
+};
+
+// src/events/TransactionBeginning.ts
+var TransactionBeginning = class extends Event {
+  /**
+   * The name of the connection.
+   */
+  #connection;
+  /**
+   * Create a new Transaction Beginning event instance.
+   */
+  constructor(connection) {
+    super("db:transaction-beginning");
+    this.#connection = connection;
+  }
+  /**
+   * Get the name of the connection.
+   */
+  get connection() {
+    return this.#connection;
+  }
+};
+
+// src/events/TransactionCommitted.ts
+var TransactionCommitted = class extends Event {
+  /**
+   * The name of the connection.
+   */
+  #connection;
+  /**
+   * Create a new Transaction Committed event instance.
+   */
+  constructor(connection) {
+    super("db:transaction-committed");
+    this.#connection = connection;
+  }
+  /**
+   * Get the name of the connection.
+   */
+  get connection() {
+    return this.#connection;
+  }
+};
+
+// src/events/TransactionRolledBack.ts
+var TransactionRolledBack = class extends Event {
+  /**
+   * The name of the connection.
+   */
+  #connection;
+  /**
+   * The reason the transaction was rolled back.
+   */
+  #reason;
+  /**
+   * Create a new Transaction Rolled Back event instance.
+   */
+  constructor(connection, reason) {
+    super("db:transaction-rolled-back");
+    this.#connection = connection;
+    this.#reason = reason;
+  }
+  /**
+   * Get the name of the connection.
+   */
+  get connection() {
+    return this.#connection;
+  }
+  /**
+   * Get the reason the transaction was rolled back.
+   */
+  get reason() {
+    return this.#reason;
+  }
+};
+
+// src/events/Dispatcher.ts
+var Dispatcher = class {
+  /**
+   * The target every database event is dispatched through.
+   */
+  static #target = new EventTarget();
+  /**
+   * Dispatch an event to the registered listeners.
+   */
+  static dispatch(event) {
+    this.#target.dispatchEvent(event);
+  }
+  /**
+   * Register a listener for an event type.
+   */
+  static listen(type, listener, once = false) {
+    this.#target.addEventListener(type, listener, { once });
+  }
+  /**
+   * Remove a listener for an event type.
+   */
+  static forget(type, listener) {
+    this.#target.removeEventListener(type, listener);
+  }
+};
+
+// src/database/Request.ts
+var Request = class {
+  /**
+   * Resolve when the request succeeds, reject when it fails.
+   */
+  static settle(request, tolerate = false) {
+    return new Promise((resolve, reject) => {
+      request.onsuccess = () => resolve(request.result);
+      request.onerror = (event) => {
+        if (tolerate) {
+          event.preventDefault();
+          event.stopPropagation();
+        }
+        reject(this.translate(request.error));
+      };
+    });
+  }
+  /**
+   * Walk a cursor, invoking the callback for each record until it asks to stop.
+   */
+  static walk(request, callback) {
+    return new Promise((resolve, reject) => {
+      request.onsuccess = () => {
+        const cursor = request.result;
+        if (cursor === null) {
+          resolve();
+          return;
+        }
+        if (callback(cursor) === false) {
+          resolve();
+          return;
+        }
+        cursor.continue();
+      };
+      request.onerror = () => reject(this.translate(request.error));
+    });
+  }
+  /**
+   * Name the failure, where the platform reports one this package can say more about.
+   */
+  static translate(error) {
+    if (error !== null && error.name === "QuotaExceededError") {
+      return new QuotaExceededException();
+    }
+    return error;
+  }
+};
+
+// src/schema/Coercer.ts
+var FALSY = ["false", "0"];
+var Coercer = class {
+  /**
+   * Coerce a value into its declared column type.
+   */
+  static coerce(value, type, strict) {
+    if (value === null || value === void 0) {
+      return value;
+    }
+    switch (type) {
+      case "string":
+        return String(value);
+      case "integer":
+        return this.#numeric(value, strict, true);
+      case "float":
+        return this.#numeric(value, strict, false);
+      case "boolean":
+        return typeof value === "string" && FALSY.includes(value) ? false : Boolean(value);
+      case "decimal":
+        return this.#scaled(value, strict);
+      case "enum":
+        return String(value);
+      case "date":
+      case "datetime":
+        return this.#temporal(value, strict);
+      default:
+        return this.#structured(value, strict);
+    }
+  }
+  /**
+   * Prepare a record for insertion, applying defaults, timestamps and coercion.
+   */
+  static insertable(record, schema, strict, at) {
+    const prepared = { ...record };
+    this.#stamp(prepared, schema, at, true);
+    for (const column of schema.columns) {
+      if (this.#generated(column, prepared)) {
+        continue;
+      }
+      if (!Object.hasOwn(prepared, column.name) && column.hasDefault) {
+        prepared[column.name] = column.default;
+      }
+      prepared[column.name] = this.#value(prepared[column.name], column, schema, strict);
+    }
+    return prepared;
+  }
+  /**
+   * Prepare a partial record for update, touching timestamps and coercing provided columns.
+   */
+  static updatable(record, schema, strict, at) {
+    const prepared = { ...record };
+    this.#stamp(prepared, schema, at, false);
+    for (const column of schema.columns) {
+      if (!Object.hasOwn(prepared, column.name)) {
+        continue;
+      }
+      prepared[column.name] = this.#value(prepared[column.name], column, schema, strict);
+    }
+    return prepared;
+  }
+  /**
+   * Coerce a single column value, enforcing nullability.
+   */
+  static #value(value, column, schema, strict) {
+    const coerced = this.#accepted(this.coerce(value, column.type, strict), column, schema, strict);
+    if (coerced !== null && coerced !== void 0) {
+      return coerced;
+    }
+    if (column.nullable) {
+      return null;
+    }
+    if (strict) {
+      throw new NotNullConstraintViolationException(schema.table, column.name);
+    }
+    return null;
+  }
+  /**
+   * Reject a value an enumerated column does not accept.
+   */
+  static #accepted(value, column, schema, strict) {
+    if (column.values === null || value === null || value === void 0 || column.values.includes(value)) {
+      return value;
+    }
+    if (strict) {
+      throw new CheckConstraintViolationException(schema.table, column.name, value, column.values);
+    }
+    return null;
+  }
+  /**
+   * Coerce a value into a whole number of a decimal column's smallest unit.
+   */
+  static #scaled(value, strict) {
+    const number = Number(value);
+    if (Number.isNaN(number)) {
+      if (strict) {
+        throw new TypeError(`Unable to coerce [${String(value)}] into a number.`);
+      }
+      return null;
+    }
+    if (!Number.isInteger(number)) {
+      if (strict) {
+        throw new TypeError(`A decimal column stores a whole number of its smallest unit, so [${String(value)}] cannot be written. Scale it first, as in Math.round(19.99 * 100).`);
+      }
+      return Math.round(number);
+    }
+    return number;
+  }
+  /**
+   * Determine whether the column is a key the database generates.
+   */
+  static #generated(column, record) {
+    return column.primary && column.increments && !Object.hasOwn(record, column.name);
+  }
+  /**
+   * Fill the timestamp columns the table declares.
+   */
+  static #stamp(record, schema, at, creating) {
+    if (!schema.timestamps) {
+      return;
+    }
+    if (creating && !Object.hasOwn(record, "created_at")) {
+      record["created_at"] = at;
+    }
+    if (!Object.hasOwn(record, "updated_at")) {
+      record["updated_at"] = at;
+    }
+  }
+  /**
+   * Coerce a value into a number, truncating when the column is an integer.
+   */
+  static #numeric(value, strict, truncate) {
+    const number = Number(value);
+    if (Number.isNaN(number)) {
+      if (strict) {
+        throw new TypeError(`Unable to coerce [${String(value)}] into a number.`);
+      }
+      return null;
+    }
+    return truncate ? Math.trunc(number) : number;
+  }
+  /**
+   * Coerce a value into a date.
+   */
+  static #temporal(value, strict) {
+    const date = value instanceof Date ? value : new Date(value);
+    if (Number.isNaN(date.getTime())) {
+      if (strict) {
+        throw new TypeError(`Unable to coerce [${String(value)}] into a date.`);
+      }
+      return null;
+    }
+    return date;
+  }
+  /**
+   * Coerce a value into a structure, parsing it when it arrives as a string.
+   */
+  static #structured(value, strict) {
+    if (typeof value !== "string") {
+      return value;
+    }
+    try {
+      return JSON.parse(value);
+    } catch {
+      if (strict) {
+        throw new TypeError(`Unable to coerce [${value}] into a structure.`);
+      }
+      return null;
+    }
+  }
+};
+
+// src/query/Columns.ts
+var Columns = class {
+  /**
+   * Split a column into its table and its name.
+   */
+  static split(column) {
+    const separator = column.indexOf(".");
+    if (separator === -1) {
+      return { table: null, name: column };
+    }
+    return { table: column.slice(0, separator), name: column.slice(separator + 1) };
+  }
+  /**
+   * Qualify a column with the table that owns it, or fail when that is not decidable.
+   */
+  static resolve(column, tables) {
+    const { table, name } = this.split(column);
+    if (table !== null) {
+      if (!tables.has(table)) {
+        throw new SchemaException(`Column [${column}] names table [${table}], which this query does not join.`);
+      }
+      return column;
+    }
+    const owners = [...tables].filter(([, columns]) => columns.includes(name)).map(([owner]) => owner);
+    if (owners.length > 1) {
+      throw new SchemaException(`Column [${name}] is ambiguous across tables [${owners.join(", ")}]. Qualify it, as in [${owners[0]}.${name}].`);
+    }
+    if (owners.length === 0) {
+      throw new SchemaException(`Column [${name}] does not exist on any table this query reads.`);
+    }
+    return `${owners[0]}.${name}`;
+  }
+  /**
+   * Parse a projection, which may alias the column it selects.
+   */
+  static parse(expression) {
+    const alias = expression.toLowerCase().indexOf(" as ");
+    if (alias === -1) {
+      return { column: expression, alias: this.split(expression).name };
+    }
+    return {
+      column: expression.slice(0, alias).trim(),
+      alias: expression.slice(alias + 4).trim()
+    };
+  }
+};
+
+// src/query/Comparator.ts
+var Comparator = class {
+  /**
+   * Sort rows by the requested orders, reading each column through the accessor.
+   */
+  static sort(rows, orders, value) {
+    if (orders.length === 0) {
+      return rows;
+    }
+    return [...rows].sort((a, b) => {
+      for (const order of orders) {
+        const compared = this.compare(value(a, order.column), value(b, order.column));
+        if (compared !== 0) {
+          return order.direction === "desc" ? -compared : compared;
+        }
+      }
+      return 0;
+    });
+  }
+  /**
+   * Compare two column values, treating null as the lowest value.
+   */
+  static compare(a, b) {
+    const left = a instanceof Date ? a.getTime() : a;
+    const right = b instanceof Date ? b.getTime() : b;
+    if (this.#missing(left) || this.#missing(right)) {
+      return this.#missing(left) && this.#missing(right) ? 0 : this.#missing(left) ? -1 : 1;
+    }
+    if (left === right) {
+      return 0;
+    }
+    return left < right ? -1 : 1;
+  }
+  /**
+   * Determine whether the value is absent, which SQL orders below everything else.
+   */
+  static #missing(value) {
+    return value === null || value === void 0;
+  }
+};
+
+// src/query/Join.ts
+var Join = class {
+  /**
+   * The conditions the tables are joined on.
+   */
+  #conditions = [];
+  /**
+   * Join on a pair of columns.
+   */
+  on(first, operator, second) {
+    return this.#condition("and", first, operator, second);
+  }
+  /**
+   * Join on a pair of columns, disjunctively.
+   */
+  orOn(first, operator, second) {
+    return this.#condition("or", first, operator, second);
+  }
+  /**
+   * Get the conditions the tables are joined on.
+   */
+  conditions() {
+    return this.#conditions;
+  }
+  /**
+   * Record a condition, allowing the operator to be left implicit.
+   */
+  #condition(conjunction, first, operator, second) {
+    const resolved = second === void 0 ? { operator: "=", second: operator } : { operator, second };
+    this.#conditions.push({ first, operator: resolved.operator, second: resolved.second, conjunction });
+    return this;
+  }
+};
+
+// src/query/Predicate.ts
+var Predicate = class {
+  /**
+   * Compile a list of constraints into a record test.
+   */
+  static compile(constraints) {
+    if (constraints.length === 0) {
+      return () => true;
+    }
+    const groups = this.#grouped(constraints);
+    return (record) => groups.some(
+      (group) => group.every(
+        (constraint) => this.#test(constraint, record)
+      )
+    );
+  }
+  /**
+   * Split the constraints into disjunctive groups, so and binds tighter than or.
+   */
+  static #grouped(constraints) {
+    const groups = [];
+    for (const [index, constraint] of constraints.entries()) {
+      if (index === 0 || constraint.conjunction === "or") {
+        groups.push([]);
+      }
+      groups[groups.length - 1]?.push(constraint);
+    }
+    return groups;
+  }
+  /**
+   * Test a single constraint against a record.
+   */
+  static #test(constraint, record) {
+    if (constraint.type === "nested") {
+      return this.#negate(constraint.not, this.compile(constraint.constraints)(record));
+    }
+    const held = record[constraint.column];
+    if (constraint.type === "null") {
+      return this.#negate(constraint.not, held === null || held === void 0);
+    }
+    if (held === null || held === void 0) {
+      return false;
+    }
+    if (constraint.type === "column") {
+      const other = record[constraint.other];
+      if (other === null || other === void 0) {
+        return false;
+      }
+      return this.#negate(constraint.not, this.#compare(held, constraint.operator, other));
+    }
+    if (constraint.type === "part") {
+      return this.#negate(constraint.not, this.#part(held, constraint.part) === constraint.value);
+    }
+    if (constraint.type === "in") {
+      return this.#negate(constraint.not, constraint.values.some((value) => this.#compare(held, "==", value)));
+    }
+    if (constraint.type === "between") {
+      return this.#negate(constraint.not, this.#compare(held, ">=", constraint.from) && this.#compare(held, "<=", constraint.to));
+    }
+    return this.#negate(constraint.not, this.#compare(held, constraint.operator, constraint.value));
+  }
+  /**
+   * Read one part of a value that should hold a date.
+   */
+  static #part(held, part) {
+    const date = held instanceof Date ? held : new Date(held);
+    if (Number.isNaN(date.getTime())) {
+      return null;
+    }
+    if (part === "year") {
+      return date.getFullYear();
+    }
+    return part === "month" ? date.getMonth() + 1 : date.getDate();
+  }
+  /**
+   * Negate a result when the constraint asks for it.
+   */
+  static #negate(not, result) {
+    return not ? !result : result;
+  }
+  /**
+   * Compare a held value against a given one under the operator.
+   */
+  static #compare(held, operator, given) {
+    if (operator === "like" || operator === "not like") {
+      const matched = typeof held === "string" && this.#like(String(given), held);
+      return operator === "like" ? matched : !matched;
+    }
+    const a = this.#comparable(held);
+    const b = this.#comparable(given);
+    switch (operator) {
+      case "=":
+      case "==":
+        return a == b;
+      case "===":
+        return a === b;
+      case "!=":
+      case "<>":
+        return a != b;
+      case "!==":
+        return a !== b;
+      case "<":
+        return a < b;
+      case ">":
+        return a > b;
+      case "<=":
+        return a <= b;
+      default:
+        return a >= b;
+    }
+  }
+  /**
+   * Reduce a value to something the comparison operators can order.
+   */
+  static #comparable(value) {
+    return value instanceof Date ? value.getTime() : value;
+  }
+  /**
+   * Determine whether a subject matches a like pattern.
+   */
+  static #like(pattern, subject) {
+    const tokens = this.#tokens(pattern);
+    let token = 0;
+    let index = 0;
+    let wildcard = -1;
+    let resume = 0;
+    while (index < subject.length) {
+      const current = tokens[token];
+      if (current !== void 0 && current.kind === "any") {
+        wildcard = token;
+        resume = index;
+        token++;
+        continue;
+      }
+      if (current !== void 0 && (current.kind === "one" || current.value === subject[index].toLowerCase())) {
+        token++;
+        index++;
+        continue;
+      }
+      if (wildcard === -1) {
+        return false;
+      }
+      token = wildcard + 1;
+      resume++;
+      index = resume;
+    }
+    while (tokens[token]?.kind === "any") {
+      token++;
+    }
+    return token === tokens.length;
+  }
+  /**
+   * Reduce a like pattern to the tokens it matches by.
+   */
+  static #tokens(pattern) {
+    const tokens = [];
+    for (let index = 0; index < pattern.length; index++) {
+      const character = pattern[index];
+      if (character === "\\" && (pattern[index + 1] === "%" || pattern[index + 1] === "_")) {
+        tokens.push({ kind: "literal", value: pattern[index + 1].toLowerCase() });
+        index++;
+        continue;
+      }
+      if (character === "%") {
+        if (tokens.at(-1)?.kind !== "any") {
+          tokens.push({ kind: "any", value: "" });
+        }
+        continue;
+      }
+      if (character === "_") {
+        tokens.push({ kind: "one", value: "" });
+        continue;
+      }
+      tokens.push({ kind: "literal", value: character.toLowerCase() });
+    }
+    return tokens;
+  }
+};
+
+// src/query/Joiner.ts
+var Joiner = class {
+  /**
+   * Prefix every key of the given records with the table that owns it.
+   */
+  static qualify(records, table) {
+    return records.map((record) => {
+      const qualified = {};
+      for (const [column, value] of Object.entries(record)) {
+        qualified[`${table}.${column}`] = value;
+      }
+      return qualified;
+    });
+  }
+  /**
+   * Join two sets of qualified records, carrying unmatched rows through where the type asks for it.
+   */
+  static join(left, right, clause, columns) {
+    if (clause.type === "cross") {
+      return left.flatMap((row) => right.map((match) => ({ ...row, ...match })));
+    }
+    if (clause.type === "right") {
+      return this.#matched(right, left, clause, this.#columnsOf(left)).map(
+        (row) => row
+      );
+    }
+    return this.#matched(left, right, clause, columns);
+  }
+  /**
+   * Pair each row of the driving side with the rows of the other that satisfy the conditions.
+   */
+  static #matched(driving, other, clause, columns) {
+    const hashed = this.#hashable(clause) ? this.#hash(other, clause) : null;
+    const matches = Predicate.compile(this.#constraints(clause));
+    const joined = [];
+    for (const row of driving) {
+      const candidates = hashed === null ? other : hashed.get(row[clause.conditions[0].first]) ?? [];
+      const paired = candidates.map((candidate) => ({ ...row, ...candidate })).filter(matches);
+      if (paired.length > 0) {
+        joined.push(...paired);
+        continue;
+      }
+      if (clause.type !== "inner") {
+        joined.push({ ...row, ...this.#absent(columns) });
+      }
+    }
+    return joined;
+  }
+  /**
+   * Determine whether the conditions reduce to a single equality, which a hash can serve.
+   */
+  static #hashable(clause) {
+    const condition = clause.conditions[0];
+    return clause.conditions.length === 1 && condition !== void 0 && condition.operator === "=";
+  }
+  /**
+   * Index the other side by the value its join column holds.
+   */
+  static #hash(records, clause) {
+    const column = clause.conditions[0].second;
+    const hashed = /* @__PURE__ */ new Map();
+    for (const record of records) {
+      const key = record[column];
+      const bucket = hashed.get(key);
+      if (bucket === void 0) {
+        hashed.set(key, [record]);
+        continue;
+      }
+      bucket.push(record);
+    }
+    return hashed;
+  }
+  /**
+   * Compile the join conditions into constraints over the merged row.
+   */
+  static #constraints(clause) {
+    return clause.conditions.map((condition, index) => ({
+      type: "column",
+      column: condition.first,
+      operator: condition.operator,
+      other: condition.second,
+      conjunction: index === 0 ? "and" : condition.conjunction,
+      not: false
+    }));
+  }
+  /**
+   * Build the null columns SQL gives an unmatched row.
+   */
+  static #absent(columns) {
+    return Object.fromEntries(columns.map((column) => [column, null]));
+  }
+  /**
+   * Get every qualified column present across the given records.
+   */
+  static #columnsOf(records) {
+    const columns = /* @__PURE__ */ new Set();
+    for (const record of records) {
+      for (const column of Object.keys(record)) {
+        columns.add(column);
+      }
+    }
+    return [...columns];
+  }
+};
+
+// src/query/Planner.ts
+var RANGEABLE = ["=", "==", "===", ">", ">=", "<", "<="];
+var Planner = class {
+  /**
+   * Compile the constraints and orders into an execution plan.
+   */
+  static plan(constraints, orders, schema) {
+    const candidate = this.#disjunctive(constraints) ? null : this.#candidate(constraints, schema);
+    const ordering = this.#disjunctive(constraints) ? null : this.#ordering(orders, schema);
+    if (candidate === null) {
+      return this.#ordered(constraints, orders, ordering);
+    }
+    const aligned = ordering !== null && ordering.source === candidate.source && ordering.index === candidate.index && candidate.values === null;
+    return {
+      source: candidate.source,
+      index: candidate.index,
+      range: candidate.range,
+      values: candidate.values,
+      direction: aligned ? this.#direction(orders) : "next",
+      ordered: aligned,
+      residual: constraints.filter((constraint) => constraint !== candidate.constraint)
+    };
+  }
+  /**
+   * Describe a plan for the query log.
+   */
+  static describe(plan) {
+    if (plan.source === "scan") {
+      return "scan";
+    }
+    return plan.source === "key" ? "key" : `index:${plan.index}`;
+  }
+  /**
+   * Build the plan for a query no constraint could drive.
+   */
+  static #ordered(constraints, orders, ordering) {
+    if (ordering === null) {
+      return { source: "scan", index: null, range: null, values: null, direction: "next", ordered: false, residual: constraints };
+    }
+    return {
+      source: ordering.source,
+      index: ordering.index,
+      range: null,
+      values: null,
+      direction: this.#direction(orders),
+      ordered: true,
+      residual: constraints
+    };
+  }
+  /**
+   * Determine whether any top level constraint is disjunctive.
+   */
+  static #disjunctive(constraints) {
+    return constraints.some((constraint, index) => index > 0 && constraint.conjunction === "or");
+  }
+  /**
+   * Get the most selective constraint able to drive the scan.
+   */
+  static #candidate(constraints, schema) {
+    let best = null;
+    for (const constraint of constraints) {
+      const candidate = this.#candidacy(constraint, schema);
+      if (candidate !== null && (best === null || candidate.rank < best.rank)) {
+        best = candidate;
+      }
+    }
+    return best;
+  }
+  /**
+   * Assess whether a single constraint can drive the scan.
+   */
+  static #candidacy(constraint, schema) {
+    if (constraint.type === "nested" || constraint.type === "null" || constraint.type === "column" || constraint.type === "part" || constraint.not) {
+      return null;
+    }
+    const target = this.#target(constraint.column, schema);
+    if (target === null) {
+      return null;
+    }
+    if (constraint.type === "in") {
+      if (constraint.values.length === 0 || !constraint.values.every((value) => this.#keyable(value))) {
+        return null;
+      }
+      return { constraint, ...target, range: null, values: constraint.values };
+    }
+    if (constraint.type === "between") {
+      if (!this.#keyable(constraint.from) || !this.#keyable(constraint.to)) {
+        return null;
+      }
+      return { constraint, ...target, range: IDBKeyRange.bound(constraint.from, constraint.to, false, false), values: null };
+    }
+    if (!RANGEABLE.includes(constraint.operator) || !this.#keyable(constraint.value)) {
+      return null;
+    }
+    return { constraint, ...target, range: this.#range(constraint.operator, constraint.value), values: null };
+  }
+  /**
+   * Resolve the column to the key path or a single column index.
+   */
+  static #target(column, schema) {
+    if (schema.key === column) {
+      return { source: "key", index: null, rank: 0 };
+    }
+    const index = schema.indexes.find(
+      (candidate) => candidate.columns.length === 1 && candidate.columns[0] === column
+    );
+    if (index === void 0) {
+      return null;
+    }
+    return { source: "index", index: index.name, rank: index.unique ? 1 : 2 };
+  }
+  /**
+   * Get the index able to satisfy the requested order without dropping records.
+   */
+  static #ordering(orders, schema) {
+    const order = orders[0];
+    if (orders.length !== 1 || order === void 0) {
+      return null;
+    }
+    const target = this.#target(order.column, schema);
+    if (target === null) {
+      return null;
+    }
+    const column = schema.columns.find((candidate) => candidate.name === order.column);
+    if (column !== void 0 && column.nullable) {
+      return null;
+    }
+    return { constraint: { type: "null", column: order.column, conjunction: "and", not: false }, ...target, range: null, values: null };
+  }
+  /**
+   * Get the cursor direction the orders ask for.
+   */
+  static #direction(orders) {
+    return orders[0]?.direction === "desc" ? "prev" : "next";
+  }
+  /**
+   * Build the key range for a comparison operator.
+   */
+  static #range(operator, value) {
+    switch (operator) {
+      case ">":
+        return IDBKeyRange.lowerBound(value, true);
+      case ">=":
+        return IDBKeyRange.lowerBound(value, false);
+      case "<":
+        return IDBKeyRange.upperBound(value, true);
+      case "<=":
+        return IDBKeyRange.upperBound(value, false);
+      default:
+        return IDBKeyRange.only(value);
+    }
+  }
+  /**
+   * Determine whether the value may be used as an IndexedDB key.
+   */
+  static #keyable(value) {
+    return value !== null && value !== void 0;
+  }
+};
+
+// src/query/Signature.ts
+var SEPARATOR = "
";
+var Signature = class {
+  /**
+   * Build a signature identifying a record by every column it holds.
+   */
+  static of(record) {
+    return Object.keys(record).sort().map((column) => this.#segment(column) + this.#segment(this.value(record[column]))).join("");
+  }
+  /**
+   * Build a signature identifying an ordered list of values.
+   */
+  static ofValues(values) {
+    return values.map((value) => this.#segment(this.value(value))).join("");
+  }
+  /**
+   * Encode one part of a signature so that its own content cannot be read as a boundary.
+   */
+  static #segment(part) {
+    return `${part.length}${SEPARATOR}${part}`;
+  }
+  /**
+   * Encode a single value, keeping types and absence distinguishable.
+   */
+  static value(value) {
+    if (value === void 0) {
+      return "?";
+    }
+    if (value === null) {
+      return "~";
+    }
+    if (value instanceof Date) {
+      return `d:${value.getTime()}`;
+    }
+    if (typeof value === "object") {
+      return `o:${JSON.stringify(value)}`;
+    }
+    return `${(typeof value).charAt(0)}:${String(value)}`;
+  }
+};
+
+// src/query/Grouping.ts
+var Grouping = class _Grouping {
+  /**
+   * Fetch the records matching the query the grouping was opened from.
+   */
+  #records;
+  /**
+   * The columns the records are grouped by.
+   */
+  #columns;
+  /**
+   * The aggregations computed for each group.
+   */
+  #aggregations = {};
+  /**
+   * The constraints the groups are filtered by.
+   */
+  #constraints = [];
+  /**
+   * The orders the groups are sorted by.
+   */
+  #orders = [];
+  /**
+   * The maximum number of groups returned.
+   */
+  #limit = null;
+  /**
+   * The number of groups skipped.
+   */
+  #offset = 0;
+  /**
+   * Create a new grouping.
+   */
+  constructor(records, columns) {
+    this.#records = records;
+    this.#columns = columns;
+  }
+  /**
+   * Compute the given aggregations for each group.
+   */
+  aggregate(aggregations) {
+    const grouping = new _Grouping(this.#records, this.#columns);
+    grouping.#aggregations = aggregations;
+    grouping.#constraints = this.#constraints;
+    grouping.#orders = this.#orders;
+    grouping.#limit = this.#limit;
+    grouping.#offset = this.#offset;
+    return grouping;
+  }
+  /**
+   * Constrain the groups the query returns.
+   */
+  having(column, operator, value) {
+    return this.#constrain("and", column, operator, value);
+  }
+  /**
+   * Add a disjunctive constraint on the groups the query returns.
+   */
+  orHaving(column, operator, value) {
+    return this.#constrain("or", column, operator, value);
+  }
+  /**
+   * Sort the groups by a column or an aggregate.
+   */
+  orderBy(column, direction = "asc") {
+    this.#orders.push({ column, direction });
+    return this;
+  }
+  /**
+   * Limit the number of groups the query returns.
+   */
+  limit(value) {
+    this.#limit = value;
+    return this;
+  }
+  /**
+   * Skip the given number of groups.
+   */
+  offset(value) {
+    this.#offset = value;
+    return this;
+  }
+  /**
+   * Get every group matching the query.
+   */
+  async get() {
+    const grouped = this.#grouped(await this.#records());
+    const rows = [];
+    for (const members of grouped.values()) {
+      rows.push(this.#row(members));
+    }
+    const matches = Predicate.compile(this.#constraints);
+    const kept = rows.filter(matches);
+    const sorted = this.#sorted(kept);
+    const from = this.#offset;
+    const paged = this.#limit === null ? sorted.slice(from) : sorted.slice(from, from + this.#limit);
+    return paged;
+  }
+  /**
+   * Get the first group matching the query.
+   */
+  async first() {
+    return (await this.get())[0] ?? null;
+  }
+  /**
+   * Count the groups matching the query.
+   */
+  async count() {
+    return (await this.get()).length;
+  }
+  /**
+   * Collect the records into groups, keyed by their grouped column values.
+   */
+  #grouped(records) {
+    const grouped = /* @__PURE__ */ new Map();
+    for (const record of records) {
+      const key = Signature.ofValues(this.#columns.map((column) => record[column]));
+      const members = grouped.get(key);
+      if (members === void 0) {
+        grouped.set(key, [record]);
+        continue;
+      }
+      members.push(record);
+    }
+    return grouped;
+  }
+  /**
+   * Build the row for a group, carrying its columns and its aggregates.
+   */
+  #row(members) {
+    const row = {};
+    const first = members[0];
+    for (const column of this.#columns) {
+      row[column] = first[column];
+    }
+    for (const [alias, aggregation] of Object.entries(this.#aggregations)) {
+      row[alias] = this.#aggregate(aggregation, members);
+    }
+    return row;
+  }
+  /**
+   * Compute a single aggregate over the members of a group.
+   */
+  #aggregate(aggregation, members) {
+    if ("count" in aggregation) {
+      return aggregation.count === "*" ? members.length : this.#values(aggregation.count, members).length;
+    }
+    const column = "sum" in aggregation ? aggregation.sum : "avg" in aggregation ? aggregation.avg : "min" in aggregation ? aggregation.min : aggregation.max;
+    const values = this.#values(column, members);
+    if ("sum" in aggregation) {
+      return values.reduce((carry, value) => carry + value, 0);
+    }
+    if (values.length === 0) {
+      return null;
+    }
+    if ("avg" in aggregation) {
+      return values.reduce((carry, value) => carry + value, 0) / values.length;
+    }
+    return "min" in aggregation ? Math.min(...values) : Math.max(...values);
+  }
+  /**
+   * Get the numeric values of a column across the members of a group.
+   */
+  #values(column, members) {
+    return members.map((member) => member[column]).filter((value) => value !== null && value !== void 0).map((value) => Number(value));
+  }
+  /**
+   * Add a constraint on the groups the query returns.
+   */
+  #constrain(conjunction, column, operator, value) {
+    const resolved = value === void 0 ? { operator: "=", value: operator } : { operator, value };
+    this.#constraints.push({ type: "basic", column, operator: resolved.operator, value: resolved.value, conjunction, not: false });
+    return this;
+  }
+  /**
+   * Sort the group rows by the requested orders.
+   */
+  #sorted(rows) {
+    return Comparator.sort(rows, this.#orders, (row, column) => row[column]);
+  }
+};
+
+// src/query/Builder.ts
+var Builder = class _Builder {
+  /**
+   * The connection the query runs on.
+   */
+  #connection;
+  /**
+   * The name of the table the query runs against.
+   */
+  #table;
+  /**
+   * The transaction the query joins, when it runs inside one.
+   */
+  #transaction;
+  /**
+   * The constraints the query filters by.
+   */
+  #constraints = [];
+  /**
+   * The orders the query sorts by.
+   */
+  #orders = [];
+  /**
+   * The maximum number of records the query returns.
+   */
+  #limit = null;
+  /**
+   * The number of records the query skips.
+   */
+  #offset = 0;
+  /**
+   * The columns the query projects, or null for every column.
+   */
+  #columns = null;
+  /**
+   * Whether the query removes duplicate records.
+   */
+  #distinct = false;
+  /**
+   * The tables joined onto this one.
+   */
+  #joins = [];
+  /**
+   * Create a new query builder.
+   */
+  constructor(connection, table, transaction = null) {
+    this.#connection = connection;
+    this.#table = table;
+    this.#transaction = transaction;
+  }
+  /**
+   * Get the name of the table the query runs against.
+   */
+  get table() {
+    return this.#table;
+  }
+  /**
+   * Add a constraint to the query.
+   */
+  where(column, operator, value) {
+    return this.#constrain("and", false, column, operator, value);
+  }
+  /**
+   * Add a disjunctive constraint to the query.
+   */
+  orWhere(column, operator, value) {
+    return this.#constrain("or", false, column, operator, value);
+  }
+  /**
+   * Add a negated constraint to the query.
+   */
+  whereNot(column, operator, value) {
+    return this.#constrain("and", true, column, operator, value);
+  }
+  /**
+   * Constrain a column to one of the given values.
+   */
+  whereIn(column, values) {
+    return this.#push({ type: "in", column, values, conjunction: "and", not: false });
+  }
+  /**
+   * Constrain a column to one of the given values, disjunctively.
+   */
+  orWhereIn(column, values) {
+    return this.#push({ type: "in", column, values, conjunction: "or", not: false });
+  }
+  /**
+   * Constrain a column to none of the given values.
+   */
+  whereNotIn(column, values) {
+    return this.#push({ type: "in", column, values, conjunction: "and", not: true });
+  }
+  /**
+   * Constrain a column to none of the given values, disjunctively.
+   */
+  orWhereNotIn(column, values) {
+    return this.#push({ type: "in", column, values, conjunction: "or", not: true });
+  }
+  /**
+   * Constrain a column to be null.
+   */
+  whereNull(column) {
+    return this.#push({ type: "null", column, conjunction: "and", not: false });
+  }
+  /**
+   * Constrain a column to be null, disjunctively.
+   */
+  orWhereNull(column) {
+    return this.#push({ type: "null", column, conjunction: "or", not: false });
+  }
+  /**
+   * Constrain a column to not be null.
+   */
+  whereNotNull(column) {
+    return this.#push({ type: "null", column, conjunction: "and", not: true });
+  }
+  /**
+   * Constrain a column to not be null, disjunctively.
+   */
+  orWhereNotNull(column) {
+    return this.#push({ type: "null", column, conjunction: "or", not: true });
+  }
+  /**
+   * Constrain a column to fall between two values, inclusive.
+   */
+  whereBetween(column, values) {
+    return this.#push({ type: "between", column, from: values[0], to: values[1], conjunction: "and", not: false });
+  }
+  /**
+   * Constrain a column to fall between two values, disjunctively.
+   */
+  orWhereBetween(column, values) {
+    return this.#push({ type: "between", column, from: values[0], to: values[1], conjunction: "or", not: false });
+  }
+  /**
+   * Constrain a column to fall outside two values.
+   */
+  whereNotBetween(column, values) {
+    return this.#push({ type: "between", column, from: values[0], to: values[1], conjunction: "and", not: true });
+  }
+  /**
+   * Constrain a column to fall outside two values, disjunctively.
+   */
+  orWhereNotBetween(column, values) {
+    return this.#push({ type: "between", column, from: values[0], to: values[1], conjunction: "or", not: true });
+  }
+  /**
+   * Constrain a column to match a pattern.
+   */
+  whereLike(column, pattern) {
+    return this.#push({ type: "basic", column, operator: "like", value: pattern, conjunction: "and", not: false });
+  }
+  /**
+   * Constrain a column to match a pattern, disjunctively.
+   */
+  orWhereLike(column, pattern) {
+    return this.#push({ type: "basic", column, operator: "like", value: pattern, conjunction: "or", not: false });
+  }
+  /**
+   * Constrain a column to not match a pattern.
+   */
+  whereNotLike(column, pattern) {
+    return this.#push({ type: "basic", column, operator: "not like", value: pattern, conjunction: "and", not: false });
+  }
+  /**
+   * Constrain a column to not match a pattern, disjunctively.
+   */
+  orWhereNotLike(column, pattern) {
+    return this.#push({ type: "basic", column, operator: "not like", value: pattern, conjunction: "or", not: false });
+  }
+  /**
+   * Constrain a date column to fall on a given day.
+   */
+  whereDate(column, value) {
+    const day = new Date(value);
+    const from = new Date(day.getFullYear(), day.getMonth(), day.getDate());
+    const to = new Date(from.getFullYear(), from.getMonth(), from.getDate() + 1);
+    return this.#push({ type: "between", column, from, to: new Date(to.getTime() - 1), conjunction: "and", not: false });
+  }
+  /**
+   * Constrain a date column to fall in a given year.
+   */
+  whereYear(column, value) {
+    return this.#part("and", column, "year", value);
+  }
+  /**
+   * Constrain a date column to fall in a given month, numbered from one.
+   */
+  whereMonth(column, value) {
+    return this.#part("and", column, "month", value);
+  }
+  /**
+   * Constrain a date column to fall on a given day of the month.
+   */
+  whereDay(column, value) {
+    return this.#part("and", column, "day", value);
+  }
+  /**
+   * Join another table, keeping only the rows that match.
+   */
+  join(table, first, operator, second) {
+    return this.#join("inner", table, first, operator, second);
+  }
+  /**
+   * Join another table, keeping every row of this one.
+   */
+  leftJoin(table, first, operator, second) {
+    return this.#join("left", table, first, operator, second);
+  }
+  /**
+   * Join another table, keeping every row of it.
+   */
+  rightJoin(table, first, operator, second) {
+    return this.#join("right", table, first, operator, second);
+  }
+  /**
+   * Pair every row of this table with every row of another.
+   */
+  crossJoin(table) {
+    this.#joins.push({ table, type: "cross", conditions: [] });
+    return this;
+  }
+  /**
+   * Constrain a column against another column of the same row.
+   */
+  whereColumn(column, operator, other) {
+    return this.#compared("and", column, operator, other);
+  }
+  /**
+   * Constrain a column against another column of the same row, disjunctively.
+   */
+  orWhereColumn(column, operator, other) {
+    return this.#compared("or", column, operator, other);
+  }
+  /**
+   * Project only the given columns, which may alias what they select.
+   */
+  select(...columns) {
+    this.#columns = columns.flat();
+    return this;
+  }
+  /**
+   * Remove duplicate records from the result.
+   */
+  distinct(value = true) {
+    this.#distinct = value;
+    return this;
+  }
+  /**
+   * Group the matching records by one or more columns.
+   */
+  groupBy(...columns) {
+    const records = this.clone();
+    records.#orders = [];
+    records.#limit = null;
+    records.#offset = 0;
+    return new Grouping(
+      async () => await records.#records(),
+      columns
+    );
+  }
+  /**
+   * Sort the result by a column.
+   */
+  orderBy(column, direction = "asc") {
+    this.#orders.push({ column, direction });
+    return this;
+  }
+  /**
+   * Sort the result by a column, newest first.
+   */
+  latest(column = "created_at") {
+    return this.orderBy(column, "desc");
+  }
+  /**
+   * Sort the result by a column, oldest first.
+   */
+  oldest(column = "created_at") {
+    return this.orderBy(column, "asc");
+  }
+  /**
+   * Limit the number of records the query returns.
+   */
+  limit(value) {
+    this.#limit = value;
+    return this;
+  }
+  /**
+   * Limit the number of records the query returns.
+   */
+  take(value) {
+    return this.limit(value);
+  }
+  /**
+   * Skip the given number of records.
+   */
+  offset(value) {
+    this.#offset = value;
+    return this;
+  }
+  /**
+   * Skip the given number of records.
+   */
+  skip(value) {
+    return this.offset(value);
+  }
+  /**
+   * Limit the query to a single page of records.
+   */
+  forPage(page, perPage = 15) {
+    return this.offset((page - 1) * perPage).limit(perPage);
+  }
+  /**
+   * Apply the callback when the value is truthy.
+   */
+  when(value, callback) {
+    if (value) {
+      callback(this, value);
+    }
+    return this;
+  }
+  /**
+   * Apply the callback when the value is falsy.
+   */
+  unless(value, callback) {
+    return this.when(!value, (query) => callback(query, value));
+  }
+  /**
+   * Pass the query to the callback and carry on.
+   */
+  tap(callback) {
+    callback(this);
+    return this;
+  }
+  /**
+   * Get a copy of the query.
+   */
+  clone() {
+    const clone = new _Builder(this.#connection, this.#table, this.#transaction);
+    clone.#constraints = [...this.#constraints];
+    clone.#orders = [...this.#orders];
+    clone.#limit = this.#limit;
+    clone.#offset = this.#offset;
+    clone.#columns = this.#columns === null ? null : [...this.#columns];
+    clone.#distinct = this.#distinct;
+    clone.#joins = [...this.#joins];
+    return clone;
+  }
+  /**
+   * Dump the state of the query.
+   */
+  dump() {
+    console.log({
+      table: this.#table,
+      constraints: this.#constraints,
+      orders: this.#orders,
+      limit: this.#limit,
+      offset: this.#offset,
+      columns: this.#columns,
+      distinct: this.#distinct
+    });
+    return this;
+  }
+  /**
+   * Describe the plan the query would run under.
+   */
+  async explain() {
+    const schema = await this.#connection.schema(this.#table);
+    return Planner.describe(Planner.plan(this.#constraints, this.#orders, schema));
+  }
+  /**
+   * Get every record matching the query.
+   */
+  async get() {
+    return this.#shape(await this.#records());
+  }
+  /**
+   * Get the first record matching the query.
+   */
+  async first() {
+    const records = await this.clone().limit(1).get();
+    return records[0] ?? null;
+  }
+  /**
+   * Get the first record matching the query, or fail.
+   */
+  async firstOrFail() {
+    const record = await this.first();
+    if (record === null) {
+      throw new RecordsNotFoundException(`No records found in table [${this.#table}].`);
+    }
+    return record;
+  }
+  /**
+   * Get the one record matching the query, failing when there is not exactly one.
+   */
+  async sole() {
+    const records = await this.clone().limit(2).get();
+    if (records.length === 0) {
+      throw new RecordsNotFoundException(`No records found in table [${this.#table}].`);
+    }
+    if (records.length > 1) {
+      throw new MultipleRecordsFoundException(this.#table);
+    }
+    return records[0];
+  }
+  /**
+   * Get the record with the given key.
+   */
+  async find(key) {
+    const store = await this.#store("readonly");
+    const started = performance.now();
+    const record = await Request.settle(store.get(key));
+    this.#emit("key", started, record === void 0 ? 0 : 1);
+    return record ?? null;
+  }
+  /**
+   * Get the record with the given key, or fail.
+   */
+  async findOrFail(key) {
+    const record = await this.find(key);
+    if (record === null) {
+      throw new RecordsNotFoundException(`No record with key [${String(key)}] in table [${this.#table}].`);
+    }
+    return record;
+  }
+  /**
+   * Get a single column from the first record matching the query.
+   */
+  async value(column) {
+    const record = await this.clone().first();
+    if (record === null) {
+      return null;
+    }
+    return record[column] ?? null;
+  }
+  async pluck(column, key) {
+    const records = await this.#records();
+    if (key === void 0) {
+      return records.map((record) => record[column]);
+    }
+    return Object.fromEntries(records.map((record) => [String(record[key]), record[column]]));
+  }
+  /**
+   * Determine whether any record matches the query.
+   */
+  async exists() {
+    return (await this.clone().limit(1).#records()).length > 0;
+  }
+  /**
+   * Determine whether no record matches the query.
+   */
+  async doesntExist() {
+    return !await this.exists();
+  }
+  /**
+   * Count the records matching the query.
+   */
+  async count() {
+    const schema = await this.#connection.schema(this.#table);
+    const plan = Planner.plan(this.#constraints, this.#orders, schema);
+    if (plan.residual.length > 0 || plan.values !== null) {
+      return (await this.#records()).length;
+    }
+    const store = await this.#store("readonly");
+    const started = performance.now();
+    const source = plan.index === null ? store : store.index(plan.index);
+    const count = await Request.settle(source.count(plan.range ?? void 0));
+    this.#emit(Planner.describe(plan), started, count);
+    return count;
+  }
+  /**
+   * Sum a column across the records matching the query.
+   */
+  async sum(column) {
+    return (await this.#numbers(column)).reduce((carry, value) => carry + value, 0);
+  }
+  /**
+   * Average a column across the records matching the query.
+   */
+  async avg(column) {
+    const values = await this.#numbers(column);
+    if (values.length === 0) {
+      return null;
+    }
+    return values.reduce((carry, value) => carry + value, 0) / values.length;
+  }
+  /**
+   * Get the smallest value of a column across the records matching the query.
+   */
+  async min(column) {
+    return this.#extreme(column, "next");
+  }
+  /**
+   * Get the largest value of a column across the records matching the query.
+   */
+  async max(column) {
+    return this.#extreme(column, "prev");
+  }
+  /**
+   * Get the value at one end of a column's range.
+   */
+  async #extreme(column, direction) {
+    const index = await this.#sole(column);
+    if (index !== null) {
+      const store = await this.#store("readonly");
+      const started = performance.now();
+      const cursor = await Request.settle(store.index(index.name).openCursor(null, direction));
+      this.#emit(`index:${index.name}`, started, cursor === null ? 0 : 1);
+      return cursor === null ? null : Number(cursor.key);
+    }
+    const values = await this.#numbers(column);
+    if (values.length === 0) {
+      return null;
+    }
+    return values.reduce((carry, value) => direction === "next" ? Math.min(carry, value) : Math.max(carry, value));
+  }
+  /**
+   * Get the single column index that can answer an unconstrained extreme, if there is one.
+   */
+  async #sole(column) {
+    if (this.#joins.length > 0 || this.#constraints.length > 0) {
+      return null;
+    }
+    const schema = await this.#connection.schema(this.#table);
+    return schema.indexes.find((index) => index.columns.length === 1 && index.columns[0] === column && !index.multiEntry) ?? null;
+  }
+  /**
+   * Get a single page of records, alongside the totals a pager needs.
+   */
+  async paginate(page = 1, perPage = 15) {
+    const counted = this.clone();
+    counted.#limit = null;
+    counted.#offset = 0;
+    const total = await counted.count();
+    const data = await this.clone().forPage(page, perPage).get();
+    return {
+      data,
+      total,
+      perPage,
+      currentPage: page,
+      lastPage: Math.max(1, Math.ceil(total / perPage))
+    };
+  }
+  /**
+   * Walk the records matching the query in chunks.
+   */
+  async chunk(size, callback) {
+    if (this.#joins.length > 0) {
+      const rows = await this.#records();
+      for (let index = 0; index < rows.length; index += size) {
+        if (await callback(rows.slice(index, index + size), Math.floor(index / size) + 1) === false) {
+          return false;
+        }
+      }
+      return true;
+    }
+    const keys = await this.#keys();
+    for (let index = 0; index < keys.length; index += size) {
+      const page = keys.slice(index, index + size);
+      const store = await this.#store("readonly");
+      const records = await Promise.all(
+        page.map((key) => Request.settle(store.get(key)))
+      );
+      const present = records.filter((record) => record !== void 0);
+      if (await callback(this.#shape(present), Math.floor(index / size) + 1) === false) {
+        return false;
+      }
+    }
+    return true;
+  }
+  /**
+   * Walk the records matching the query as an async iterable.
+   */
+  async *lazy(size = 100) {
+    if (this.#joins.length > 0) {
+      yield* await this.#records();
+      return;
+    }
+    const keys = await this.#keys();
+    for (let index = 0; index < keys.length; index += size) {
+      const page = keys.slice(index, index + size);
+      const store = await this.#store("readonly");
+      const records = await Promise.all(
+        page.map((key) => Request.settle(store.get(key)))
+      );
+      yield* this.#shape(records.filter((record) => record !== void 0));
+    }
+  }
+  /**
+   * Walk the records matching the query one at a time.
+   */
+  async each(callback) {
+    let index = 0;
+    return this.chunk(1, async (records) => callback(records[0], index++));
+  }
+  /**
+   * Insert one or more records into the table.
+   */
+  async insert(records) {
+    const rows = Array.isArray(records) ? records : [records];
+    const schema = await this.#connection.schema(this.#table);
+    const store = await this.#store("readwrite");
+    const started = performance.now();
+    for (const row of rows) {
+      await this.#add(store, schema, row);
+    }
+    this.#emit("insert", started, rows.length);
+    return rows.length;
+  }
+  /**
+   * Insert one or more records, skipping any the unique indexes reject.
+   */
+  async insertOrIgnore(records) {
+    const rows = Array.isArray(records) ? records : [records];
+    const schema = await this.#connection.schema(this.#table);
+    const store = await this.#store("readwrite");
+    const started = performance.now();
+    let inserted = 0;
+    for (const row of rows) {
+      try {
+        await this.#add(store, schema, row);
+        inserted++;
+      } catch (error) {
+        if (!(error instanceof UniqueConstraintViolationException)) {
+          throw error;
+        }
+      }
+    }
+    this.#emit("insert", started, inserted);
+    return inserted;
+  }
+  /**
+   * Insert a record and get the key the database gave it.
+   */
+  async insertGetId(record) {
+    const schema = await this.#connection.schema(this.#table);
+    const store = await this.#store("readwrite");
+    const started = performance.now();
+    const key = await this.#add(store, schema, record);
+    this.#emit("insert", started, 1);
+    return key;
+  }
+  /**
+   * Update every record matching the query.
+   */
+  async update(values) {
+    const schema = await this.#connection.schema(this.#table);
+    const prepared = Coercer.updatable(values, schema, this.#connection.strict, /* @__PURE__ */ new Date());
+    this.#settled(schema, prepared);
+    return this.#modify((cursor) => {
+      cursor.update({ ...cursor.value, ...prepared });
+    });
+  }
+  /**
+   * Update the matching record, inserting it when there is none.
+   */
+  async updateOrInsert(attributes, values = {}) {
+    const query = this.clone().where(attributes);
+    if (await query.exists()) {
+      await query.update(values);
+      return false;
+    }
+    await this.clone().insert({ ...attributes, ...values });
+    return true;
+  }
+  /**
+   * Insert records, updating those that already exist.
+   */
+  async upsert(values, uniqueBy, update) {
+    const schema = await this.#connection.schema(this.#table);
+    const columns = Array.isArray(uniqueBy) ? uniqueBy : [uniqueBy];
+    const target = this.#conflict(schema, columns);
+    const store = await this.#store("readwrite");
+    const started = performance.now();
+    for (const value of values) {
+      await this.#merge(store, schema, columns, target, value, update);
+    }
+    this.#emit("upsert", started, values.length);
+    return values.length;
+  }
+  /**
+   * Add the given amount to a column of every record matching the query.
+   */
+  async increment(column, amount = 1, extra = {}) {
+    return this.#step(column, amount, extra);
+  }
+  /**
+   * Subtract the given amount from a column of every record matching the query.
+   */
+  async decrement(column, amount = 1, extra = {}) {
+    return this.#step(column, -amount, extra);
+  }
+  /**
+   * Delete every record matching the query.
+   */
+  async delete() {
+    return this.#modify((cursor) => {
+      cursor.delete();
+    });
+  }
+  /**
+   * Delete every record in the table.
+   */
+  async truncate() {
+    const store = await this.#store("readwrite");
+    const started = performance.now();
+    await Request.settle(store.clear());
+    this.#emit("truncate", started, 0);
+  }
+  /**
+   * Add a record to the store, reporting a violated constraint by its index.
+   */
+  async #add(store, schema, record) {
+    const prepared = Coercer.insertable(record, schema, this.#connection.strict, /* @__PURE__ */ new Date());
+    try {
+      return await Request.settle(store.add(prepared), true);
+    } catch (error) {
+      if (error instanceof DOMException && error.name === "ConstraintError") {
+        const index = await this.#violated(store, schema, prepared);
+        if (index !== null) {
+          throw new UniqueConstraintViolationException(this.#table, index);
+        }
+      }
+      throw error;
+    }
+  }
+  /**
+   * Find the unique index the record collides with, or null when it cannot be attributed.
+   */
+  async #violated(store, schema, record) {
+    if (schema.key !== null && this.#keyable(record[schema.key])) {
+      if (await Request.settle(store.count(IDBKeyRange.only(record[schema.key]))) > 0) {
+        return schema.key;
+      }
+    }
+    for (const index of schema.indexes.filter((candidate) => candidate.unique)) {
+      if (!index.columns.every((column) => this.#keyable(record[column]))) {
+        continue;
+      }
+      const key = this.#keyOf(index.columns, record);
+      if (await Request.settle(store.index(index.name).count(IDBKeyRange.only(key))) > 0) {
+        return index.name;
+      }
+    }
+    return null;
+  }
+  /**
+   * Determine whether the value may be used as an IndexedDB key.
+   */
+  #keyable(value) {
+    return value !== null && value !== void 0;
+  }
+  /**
+   * Build the index key the given columns of a record form.
+   */
+  #keyOf(columns, record) {
+    if (columns.length === 1) {
+      return record[columns[0]];
+    }
+    return columns.map((column) => record[column]);
+  }
+  /**
+   * Resolve the conflict target of an upsert, or fail when it cannot be enforced.
+   */
+  #conflict(schema, columns) {
+    if (columns.length === 1 && columns[0] === schema.key) {
+      return null;
+    }
+    const index = schema.indexes.find((candidate) => candidate.unique && candidate.columns.length === columns.length && candidate.columns.every((column, position) => column === columns[position]));
+    if (index === void 0) {
+      throw new SchemaException(`Upsert on table [${this.#table}] requires [${columns.join(", ")}] to be the key path or a unique index.`);
+    }
+    return index;
+  }
+  /**
+   * Insert a record, or merge it into the one already holding its conflict key.
+   */
+  async #merge(store, schema, columns, target, value, update) {
+    if (target === null) {
+      await Request.settle(store.put(Coercer.insertable(value, schema, this.#connection.strict, /* @__PURE__ */ new Date())));
+      return;
+    }
+    const key = this.#keyOf(columns, value);
+    const existing = await Request.settle(store.index(target.name).get(IDBKeyRange.only(key)));
+    if (existing === void 0) {
+      await this.#add(store, schema, value);
+      return;
+    }
+    const changes = update === void 0 ? value : Object.fromEntries(update.map((column) => [column, value[column]]));
+    const prepared = Coercer.updatable(changes, schema, this.#connection.strict, /* @__PURE__ */ new Date());
+    this.#settled(schema, prepared);
+    await Request.settle(store.put({ ...existing, ...prepared }));
+  }
+  /**
+   * Add the given amount to a column of every record matching the query.
+   */
+  async #step(column, amount, extra) {
+    const schema = await this.#connection.schema(this.#table);
+    const prepared = Coercer.updatable(extra, schema, this.#connection.strict, /* @__PURE__ */ new Date());
+    this.#settled(schema, prepared);
+    return this.#modify((cursor) => {
+      const record = { ...cursor.value };
+      const current = Number(record[column] ?? 0);
+      cursor.update({ ...record, ...prepared, [column]: current + amount });
+    });
+  }
+  /**
+   * Assert the changes leave the key path of the record alone.
+   */
+  #settled(schema, changes) {
+    if (schema.key !== null && Object.hasOwn(changes, schema.key)) {
+      throw new SchemaException(`Column [${schema.key}] is the key path of table [${this.#table}] and may not be updated.`);
+    }
+  }
+  /**
+   * Apply a change to every record matching the query, in the order the plan scans them.
+   */
+  async #modify(apply) {
+    const schema = await this.#connection.schema(this.#table);
+    const plan = Planner.plan(this.#constraints, this.#orders, schema);
+    const store = await this.#store("readwrite");
+    const started = performance.now();
+    const matches = Predicate.compile(plan.residual);
+    const ceiling = this.#limit === null ? null : this.#offset + this.#limit;
+    let seen = 0;
+    let affected = 0;
+    const visit = (cursor) => {
+      if (!matches(cursor.value)) {
+        return true;
+      }
+      seen++;
+      if (seen > this.#offset) {
+        apply(cursor);
+        affected++;
+      }
+      return ceiling === null || seen < ceiling;
+    };
+    if (plan.values === null) {
+      const source = plan.index === null ? store : store.index(plan.index);
+      await Request.walk(source.openCursor(plan.range, plan.direction), visit);
+    } else {
+      for (const value of plan.values) {
+        const source = plan.index === null ? store : store.index(plan.index);
+        await Request.walk(source.openCursor(IDBKeyRange.only(value)), visit);
+      }
+    }
+    this.#emit(Planner.describe(plan), started, affected);
+    return affected;
+  }
+  /**
+   * Add a constraint of the given shape to the query.
+   */
+  #constrain(conjunction, not, column, operator, value) {
+    if (typeof column === "function") {
+      const nested = new _Builder(this.#connection, this.#table, this.#transaction);
+      column(nested);
+      return this.#push({ type: "nested", constraints: nested.#constraints, conjunction, not });
+    }
+    if (typeof column === "object" && column !== null) {
+      const constraints = Object.entries(column).map(([key, held]) => ({
+        type: "basic",
+        column: key,
+        operator: "=",
+        value: held,
+        conjunction: "and",
+        not: false
+      }));
+      return this.#push({ type: "nested", constraints, conjunction, not });
+    }
+    const resolved = value === void 0 ? { operator: "=", value: operator } : { operator, value };
+    return this.#push({ type: "basic", column, operator: resolved.operator, value: resolved.value, conjunction, not });
+  }
+  /**
+   * Add a constraint on one part of a date column.
+   */
+  #part(conjunction, column, part, value) {
+    return this.#push({ type: "part", column, part, value, conjunction, not: false });
+  }
+  /**
+   * Add a constraint comparing two columns, allowing the operator to be left implicit.
+   */
+  #compared(conjunction, column, operator, other) {
+    const resolved = other === void 0 ? { operator: "=", other: operator } : { operator, other };
+    return this.#push({ type: "column", column, operator: resolved.operator, other: resolved.other, conjunction, not: false });
+  }
+  /**
+   * Append a constraint to the query.
+   */
+  #push(constraint) {
+    this.#constraints.push(constraint);
+    return this;
+  }
+  /**
+   * Get the object store the query reads from.
+   */
+  async #store(mode, table = this.#table) {
+    if (this.#transaction !== null) {
+      return this.#transaction.objectStore(table);
+    }
+    const database = await this.#connection.open();
+    await this.#connection.schema(table);
+    return database.transaction(table, mode).objectStore(table);
+  }
+  /**
+   * Get the numeric values of a column across the records matching the query.
+   */
+  async #numbers(column) {
+    const records = await this.#records();
+    return records.map((record) => record[column]).filter((value) => value !== null && value !== void 0).map((value) => Number(value));
+  }
+  /**
+   * Get the records matching the query, unshaped.
+   */
+  async #records() {
+    return (await this.#matched()).records;
+  }
+  /**
+   * Get the keys of the records matching the query.
+   */
+  async #keys() {
+    return (await this.#matched()).keys;
+  }
+  /**
+   * Record a join, accepting either the column shorthand or a closure of conditions.
+   */
+  #join(type, table, first, operator, second) {
+    const clause = new Join();
+    if (typeof first === "function") {
+      first(clause);
+    } else {
+      clause.on(first, operator, second);
+    }
+    this.#joins.push({ table, type, conditions: clause.conditions() });
+    return this;
+  }
+  /**
+   * Get the columns of every table the query reads, keyed by table.
+   */
+  async #tables() {
+    const tables = /* @__PURE__ */ new Map();
+    const names = [this.#table, ...this.#joins.map((clause) => clause.table)];
+    for (const name of names) {
+      const schema = await this.#connection.schema(name);
+      tables.set(name, schema.columns.map((column) => column.name));
+    }
+    return tables;
+  }
+  /**
+   * Run the joins, returning rows whose keys are all qualified by table.
+   */
+  async #joined() {
+    const tables = await this.#tables();
+    const store = await this.#store("readonly");
+    const started = performance.now();
+    let rows = Joiner.qualify(
+      await Request.settle(store.getAll()),
+      this.#table
+    );
+    for (const clause of this.#joins) {
+      const other = await this.#store("readonly", clause.table);
+      const records = await Request.settle(other.getAll());
+      const columns = tables.get(clause.table).map((column) => `${clause.table}.${column}`);
+      rows = Joiner.join(rows, Joiner.qualify(records, clause.table), clause, columns);
+    }
+    const constraints = this.#constraints.map((constraint) => this.#qualified(constraint, tables));
+    const orders = this.#orders.map((order) => ({ ...order, column: Columns.resolve(order.column, tables) }));
+    const matches = Predicate.compile(constraints);
+    const kept = rows.filter(matches);
+    const sorted = Comparator.sort(kept, orders, (row, column) => row[column]);
+    const from = this.#offset;
+    const paged = this.#limit === null ? sorted.slice(from) : sorted.slice(from, from + this.#limit);
+    this.#emit("join", started, paged.length);
+    return this.#flatten(paged, tables);
+  }
+  /**
+   * Qualify every column a constraint names with the table that owns it.
+   */
+  #qualified(constraint, tables) {
+    if (constraint.type === "nested") {
+      return { ...constraint, constraints: constraint.constraints.map((nested) => this.#qualified(nested, tables)) };
+    }
+    if (constraint.type === "column") {
+      return { ...constraint, column: Columns.resolve(constraint.column, tables), other: Columns.resolve(constraint.other, tables) };
+    }
+    return { ...constraint, column: Columns.resolve(constraint.column, tables) };
+  }
+  /**
+   * Flatten qualified rows the way SQL does, letting later tables win a collision.
+   */
+  #flatten(rows, tables) {
+    if (this.#columns !== null) {
+      return rows.map((row) => Object.fromEntries(
+        this.#columns.map((expression) => {
+          const projection = Columns.parse(expression);
+          return [projection.alias, row[Columns.resolve(projection.column, tables)]];
+        })
+      ));
+    }
+    const order = [...tables.keys()];
+    return rows.map((row) => {
+      const flat = {};
+      for (const table of order) {
+        for (const column of tables.get(table)) {
+          if (Object.hasOwn(row, `${table}.${column}`)) {
+            flat[column] = row[`${table}.${column}`];
+          }
+        }
+      }
+      return flat;
+    });
+  }
+  /**
+   * Run the query, collecting the matching records and their keys.
+   */
+  async #matched() {
+    if (this.#joins.length > 0) {
+      const rows = await this.#joined();
+      return { records: rows, keys: [] };
+    }
+    const schema = await this.#connection.schema(this.#table);
+    const plan = Planner.plan(this.#constraints, this.#orders, schema);
+    const store = await this.#store("readonly");
+    const started = performance.now();
+    const matches = Predicate.compile(plan.residual);
+    const collected = plan.values === null ? await this.#cursored(store, plan, matches) : await this.#points(store, plan, matches);
+    const ordered = plan.ordered ? collected : this.#sorted(collected);
+    const paged = this.#paged(ordered);
+    this.#emit(Planner.describe(plan), started, paged.length);
+    return {
+      records: paged.map((entry) => entry.record),
+      keys: paged.map((entry) => entry.key)
+    };
+  }
+  /**
+   * Collect the records a cursor over the planned source yields.
+   */
+  async #cursored(store, plan, matches) {
+    const source = plan.index === null ? store : store.index(plan.index);
+    const collected = [];
+    const ceiling = plan.ordered && this.#limit !== null ? this.#offset + this.#limit : null;
+    await Request.walk(source.openCursor(plan.range, plan.direction), (cursor) => {
+      if (matches(cursor.value)) {
+        collected.push({ record: cursor.value, key: cursor.primaryKey });
+      }
+      return ceiling === null || collected.length < ceiling;
+    });
+    return collected;
+  }
+  /**
+   * Collect the records the planned point lookups yield.
+   */
+  async #points(store, plan, matches) {
+    const source = plan.index === null ? store : store.index(plan.index);
+    const collected = [];
+    for (const value of plan.values) {
+      const range = IDBKeyRange.only(value);
+      await Request.walk(source.openCursor(range), (cursor) => {
+        if (matches(cursor.value)) {
+          collected.push({ record: cursor.value, key: cursor.primaryKey });
+        }
+      });
+    }
+    return collected;
+  }
+  /**
+   * Sort the collected records by the requested orders.
+   */
+  #sorted(collected) {
+    return Comparator.sort(
+      collected,
+      this.#orders,
+      (entry, column) => entry.record[column]
+    );
+  }
+  /**
+   * Apply the offset and limit to the collected records.
+   */
+  #paged(collected) {
+    const from = this.#offset;
+    return this.#limit === null ? collected.slice(from) : collected.slice(from, from + this.#limit);
+  }
+  /**
+   * Project and deduplicate the records the query returns.
+   */
+  #shape(records) {
+    const projected = this.#columns === null || this.#joins.length > 0 ? records : records.map((record) => Object.fromEntries(
+      this.#columns.map((expression) => {
+        const projection = Columns.parse(expression);
+        return [projection.alias, record[projection.column]];
+      })
+    ));
+    if (!this.#distinct) {
+      return projected;
+    }
+    const seen = /* @__PURE__ */ new Set();
+    return projected.filter((record) => {
+      const signature = Signature.of(record);
+      if (seen.has(signature)) {
+        return false;
+      }
+      seen.add(signature);
+      return true;
+    });
+  }
+  /**
+   * Announce that the query ran.
+   */
+  #emit(plan, started, records) {
+    Dispatcher.dispatch(new QueryExecuted(
+      this.#connection.name,
+      this.#table,
+      plan,
+      this.#constraints,
+      this.#orders,
+      this.#limit,
+      performance.now() - started,
+      records
+    ));
+  }
+};
+
+// src/schema/Registry.ts
+var Registry = class {
+  /**
+   * The name of the reserved store holding the table schemas.
+   */
+  static table = "schema";
+  /**
+   * Create the schema store, unless it already exists.
+   */
+  static create(database) {
+    if (database.objectStoreNames.contains(this.table)) {
+      return;
+    }
+    database.createObjectStore(this.table, { keyPath: "table" });
+  }
+  /**
+   * Get the schema of every table.
+   */
+  static all(transaction) {
+    return Request.settle(transaction.objectStore(this.table).getAll());
+  }
+  /**
+   * Record the schema of a table.
+   */
+  static put(transaction, schema) {
+    transaction.objectStore(this.table).put(schema);
+  }
+  /**
+   * Forget the schema of a table.
+   */
+  static forget(transaction, table) {
+    transaction.objectStore(this.table).delete(table);
+  }
+};
+
+// src/migrations/Repository.ts
+var Repository = class {
+  /**
+   * The name of the reserved store holding the migration records.
+   */
+  static table = "migrations";
+  /**
+   * Create the migrations store, unless it already exists.
+   */
+  static create(database) {
+    if (database.objectStoreNames.contains(this.table)) {
+      return;
+    }
+    database.createObjectStore(this.table, { keyPath: "order" });
+  }
+  /**
+   * Record that a migration ran.
+   */
+  static log(transaction, order, migration, at) {
+    transaction.objectStore(this.table).put({ order, migration, at: at.toISOString() });
+  }
+  /**
+   * Get every recorded migration, in the order they were applied.
+   */
+  static ran(transaction) {
+    return Request.settle(transaction.objectStore(this.table).getAll());
+  }
+};
+
+// src/migrations/Migrator.ts
+var Migrator = class {
+  /**
+   * The context of the migration currently running.
+   */
+  static #context = null;
+  /**
+   * Get the context of the migration currently running.
+   */
+  static context() {
+    return this.#context;
+  }
+  /**
+   * Get the version a database with the given migrations should be opened at.
+   */
+  static version(migrations) {
+    return migrations.length + 1;
+  }
+  /**
+   * Get the index of the first migration still pending at the given version.
+   */
+  static pending(version) {
+    return Math.max(0, version - 1);
+  }
+  /**
+   * Get the names of the given migrations, in order.
+   */
+  static names(migrations) {
+    return migrations.map((migration) => new migration().name());
+  }
+  /**
+   * Assert that the migrations already run are a prefix of those registered.
+   */
+  static verify(ran, registered) {
+    const applied = ran.map((record) => record.migration);
+    const diverged = applied.length > registered.length || applied.some((migration, index) => registered[index] !== migration);
+    if (diverged) {
+      throw new MigrationMismatchException(applied, registered);
+    }
+  }
+  /**
+   * Assert that the active migration still holds its transaction.
+   */
+  static alive() {
+    const context = this.#context;
+    if (context === null) {
+      throw new MigrationTransactionClosedException("unknown");
+    }
+    if (!context.alive) {
+      throw new MigrationTransactionClosedException(context.migration);
+    }
+    return context;
+  }
+  /**
+   * Run the migrations still pending inside the version change transaction.
+   */
+  static async run(connection, database, transaction, migrations, from, at) {
+    Repository.create(database);
+    Registry.create(database);
+    const records = Repository.ran(transaction);
+    const registry = Registry.all(transaction);
+    const [ran, schemas] = await Promise.all([records, registry]);
+    this.verify(ran, this.names(migrations));
+    this.#context = {
+      database,
+      transaction,
+      migration: "unknown",
+      schemas: new Map(schemas.map((schema) => [schema.table, schema])),
+      alive: true
+    };
+    transaction.addEventListener("complete", this.#close);
+    transaction.addEventListener("abort", this.#close);
+    try {
+      return await this.#migrate(connection, migrations, from, at);
+    } finally {
+      this.#context = null;
+    }
+  }
+  /**
+   * Run each pending migration in order, recording it as it completes.
+   */
+  static async #migrate(connection, migrations, from, at) {
+    const pending = migrations.slice(from);
+    if (pending.length === 0) {
+      Dispatcher.dispatch(new NoPendingMigrations(connection));
+      return [];
+    }
+    const ran = [];
+    Dispatcher.dispatch(new MigrationsStarted(connection, this.names(pending)));
+    for (const [offset, constructor] of pending.entries()) {
+      const migration = new constructor();
+      const name = migration.name();
+      const context = this.alive();
+      context.migration = name;
+      Dispatcher.dispatch(new MigrationStarted(name));
+      await migration.up();
+      Repository.log(this.alive().transaction, from + offset + 1, name, at);
+      Dispatcher.dispatch(new MigrationEnded(name));
+      ran.push(name);
+    }
+    Dispatcher.dispatch(new MigrationsEnded(connection, ran));
+    return ran;
+  }
+  /**
+   * Mark the active context as no longer holding its transaction.
+   */
+  static #close = () => {
+    if (this.#context !== null) {
+      this.#context.alive = false;
+    }
+  };
+};
+
+// src/database/Resolver.ts
+var Resolver = class {
+  /**
+   * The connection standing in for the configured default.
+   */
+  static #override = null;
+  /**
+   * Get the connection standing in for the configured default.
+   */
+  static override() {
+    return this.#override;
+  }
+  /**
+   * Run the callback with the given connection standing in as the default.
+   */
+  static async during(name, callback) {
+    const previous = this.#override;
+    this.#override = name;
+    try {
+      return await callback();
+    } finally {
+      this.#override = previous;
+    }
+  }
+};
+
+// src/database/Transaction.ts
+var Transaction = class {
+  /**
+   * The connection the transaction runs on.
+   */
+  #connection;
+  /**
+   * The underlying transaction.
+   */
+  #transaction;
+  /**
+   * Create a new transaction.
+   */
+  constructor(connection, transaction) {
+    this.#connection = connection;
+    this.#transaction = transaction;
+  }
+  /**
+   * Get the names of the tables the transaction is scoped to.
+   */
+  get tables() {
+    return Array.from(this.#transaction.objectStoreNames);
+  }
+  /**
+   * Begin a query against a table inside the transaction.
+   */
+  table(name) {
+    if (!this.#transaction.objectStoreNames.contains(name)) {
+      throw new SchemaException(`Table [${name}] is outside the scope of this transaction.`);
+    }
+    return this.#connection.table(name, this.#transaction);
+  }
+};
+
+// src/database/Connection.ts
+var Connection = class {
+  /**
+   * The name of the connection.
+   */
+  #name;
+  /**
+   * The configuration of the connection.
+   */
+  #config;
+  /**
+   * The open database handle.
+   */
+  #database = null;
+  /**
+   * The open in flight, so concurrent callers share one handle.
+   */
+  #opening = null;
+  /**
+   * The table schemas, read once per open and held in memory.
+   */
+  #schemas = /* @__PURE__ */ new Map();
+  /**
+   * The transaction currently running, so a nested call joins it.
+   */
+  #active = null;
+  /**
+   * The names of the migrations run by the last open.
+   */
+  #migrated = [];
+  /**
+   * Create a new connection.
+   */
+  constructor(name, config) {
+    this.#name = name;
+    this.#config = config;
+  }
+  /**
+   * Get the name of the connection.
+   */
+  get name() {
+    return this.#name;
+  }
+  /**
+   * Get the name of the underlying database.
+   */
+  get database() {
+    return this.#config.database;
+  }
+  /**
+   * Determine whether the connection enforces its column declarations.
+   */
+  get strict() {
+    return this.#config.strict !== false;
+  }
+  /**
+   * Get the migrations registered on the connection.
+   */
+  get migrations() {
+    return this.#config.migrations ?? [];
+  }
+  /**
+   * Get the seeders registered on the connection.
+   */
+  get seeders() {
+    return this.#config.seeders ?? [];
+  }
+  /**
+   * Open the underlying database, running any pending migrations.
+   */
+  async open() {
+    if (this.#database !== null) {
+      return this.#database;
+    }
+    if (this.#opening === null) {
+      this.#opening = this.#connect();
+    }
+    try {
+      return await this.#opening;
+    } finally {
+      this.#opening = null;
+    }
+  }
+  /**
+   * Run any pending migrations, returning the names of those this call ran.
+   */
+  async migrate() {
+    await this.open();
+    const migrated = this.#migrated;
+    this.#migrated = [];
+    return migrated;
+  }
+  /**
+   * Run every registered seeder, returning their names.
+   */
+  async seed() {
+    await this.open();
+    const seeders = this.seeders;
+    if (seeders.length === 0) {
+      return [];
+    }
+    const names = seeders.map((seeder) => new seeder().name());
+    Dispatcher.dispatch(new SeedingStarted(this.#name, names));
+    await Resolver.during(this.#name, async () => {
+      for (const constructor of seeders) {
+        const seeder = new constructor();
+        const name = seeder.name();
+        Dispatcher.dispatch(new SeederStarted(name));
+        await seeder.run();
+        Dispatcher.dispatch(new SeederEnded(name));
+      }
+    });
+    Dispatcher.dispatch(new SeedingEnded(this.#name, names));
+    return names;
+  }
+  /**
+   * Delete the database and replay every migration.
+   */
+  async fresh(options = {}) {
+    this.disconnect();
+    await new Promise((resolve, reject) => {
+      const request = indexedDB.deleteDatabase(this.#config.database);
+      request.onsuccess = () => resolve();
+      request.onerror = () => reject(request.error);
+      request.onblocked = () => {
+        Dispatcher.dispatch(new DatabaseBlocked(this.#config.database));
+        reject(new DatabaseBlockedException(this.#config.database));
+      };
+    });
+    const migrated = await this.migrate();
+    if (options.seed === true) {
+      await this.seed();
+    }
+    return migrated;
+  }
+  /**
+   * Get the state of every registered migration, without running any of them.
+   */
+  async status() {
+    const applied = new Map(
+      (await this.#recorded()).map((record) => [record.migration, record.at])
+    );
+    return Migrator.names(this.migrations).map((migration) => ({
+      migration,
+      ran: applied.has(migration),
+      at: applied.get(migration) ?? null
+    }));
+  }
+  /**
+   * Begin a query against a table.
+   */
+  table(table, transaction = null) {
+    return new Builder(this, table, transaction);
+  }
+  /**
+   * Run the callback inside a transaction, committing when it resolves.
+   */
+  async transaction(callback, options = {}) {
+    if (this.#active !== null) {
+      return callback(this.#active);
+    }
+    const database = await this.open();
+    const tables = options.tables ?? Array.from(database.objectStoreNames);
+    const handle = database.transaction(tables, "readwrite");
+    const transaction = new Transaction(this, handle);
+    let finished = false;
+    let aborting = false;
+    handle.onerror = () => {
+      aborting = true;
+    };
+    const settled = new Promise((resolve, reject) => {
+      handle.oncomplete = () => {
+        finished = true;
+        resolve();
+      };
+      handle.onabort = () => {
+        finished = true;
+        reject(Request.translate(handle.error) ?? new DOMException("The transaction was aborted.", "AbortError"));
+      };
+    });
+    settled.catch(() => {
+    });
+    this.#active = transaction;
+    Dispatcher.dispatch(new TransactionBeginning(this.#name));
+    try {
+      const result = await callback(transaction);
+      await settled;
+      this.#active = null;
+      Dispatcher.dispatch(new TransactionCommitted(this.#name));
+      return result;
+    } catch (error) {
+      this.#active = null;
+      if (!finished) {
+        if (!aborting) {
+          handle.abort();
+        }
+        Dispatcher.dispatch(new TransactionRolledBack(this.#name, error));
+      }
+      throw error;
+    }
+  }
+  /**
+   * Get the schema of a table.
+   */
+  async schema(table) {
+    await this.open();
+    const schema = this.#schemas.get(table);
+    if (schema === void 0) {
+      throw new TableNotFoundException(table);
+    }
+    return schema;
+  }
+  /**
+   * Get the names of every table.
+   */
+  async tables() {
+    await this.open();
+    return [...this.#schemas.keys()];
+  }
+  /**
+   * Determine whether a table exists.
+   */
+  async hasTable(table) {
+    return (await this.tables()).includes(table);
+  }
+  /**
+   * Determine whether a table has a column.
+   */
+  async hasColumn(table, column) {
+    return (await this.getColumns(table)).some((candidate) => candidate.name === column);
+  }
+  /**
+   * Get the columns of a table.
+   */
+  async getColumns(table) {
+    return (await this.schema(table)).columns;
+  }
+  /**
+   * Get the indexes of a table.
+   */
+  async getIndexes(table) {
+    return (await this.schema(table)).indexes;
+  }
+  /**
+   * Close the underlying database.
+   */
+  disconnect() {
+    this.#database?.close();
+    this.#database = null;
+    this.#schemas = /* @__PURE__ */ new Map();
+  }
+  /**
+   * Open the database at the version the registered migrations ask for.
+   */
+  #connect() {
+    const migrations = this.migrations;
+    const version = Migrator.version(migrations);
+    return new Promise((resolve, reject) => {
+      const request = indexedDB.open(this.#config.database, version);
+      let runner = null;
+      let failure = null;
+      request.onupgradeneeded = (event) => {
+        runner = Migrator.run(
+          this.#name,
+          request.result,
+          request.transaction,
+          migrations,
+          Migrator.pending(event.oldVersion),
+          /* @__PURE__ */ new Date()
+        );
+        runner.catch((error) => {
+          failure = error;
+          request.transaction?.abort();
+        });
+      };
+      request.onblocked = () => {
+        Dispatcher.dispatch(new DatabaseBlocked(this.#config.database));
+        reject(new DatabaseBlockedException(this.#config.database));
+      };
+      request.onerror = () => {
+        if (failure !== null) {
+          reject(failure);
+          return;
+        }
+        if (request.error?.name === "VersionError") {
+          this.#recorded().then(
+            (ran) => reject(new MigrationMismatchException(ran.map((record) => record.migration), Migrator.names(migrations))),
+            reject
+          );
+          return;
+        }
+        reject(request.error);
+      };
+      request.onsuccess = () => {
+        this.#ready(request.result, runner).then(resolve, reject);
+      };
+    });
+  }
+  /**
+   * Get the recorded migrations, opening at whatever version is already stored.
+   */
+  async #recorded() {
+    const database = await new Promise((resolve, reject) => {
+      const request = indexedDB.open(this.#config.database);
+      request.onsuccess = () => resolve(request.result);
+      request.onerror = () => reject(request.error);
+    });
+    try {
+      if (!database.objectStoreNames.contains(Repository.table)) {
+        return [];
+      }
+      return await Repository.ran(database.transaction(Repository.table, "readonly"));
+    } finally {
+      database.close();
+    }
+  }
+  /**
+   * Finish opening: await the migrations, verify them and cache the schemas.
+   */
+  async #ready(database, runner) {
+    this.#migrated = runner === null ? [] : await runner;
+    const transaction = database.transaction([Repository.table, Registry.table], "readonly");
+    const records = Repository.ran(transaction);
+    const schemas = Registry.all(transaction);
+    const [ran, registry] = await Promise.all([records, schemas]);
+    Migrator.verify(ran, Migrator.names(this.migrations));
+    this.#schemas = new Map(registry.map((schema) => [schema.table, schema]));
+    this.#database = database;
+    database.onversionchange = () => this.disconnect();
+    return database;
+  }
+};
+
+// src/database/DatabaseManager.ts
+var DatabaseManager = class {
+  /**
+   * The registered configuration.
+   */
+  static #config = null;
+  /**
+   * The connections resolved so far, keyed by name.
+   */
+  static #connections = /* @__PURE__ */ new Map();
+  /**
+   * The queries recorded while the log is enabled.
+   */
+  static #log = [];
+  /**
+   * The listener recording queries, present only while the log is enabled.
+   */
+  static #logger = null;
+  /**
+   * Register the database configuration, replacing anything registered before.
+   */
+  static configure(config) {
+    for (const connection of this.#connections.values()) {
+      connection.disconnect();
+    }
+    this.#config = config;
+    this.#connections = /* @__PURE__ */ new Map();
+  }
+  /**
+   * Resolve a connection by name, or the default one.
+   */
+  static connection(name) {
+    const config = this.#config;
+    if (config === null) {
+      throw new ConnectionNotConfiguredException(name ?? "default");
+    }
+    const resolved = name ?? Resolver.override() ?? config.default;
+    const cached = this.#connections.get(resolved);
+    if (cached !== void 0) {
+      return cached;
+    }
+    const entry = config.connections[resolved];
+    if (entry === void 0) {
+      throw new ConnectionNotConfiguredException(resolved);
+    }
+    const connection = new Connection(resolved, entry);
+    this.#connections.set(resolved, connection);
+    return connection;
+  }
+  /**
+   * Begin a query against a table on the default connection.
+   */
+  static table(table) {
+    return this.connection().table(table);
+  }
+  /**
+   * Run the callback inside a transaction on the default connection.
+   */
+  static transaction(callback, options) {
+    return this.connection().transaction(callback, options);
+  }
+  /**
+   * Run any pending migrations, returning the names of those this call ran.
+   */
+  static migrate(name) {
+    return this.connection(name).migrate();
+  }
+  /**
+   * Run every registered seeder, returning their names.
+   */
+  static seed(name) {
+    return this.connection(name).seed();
+  }
+  /**
+   * Delete the database and replay every migration, optionally seeding afterwards.
+   */
+  static fresh(name, options) {
+    return this.connection(name).fresh(options);
+  }
+  /**
+   * Get the state of every registered migration.
+   */
+  static status(name) {
+    return this.connection(name).status();
+  }
+  /**
+   * Determine whether a table exists.
+   */
+  static hasTable(table, name) {
+    return this.connection(name).hasTable(table);
+  }
+  /**
+   * Determine whether a table has a column.
+   */
+  static hasColumn(table, column, name) {
+    return this.connection(name).hasColumn(table, column);
+  }
+  /**
+   * Get the names of every table.
+   */
+  static getTables(name) {
+    return this.connection(name).tables();
+  }
+  /**
+   * Get the columns of a table.
+   */
+  static getColumns(table, name) {
+    return this.connection(name).getColumns(table);
+  }
+  /**
+   * Get the indexes of a table.
+   */
+  static getIndexes(table, name) {
+    return this.connection(name).getIndexes(table);
+  }
+  /**
+   * Close a connection, leaving it registered so the next query reopens it.
+   */
+  static disconnect(name) {
+    this.connection(name).disconnect();
+  }
+  /**
+   * Close a connection and drop it, so the next resolve rebuilds it from configuration.
+   */
+  static purge(name) {
+    const connection = this.connection(name);
+    connection.disconnect();
+    this.#connections.delete(connection.name);
+  }
+  /**
+   * Get how much storage this origin is using, and how much it may use.
+   */
+  static async estimate() {
+    const storage = globalThis.navigator?.storage;
+    if (storage === void 0) {
+      return {};
+    }
+    return storage.estimate();
+  }
+  /**
+   * Ask the browser not to evict this origin's storage under pressure.
+   */
+  static async persist() {
+    const storage = globalThis.navigator?.storage;
+    if (storage === void 0) {
+      return false;
+    }
+    return storage.persist();
+  }
+  /**
+   * Determine whether this origin's storage is already exempt from eviction.
+   */
+  static async persisted() {
+    const storage = globalThis.navigator?.storage;
+    if (storage === void 0) {
+      return false;
+    }
+    return storage.persisted();
+  }
+  /**
+   * Register an event listener.
+   */
+  static listen(event, listener, options = {}) {
+    Dispatcher.listen(`db:${event}`, listener, options.once ?? false);
+  }
+  /**
+   * Remove an event listener.
+   */
+  static forget(event, listener) {
+    Dispatcher.forget(`db:${event}`, listener);
+  }
+  /**
+   * Register a listener on the "query" event.
+   */
+  static onQueryExecuted(listener, options) {
+    this.listen("query", listener, options);
+  }
+  /**
+   * Register a listener on the "transaction-beginning" event.
+   */
+  static onTransactionBeginning(listener, options) {
+    this.listen("transaction-beginning", listener, options);
+  }
+  /**
+   * Register a listener on the "transaction-committed" event.
+   */
+  static onTransactionCommitted(listener, options) {
+    this.listen("transaction-committed", listener, options);
+  }
+  /**
+   * Register a listener on the "transaction-rolled-back" event.
+   */
+  static onTransactionRolledBack(listener, options) {
+    this.listen("transaction-rolled-back", listener, options);
+  }
+  /**
+   * Register a listener on the "migrations-started" event.
+   */
+  static onMigrationsStarted(listener, options) {
+    this.listen("migrations-started", listener, options);
+  }
+  /**
+   * Register a listener on the "migration-started" event.
+   */
+  static onMigrationStarted(listener, options) {
+    this.listen("migration-started", listener, options);
+  }
+  /**
+   * Register a listener on the "migration-ended" event.
+   */
+  static onMigrationEnded(listener, options) {
+    this.listen("migration-ended", listener, options);
+  }
+  /**
+   * Register a listener on the "migrations-ended" event.
+   */
+  static onMigrationsEnded(listener, options) {
+    this.listen("migrations-ended", listener, options);
+  }
+  /**
+   * Register a listener on the "no-pending-migrations" event.
+   */
+  static onNoPendingMigrations(listener, options) {
+    this.listen("no-pending-migrations", listener, options);
+  }
+  /**
+   * Register a listener on the "database-blocked" event.
+   */
+  static onDatabaseBlocked(listener, options) {
+    this.listen("database-blocked", listener, options);
+  }
+  /**
+   * Register a listener on the "seeding-started" event.
+   */
+  static onSeedingStarted(listener, options) {
+    this.listen("seeding-started", listener, options);
+  }
+  /**
+   * Register a listener on the "seeder-started" event.
+   */
+  static onSeederStarted(listener, options) {
+    this.listen("seeder-started", listener, options);
+  }
+  /**
+   * Register a listener on the "seeder-ended" event.
+   */
+  static onSeederEnded(listener, options) {
+    this.listen("seeder-ended", listener, options);
+  }
+  /**
+   * Register a listener on the "seeding-ended" event.
+   */
+  static onSeedingEnded(listener, options) {
+    this.listen("seeding-ended", listener, options);
+  }
+  /**
+   * Start recording every query that runs.
+   */
+  static enableQueryLog() {
+    if (this.#logger !== null) {
+      return;
+    }
+    this.#logger = (event) => {
+      const query = event;
+      this.#log.push({
+        connection: query.connection,
+        table: query.table,
+        plan: query.plan,
+        duration: query.duration,
+        records: query.records
+      });
+    };
+    Dispatcher.listen("db:query", this.#logger);
+  }
+  /**
+   * Stop recording queries.
+   */
+  static disableQueryLog() {
+    if (this.#logger === null) {
+      return;
+    }
+    Dispatcher.forget("db:query", this.#logger);
+    this.#logger = null;
+  }
+  /**
+   * Get the recorded queries.
+   */
+  static getQueryLog() {
+    return [...this.#log];
+  }
+  /**
+   * Discard the recorded queries.
+   */
+  static flushQueryLog() {
+    this.#log = [];
+  }
+  /**
+   * Determine whether queries are being recorded.
+   */
+  static logging() {
+    return this.#logger !== null;
+  }
+};
+
+// src/migrations/Migration.ts
+var Migration = class {
+  /**
+   * Get the name of the migration.
+   */
+  name() {
+    return this.constructor.name;
+  }
+};
+
+// src/schema/Schema.ts
+var Schema = class {
+  /**
+   * Get the table names the database layer reserves for itself.
+   */
+  static reserved() {
+    return [Repository.table, Registry.table];
+  }
+  /**
+   * Get a connection to read schema information from.
+   */
+  static connection(name) {
+    return DatabaseManager.connection(name);
+  }
+  /**
+   * Determine whether a table exists.
+   */
+  static hasTable(table) {
+    return this.connection().hasTable(table);
+  }
+  /**
+   * Determine whether a table has a column.
+   */
+  static hasColumn(table, column) {
+    return this.connection().hasColumn(table, column);
+  }
+  /**
+   * Get the names of every table.
+   */
+  static getTables() {
+    return this.connection().tables();
+  }
+  /**
+   * Get the columns of a table.
+   */
+  static getColumns(table) {
+    return this.connection().getColumns(table);
+  }
+  /**
+   * Get the indexes of a table.
+   */
+  static getIndexes(table) {
+    return this.connection().getIndexes(table);
+  }
+  /**
+   * Create a table.
+   */
+  static async create(table, callback) {
+    const context = this.#context("create");
+    this.#available(table);
+    if (context.database.objectStoreNames.contains(table)) {
+      throw new SchemaException(`Table [${table}] already exists.`);
+    }
+    const blueprint = new Blueprint(table);
+    callback(blueprint);
+    const schema = blueprint.toSchema();
+    const store = context.database.createObjectStore(table, this.#options(schema));
+    for (const index of schema.indexes) {
+      this.#createIndex(store, index);
+    }
+    this.#record(context, schema);
+    await Promise.resolve();
+  }
+  /**
+   * Alter a table.
+   */
+  static async table(table, callback) {
+    const context = this.#context("table");
+    const existing = this.#existing(context, table);
+    const blueprint = new Blueprint(table, existing);
+    callback(blueprint);
+    const schema = blueprint.toSchema();
+    const operations = blueprint.operations();
+    this.#immovable(existing, operations);
+    const store = context.transaction.objectStore(table);
+    for (const name of operations.unindexed) {
+      store.deleteIndex(name);
+    }
+    for (const index of operations.indexed) {
+      this.#createIndex(store, index);
+    }
+    await this.#rewrite(store, operations);
+    this.#record(context, schema);
+  }
+  /**
+   * Drop a table.
+   */
+  static async drop(table) {
+    const context = this.#context("drop");
+    this.#existing(context, table);
+    this.#delete(context, table);
+    await Promise.resolve();
+  }
+  /**
+   * Drop a table, if it exists.
+   */
+  static async dropIfExists(table) {
+    const context = this.#context("dropIfExists");
+    if (context.schemas.has(table)) {
+      this.#delete(context, table);
+    }
+    await Promise.resolve();
+  }
+  /**
+   * Rename a table, copying every record into the new one.
+   */
+  static async rename(from, to) {
+    const context = this.#context("rename");
+    const schema = this.#existing(context, from);
+    this.#available(to);
+    if (context.database.objectStoreNames.contains(to)) {
+      throw new SchemaException(`Table [${to}] already exists.`);
+    }
+    const target = context.database.createObjectStore(to, this.#options(schema));
+    for (const index of schema.indexes) {
+      this.#createIndex(target, index);
+    }
+    const source = context.transaction.objectStore(from);
+    await Request.walk(source.openCursor(), (cursor) => {
+      if (schema.key === null) {
+        target.add(cursor.value, cursor.primaryKey);
+        return;
+      }
+      target.add(cursor.value);
+    });
+    this.#delete(context, from);
+    this.#record(context, { ...schema, table: to });
+  }
+  /**
+   * Get the active migration context, or fail when there is none.
+   */
+  static #context(operation) {
+    if (Migrator.context() === null) {
+      throw new SchemaException(`Schema.${operation}() may only be called inside a migration.`);
+    }
+    return Migrator.alive();
+  }
+  /**
+   * Get the schema of a table that must already exist.
+   */
+  static #existing(context, table) {
+    const schema = context.schemas.get(table);
+    if (schema === void 0) {
+      throw new TableNotFoundException(table);
+    }
+    return schema;
+  }
+  /**
+   * Assert the table name is not reserved by the database layer.
+   */
+  static #available(table) {
+    if (this.reserved().includes(table)) {
+      throw new ReservedTableException(table);
+    }
+  }
+  /**
+   * Assert the operations leave the key path of the table alone.
+   */
+  static #immovable(existing, operations) {
+    if (existing.key === null) {
+      return;
+    }
+    const moved = operations.dropped.includes(existing.key) || operations.renamed.some((rename) => rename.from === existing.key);
+    if (moved) {
+      throw new SchemaException(`Column [${existing.key}] is the key path of table [${existing.table}] and may not be dropped or renamed.`);
+    }
+  }
+  /**
+   * Get the store options describing the key of a table.
+   */
+  static #options(schema) {
+    if (schema.key === null) {
+      return { autoIncrement: true };
+    }
+    return { keyPath: schema.key, autoIncrement: schema.increments };
+  }
+  /**
+   * Create an index on a store.
+   */
+  static #createIndex(store, index) {
+    const path = index.columns.length === 1 ? index.columns[0] : index.columns;
+    store.createIndex(index.name, path, { unique: index.unique, multiEntry: index.multiEntry });
+  }
+  /**
+   * Rewrite every record of a store to match the applied operations.
+   */
+  static async #rewrite(store, operations) {
+    const backfill = operations.added.filter((column) => column.hasDefault);
+    if (backfill.length === 0 && operations.dropped.length === 0 && operations.renamed.length === 0) {
+      return;
+    }
+    await Request.walk(store.openCursor(), (cursor) => {
+      const record = { ...cursor.value };
+      for (const column of backfill) {
+        if (!Object.hasOwn(record, column.name)) {
+          record[column.name] = column.default;
+        }
+      }
+      for (const rename of operations.renamed) {
+        record[rename.to] = record[rename.from];
+        delete record[rename.from];
+      }
+      for (const column of operations.dropped) {
+        delete record[column];
+      }
+      cursor.update(record);
+    });
+  }
+  /**
+   * Record the schema of a table, in the registry and the context cache.
+   */
+  static #record(context, schema) {
+    Registry.put(context.transaction, schema);
+    context.schemas.set(schema.table, schema);
+  }
+  /**
+   * Delete a table, from the database, the registry and the context cache.
+   */
+  static #delete(context, table) {
+    context.database.deleteObjectStore(table);
+    Registry.forget(context.transaction, table);
+    context.schemas.delete(table);
+  }
+};
+
+// src/seeders/Seeder.ts
+var Seeder = class {
+  /**
+   * Get the name of the seeder.
+   */
+  name() {
+    return this.constructor.name;
+  }
+};
+export {
+  Blueprint,
+  Builder,
+  CheckConstraintViolationException,
+  ColumnDefinition,
+  Connection,
+  ConnectionNotConfiguredException,
+  DatabaseManager as DB,
+  DatabaseBlocked,
+  DatabaseBlockedException,
+  DatabaseManager,
+  Grouping,
+  Join,
+  Migration,
+  MigrationEnded,
+  MigrationMismatchException,
+  MigrationStarted,
+  MigrationTransactionClosedException,
+  MigrationsEnded,
+  MigrationsStarted,
+  MultipleRecordsFoundException,
+  NoPendingMigrations,
+  NotNullConstraintViolationException,
+  QueryExecuted,
+  QuotaExceededException,
+  RecordsNotFoundException,
+  ReservedTableException,
+  Schema,
+  SchemaException,
+  Seeder,
+  SeederEnded,
+  SeederStarted,
+  SeedingEnded,
+  SeedingStarted,
+  TableNotFoundException,
+  Transaction,
+  TransactionBeginning,
+  TransactionCommitted,
+  TransactionRolledBack,
+  UniqueConstraintViolationException
+};