@mailwoman/sqlite 9.4.0 → 10.1.0

package/lib/sealed/db.ts

@@ -0,0 +1,191 @@
+/**
+ * @copyright Sister Software
+ * @license AGPL-3.0
+ * @author Teffen Ellis, et al.
+ *
+ *   The sealed-artifact invariant: every SQLite DB a build produces is a read-only asset. `sealDatabase`
+ *   is the last step of every builder — checkpoint, freeze the journal, chmod 0444. `openBuiltClient`
+ *   (`@mailwoman/sqlite/sealed`) is how anything opens a data artifact. a write-mode open of a sealed
+ *   file throws a descriptive error pointing at the rebuild command instead of a cryptic SQLITE_READONLY.
+ *   A caller can restore write permission only with manual `chmod u+w`; the program never changes permissions.
+ *   Rebuild the artifact to make changes.
+ *
+ *   `swapDatabaseIntoPlace` is the atomic publish step agents.md
+ *   specifies in prose ("build it successfully. Move the previous version to a temp directory.
+ *   Move the new version into place."). It lives here because this module already owns the
+ *   built-artifact lifecycle. A rule stated in project prose and implemented by several builders belongs in a
+ *   shared function.
+ */
+
+import type { DatabaseSync } from "node:sqlite"
+
+import { pathExists, statPath } from "@mailwoman/core/fs/readers"
+import { changeMode, movePath, removePath, removePathIfPresent } from "@mailwoman/core/fs/writers"
+import { basename, type PathBuilderLike } from "path-ts"
+
+/**
+ * The one capability {@link assertDatabaseIntegrity} needs.
+ *
+ * A narrow callback type lets a `DatabaseClient` satisfy the parameter with no import and no cast.
+ */
+type IntegrityProbe = Pick<DatabaseSync, "prepare">
+
+/**
+ * `node:sqlite` via {@link process.getBuiltinModule} — invisible to bundlers.
+ *
+ * A static import here would ride the `@mailwoman/core/utils` barrel into every consumer.
+ * The docs' plugin loader transpiles `docusaurus.config` imports and cannot resolve
+ * `node:sqlite` (CI: "Cannot find module 'sqlite'").
+ *
+ * The builtin accessor keeps `node:sqlite` out of the static import graph with zero resolve surface.
+ */
+function sqlite(): typeof import("node:sqlite") {
+	return process.getBuiltinModule("node:sqlite")
+}
+
+/**
+ * A write-mode open was attempted on a sealed (0444) data artifact.
+ */
+export class SealedArtifactError extends Error {
+	constructor(path: PathBuilderLike) {
+		super(
+			`${basename(path)} is a sealed read-only artifact — rebuild it via \`mailwoman gazetteer build …\`, ` +
+				`don't mutate it. (Deliberate unseal: chmod u+w — but prefer a rebuild.)`
+		)
+
+		this.name = "SealedArtifactError"
+	}
+}
+
+/**
+ * True when the artifact exists and has no write bits (the sealed state {@link sealDatabase} leaves).
+ */
+export async function isSealed(path: PathBuilderLike): Promise<boolean> {
+	return (await pathExists(path)) && ((await statPath(path)).mode & 0o222) === 0
+}
+
+/**
+ * Finalize a built DB: WAL-checkpoint → `journal_mode = delete` → remove
+ * `-wal`/`-shm` sidecars → `chmod 0o444`.
+ *
+ * Idempotent.
+ * Throws if the checkpoint cannot complete (another writer holds the DB).
+ */
+export async function sealDatabase(path: PathBuilderLike): Promise<void> {
+	// A previously sealed artifact needs the write bit back for the journal-mode switch.
+	if (await isSealed(path)) {
+		await changeMode(path, 0o644)
+	}
+
+	let mode: { journal_mode: string }
+
+	{
+		using db = new (sqlite().DatabaseSync)(path.toString())
+		const checkpoint = db.prepare("PRAGMA wal_checkpoint(TRUNCATE)").get() as { busy: number }
+
+		if (checkpoint.busy !== 0) {
+			throw new Error(`sealDatabase: WAL checkpoint busy on ${path} — close all writers first`)
+		}
+
+		mode = db.prepare("PRAGMA journal_mode = DELETE").get() as { journal_mode: string }
+	}
+
+	if (mode.journal_mode !== "delete") {
+		throw new Error(`sealDatabase: journal_mode switch failed on ${path} (still ${mode.journal_mode})`)
+	}
+
+	for (const sidecar of [`${path}-wal`, `${path}-shm`]) {
+		if (await pathExists(sidecar)) {
+			await removePath(sidecar)
+		}
+	}
+
+	await changeMode(path, 0o444)
+}
+
+/**
+ * Verify a freshly-built database is not corrupt, immediately before it is sealed and published.
+ *
+ * Belongs beside {@link sealDatabase} for the same reason `swapDatabaseIntoPlace` does.
+ * The check is part of the built-artifact lifecycle.
+ *
+ * Every builder previously ran its own copy.
+ * `integrity_check` answers with the single row `{ integrity_check: "ok" }` on a healthy file
+ * and one row per problem otherwise, so only the first matters.
+ *
+ * A builder that reads the column and compares it to `"ok"` has done the whole check.
+ *
+ * @throws When the database reports anything other than `ok`, naming the artifact and what SQLite said.
+ */
+export function assertDatabaseIntegrity(db: IntegrityProbe, artifact: PathBuilderLike): void {
+	const row = db.prepare("PRAGMA integrity_check").get() as { integrity_check: string } | undefined
+	const verdict = row?.integrity_check
+
+	if (verdict !== "ok") {
+		throw new Error(`integrity_check failed on ${basename(artifact)}: ${verdict ?? "no result"}`)
+	}
+}
+
+/**
+ * Refuse a write-mode open of a sealed artifact, naming the rebuild command
+ * instead of letting SQLite answer `SQLITE_READONLY`.
+ *
+ * The open itself lives in `@mailwoman/sqlite/sealed`.
+ * `openBuiltClient`, which every caller uses.
+ *
+ * This half stays here because it is a filesystem predicate.
+ * This module reaches `node:sqlite` through {@link process.getBuiltinModule} to
+ * keep the `@mailwoman/core/utils` barrel free of it.
+ *
+ * @throws {SealedArtifactError} When `path` is sealed.
+ */
+export async function assertUnsealedForWrite(path: PathBuilderLike): Promise<void> {
+	if (await isSealed(path)) throw new SealedArtifactError(path)
+}
+
+/**
+ * Atomically move a freshly-built database into its published location.
+ *
+ * The build writes to a temp path, so a mid-build crash never leaves a half-written DB at `finalPath`.
+ * This moves any prior version aside, slots the new one in, then drops the old.
+ *
+ * The previous file stays intact until the replacement is committed.
+ * The function clears the `-wal` and `-shm` siblings of both paths, so a stale
+ * journal cannot pair with a new main file.
+ *
+ * The code seals (`sealDatabase`) the temp file before the swap.
+ * The published artifact is sealed.
+ * Mode 0444 still permits a rename.
+ */
+export async function swapDatabaseIntoPlace(tmpPath: PathBuilderLike, finalPath: PathBuilderLike): Promise<void> {
+	const tmpPathString = tmpPath.toString()
+	const finalPathString = finalPath.toString()
+	const aside = `${finalPathString}.old-${process.pid}`
+
+	if (await pathExists(finalPathString)) {
+		await movePath(finalPathString, aside)
+	}
+
+	for (const sfx of ["-wal", "-shm"]) {
+		await removePathIfPresent(finalPathString + sfx)
+	}
+
+	try {
+		await movePath(tmpPathString, finalPathString)
+	} catch (error) {
+		// The prior version is already aside at this point.
+		// A failed forward rename must not leave the slot empty while a restorable
+		// artifact sits one rename away.
+		if ((await pathExists(aside)) && !(await pathExists(finalPathString))) {
+			await movePath(aside, finalPathString)
+		}
+
+		throw error
+	}
+
+	for (const sfx of ["-wal", "-shm"]) {
+		await removePathIfPresent(tmpPathString + sfx)
+	}
+
+	await removePathIfPresent(aside)
+}

package/lib/sealed.ts

@@ -3,29 +3,34 @@
  * @license AGPL-3.0
  * @author Teffen Ellis, et al.
  *
- *   Opening a built data artifact.
+ *   Open a built data artifact.
  *
  *   This is the other half of the sealed-artifact invariant in `../utils/sealed-db.ts`: that module owns the
  *   filesystem side (seal, unseal-refusal, atomic swap) and stays free of a static `node:sqlite` import, because it
- *   rides the `@mailwoman/core/utils` barrel into consumers that cannot resolve one. The open lives here, where
+ *   flows through the `@mailwoman/core/utils` barrel into consumers that cannot resolve one. The open lives here, where
  *   `DatabaseClient` is already imported and the cost is paid. The open is asynchronous: the write branch awaits the
  *   seal check against the filesystem before the handle is constructed.
  */
 
+import type { PathBuilderLike } from "path-ts"
+
 import { DatabaseClient } from "#client"
 import type { Database } from "#database-schema"
-import { assertUnsealedForWrite } from "#sealed-db"
+import { assertUnsealedForWrite } from "#sealed/db"
 
 /**
- * Open a built data artifact. Read-only by default; `write: true` is for builders working on UNsealed staging, and
- * throws `SealedArtifactError` against a sealed file.
+ * Open a built data artifact.
+ *
+ * Read-only by default.
+ * Builders set `write: true` when working on UNsealed staging.
+ * A sealed file raises `SealedArtifactError`.
  *
- * Together with `new DatabaseClient(path)` this is the whole set of ways a connection comes into being. `DatabaseSync`
- * is constructed in exactly one place, inside `DatabaseClient`, so no caller holds a raw handle and no database ends up
- * described by two schemas.
+ * Together with `new DatabaseClient(path)` this is the whole set of ways a connection comes into being.
+ * `DatabaseSync` is constructed in exactly one place, inside `DatabaseClient`,
+ * so no caller holds a raw handle and no database ends up described by two schemas.
  */
 export async function openBuiltClient<DB = Database>(
-	path: string,
+	path: PathBuilderLike,
 	opts: { write?: boolean } = {}
 ): Promise<DatabaseClient<DB>> {
 	if (opts.write) {

package/out/batched.d.ts

@@ -3,7 +3,7 @@
  * @license AGPL-3.0
  * @author Teffen Ellis, et al.
  *
- *   Batched bulk-write transactions — the `COMMIT`/`BEGIN` cadence every streaming ingest repeats around its
+ *   Batched bulk-write transactions — the `commit`/`begin` cadence every streaming ingest repeats around its
  *   raw prepared-statement loop.
  */
 /**
@@ -11,26 +11,20 @@
  */
 export interface BatchedTransaction {
     /**
-     * Record one written row. Every `rowsPerCommit` rows the open transaction is committed and a new one opened; answers
-     * `true` on the call that committed, so a caller can hang a progress report off the boundary.
+     * Record one written row, committing and reopening the transaction every `rowsPerCommit`
+     * rows and answering `true` on the call that committed.
      */
     rowWritten(): boolean;
-    /**
-     * Commit the open transaction — the ordinary end of an ingest loop.
-     */
     commit(): void;
     /**
-     * Best-effort `ROLLBACK`, and it must never replace the real error: a build runs with the journal off (nothing is
-     * ever published without the swap), so SQLite may refuse to unwind. What matters is that the caller sees WHY the
-     * ingest stopped, not that a scratch file was tidied.
+     * Best-effort `rollback` that must never replace the real error, so the caller
+     * still sees why the ingest stopped.
      */
     rollbackQuietly(): void;
 }
 /**
- * Open a transaction that commits and reopens itself every `rowsPerCommit` written rows.
- *
- * The batch size is the caller's: a geometry table whose rows carry a blob wants a smaller transaction than a
- * fixed-width staging table, because a larger one grows the write-ahead file without improving throughput.
+ * Open a transaction that commits and reopens itself every `rowsPerCommit` written rows,
+ * with the batch size left to the caller.
  */
 export declare function beginBatched(database: {
     exec(sql: string): void;

package/out/batched.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"batched.d.ts","sourceRoot":"","sources":["../lib/batched.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AAEH;;GAEG;AACH,MAAM,WAAW,kBAAkB;IAClC;;;OAGG;IACH,UAAU,IAAI,OAAO,CAAA;IACrB;;OAEG;IACH,MAAM,IAAI,IAAI,CAAA;IACd;;;;OAIG;IACH,eAAe,IAAI,IAAI,CAAA;CACvB;AAED;;;;;GAKG;AACH,wBAAgB,YAAY,CAC3B,QAAQ,EAAE;IAAE,IAAI,CAAC,GAAG,EAAE,MAAM,GAAG,IAAI,CAAA;CAAE,EACrC,OAAO,EAAE;IAAE,aAAa,EAAE,MAAM,CAAA;CAAE,GAChC,kBAAkB,CA6BpB"}
+{"version":3,"file":"batched.d.ts","sourceRoot":"","sources":["../lib/batched.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AAEH;;GAEG;AACH,MAAM,WAAW,kBAAkB;IAClC;;;OAGG;IACH,UAAU,IAAI,OAAO,CAAA;IACrB,MAAM,IAAI,IAAI,CAAA;IACd;;;OAGG;IACH,eAAe,IAAI,IAAI,CAAA;CACvB;AAED;;;GAGG;AACH,wBAAgB,YAAY,CAC3B,QAAQ,EAAE;IAAE,IAAI,CAAC,GAAG,EAAE,MAAM,GAAG,IAAI,CAAA;CAAE,EACrC,OAAO,EAAE;IAAE,aAAa,EAAE,MAAM,CAAA;CAAE,GAChC,kBAAkB,CA6BpB"}

package/out/batched.js

@@ -3,14 +3,12 @@
  * @license AGPL-3.0
  * @author Teffen Ellis, et al.
  *
- *   Batched bulk-write transactions — the `COMMIT`/`BEGIN` cadence every streaming ingest repeats around its
+ *   Batched bulk-write transactions — the `commit`/`begin` cadence every streaming ingest repeats around its
  *   raw prepared-statement loop.
  */
 /**
- * Open a transaction that commits and reopens itself every `rowsPerCommit` written rows.
- *
- * The batch size is the caller's: a geometry table whose rows carry a blob wants a smaller transaction than a
- * fixed-width staging table, because a larger one grows the write-ahead file without improving throughput.
+ * Open a transaction that commits and reopens itself every `rowsPerCommit` written rows,
+ * with the batch size left to the caller.
  */
 export function beginBatched(database, options) {
     let pending = 0;

package/out/batched.js.map

@@ -1 +1 @@
-{"version":3,"file":"batched.js","sourceRoot":"","sources":["../lib/batched.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AAuBH;;;;;GAKG;AACH,MAAM,UAAU,YAAY,CAC3B,QAAqC,EACrC,OAAkC;IAElC,IAAI,OAAO,GAAG,CAAC,CAAA;IAEf,QAAQ,CAAC,IAAI,CAAC,OAAO,CAAC,CAAA;IAEtB,OAAO;QACN,UAAU;YACT,OAAO,EAAE,CAAA;YAET,IAAI,OAAO,GAAG,OAAO,CAAC,aAAa;gBAAE,OAAO,KAAK,CAAA;YAEjD,QAAQ,CAAC,IAAI,CAAC,QAAQ,CAAC,CAAA;YACvB,QAAQ,CAAC,IAAI,CAAC,OAAO,CAAC,CAAA;YAEtB,OAAO,GAAG,CAAC,CAAA;YAEX,OAAO,IAAI,CAAA;QACZ,CAAC;QACD,MAAM;YACL,QAAQ,CAAC,IAAI,CAAC,QAAQ,CAAC,CAAA;QACxB,CAAC;QACD,eAAe;YACd,IAAI,CAAC;gBACJ,QAAQ,CAAC,IAAI,CAAC,UAAU,CAAC,CAAA;YAC1B,CAAC;YAAC,MAAM,CAAC;gBACR,6CAA6C;YAC9C,CAAC;QACF,CAAC;KACD,CAAA;AACF,CAAC"}
+{"version":3,"file":"batched.js","sourceRoot":"","sources":["../lib/batched.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AAmBH;;;GAGG;AACH,MAAM,UAAU,YAAY,CAC3B,QAAqC,EACrC,OAAkC;IAElC,IAAI,OAAO,GAAG,CAAC,CAAA;IAEf,QAAQ,CAAC,IAAI,CAAC,OAAO,CAAC,CAAA;IAEtB,OAAO;QACN,UAAU;YACT,OAAO,EAAE,CAAA;YAET,IAAI,OAAO,GAAG,OAAO,CAAC,aAAa;gBAAE,OAAO,KAAK,CAAA;YAEjD,QAAQ,CAAC,IAAI,CAAC,QAAQ,CAAC,CAAA;YACvB,QAAQ,CAAC,IAAI,CAAC,OAAO,CAAC,CAAA;YAEtB,OAAO,GAAG,CAAC,CAAA;YAEX,OAAO,IAAI,CAAA;QACZ,CAAC;QACD,MAAM;YACL,QAAQ,CAAC,IAAI,CAAC,QAAQ,CAAC,CAAA;QACxB,CAAC;QACD,eAAe;YACd,IAAI,CAAC;gBACJ,QAAQ,CAAC,IAAI,CAAC,UAAU,CAAC,CAAA;YAC1B,CAAC;YAAC,MAAM,CAAC;gBACR,6CAA6C;YAC9C,CAAC;QACF,CAAC;KACD,CAAA;AACF,CAAC"}

package/out/client.d.ts

@@ -7,80 +7,53 @@ import { DatabaseSync, type DatabaseSyncOptions, type FunctionOptions, type SQLI
 import { Kysely, type KyselyConfig } from "kysely";
 import { type PathBuilderLike } from "path-ts";
 import type { Database } from "#database-schema";
-import type { SqliteDialectConfig } from "#dialect-config";
-/**
- * A SQLite client for one database file: a Kysely query builder over `node:sqlite`, plus the two raw statements Kysely
- * cannot express.
- *
- * The client opens the file. A caller says which file and which schema; it never builds the connection itself.
- *
- * ```ts
- * using kdb = new DatabaseClient<MySchema>("db.sqlite", { readOnly: true })
- * ```
- *
- * Handing that job to callers is what let one database be described by two schemas — the type argument here and a
- * second one on the handle — with nothing to make them agree. It also split ownership: `SqliteDriver.destroy()` closes
- * whatever connection it was given, so a shared handle has two owners and the first `destroy()` closes it under the
- * other. One construction gives one schema, one owner, and a lifetime `using` can end.
- *
- * `exec` and `prepare` reach the same connection for the work Kysely does not model. See `core/db/schema.ts`.
- */
+import type { SqliteDialectConfig } from "#dialect/config";
 /**
  * A connection's non-Kysely surface: the statements Kysely does not model, plus ending the connection.
  *
- * Schema-agnostic by construction — none of these members mentions `DB` — so a `DatabaseClient<AnySchema>` satisfies it
- * and a helper need not name its caller's schema. That matters because Kysely is INVARIANT in `DB`: a parameter typed
- * `DatabaseClient` (the empty default) would reject every real client. This is the narrowing the
- * `mailwoman/no-database-handle-cast` rule prescribes, applied to the raw side.
+ * Schema-agnostic because Kysely is invariant in `DB`: a parameter typed
+ * `DatabaseClient` would reject every real client.
  */
 export type RawStatements = Pick<DatabaseClient, "exec" | "prepare" | "function" | "destroy"> & Disposable;
+/**
+ * A SQLite client for one database file: a Kysely query builder over `node:sqlite`,
+ * plus the two raw statements Kysely cannot express.
+ */
 export declare class DatabaseClient<DB = Database> extends Kysely<DB> implements Disposable {
     #private;
     /**
-     * A memory-only database, for tests and other ephemeral work. The connection is open until the client is disposed.
+     * A memory-only database, for tests and other ephemeral work.
      */
     static temp<DB = Database>(): DatabaseClient<DB>;
     constructor(location: PathBuilderLike, options?: DatabaseSyncOptions, config?: Partial<KyselyConfig>);
     constructor(database: DatabaseSync, config?: Partial<KyselyConfig>);
     constructor(dialectConfig: SqliteDialectConfig, config?: Partial<KyselyConfig>);
     /**
-     * Run a statement Kysely does not model: `PRAGMA`, `VACUUM`, `ANALYZE`, `ATTACH`, FTS5 virtual-table DDL.
-     *
-     * Not to be confused with Kysely's `execute()`, which runs a compiled query. This one takes SQL text and returns
-     * nothing.
+     * Run a statement Kysely does not model: `pragma`, `vacuum`, `analyze`, `attach`, FTS5 virtual-table DDL.
      */
     exec(sql: string): void;
     /**
      * A prepared statement on this client's connection, for the bulk-write path.
-     *
-     * Kysely compiles per call, which a positional insert loop over millions of rows cannot afford. Reach for this only
-     * there and in the other cases `AGENTS.md` lists as deliberately raw; everything cold goes through the query builder,
-     * where the schema is checked.
      */
     prepare(sql: string): StatementSync;
     /**
      * Register a user-defined SQL function on this client's connection, callable from any statement it runs.
      *
-     * SQLite resolves the name at statement-compile time, so registration must precede the first query that uses it.
+     * SQLite resolves the name at statement-compile time, so registration must
+     * precede the first query that uses it.
      */
     function(name: string, options: FunctionOptions, fn: (...args: SQLOutputValue[]) => SQLInputValue): void;
     function(name: string, fn: (...args: SQLOutputValue[]) => SQLInputValue): void;
     /**
      * End the connection at scope exit, synchronously.
      *
-     * `destroy()` is Kysely's teardown and returns a promise, which `Symbol.dispose` cannot await — calling it here would
-     * return with the file still open, and the next thing to touch that path (a `sealDatabase`, a reader expecting a
-     * finalized statement) would see a connection that should have been gone. `node:sqlite`'s `close()` is synchronous,
-     * so `using` closes the file before the scope ends.
-     *
-     * Kysely's own driver state is not unwound here. It holds this one connection and nothing else, and a query issued
-     * afterwards fails on the closed handle rather than on a pool that thinks it is alive.
+     * `destroy()` returns a promise, so `Symbol.dispose` cannot call it.
+     * `node:sqlite`'s `close()` is synchronous.
      */
     [Symbol.dispose](): void;
 }
 /**
- * The `node:sqlite` types a caller needs when it holds a statement or binds a value. Re-exported so nothing has to
- * reach past this package for them.
+ * The `node:sqlite` types a caller needs when it holds a statement or binds a value.
  */
 export type { DatabaseSyncOptions, SQLInputValue, SQLOutputValue, StatementSync } from "node:sqlite";
 //# sourceMappingURL=client.d.ts.map

package/out/client.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"client.d.ts","sourceRoot":"","sources":["../lib/client.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAEH,OAAO,EACN,YAAY,EACZ,KAAK,mBAAmB,EACxB,KAAK,eAAe,EACpB,KAAK,aAAa,EAClB,KAAK,cAAc,EACnB,KAAK,aAAa,EAClB,MAAM,aAAa,CAAA;AAEpB,OAAO,EAAE,MAAM,EAAE,KAAK,YAAY,EAAE,MAAM,QAAQ,CAAA;AAClD,OAAO,EAAe,KAAK,eAAe,EAAE,MAAM,SAAS,CAAA;AAE3D,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,kBAAkB,CAAA;AAEhD,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,iBAAiB,CAAA;AAE1D;;;;;;;;;;;;;;;;GAgBG;AACH;;;;;;;GAOG;AACH,MAAM,MAAM,aAAa,GAAG,IAAI,CAAC,cAAc,EAAE,MAAM,GAAG,SAAS,GAAG,UAAU,GAAG,SAAS,CAAC,GAAG,UAAU,CAAA;AAE1G,qBAAa,cAAc,CAAC,EAAE,GAAG,QAAQ,CAAE,SAAQ,MAAM,CAAC,EAAE,CAAE,YAAW,UAAU;;IAClF;;OAEG;WACW,IAAI,CAAC,EAAE,GAAG,QAAQ,KAAK,cAAc,CAAC,EAAE,CAAC;gBAM3C,QAAQ,EAAE,eAAe,EAAE,OAAO,CAAC,EAAE,mBAAmB,EAAE,MAAM,CAAC,EAAE,OAAO,CAAC,YAAY,CAAC;gBACxF,QAAQ,EAAE,YAAY,EAAE,MAAM,CAAC,EAAE,OAAO,CAAC,YAAY,CAAC;gBACtD,aAAa,EAAE,mBAAmB,EAAE,MAAM,CAAC,EAAE,OAAO,CAAC,YAAY,CAAC;IAuC9E;;;;;OAKG;IACH,IAAI,CAAC,GAAG,EAAE,MAAM,GAAG,IAAI;IAIvB;;;;;;OAMG;IACH,OAAO,CAAC,GAAG,EAAE,MAAM,GAAG,aAAa;IAInC;;;;OAIG;IACH,QAAQ,CAAC,IAAI,EAAE,MAAM,EAAE,OAAO,EAAE,eAAe,EAAE,EAAE,EAAE,CAAC,GAAG,IAAI,EAAE,cAAc,EAAE,KAAK,aAAa,GAAG,IAAI;IACxG,QAAQ,CAAC,IAAI,EAAE,MAAM,EAAE,EAAE,EAAE,CAAC,GAAG,IAAI,EAAE,cAAc,EAAE,KAAK,aAAa,GAAG,IAAI;IAe9E;;;;;;;;;;OAUG;IACH,CAAC,MAAM,CAAC,OAAO,CAAC,IAAI,IAAI;CAGxB;AAED;;;GAGG;AACH,YAAY,EAAE,mBAAmB,EAAE,aAAa,EAAE,cAAc,EAAE,aAAa,EAAE,MAAM,aAAa,CAAA"}
+{"version":3,"file":"client.d.ts","sourceRoot":"","sources":["../lib/client.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAEH,OAAO,EACN,YAAY,EACZ,KAAK,mBAAmB,EACxB,KAAK,eAAe,EACpB,KAAK,aAAa,EAClB,KAAK,cAAc,EACnB,KAAK,aAAa,EAClB,MAAM,aAAa,CAAA;AAEpB,OAAO,EAAE,MAAM,EAAE,KAAK,YAAY,EAAE,MAAM,QAAQ,CAAA;AAClD,OAAO,EAAe,KAAK,eAAe,EAAE,MAAM,SAAS,CAAA;AAE3D,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,kBAAkB,CAAA;AAEhD,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,iBAAiB,CAAA;AAE1D;;;;;GAKG;AACH,MAAM,MAAM,aAAa,GAAG,IAAI,CAAC,cAAc,EAAE,MAAM,GAAG,SAAS,GAAG,UAAU,GAAG,SAAS,CAAC,GAAG,UAAU,CAAA;AAE1G;;;GAGG;AACH,qBAAa,cAAc,CAAC,EAAE,GAAG,QAAQ,CAAE,SAAQ,MAAM,CAAC,EAAE,CAAE,YAAW,UAAU;;IAClF;;OAEG;IACH,OAAc,IAAI,CAAC,EAAE,GAAG,QAAQ,KAAK,cAAc,CAAC,EAAE,CAAC,CAEtD;IAID,YAAY,QAAQ,EAAE,eAAe,EAAE,OAAO,CAAC,EAAE,mBAAmB,EAAE,MAAM,CAAC,EAAE,OAAO,CAAC,YAAY,CAAC,EAAC;IACrG,YAAY,QAAQ,EAAE,YAAY,EAAE,MAAM,CAAC,EAAE,OAAO,CAAC,YAAY,CAAC,EAAC;IACnE,YAAY,aAAa,EAAE,mBAAmB,EAAE,MAAM,CAAC,EAAE,OAAO,CAAC,YAAY,CAAC,EAAC;IAuC/E;;OAEG;IACH,IAAI,CAAC,GAAG,EAAE,MAAM,GAAG,IAAI,CAEtB;IAED;;OAEG;IACH,OAAO,CAAC,GAAG,EAAE,MAAM,GAAG,aAAa,CAElC;IAED;;;;;OAKG;IACH,QAAQ,CAAC,IAAI,EAAE,MAAM,EAAE,OAAO,EAAE,eAAe,EAAE,EAAE,EAAE,CAAC,GAAG,IAAI,EAAE,cAAc,EAAE,KAAK,aAAa,GAAG,IAAI,CAAA;IACxG,QAAQ,CAAC,IAAI,EAAE,MAAM,EAAE,EAAE,EAAE,CAAC,GAAG,IAAI,EAAE,cAAc,EAAE,KAAK,aAAa,GAAG,IAAI,CAAA;IAe9E;;;;;OAKG;IACH,CAAC,MAAM,CAAC,OAAO,CAAC,IAAI,IAAI,CAEvB;CACD;AAED;;GAEG;AACH,YAAY,EAAE,mBAAmB,EAAE,aAAa,EAAE,cAAc,EAAE,aAAa,EAAE,MAAM,aAAa,CAAA"}

package/out/client.js

@@ -7,9 +7,13 @@ import { DatabaseSync, } from "node:sqlite";
 import { Kysely } from "kysely";
 import { PathBuilder } from "path-ts";
 import { SqliteDialect } from "#dialect";
+/**
+ * A SQLite client for one database file: a Kysely query builder over `node:sqlite`,
+ * plus the two raw statements Kysely cannot express.
+ */
 export class DatabaseClient extends Kysely {
     /**
-     * A memory-only database, for tests and other ephemeral work. The connection is open until the client is disposed.
+     * A memory-only database, for tests and other ephemeral work.
      */
     static temp() {
         return new DatabaseClient(":memory:");
@@ -21,7 +25,7 @@ export class DatabaseClient extends Kysely {
         if (typeof source === "string" || source instanceof PathBuilder) {
             const location = source.toString();
             const options = optionsOrConfig;
-            // node:sqlite checks the argument count, not the value: `new DatabaseSync(path, undefined)` throws.
+            // node:sqlite checks the argument count rather than the value: `new DatabaseSync(path, undefined)` throws.
             const openArgs = options ? [location, options] : [location];
             database = new DatabaseSync(...openArgs);
             kyselyConfig = config;
@@ -42,20 +46,13 @@ export class DatabaseClient extends Kysely {
         this.#database = database;
     }
     /**
-     * Run a statement Kysely does not model: `PRAGMA`, `VACUUM`, `ANALYZE`, `ATTACH`, FTS5 virtual-table DDL.
-     *
-     * Not to be confused with Kysely's `execute()`, which runs a compiled query. This one takes SQL text and returns
-     * nothing.
+     * Run a statement Kysely does not model: `pragma`, `vacuum`, `analyze`, `attach`, FTS5 virtual-table DDL.
      */
     exec(sql) {
         this.#database.exec(sql);
     }
     /**
      * A prepared statement on this client's connection, for the bulk-write path.
-     *
-     * Kysely compiles per call, which a positional insert loop over millions of rows cannot afford. Reach for this only
-     * there and in the other cases `AGENTS.md` lists as deliberately raw; everything cold goes through the query builder,
-     * where the schema is checked.
      */
     prepare(sql) {
         return this.#database.prepare(sql);
@@ -70,13 +67,8 @@ export class DatabaseClient extends Kysely {
     /**
      * End the connection at scope exit, synchronously.
      *
-     * `destroy()` is Kysely's teardown and returns a promise, which `Symbol.dispose` cannot await — calling it here would
-     * return with the file still open, and the next thing to touch that path (a `sealDatabase`, a reader expecting a
-     * finalized statement) would see a connection that should have been gone. `node:sqlite`'s `close()` is synchronous,
-     * so `using` closes the file before the scope ends.
-     *
-     * Kysely's own driver state is not unwound here. It holds this one connection and nothing else, and a query issued
-     * afterwards fails on the closed handle rather than on a pool that thinks it is alive.
+     * `destroy()` returns a promise, so `Symbol.dispose` cannot call it.
+     * `node:sqlite`'s `close()` is synchronous.
      */
     [Symbol.dispose]() {
         this.#database[Symbol.dispose]();

package/out/client.js.map

@@ -1 +1 @@
-{"version":3,"file":"client.js","sourceRoot":"","sources":["../lib/client.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAEH,OAAO,EACN,YAAY,GAMZ,MAAM,aAAa,CAAA;AAEpB,OAAO,EAAE,MAAM,EAAqB,MAAM,QAAQ,CAAA;AAClD,OAAO,EAAE,WAAW,EAAwB,MAAM,SAAS,CAAA;AAG3D,OAAO,EAAE,aAAa,EAAE,MAAM,UAAU,CAAA;AA8BxC,MAAM,OAAO,cAA8B,SAAQ,MAAU;IAC5D;;OAEG;IACI,MAAM,CAAC,IAAI;QACjB,OAAO,IAAI,cAAc,CAAK,UAAU,CAAC,CAAA;IAC1C,CAAC;IAEQ,SAAS,CAAc;IAKhC,YACC,MAA4D,EAC5D,eAA6D,EAC7D,MAA8B;QAE9B,IAAI,QAAsB,CAAA;QAC1B,IAAI,YAA+C,CAAA;QAEnD,IAAI,OAAO,MAAM,KAAK,QAAQ,IAAI,MAAM,YAAY,WAAW,EAAE,CAAC;YACjE,MAAM,QAAQ,GAAG,MAAM,CAAC,QAAQ,EAAE,CAAA;YAClC,MAAM,OAAO,GAAG,eAAkD,CAAA;YAClE,oGAAoG;YACpG,MAAM,QAAQ,GAAmC,OAAO,CAAC,CAAC,CAAC,CAAC,QAAQ,EAAE,OAAO,CAAC,CAAC,CAAC,CAAC,CAAC,QAAQ,CAAC,CAAA;YAE3F,QAAQ,GAAG,IAAI,YAAY,CAAC,GAAG,QAAQ,CAAC,CAAA;YACxC,YAAY,GAAG,MAAM,CAAA;QACtB,CAAC;aAAM,CAAC;YACP,MAAM,aAAa,GAAG,UAAU,IAAI,MAAM,CAAC,CAAC,CAAC,MAAM,CAAC,CAAC,CAAC,EAAE,QAAQ,EAAE,MAAM,EAAE,CAAA;YAE1E,IAAI,OAAO,aAAa,CAAC,QAAQ,KAAK,UAAU,EAAE,CAAC;gBAClD,MAAM,IAAI,SAAS,CAClB,kGAAkG;oBACjG,kEAAkE,CACnE,CAAA;YACF,CAAC;YAED,QAAQ,GAAG,aAAa,CAAC,QAAQ,CAAA;YACjC,YAAY,GAAG,eAAoD,CAAA;QACpE,CAAC;QAED,KAAK,CAAC;YACL,GAAG,YAAY;YACf,OAAO,EAAE,IAAI,aAAa,CAAC,EAAE,QAAQ,EAAE,CAAC;SACxC,CAAC,CAAA;QAEF,IAAI,CAAC,SAAS,GAAG,QAAQ,CAAA;IAC1B,CAAC;IAED;;;;;OAKG;IACH,IAAI,CAAC,GAAW;QACf,IAAI,CAAC,SAAS,CAAC,IAAI,CAAC,GAAG,CAAC,CAAA;IACzB,CAAC;IAED;;;;;;OAMG;IACH,OAAO,CAAC,GAAW;QAClB,OAAO,IAAI,CAAC,SAAS,CAAC,OAAO,CAAC,GAAG,CAAC,CAAA;IACnC,CAAC;IASD,QAAQ,CACP,IAAY,EACZ,WAA6E,EAC7E,EAAiD;QAEjD,IAAI,OAAO,WAAW,KAAK,UAAU,EAAE,CAAC;YACvC,IAAI,CAAC,SAAS,CAAC,QAAQ,CAAC,IAAI,EAAE,WAAW,CAAC,CAAA;YAE1C,OAAM;QACP,CAAC;QAED,IAAI,CAAC,SAAS,CAAC,QAAQ,CAAC,IAAI,EAAE,WAAW,EAAE,EAAG,CAAC,CAAA;IAChD,CAAC;IAED;;;;;;;;;;OAUG;IACH,CAAC,MAAM,CAAC,OAAO,CAAC;QACf,IAAI,CAAC,SAAS,CAAC,MAAM,CAAC,OAAO,CAAC,EAAE,CAAA;IACjC,CAAC;CACD"}
+{"version":3,"file":"client.js","sourceRoot":"","sources":["../lib/client.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAEH,OAAO,EACN,YAAY,GAMZ,MAAM,aAAa,CAAA;AAEpB,OAAO,EAAE,MAAM,EAAqB,MAAM,QAAQ,CAAA;AAClD,OAAO,EAAE,WAAW,EAAwB,MAAM,SAAS,CAAA;AAG3D,OAAO,EAAE,aAAa,EAAE,MAAM,UAAU,CAAA;AAWxC;;;GAGG;AACH,MAAM,OAAO,cAA8B,SAAQ,MAAU;IAC5D;;OAEG;IACI,MAAM,CAAC,IAAI;QACjB,OAAO,IAAI,cAAc,CAAK,UAAU,CAAC,CAAA;IAC1C,CAAC;IAEQ,SAAS,CAAc;IAKhC,YACC,MAA4D,EAC5D,eAA6D,EAC7D,MAA8B;QAE9B,IAAI,QAAsB,CAAA;QAC1B,IAAI,YAA+C,CAAA;QAEnD,IAAI,OAAO,MAAM,KAAK,QAAQ,IAAI,MAAM,YAAY,WAAW,EAAE,CAAC;YACjE,MAAM,QAAQ,GAAG,MAAM,CAAC,QAAQ,EAAE,CAAA;YAClC,MAAM,OAAO,GAAG,eAAkD,CAAA;YAClE,2GAA2G;YAC3G,MAAM,QAAQ,GAAmC,OAAO,CAAC,CAAC,CAAC,CAAC,QAAQ,EAAE,OAAO,CAAC,CAAC,CAAC,CAAC,CAAC,QAAQ,CAAC,CAAA;YAE3F,QAAQ,GAAG,IAAI,YAAY,CAAC,GAAG,QAAQ,CAAC,CAAA;YACxC,YAAY,GAAG,MAAM,CAAA;QACtB,CAAC;aAAM,CAAC;YACP,MAAM,aAAa,GAAG,UAAU,IAAI,MAAM,CAAC,CAAC,CAAC,MAAM,CAAC,CAAC,CAAC,EAAE,QAAQ,EAAE,MAAM,EAAE,CAAA;YAE1E,IAAI,OAAO,aAAa,CAAC,QAAQ,KAAK,UAAU,EAAE,CAAC;gBAClD,MAAM,IAAI,SAAS,CAClB,kGAAkG;oBACjG,kEAAkE,CACnE,CAAA;YACF,CAAC;YAED,QAAQ,GAAG,aAAa,CAAC,QAAQ,CAAA;YACjC,YAAY,GAAG,eAAoD,CAAA;QACpE,CAAC;QAED,KAAK,CAAC;YACL,GAAG,YAAY;YACf,OAAO,EAAE,IAAI,aAAa,CAAC,EAAE,QAAQ,EAAE,CAAC;SACxC,CAAC,CAAA;QAEF,IAAI,CAAC,SAAS,GAAG,QAAQ,CAAA;IAC1B,CAAC;IAED;;OAEG;IACH,IAAI,CAAC,GAAW;QACf,IAAI,CAAC,SAAS,CAAC,IAAI,CAAC,GAAG,CAAC,CAAA;IACzB,CAAC;IAED;;OAEG;IACH,OAAO,CAAC,GAAW;QAClB,OAAO,IAAI,CAAC,SAAS,CAAC,OAAO,CAAC,GAAG,CAAC,CAAA;IACnC,CAAC;IAUD,QAAQ,CACP,IAAY,EACZ,WAA6E,EAC7E,EAAiD;QAEjD,IAAI,OAAO,WAAW,KAAK,UAAU,EAAE,CAAC;YACvC,IAAI,CAAC,SAAS,CAAC,QAAQ,CAAC,IAAI,EAAE,WAAW,CAAC,CAAA;YAE1C,OAAM;QACP,CAAC;QAED,IAAI,CAAC,SAAS,CAAC,QAAQ,CAAC,IAAI,EAAE,WAAW,EAAE,EAAG,CAAC,CAAA;IAChD,CAAC;IAED;;;;;OAKG;IACH,CAAC,MAAM,CAAC,OAAO,CAAC;QACf,IAAI,CAAC,SAAS,CAAC,MAAM,CAAC,OAAO,CAAC,EAAE,CAAA;IACjC,CAAC;CACD"}

package/out/database-schema.d.ts

@@ -3,28 +3,10 @@
  * @license AGPL-3.0
  * @author Teffen Ellis, et al.
  *
- *   Shared `Database` typing for the Kysely client at `core/kysley/client.ts`.
- *
- *   This file intentionally ships an empty schema. Consumers that want compile-time table typing
- *   should extend `Kysely<TheirSchema>` directly rather than baking a schema into core — the WOF
- *   resolver (Phase 4.2), corpus adapters, and any future consumer all touch different tables.
- *
- *   The exported `Database` interface exists so `client.ts` has a target for `Kysely<Database>` and
- *   the boilerplate compiles without forcing a concrete schema commitment.
- *
- *   IT IS THE DEFAULT, NOT THE ONLY OPTION, and reading it as the only option is how `as never` gets written. Every
- *   table name typed against `Record<string, never>` IS `never`, so `insertInto("poi")` cannot compile and a caller
- *   who believes no alternative exists casts — which disarms not just that one check but every type-level guarantee
- *   anyone later adds to the table (#1757 has the worked case: a branded key column whose check a neighbouring
- *   `as never` had already defeated).
+ *   Default schema type for {@link DatabaseClient}; consumers supply their own table schema.
  */
 /**
- * Empty schema marker, and the DEFAULT type argument only.
- *
- * Consumers declare their own schema interface and pass it directly: `new Kysely<MySchema>({…})` or `new
- * DatabaseClient<MySchema>(…)`. `DatabaseClient<DB = Database>` is generic today, so this is available now — the
- * sentence here once deferred it to "Phase 4.2 work", which had already landed, and a reader who believed that had no
- * option but to cast.
+ * Empty schema marker used only as the generic default.
  */
 export type Database = Record<string, never>;
 //# sourceMappingURL=database-schema.d.ts.map

package/out/database-schema.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"database-schema.d.ts","sourceRoot":"","sources":["../lib/database-schema.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;GAmBG;AAEH;;;;;;;GAOG;AACH,MAAM,MAAM,QAAQ,GAAG,MAAM,CAAC,MAAM,EAAE,KAAK,CAAC,CAAA"}
+{"version":3,"file":"database-schema.d.ts","sourceRoot":"","sources":["../lib/database-schema.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAEH;;GAEG;AACH,MAAM,MAAM,QAAQ,GAAG,MAAM,CAAC,MAAM,EAAE,KAAK,CAAC,CAAA"}

package/out/database-schema.js

@@ -3,20 +3,7 @@
  * @license AGPL-3.0
  * @author Teffen Ellis, et al.
  *
- *   Shared `Database` typing for the Kysely client at `core/kysley/client.ts`.
- *
- *   This file intentionally ships an empty schema. Consumers that want compile-time table typing
- *   should extend `Kysely<TheirSchema>` directly rather than baking a schema into core — the WOF
- *   resolver (Phase 4.2), corpus adapters, and any future consumer all touch different tables.
- *
- *   The exported `Database` interface exists so `client.ts` has a target for `Kysely<Database>` and
- *   the boilerplate compiles without forcing a concrete schema commitment.
- *
- *   IT IS THE DEFAULT, NOT THE ONLY OPTION, and reading it as the only option is how `as never` gets written. Every
- *   table name typed against `Record<string, never>` IS `never`, so `insertInto("poi")` cannot compile and a caller
- *   who believes no alternative exists casts — which disarms not just that one check but every type-level guarantee
- *   anyone later adds to the table (#1757 has the worked case: a branded key column whose check a neighbouring
- *   `as never` had already defeated).
+ *   Default schema type for {@link DatabaseClient}; consumers supply their own table schema.
  */
 export {};
 //# sourceMappingURL=database-schema.js.map

package/out/database-schema.js.map

@@ -1 +1 @@
-{"version":3,"file":"database-schema.js","sourceRoot":"","sources":["../lib/database-schema.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;GAmBG"}
+{"version":3,"file":"database-schema.js","sourceRoot":"","sources":["../lib/database-schema.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG"}

package/out/{dialect-config.d.ts → dialect/config.d.ts}

@@ -24,4 +24,4 @@ export interface SqliteDialectConfig {
      */
     onCreateConnection?: (connection: DatabaseConnection) => Promise<void>;
 }
-//# sourceMappingURL=dialect-config.d.ts.map
+//# sourceMappingURL=config.d.ts.map

package/out/dialect/config.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"config.d.ts","sourceRoot":"","sources":["../../lib/dialect/config.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAEH,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,aAAa,CAAA;AAE/C,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,QAAQ,CAAA;AAEhD;;GAEG;AACH,MAAM,WAAW,mBAAmB;IACnC;;;;;;OAMG;IACH,QAAQ,EAAE,YAAY,GAAG,CAAC,MAAM,OAAO,CAAC,YAAY,CAAC,CAAC,CAAA;IAEtD;;;;OAIG;IACH,kBAAkB,CAAC,EAAE,CAAC,UAAU,EAAE,kBAAkB,KAAK,OAAO,CAAC,IAAI,CAAC,CAAA;CACtE"}

package/out/{dialect-config.js → dialect/config.js}

@@ -4,4 +4,4 @@
  * @author Teffen Ellis, et al.
  */
 export {};
-//# sourceMappingURL=dialect-config.js.map
+//# sourceMappingURL=config.js.map

package/out/dialect/config.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"config.js","sourceRoot":"","sources":["../../lib/dialect/config.ts"],"names":[],"mappings":"AAAA;;;;GAIG"}

package/out/dialect.d.ts

@@ -4,7 +4,7 @@
  * @author Teffen Ellis, et al.
  */
 import { type DatabaseIntrospector, type Dialect, type DialectAdapter, type Driver, type Kysely, type QueryCompiler } from "kysely";
-import type { SqliteDialectConfig } from "#dialect-config";
+import type { SqliteDialectConfig } from "#dialect/config";
 /**
  * SQLite dialect that uses the [`node:sqlite`](https://nodejs.org/api/sqlite.html) library.
  *

package/out/dialect.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"dialect.d.ts","sourceRoot":"","sources":["../lib/dialect.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAEH,OAAO,EAIN,KAAK,oBAAoB,EACzB,KAAK,OAAO,EACZ,KAAK,cAAc,EACnB,KAAK,MAAM,EACX,KAAK,MAAM,EACX,KAAK,aAAa,EAClB,MAAM,QAAQ,CAAA;AAEf,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,iBAAiB,CAAA;AAG1D;;;;;;;;;;;;;;;;;;;;;;GAsBG;AACH,qBAAa,aAAc,YAAW,OAAO;IAC5C,SAAS,CAAC,MAAM,EAAE,mBAAmB,CAAA;gBAEzB,MAAM,EAAE,mBAAmB;IAIvC,YAAY,IAAI,MAAM;IAItB,mBAAmB,IAAI,aAAa;IAIpC,aAAa,IAAI,cAAc;IAI/B,kBAAkB,CAAC,EAAE,EAAE,MAAM,CAAC,OAAO,CAAC,GAAG,oBAAoB;CAG7D"}
+{"version":3,"file":"dialect.d.ts","sourceRoot":"","sources":["../lib/dialect.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAEH,OAAO,EAIN,KAAK,oBAAoB,EACzB,KAAK,OAAO,EACZ,KAAK,cAAc,EACnB,KAAK,MAAM,EACX,KAAK,MAAM,EACX,KAAK,aAAa,EAClB,MAAM,QAAQ,CAAA;AAEf,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,iBAAiB,CAAA;AAG1D;;;;;;;;;;;;;;;;;;;;;;GAsBG;AACH,qBAAa,aAAc,YAAW,OAAO;IAC5C,SAAS,CAAC,MAAM,EAAE,mBAAmB,CAAA;IAErC,YAAY,MAAM,EAAE,mBAAmB,EAEtC;IAED,YAAY,IAAI,MAAM,CAErB;IAED,mBAAmB,IAAI,aAAa,CAEnC;IAED,aAAa,IAAI,cAAc,CAE9B;IAED,kBAAkB,CAAC,EAAE,EAAE,MAAM,CAAC,OAAO,CAAC,GAAG,oBAAoB,CAE5D;CACD"}

package/out/driver.d.ts

@@ -4,7 +4,7 @@
  * @author Teffen Ellis, et al.
  */
 import { type DatabaseConnection, type Driver, type QueryCompiler } from "kysely";
-import type { SqliteDialectConfig } from "#dialect-config";
+import type { SqliteDialectConfig } from "#dialect/config";
 export declare class SqliteDriver implements Driver {
     #private;
     constructor(config: SqliteDialectConfig);

package/out/driver.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"driver.d.ts","sourceRoot":"","sources":["../lib/driver.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAIH,OAAO,EAGN,KAAK,kBAAkB,EACvB,KAAK,MAAM,EAEX,KAAK,aAAa,EAIlB,MAAM,QAAQ,CAAA;AAEf,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,iBAAiB,CAAA;AA0B1D,qBAAa,YAAa,YAAW,MAAM;;gBAO9B,MAAM,EAAE,mBAAmB;IAIjC,IAAI,IAAI,OAAO,CAAC,IAAI,CAAC;IAWrB,iBAAiB,IAAI,OAAO,CAAC,kBAAkB,CAAC;IAShD,gBAAgB,CAAC,UAAU,EAAE,kBAAkB,GAAG,OAAO,CAAC,IAAI,CAAC;IAI/D,iBAAiB,CAAC,UAAU,EAAE,kBAAkB,GAAG,OAAO,CAAC,IAAI,CAAC;IAIhE,mBAAmB,CAAC,UAAU,EAAE,kBAAkB,GAAG,OAAO,CAAC,IAAI,CAAC;IAIlE,SAAS,CACd,UAAU,EAAE,kBAAkB,EAC9B,aAAa,EAAE,MAAM,EACrB,YAAY,EAAE,aAAa,CAAC,cAAc,CAAC,GACzC,OAAO,CAAC,IAAI,CAAC;IAIV,mBAAmB,CACxB,UAAU,EAAE,kBAAkB,EAC9B,aAAa,EAAE,MAAM,EACrB,YAAY,EAAE,aAAa,CAAC,cAAc,CAAC,GACzC,OAAO,CAAC,IAAI,CAAC;IAIV,gBAAgB,CACrB,UAAU,EAAE,kBAAkB,EAC9B,aAAa,EAAE,MAAM,EACrB,YAAY,EAAE,aAAa,CAAC,cAAc,CAAC,GACzC,OAAO,CAAC,IAAI,CAAC;IAIV,iBAAiB,IAAI,OAAO,CAAC,IAAI,CAAC;IAIlC,OAAO,IAAI,OAAO,CAAC,IAAI,CAAC;CAG9B"}
+{"version":3,"file":"driver.d.ts","sourceRoot":"","sources":["../lib/driver.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAIH,OAAO,EAGN,KAAK,kBAAkB,EACvB,KAAK,MAAM,EAEX,KAAK,aAAa,EAIlB,MAAM,QAAQ,CAAA;AAEf,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,iBAAiB,CAAA;AA0B1D,qBAAa,YAAa,YAAW,MAAM;;IAO1C,YAAY,MAAM,EAAE,mBAAmB,EAEtC;IAEK,IAAI,IAAI,OAAO,CAAC,IAAI,CAAC,CAS1B;IAEK,iBAAiB,IAAI,OAAO,CAAC,kBAAkB,CAAC,CAOrD;IAEK,gBAAgB,CAAC,UAAU,EAAE,kBAAkB,GAAG,OAAO,CAAC,IAAI,CAAC,CAEpE;IAEK,iBAAiB,CAAC,UAAU,EAAE,kBAAkB,GAAG,OAAO,CAAC,IAAI,CAAC,CAErE;IAEK,mBAAmB,CAAC,UAAU,EAAE,kBAAkB,GAAG,OAAO,CAAC,IAAI,CAAC,CAEvE;IAEK,SAAS,CACd,UAAU,EAAE,kBAAkB,EAC9B,aAAa,EAAE,MAAM,EACrB,YAAY,EAAE,aAAa,CAAC,cAAc,CAAC,GACzC,OAAO,CAAC,IAAI,CAAC,CAEf;IAEK,mBAAmB,CACxB,UAAU,EAAE,kBAAkB,EAC9B,aAAa,EAAE,MAAM,EACrB,YAAY,EAAE,aAAa,CAAC,cAAc,CAAC,GACzC,OAAO,CAAC,IAAI,CAAC,CAEf;IAEK,gBAAgB,CACrB,UAAU,EAAE,kBAAkB,EAC9B,aAAa,EAAE,MAAM,EACrB,YAAY,EAAE,aAAa,CAAC,cAAc,CAAC,GACzC,OAAO,CAAC,IAAI,CAAC,CAEf;IAEK,iBAAiB,IAAI,OAAO,CAAC,IAAI,CAAC,CAEvC;IAEK,OAAO,IAAI,OAAO,CAAC,IAAI,CAAC,CAE7B;CACD"}

package/out/driver.js

@@ -39,8 +39,8 @@ export class SqliteDriver {
         }
     }
     async acquireConnection() {
-        // SQLite only has one single connection. We use a mutex here to wait
-        // until the single connection has been released.
+        // SQLite only has one single connection.
+        // We use a mutex here to wait until the single connection has been released.
         await this.#connectionMutex.lock();
         // biome-ignore lint/style/noNonNullAssertion: :shrug:
         return this.#connection;