@shapio/local 0.5.0

package/dist/advisoryLocks-COlJQc1r.js

@@ -0,0 +1,4181 @@
+import { AliasNode, AndNode, BinaryOperationNode, ColumnNode, ColumnUpdateNode, IdentifierNode, InsertQueryNode, Kysely, ListNode, MysqlAdapter, MysqlIntrospector, MysqlQueryCompiler, OnDuplicateKeyNode, OperationNodeTransformer, OperatorNode, OrNode, OrderByItemNode, ParensNode, PrimitiveValueListNode, RawNode, ReferenceNode, SelectAllNode, SelectModifierNode, SelectQueryNode, SelectionNode, SqliteAdapter, SqliteIntrospector, SqliteQueryCompiler, TableNode, UpdateQueryNode, ValueListNode, ValueNode, ValuesNode, WhereNode } from "kysely";
+import { createHash, randomUUID } from "node:crypto";
+import { AsyncLocalStorage } from "node:async_hooks";
+import { EventEmitter } from "node:events";
+import { resolve } from "node:path";
+import { DatabaseSync } from "node:sqlite";
+//#region ../../apps/api/src/helpers/appError.ts
+/**
+* An error with a stable machine-readable code, rendered by the central error handler as
+* `{ error: { code, message, details? } }`. Services throw these; they carry no HTTP objects.
+*/
+var AppError = class extends Error {
+	statusCode;
+	code;
+	details;
+	constructor(statusCode, code, message, details, options) {
+		super(message, options);
+		this.name = "AppError";
+		this.statusCode = statusCode;
+		this.code = code;
+		this.details = details;
+	}
+};
+//#endregion
+//#region ../../apps/api/src/db/mysql/codec.ts
+/**
+* The MySQL value codec (ADR 0001, "MySQL"). Shapio's PostgreSQL types map to MySQL like this, and rows
+* read back with the JavaScript shape `pg` gives them:
+*
+* | PostgreSQL      | MySQL                                   | read as                     |
+* | --------------- | --------------------------------------- | --------------------------- |
+* | uuid            | CHAR(36) ascii, case-insensitive        | string                      |
+* | text            | VARCHAR(n) (keys) / LONGTEXT, 0900_bin  | string                      |
+* | timestamptz     | DATETIME(6), UTC                        | Date                        |
+* | date            | DATE                                    | `YYYY-MM-DD` string         |
+* | jsonb / text[]  | JSON                                    | parsed value                |
+* | boolean         | TINYINT(1)                              | boolean                     |
+* | bigint          | BIGINT                                  | decimal string              |
+* | integer / real  | INT / FLOAT                             | number                      |
+*
+* Parameters: plain objects and arrays are bound as JSON text (mysql2 would otherwise expand an object into
+* `key = value` pairs and an array into a list), Dates as UTC `DATETIME` text, booleans as 1/0. `undefined`
+* is refused rather than written as NULL.
+*/
+/** A parameter that cannot be bound; never silently written as NULL. */
+var MysqlBindError = class extends TypeError {
+	constructor(index, value) {
+		const kind = value === void 0 ? "undefined" : value?.constructor?.name ?? typeof value;
+		super(`Cannot bind ${kind} to MySQL parameter ${index + 1}`);
+		this.name = "MysqlBindError";
+	}
+};
+const pad = (value, width = 2) => String(value).padStart(width, "0");
+/** A Date as MySQL `DATETIME(6)` text in UTC (millisecond precision, the precision of a Date). */
+const formatDatetime = (date) => `${date.getUTCFullYear()}-${pad(date.getUTCMonth() + 1)}-${pad(date.getUTCDate())} ${pad(date.getUTCHours())}:${pad(date.getUTCMinutes())}:${pad(date.getUTCSeconds())}.${pad(date.getUTCMilliseconds(), 3)}`;
+const ISO_UTC = /^(\d{4}-\d{2}-\d{2})[T ](\d{2}:\d{2}:\d{2})(?:\.(\d{1,6}))?(?:Z|\+00:?00)$/;
+/**
+* A timestamp parameter as `DATETIME(6)` text. ISO-8601 UTC text keeps all its fractional digits (keyset
+* cursors carry microseconds); other text is parsed as a Date. Throws on an invalid time.
+*/
+const toDatetimeText = (value) => {
+	if (typeof value === "string") {
+		const match = ISO_UTC.exec(value);
+		if (match) return `${match[1]} ${match[2]}.${(match[3] ?? "").padEnd(6, "0")}`;
+	}
+	const date = value instanceof Date ? value : new Date(value);
+	if (Number.isNaN(date.getTime())) throw new RangeError(`Invalid timestamp: ${String(value)}`);
+	return formatDatetime(date);
+};
+const isPlainObject$1 = (value) => {
+	const prototype = Object.getPrototypeOf(value);
+	return prototype === Object.prototype || prototype === null;
+};
+/** A JavaScript value as a mysql2 parameter (see the table above). */
+const encodeParameter$1 = (value, index) => {
+	switch (typeof value) {
+		case "string":
+		case "number":
+		case "bigint": return value;
+		case "boolean": return value ? 1 : 0;
+		case "object":
+			if (value === null || value instanceof Uint8Array) return value;
+			if (value instanceof Date) return formatDatetime(value);
+			if (Array.isArray(value) || isPlainObject$1(value)) return JSON.stringify(value);
+			throw new MysqlBindError(index, value);
+		default: throw new MysqlBindError(index, value);
+	}
+};
+/**
+* Decodes result columns: `TINYINT(1)` as boolean (MySQL's boolean), `DATE` as `YYYY-MM-DD` text.
+* DATETIME (UTC Dates), JSON (parsed), BIGINT/DECIMAL (strings) are decoded by the pool options.
+*/
+const typeCast = (field, next) => {
+	if (field.type === "TINY" && field.length === 1) {
+		const text = field.string();
+		return text === null ? null : text !== "0";
+	}
+	if (field.type === "DATE") return field.string();
+	return next();
+};
+//#endregion
+//#region ../../apps/api/src/db/sql/typed.ts
+const MARKED = /* @__PURE__ */ new WeakMap();
+/** The marker on a selection's expression node, if any (read by the SQLite plugin). */
+const markedResultType = (node) => MARKED.get(node);
+//#endregion
+//#region ../../apps/api/src/db/sql/time.ts
+/**
+* Time primitives (dialect boundary, ADR 0001). Only SQL that creates, formats or casts a time value goes
+* through here. Comparing or sorting a timestamp column against a bound JavaScript `Date` stays plain Kysely:
+* it is portable as long as every dialect stores timestamps so that their order is time order.
+*
+* SQLite stores timestamps as fixed-width UTC ISO-8601 text with milliseconds (`toStoredTimestamp`), so text
+* order is time order. PostgreSQL keeps microseconds; SQLite's precision is the millisecond. MySQL stores
+* `DATETIME(6)` in UTC (the session time zone), microseconds like PostgreSQL.
+*/
+/**
+* The text SQLite stores for an instant: `YYYY-MM-DDTHH:MM:SS.sssZ` (24 characters, UTC, milliseconds).
+* Every timestamp written on SQLite has exactly this form (the driver's codec, column defaults and
+* `currentTimestamp`), so comparisons between stored values and bound values are text comparisons.
+* Accepts a Date or any text `Date` parses (sub-millisecond digits are truncated). Throws on an invalid time.
+*/
+const toStoredTimestamp = (value) => {
+	const date = value instanceof Date ? value : new Date(value);
+	if (Number.isNaN(date.getTime())) throw new RangeError(`Invalid timestamp: ${String(value)}`);
+	return date.toISOString();
+};
+//#endregion
+//#region ../../apps/api/src/db/connectionScope.ts
+const scopes$1 = new AsyncLocalStorage();
+var NestedPoolAcquireError = class extends Error {
+	constructor() {
+		super("A query inside an open transaction asked the pool for a second connection; under load every connection waits for another. Run it on the transaction (trx) instead.");
+		this.name = "NestedPoolAcquireError";
+	}
+};
+const holdsConnection = (scope) => {
+	for (let current = scope; current; current = current.parent) if (current.acquired) return true;
+	return false;
+};
+/**
+* Called by a driver before it takes a pooled connection. The first acquisition of a scope is the
+* transaction's own connection; any later one, or one inside a scope that already holds a connection, is
+* nested.
+*/
+const assertNotNested = () => {
+	const scope = scopes$1.getStore();
+	if (!scope) return;
+	if (holdsConnection(scope)) throw new NestedPoolAcquireError();
+	scope.acquired = true;
+};
+/**
+* Runs `fn` as if no transaction were open: for work that does not belong to the enclosing transaction and
+* that it never waits for (notifications published at commit, a test's independent request).
+*/
+const outsideConnectionScope = (fn) => scopes$1.exit(fn);
+/** Runs every `execute` of a transaction builder (and of the builders it returns) in a connection scope. */
+const withConnectionScope = (builder) => new Proxy(builder, { get(target, property, receiver) {
+	if (property === "execute") return (callback) => scopes$1.run({
+		acquired: false,
+		parent: scopes$1.getStore()
+	}, () => target.execute(callback));
+	if (property === "setIsolationLevel" || property === "setAccessMode") return (value) => withConnectionScope(target[property](value));
+	return Reflect.get(target, property, receiver);
+} });
+//#endregion
+//#region ../../apps/api/src/db/mysql/tables.ts
+const MYSQL_TABLES = {
+	admin_invitations: {
+		primaryKey: ["id"],
+		generated: { id: "uuid" },
+		columns: [
+			"id",
+			"email",
+			"token_hash",
+			"invited_by",
+			"expires_at",
+			"accepted_at",
+			"revoked_at",
+			"created_at",
+			"updated_at",
+			"role_assignments"
+		],
+		nullable: [
+			"token_hash",
+			"invited_by",
+			"accepted_at",
+			"revoked_at"
+		],
+		timestamps: [
+			"expires_at",
+			"accepted_at",
+			"revoked_at",
+			"created_at",
+			"updated_at"
+		],
+		uniqueKeys: [{
+			name: "admin_invitations_pkey",
+			columns: ["id"]
+		}, {
+			name: "admin_invitations_token_hash_key",
+			columns: ["token_hash"]
+		}]
+	},
+	admin_role_permissions: {
+		primaryKey: ["id"],
+		generated: { id: "uuid" },
+		columns: [
+			"id",
+			"role_id",
+			"action",
+			"model_id",
+			"condition",
+			"field_ids",
+			"created_at",
+			"updated_at"
+		],
+		nullable: [
+			"model_id",
+			"condition",
+			"field_ids"
+		],
+		timestamps: ["created_at", "updated_at"],
+		uniqueKeys: [{
+			name: "admin_role_permissions_grant_uq",
+			columns: [
+				"role_id",
+				"action",
+				"model_id"
+			]
+		}, {
+			name: "admin_role_permissions_pkey",
+			columns: ["id"]
+		}]
+	},
+	admin_roles: {
+		primaryKey: ["id"],
+		generated: { id: "uuid" },
+		columns: [
+			"id",
+			"key",
+			"name",
+			"description",
+			"kind",
+			"is_system",
+			"version",
+			"created_at",
+			"updated_at"
+		],
+		nullable: [],
+		timestamps: ["created_at", "updated_at"],
+		uniqueKeys: [{
+			name: "admin_roles_key_key",
+			columns: ["key"]
+		}, {
+			name: "admin_roles_pkey",
+			columns: ["id"]
+		}]
+	},
+	admin_sessions: {
+		primaryKey: ["id"],
+		generated: { id: "uuid" },
+		columns: [
+			"id",
+			"admin_user_id",
+			"token_hash",
+			"csrf_secret",
+			"ip",
+			"user_agent",
+			"last_seen_at",
+			"expires_at",
+			"revoked_at",
+			"rotation_required",
+			"created_at",
+			"updated_at"
+		],
+		nullable: [
+			"ip",
+			"user_agent",
+			"revoked_at"
+		],
+		timestamps: [
+			"last_seen_at",
+			"expires_at",
+			"revoked_at",
+			"created_at",
+			"updated_at"
+		],
+		uniqueKeys: [{
+			name: "admin_sessions_pkey",
+			columns: ["id"]
+		}, {
+			name: "admin_sessions_token_hash_key",
+			columns: ["token_hash"]
+		}]
+	},
+	admin_user_roles: {
+		primaryKey: ["id"],
+		generated: { id: "uuid" },
+		columns: [
+			"admin_user_id",
+			"role_id",
+			"created_at",
+			"updated_at",
+			"site_id",
+			"id"
+		],
+		nullable: ["site_id"],
+		timestamps: ["created_at", "updated_at"],
+		uniqueKeys: [{
+			name: "admin_user_roles_assignment_uq",
+			columns: [
+				"admin_user_id",
+				"role_id",
+				"site_id"
+			]
+		}, {
+			name: "admin_user_roles_pk",
+			columns: ["id"]
+		}]
+	},
+	admin_users: {
+		primaryKey: ["id"],
+		generated: { id: "uuid" },
+		columns: [
+			"id",
+			"email",
+			"name",
+			"password_hash",
+			"status",
+			"last_login_at",
+			"password_changed_at",
+			"created_at",
+			"updated_at"
+		],
+		nullable: ["last_login_at"],
+		timestamps: [
+			"last_login_at",
+			"password_changed_at",
+			"created_at",
+			"updated_at"
+		],
+		uniqueKeys: [{
+			name: "admin_users_email_key",
+			columns: ["email"]
+		}, {
+			name: "admin_users_pkey",
+			columns: ["id"]
+		}]
+	},
+	api_tokens: {
+		primaryKey: ["id"],
+		generated: { id: "uuid" },
+		columns: [
+			"id",
+			"name",
+			"token_hash",
+			"token_prefix",
+			"role_id",
+			"created_by",
+			"expires_at",
+			"last_used_at",
+			"revoked_at",
+			"created_at",
+			"updated_at",
+			"site_id"
+		],
+		nullable: [
+			"created_by",
+			"expires_at",
+			"last_used_at",
+			"revoked_at",
+			"site_id"
+		],
+		timestamps: [
+			"expires_at",
+			"last_used_at",
+			"revoked_at",
+			"created_at",
+			"updated_at"
+		],
+		uniqueKeys: [{
+			name: "api_tokens_pkey",
+			columns: ["id"]
+		}, {
+			name: "api_tokens_token_hash_key",
+			columns: ["token_hash"]
+		}]
+	},
+	app_login_codes: {
+		primaryKey: ["id"],
+		generated: { id: "uuid" },
+		columns: [
+			"id",
+			"app_user_id",
+			"code_hash",
+			"expires_at",
+			"used_at",
+			"created_at",
+			"code_challenge"
+		],
+		nullable: ["used_at"],
+		timestamps: [
+			"expires_at",
+			"used_at",
+			"created_at"
+		],
+		uniqueKeys: [{
+			name: "app_login_codes_code_hash_key",
+			columns: ["code_hash"]
+		}, {
+			name: "app_login_codes_pkey",
+			columns: ["id"]
+		}]
+	},
+	app_oauth_accounts: {
+		primaryKey: ["id"],
+		generated: { id: "uuid" },
+		columns: [
+			"id",
+			"app_user_id",
+			"provider",
+			"provider_user_id",
+			"email",
+			"created_at",
+			"updated_at",
+			"site_id"
+		],
+		nullable: ["email"],
+		timestamps: ["created_at", "updated_at"],
+		uniqueKeys: [{
+			name: "app_oauth_accounts_identity_uq",
+			columns: [
+				"site_id",
+				"provider",
+				"provider_user_id"
+			]
+		}, {
+			name: "app_oauth_accounts_pkey",
+			columns: ["id"]
+		}]
+	},
+	app_password_resets: {
+		primaryKey: ["id"],
+		generated: { id: "uuid" },
+		columns: [
+			"id",
+			"app_user_id",
+			"email",
+			"token_hash",
+			"expires_at",
+			"used_at",
+			"created_at",
+			"updated_at"
+		],
+		nullable: ["token_hash", "used_at"],
+		timestamps: [
+			"expires_at",
+			"used_at",
+			"created_at",
+			"updated_at"
+		],
+		uniqueKeys: [{
+			name: "app_password_resets_pkey",
+			columns: ["id"]
+		}, {
+			name: "app_password_resets_token_hash_key",
+			columns: ["token_hash"]
+		}]
+	},
+	app_refresh_tokens: {
+		primaryKey: ["id"],
+		generated: { id: "uuid" },
+		columns: [
+			"id",
+			"app_user_id",
+			"family_id",
+			"token_hash",
+			"expires_at",
+			"used_at",
+			"reuse_grace_used_at",
+			"revoked_at",
+			"revoked_reason",
+			"ip",
+			"user_agent",
+			"created_at"
+		],
+		nullable: [
+			"used_at",
+			"reuse_grace_used_at",
+			"revoked_at",
+			"revoked_reason",
+			"ip",
+			"user_agent"
+		],
+		timestamps: [
+			"expires_at",
+			"used_at",
+			"reuse_grace_used_at",
+			"revoked_at",
+			"created_at"
+		],
+		uniqueKeys: [{
+			name: "app_refresh_tokens_pkey",
+			columns: ["id"]
+		}, {
+			name: "app_refresh_tokens_token_hash_key",
+			columns: ["token_hash"]
+		}]
+	},
+	app_role_permissions: {
+		primaryKey: ["id"],
+		generated: { id: "uuid" },
+		columns: [
+			"id",
+			"role_id",
+			"action",
+			"model_id",
+			"condition",
+			"field_ids",
+			"created_at",
+			"updated_at"
+		],
+		nullable: [
+			"model_id",
+			"condition",
+			"field_ids"
+		],
+		timestamps: ["created_at", "updated_at"],
+		uniqueKeys: [{
+			name: "app_role_permissions_grant_uq",
+			columns: [
+				"role_id",
+				"action",
+				"model_id"
+			]
+		}, {
+			name: "app_role_permissions_pkey",
+			columns: ["id"]
+		}]
+	},
+	app_roles: {
+		primaryKey: ["id"],
+		generated: { id: "uuid" },
+		columns: [
+			"id",
+			"key",
+			"name",
+			"description",
+			"is_system",
+			"version",
+			"created_at",
+			"updated_at"
+		],
+		nullable: [],
+		timestamps: ["created_at", "updated_at"],
+		uniqueKeys: [{
+			name: "app_roles_key_key",
+			columns: ["key"]
+		}, {
+			name: "app_roles_pkey",
+			columns: ["id"]
+		}]
+	},
+	app_user_roles: {
+		primaryKey: ["app_user_id", "role_id"],
+		columns: [
+			"app_user_id",
+			"role_id",
+			"created_at",
+			"site_id"
+		],
+		nullable: [],
+		timestamps: ["created_at"],
+		uniqueKeys: [{
+			name: "app_user_roles_pk",
+			columns: ["app_user_id", "role_id"]
+		}]
+	},
+	app_users: {
+		primaryKey: ["id"],
+		generated: { id: "uuid" },
+		columns: [
+			"id",
+			"email",
+			"name",
+			"password_hash",
+			"confirmed_at",
+			"blocked_at",
+			"last_login_at",
+			"password_changed_at",
+			"deleted_at",
+			"created_at",
+			"updated_at",
+			"token_version",
+			"site_id"
+		],
+		nullable: [
+			"password_hash",
+			"confirmed_at",
+			"blocked_at",
+			"last_login_at",
+			"password_changed_at",
+			"deleted_at"
+		],
+		timestamps: [
+			"confirmed_at",
+			"blocked_at",
+			"last_login_at",
+			"password_changed_at",
+			"deleted_at",
+			"created_at",
+			"updated_at"
+		],
+		uniqueKeys: [{
+			name: "app_users_email_uq",
+			columns: ["site_id", "email"]
+		}, {
+			name: "app_users_pkey",
+			columns: ["id"]
+		}]
+	},
+	assist_runs: {
+		primaryKey: ["id"],
+		generated: { id: "uuid" },
+		columns: [
+			"id",
+			"site_id",
+			"actor_type",
+			"actor_id",
+			"action",
+			"rule",
+			"provider",
+			"model",
+			"input_tokens",
+			"output_tokens",
+			"duration_ms",
+			"status",
+			"error_code",
+			"job_id",
+			"created_at",
+			"finished_at"
+		],
+		nullable: [
+			"rule",
+			"error_code",
+			"job_id",
+			"finished_at"
+		],
+		timestamps: ["created_at", "finished_at"],
+		uniqueKeys: [{
+			name: "assist_runs_pkey",
+			columns: ["id"]
+		}]
+	},
+	audit_events: {
+		primaryKey: ["id"],
+		identity: "seq",
+		generated: { id: "uuid" },
+		columns: [
+			"id",
+			"occurred_at",
+			"actor_type",
+			"actor_id",
+			"action",
+			"target_type",
+			"target_id",
+			"outcome",
+			"request_id",
+			"ip",
+			"metadata",
+			"site_id",
+			"seq"
+		],
+		nullable: [
+			"actor_id",
+			"target_type",
+			"target_id",
+			"request_id",
+			"ip",
+			"site_id"
+		],
+		timestamps: ["occurred_at"],
+		uniqueKeys: [{
+			name: "audit_events_pkey",
+			columns: ["id"]
+		}, {
+			name: "audit_events_seq_key",
+			columns: ["seq"]
+		}]
+	},
+	change_set_items: {
+		primaryKey: ["id"],
+		generated: { id: "uuid" },
+		columns: [
+			"id",
+			"change_set_id",
+			"kind",
+			"position",
+			"entry_id",
+			"model_id",
+			"locale",
+			"action",
+			"source_revision_id",
+			"schema_draft_id",
+			"status",
+			"error",
+			"ship_state",
+			"created_at",
+			"site_id"
+		],
+		nullable: [
+			"entry_id",
+			"model_id",
+			"locale",
+			"action",
+			"source_revision_id",
+			"schema_draft_id",
+			"error",
+			"ship_state"
+		],
+		timestamps: ["created_at"],
+		uniqueKeys: [
+			{
+				name: "change_set_items_draft_uq",
+				columns: ["schema_draft_id"]
+			},
+			{
+				name: "change_set_items_entry_uq",
+				columns: [
+					"change_set_id",
+					"entry_id",
+					"locale"
+				]
+			},
+			{
+				name: "change_set_items_pkey",
+				columns: ["id"]
+			}
+		]
+	},
+	change_sets: {
+		primaryKey: ["id"],
+		generated: { id: "uuid" },
+		columns: [
+			"id",
+			"title",
+			"description",
+			"status",
+			"ship_phase",
+			"source",
+			"restore_of_seq",
+			"scheduled_for",
+			"schedule_job_id",
+			"scheduled_by",
+			"scheduled_by_token",
+			"ship_job_id",
+			"ship_mode",
+			"ship_requested_by",
+			"ship_requested_by_token",
+			"acknowledge_breaking",
+			"acknowledge_destructive",
+			"deployment_connection_id",
+			"deployment_run_id",
+			"shipped_at",
+			"shipped_seq",
+			"schema_version_after",
+			"error",
+			"restore_report",
+			"created_by",
+			"created_by_token",
+			"version",
+			"created_at",
+			"updated_at",
+			"site_id"
+		],
+		nullable: [
+			"ship_phase",
+			"restore_of_seq",
+			"scheduled_for",
+			"schedule_job_id",
+			"scheduled_by",
+			"scheduled_by_token",
+			"ship_job_id",
+			"ship_mode",
+			"ship_requested_by",
+			"ship_requested_by_token",
+			"deployment_connection_id",
+			"deployment_run_id",
+			"shipped_at",
+			"shipped_seq",
+			"schema_version_after",
+			"error",
+			"created_by",
+			"created_by_token"
+		],
+		timestamps: [
+			"scheduled_for",
+			"shipped_at",
+			"created_at",
+			"updated_at"
+		],
+		uniqueKeys: [{
+			name: "change_sets_id_site_uq",
+			columns: ["id", "site_id"]
+		}, {
+			name: "change_sets_pkey",
+			columns: ["id"]
+		}]
+	},
+	content_health_findings: {
+		primaryKey: ["id"],
+		generated: { id: "uuid" },
+		columns: [
+			"id",
+			"entry_id",
+			"model_id",
+			"locale",
+			"rule",
+			"subject",
+			"severity",
+			"path",
+			"details",
+			"first_seen_at",
+			"last_seen_at",
+			"resolved_at",
+			"site_id"
+		],
+		nullable: ["path", "resolved_at"],
+		timestamps: [
+			"first_seen_at",
+			"last_seen_at",
+			"resolved_at"
+		],
+		uniqueKeys: [{
+			name: "content_health_findings_entry_id_locale_rule_subject_key",
+			columns: [
+				"entry_id",
+				"locale",
+				"rule",
+				"subject"
+			]
+		}, {
+			name: "content_health_findings_pkey",
+			columns: ["id"]
+		}]
+	},
+	content_revisions: {
+		primaryKey: ["id"],
+		generated: { id: "uuid" },
+		columns: [
+			"id",
+			"entry_id",
+			"locale",
+			"schema_revision_id",
+			"data",
+			"reason",
+			"author_type",
+			"author_id",
+			"parent_revision_id",
+			"created_at"
+		],
+		nullable: ["author_id", "parent_revision_id"],
+		timestamps: ["created_at"],
+		uniqueKeys: [{
+			name: "content_revisions_pkey",
+			columns: ["id"]
+		}]
+	},
+	deployment_connections: {
+		primaryKey: ["id"],
+		generated: { id: "uuid" },
+		columns: [
+			"id",
+			"name",
+			"provider",
+			"settings",
+			"secrets_encrypted",
+			"secret_env_refs",
+			"delivery_role_id",
+			"preview_url_template",
+			"trigger_policy",
+			"debounce_seconds",
+			"allow_private_network",
+			"enabled",
+			"version",
+			"created_by",
+			"created_at",
+			"updated_at",
+			"site_id"
+		],
+		nullable: [
+			"delivery_role_id",
+			"preview_url_template",
+			"created_by"
+		],
+		timestamps: ["created_at", "updated_at"],
+		uniqueKeys: [{
+			name: "deployment_connections_pkey",
+			columns: ["id"]
+		}]
+	},
+	deployment_runs: {
+		primaryKey: ["id"],
+		generated: { id: "uuid" },
+		columns: [
+			"id",
+			"connection_id",
+			"status",
+			"status_rank",
+			"trigger",
+			"snapshot_seq",
+			"schema_version",
+			"retry_of",
+			"provider_ref",
+			"log_url",
+			"site_url",
+			"error",
+			"timeline",
+			"job_id",
+			"triggered_at",
+			"finished_at",
+			"created_by",
+			"created_at",
+			"updated_at",
+			"change_set_id"
+		],
+		nullable: [
+			"snapshot_seq",
+			"schema_version",
+			"retry_of",
+			"provider_ref",
+			"log_url",
+			"site_url",
+			"error",
+			"job_id",
+			"triggered_at",
+			"finished_at",
+			"created_by",
+			"change_set_id"
+		],
+		timestamps: [
+			"triggered_at",
+			"finished_at",
+			"created_at",
+			"updated_at"
+		],
+		uniqueKeys: [{
+			name: "deployment_runs_pkey",
+			columns: ["id"]
+		}, {
+			name: "deployment_runs_queued_uq",
+			columns: ["connection_id"]
+		}]
+	},
+	editor_presence: {
+		primaryKey: [
+			"entry_id",
+			"admin_user_id",
+			"tab_id"
+		],
+		columns: [
+			"entry_id",
+			"model_id",
+			"admin_user_id",
+			"tab_id",
+			"locale",
+			"started_at",
+			"last_seen_at"
+		],
+		nullable: ["locale"],
+		timestamps: ["started_at", "last_seen_at"],
+		uniqueKeys: [{
+			name: "editor_presence_pkey",
+			columns: [
+				"entry_id",
+				"admin_user_id",
+				"tab_id"
+			]
+		}]
+	},
+	email_confirmations: {
+		primaryKey: ["id"],
+		generated: { id: "uuid" },
+		columns: [
+			"id",
+			"app_user_id",
+			"email",
+			"token_hash",
+			"expires_at",
+			"used_at",
+			"created_at",
+			"updated_at"
+		],
+		nullable: ["token_hash", "used_at"],
+		timestamps: [
+			"expires_at",
+			"used_at",
+			"created_at",
+			"updated_at"
+		],
+		uniqueKeys: [{
+			name: "email_confirmations_pkey",
+			columns: ["id"]
+		}, {
+			name: "email_confirmations_token_hash_key",
+			columns: ["token_hash"]
+		}]
+	},
+	entries: {
+		primaryKey: ["id"],
+		generated: { id: "uuid" },
+		columns: [
+			"id",
+			"model_id",
+			"owner_app_user_id",
+			"created_by_admin_id",
+			"created_at",
+			"updated_at",
+			"deleted_at",
+			"site_id"
+		],
+		nullable: [
+			"owner_app_user_id",
+			"created_by_admin_id",
+			"deleted_at"
+		],
+		timestamps: [
+			"created_at",
+			"updated_at",
+			"deleted_at"
+		],
+		uniqueKeys: [{
+			name: "entries_id_site_uq",
+			columns: ["id", "site_id"]
+		}, {
+			name: "entries_pkey",
+			columns: ["id"]
+		}]
+	},
+	entry_heads: {
+		primaryKey: [
+			"entry_id",
+			"locale",
+			"state"
+		],
+		generated: { change_seq: "entry_heads_change_seq" },
+		columns: [
+			"entry_id",
+			"model_id",
+			"locale",
+			"state",
+			"revision_id",
+			"data",
+			"autosaved_at",
+			"version",
+			"change_seq",
+			"created_at",
+			"updated_at",
+			"site_id",
+			"entry_created_at"
+		],
+		nullable: ["autosaved_at", "entry_created_at"],
+		timestamps: [
+			"autosaved_at",
+			"created_at",
+			"updated_at",
+			"entry_created_at"
+		],
+		uniqueKeys: [{
+			name: "entry_heads_pkey",
+			columns: [
+				"entry_id",
+				"locale",
+				"state"
+			]
+		}]
+	},
+	extension_hook_runs: {
+		primaryKey: ["event_id", "hook"],
+		columns: [
+			"event_id",
+			"hook",
+			"job_id",
+			"completed_at"
+		],
+		nullable: ["job_id"],
+		timestamps: ["completed_at"],
+		uniqueKeys: [{
+			name: "extension_hook_runs_pkey",
+			columns: ["event_id", "hook"]
+		}]
+	},
+	field_reads: {
+		primaryKey: [
+			"day",
+			"site_id",
+			"model_id",
+			"field_path",
+			"principal_key",
+			"selection"
+		],
+		columns: [
+			"day",
+			"model_id",
+			"field_path",
+			"principal_key",
+			"selection",
+			"reads",
+			"last_read_at",
+			"site_id"
+		],
+		nullable: [],
+		timestamps: ["last_read_at"],
+		uniqueKeys: [{
+			name: "field_reads_pkey",
+			columns: [
+				"day",
+				"site_id",
+				"model_id",
+				"field_path",
+				"principal_key",
+				"selection"
+			]
+		}]
+	},
+	jobs: {
+		primaryKey: ["id"],
+		generated: { id: "uuid" },
+		columns: [
+			"id",
+			"type",
+			"payload",
+			"status",
+			"priority",
+			"run_at",
+			"attempts",
+			"max_attempts",
+			"idempotency_key",
+			"locked_by",
+			"locked_until",
+			"checkpoint",
+			"result",
+			"last_error",
+			"created_at",
+			"updated_at",
+			"finished_at"
+		],
+		nullable: [
+			"idempotency_key",
+			"locked_by",
+			"locked_until",
+			"checkpoint",
+			"result",
+			"last_error",
+			"finished_at"
+		],
+		timestamps: [
+			"run_at",
+			"locked_until",
+			"created_at",
+			"updated_at",
+			"finished_at"
+		],
+		uniqueKeys: [{
+			name: "jobs_idempotency_key_uq",
+			columns: ["idempotency_key"]
+		}, {
+			name: "jobs_pkey",
+			columns: ["id"]
+		}]
+	},
+	locales: {
+		primaryKey: ["code"],
+		columns: [
+			"code",
+			"label",
+			"is_default",
+			"fallbacks",
+			"created_at",
+			"updated_at"
+		],
+		nullable: [],
+		timestamps: ["created_at", "updated_at"],
+		uniqueKeys: [{
+			name: "locales_pkey",
+			columns: ["code"]
+		}, {
+			name: "locales_single_default_uq",
+			columns: ["is_default"]
+		}]
+	},
+	media_assets: {
+		primaryKey: ["id"],
+		columns: [
+			"id",
+			"folder_id",
+			"storage_driver",
+			"storage_key",
+			"original_filename",
+			"mime_type",
+			"size_bytes",
+			"width",
+			"height",
+			"checksum_sha256",
+			"alt",
+			"caption",
+			"focal_x",
+			"focal_y",
+			"visibility",
+			"status",
+			"processing_error",
+			"created_by",
+			"version",
+			"deleted_at",
+			"created_at",
+			"updated_at",
+			"site_id"
+		],
+		nullable: [
+			"folder_id",
+			"width",
+			"height",
+			"checksum_sha256",
+			"focal_x",
+			"focal_y",
+			"processing_error",
+			"created_by",
+			"deleted_at"
+		],
+		timestamps: [
+			"deleted_at",
+			"created_at",
+			"updated_at"
+		],
+		uniqueKeys: [{
+			name: "media_assets_pkey",
+			columns: ["id"]
+		}, {
+			name: "media_assets_storage_key_uq",
+			columns: ["storage_key"]
+		}]
+	},
+	media_folders: {
+		primaryKey: ["id"],
+		generated: { id: "uuid" },
+		columns: [
+			"id",
+			"parent_id",
+			"name",
+			"created_by",
+			"version",
+			"created_at",
+			"updated_at",
+			"site_id"
+		],
+		nullable: ["parent_id", "created_by"],
+		timestamps: ["created_at", "updated_at"],
+		uniqueKeys: [
+			{
+				name: "media_folders_id_site_uq",
+				columns: ["id", "site_id"]
+			},
+			{
+				name: "media_folders_pkey",
+				columns: ["id"]
+			},
+			{
+				name: "media_folders_sibling_name_uq",
+				columns: [
+					"site_id",
+					"parent_id",
+					"name"
+				]
+			}
+		]
+	},
+	media_references: {
+		primaryKey: [
+			"asset_id",
+			"entry_id",
+			"locale",
+			"state",
+			"field_id"
+		],
+		columns: [
+			"asset_id",
+			"entry_id",
+			"model_id",
+			"field_id",
+			"locale",
+			"state",
+			"created_at"
+		],
+		nullable: [],
+		timestamps: ["created_at"],
+		uniqueKeys: [{
+			name: "media_references_pk",
+			columns: [
+				"asset_id",
+				"entry_id",
+				"locale",
+				"state",
+				"field_id"
+			]
+		}]
+	},
+	media_upload_grants: {
+		primaryKey: ["id"],
+		generated: { id: "uuid" },
+		columns: [
+			"id",
+			"asset_id",
+			"kind",
+			"storage_driver",
+			"storage_key",
+			"original_filename",
+			"declared_mime_type",
+			"max_size_bytes",
+			"folder_id",
+			"visibility",
+			"created_by",
+			"created_by_principal",
+			"status",
+			"expires_at",
+			"consumed_at",
+			"created_at",
+			"site_id"
+		],
+		nullable: [
+			"folder_id",
+			"created_by",
+			"consumed_at"
+		],
+		timestamps: [
+			"expires_at",
+			"consumed_at",
+			"created_at"
+		],
+		uniqueKeys: [{
+			name: "media_upload_grants_pkey",
+			columns: ["id"]
+		}, {
+			name: "media_upload_grants_storage_key_key",
+			columns: ["storage_key"]
+		}]
+	},
+	media_variants: {
+		primaryKey: ["id"],
+		generated: { id: "uuid" },
+		columns: [
+			"id",
+			"asset_id",
+			"name",
+			"width",
+			"height",
+			"format",
+			"mime_type",
+			"storage_key",
+			"size_bytes",
+			"checksum_sha256",
+			"status",
+			"error",
+			"created_at",
+			"updated_at"
+		],
+		nullable: [
+			"width",
+			"height",
+			"storage_key",
+			"size_bytes",
+			"checksum_sha256",
+			"error"
+		],
+		timestamps: ["created_at", "updated_at"],
+		uniqueKeys: [
+			{
+				name: "media_variants_asset_name_uq",
+				columns: ["asset_id", "name"]
+			},
+			{
+				name: "media_variants_pkey",
+				columns: ["id"]
+			},
+			{
+				name: "media_variants_storage_key_uq",
+				columns: ["storage_key"]
+			}
+		]
+	},
+	model_active_versions: {
+		primaryKey: ["model_id"],
+		columns: [
+			"model_id",
+			"revision_id",
+			"version",
+			"schema_version",
+			"activated_at"
+		],
+		nullable: [],
+		timestamps: ["activated_at"],
+		uniqueKeys: [{
+			name: "model_active_versions_pkey",
+			columns: ["model_id"]
+		}]
+	},
+	models: {
+		primaryKey: ["id"],
+		columns: [
+			"id",
+			"kind",
+			"api_key",
+			"created_at",
+			"updated_at",
+			"deleted_at",
+			"site_id"
+		],
+		nullable: ["deleted_at", "site_id"],
+		timestamps: [
+			"created_at",
+			"updated_at",
+			"deleted_at"
+		],
+		uniqueKeys: [{
+			name: "models_api_key_uq",
+			columns: ["site_id", "api_key"]
+		}, {
+			name: "models_pkey",
+			columns: ["id"]
+		}]
+	},
+	outbox_events: {
+		primaryKey: ["id"],
+		identity: "id",
+		generated: { event_id: "uuid" },
+		columns: [
+			"id",
+			"event_id",
+			"type",
+			"aggregate_type",
+			"aggregate_id",
+			"payload",
+			"created_at",
+			"dispatched_at",
+			"dispatch_attempts",
+			"last_dispatch_error",
+			"site_id"
+		],
+		nullable: [
+			"dispatched_at",
+			"last_dispatch_error",
+			"site_id"
+		],
+		timestamps: ["created_at", "dispatched_at"],
+		uniqueKeys: [{
+			name: "outbox_events_event_id_key",
+			columns: ["event_id"]
+		}, {
+			name: "outbox_events_pkey",
+			columns: ["id"]
+		}]
+	},
+	password_resets: {
+		primaryKey: ["id"],
+		generated: { id: "uuid" },
+		columns: [
+			"id",
+			"admin_user_id",
+			"token_hash",
+			"expires_at",
+			"used_at",
+			"created_at",
+			"updated_at"
+		],
+		nullable: ["token_hash", "used_at"],
+		timestamps: [
+			"expires_at",
+			"used_at",
+			"created_at",
+			"updated_at"
+		],
+		uniqueKeys: [{
+			name: "password_resets_pkey",
+			columns: ["id"]
+		}, {
+			name: "password_resets_token_hash_key",
+			columns: ["token_hash"]
+		}]
+	},
+	preview_tokens: {
+		primaryKey: ["id"],
+		generated: { id: "uuid" },
+		columns: [
+			"id",
+			"token_hash",
+			"token_prefix",
+			"model_id",
+			"entry_id",
+			"locale",
+			"connection_id",
+			"delivery_role_id",
+			"created_by",
+			"expires_at",
+			"revoked_at",
+			"last_used_at",
+			"created_at",
+			"site_id"
+		],
+		nullable: [
+			"locale",
+			"connection_id",
+			"delivery_role_id",
+			"revoked_at",
+			"last_used_at"
+		],
+		timestamps: [
+			"expires_at",
+			"revoked_at",
+			"last_used_at",
+			"created_at"
+		],
+		uniqueKeys: [{
+			name: "preview_tokens_pkey",
+			columns: ["id"]
+		}, {
+			name: "preview_tokens_token_hash_key",
+			columns: ["token_hash"]
+		}]
+	},
+	publication_log: {
+		primaryKey: ["id"],
+		identity: "id",
+		columns: [
+			"id",
+			"entry_id",
+			"model_id",
+			"locale",
+			"revision_id",
+			"from_seq",
+			"to_seq",
+			"published_at",
+			"site_id"
+		],
+		nullable: ["to_seq"],
+		timestamps: ["published_at"],
+		uniqueKeys: [{
+			name: "publication_log_open_uq",
+			columns: ["entry_id", "locale"]
+		}, {
+			name: "publication_log_pkey",
+			columns: ["id"]
+		}]
+	},
+	publication_snapshots: {
+		primaryKey: ["site_id", "seq"],
+		columns: [
+			"seq",
+			"schema_version",
+			"source",
+			"change_set_id",
+			"actor_type",
+			"actor_id",
+			"created_at",
+			"site_id"
+		],
+		nullable: [
+			"schema_version",
+			"change_set_id",
+			"actor_type",
+			"actor_id"
+		],
+		timestamps: ["created_at"],
+		uniqueKeys: [{
+			name: "publication_snapshots_pkey",
+			columns: ["site_id", "seq"]
+		}]
+	},
+	publication_state: {
+		primaryKey: ["site_id"],
+		columns: ["last_seq", "site_id"],
+		nullable: [],
+		uniqueKeys: [{
+			name: "publication_state_pkey",
+			columns: ["site_id"]
+		}]
+	},
+	relation_edges: {
+		primaryKey: [
+			"source_entry_id",
+			"locale",
+			"state",
+			"field_id",
+			"position"
+		],
+		columns: [
+			"source_entry_id",
+			"locale",
+			"state",
+			"field_id",
+			"position",
+			"target_entry_id"
+		],
+		nullable: [],
+		uniqueKeys: [{
+			name: "relation_edges_pkey",
+			columns: [
+				"source_entry_id",
+				"locale",
+				"state",
+				"field_id",
+				"position"
+			]
+		}]
+	},
+	scheduled_publications: {
+		primaryKey: ["id"],
+		generated: { id: "uuid" },
+		columns: [
+			"id",
+			"entry_id",
+			"model_id",
+			"locale",
+			"action",
+			"run_at",
+			"status",
+			"created_by_token",
+			"job_id",
+			"snapshot_seq",
+			"error",
+			"executed_at",
+			"created_by",
+			"created_at",
+			"updated_at",
+			"site_id"
+		],
+		nullable: [
+			"created_by_token",
+			"job_id",
+			"snapshot_seq",
+			"error",
+			"executed_at",
+			"created_by"
+		],
+		timestamps: [
+			"run_at",
+			"executed_at",
+			"created_at",
+			"updated_at"
+		],
+		uniqueKeys: [{
+			name: "scheduled_publications_pkey",
+			columns: ["id"]
+		}]
+	},
+	schema_change_jobs: {
+		primaryKey: ["id"],
+		generated: { id: "uuid" },
+		columns: [
+			"id",
+			"target_type",
+			"target_id",
+			"model_id",
+			"from_revision_id",
+			"to_revision_id",
+			"status",
+			"plan",
+			"job_id",
+			"error",
+			"requested_by_type",
+			"requested_by_id",
+			"created_at",
+			"updated_at",
+			"finished_at",
+			"change_set_id"
+		],
+		nullable: [
+			"model_id",
+			"from_revision_id",
+			"to_revision_id",
+			"job_id",
+			"error",
+			"requested_by_id",
+			"finished_at",
+			"change_set_id"
+		],
+		timestamps: [
+			"created_at",
+			"updated_at",
+			"finished_at"
+		],
+		uniqueKeys: [{
+			name: "schema_change_jobs_in_flight_uq",
+			columns: ["target_type", "target_id"]
+		}, {
+			name: "schema_change_jobs_pkey",
+			columns: ["id"]
+		}]
+	},
+	schema_drafts: {
+		primaryKey: ["id"],
+		generated: { id: "uuid" },
+		columns: [
+			"id",
+			"change_set_id",
+			"definition_id",
+			"kind",
+			"api_key",
+			"base_version",
+			"definition",
+			"version",
+			"updated_by_type",
+			"updated_by_id",
+			"created_at",
+			"updated_at",
+			"shared"
+		],
+		nullable: [
+			"base_version",
+			"definition",
+			"updated_by_id"
+		],
+		timestamps: ["created_at", "updated_at"],
+		uniqueKeys: [{
+			name: "schema_drafts_pkey",
+			columns: ["id"]
+		}, {
+			name: "schema_drafts_set_definition_uq",
+			columns: ["change_set_id", "definition_id"]
+		}]
+	},
+	schema_revisions: {
+		primaryKey: ["id"],
+		generated: { id: "uuid" },
+		columns: [
+			"id",
+			"model_id",
+			"version",
+			"definition",
+			"hash",
+			"parent_revision_id",
+			"created_by_type",
+			"created_by_id",
+			"created_at"
+		],
+		nullable: ["parent_revision_id", "created_by_id"],
+		timestamps: ["created_at"],
+		uniqueKeys: [{
+			name: "schema_revisions_model_version_uq",
+			columns: ["model_id", "version"]
+		}, {
+			name: "schema_revisions_pkey",
+			columns: ["id"]
+		}]
+	},
+	schema_settings: {
+		primaryKey: ["id"],
+		columns: [
+			"id",
+			"read_only",
+			"read_only_reason",
+			"updated_by_type",
+			"updated_by_id",
+			"updated_at"
+		],
+		nullable: [
+			"read_only_reason",
+			"updated_by_type",
+			"updated_by_id"
+		],
+		timestamps: ["updated_at"],
+		uniqueKeys: [{
+			name: "schema_settings_pkey",
+			columns: ["id"]
+		}]
+	},
+	setup_tokens: {
+		primaryKey: ["id"],
+		generated: { id: "uuid" },
+		columns: [
+			"id",
+			"token_hash",
+			"used_at",
+			"superseded_at",
+			"created_at",
+			"updated_at"
+		],
+		nullable: ["used_at", "superseded_at"],
+		timestamps: [
+			"used_at",
+			"superseded_at",
+			"created_at",
+			"updated_at"
+		],
+		uniqueKeys: [{
+			name: "setup_tokens_pkey",
+			columns: ["id"]
+		}, {
+			name: "setup_tokens_token_hash_key",
+			columns: ["token_hash"]
+		}]
+	},
+	site_app_roles: {
+		primaryKey: [
+			"site_id",
+			"audience",
+			"role_id"
+		],
+		columns: [
+			"site_id",
+			"audience",
+			"role_id",
+			"created_at"
+		],
+		nullable: [],
+		timestamps: ["created_at"],
+		uniqueKeys: [{
+			name: "site_app_roles_pkey",
+			columns: [
+				"site_id",
+				"audience",
+				"role_id"
+			]
+		}]
+	},
+	sites: {
+		primaryKey: ["id"],
+		generated: { id: "uuid" },
+		columns: [
+			"id",
+			"key",
+			"name",
+			"is_primary",
+			"version",
+			"created_at",
+			"updated_at",
+			"seo_defaults"
+		],
+		nullable: ["seo_defaults"],
+		timestamps: ["created_at", "updated_at"],
+		uniqueKeys: [
+			{
+				name: "sites_key_key",
+				columns: ["key"]
+			},
+			{
+				name: "sites_pkey",
+				columns: ["id"]
+			},
+			{
+				name: "sites_single_primary_uq",
+				columns: ["is_primary"]
+			}
+		]
+	},
+	system_settings: {
+		primaryKey: ["key"],
+		columns: [
+			"key",
+			"value",
+			"updated_at"
+		],
+		nullable: [],
+		timestamps: ["updated_at"],
+		uniqueKeys: [{
+			name: "system_settings_pkey",
+			columns: ["key"]
+		}]
+	},
+	system_versions: {
+		primaryKey: ["id"],
+		columns: [
+			"id",
+			"schema_version",
+			"permissions_version",
+			"updated_at",
+			"release"
+		],
+		nullable: ["release"],
+		timestamps: ["updated_at"],
+		uniqueKeys: [{
+			name: "system_versions_pkey",
+			columns: ["id"]
+		}]
+	},
+	token_reads: {
+		primaryKey: [
+			"day",
+			"site_id",
+			"principal_key"
+		],
+		columns: [
+			"day",
+			"principal_key",
+			"requests",
+			"last_snapshot",
+			"last_read_at",
+			"site_id"
+		],
+		nullable: ["last_snapshot"],
+		timestamps: ["last_read_at"],
+		uniqueKeys: [{
+			name: "token_reads_pkey",
+			columns: [
+				"day",
+				"site_id",
+				"principal_key"
+			]
+		}]
+	},
+	unique_values: {
+		primaryKey: [
+			"site_id",
+			"field_id",
+			"locale",
+			"state",
+			"value_hash"
+		],
+		columns: [
+			"field_id",
+			"locale",
+			"state",
+			"value_hash",
+			"entry_id",
+			"model_id",
+			"site_id"
+		],
+		nullable: [],
+		uniqueKeys: [{
+			name: "unique_values_pkey",
+			columns: [
+				"site_id",
+				"field_id",
+				"locale",
+				"state",
+				"value_hash"
+			]
+		}]
+	},
+	webhook_deliveries: {
+		primaryKey: ["id"],
+		generated: { id: "uuid" },
+		columns: [
+			"id",
+			"webhook_id",
+			"event_id",
+			"event_type",
+			"payload",
+			"is_test",
+			"status",
+			"attempts",
+			"last_response_status",
+			"last_error",
+			"attempt_log",
+			"job_id",
+			"delivered_at",
+			"created_at",
+			"updated_at"
+		],
+		nullable: [
+			"event_id",
+			"last_response_status",
+			"last_error",
+			"job_id",
+			"delivered_at"
+		],
+		timestamps: [
+			"delivered_at",
+			"created_at",
+			"updated_at"
+		],
+		uniqueKeys: [{
+			name: "webhook_deliveries_event_uq",
+			columns: ["webhook_id", "event_id"]
+		}, {
+			name: "webhook_deliveries_pkey",
+			columns: ["id"]
+		}]
+	},
+	webhooks: {
+		primaryKey: ["id"],
+		generated: { id: "uuid" },
+		columns: [
+			"id",
+			"name",
+			"url",
+			"events",
+			"enabled",
+			"secret_encrypted",
+			"allow_private_network",
+			"max_attempts",
+			"version",
+			"created_by",
+			"created_at",
+			"updated_at",
+			"site_id"
+		],
+		nullable: ["created_by", "site_id"],
+		timestamps: ["created_at", "updated_at"],
+		uniqueKeys: [{
+			name: "webhooks_pkey",
+			columns: ["id"]
+		}]
+	},
+	advisory_locks: {
+		primaryKey: ["namespace", "lock_key"],
+		columns: ["namespace", "lock_key"],
+		nullable: [],
+		uniqueKeys: [{
+			name: "advisory_locks_pkey",
+			columns: ["namespace", "lock_key"]
+		}]
+	},
+	notifications: {
+		primaryKey: ["id"],
+		identity: "id",
+		columns: [
+			"id",
+			"channel",
+			"payload",
+			"created_at"
+		],
+		nullable: [],
+		timestamps: ["created_at"],
+		uniqueKeys: [{
+			name: "notifications_pkey",
+			columns: ["id"]
+		}]
+	},
+	sequence_entry_heads_change_seq: {
+		primaryKey: ["value"],
+		identity: "value",
+		columns: ["value"],
+		nullable: [],
+		uniqueKeys: [{
+			name: "sequence_entry_heads_change_seq_pkey",
+			columns: ["value"]
+		}]
+	}
+};
+/** The table's metadata, or undefined for a table Shapio does not own (tests' own tables). */
+const tableInfo = (table) => MYSQL_TABLES[table];
+//#endregion
+//#region ../../apps/api/src/db/mysql/conflicts.ts
+/** The alias the compiler gives the inserted row in `ON DUPLICATE KEY UPDATE` (PostgreSQL's `excluded`). */
+const EXCLUDED_ALIAS = "excluded";
+const sameColumns = (a, b) => a.length === b.length && a.every((column) => b.includes(column));
+/**
+* Whether `ON DUPLICATE KEY` (which fires on any unique key) behaves like `ON CONFLICT (target)` for this
+* insert: every other unique key of the table is made of columns generated for this insert (fresh UUIDs),
+* so it cannot collide. An untargeted conflict (`ON CONFLICT DO NOTHING`) matches any key, like MySQL.
+*/
+const duplicateKeyMatchesTarget = (table, target, supplied) => {
+	const info = tableInfo(table);
+	if (!info) return false;
+	if (target === void 0) return true;
+	const generated = info.generated ?? {};
+	return info.uniqueKeys.every((key) => sameColumns(key.columns, target) || key.columns.every((column) => generated[column] === "uuid" && !supplied.includes(column)));
+};
+/**
+* Tables whose rows a trigger keeps immutable (the baseline's `*_no_update` triggers): a no-op
+* `ON DUPLICATE KEY UPDATE` is still an UPDATE there, so their `DO NOTHING` goes through the plan.
+*/
+const REFUSES_UPDATES = /* @__PURE__ */ new Set(["content_revisions", "schema_revisions"]);
+const targetOf = (conflict) => conflict.columns?.map((column) => column.column.name);
+/**
+* `ON CONFLICT … DO UPDATE` as `ON DUPLICATE KEY UPDATE`, and `ON CONFLICT … DO NOTHING` without RETURNING
+* as `ON DUPLICATE KEY UPDATE <key> = <key>` (a no-op), when MySQL's any-key behaviour equals the target's
+* (`duplicateKeyMatchesTarget`). Any other conflict clause (another unique key could fire, a `WHERE` on the
+* update, RETURNING) is left for the compiler's plan: each row inserted under a savepoint, and a duplicate
+* on the target either skipped or turned into an UPDATE of the row it found.
+*/
+const toOnDuplicateKey = (node, conflict, table) => {
+	const target = targetOf(conflict);
+	const supplied = node.columns?.map((column) => column.column.name) ?? [];
+	const matches = duplicateKeyMatchesTarget(table, target, supplied);
+	if (conflict.doNothing) {
+		if (node.returning || !matches || REFUSES_UPDATES.has(table)) return node;
+		const column = target?.[0] ?? tableInfo(table).primaryKey[0];
+		const self = ReferenceNode.create(ColumnNode.create(column), TableNode.create(table));
+		return Object.freeze({
+			...node,
+			onConflict: void 0,
+			onDuplicateKey: OnDuplicateKeyNode.create([ColumnUpdateNode.create(ColumnNode.create(column), self)])
+		});
+	}
+	if (conflict.constraint || conflict.indexExpression) throw new Error(`MySQL: ON CONFLICT on ${table} needs a column target`);
+	if (conflict.updateWhere || !matches || node.returning || !node.values || !ValuesNode.is(node.values)) return node;
+	return Object.freeze({
+		...node,
+		onConflict: void 0,
+		onDuplicateKey: OnDuplicateKeyNode.create(conflict.updates ?? [])
+	});
+};
+const FOREIGN_KEY_CODES = /* @__PURE__ */ new Set(["ER_ROW_IS_REFERENCED_2", "ER_NO_REFERENCED_ROW_2"]);
+const fieldsOf = (error) => typeof error === "object" && error !== null ? error : void 0;
+/** `Duplicate entry '…' for key 'table.index'` → { table, index } (`PRIMARY` → `<table>_pkey`). */
+const duplicateKeyOf = (message) => {
+	const match = /for key '(?:([^.']+)\.)?([^']+)'$/.exec(message);
+	if (!match) return;
+	const [, table, key] = match;
+	return {
+		table,
+		constraint: key === "PRIMARY" && table ? `${table}_pkey` : key
+	};
+};
+/** `… (\`db\`.\`table\`, CONSTRAINT \`name\` FOREIGN KEY …` → { table, constraint }. */
+const foreignKeyOf = (message) => {
+	const match = /\(`[^`]+`\.`([^`]+)`, CONSTRAINT `([^`]+)`/.exec(message);
+	return match ? {
+		table: match[1],
+		constraint: match[2]
+	} : void 0;
+};
+/** Adds `constraint` and `table` to a MySQL constraint error (mutates and returns it). */
+const annotateMysqlError = (error) => {
+	const fields = fieldsOf(error);
+	if (!fields || typeof fields.sqlMessage !== "string") return error;
+	const found = fields.code === "ER_DUP_ENTRY" ? duplicateKeyOf(fields.sqlMessage) : FOREIGN_KEY_CODES.has(fields.code) ? foreignKeyOf(fields.sqlMessage) : void 0;
+	if (found) {
+		fields.constraint = found.constraint;
+		fields.table = found.table;
+	}
+	return error;
+};
+/** Whether `error` is a duplicate key on one of `indexes` (any unique key when `indexes` is undefined). */
+const isDuplicateKeyOn = (error, indexes) => {
+	const fields = fieldsOf(error);
+	if (fields?.code !== "ER_DUP_ENTRY") return false;
+	return indexes === void 0 || indexes.has(fields.constraint);
+};
+//#endregion
+//#region ../../apps/api/src/db/mysql/planKeys.ts
+/** Building blocks of statement plans (`plans.ts`): rows found again by their keys. */
+const ref = (column, table) => ReferenceNode.create(ColumnNode.create(column), table === void 0 ? void 0 : TableNode.create(table));
+const equals = (left, right) => BinaryOperationNode.create(left, OperatorNode.create("="), right);
+const valueNode = (value) => value !== null && typeof value === "object" && "kind" in value ? value : ValueNode.create(value);
+/** `(k1 = v1 and k2 = v2) or (…)` over rows of key values (values may be expressions). */
+const keyMatch = (columns, keys) => {
+	if (columns.length === 1) {
+		const [column] = columns;
+		const values = keys.map((key) => key[0]);
+		if (values.every((value) => !(value !== null && typeof value === "object" && "kind" in value))) return WhereNode.create(BinaryOperationNode.create(ref(column), OperatorNode.create("in"), PrimitiveValueListNode.create(values)));
+	}
+	const rows = keys.map((key) => ParensNode.create(columns.map((column, index) => equals(ref(column), valueNode(key[index]))).reduce((left, right) => AndNode.create(left, right))));
+	return WhereNode.create(rows.slice(1).reduce((left, right) => OrNode.create(left, right), rows[0]));
+};
+const keyText = (values) => JSON.stringify(values.map((value) => String(value).toLowerCase()));
+/** Rows in the order of `keys`, without the key columns the plan selected (expression keys keep the database's order). */
+const inKeyOrder = (rows, columns, keys) => {
+	const keyColumns = columns.map((_, index) => `__shapio_key_${index}`);
+	const strip = (row) => Object.fromEntries(Object.entries(row).filter(([name]) => !keyColumns.includes(name)));
+	if (keys.some((key) => key.some((value) => value !== null && typeof value === "object"))) return rows.map(strip);
+	const position = new Map(keys.map((key, index) => [keyText(key), index]));
+	const positionOf = (row) => position.get(keyText(keyColumns.map((column) => row[column]))) ?? 0;
+	return [...rows].sort((a, b) => positionOf(a) - positionOf(b)).map(strip);
+};
+/** `select <returning>, <key columns as __shapio_key_i> from <table> where <keys>`. */
+const selectByKeys = (table, returning, columns, keys) => Object.freeze({
+	...SelectQueryNode.createFrom([TableNode.create(table)]),
+	selections: [...returning.selections, ...columns.map((column, index) => SelectionNode.create(AliasNode.create(ref(column, table), IdentifierNode.create(`__shapio_key_${index}`))))],
+	where: keyMatch(columns, keys)
+});
+const infoOf = (table) => {
+	const info = tableInfo(table);
+	if (!info) throw new Error(`MySQL: RETURNING and ON CONFLICT need a Shapio table; ${table} is not one`);
+	return info;
+};
+const tableOf = (node, statement) => {
+	const table = node && TableNode.is(node) ? node : void 0;
+	if (!table) throw new Error(`MySQL: ${statement} with RETURNING needs a single table without an alias`);
+	return table.table.identifier.name;
+};
+const resultOf = (rows, affected) => ({
+	rows,
+	numAffectedRows: BigInt(affected)
+});
+/** The value a VALUES row gives `column` (a primitive or an expression node). */
+const rowValue = (row, index) => {
+	if (PrimitiveValueListNode.is(row)) return row.values[index];
+	const value = row.values[index];
+	return value && ValueNode.is(value) ? value.value : value;
+};
+//#endregion
+//#region ../../apps/api/src/db/mysql/insertPlan.ts
+/**
+* INSERT … RETURNING and INSERT … ON CONFLICT on MySQL (`plans.ts`): the insert, then the returned rows by
+* key; with a conflict target, each row under a savepoint, a duplicate on the target skipped or turned into
+* an UPDATE of the row it found.
+*/
+/** Replaces `excluded.<column>` references with the values one VALUES row gives those columns. */
+var ExcludedRowValues = class extends OperationNodeTransformer {
+	#value;
+	constructor(value) {
+		super();
+		this.#value = value;
+	}
+	transformReference(node) {
+		if (node.table?.table.identifier.name === "excluded" && ColumnNode.is(node.column)) return this.#value(node.column.column.name);
+		return node;
+	}
+};
+/**
+* The UPDATE `ON CONFLICT (target) DO UPDATE SET … [WHERE …]` runs on the row the target found, with the
+* proposed row's values in place of `excluded.*`.
+*/
+const conflictUpdate = (table, conflict, target, value) => {
+	const replace = new ExcludedRowValues(value);
+	const match = keyMatch(target, [target.map((column) => value(column))]).where;
+	const where = conflict.updateWhere ? AndNode.create(match, ParensNode.create(replace.transformNode(conflict.updateWhere.where))) : match;
+	return Object.freeze({
+		...UpdateQueryNode.create([TableNode.create(table)]),
+		updates: (conflict.updates ?? []).map((update) => replace.transformNode(update)),
+		where: WhereNode.create(where)
+	});
+};
+const insertPlan = (node, compile) => {
+	const table = tableOf(node.into, "INSERT");
+	const info = infoOf(table);
+	if (!node.values || !ValuesNode.is(node.values) || !node.columns) throw new Error(`MySQL: INSERT … SELECT into ${table} cannot use RETURNING or ON CONFLICT DO NOTHING`);
+	const columns = node.columns.map((column) => column.column.name);
+	const rows = node.values.values;
+	const conflict = node.onConflict;
+	const target = conflict?.columns?.map((column) => column.column.name);
+	const targetIndexes = target ? new Set(info.uniqueKeys.filter((key) => sameColumns(key.columns, target)).map((key) => key.name)) : void 0;
+	if (targetIndexes && targetIndexes.size === 0) throw new Error(`MySQL: no unique key on ${table} (${target.join(", ")}) for ON CONFLICT`);
+	const identityKey = info.identity !== void 0 && !columns.includes(info.identity);
+	const perRow = conflict !== void 0 || identityKey && node.returning !== void 0;
+	const base = Object.freeze({
+		...node,
+		onConflict: void 0,
+		returning: void 0
+	});
+	const statements = perRow ? rows.map((row) => compile(Object.freeze({
+		...base,
+		values: ValuesNode.create([row])
+	}))) : [compile(base)];
+	const updates = conflict !== void 0 && !conflict.doNothing;
+	if (updates && !target) throw new Error(`MySQL: ON CONFLICT DO UPDATE on ${table} needs a conflict target`);
+	const keyColumns = updates ? target : identityKey ? [info.identity] : info.primaryKey;
+	const valueOf = (rowIndex) => (column) => {
+		const index = columns.indexOf(column);
+		if (index < 0) throw new Error(`MySQL: ON CONFLICT on ${table} refers to ${column}, which the insert leaves out`);
+		return valueNode(rowValue(rows[rowIndex], index));
+	};
+	const keyOf = (rowIndex, insertId) => identityKey && !updates ? [String(insertId)] : keyColumns.map((column) => rowValue(rows[rowIndex], columns.indexOf(column)));
+	return (context) => context.atomically(async () => {
+		const keys = [];
+		let affected = 0;
+		for (const [index, statement] of statements.entries()) {
+			let result;
+			try {
+				result = conflict ? await context.savepoint(() => context.run(statement)) : await context.run(statement);
+			} catch (error) {
+				if (!conflict || !isDuplicateKeyOn(error, targetIndexes)) throw error;
+				if (!updates) continue;
+				result = await context.run(compile(conflictUpdate(table, conflict, target, valueOf(index))));
+				if (Number(result.numAffectedRows ?? 0n) === 0) continue;
+			}
+			affected += Number(result.numAffectedRows ?? 0n);
+			if (perRow) keys.push(keyOf(index, result.insertId));
+			else keys.push(...rows.map((_, rowIndex) => keyOf(rowIndex, result.insertId)));
+		}
+		if (!node.returning || keys.length === 0) return resultOf([], affected);
+		const selected = await context.run(compile(selectByKeys(table, node.returning, keyColumns, keys)));
+		return resultOf(inKeyOrder(selected.rows, keyColumns, keys), affected);
+	});
+};
+//#endregion
+//#region ../../apps/api/src/db/mysql/subqueries.ts
+/**
+* Subquery shapes MySQL rejects, rewritten (ADR 0001, "MySQL"): `IN (… LIMIT n)` (error 1235) and a subquery
+* reading the table an UPDATE, DELETE or INSERT writes (error 1093) read a derived table instead, which MySQL
+* materialises first; PostgreSQL's `UPDATE … FROM` becomes a multi-table UPDATE.
+*/
+/** The alias of a derived table wrapped around a subquery. */
+const DERIVED_ALIAS = "shapio_derived";
+const tableNameOf$1 = (node) => node && TableNode.is(node) ? node.table.identifier.name : void 0;
+/**
+* Whether an IN subquery must read a derived table: it has a LIMIT (MySQL rejects `IN (… LIMIT n)`), or it
+* reads `table`, the target of the enclosing UPDATE, DELETE or INSERT (error 1093).
+*/
+const needsDerivedTable = (node, table) => node.limit !== void 0 || table !== void 0 && ((node.from?.froms ?? []).some((item) => tableNameOf$1(AliasNode.is(item) ? item.node : item) === table) || (node.joins ?? []).some((join) => tableNameOf$1(AliasNode.is(join.table) ? join.table.node : join.table) === table));
+/** `(select * from (<subquery>) as shapio_derived)`: MySQL materialises it first. */
+const derived = (node) => Object.freeze({
+	...SelectQueryNode.createFrom([AliasNode.create(node, IdentifierNode.create(DERIVED_ALIAS))]),
+	selections: [SelectionNode.create(SelectAllNode.create())]
+});
+const IN_OPERATORS = /* @__PURE__ */ new Set(["in", "not in"]);
+/** Wraps the IN-subqueries of a WHERE tree that need it (see `needsDerivedTable`). */
+var DerivedTableWrapper = class extends OperationNodeTransformer {
+	#table;
+	constructor(table) {
+		super();
+		this.#table = table;
+	}
+	transformBinaryOperation(node, queryId) {
+		const transformed = super.transformBinaryOperation(node, queryId);
+		const operator = OperatorNode.is(transformed.operator) ? transformed.operator.operator : "";
+		const right = transformed.rightOperand;
+		if (IN_OPERATORS.has(operator) && SelectQueryNode.is(right) && needsDerivedTable(right, this.#table)) return Object.freeze({
+			...transformed,
+			rightOperand: derived(right)
+		});
+		return transformed;
+	}
+	transformSelectQuery(node) {
+		return node;
+	}
+};
+const wrapSubqueries = (where, table) => where ? new DerivedTableWrapper(table).transformNode(where) : where;
+/**
+* An INSERT whose VALUES read the target table in a scalar subquery (`coalesce(max(position) + 1, 0)`):
+* MySQL rejects that (error 1093) unless the subquery reads a derived table, which it materialises first.
+*/
+const withDerivedValueSubqueries = (node) => {
+	const table = node.into?.table.identifier.name;
+	if (!table || !node.values || !ValuesNode.is(node.values)) return node;
+	let changed = false;
+	const rows = node.values.values.map((row) => {
+		if (!ValueListNode.is(row)) return row;
+		const values = row.values.map((value) => {
+			if (SelectQueryNode.is(value) && needsDerivedTable(value, table)) {
+				changed = true;
+				return derived(value);
+			}
+			return value;
+		});
+		return ValueListNode.create(values);
+	});
+	return changed ? Object.freeze({
+		...node,
+		values: ValuesNode.create(rows)
+	}) : node;
+};
+/**
+* `UPDATE t SET … FROM u WHERE …` (PostgreSQL) as MySQL's multi-table `UPDATE t, u SET … WHERE …`, which
+* joins the same way: the WHERE relates the tables.
+*/
+const withFromAsTables = (node) => node.from && node.table ? Object.freeze({
+	...node,
+	table: ListNode.create([node.table, ...node.from.froms]),
+	from: void 0
+}) : node;
+//#endregion
+//#region ../../apps/api/src/db/mysql/keyedWritePlans.ts
+/**
+* UPDATE/DELETE … RETURNING on MySQL (`plans.ts`): lock the matching keys (`SELECT … FOR UPDATE`, or the
+* statement's own `key IN (subquery)`), run the statement by key, then read the returned rows by key.
+*/
+const forUpdate = (node) => node.endModifiers?.some((modifier) => modifier.modifier === "ForUpdate") ? node : Object.freeze({
+	...node,
+	endModifiers: [...node.endModifiers ?? [], SelectModifierNode.create("ForUpdate")]
+});
+/** For `key in (subquery)` (possibly wrapped in the plugin's derived table): the subquery. */
+const keySubquery = (where, key) => {
+	const condition = where?.where;
+	if (key.length !== 1 || !condition || !BinaryOperationNode.is(condition) || !OperatorNode.is(condition.operator) || condition.operator.operator !== "in" || !ReferenceNode.is(condition.leftOperand) || !ColumnNode.is(condition.leftOperand.column) || condition.leftOperand.column.column.name !== key[0] || !SelectQueryNode.is(condition.rightOperand)) return;
+	const subquery = condition.rightOperand;
+	const from = subquery.from?.froms[0];
+	if (from && AliasNode.is(from) && IdentifierNode.is(from.alias) && from.alias.name === "shapio_derived") return SelectQueryNode.is(from.node) ? from.node : void 0;
+	return subquery;
+};
+/** `select <key> from <table> where <where> [order/limit] for update` (or the key subquery itself). */
+const lockingKeySelect = (table, key, node, extra) => {
+	const subquery = extra.length === 0 ? keySubquery(node.where, key) : void 0;
+	if (subquery) return forUpdate(subquery);
+	return forUpdate(Object.freeze({
+		...SelectQueryNode.createFrom([TableNode.create(table)]),
+		selections: [...extra, ...key.map((column, index) => SelectionNode.create(AliasNode.create(ref(column, table), IdentifierNode.create(`__shapio_key_${index}`))))],
+		where: node.where,
+		orderBy: node.orderBy,
+		limit: node.limit
+	}));
+};
+const keysOf = (rows, key, bySubquery) => rows.map((row) => bySubquery ? [Object.values(row)[0]] : key.map((_, index) => row[`__shapio_key_${index}`]));
+const updatePlan = (node, compile) => {
+	const table = tableOf(node.table, "UPDATE");
+	if (node.from || node.joins?.length) throw new Error(`MySQL: UPDATE … FROM/JOIN on ${table} cannot use RETURNING`);
+	const key = infoOf(table).primaryKey;
+	const bySubquery = keySubquery(node.where, key) !== void 0;
+	const lock = compile(lockingKeySelect(table, key, node, []));
+	return (context) => context.atomically(async () => {
+		const keys = keysOf((await context.run(lock)).rows, key, bySubquery);
+		if (keys.length === 0) return resultOf([], 0);
+		await context.run(compile(Object.freeze({
+			...node,
+			where: keyMatch(key, keys),
+			returning: void 0,
+			limit: void 0,
+			orderBy: void 0
+		})));
+		const selected = await context.run(compile(selectByKeys(table, node.returning, key, keys)));
+		return resultOf(inKeyOrder(selected.rows, key, keys), keys.length);
+	});
+};
+const deletePlan = (node, compile) => {
+	const table = tableOf(node.from.froms[0], "DELETE");
+	if (node.from.froms.length > 1 || node.using || node.joins?.length) throw new Error(`MySQL: DELETE … USING/JOIN on ${table} cannot use RETURNING`);
+	const key = infoOf(table).primaryKey;
+	const lock = compile(lockingKeySelect(table, key, node, node.returning.selections));
+	return (context) => context.atomically(async () => {
+		const locked = (await context.run(lock)).rows;
+		const keys = keysOf(locked, key, false);
+		if (keys.length === 0) return resultOf([], 0);
+		await context.run(compile(Object.freeze({
+			...node,
+			where: keyMatch(key, keys),
+			returning: void 0,
+			limit: void 0,
+			orderBy: void 0
+		})));
+		return resultOf(inKeyOrder(locked, key, keys), keys.length);
+	});
+};
+//#endregion
+//#region ../../apps/api/src/db/mysql/plans.ts
+/**
+* Statement plans (ADR 0001, "MySQL"): MySQL has no `RETURNING` and no `ON CONFLICT (target) DO NOTHING`,
+* so the compiler turns such a statement into a few statements the connection runs atomically (inside the
+* caller's transaction under a savepoint, or in a transaction of its own):
+* - INSERT … RETURNING: the insert, then a SELECT of the returned columns by primary key (keys are known:
+*   the plugin generates UUIDs; an identity key comes from `LAST_INSERT_ID()`, one row per statement).
+* - INSERT … ON CONFLICT (target) DO NOTHING [RETURNING]: each row inserted under a savepoint; a duplicate
+*   on the target's unique index (any index without a target) rolls that row back and returns nothing for
+*   it, so other unique violations still raise, as on PostgreSQL.
+* - UPDATE/DELETE … RETURNING: `SELECT <key> … FOR UPDATE` with the statement's WHERE (or, for
+*   `key IN (subquery)`, the subquery itself, keeping its `FOR UPDATE SKIP LOCKED`), the statement by key,
+*   then (UPDATE) a SELECT of the returned columns by key. The rows stay locked, so the result is exact.
+*/
+/** The plan a statement needs on MySQL, or undefined when it runs as written. */
+const planFor = (node, compile) => {
+	switch (node.kind) {
+		case "InsertQueryNode": return node.returning || node.onConflict ? insertPlan(node, compile) : void 0;
+		case "UpdateQueryNode": return node.returning ? updatePlan(node, compile) : void 0;
+		case "DeleteQueryNode": return node.returning ? deletePlan(node, compile) : void 0;
+		default: return;
+	}
+};
+/** The statement without the parts a plan replaces (what logs and errors show). */
+const plannedStatement = (node) => node.kind === "InsertQueryNode" || node.kind === "UpdateQueryNode" || node.kind === "DeleteQueryNode" ? Object.freeze({
+	...node,
+	returning: void 0,
+	...node.kind === "InsertQueryNode" ? { onConflict: void 0 } : {}
+}) : node;
+//#endregion
+//#region ../../apps/api/src/db/mysql/compiler.ts
+/** The property of a compiled query that carries its plan (`plans.ts`). */
+const STATEMENT_PLAN = Symbol("shapio.mysql.plan");
+const planOf = (query) => query[STATEMENT_PLAN];
+/**
+* Kysely's MySQL compiler, plus: statements MySQL cannot run as one get a plan (`plans.ts`), and
+* `ON DUPLICATE KEY UPDATE` names the inserted row `excluded` (MySQL ≥ 8.0.19 row alias), so the
+* `excluded.<column>` references of a PostgreSQL upsert compile unchanged.
+*/
+var ShapioMysqlQueryCompiler = class ShapioMysqlQueryCompiler extends MysqlQueryCompiler {
+	#insertWithValues = false;
+	compileQuery(node, queryId) {
+		const plan = planFor(node, (statement) => new ShapioMysqlQueryCompiler().compileQuery(statement, queryId));
+		if (!plan) return super.compileQuery(node, queryId);
+		const shown = super.compileQuery(plannedStatement(node), queryId);
+		return Object.freeze({
+			...shown,
+			query: node,
+			[STATEMENT_PLAN]: plan
+		});
+	}
+	visitInsertQuery(node) {
+		const previous = this.#insertWithValues;
+		this.#insertWithValues = node.values !== void 0 && ValuesNode.is(node.values);
+		try {
+			super.visitInsertQuery(node);
+		} finally {
+			this.#insertWithValues = previous;
+		}
+	}
+	visitOnDuplicateKey(node) {
+		if (this.#insertWithValues) this.append(`as ${this.getLeftIdentifierWrapper()}${EXCLUDED_ALIAS}${this.getRightIdentifierWrapper()} `);
+		super.visitOnDuplicateKey(node);
+	}
+	visitOnConflict(_node) {
+		throw new Error("MySQL has no ON CONFLICT; the MySQL plugin or a statement plan must replace it");
+	}
+	visitReturning(_node) {
+		throw new Error("MySQL has no RETURNING; a statement plan must replace it");
+	}
+};
+//#endregion
+//#region ../../apps/api/src/db/notifyHub.ts
+/**
+* In-process notification delivery (ADR 0002 notes notifications are an optimisation; consumers also check
+* a durable version): an event bus per database. Every handle on the same database in this process shares
+* one bus, so two app instances in one test process still hear each other.
+* - SQLite: the only delivery (SQLite deployments are single-process).
+* - MySQL: the fast path for listeners in the publishing process; other processes poll the notifications
+*   table (`mysql/notificationListener.ts`), and the row ID lets a listener skip what it already heard.
+*/
+const HUBS = /* @__PURE__ */ new Map();
+const hubFor = (databaseKey) => {
+	let hub = HUBS.get(databaseKey);
+	if (!hub) {
+		hub = new EventEmitter();
+		hub.setMaxListeners(0);
+		HUBS.set(databaseKey, hub);
+	}
+	return hub;
+};
+/** Delivers on a later turn of the event loop, like a notification arriving from the network. */
+const publishNotification = (databaseKey, channel, payload, id) => {
+	setImmediate(() => hubFor(databaseKey).emit("notification", channel, payload, id));
+};
+//#endregion
+//#region ../../apps/api/src/db/poolAcquire.ts
+/**
+* How long a query waits for a free pooled connection (PostgreSQL and MySQL) before it fails with
+* `PoolAcquireTimeoutError`. Without a bound, an exhausted pool queues requests forever and the server
+* stops answering until it restarts. SQLite has no such wait (see `db/sqlite/driver.ts`).
+*/
+const DEFAULT_POOL_ACQUIRE_TIMEOUT_MS = 1e4;
+/**
+* No pooled connection became free in time. A 503 the client may retry; the central error handler logs it
+* as a failed request, so an exhausted pool shows in the logs instead of as a silent hang.
+*/
+var PoolAcquireTimeoutError = class extends AppError {
+	constructor(timeoutMs, poolMax, options) {
+		super(503, "DATABASE_BUSY", `No database connection became free within ${timeoutMs} ms (pool of ${poolMax}); try again shortly`, void 0, options);
+		this.name = "PoolAcquireTimeoutError";
+	}
+};
+/**
+* Opening a new connection took longer than the acquire timeout: the database is unreachable or overloaded.
+* A 503 the client may retry, logged by the central error handler like `PoolAcquireTimeoutError`.
+*/
+var DatabaseUnavailableError = class extends AppError {
+	constructor(timeoutMs, options) {
+		super(503, "DATABASE_UNAVAILABLE", `Could not connect to the database within ${timeoutMs} ms; try again shortly`, void 0, options);
+		this.name = "DatabaseUnavailableError";
+	}
+};
+/** pg-pool's error when `connectionTimeoutMillis` passes while the request waits in the pool's queue. */
+const PG_QUEUE_TIMEOUT_MESSAGE = "timeout exceeded when trying to connect";
+/** pg-pool's error when `connectionTimeoutMillis` passes while it opens a new connection. */
+const PG_CONNECT_TIMEOUT_MESSAGE = "Connection terminated due to connection timeout";
+/** The 503 for a pg-pool acquisition error, or the error itself when it is not a timeout. */
+const pgAcquireError = (error, poolMax, timeoutMs) => {
+	if (!(error instanceof Error)) return error;
+	if (error.message === PG_QUEUE_TIMEOUT_MESSAGE) return new PoolAcquireTimeoutError(timeoutMs, poolMax, { cause: error });
+	if (error.message === PG_CONNECT_TIMEOUT_MESSAGE) return new DatabaseUnavailableError(timeoutMs, { cause: error });
+	return error;
+};
+//#endregion
+//#region ../../apps/api/src/db/mysql/module.ts
+/**
+* mysql2, loaded on first use. A process on PostgreSQL never loads it, and a bundle of the read path (the
+* in-process delivery runtime) can leave it out as an optional dependency.
+*/
+const loadMysql = async () => (await import("mysql2")).default;
+//#endregion
+//#region ../../apps/api/src/db/mysql/parameters.ts
+/**
+* Parameters the MySQL connection resolves itself just before a statement runs (ADR 0001, "MySQL").
+* They let a `db/` primitive keep its single-expression contract where MySQL needs a statement of its own.
+*/
+/** The next value of a sequence: allocated from an AUTO_INCREMENT table (no lock held to commit). */
+var SequenceValue = class {
+	name;
+	constructor(name) {
+		this.name = name;
+	}
+};
+/**
+* A notification's channel. The statement that binds it inserts the notification; the connection also
+* publishes it to listeners in this process once the transaction commits (or at once outside one).
+*/
+var NotificationChannel = class {
+	channel;
+	payload;
+	constructor(channel, payload) {
+		this.channel = channel;
+		this.payload = payload;
+	}
+};
+/** The table that backs a sequence. */
+const sequenceTableOf = (name) => `sequence_${name}`;
+//#endregion
+//#region ../../apps/api/src/db/mysql/driver.ts
+/**
+* Shapio's MySQL driver (ADR 0001, "MySQL") on mysql2's pool. Beyond Kysely's own MySQL driver it:
+* - sets every session up like PostgreSQL behaves: UTC, READ COMMITTED, strict SQL mode, utf8mb4 with the
+*   binary `utf8mb4_0900_bin` collation, a large `group_concat_max_len` (JSON aggregates);
+* - pins `NOW()` and `CURRENT_TIMESTAMP` defaults to the transaction's start (`SET timestamp`), as
+*   PostgreSQL's `now()` is;
+* - runs statement plans (`plans.ts`) atomically: inside a transaction under a savepoint, otherwise in a
+*   transaction of their own;
+* - resolves sequence values and notification channels bound as parameters (`parameters.ts`), and publishes
+*   notifications to listeners in this process once their transaction commits;
+* - names the constraint of a constraint error (`errors.ts`).
+*/
+const SESSION_SETUP = "set names utf8mb4 collate utf8mb4_0900_bin, time_zone = '+00:00', transaction_isolation = 'READ-COMMITTED', sql_mode = 'STRICT_TRANS_TABLES,NO_ZERO_IN_DATE,NO_ZERO_DATE,ERROR_FOR_DIVISION_BY_ZERO,ONLY_FULL_GROUP_BY,NO_ENGINE_SUBSTITUTION', group_concat_max_len = 1073741824";
+const PIN_TIMESTAMP = "set timestamp = unix_timestamp(sysdate(6))";
+const UNPIN_TIMESTAMP = "set timestamp = default";
+/** `host:port/database` of a mysql: URL: the key listeners in this process share. */
+const mysqlDatabaseKey = (url) => {
+	const parsed = new URL(url);
+	return `mysql:${parsed.hostname}:${parsed.port || "3306"}${parsed.pathname}`;
+};
+const mysqlPoolOptions = (url, poolMax, applicationName = "shapio") => ({
+	uri: url,
+	connectAttributes: { program_name: applicationName },
+	connectionLimit: poolMax,
+	charset: "UTF8MB4_GENERAL_CI",
+	timezone: "Z",
+	supportBigNumbers: true,
+	bigNumberStrings: true,
+	decimalNumbers: false,
+	typeCast,
+	multipleStatements: false
+});
+const isResultHeader = (result) => !Array.isArray(result) && typeof result === "object" && "affectedRows" in result;
+var MysqlConnection = class {
+	#connection;
+	#databaseKey;
+	#inTransaction = false;
+	#savepoints = 0;
+	#pending = [];
+	constructor(connection, databaseKey) {
+		this.#connection = connection;
+		this.#databaseKey = databaseKey;
+	}
+	get inTransaction() {
+		return this.#inTransaction;
+	}
+	release() {
+		this.#connection.release();
+	}
+	#query(sql, parameters = []) {
+		return new Promise((resolve, reject) => {
+			this.#connection.query(sql, parameters, (error, result) => {
+				if (error) reject(annotateMysqlError(error));
+				else resolve(result);
+			});
+		});
+	}
+	/** Runs a raw control statement (transactions, savepoints, session settings). */
+	async control(sql) {
+		await this.#query(sql);
+	}
+	async begin(settings) {
+		const statements = [];
+		if (settings.isolationLevel || settings.accessMode) {
+			const parts = [...settings.isolationLevel ? [`isolation level ${settings.isolationLevel}`] : [], ...settings.accessMode ? [settings.accessMode] : []];
+			statements.push(`set transaction ${parts.join(", ")}`);
+		}
+		statements.push(PIN_TIMESTAMP, "begin");
+		await Promise.all(statements.map((statement) => this.#query(statement)));
+		this.#inTransaction = true;
+		this.#pending = [];
+	}
+	async end(command) {
+		const pending = this.#pending;
+		this.#pending = [];
+		this.#inTransaction = false;
+		await Promise.all([this.#query(command), this.#query(UNPIN_TIMESTAMP)]);
+		if (command === "commit") outsideConnectionScope(() => {
+			for (const { channel, payload, id } of pending) publishNotification(this.#databaseKey, channel, payload, id);
+		});
+	}
+	async #nextSequenceValue(name) {
+		const table = sequenceTableOf(name);
+		const inserted = await this.#query(`insert into \`${table}\` () values ()`);
+		const value = isResultHeader(inserted) ? String(inserted.insertId) : void 0;
+		if (value === void 0) throw new Error(`No value from sequence ${name}`);
+		await this.#query(`delete from \`${table}\` where \`value\` = ?`, [value]);
+		return value;
+	}
+	/** Encodes parameters, allocating sequence values and noting notifications. */
+	async #parametersOf(parameters) {
+		const values = [];
+		const notifications = [];
+		for (const [index, parameter] of parameters.entries()) if (parameter instanceof SequenceValue) values.push(await this.#nextSequenceValue(parameter.name));
+		else if (parameter instanceof NotificationChannel) {
+			notifications.push({
+				channel: parameter.channel,
+				payload: parameter.payload
+			});
+			values.push(parameter.channel);
+		} else values.push(encodeParameter$1(parameter, index));
+		return {
+			values,
+			notifications
+		};
+	}
+	async #execute(query) {
+		const { values, notifications } = await this.#parametersOf(query.parameters);
+		const result = await this.#query(query.sql, values);
+		if (notifications.length > 0) {
+			const id = isResultHeader(result) && result.insertId ? String(result.insertId) : void 0;
+			const published = notifications.map((notification) => ({
+				...notification,
+				id
+			}));
+			if (this.#inTransaction) this.#pending.push(...published);
+			else for (const notification of published) publishNotification(this.#databaseKey, notification.channel, notification.payload, notification.id);
+		}
+		if (!isResultHeader(result)) return { rows: Array.isArray(result) ? result : [] };
+		return {
+			rows: [],
+			numAffectedRows: BigInt(result.affectedRows),
+			...result.insertId ? { insertId: BigInt(result.insertId) } : {}
+		};
+	}
+	#planContext = {
+		run: (query) => this.#execute(query),
+		atomically: async (fn) => {
+			if (this.#inTransaction) return this.#planContext.savepoint(fn);
+			await this.begin({});
+			try {
+				const result = await fn();
+				await this.end("commit");
+				return result;
+			} catch (error) {
+				await this.end("rollback");
+				throw error;
+			}
+		},
+		savepoint: async (fn) => {
+			const name = `shapio_plan_${this.#savepoints += 1}`;
+			await this.#query(`savepoint ${name}`);
+			try {
+				const result = await fn();
+				await this.#query(`release savepoint ${name}`);
+				return result;
+			} catch (error) {
+				await this.#query(`rollback to savepoint ${name}`);
+				throw error;
+			}
+		}
+	};
+	async executeQuery(query) {
+		const plan = planOf(query);
+		return plan ? await plan(this.#planContext) : await this.#execute(query);
+	}
+	async *streamQuery() {
+		throw new Error("Streaming queries are not supported on MySQL");
+	}
+};
+var MysqlDriver = class {
+	#options;
+	databaseKey;
+	get strict() {
+		return this.#options.strict ?? false;
+	}
+	#pool;
+	#connections = /* @__PURE__ */ new WeakMap();
+	constructor(options) {
+		this.#options = options;
+		this.databaseKey = mysqlDatabaseKey(options.url);
+	}
+	async init() {
+		const pool = (await loadMysql()).createPool(mysqlPoolOptions(this.#options.url, this.#options.poolMax, this.#options.applicationName));
+		pool.on("connection", (connection) => {
+			connection.query(SESSION_SETUP, (error) => {
+				if (error) {
+					this.#options.onIdleConnectionError?.(error);
+					connection.destroy();
+				}
+			});
+			connection.on("error", (error) => this.#options.onIdleConnectionError?.(error));
+		});
+		this.#pool = pool;
+	}
+	#pooled() {
+		if (!this.#pool) throw new Error("The MySQL driver is not initialised");
+		return this.#pool;
+	}
+	/**
+	* A pooled connection, or `PoolAcquireTimeoutError` once `acquireTimeoutMs` passes. mysql2 cannot withdraw
+	* a queued request, so a connection that arrives after the timeout goes straight back to the pool.
+	*/
+	#getConnection() {
+		const { acquireTimeoutMs = DEFAULT_POOL_ACQUIRE_TIMEOUT_MS, poolMax } = this.#options;
+		return new Promise((resolve, reject) => {
+			let timedOut = false;
+			const timer = setTimeout(() => {
+				timedOut = true;
+				reject(new PoolAcquireTimeoutError(acquireTimeoutMs, poolMax));
+			}, acquireTimeoutMs);
+			this.#pooled().getConnection((error, connection) => {
+				clearTimeout(timer);
+				if (timedOut) connection?.release();
+				else if (error) reject(error);
+				else resolve(connection);
+			});
+		});
+	}
+	async acquireConnection() {
+		if (this.#options.strict) assertNotNested();
+		const raw = await this.#getConnection();
+		let connection = this.#connections.get(raw);
+		if (!connection) {
+			connection = new MysqlConnection(raw, this.databaseKey);
+			this.#connections.set(raw, connection);
+		}
+		return connection;
+	}
+	async beginTransaction(connection, settings) {
+		await connection.begin(settings);
+	}
+	async commitTransaction(connection) {
+		await connection.end("commit");
+	}
+	async rollbackTransaction(connection) {
+		await connection.end("rollback");
+	}
+	async savepoint(connection, name) {
+		await connection.control(`savepoint \`${name}\``);
+	}
+	async rollbackToSavepoint(connection, name) {
+		await connection.control(`rollback to savepoint \`${name}\``);
+	}
+	async releaseSavepoint(connection, name) {
+		await connection.control(`release savepoint \`${name}\``);
+	}
+	async releaseConnection(connection) {
+		connection.release();
+	}
+	async destroy() {
+		const pool = this.#pool;
+		this.#pool = void 0;
+		if (pool) await new Promise((resolve, reject) => pool.end((error) => error ? reject(error) : resolve()));
+	}
+};
+//#endregion
+//#region ../../apps/api/src/db/sql/markers.ts
+/**
+* Result-type markers of a query's output columns (`typed.ts`), for drivers whose database does not report
+* the type of a computed column (SQLite) or reports one PostgreSQL would not (MySQL computes comparisons as
+* integers). Shared by the SQLite and MySQL plugins.
+*/
+const selectionsOf = (node) => {
+	switch (node.kind) {
+		case "SelectQueryNode": return node.selections;
+		case "InsertQueryNode":
+		case "UpdateQueryNode":
+		case "DeleteQueryNode": return node.returning?.selections;
+		default: return;
+	}
+};
+/** Functions whose result has the type of their (marked) arguments. */
+const TYPE_PRESERVING_FUNCTIONS = /* @__PURE__ */ new Set([
+	"coalesce",
+	"max",
+	"min",
+	"ifnull"
+]);
+/** Aggregates PostgreSQL returns as bigint/numeric, which its driver reads as decimal strings. */
+const BIGINT_AGGREGATES = /* @__PURE__ */ new Set(["count", "sum"]);
+/**
+* The marker of an expression: its own, or one it inherits through `coalesce`/`max`/`min`, parentheses
+* and scalar subqueries (`coalesce((select asJson(…) …), emptyArray())` needs no second marker).
+* `count` and `sum` read as decimal strings, like PostgreSQL's bigint and numeric.
+*/
+const markerOf = (node) => {
+	if (!node) return;
+	const own = markedResultType(node);
+	if (own) return own;
+	switch (node.kind) {
+		case "AliasNode": return markerOf(node.node);
+		case "ParensNode": return markerOf(node.node);
+		case "SelectionNode": return markerOf(node.selection);
+		case "SelectQueryNode": {
+			const selections = node.selections;
+			return selections?.length === 1 ? markerOf(selections[0]) : void 0;
+		}
+		case "AggregateFunctionNode":
+		case "FunctionNode": {
+			const call = node;
+			if (node.kind === "AggregateFunctionNode" && BIGINT_AGGREGATES.has(String(call.func).toLowerCase())) return "bigint";
+			if (!TYPE_PRESERVING_FUNCTIONS.has(String(call.func).toLowerCase())) return;
+			for (const argument of call.aggregated ?? call.arguments ?? []) {
+				const marker = markerOf(argument);
+				if (marker) return marker;
+			}
+			return;
+		}
+		default: return;
+	}
+};
+/** Output column name → marker, for top-level selections that are (or inherit) marked expressions. */
+const collectMarkers = (node) => {
+	let markers;
+	for (const selection of selectionsOf(node) ?? []) {
+		const aliased = selection.selection;
+		if (!AliasNode.is(aliased) || !IdentifierNode.is(aliased.alias)) continue;
+		const type = markerOf(aliased.node);
+		if (type) {
+			markers ??= /* @__PURE__ */ new Map();
+			markers.set(aliased.alias.name, type);
+		}
+	}
+	return markers;
+};
+//#endregion
+//#region ../../apps/api/src/db/mysql/insertValues.ts
+/**
+* Values MySQL needs written differently (ADR 0001, "MySQL"): columns PostgreSQL defaults that MySQL cannot
+* (UUIDs generated here, so a planned RETURNING knows the key; the change sequence), and ISO-8601 text bound
+* to timestamp columns.
+*/
+const ISO_TIMESTAMP = /^\d{4}-\d{2}-\d{2}[T ]\d{2}:\d{2}/;
+/**
+* Text bound to a timestamp column, as UTC `DATETIME` text: PostgreSQL reads ISO-8601 with a zone
+* (`…T…Z`, `+02:00`); MySQL would reject it or ignore the zone.
+*/
+const timestampText = (value) => typeof value === "string" && ISO_TIMESTAMP.test(value) ? toDatetimeText(value) : value;
+const isTimestampColumn = (table, column) => table !== void 0 && (tableInfo(table)?.timestamps ?? []).includes(column);
+/** A value node (or primitive list) bound to a timestamp column, with ISO text normalised. */
+const timestampValue = (node) => {
+	if (ValueNode.is(node)) {
+		const value = timestampText(node.value);
+		return value === node.value ? node : ValueNode.create(value);
+	}
+	if (PrimitiveValueListNode.is(node)) return PrimitiveValueListNode.create(node.values.map(timestampText));
+	return node;
+};
+/** Insert rows with ISO text for timestamp columns normalised. */
+const withTimestampValues = (node) => {
+	const table = node.into?.table.identifier.name;
+	const positions = (node.columns?.map((column) => column.column.name) ?? []).flatMap((column, index) => isTimestampColumn(table, column) ? [index] : []);
+	if (positions.length === 0 || !node.values || !ValuesNode.is(node.values)) return node;
+	const rows = node.values.values.map((row) => PrimitiveValueListNode.is(row) ? PrimitiveValueListNode.create(row.values.map((value, index) => positions.includes(index) ? timestampText(value) : value)) : ValueListNode.create(row.values.map((value, index) => positions.includes(index) ? timestampValue(value) : value)));
+	return Object.freeze({
+		...node,
+		values: ValuesNode.create(rows)
+	});
+};
+/** A fresh value for a column PostgreSQL defaults. */
+const generatedValue = (kind) => kind === "uuid" ? randomUUID() : new SequenceValue(kind);
+/** The insert with every generated column the statement leaves out filled in. */
+const withGeneratedColumns = (node, info) => {
+	const generated = Object.entries(info.generated ?? {});
+	const columns = node.columns?.map((column) => column.column.name) ?? [];
+	const missing = generated.filter(([column]) => !columns.includes(column));
+	if (missing.length === 0 || !node.values || !ValuesNode.is(node.values) || !node.columns) return node;
+	const rows = node.values.values.map((row) => {
+		const extra = missing.map(([, kind]) => generatedValue(kind));
+		return PrimitiveValueListNode.is(row) ? PrimitiveValueListNode.create([...row.values, ...extra]) : ValueListNode.create([...row.values, ...extra.map((value) => ValueNode.create(value))]);
+	});
+	return Object.freeze({
+		...node,
+		columns: [...node.columns, ...missing.map(([column]) => ColumnNode.create(column))],
+		values: ValuesNode.create(rows)
+	});
+};
+//#endregion
+//#region ../../apps/api/src/db/mysql/nullOrdering.ts
+/**
+* PostgreSQL's NULL placement on MySQL (ADR 0001, "MySQL"): PostgreSQL sorts NULLs last ascending and first
+* descending, MySQL the reverse. An ORDER BY item that may be NULL gets an `(expr is null)` item before it;
+* a NOT NULL column of a table in scope (`tables.ts`) does not, so index-ordered scans stay possible.
+*/
+/** `asc`/`desc` from an order item's direction node. */
+const directionOf$1 = (node) => {
+	const direction = node.direction;
+	if (direction && RawNode.is(direction)) return direction.sqlFragments.join("").trim().toLowerCase() === "desc" ? "desc" : "asc";
+	return "asc";
+};
+const addToScope = (scope, node, outer) => {
+	if (AliasNode.is(node) && IdentifierNode.is(node.alias)) {
+		const table = tableNameOf$1(node.node);
+		if (table) scope.set(node.alias.name, {
+			table,
+			outer
+		});
+		return;
+	}
+	const table = tableNameOf$1(node);
+	if (table) scope.set(table, {
+		table,
+		outer
+	});
+};
+const scopeOf = (from, joins, extra) => {
+	const scope = /* @__PURE__ */ new Map();
+	for (const item of from?.froms ?? []) addToScope(scope, item, false);
+	for (const join of joins ?? []) addToScope(scope, join.table, join.joinType !== "InnerJoin");
+	if (extra) scope.set(extra, {
+		table: extra,
+		outer: false
+	});
+	return scope;
+};
+/** Whether an ORDER BY expression can never be NULL (a NOT NULL column of a table in scope). */
+const neverNull = (node, scope) => {
+	if (!ReferenceNode.is(node) || !ColumnNode.is(node.column)) return false;
+	const column = node.column.column.name;
+	const qualifier = node.table?.table.identifier.name;
+	const candidates = qualifier ? [scope.get(qualifier)].filter((entry) => entry !== void 0) : [...scope.values()].filter((entry) => tableInfo(entry.table)?.columns.includes(column));
+	if (candidates.length !== 1) return false;
+	const entry = candidates[0];
+	const info = tableInfo(entry.table);
+	return !entry.outer && info !== void 0 && info.columns.includes(column) && !info.nullable.includes(column);
+};
+const isNull = (expression) => ParensNode.create(BinaryOperationNode.create(expression, OperatorNode.create("is"), ValueNode.createImmediate(null)));
+const withDirection = (node, direction) => OrderByItemNode.create(node, RawNode.createWithSql(direction));
+/** True when a raw ORDER BY item already spells its own direction (the content compiler's SQL). */
+const spellsDirection = (node) => RawNode.is(node.orderBy) && /\b(asc|desc)\b/i.test(node.orderBy.sqlFragments.join(" "));
+/** PostgreSQL's NULL placement for one ORDER BY item, as MySQL items. */
+const orderItems = (item, scope) => {
+	if (spellsDirection(item)) return [item];
+	const direction = directionOf$1(item);
+	const nullsLast = item.nulls ? item.nulls === "last" : direction === "asc";
+	const mysqlNullsLast = direction === "desc";
+	const plain = Object.freeze({
+		...item,
+		nulls: void 0
+	});
+	if (nullsLast === mysqlNullsLast || neverNull(item.orderBy, scope)) return [plain];
+	return [withDirection(isNull(item.orderBy), nullsLast ? "asc" : "desc"), plain];
+};
+//#endregion
+//#region ../../apps/api/src/db/mysql/resultDecoding.ts
+/** A marked column's value as PostgreSQL's driver would give it (`db/sql/typed.ts`). */
+const DECODERS = {
+	boolean: (value) => Number(value) !== 0,
+	bigint: (value) => String(value),
+	json: (value) => typeof value === "string" ? JSON.parse(value) : value,
+	timestamp: (value) => value instanceof Date ? value : /* @__PURE__ */ new Date(`${String(value).replace(" ", "T")}Z`),
+	text: (value) => String(value)
+};
+const decodeRow = (row, markers) => {
+	const decoded = { ...row };
+	for (const [column, type] of markers) {
+		const value = decoded[column];
+		if (value !== null && value !== void 0) decoded[column] = DECODERS[type](value);
+	}
+	return decoded;
+};
+//#endregion
+//#region ../../apps/api/src/db/mysql/plugin.ts
+/**
+* Adapts Kysely queries written for PostgreSQL to MySQL (dialect boundary, ADR 0001, "MySQL"). Rewrites that
+* stay one statement happen here; statements MySQL cannot run as one (`RETURNING`, most `ON CONFLICT`) are
+* planned by the compiler (`plans.ts`). This plugin:
+* - fills the columns PostgreSQL defaults that MySQL cannot, and normalises ISO text bound to timestamp
+*   columns (`insertValues.ts`);
+* - spells casts MySQL's way (`text` → `char`, `bigint`/`integer` → `signed`) and maps row locks MySQL lacks;
+* - keeps PostgreSQL's NULL placement in ORDER BY (`nullOrdering.ts`);
+* - turns `ON CONFLICT` into `ON DUPLICATE KEY UPDATE` where that means the same (`conflicts.ts`);
+* - rewrites the subquery shapes MySQL rejects and `UPDATE … FROM` (`subqueries.ts`);
+* - decodes result columns marked with `db/sql/typed.ts` (MySQL computes comparisons as integers).
+*/
+const CAST_TYPES = {
+	text: "char",
+	uuid: "char(36)",
+	integer: "signed",
+	bigint: "signed",
+	int4: "signed",
+	int8: "signed",
+	numeric: "decimal(65,30)"
+};
+const ROW_LOCKS$1 = {
+	ForNoKeyUpdate: "ForUpdate",
+	ForKeyShare: "ForShare"
+};
+const emptyScope = () => /* @__PURE__ */ new Map();
+var MysqlTransformer = class extends OperationNodeTransformer {
+	#scopes = [];
+	transformSelectQuery(node, queryId) {
+		this.#scopes.push(scopeOf(node.from, node.joins));
+		try {
+			const transformed = super.transformSelectQuery(node, queryId);
+			const where = wrapSubqueries(transformed.where, void 0);
+			return where === transformed.where ? transformed : Object.freeze({
+				...transformed,
+				where
+			});
+		} finally {
+			this.#scopes.pop();
+		}
+	}
+	transformUpdateQuery(node, queryId) {
+		const table = tableNameOf$1(node.table && AliasNode.is(node.table) ? node.table.node : node.table);
+		this.#scopes.push(scopeOf(node.from, node.joins, table));
+		try {
+			const transformed = super.transformUpdateQuery(node, queryId);
+			const multiTable = withFromAsTables(transformed);
+			const updates = multiTable.updates?.map((update) => ColumnNode.is(update.column) && isTimestampColumn(table, update.column.column.name) ? Object.freeze({
+				...update,
+				value: timestampValue(update.value)
+			}) : update);
+			return Object.freeze({
+				...multiTable,
+				updates,
+				where: wrapSubqueries(multiTable.where, table)
+			});
+		} finally {
+			this.#scopes.pop();
+		}
+	}
+	transformDeleteQuery(node, queryId) {
+		const table = tableNameOf$1(node.from.froms[0]);
+		this.#scopes.push(scopeOf(node.from, node.joins));
+		try {
+			const transformed = super.transformDeleteQuery(node, queryId);
+			return Object.freeze({
+				...transformed,
+				where: wrapSubqueries(transformed.where, table)
+			});
+		} finally {
+			this.#scopes.pop();
+		}
+	}
+	transformInsertQuery(node, queryId) {
+		const transformed = withTimestampValues(withDerivedValueSubqueries(super.transformInsertQuery(node, queryId)));
+		const table = transformed.into?.table.identifier.name;
+		const info = table === void 0 ? void 0 : tableInfo(table);
+		let result = transformed;
+		if (table && transformed.onConflict) result = toOnDuplicateKey(result, transformed.onConflict, table);
+		return info ? withGeneratedColumns(result, info) : result;
+	}
+	transformOrderBy(node, queryId) {
+		const transformed = super.transformOrderBy(node, queryId);
+		const scope = this.#scopes.at(-1) ?? emptyScope();
+		return Object.freeze({
+			...transformed,
+			items: transformed.items.flatMap((item) => orderItems(item, scope))
+		});
+	}
+	/** `timestamp_column <op> 'ISO text'`: the text as UTC DATETIME text. */
+	transformBinaryOperation(node, queryId) {
+		const transformed = super.transformBinaryOperation(node, queryId);
+		const left = transformed.leftOperand;
+		if (!ReferenceNode.is(left) || !ColumnNode.is(left.column)) return transformed;
+		const column = left.column.column.name;
+		const scope = this.#scopes.at(-1) ?? emptyScope();
+		const qualifier = left.table?.table.identifier.name;
+		const tables = qualifier ? [scope.get(qualifier)?.table] : [...scope.values()].map((entry) => entry.table).filter((table) => tableInfo(table)?.columns.includes(column));
+		if (tables.length !== 1 || !isTimestampColumn(tables[0], column)) return transformed;
+		const right = timestampValue(transformed.rightOperand);
+		return right === transformed.rightOperand ? transformed : Object.freeze({
+			...transformed,
+			rightOperand: right
+		});
+	}
+	transformCast(node, queryId) {
+		const transformed = super.transformCast(node, queryId);
+		const dataType = transformed.dataType;
+		const mapped = dataType.kind === "DataTypeNode" ? CAST_TYPES[String(dataType.dataType)] : void 0;
+		return mapped ? Object.freeze({
+			...transformed,
+			dataType: RawNode.createWithSql(mapped)
+		}) : transformed;
+	}
+	transformSelectModifier(node, queryId) {
+		const transformed = super.transformSelectModifier(node, queryId);
+		const mapped = transformed.modifier ? ROW_LOCKS$1[transformed.modifier] : void 0;
+		return mapped ? Object.freeze({
+			...transformed,
+			modifier: mapped
+		}) : transformed;
+	}
+};
+var MysqlPlugin = class {
+	#markers = /* @__PURE__ */ new WeakMap();
+	transformQuery({ node, queryId }) {
+		const markers = collectMarkers(node);
+		if (markers) this.#markers.set(queryId, markers);
+		return new MysqlTransformer().transformNode(node, queryId);
+	}
+	/** Decodes columns marked with a result type (MySQL computes `a is not null` as an integer). */
+	async transformResult({ result, queryId }) {
+		const markers = this.#markers.get(queryId);
+		if (!markers || result.rows.length === 0) return result;
+		return {
+			...result,
+			rows: result.rows.map((row) => decodeRow(row, markers))
+		};
+	}
+};
+//#endregion
+//#region ../../apps/api/src/db/mysql/index.ts
+/**
+* Kysely on MySQL 8.4 (ADR 0001, "MySQL"). RETURNING is emulated by statement plans. Migration locking is Shapio's own session lock
+* (`db/migrator.ts`), scoped to the database, so Kysely's server-wide `GET_LOCK` name is not taken.
+*/
+var ShapioMysqlAdapter = class extends MysqlAdapter {
+	/** Statement plans give MySQL RETURNING (`plans.ts`), so builders return the rows. */
+	get supportsReturning() {
+		return true;
+	}
+	async acquireMigrationLock() {}
+	async releaseMigrationLock() {}
+};
+var ShapioMysqlDialect = class {
+	driver;
+	constructor(driver) {
+		this.driver = driver;
+	}
+	createAdapter() {
+		return new ShapioMysqlAdapter();
+	}
+	createDriver() {
+		return this.driver;
+	}
+	createIntrospector(db) {
+		return new MysqlIntrospector(db);
+	}
+	createQueryCompiler() {
+		return new ShapioMysqlQueryCompiler();
+	}
+};
+/** A Kysely handle on MySQL; the driver is reachable for the database key listeners share. */
+var MysqlKysely = class extends Kysely {
+	mysqlDriver;
+	constructor(driver) {
+		super({
+			dialect: new ShapioMysqlDialect(driver),
+			plugins: [new MysqlPlugin()]
+		});
+		this.mysqlDriver = driver;
+	}
+	/** Strict mode runs transactions in a connection scope (`db/connectionScope.ts`). */
+	transaction() {
+		const builder = super.transaction();
+		return this.mysqlDriver.strict ? withConnectionScope(builder) : builder;
+	}
+};
+const createMysqlDb = (options) => new MysqlKysely(new MysqlDriver(options));
+/** The MySQL driver behind a handle, or undefined for another dialect. */
+const mysqlDriverOf = (db) => db instanceof MysqlKysely ? db.mysqlDriver : void 0;
+//#endregion
+//#region ../../apps/api/src/db/sqlite/codec.ts
+/**
+* The SQLite value codec (ADR 0001, "Dialect boundary"). SQLite has five storage classes, so Shapio's
+* PostgreSQL types are declared with names that keep both the storage affinity right (`text_*` → TEXT,
+* `integer_*`/`bigint` → INTEGER) and the original type readable; the driver decodes every result column by
+* its declared type (`StatementSync.columns()` reports it even through subqueries, CTEs and RETURNING), so
+* rows have the same JavaScript shape as on PostgreSQL:
+*
+* | PostgreSQL     | declared            | stored                          | read as            |
+* | -------------- | ------------------- | ------------------------------- | ------------------ |
+* | timestamptz    | text_timestamptz    | `YYYY-MM-DDTHH:MM:SS.sssZ`      | Date               |
+* | date           | text_date           | `YYYY-MM-DD`                    | string             |
+* | jsonb / json   | text_jsonb / _json  | JSON text                       | parsed value       |
+* | text[] / uuid[]| text_array / _uuid_array | JSON array text            | string[]           |
+* | uuid           | text_uuid           | lowercase text                  | string             |
+* | boolean        | integer_boolean     | 0 / 1                           | boolean            |
+* | bigint         | bigint              | integer                         | decimal string     |
+* | integer        | integer             | integer                         | number             |
+* | real / double  | real / double       | real                            | number             |
+*/
+const DECLARED_TYPES = {
+	timestamptz: "text_timestamptz",
+	date: "text_date",
+	jsonb: "text_jsonb",
+	json: "text_json",
+	textArray: "text_array",
+	uuidArray: "text_uuid_array",
+	uuid: "text_uuid",
+	boolean: "integer_boolean",
+	bigint: "bigint",
+	integer: "integer",
+	real: "real",
+	double: "double",
+	text: "text"
+};
+/**
+* `bigint` identity primary keys. SQLite only makes a column its auto-incrementing row ID when it is
+* declared exactly `INTEGER PRIMARY KEY`, so these read back as strings by name instead of by type.
+*/
+const BIGINT_ROWID_COLUMNS = /* @__PURE__ */ new Set(["outbox_events.id", "publication_log.id"]);
+/** A parameter that cannot be stored; never silently written as NULL. */
+var SqliteBindError = class extends TypeError {
+	constructor(index, value) {
+		const kind = value === void 0 ? "undefined" : value?.constructor?.name ?? typeof value;
+		super(`Cannot bind ${kind} to SQLite parameter ${index + 1}`);
+		this.name = "SqliteBindError";
+	}
+};
+const isPlainObject = (value) => {
+	const prototype = Object.getPrototypeOf(value);
+	return prototype === Object.prototype || prototype === null;
+};
+/** A JavaScript value as SQLite stores it (see the table above). Throws on values with no column type. */
+const encodeParameter = (value, index) => {
+	switch (typeof value) {
+		case "string":
+		case "number":
+		case "bigint": return value;
+		case "boolean": return value ? 1 : 0;
+		case "object":
+			if (value === null) return null;
+			if (value instanceof Date) return toStoredTimestamp(value);
+			if (value instanceof Uint8Array) return value;
+			if (Array.isArray(value) || isPlainObject(value)) return JSON.stringify(value);
+			throw new SqliteBindError(index, value);
+		default: throw new SqliteBindError(index, value);
+	}
+};
+const toNumber = (value) => typeof value === "bigint" ? Number(value) : value;
+const toDecimalString = (value) => typeof value === "bigint" || typeof value === "number" ? String(value) : value;
+const toDate = (value) => typeof value === "string" ? new Date(value) : value;
+const toBoolean = (value) => value === null ? null : Number(value) !== 0;
+const parseJson = (value) => typeof value === "string" ? JSON.parse(value) : value;
+const passText = (value) => typeof value === "bigint" ? String(value) : value;
+/** Integers arrive as bigint (`setReadBigInts`); an untyped one is a number when it fits, else a string. */
+const untyped = (value) => {
+	if (typeof value !== "bigint") return value;
+	return value >= BigInt(Number.MIN_SAFE_INTEGER) && value <= BigInt(Number.MAX_SAFE_INTEGER) ? Number(value) : String(value);
+};
+const BY_DECLARED_TYPE = {
+	[DECLARED_TYPES.timestamptz]: toDate,
+	[DECLARED_TYPES.date]: passText,
+	[DECLARED_TYPES.jsonb]: parseJson,
+	[DECLARED_TYPES.json]: parseJson,
+	[DECLARED_TYPES.textArray]: parseJson,
+	[DECLARED_TYPES.uuidArray]: parseJson,
+	[DECLARED_TYPES.uuid]: passText,
+	[DECLARED_TYPES.boolean]: toBoolean,
+	[DECLARED_TYPES.bigint]: toDecimalString,
+	[DECLARED_TYPES.integer]: toNumber,
+	[DECLARED_TYPES.real]: toNumber,
+	[DECLARED_TYPES.double]: toNumber,
+	[DECLARED_TYPES.text]: passText
+};
+const BY_MARKER = {
+	json: parseJson,
+	timestamp: toDate,
+	boolean: toBoolean,
+	bigint: toDecimalString,
+	text: passText
+};
+/** The decoder of one result column: a marker wins, then the origin column, then the declared type. */
+const decoderFor = (metadata, marker) => {
+	if (marker) return BY_MARKER[marker];
+	if (metadata.table !== null && BIGINT_ROWID_COLUMNS.has(`${metadata.table}.${metadata.column ?? ""}`)) return toDecimalString;
+	const declared = metadata.type?.toLowerCase();
+	return (declared === void 0 ? void 0 : BY_DECLARED_TYPE[declared]) ?? untyped;
+};
+const STORED_TIMESTAMP = /^\d{4}-\d\d-\d\dT\d\d:\d\d:\d\d\.\d{3}Z$/;
+/**
+* Strict mode (tests): an unmarked computed column whose text looks like a stored timestamp or a JSON
+* document was almost certainly meant to be decoded; fail loudly so the query gets a `db/sql/typed` marker.
+*/
+const assertNotUndecoded = (name, value) => {
+	if (typeof value !== "string") return;
+	if (STORED_TIMESTAMP.test(value)) throw new Error(`SQLite result column "${name}" is a computed timestamp without a type marker; wrap it in asTimestamp() (db/sql/typed.ts)`);
+	const first = value[0];
+	if (first === "{" || first === "[") {
+		try {
+			JSON.parse(value);
+		} catch {
+			return;
+		}
+		throw new Error(`SQLite result column "${name}" is computed JSON without a type marker; wrap it in asJson() (db/sql/typed.ts)`);
+	}
+};
+//#endregion
+//#region ../../apps/api/src/db/sqlite/errors.ts
+/**
+* SQLite errors in the shape `db/sql/errors.ts` classifies: `code` is the extended result code's name and,
+* like PostgreSQL's error fields, `constraint` names the violated unique index and `table` the table a
+* failed foreign-key write targeted (SQLite reports no constraint name for foreign keys).
+*/
+var SqliteDatabaseError = class extends Error {
+	code;
+	errcode;
+	constraint;
+	table;
+	/** The failed statement's SQL (values are bound separately and never included). */
+	sql;
+	constructor(message, fields, options) {
+		super(message, options);
+		this.name = "SqliteDatabaseError";
+		this.code = fields.code;
+		this.errcode = fields.errcode;
+		this.constraint = fields.constraint;
+		this.table = fields.table;
+		this.sql = fields.sql;
+	}
+};
+/** Extended result codes Shapio distinguishes (sqlite.org/rescode.html). */
+const CODE_NAMES = {
+	5: "SQLITE_BUSY",
+	19: "SQLITE_CONSTRAINT",
+	275: "SQLITE_CONSTRAINT_CHECK",
+	787: "SQLITE_CONSTRAINT_FOREIGNKEY",
+	1299: "SQLITE_CONSTRAINT_NOTNULL",
+	1555: "SQLITE_CONSTRAINT_PRIMARYKEY",
+	1811: "SQLITE_CONSTRAINT_TRIGGER",
+	2067: "SQLITE_CONSTRAINT_UNIQUE"
+};
+const NAMED_INDEX = /UNIQUE constraint failed: index '([^']+)'/;
+const COLUMN_LIST = /(?:UNIQUE) constraint failed: (.+)$/;
+/** The unique index on exactly `columns` of `table` (PostgreSQL names the primary key `<table>_pkey`). */
+const uniqueIndexOn = (database, table, columns) => {
+	const indexes = database.prepare(`select name, origin from pragma_index_list(?) where "unique" = 1`).all(table);
+	for (const index of indexes) {
+		const indexColumns = database.prepare("select name from pragma_index_info(?) order by seqno").all(index.name).map((row) => row.name);
+		if (indexColumns.length === columns.length && indexColumns.every((name, at) => name === columns[at])) return index.origin === "pk" ? `${table}_pkey` : index.name;
+	}
+};
+/** `t.a, t.b` → table `t`, columns `[a, b]`. */
+const parseColumnList = (list) => {
+	const parts = list.split(",").map((part) => part.trim().split("."));
+	const table = parts[0]?.[0];
+	if (!table || parts.some((part) => part.length !== 2 || part[0] !== table)) return;
+	return {
+		table,
+		columns: parts.map((part) => part[1] ?? "")
+	};
+};
+const uniqueConstraintOf = (database, message) => {
+	const named = NAMED_INDEX.exec(message);
+	if (named) return named[1];
+	const list = COLUMN_LIST.exec(message)?.[1];
+	const parsed = list === void 0 ? void 0 : parseColumnList(list);
+	return parsed && uniqueIndexOn(database, parsed.table, parsed.columns);
+};
+/**
+* Wraps a `node:sqlite` error with the constraint details services ask about. `writtenTable` is the table an
+* INSERT or UPDATE targeted (attached to foreign-key failures). Other errors pass through unchanged.
+*/
+const translateSqliteError = (error, database, writtenTable, statement) => {
+	const errcode = error?.errcode;
+	if (!(error instanceof Error) || typeof errcode !== "number") return error;
+	const code = CODE_NAMES[errcode] ?? `SQLITE_${errcode}`;
+	const fields = {
+		code,
+		errcode,
+		...statement === void 0 ? {} : { sql: statement }
+	};
+	if (code === "SQLITE_CONSTRAINT_UNIQUE" || code === "SQLITE_CONSTRAINT_PRIMARYKEY") {
+		const constraint = uniqueConstraintOf(database, error.message);
+		if (constraint) fields.constraint = constraint;
+	}
+	if (code === "SQLITE_CONSTRAINT_FOREIGNKEY" && writtenTable) fields.table = writtenTable;
+	return new SqliteDatabaseError(error.message, fields, { cause: error });
+};
+//#endregion
+//#region ../../apps/api/src/db/sqlite/functions.ts
+/** Unicode-aware case folding (SQLite's own `lower`/`upper`/`LIKE` only fold ASCII). */
+const fold = (value) => typeof value === "string" ? value.toLowerCase() : value;
+const upper = (value) => typeof value === "string" ? value.toUpperCase() : value;
+const PATTERNS = /* @__PURE__ */ new Map();
+const compiled = (pattern) => {
+	let regexp = PATTERNS.get(pattern);
+	if (!regexp) {
+		regexp = new RegExp(pattern, "u");
+		PATTERNS.set(pattern, regexp);
+	}
+	return regexp;
+};
+/** `value REGEXP pattern` (PostgreSQL `~`), which SQLite rewrites to `regexp(pattern, value)`. */
+const regexp = (pattern, value) => {
+	if (pattern === null || value === null) return null;
+	return compiled(String(pattern)).test(String(value)) ? 1 : 0;
+};
+/** PostgreSQL's `split_part(text, delimiter, n)` for n ≥ 1: empty text past the last part. */
+const splitPart = (value, delimiter, position) => {
+	if (value === null || delimiter === null || position === null) return null;
+	const index = Number(position);
+	if (!Number.isInteger(index) || index < 1) throw new Error("split_part: field position must be a positive integer");
+	return String(value).split(String(delimiter))[index - 1] ?? "";
+};
+const DETERMINISTIC = { deterministic: true };
+const registerFunctions = (database, hooks) => {
+	database.function("shapio_fold", DETERMINISTIC, fold);
+	database.function("lower", DETERMINISTIC, fold);
+	database.function("upper", DETERMINISTIC, upper);
+	database.function("regexp", DETERMINISTIC, regexp);
+	database.function("split_part", DETERMINISTIC, splitPart);
+	database.function("gen_random_uuid", () => randomUUID());
+	database.function("shapio_now", () => hooks.now());
+	database.function("shapio_nextval", (name) => hooks.nextval(String(name)));
+	database.function("shapio_assert_write_transaction", () => {
+		hooks.assertWriteTransaction();
+		return 1;
+	});
+	database.function("shapio_notify", (channel, payload) => {
+		hooks.notify(String(channel), payload === null ? "" : String(payload));
+		return null;
+	});
+};
+//#endregion
+//#region ../../apps/api/src/db/sqlite/connection.ts
+const STATEMENT_CACHE_SIZE = 500;
+/**
+* One `node:sqlite` connection. The writer runs every write transaction; readers run read-only
+* transactions and autocommit reads (WAL lets them read while the writer works). Calls are synchronous:
+* a statement blocks the event loop while it runs.
+*/
+var SqliteConnection = class {
+	role;
+	#database;
+	#options;
+	#statements = /* @__PURE__ */ new Map();
+	#transactionStart;
+	#statementStart;
+	#pendingNotifications = [];
+	constructor(options) {
+		this.#options = options;
+		this.role = options.role;
+		this.#database = new DatabaseSync(options.location, { enableForeignKeyConstraints: true });
+		this.#database.exec(`pragma busy_timeout = ${options.busyTimeoutMs}`);
+		if (options.location !== ":memory:") {
+			if (options.role === "writer") this.#database.exec("pragma journal_mode = wal");
+			this.#database.exec("pragma synchronous = normal");
+		}
+		if (options.role === "reader") this.#database.exec("pragma query_only = 1");
+		const nextvalStatement = () => {
+			const statement = this.#database.prepare("update sequences set value = value + 1 where name = ? returning value");
+			statement.setReadBigInts(true);
+			return statement;
+		};
+		let nextval;
+		registerFunctions(this.#database, {
+			now: () => this.#transactionStart ?? this.#statementStart ?? toStoredTimestamp(/* @__PURE__ */ new Date()),
+			nextval: (name) => {
+				nextval ??= nextvalStatement();
+				const row = nextval.get(name);
+				if (!row) throw new Error(`Unknown sequence ${name}`);
+				return row.value;
+			},
+			assertWriteTransaction: () => {
+				if (this.role !== "writer" || this.#transactionStart === void 0) throw new Error("A transaction-level lock needs a write transaction on SQLite");
+			},
+			notify: (channel, payload) => {
+				if (this.#transactionStart === void 0) publishNotification(this.#options.databaseKey, channel, payload);
+				else this.#pendingNotifications.push([channel, payload]);
+			}
+		});
+	}
+	get inTransaction() {
+		return this.#transactionStart !== void 0;
+	}
+	/** Opens a transaction (`begin immediate` takes SQLite's write lock up front). */
+	begin(mode) {
+		this.#database.exec(mode === "immediate" ? "begin immediate" : "begin");
+		this.#transactionStart = toStoredTimestamp(/* @__PURE__ */ new Date());
+		this.#pendingNotifications = [];
+	}
+	/** Commits and delivers the notifications queued inside the transaction. */
+	commit() {
+		try {
+			this.#database.exec("commit");
+		} catch (error) {
+			this.rollback();
+			throw error;
+		}
+		const notifications = this.#pendingNotifications;
+		this.#end();
+		for (const [channel, payload] of notifications) publishNotification(this.#options.databaseKey, channel, payload);
+	}
+	/** Rolls back (a no-op when SQLite already ended the transaction) and drops queued notifications. */
+	rollback() {
+		try {
+			if (this.#database.isTransaction) this.#database.exec("rollback");
+		} finally {
+			this.#end();
+		}
+	}
+	#end() {
+		this.#transactionStart = void 0;
+		this.#pendingNotifications = [];
+	}
+	#prepare(sql) {
+		const cached = this.#statements.get(sql);
+		if (cached) {
+			this.#statements.delete(sql);
+			this.#statements.set(sql, cached);
+			return cached;
+		}
+		const statement = this.#database.prepare(sql);
+		statement.setReadBigInts(true);
+		const metadata = statement.columns();
+		const prepared = {
+			statement,
+			columns: metadata.length === 0 ? void 0 : metadata,
+			decoders: /* @__PURE__ */ new Map()
+		};
+		this.#statements.set(sql, prepared);
+		if (this.#statements.size > STATEMENT_CACHE_SIZE) {
+			const oldest = this.#statements.keys().next().value;
+			if (oldest !== void 0) this.#statements.delete(oldest);
+		}
+		return prepared;
+	}
+	#decodersOf(prepared, context) {
+		const { markers } = context;
+		const strict = this.#options.strict && !context.handWritten;
+		const cacheKey = markers === void 0 ? String(strict) : void 0;
+		let decoders = cacheKey === void 0 ? void 0 : prepared.decoders.get(cacheKey);
+		if (!decoders) {
+			decoders = (prepared.columns ?? []).map((column) => {
+				const marker = markers?.get(column.name);
+				const decoder = decoderFor(column, marker);
+				if (!strict || marker || column.type !== null) return decoder;
+				return (value) => {
+					assertNotUndecoded(column.name, value);
+					return decoder(value);
+				};
+			});
+			if (cacheKey !== void 0) prepared.decoders.set(cacheKey, decoders);
+		}
+		return decoders;
+	}
+	/** Runs one compiled statement and decodes its rows. */
+	execute(query, context) {
+		this.#statementStart = this.#transactionStart === void 0 ? toStoredTimestamp(/* @__PURE__ */ new Date()) : void 0;
+		try {
+			const prepared = this.#prepare(query.sql);
+			const parameters = query.parameters.map(encodeParameter);
+			if (!prepared.columns) {
+				const { changes, lastInsertRowid } = prepared.statement.run(...parameters);
+				return {
+					numAffectedRows: BigInt(changes),
+					insertId: BigInt(lastInsertRowid),
+					rows: []
+				};
+			}
+			const columns = prepared.columns;
+			const decoders = this.#decodersOf(prepared, context);
+			return { rows: prepared.statement.all(...parameters).map((source) => {
+				const row = {};
+				for (const [index, column] of columns.entries()) row[column.name] = decoders[index](source[column.name]);
+				return row;
+			}) };
+		} catch (error) {
+			throw translateSqliteError(error, this.#database, context.writtenTable, query.sql);
+		} finally {
+			this.#statementStart = void 0;
+		}
+	}
+	/** The planner statistics this database holds (`sqlite_stat1`), as text to compare; '' when it has none. */
+	statistics() {
+		try {
+			return this.#database.prepare(`select group_concat(tbl || ' ' || coalesce(idx, '') || ' ' || stat, char(10)) as stats from sqlite_stat1`).get()?.stats ?? "";
+		} catch {
+			return "";
+		}
+	}
+	/** Runs SQL text with no parameters or results (pragmas, `vacuum into`). */
+	exec(sql) {
+		this.#database.exec(sql);
+	}
+	close() {
+		this.#statements.clear();
+		if (this.#database.isOpen) this.#database.close();
+	}
+};
+//#endregion
+//#region ../../apps/api/src/db/sqlite/nullsNotDistinct.ts
+const NULLS_NOT_DISTINCT_INDEXES = [
+	{
+		name: "admin_role_permissions_grant_uq",
+		table: "admin_role_permissions",
+		columns: [
+			"role_id",
+			"action",
+			"model_id"
+		],
+		nullable: ["model_id"]
+	},
+	{
+		name: "app_role_permissions_grant_uq",
+		table: "app_role_permissions",
+		columns: [
+			"role_id",
+			"action",
+			"model_id"
+		],
+		nullable: ["model_id"]
+	},
+	{
+		name: "admin_user_roles_assignment_uq",
+		table: "admin_user_roles",
+		columns: [
+			"admin_user_id",
+			"role_id",
+			"site_id"
+		],
+		nullable: ["site_id"]
+	}
+];
+const quote = (identifier) => `"${identifier.replace(/"/g, "\"\"")}"`;
+/** The index's column list as SQL: `"a", "b", coalesce("c", '')`. */
+const indexExpressionSql = (index) => index.columns.map((column) => index.nullable.includes(column) ? `coalesce(${quote(column)}, '')` : quote(column)).join(", ");
+/** The index whose columns are exactly `columns` (in any order) on `table`. */
+const nullsNotDistinctIndexFor = (table, columns) => NULLS_NOT_DISTINCT_INDEXES.find((index) => index.table === table && index.columns.length === columns.length && index.columns.every((column) => columns.includes(column)));
+//#endregion
+//#region ../../apps/api/src/db/sqlite/plugin.ts
+/** Row-lock modifiers PostgreSQL needs and SQLite rejects; its write transactions are already serialised. */
+const ROW_LOCKS = /* @__PURE__ */ new Set([
+	"ForUpdate",
+	"ForNoKeyUpdate",
+	"ForShare",
+	"ForKeyShare",
+	"NoWait",
+	"SkipLocked"
+]);
+const MARKERS = /* @__PURE__ */ new WeakMap();
+/** The result-type markers of a query's output columns (read by the driver when it decodes rows). */
+const markersOf = (queryId) => MARKERS.get(queryId);
+/** `asc`/`desc` from an order item's direction node (Kysely emits it as a raw `asc`/`desc`). */
+const directionOf = (node) => {
+	const direction = node.direction;
+	if (direction && RawNode.is(direction)) return direction.sqlFragments.join("").trim().toLowerCase() === "desc" ? "desc" : "asc";
+	return "asc";
+};
+/** Writes bound values as literals (SQLite proves a partial index's WHERE only from literal values). */
+var InlineValues = class extends OperationNodeTransformer {
+	transformValue(node) {
+		return node.immediate ? node : ValueNode.createImmediate(node.value);
+	}
+};
+const inlineValues = new InlineValues();
+/** The conflict target's WHERE (matching a partial unique index) with its values written inline. */
+const withInlineIndexWhere = (node) => node.indexWhere ? Object.freeze({
+	...node,
+	indexWhere: inlineValues.transformNode(node.indexWhere)
+}) : node;
+var SqliteTransformer = class extends OperationNodeTransformer {
+	#insertTable;
+	transformSelectQuery(node, queryId) {
+		const transformed = super.transformSelectQuery(node, queryId);
+		const modifiers = transformed.endModifiers?.filter((modifier) => modifier.modifier === void 0 || !ROW_LOCKS.has(modifier.modifier));
+		if (modifiers === transformed.endModifiers) return transformed;
+		return Object.freeze({
+			...transformed,
+			endModifiers: modifiers?.length ? Object.freeze(modifiers) : void 0
+		});
+	}
+	/** PostgreSQL places NULLs last ascending and first descending; SQLite does the reverse. Keep PostgreSQL's. */
+	transformOrderByItem(node, queryId) {
+		const transformed = super.transformOrderByItem(node, queryId);
+		if (transformed.nulls) return transformed;
+		const rawOrder = RawNode.is(transformed.orderBy) ? transformed.orderBy.sqlFragments.join(" ") : "";
+		if (/\b(asc|desc|nulls)\s*$/i.test(rawOrder)) throw new Error(`Write the direction with orderBy(expr, 'asc' | 'desc'), not inside raw SQL: ${rawOrder}`);
+		return Object.freeze({
+			...transformed,
+			nulls: directionOf(transformed) === "asc" ? "last" : "first"
+		});
+	}
+	transformInsertQuery(node, queryId) {
+		const previous = this.#insertTable;
+		this.#insertTable = node.into?.table.identifier.name;
+		try {
+			return super.transformInsertQuery(node, queryId);
+		} finally {
+			this.#insertTable = previous;
+		}
+	}
+	/** A column target on a NULLS NOT DISTINCT constraint becomes the SQLite index's expressions. */
+	transformOnConflict(node, queryId) {
+		const transformed = withInlineIndexWhere(super.transformOnConflict(node, queryId));
+		const columns = transformed.columns?.map((column) => column.column.name);
+		const index = columns && this.#insertTable !== void 0 ? nullsNotDistinctIndexFor(this.#insertTable, columns) : void 0;
+		if (!index) return transformed;
+		return Object.freeze({
+			...transformed,
+			columns: void 0,
+			indexExpression: RawNode.createWithSql(indexExpressionSql(index))
+		});
+	}
+	/** SQLite has no DEFAULT keyword in VALUES; Kysely would write NULL there instead of the default. */
+	transformDefaultInsertValue(_node) {
+		throw new Error("A multi-row insert leaves a column out of some rows; SQLite cannot insert DEFAULT there. Give every row the same columns.");
+	}
+};
+/**
+* Adapts Kysely queries written for PostgreSQL to SQLite (dialect boundary, ADR 0001): drops row locks,
+* spells out PostgreSQL's NULL ordering, retargets conflicts on NULLS NOT DISTINCT constraints and records
+* the result-type markers of computed columns for the driver.
+*/
+var SqlitePlugin = class {
+	#transformer = new SqliteTransformer();
+	transformQuery({ node, queryId }) {
+		const markers = collectMarkers(node);
+		if (markers) MARKERS.set(queryId, markers);
+		return this.#transformer.transformNode(node, queryId);
+	}
+	async transformResult({ result }) {
+		return result;
+	}
+};
+//#endregion
+//#region ../../apps/api/src/db/sqlite/writeLock.ts
+const scopes = new AsyncLocalStorage();
+/** Runs `fn` (a Kysely transaction, including its begin) in a fresh transaction scope. */
+const runInTransactionScope = (fn) => scopes.run({
+	holdsWriteLock: false,
+	parent: scopes.getStore()
+}, fn);
+/** Whether `scope` or a transaction enclosing it holds the write lock. */
+const insideWriter = (scope) => {
+	for (let current = scope; current; current = current.parent) if (current.holdsWriteLock) return true;
+	return false;
+};
+const currentTransactionScope = () => scopes.getStore();
+var SqliteNestedWriteError = class extends Error {
+	constructor(statement) {
+		super(`A write outside the open SQLite write transaction would wait for that transaction forever. Run it on the transaction (trx) instead: ${statement.slice(0, 200)}`);
+		this.name = "SqliteNestedWriteError";
+	}
+};
+var WriteLock = class {
+	#tail = Promise.resolve();
+	#holder;
+	/**
+	* Waits for the write lock and returns its release function. `scope` is the transaction taking it (it
+	* then holds the lock until commit or rollback), or undefined for one autocommit statement.
+	*/
+	async acquire(statement, scope) {
+		if (this.#holder !== void 0 && insideWriter(scopes.getStore())) throw new SqliteNestedWriteError(statement);
+		const previous = this.#tail;
+		let release;
+		this.#tail = new Promise((resolve) => {
+			release = resolve;
+		});
+		await previous;
+		this.#holder = scope;
+		if (scope) scope.holdsWriteLock = true;
+		let released = false;
+		return () => {
+			if (released) return;
+			released = true;
+			if (scope) scope.holdsWriteLock = false;
+			this.#holder = void 0;
+			release();
+		};
+	}
+};
+//#endregion
+//#region ../../apps/api/src/db/sqlite/driver.ts
+/** Statement text that may write (or call a function that writes). Anything unsure counts as a write. */
+const WRITE_WORDS = /\b(insert|update|delete|replace|create|drop|alter|vacuum|pragma|shapio_nextval|begin|commit|rollback|savepoint|release)\b/i;
+const isRead = (query) => {
+	if (SelectQueryNode.is(query.query)) return !query.sql.includes("shapio_nextval(");
+	if (RawNode.is(query.query)) return /^\s*(select|with)\b/i.test(query.sql) && !WRITE_WORDS.test(query.sql);
+	return false;
+};
+const tableNameOf = (node) => {
+	return (node?.table)?.identifier?.name;
+};
+const writtenTableOf = (query) => {
+	const node = query.query;
+	if (InsertQueryNode.is(node)) return tableNameOf(node.into);
+	if (UpdateQueryNode.is(node) && node.table) return tableNameOf(node.table) ?? tableNameOf(node.table.node);
+};
+/**
+* The key a database's notification bus and session locks use: the absolute file path (every in-memory
+* database shares one key; notifications are only hints).
+*/
+const notificationKeyOf = (location) => location.kind === "memory" ? ":memory:" : resolve(location.path);
+const contextOf = (query) => ({
+	markers: markersOf(query.queryId),
+	writtenTable: writtenTableOf(query),
+	handWritten: RawNode.is(query.query)
+});
+/** How often the writer refreshes the query planner's statistics. */
+const STATISTICS_INTERVAL_MS = 6e5;
+/**
+* Planner statistics (`sqlite_stat1`), as SQLite recommends for long-lived connections: `full` also
+* analyzes tables that were never analyzed (0x10000: every table, not only those this connection queried);
+* `refresh` re-analyzes the tables whose size changed a lot since. Both are usually no-ops. Without
+* statistics SQLite cannot tell that a list in `created_at` order is best read through the entries index.
+* A connection loads statistics when it opens (or its schema changes), so when they change the readers
+* are reopened: idle ones at once, busy ones when released.
+*/
+const OPTIMIZE = {
+	full: "pragma optimize=0x10002",
+	refresh: "pragma optimize"
+};
+/**
+* A Kysely driver over Node's built-in `node:sqlite` (no native dependency). One writer connection runs
+* every write, serialised by an in-process lock (`writeLock.ts`, `BEGIN IMMEDIATE`); reader connections
+* serve read-only transactions and autocommit reads concurrently (WAL). An in-memory database has the
+* writer only, and every statement takes the lock.
+*/
+var SqliteDriver = class {
+	#options;
+	#writeLock = new WriteLock();
+	databaseKey;
+	#writer;
+	#autocommitReader;
+	#idleReaders = [];
+	#openReaders = 0;
+	#readerWaiters = [];
+	#allConnections = [];
+	#statisticsTimer;
+	/** Bumped when the statistics change; a reader opened under an older one is closed on release. */
+	#statisticsGeneration = 0;
+	#readerGenerations = /* @__PURE__ */ new WeakMap();
+	constructor(options) {
+		this.#options = options;
+		this.databaseKey = notificationKeyOf(options.location);
+	}
+	get #hasReaders() {
+		return this.#options.location.kind === "file";
+	}
+	#open(role) {
+		const connection = new SqliteConnection({
+			location: this.#options.location.kind === "memory" ? ":memory:" : this.databaseKey,
+			databaseKey: this.databaseKey,
+			role,
+			busyTimeoutMs: this.#options.busyTimeoutMs,
+			strict: this.#options.strict
+		});
+		this.#allConnections.push(connection);
+		if (role === "reader") this.#readerGenerations.set(connection, this.#statisticsGeneration);
+		return connection;
+	}
+	#close(connection) {
+		connection.close();
+		this.#allConnections = this.#allConnections.filter((candidate) => candidate !== connection);
+	}
+	/** Closes readers that hold old statistics: the autocommit one and idle ones now, busy ones on release. */
+	#retireReaders() {
+		this.#statisticsGeneration += 1;
+		if (this.#autocommitReader) {
+			this.#close(this.#autocommitReader);
+			this.#autocommitReader = void 0;
+		}
+		for (const reader of this.#idleReaders) {
+			this.#close(reader);
+			this.#openReaders -= 1;
+		}
+		this.#idleReaders = [];
+	}
+	get writer() {
+		if (!this.#writer) {
+			this.#writer = this.#open("writer");
+			this.#writer.exec(OPTIMIZE.full);
+			this.#statisticsTimer = setInterval(() => {
+				this.optimizeStatistics("refresh").catch((error) => {
+					process.emitWarning(`SQLite statistics refresh (PRAGMA optimize) failed: ${String(error)}`);
+				});
+			}, STATISTICS_INTERVAL_MS);
+			this.#statisticsTimer.unref();
+		}
+		return this.#writer;
+	}
+	/** Refreshes planner statistics on the writer, between write transactions (after migrations: `full`). */
+	async optimizeStatistics(mode) {
+		const release = await this.lockWriter(OPTIMIZE[mode], false);
+		try {
+			const before = this.writer.statistics();
+			this.writer.exec(OPTIMIZE[mode]);
+			if (this.writer.statistics() !== before) this.#retireReaders();
+		} finally {
+			release();
+		}
+	}
+	async init() {
+		this.writer;
+	}
+	async acquireConnection() {
+		return new SqliteSession(this);
+	}
+	async beginTransaction(connection, settings) {
+		await connection.begin(settings.accessMode === "read only");
+	}
+	async commitTransaction(connection) {
+		connection.commit();
+	}
+	async rollbackTransaction(connection) {
+		connection.rollback();
+	}
+	async savepoint(connection, savepointName) {
+		connection.savepointCommand("savepoint", savepointName);
+	}
+	async rollbackToSavepoint(connection, savepointName) {
+		connection.savepointCommand("rollback to", savepointName);
+	}
+	async releaseSavepoint(connection, savepointName) {
+		connection.savepointCommand("release", savepointName);
+	}
+	async releaseConnection(connection) {
+		connection.release();
+	}
+	async destroy() {
+		clearInterval(this.#statisticsTimer);
+		this.#statisticsTimer = void 0;
+		for (const connection of this.#allConnections) connection.close();
+		this.#allConnections = [];
+		this.#writer = void 0;
+		this.#autocommitReader = void 0;
+		this.#idleReaders = [];
+	}
+	/** Takes the write lock for one statement or a whole transaction (see `writeLock.ts`). */
+	lockWriter(statement, transaction) {
+		return this.#writeLock.acquire(statement, transaction ? currentTransactionScope() : void 0);
+	}
+	/** The connection autocommit reads use: a reader, or the writer for an in-memory database. */
+	readerForStatement() {
+		if (!this.#hasReaders) return;
+		this.#autocommitReader ??= this.#open("reader");
+		return this.#autocommitReader;
+	}
+	/** A reader for a read-only transaction; waits when `readers` are all in use. */
+	async acquireReader() {
+		if (!this.#hasReaders) return;
+		const idle = this.#idleReaders.pop();
+		if (idle) return idle;
+		if (this.#openReaders < this.#options.readers) {
+			this.#openReaders += 1;
+			return this.#open("reader");
+		}
+		return new Promise((resolve) => this.#readerWaiters.push(resolve));
+	}
+	releaseReader(released) {
+		let reader = released;
+		if ((this.#readerGenerations.get(released) ?? 0) < this.#statisticsGeneration) {
+			this.#close(released);
+			reader = this.#open("reader");
+		}
+		const waiter = this.#readerWaiters.shift();
+		if (waiter) waiter(reader);
+		else this.#idleReaders.push(reader);
+	}
+};
+/**
+* The connection Kysely holds for one query or transaction. It binds to a physical connection lazily:
+* a write transaction to the writer (holding the write lock until it ends), a read-only one to a reader, and
+* a single statement to whichever fits.
+*/
+var SqliteSession = class {
+	#driver;
+	#transaction;
+	#releaseWriteLock;
+	constructor(driver) {
+		this.#driver = driver;
+	}
+	async begin(readOnly) {
+		const reader = readOnly ? await this.#driver.acquireReader() : void 0;
+		if (reader) {
+			try {
+				reader.begin("deferred");
+			} catch (error) {
+				this.#driver.releaseReader(reader);
+				throw error;
+			}
+			this.#transaction = reader;
+			return;
+		}
+		const release = await this.#driver.lockWriter("begin", true);
+		try {
+			this.#driver.writer.begin("immediate");
+		} catch (error) {
+			release();
+			throw error;
+		}
+		this.#releaseWriteLock = release;
+		this.#transaction = this.#driver.writer;
+	}
+	#finish(end) {
+		const connection = this.#transaction;
+		if (!connection) return;
+		this.#transaction = void 0;
+		try {
+			end(connection);
+		} finally {
+			if (connection.role === "reader") this.#driver.releaseReader(connection);
+			else {
+				this.#releaseWriteLock?.();
+				this.#releaseWriteLock = void 0;
+			}
+		}
+	}
+	commit() {
+		this.#finish((connection) => connection.commit());
+	}
+	rollback() {
+		this.#finish((connection) => connection.rollback());
+	}
+	/** Kysely releases the connection after a failed begin or commit too: never leave a lock behind. */
+	release() {
+		if (this.#transaction) this.rollback();
+	}
+	savepointCommand(command, name) {
+		if (!this.#transaction) throw new Error("Savepoints need an open transaction");
+		this.#transaction.exec(`${command} "${name.replace(/"/g, "\"\"")}"`);
+	}
+	async executeQuery(query) {
+		const context = contextOf(query);
+		if (this.#transaction) return this.#transaction.execute(query, context);
+		const reader = isRead(query) ? this.#driver.readerForStatement() : void 0;
+		if (reader) return reader.execute(query, context);
+		const release = await this.#driver.lockWriter(query.sql, false);
+		try {
+			return this.#driver.writer.execute(query, context);
+		} finally {
+			release();
+		}
+	}
+	async *streamQuery(query) {
+		const result = await this.executeQuery(query);
+		for (const row of result.rows) yield { rows: [row] };
+	}
+};
+//#endregion
+//#region ../../apps/api/src/db/sqlite/index.ts
+/**
+* SQLite runs DDL inside transactions, so each migration commits or rolls back whole. The driver handles
+* concurrency itself (one writer, several readers), so Kysely must not serialise connections on top.
+*/
+var ShapioSqliteAdapter = class extends SqliteAdapter {
+	get supportsTransactionalDdl() {
+		return true;
+	}
+	get supportsMultipleConnections() {
+		return true;
+	}
+};
+var ShapioSqliteDialect = class {
+	driver;
+	constructor(driver) {
+		this.driver = driver;
+	}
+	createAdapter() {
+		return new ShapioSqliteAdapter();
+	}
+	createDriver() {
+		return this.driver;
+	}
+	createIntrospector(db) {
+		return new SqliteIntrospector(db);
+	}
+	createQueryCompiler() {
+		return new SqliteQueryCompiler();
+	}
+};
+/** Runs every `execute` of a transaction builder (and of the builders it returns) in a transaction scope. */
+const scoped = (builder) => new Proxy(builder, { get(target, property, receiver) {
+	if (property === "execute") return (callback) => runInTransactionScope(() => target.execute(callback));
+	if (property === "setIsolationLevel" || property === "setAccessMode") return (value) => scoped(target[property](value));
+	return Reflect.get(target, property, receiver);
+} });
+/**
+* Kysely on SQLite. Transactions run in a scope so a write that would wait for its own enclosing write
+* transaction fails at once instead of hanging (`writeLock.ts`).
+*/
+var SqliteKysely = class extends Kysely {
+	sqliteDriver;
+	constructor(config) {
+		super(config);
+		this.sqliteDriver = config.dialect.driver;
+	}
+	transaction() {
+		return scoped(super.transaction());
+	}
+};
+const DEFAULT_BUSY_TIMEOUT_MS = 5e3;
+const createSqliteDb = ({ location, readers, busyTimeoutMs = DEFAULT_BUSY_TIMEOUT_MS, strict = false }) => new SqliteKysely({
+	dialect: new ShapioSqliteDialect(new SqliteDriver({
+		location,
+		readers,
+		busyTimeoutMs,
+		strict
+	})),
+	plugins: [new SqlitePlugin()]
+});
+/** The SQLite driver behind a handle, or undefined for another dialect. */
+const sqliteDriverOf = (db) => db instanceof SqliteKysely ? db.sqliteDriver : void 0;
+//#endregion
+//#region ../../apps/api/src/db/advisoryLocks.ts
+/**
+* Advisory-lock primitives. Kept in `db/` beside the Kysely instance so no other module writes lock SQL.
+* Keys are (namespace, key) int4 pairs; see constants/lockKeys.ts.
+*
+* PostgreSQL: advisory locks. SQLite (single process): session locks are an in-process mutex per database
+* and key; transaction locks are checks only, because every write transaction already holds SQLite's single
+* write lock, so no other transaction can run while one holds them.
+*/
+/** Stable 32-bit signed key for a string ID (e.g. a model UUID). Collisions only cost extra serialization. */
+const lockKeyFromId = (id) => createHash("sha256").update(id).digest().readInt32BE(0);
+//#endregion
+export { mysqlDriverOf as a, assertNotNested as c, toDatetimeText as d, AppError as f, createMysqlDb as i, withConnectionScope as l, createSqliteDb as n, DEFAULT_POOL_ACQUIRE_TIMEOUT_MS as o, sqliteDriverOf as r, pgAcquireError as s, lockKeyFromId as t, toStoredTimestamp as u };
+
+//# sourceMappingURL=advisoryLocks-COlJQc1r.js.map