emdash 0.35.0 → 0.37.0

package/src/database/repositories/media.ts

@@ -1,6 +1,13 @@
-import { sql, type ExpressionBuilder, type Kysely, type SqlBool } from "kysely";
+import {
+	sql,
+	type ExpressionBuilder,
+	type Kysely,
+	type SelectQueryBuilder,
+	type SqlBool,
+} from "kysely";
 import { ulid } from "ulidx";
 
+import { normalizeFocalPoint, type FocalPointUpdate } from "../../media/focal-point.js";
 import type { Database, MediaRow } from "../types.js";
 import type { FindManyResult } from "./types.js";
 import { encodeCursor, decodeCursor } from "./types.js";
@@ -48,6 +55,8 @@ export interface MediaItem {
 	size: number | null;
 	width: number | null;
 	height: number | null;
+	focalX: number | null;
+	focalY: number | null;
 	alt: string | null;
 	caption: string | null;
 	storageKey: string;
@@ -57,6 +66,7 @@ export interface MediaItem {
 	dominantColor: string | null;
 	createdAt: string;
 	authorId: string | null;
+	folderId?: string | null;
 }
 
 export interface CreateMediaInput {
@@ -73,6 +83,7 @@ export interface CreateMediaInput {
 	dominantColor?: string;
 	status?: MediaStatus;
 	authorId?: string;
+	folderId?: string | null;
 }
 
 export interface FindManyMediaOptions {
@@ -83,6 +94,32 @@ export interface FindManyMediaOptions {
 	status?: MediaStatus | "all"; // Filter by status, defaults to "ready"
 	/** Case-insensitive substring matched against the filename (covers filename and extension). */
 	q?: string;
+	/** Omit for all media, pass null for the Main library, or pass a folder ID. */
+	folderId?: string | null;
+}
+
+export interface UpdateMediaInput extends FocalPointUpdate {
+	alt?: string;
+	caption?: string;
+	width?: number;
+	height?: number;
+	folderId?: string | null;
+}
+
+export interface ReplaceReadyMediaInput {
+	size: number;
+	width: number;
+	height: number;
+	contentHash: string;
+}
+
+export interface FindMediaPageOptions extends Omit<FindManyMediaOptions, "cursor"> {
+	page: number;
+}
+
+export interface MediaPageResult {
+	items: MediaItem[];
+	totalCount: number;
 }
 
 const UPLOAD_ATTEMPT_CLEANUP_AGE_MS = 60 * 60 * 1000;
@@ -108,6 +145,8 @@ export class MediaRepository {
 			size: input.size ?? null,
 			width: input.width ?? null,
 			height: input.height ?? null,
+			focal_x: null,
+			focal_y: null,
 			alt: input.alt ?? null,
 			caption: input.caption ?? null,
 			storage_key: input.storageKey,
@@ -117,6 +156,7 @@ export class MediaRepository {
 			status: input.status ?? "ready",
 			created_at: now,
 			author_id: input.authorId ?? null,
+			folder_id: input.folderId ?? null,
 		};
 
 		await this.db.insertInto("media").values(row).execute();
@@ -134,6 +174,7 @@ export class MediaRepository {
 		storageKey: string;
 		contentHash?: string;
 		authorId?: string;
+		folderId?: string | null;
 	}): Promise<MediaItem> {
 		return this.create({
 			...input,
@@ -343,6 +384,30 @@ export class MediaRepository {
 		return row ? this.rowToItem(row) : null;
 	}
 
+	async findAvailableFilename(filename: string): Promise<string> {
+		const exists = async (candidate: string) =>
+			Boolean(
+				await this.db
+					.selectFrom("media")
+					.select("id")
+					.where(sql<string>`lower(filename)`, "=", candidate.toLowerCase())
+					.executeTakeFirst(),
+			);
+		if (!(await exists(filename))) return filename;
+
+		const extensionIndex = filename.lastIndexOf(".");
+		const hasExtension = extensionIndex > 0;
+		const extension = hasExtension ? filename.slice(extensionIndex) : "";
+		const stem = hasExtension ? filename.slice(0, extensionIndex) : filename;
+		let copyNumber = 2;
+		let candidate = `${stem}-${copyNumber}${extension}`;
+		while (await exists(candidate)) {
+			copyNumber += 1;
+			candidate = `${stem}-${copyNumber}${extension}`;
+		}
+		return candidate;
+	}
+
 	/**
 	 * Find media by content hash
 	 * Used for deduplication - same content = same hash
@@ -367,8 +432,7 @@ export class MediaRepository {
 	async findMany(options: FindManyMediaOptions = {}): Promise<FindManyResult<MediaItem>> {
 		const limit = Math.min(options.limit || 50, 100);
 
-		let query = this.db
-			.selectFrom("media")
+		let query = this.applyListFilters(this.db.selectFrom("media"), options)
 			.selectAll()
 			.orderBy("created_at", "desc")
 			.orderBy("id", "desc")
@@ -387,28 +451,6 @@ export class MediaRepository {
 			);
 		}
 
-		const mimeFilters = normalizeMimeFilter(options.mimeType);
-		if (mimeFilters.length > 0) {
-			query = query.where((eb) => mimeMatchExpr(eb, mimeFilters));
-		}
-
-		// Case-insensitive filename substring search (also matches extensions).
-		// LIKE wildcards in the term are escaped so they're treated literally.
-		const term = options.q?.trim();
-		if (term) {
-			const pattern = `%${escapeLike(term)}%`;
-			query = query.where(
-				sql<string>`lower(filename)`,
-				"like",
-				sql<string>`lower(${pattern}) escape '\\'`,
-			);
-		}
-
-		// Default to only showing ready items
-		if (options.status !== "all") {
-			query = query.where("status", "=", options.status ?? "ready");
-		}
-
 		const rows = await query.execute();
 
 		const hasMore = rows.length > limit;
@@ -423,13 +465,31 @@ export class MediaRepository {
 		return { items, nextCursor };
 	}
 
+	async findPage(options: FindMediaPageOptions): Promise<MediaPageResult> {
+		const limit = Math.min(options.limit || 50, 100);
+		const offset = (options.page - 1) * limit;
+		const filtered = this.applyListFilters(this.db.selectFrom("media"), options);
+		const rows = await filtered
+			.selectAll()
+			.orderBy("created_at", "desc")
+			.orderBy("id", "desc")
+			.limit(limit)
+			.offset(offset)
+			.execute();
+		const count = await filtered
+			.select((eb) => eb.fn.count<number>("id").as("count"))
+			.executeTakeFirst();
+
+		return {
+			items: rows.map((row) => this.rowToItem(row)),
+			totalCount: Number(count?.count ?? 0),
+		};
+	}
+
 	/**
 	 * Update media metadata
 	 */
-	async update(
-		id: string,
-		input: Partial<Pick<CreateMediaInput, "alt" | "caption" | "width" | "height">>,
-	): Promise<MediaItem | null> {
+	async update(id: string, input: UpdateMediaInput): Promise<MediaItem | null> {
 		const existing = await this.findById(id);
 		if (!existing) {
 			return null;
@@ -440,6 +500,11 @@ export class MediaRepository {
 		if (input.caption !== undefined) updates.caption = input.caption;
 		if (input.width !== undefined) updates.width = input.width;
 		if (input.height !== undefined) updates.height = input.height;
+		if (input.folderId !== undefined) updates.folder_id = input.folderId;
+		if (input.focalX !== undefined && input.focalY !== undefined) {
+			updates.focal_x = input.focalX;
+			updates.focal_y = input.focalY;
+		}
 
 		if (Object.keys(updates).length > 0) {
 			await this.db.updateTable("media").set(updates).where("id", "=", id).execute();
@@ -448,6 +513,32 @@ export class MediaRepository {
 		return this.findById(id);
 	}
 
+	async replaceReadyFile(
+		id: string,
+		expectedStorageKey: string,
+		input: ReplaceReadyMediaInput,
+	): Promise<MediaItem | null> {
+		const row = await this.db
+			.updateTable("media")
+			.set({
+				size: input.size,
+				width: input.width,
+				height: input.height,
+				content_hash: input.contentHash,
+				blurhash: null,
+				dominant_color: null,
+				focal_x: null,
+				focal_y: null,
+			})
+			.where("id", "=", id)
+			.where("status", "=", "ready")
+			.where("storage_key", "=", expectedStorageKey)
+			.returningAll()
+			.executeTakeFirst();
+
+		return row ? this.rowToItem(row) : null;
+	}
+
 	/**
 	 * Delete media item
 	 */
@@ -480,6 +571,38 @@ export class MediaRepository {
 		return Number(result?.count || 0);
 	}
 
+	private applyListFilters<O>(
+		query: SelectQueryBuilder<Database, "media", O>,
+		options: Omit<FindManyMediaOptions, "cursor" | "limit">,
+	): SelectQueryBuilder<Database, "media", O> {
+		const mimeFilters = normalizeMimeFilter(options.mimeType);
+		if (mimeFilters.length > 0) {
+			query = query.where((eb) => mimeMatchExpr(eb, mimeFilters));
+		}
+
+		const term = options.q?.trim();
+		if (term) {
+			const pattern = `%${escapeLike(term)}%`;
+			query = query.where(
+				sql<string>`lower(filename)`,
+				"like",
+				sql<string>`lower(${pattern}) escape '\\'`,
+			);
+		}
+
+		if (options.status !== "all") {
+			query = query.where("status", "=", options.status ?? "ready");
+		}
+
+		if (options.folderId === null) {
+			query = query.where("folder_id", "is", null);
+		} else if (options.folderId !== undefined) {
+			query = query.where("folder_id", "=", options.folderId);
+		}
+
+		return query;
+	}
+
 	/**
 	 * Delete pending uploads older than the given age.
 	 * Pending uploads that were never confirmed indicate abandoned upload flows.
@@ -504,6 +627,7 @@ export class MediaRepository {
 	 * Convert database row to MediaItem
 	 */
 	private rowToItem(row: MediaRow): MediaItem {
+		const focalPoint = normalizeFocalPoint(row.focal_x, row.focal_y);
 		return {
 			id: row.id,
 			filename: row.filename,
@@ -511,6 +635,8 @@ export class MediaRepository {
 			size: row.size,
 			width: row.width,
 			height: row.height,
+			focalX: focalPoint?.focalX ?? null,
+			focalY: focalPoint?.focalY ?? null,
 			alt: row.alt,
 			caption: row.caption,
 			storageKey: row.storage_key,
@@ -521,6 +647,7 @@ export class MediaRepository {
 			status: row.status as MediaStatus,
 			createdAt: row.created_at,
 			authorId: row.author_id,
+			folderId: row.folder_id,
 		};
 	}
 }

package/src/database/repositories/plugin-storage.ts

@@ -16,6 +16,7 @@ import {
 	validateOrderByClause,
 	getIndexedFields,
 	jsonOrderExtract,
+	StorageQueryError,
 } from "../../plugins/storage-query.js";
 import type {
 	StorageCollection,
@@ -52,6 +53,19 @@ function rawWhereExpr(sqlText: string, params: unknown[]): RawBuilder<boolean> {
  *
  * Implements the StorageCollection interface for a specific plugin and collection.
  */
+/**
+ * Rank a sort expression so NULLs get a deterministic position.
+ *
+ * A missing key in a schemaless document extracts as NULL, which sorts
+ * differently per dialect (SQLite first, Postgres last) and makes every
+ * comparison against it UNKNOWN. Sorting on this rank ahead of the value puts
+ * NULLs in the same place on both dialects and keeps the seek operands
+ * non-NULL.
+ */
+function nullRank(expr: RawBuilder<unknown>): RawBuilder<number> {
+	return sql`(case when ${expr} is null then 1 else 0 end)`;
+}
+
 export class PluginStorageRepository<T = unknown> implements StorageCollection<T> {
 	private indexedFields: Set<string>;
 
@@ -234,24 +248,75 @@ export class PluginStorageRepository<T = unknown> implements StorageCollection<T
 			query = query.where(rawWhereExpr(whereResult.sql, whereResult.params));
 		}
 
+		const orderEntries = Object.entries(orderBy);
+		const orderDirections = new Set(orderEntries.map(([, direction]) => direction));
+		const descending = orderEntries.length > 0 && orderEntries[0][1] === "desc";
+
+		// A missing key in a schemaless document extracts as NULL, and NULL sorts
+		// differently per dialect (SQLite first, Postgres last) and makes any
+		// comparison against it UNKNOWN. Rank nulls explicitly so both the sort and
+		// the seek agree on where they sit, on either dialect, and so no comparison
+		// operand is ever NULL.
+		const sortExpr = (field: string): RawBuilder<unknown> =>
+			sql`${sql.raw(jsonOrderExtract(this.db, field))}`;
+
 		// Handle cursor-based pagination — throws on invalid cursor.
 		if (cursor) {
 			const decoded = decodeCursor(cursor);
-			query = query.where(({ eb }) =>
-				eb(sql`(created_at, id)`, ">", sql`(${decoded.orderValue}, ${decoded.id})`),
-			);
+			if (orderEntries.length === 0) {
+				query = query.where(({ eb }) =>
+					eb(sql`(created_at, id)`, ">", sql`(${decoded.orderValue}, ${decoded.id})`),
+				);
+			} else {
+				if (orderDirections.size > 1) {
+					throw new StorageQueryError(
+						"Cursor pagination requires every orderBy field to share one direction.",
+						Object.keys(orderBy).join(", "),
+						"Sort every field the same way, or page without a cursor.",
+					);
+				}
+				const op = descending ? sql`<` : sql`>`;
+				// The cursor row's sort values, recomputed with the same expression
+				// rather than carried in the cursor, so nothing is bound as a literal
+				// and neither dialect has to coerce a JSON value to compare it.
+				const cursorExpr = (field: string): RawBuilder<unknown> =>
+					sql`(select ${sql.raw(jsonOrderExtract(this.db, field))} from _plugin_storage where plugin_id = ${this.pluginId} and collection = ${this.collection} and id = ${decoded.id})`;
+
+				const fields = orderEntries.map(([field]) => {
+					const own = sortExpr(field);
+					const theirs = cursorExpr(field);
+					return {
+						equal: sql`(${nullRank(own)} = ${nullRank(theirs)} and (${nullRank(own)} = 1 or ${own} = ${theirs}))`,
+						after: sql`(${nullRank(own)} ${op} ${nullRank(theirs)} or (${nullRank(own)} = ${nullRank(theirs)} and ${nullRank(own)} = 0 and ${own} ${op} ${theirs}))`,
+					};
+				});
+
+				// Lexicographic seek: ties on every earlier field, then strictly after
+				// on this one; finally all fields tied and strictly after on id.
+				const terms = fields.map(
+					(_, k) =>
+						sql`(${sql.join([...fields.slice(0, k).map((f) => f.equal), fields[k].after], sql` and `)})`,
+				);
+				terms.push(
+					sql`(${sql.join([...fields.map((f) => f.equal), sql`id ${op} ${decoded.id}`], sql` and `)})`,
+				);
+				query = query.where(sql<boolean>`(${sql.join(terms, sql` or `)})`);
+			}
 		}
 
 		// Build ORDER BY using sql template
-		if (Object.keys(orderBy).length > 0) {
-			for (const [field, direction] of Object.entries(orderBy)) {
+		if (orderEntries.length > 0) {
+			for (const [field, direction] of orderEntries) {
+				const dir = direction === "desc" ? sql`desc` : sql`asc`;
+				const expr = sortExpr(field);
+				// Null rank first so NULL placement is identical on both dialects.
+				query = query.orderBy(sql`${nullRank(expr)} ${dir}`);
 				// Order over the jsonb-native value on Postgres so numeric fields sort
 				// numerically, not lexically. See pluginDataOrderExpr.
-				const extract = jsonOrderExtract(this.db, field);
-				const orderExpr =
-					direction === "desc" ? sql`${sql.raw(extract)} desc` : sql`${sql.raw(extract)} asc`;
-				query = query.orderBy(orderExpr);
+				query = query.orderBy(sql`${expr} ${dir}`);
 			}
+			// Total order, so a page boundary can never fall inside a group of ties.
+			query = query.orderBy("id", descending ? "desc" : "asc");
 		} else {
 			// Default ordering for consistent pagination
 			query = query.orderBy("created_at", "asc").orderBy("id", "asc");

package/src/database/repositories/types.ts

@@ -64,13 +64,14 @@ export interface BylineSummary {
 	avatarMediaId: string | null;
 	/**
 	 * The avatar media's storage key, folded in by a LEFT JOIN on the
-	 * `media` table during content byline hydration. Non-null only when the
-	 * byline has an avatar AND was loaded through the content-credit hydration
-	 * path (`getContentBylines` / `getContentBylinesMany`, i.e. the
-	 * `entry.data.bylines` populated by `getEmDashCollection` / `getEmDashEntry`).
-	 * The plain byline finders (`findById`, `findBySlug`, …) leave it null.
+	 * `media` table. Populated by the content-credit hydration path
+	 * (`getContentBylines` / `getContentBylinesMany`, i.e. the
+	 * `entry.data.bylines` populated by `getEmDashCollection` /
+	 * `getEmDashEntry`) and by the single-row finders (`findById`,
+	 * `findBySlug`, `findByUserId`, `findByUserIds`). `findMany` doesn't
+	 * join media, so it leaves this null.
 	 *
-	 * Lets list pages build a direct storage URL for an author avatar without a
+	 * Lets a page build a direct storage URL for an author avatar without a
 	 * per-byline `MediaRepository.findById`, avoiding an N+1 when many distinct
 	 * authors appear on one page.
 	 *
@@ -86,7 +87,7 @@ export interface BylineSummary {
 	 * same media join as `avatarStorageKey`. Lets a renderer paint a blurred
 	 * placeholder while the full avatar loads, with no extra media lookup.
 	 * Null when the byline has no avatar, the media row has no blurhash, or the
-	 * byline was loaded through a finder that doesn't join media.
+	 * byline came from `findMany`, which doesn't join media.
 	 */
 	avatarBlurhash?: string | null;
 	/**

package/src/database/transaction.ts

@@ -29,6 +29,7 @@ export async function withTransaction<DB, T>(
 	db: Kysely<DB>,
 	fn: (trx: Kysely<DB> | Transaction<DB>) => Promise<T>,
 ): Promise<T> {
+	if (db.isTransaction) return fn(db);
 	// Fast path: we already know transactions work
 	if (transactionsSupported === true) {
 		return db.transaction().execute(fn);

package/src/database/types.ts

@@ -67,6 +67,8 @@ export interface MediaTable {
 	size: number | null;
 	width: number | null;
 	height: number | null;
+	focal_x: number | null;
+	focal_y: number | null;
 	alt: string | null;
 	caption: string | null;
 	storage_key: string;
@@ -76,6 +78,13 @@ export interface MediaTable {
 	dominant_color: string | null;
 	created_at: Generated<string>;
 	author_id: string | null;
+	folder_id: Generated<string | null>;
+}
+
+export interface MediaFolderTable {
+	id: string;
+	name: string;
+	name_key: string;
 }
 
 export interface MediaUploadAttemptTable {
@@ -627,6 +636,7 @@ export interface Database {
 	content_taxonomies: ContentTaxonomyTable;
 	_emdash_taxonomy_defs: TaxonomyDefTable;
 	media: MediaTable;
+	media_folders: MediaFolderTable;
 	_emdash_media_upload_attempts: MediaUploadAttemptTable;
 	_emdash_media_usage_sources: MediaUsageSourceTable;
 	_emdash_media_usage: MediaUsageTable;
@@ -685,6 +695,8 @@ export type MediaRow = {
 	size: number | null;
 	width: number | null;
 	height: number | null;
+	focal_x: number | null;
+	focal_y: number | null;
 	alt: string | null;
 	caption: string | null;
 	storage_key: string;
@@ -694,6 +706,7 @@ export type MediaRow = {
 	dominant_color: string | null;
 	created_at: string;
 	author_id: string | null;
+	folder_id: string | null;
 };
 
 export interface RedirectTable {

package/src/db/adapters.ts

@@ -134,9 +134,9 @@ export interface LibsqlConfig {
 }
 
 /**
- * SQLite database adapter (better-sqlite3)
+ * SQLite database adapter (node:sqlite)
  *
- * For local development and Node.js deployments.
+ * For local development and Node.js deployments. Requires Node.js 22.16 or later.
  *
  * @example
  * ```ts
@@ -199,7 +199,14 @@ export interface PostgresConfig {
 	user?: string;
 	password?: string;
 	ssl?: boolean;
-	pool?: { min?: number; max?: number };
+	pool?: {
+		min?: number;
+		max?: number;
+		/** Maximum time to wait for a connection, in milliseconds. Uses the pg default when omitted. */
+		connectionTimeoutMillis?: number;
+		/** Time before an idle client is closed, in milliseconds. Uses the pg default when omitted. */
+		idleTimeoutMillis?: number;
+	};
 	migrationConnectionStringEnv?: string;
 }
 

package/src/db/node-sqlite-compat.ts

@@ -0,0 +1,78 @@
+import { DatabaseSync } from "node:sqlite";
+
+export interface NodeSqliteCompatDatabase {
+	close(): void;
+	prepare(sql: string): NodeSqliteCompatStatement;
+}
+
+export interface NodeSqliteCompatStatement {
+	readonly reader: boolean;
+	all(parameters: ReadonlyArray<unknown>): unknown[];
+	run(parameters: ReadonlyArray<unknown>): {
+		changes: number | bigint;
+		lastInsertRowid: number | bigint;
+	};
+	iterate(parameters: ReadonlyArray<unknown>): IterableIterator<unknown>;
+}
+
+export interface NodeSqliteOpenOptions {
+	journalMode?: "wal";
+}
+
+type SqliteBinding = null | number | bigint | string | Uint8Array;
+
+export function openNodeSqliteDatabase(
+	path: string,
+	options: NodeSqliteOpenOptions = {},
+): NodeSqliteCompatDatabase {
+	const database = new DatabaseSync(path);
+
+	try {
+		database.exec("PRAGMA busy_timeout = 5000");
+		database.exec("PRAGMA foreign_keys = ON");
+		// Negative cache_size values are kibibytes.
+		database.exec("PRAGMA cache_size = -16000");
+		if (options.journalMode === "wal") {
+			database.exec("PRAGMA journal_mode = WAL");
+		}
+		const journalMode = database.prepare("PRAGMA journal_mode").get()?.["journal_mode"];
+		if (journalMode === "wal") {
+			database.exec("PRAGMA synchronous = NORMAL");
+		}
+	} catch (error) {
+		try {
+			database.close();
+		} catch {
+			throw new Error("SQLite setup failed and the connection could not be closed", {
+				cause: error,
+			});
+		}
+		throw error;
+	}
+
+	return {
+		close: () => database.close(),
+		prepare(sql) {
+			const statement = database.prepare(sql);
+			return {
+				reader: statement.columns().length > 0,
+				all: (parameters) => statement.all(...toBindings(parameters)),
+				run: (parameters) => statement.run(...toBindings(parameters)),
+				iterate: (parameters) => statement.iterate(...toBindings(parameters)),
+			};
+		},
+	};
+}
+
+function toBindings(parameters: ReadonlyArray<unknown>): SqliteBinding[] {
+	return parameters.map((value) => {
+		if (value === null || typeof value === "string" || typeof value === "number") {
+			return value;
+		}
+		if (typeof value === "bigint") return value;
+		if (typeof value === "boolean") return value ? 1 : 0;
+		if (value === undefined) return null;
+		if (value instanceof Uint8Array) return value;
+		throw new TypeError(`Cannot bind ${Object.prototype.toString.call(value)} to SQLite`);
+	});
+}

package/src/db/postgres.ts

@@ -11,6 +11,26 @@ import { Pool } from "pg";
 import { FailFastPostgresDialect } from "../database/pg-migration-lock.js";
 import type { PostgresConfig } from "./adapters.js";
 
+const URL_PATTERN = /[A-Za-z][A-Za-z0-9+.-]*:\/\/\S+/g;
+const CREDENTIAL_PATTERN = /\b(auth|credential|key|password|secret|signature|token)\s*[=:]\s*\S+/gi;
+const ERROR_CODE_PATTERN = /^[A-Za-z0-9_-]{1,32}$/;
+
+function redactPoolErrorMessage(message: string): string {
+	return message
+		.replace(URL_PATTERN, "[REDACTED_URL]")
+		.replace(CREDENTIAL_PATTERN, "$1=[REDACTED]")
+		.replaceAll(/[\r\n\t]/g, " ")
+		.slice(0, 1_000);
+}
+
+function logPoolError(error: Error): void {
+	// pg attaches the failed client to this error, which can contain connection credentials.
+	const code = "code" in error && typeof error.code === "string" ? error.code : undefined;
+	const safeCode = code && ERROR_CODE_PATTERN.test(code) ? ` (${code})` : "";
+	const message = redactPoolErrorMessage(error.message) || "Unknown error";
+	console.error(`[emdash] PostgreSQL idle client error${safeCode}: ${message}`);
+}
+
 /**
  * Create a PostgreSQL dialect from config
  */
@@ -25,7 +45,10 @@ export function createDialect(config: PostgresConfig): PostgresDialect {
 		ssl: config.ssl,
 		min: config.pool?.min ?? 0,
 		max: config.pool?.max ?? 10,
+		connectionTimeoutMillis: config.pool?.connectionTimeoutMillis,
+		idleTimeoutMillis: config.pool?.idleTimeoutMillis,
 	});
+	pool.on("error", logPoolError);
 
 	// Fail-fast migration locking instead of Kysely's blocking advisory
 	// lock — see pg-migration-lock.ts (#1744).

package/src/db/sqlite.ts

@@ -1,14 +1,14 @@
 /**
  * SQLite runtime adapter
  *
- * Creates a Kysely dialect for better-sqlite3.
+ * Creates a Kysely dialect for Node's built-in SQLite driver.
  * Loaded at runtime via virtual module.
  */
 
-import BetterSqlite3 from "better-sqlite3";
 import { type Dialect, SqliteDialect } from "kysely";
 
 import type { SqliteConfig } from "./adapters.js";
+import { openNodeSqliteDatabase } from "./node-sqlite-compat.js";
 
 /**
  * Create a SQLite dialect from config
@@ -18,7 +18,7 @@ export function createDialect(config: SqliteConfig): Dialect {
 	const url = config.url;
 	const filePath = url.startsWith("file:") ? url.slice(5) : url;
 
-	const database = new BetterSqlite3(filePath);
+	const database = openNodeSqliteDatabase(filePath);
 
 	return new SqliteDialect({ database });
 }