emdash 0.30.0 → 0.31.0

package/src/astro/routes/api/oauth/authorize.ts

@@ -69,11 +69,16 @@ function getCsrfCookie(request: Request): string | null {
 
 const SCOPE_LABELS: Record<string, string> = {
 	"content:read": "Read content (posts, pages, etc.)",
-	"content:write": "Create, edit, and delete content",
+	"content:write": "Create, edit, and delete content; manage menus and taxonomies",
 	"media:read": "View media files",
 	"media:write": "Upload and manage media files",
 	"schema:read": "View collection schemas",
 	"schema:write": "Create and modify collection schemas",
+	"taxonomies:manage": "Manage taxonomies",
+	"menus:manage": "Manage navigation menus",
+	"settings:read": "View site settings",
+	"settings:manage": "Modify site settings",
+	"mcp:tools": "Use MCP tools from all enabled plugins",
 	admin: "Full administrative access",
 };
 
@@ -141,7 +146,9 @@ export const GET: APIRoute = async ({ url, request, locals }) => {
 	}
 
 	// Parse and validate scopes
-	const requestedScopes = (scope ?? "").split(" ").filter(Boolean).filter(isValidScope);
+	const requestedScopes = [
+		...new Set((scope ?? "").split(" ").filter(Boolean).filter(isValidScope)),
+	];
 
 	if (requestedScopes.length === 0) {
 		return new Response(renderErrorPage("No valid scopes requested."), {
@@ -201,6 +208,21 @@ export const POST: APIRoute = async ({ request, locals }) => {
 		const v = formData.get(name);
 		return typeof v === "string" ? v : fallback;
 	};
+	const requestedScopes = new Set(
+		(new URL(request.url).searchParams.get("scope") ?? "")
+			.split(" ")
+			.filter(Boolean)
+			.filter(isValidScope),
+	);
+	const selectedScopes = [
+		...new Set(
+			formData
+				.getAll("scope")
+				.filter((value): value is string => typeof value === "string")
+				.filter(isValidScope)
+				.filter((scope) => requestedScopes.has(scope)),
+		),
+	];
 
 	// SEC-18: Validate CSRF token (double-submit cookie pattern).
 	// The form includes a hidden csrf_token field; the cookie has the same value.
@@ -285,7 +307,7 @@ export const POST: APIRoute = async ({ request, locals }) => {
 		response_type: field("response_type", "code"),
 		client_id: field("client_id"),
 		redirect_uri: redirectUri,
-		scope: field("scope"),
+		scope: selectedScopes.join(" "),
 		state,
 		code_challenge: field("code_challenge"),
 		code_challenge_method: field("code_challenge_method", "S256"),
@@ -294,12 +316,16 @@ export const POST: APIRoute = async ({ request, locals }) => {
 
 	if (!result.success) {
 		const errMsg = result.error?.message ?? "Authorization failed";
+		const invalidScope = result.error?.code === "INVALID_SCOPE";
 		// On error, redirect back with error params — use generic description to avoid
 		// leaking internal error details to the (already-validated) redirect target
 		try {
 			const errorUrl = new URL(redirectUri);
-			errorUrl.searchParams.set("error", "server_error");
-			errorUrl.searchParams.set("error_description", "Authorization failed");
+			errorUrl.searchParams.set("error", invalidScope ? "invalid_scope" : "server_error");
+			errorUrl.searchParams.set(
+				"error_description",
+				invalidScope ? "No selected permission can be granted" : "Authorization failed",
+			);
 			if (state) errorUrl.searchParams.set("state", state);
 			return Response.redirect(errorUrl.toString(), 302);
 		} catch {
@@ -331,8 +357,8 @@ function renderConsentPage(params: {
 }): string {
 	const scopeList = params.scopes
 		.map((s) => {
-			const label = SCOPE_LABELS[s] ?? s;
-			return `<li>${escapeHtml(label)}</li>`;
+			const label = SCOPE_LABELS[s] ?? getPluginScopeLabel(s) ?? s;
+			return `<li><label><input type="checkbox" name="scope" value="${escapeHtml(s)}" checked><span>${escapeHtml(label)}</span></label></li>`;
 		})
 		.join("\n");
 
@@ -353,6 +379,8 @@ function renderConsentPage(params: {
   ul { list-style: none; margin-bottom: 1.5rem; }
   li { padding: 0.5rem 0; border-bottom: 1px solid #262626; font-size: 0.875rem; }
   li:last-child { border-bottom: none; }
+  label { display: flex; align-items: flex-start; gap: 0.625rem; cursor: pointer; }
+  input[type="checkbox"] { margin-top: 0.125rem; accent-color: #2563eb; }
   .actions { display: flex; gap: 0.75rem; }
   button { flex: 1; padding: 0.625rem 1rem; border-radius: 8px; border: none; font-size: 0.875rem; font-weight: 500; cursor: pointer; }
   .approve { background: #2563eb; color: white; }
@@ -366,14 +394,13 @@ function renderConsentPage(params: {
   <h1>Authorize Application</h1>
   <p class="client-id">${escapeHtml(params.clientId)}</p>
   <p class="user">Signed in as <strong>${escapeHtml(params.userName)}</strong></p>
-  <h2>Permissions requested</h2>
-  <ul>${scopeList}</ul>
   <form method="POST">
+    <h2>Permissions requested</h2>
+    <ul>${scopeList}</ul>
     <input type="hidden" name="csrf_token" value="${escapeHtml(params.csrfToken)}">
     <input type="hidden" name="response_type" value="${escapeHtml(params.responseType)}">
     <input type="hidden" name="client_id" value="${escapeHtml(params.clientId)}">
     <input type="hidden" name="redirect_uri" value="${escapeHtml(params.redirectUri)}">
-    <input type="hidden" name="scope" value="${escapeHtml(params.scopes.join(" "))}">
     <input type="hidden" name="state" value="${escapeHtml(params.state)}">
     <input type="hidden" name="code_challenge" value="${escapeHtml(params.codeChallenge)}">
     <input type="hidden" name="code_challenge_method" value="${escapeHtml(params.codeChallengeMethod)}">
@@ -388,6 +415,11 @@ function renderConsentPage(params: {
 </html>`;
 }
 
+function getPluginScopeLabel(scope: string): string | null {
+	const pluginId = scope.startsWith("mcp:tools:") ? scope.slice("mcp:tools:".length) : "";
+	return pluginId ? `Use MCP tools from ${pluginId}` : null;
+}
+
 function renderErrorPage(message: string): string {
 	return `<!DOCTYPE html>
 <html lang="en">

package/src/components/Gallery.astro

@@ -2,11 +2,17 @@
 /**
  * Portable Text Gallery block component
  *
- * Renders image galleries from WordPress imports.
- * Uses Astro's Image component for optimization when dimensions are available.
+ * Renders image galleries from WordPress imports and EmDash media.
+ * Uses the provider's getEmbed/getSrc functions for external media (mirrors
+ * Image.astro), falling back to Astro's Image component when dimensions are
+ * available for locally-stored media.
  */
 import { Image as AstroImage } from "astro:assets";
+import type { ImageEmbed } from "../media/types.js";
+import { getMediaProvider } from "../media/provider-loader.js";
 import { buildRenderMediaUrl } from "../media/url.js";
+import { toAbsoluteMediaUrl, RESPONSIVE_BREAKPOINTS } from "../media/responsive.js";
+import { getPublicOrigin } from "../api/public-url.js";
 
 export interface Props {
 	node: {
@@ -18,50 +24,159 @@ export interface Props {
 			asset: {
 				_ref: string;
 				url?: string;
+				/** Provider ID for external media (e.g., "cloudflare-images") */
+				provider?: string;
 			};
 			alt?: string;
 			caption?: string;
 			width?: number;
 			height?: number;
+			/** LQIP blurhash placeholder (images only) */
+			blurhash?: string;
+			/** LQIP dominant-color placeholder, as a CSS color (images only) */
+			dominantColor?: string;
 		}>;
 		columns?: number;
 	};
+	/** Render the LQIP placeholder as an inline background. Disable for strict CSP. */
+	placeholder?: boolean;
 }
 
-const { node } = Astro.props;
+/**
+ * Generate srcset using provider's getSrc function
+ */
+function generateSrcset(
+	getSrc: NonNullable<ImageEmbed["getSrc"]>,
+	maxWidth: number,
+	aspectRatio?: number,
+): string {
+	return RESPONSIVE_BREAKPOINTS.filter((w) => w <= maxWidth * 2)
+		.map((w) => {
+			const h = aspectRatio ? Math.round(w / aspectRatio) : undefined;
+			return `${getSrc({ width: w, height: h })} ${w}w`;
+		})
+		.join(", ");
+}
+
+const { node, placeholder = true } = Astro.props;
 const images = node?.images ?? [];
 const columns = node?.columns ?? 3;
 
 if (!images.length) {
 	return null;
 }
+
+// Resolve provider embeds up front (async), keeping the template's `.map()`
+// synchronous over the resolved data — mirrors Image.astro's per-image logic.
+const resolvedImages = await Promise.all(
+	images.map(async (image) => {
+		const { asset, alt = "", width, height } = image;
+		const aspectRatio = width && height ? width / height : undefined;
+
+		let src = "";
+		let srcset: string | undefined;
+		let sizes: string | undefined;
+		let astroImageSrc = "";
+		const providerId = asset.provider;
+
+		if (providerId && providerId !== "local") {
+			const provider = await getMediaProvider(providerId);
+			if (provider) {
+				try {
+					const mediaValue = {
+						provider: providerId,
+						id: asset._ref,
+						width,
+						height,
+						alt,
+					};
+					const result = provider.getEmbed(mediaValue, { width, height });
+					const embed = result instanceof Promise ? await result : result;
+					if (embed.type === "image") {
+						src = embed.src;
+
+						if (embed.getSrc) {
+							const maxWidth = width || 1200;
+							srcset = generateSrcset(embed.getSrc, maxWidth, aspectRatio);
+							sizes = width ? `(min-width: ${width}px) ${width}px, 100vw` : "100vw";
+						}
+					}
+				} catch (error) {
+					console.warn(`Failed to get embed for image ${asset._ref}:`, error);
+				}
+			}
+		}
+
+		// Fallback for local provider. `asset.url` carries the storage key with
+		// extension when present; `asset._ref` is a bare ULID that only the
+		// internal `/file/{id}` route can resolve. `buildRenderMediaUrl` picks
+		// the right shape.
+		if (!src) {
+			src = buildRenderMediaUrl(Astro.locals.emdash?.getPublicMediaUrl, {
+				url: asset.url,
+				id: asset._ref,
+			});
+			if (width && height) {
+				astroImageSrc = toAbsoluteMediaUrl(
+					src,
+					getPublicOrigin(Astro.url, Astro.locals.emdash?.config),
+				);
+			}
+		}
+
+		// Prefer blurhash over dominant color for the LQIP placeholder, like
+		// Image.astro.
+		let placeholderStyle = "";
+		if (placeholder && image.blurhash) {
+			const { blurhashToImageCssString } = await import("@unpic/placeholder");
+			placeholderStyle = blurhashToImageCssString(image.blurhash);
+		} else if (placeholder && image.dominantColor) {
+			placeholderStyle = `background-color: ${image.dominantColor};`;
+		}
+
+		return {
+			key: image._key,
+			alt,
+			caption: image.caption,
+			width,
+			height,
+			src,
+			srcset,
+			sizes,
+			astroImageSrc,
+			placeholderStyle,
+		};
+	}),
+);
 ---
 
 <div class="emdash-gallery" style={`--columns: ${columns}`}>
 	{
-		images.map((image) => {
-			const src = buildRenderMediaUrl(Astro.locals.emdash?.getPublicMediaUrl, {
-				url: image.asset.url,
-				id: image.asset._ref,
-			});
-			const hasSize = image.width && image.height;
-			return (
-				<figure class="emdash-gallery-item">
-					{hasSize ? (
-						<AstroImage
-							src={src}
-							alt={image.alt || ""}
-							width={image.width!}
-							height={image.height!}
-							layout="constrained"
-						/>
-					) : (
-						<img src={src} alt={image.alt || ""} loading="lazy" decoding="async" />
-					)}
-					{image.caption && <figcaption>{image.caption}</figcaption>}
-				</figure>
-			);
-		})
+		resolvedImages.map((image) => (
+			<figure class="emdash-gallery-item" style={image.placeholderStyle || undefined}>
+				{image.astroImageSrc ? (
+					<AstroImage
+						src={image.astroImageSrc}
+						alt={image.alt}
+						width={image.width!}
+						height={image.height!}
+						layout="constrained"
+					/>
+				) : (
+					<img
+						src={image.src}
+						srcset={image.srcset}
+						sizes={image.sizes}
+						alt={image.alt}
+						width={image.width}
+						height={image.height}
+						loading="lazy"
+						decoding="async"
+					/>
+				)}
+				{image.caption && <figcaption>{image.caption}</figcaption>}
+			</figure>
+		))
 	}
 </div>
 

package/src/config/secrets.ts

@@ -108,8 +108,9 @@ export interface ResolveSecretsOptions {
 	db: Kysely<Database>;
 	/**
 	 * Optional explicit env override map. When omitted, falls back to
-	 * `import.meta.env` via the global accessor below. Tests pass an
-	 * explicit map to avoid leaking process state.
+	 * `process.env` via `readDefaultEnv` below (never `import.meta.env` —
+	 * see that function's docstring). Tests pass an explicit map to avoid
+	 * leaking process state.
 	 */
 	env?: SecretsEnv;
 	/**
@@ -514,29 +515,34 @@ function decodeBase64urlStrict(input: string): Uint8Array | null {
 /**
  * Default env reader.
  *
- * Note: this is the **only** code path in core that reads both
- * `import.meta.env` and `process.env`. Route handlers should not — they
- * always run inside the Astro/Vite bundle where `import.meta.env` is
- * the correct source. This resolver is shared with the CLI surface (via
- * `cli/commands/secrets.ts`) which runs outside the bundle, so we
- * deliberately consult both. `import.meta.env` wins so build-time
- * substitutions are honored when present.
+ * Reads **only** `process.env`. This module must never reference
+ * `import.meta.env`: in an Astro/Vite production build the bare
+ * `import.meta.env` expression is statically replaced with an object
+ * literal built from the env loaded at build time, which (a) embeds any
+ * secret present in `.env` on the build machine into the shipped server
+ * bundle, and (b) makes that stale build-time value silently shadow the
+ * real runtime secret configured on the deployment platform (e.g. via
+ * `wrangler secret put`). See #2139.
+ *
+ * `process.env` is the runtime source on Node/container deployments and
+ * on Cloudflare Workers with Node compatibility (the same source
+ * `resolveS3Config` in `../storage/s3.ts` uses). The CLI surface
+ * (`cli/commands/secrets.ts`) runs outside the bundle where
+ * `process.env` is native.
  *
  * The convention documented in AGENTS.md ("import.meta.env.EMDASH_X ||
- * import.meta.env.X") is the route-handler convention; this is the
- * shared-with-CLI exception.
+ * import.meta.env.X") is for public, build-time config in route
+ * handlers; secrets are deliberately excluded from it.
  */
 function readDefaultEnv(): SecretsEnv {
-	// eslint-disable-next-line typescript/no-unsafe-type-assertion -- import.meta.env is loose by design
-	const meta = (import.meta.env ?? {}) as Record<string, string | undefined>;
 	const proc = typeof process !== "undefined" && process.env ? process.env : {};
 
 	return {
-		EMDASH_ENCRYPTION_KEY: meta.EMDASH_ENCRYPTION_KEY ?? proc.EMDASH_ENCRYPTION_KEY,
-		EMDASH_PREVIEW_SECRET: meta.EMDASH_PREVIEW_SECRET ?? proc.EMDASH_PREVIEW_SECRET,
-		PREVIEW_SECRET: meta.PREVIEW_SECRET ?? proc.PREVIEW_SECRET,
-		EMDASH_IP_SALT: meta.EMDASH_IP_SALT ?? proc.EMDASH_IP_SALT,
-		EMDASH_AUTH_SECRET: meta.EMDASH_AUTH_SECRET ?? proc.EMDASH_AUTH_SECRET,
-		AUTH_SECRET: meta.AUTH_SECRET ?? proc.AUTH_SECRET,
+		EMDASH_ENCRYPTION_KEY: proc.EMDASH_ENCRYPTION_KEY,
+		EMDASH_PREVIEW_SECRET: proc.EMDASH_PREVIEW_SECRET,
+		PREVIEW_SECRET: proc.PREVIEW_SECRET,
+		EMDASH_IP_SALT: proc.EMDASH_IP_SALT,
+		EMDASH_AUTH_SECRET: proc.EMDASH_AUTH_SECRET,
+		AUTH_SECRET: proc.AUTH_SECRET,
 	};
 }

package/src/content/converters/gallery.ts

@@ -0,0 +1,61 @@
+/**
+ * Shared sanitization for gallery block images, used by both converters so
+ * the editor round-trip and the stored shape stay in lockstep.
+ */
+
+import type { PortableTextGalleryImage } from "./types.js";
+
+/**
+ * Normalize an untrusted `images` value into well-formed gallery images.
+ * Non-object entries and entries without an asset object are dropped.
+ * Missing `_key`s are filled via `generateKey` when provided (PM → PT);
+ * left empty otherwise (PT → PM keeps whatever the block carried).
+ */
+export function sanitizeGalleryImages(
+	value: unknown,
+	generateKey?: () => string,
+): PortableTextGalleryImage[] {
+	if (!Array.isArray(value)) return [];
+
+	const images: PortableTextGalleryImage[] = [];
+	for (const entry of value as unknown[]) {
+		if (!isRecord(entry)) continue;
+		const record = entry;
+		const asset = record.asset;
+		if (!isRecord(asset)) continue;
+		const assetRecord = asset;
+
+		const image: PortableTextGalleryImage = {
+			_type: "image",
+			_key:
+				typeof record._key === "string" && record._key
+					? record._key
+					: generateKey
+						? generateKey()
+						: "",
+			asset: {
+				_type: "reference",
+				_ref: typeof assetRecord._ref === "string" ? assetRecord._ref : "",
+				...(typeof assetRecord.url === "string" && assetRecord.url ? { url: assetRecord.url } : {}),
+				...(typeof assetRecord.provider === "string" && assetRecord.provider
+					? { provider: assetRecord.provider }
+					: {}),
+			},
+		};
+		if (typeof record.alt === "string" && record.alt) image.alt = record.alt;
+		if (typeof record.caption === "string" && record.caption) image.caption = record.caption;
+		if (typeof record.width === "number") image.width = record.width;
+		if (typeof record.height === "number") image.height = record.height;
+		if (typeof record.blurhash === "string" && record.blurhash) image.blurhash = record.blurhash;
+		if (typeof record.dominantColor === "string" && record.dominantColor)
+			image.dominantColor = record.dominantColor;
+
+		images.push(image);
+	}
+
+	return images;
+}
+
+function isRecord(value: unknown): value is Record<string, unknown> {
+	return typeof value === "object" && value !== null && !Array.isArray(value);
+}

package/src/content/converters/portable-text-to-prosemirror.ts

@@ -4,6 +4,7 @@
  * Converts Portable Text to TipTap's ProseMirror JSON format for editing.
  */
 
+import { sanitizeGalleryImages } from "./gallery.js";
 import type {
 	ProseMirrorDocument,
 	ProseMirrorNode,
@@ -13,6 +14,7 @@ import type {
 	PortableTextSpan,
 	PortableTextMarkDef,
 	PortableTextImageBlock,
+	PortableTextGalleryBlock,
 	PortableTextCodeBlock,
 } from "./types.js";
 
@@ -128,6 +130,14 @@ function isImageBlock(block: PortableTextBlock): block is PortableTextImageBlock
 	);
 }
 
+/**
+ * Type guard for gallery blocks. Requires an `images` array — a gallery
+ * without one is malformed and falls through to the unknown-block path.
+ */
+function isGalleryBlock(block: PortableTextBlock): block is PortableTextGalleryBlock {
+	return block._type === "gallery" && "images" in block && Array.isArray(block.images);
+}
+
 /**
  * Type guard for code blocks
  */
@@ -149,6 +159,15 @@ function convertBlock(block: PortableTextBlock): ProseMirrorNode | null {
 		// Malformed image block (no asset wrapper) — extract url from top level
 		return convertMalformedImage(block);
 	}
+	if (isGalleryBlock(block)) {
+		return {
+			type: "gallery",
+			attrs: {
+				images: sanitizeGalleryImages(block.images),
+				columns: typeof block.columns === "number" ? block.columns : undefined,
+			},
+		};
+	}
 	if (isCodeBlock(block)) {
 		return convertCodeBlock(block);
 	}

package/src/content/converters/prosemirror-to-portable-text.ts

@@ -4,6 +4,7 @@
  * Converts TipTap's ProseMirror JSON format to Portable Text for storage.
  */
 
+import { sanitizeGalleryImages } from "./gallery.js";
 import type {
 	ProseMirrorDocument,
 	ProseMirrorNode,
@@ -13,6 +14,7 @@ import type {
 	PortableTextSpan,
 	PortableTextMarkDef,
 	PortableTextImageBlock,
+	PortableTextGalleryBlock,
 	PortableTextCodeBlock,
 	PortableTextHtmlBlock,
 } from "./types.js";
@@ -77,6 +79,9 @@ function convertNode(node: ProseMirrorNode): PortableTextBlock | PortableTextBlo
 		case "image":
 			return convertImage(node);
 
+		case "gallery":
+			return convertGallery(node);
+
 		case "horizontalRule":
 			return {
 				_type: "break",
@@ -327,6 +332,19 @@ function convertImage(node: ProseMirrorNode): PortableTextImageBlock {
 	};
 }
 
+/**
+ * Convert gallery node to Portable Text
+ */
+function convertGallery(node: ProseMirrorNode): PortableTextGalleryBlock {
+	const columns = node.attrs?.columns;
+	return {
+		_type: "gallery",
+		_key: generateKey(),
+		images: sanitizeGalleryImages(node.attrs?.images, generateKey),
+		...(typeof columns === "number" ? { columns } : {}),
+	};
+}
+
 /**
  * Convert inline content (text nodes with marks) to Portable Text spans
  */

package/src/content/converters/types.ts

@@ -70,6 +70,41 @@ export interface PortableTextImageBlock {
 	displayHeight?: number;
 }
 
+/**
+ * A single image inside a gallery block. Mirrors the shape produced by
+ * gutenberg-to-portable-text and consumed by Gallery.astro.
+ */
+export interface PortableTextGalleryImage {
+	_type: "image";
+	_key: string;
+	asset: {
+		/** Present on WordPress-imported galleries; always emitted on round-trip */
+		_type?: "reference";
+		_ref: string;
+		url?: string;
+		/** Provider ID for external media (e.g., "cloudflare-images") */
+		provider?: string;
+	};
+	alt?: string;
+	caption?: string;
+	width?: number;
+	height?: number;
+	/** LQIP blurhash placeholder (images only) */
+	blurhash?: string;
+	/** LQIP dominant-color placeholder, as a CSS color (images only) */
+	dominantColor?: string;
+}
+
+/**
+ * Gallery block (grid of images with optional per-image captions)
+ */
+export interface PortableTextGalleryBlock {
+	_type: "gallery";
+	_key: string;
+	images: PortableTextGalleryImage[];
+	columns?: number;
+}
+
 /**
  * Code block
  */
@@ -105,6 +140,7 @@ export interface PortableTextUnknownBlock {
 export type PortableTextBlock =
 	| PortableTextTextBlock
 	| PortableTextImageBlock
+	| PortableTextGalleryBlock
 	| PortableTextCodeBlock
 	| PortableTextHtmlBlock
 	| PortableTextUnknownBlock;

package/src/database/dialect-helpers.ts

@@ -11,7 +11,7 @@
  */
 
 import type { ColumnDataType, Kysely, RawBuilder } from "kysely";
-import { sql } from "kysely";
+import { PostgresAdapter, sql } from "kysely";
 
 import type { DatabaseDialectType } from "../db/adapters.js";
 import { validateIdentifier, validateJsonFieldName } from "./validate.js";
@@ -19,12 +19,11 @@ import { validateIdentifier, validateJsonFieldName } from "./validate.js";
 export type { DatabaseDialectType };
 
 /**
- * Detect dialect type from a Kysely instance via the adapter class name.
+ * Detect dialect type from a Kysely instance via the adapter class.
  */
 // eslint-disable-next-line @typescript-eslint/no-explicit-any -- accepts any Kysely instance
 export function detectDialect(db: Kysely<any>): DatabaseDialectType {
-	const name = db.getExecutor().adapter.constructor.name;
-	if (name === "PostgresAdapter") return "postgres";
+	if (db.getExecutor().adapter instanceof PostgresAdapter) return "postgres";
 	return "sqlite";
 }
 

package/src/database/pg-migration-lock.ts

@@ -38,10 +38,7 @@ const KYSELY_PG_MIGRATION_LOCK_ID = BigInt("3853314791062309107");
 
 /**
  * Extends the stock adapter so every capability flag and `instanceof` check
- * is inherited, and keeps the class NAME `PostgresAdapter` because
- * `detectDialect()` (dialect-helpers.ts) identifies the dialect via
- * `adapter.constructor.name` — a differently-named adapter would make every
- * dialect helper fall back to SQLite SQL against a Postgres database.
+ * is inherited.
  */
 class PostgresAdapter extends KyselyPostgresAdapter {
 	// eslint-disable-next-line typescript/no-explicit-any -- matches the DialectAdapter signature