emdash 0.29.0 → 0.31.0

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";
 }
 
@@ -215,17 +214,91 @@ export function binaryType(db: Kysely<any>): ColumnDataType {
 }
 
 /**
- * SQL expression for extracting a field from a JSON/JSONB column.
+ * SQL expression for extracting a field from a JSON column stored as text.
  *
  * sqlite:   json_extract(column, '$.path')
- * postgres: column->>'path'
+ * postgres: (column)::jsonb->>'path'
+ *
+ * The Postgres cast is required because JSON columns (e.g.
+ * `_plugin_storage.data`) are `text`, and `text ->> unknown` is not an
+ * operator. The cast is immutable, so the same expression works in
+ * expression indexes — queries and indexes must build it through this
+ * helper so the planner can match them.
  */
 // eslint-disable-next-line @typescript-eslint/no-explicit-any -- accepts any Kysely instance
 export function jsonExtractExpr(db: Kysely<any>, column: string, path: string): string {
 	validateIdentifier(column, "JSON column name");
 	validateJsonFieldName(path, "JSON path");
 	if (isPostgres(db)) {
-		return `${column}->>'${path}'`;
+		return `(${column})::jsonb->>'${path}'`;
 	}
 	return `json_extract(${column}, '$.${path}')`;
 }
+
+/**
+ * SQL expression for extracting a queryable field from the plugin-storage
+ * `data` column.
+ *
+ * `_plugin_storage.data` is `text`, so Postgres extraction goes through the
+ * `(data)::jsonb->>'field'` cast (#1898) — otherwise `text ->> unknown` is not
+ * an operator. But the extracted value is still `text`, so a numeric comparison
+ * (`stock >= 10`) compares lexically (`'9' >= '10'` is TRUE) and silently
+ * over-counts / oversells; pass `{ numeric: true }` for a numeric comparison.
+ *
+ * The numeric form is a **type-guarded** cast, not a bare `::numeric`. A bare
+ * cast throws `invalid input syntax for type numeric` the moment a single
+ * scanned row stores a non-number in that field (documents are schemaless),
+ * aborting the whole query — and it would diverge from SQLite, which silently
+ * coerces. Guarding with `jsonb_typeof`/`json_type` makes the comparison total
+ * and parity-correct on both dialects: a non-number stored value yields `NULL`
+ * (no match) instead of an error.
+ *
+ * The field name is validated before interpolation, so the casts wrap only a
+ * safe identifier and add no injection surface.
+ *
+ * sqlite text:      json_extract(data, '$.field')
+ * sqlite numeric:   CASE WHEN json_type(data, '$.field') IN ('integer', 'real')
+ *                     THEN json_extract(data, '$.field') END
+ * postgres text:    (data)::jsonb->>'field'
+ * postgres numeric: CASE WHEN jsonb_typeof((data)::jsonb->'field') = 'number'
+ *                     THEN ((data)::jsonb->>'field')::numeric END
+ */
+// eslint-disable-next-line @typescript-eslint/no-explicit-any -- accepts any Kysely instance
+export function pluginDataExtractExpr(
+	db: Kysely<any>,
+	field: string,
+	options?: { numeric?: boolean },
+): string {
+	validateJsonFieldName(field, "plugin storage field name");
+	if (isPostgres(db)) {
+		const text = `(data)::jsonb->>'${field}'`;
+		if (!options?.numeric) return text;
+		return `CASE WHEN jsonb_typeof((data)::jsonb->'${field}') = 'number' THEN (${text})::numeric END`;
+	}
+	const extract = `json_extract(data, '$.${field}')`;
+	if (!options?.numeric) return extract;
+	return `CASE WHEN json_type(data, '$.${field}') IN ('integer', 'real') THEN ${extract} END`;
+}
+
+/**
+ * SQL expression for ordering plugin-storage rows by a `data` field.
+ *
+ * `ORDER BY` has no bound operand to infer numeric-vs-text from, so extracting
+ * as text (`->>'field'`) would sort a numeric field lexically on Postgres
+ * (`[10, 100, 9]`) while SQLite's `json_extract` sorts it numerically — a
+ * cross-dialect divergence. Ordering over the jsonb-native value (`->'field'`,
+ * single arrow) fixes this: jsonb btree ordering is numeric among numbers,
+ * lexical among strings, and total across heterogeneous values (never throws).
+ * SQLite's `json_extract` already orders numerically, so it is unchanged.
+ *
+ * sqlite:   json_extract(data, '$.field')
+ * postgres: (data)::jsonb->'field'
+ */
+// eslint-disable-next-line @typescript-eslint/no-explicit-any -- accepts any Kysely instance
+export function pluginDataOrderExpr(db: Kysely<any>, field: string): string {
+	validateJsonFieldName(field, "plugin storage order field name");
+	if (isPostgres(db)) {
+		return `(data)::jsonb->'${field}'`;
+	}
+	return `json_extract(data, '$.${field}')`;
+}

package/src/database/migrations/051_content_taxonomies_denorm.ts

@@ -0,0 +1,120 @@
+import type { Kysely } from "kysely";
+import { sql } from "kysely";
+
+import { columnExists, listTablesLike } from "../dialect-helpers.js";
+import { validateIdentifier } from "../validate.js";
+
+/**
+ * Denormalize the filter + sort columns from `ec_*` onto `content_taxonomies`
+ * and mirror `ec_*`'s composite sort indexes onto the pivot (#1834).
+ *
+ * A taxonomy-filtered listing used to apply the term filter as a correlated
+ * `EXISTS` on `SELECT * FROM ec_<collection> … ORDER BY … LIMIT ?`. The pivot
+ * carried only `(collection, entry_id, taxonomy_id)`, so the filter
+ * (`deleted_at`, `status`, `locale`) and the sort (`published_at`/`created_at`)
+ * could only be evaluated on the `ec_*` row. On stats-blind SQLite/D1 a
+ * selective term never fills the `LIMIT`, so the query walked the whole
+ * collection (~75k D1 rows read for a one-row page).
+ *
+ * Copying those columns onto the pivot and indexing them keyed by
+ * `(taxonomy_id, collection, …)` lets the loader seek the term and walk a
+ * sort-ordered pivot index, short-circuiting on `LIMIT`, then touch `ec_*` only
+ * by primary key to hydrate the page.
+ *
+ * The columns are advisory (D1 has no transactions; the write-path re-stamp is
+ * non-atomic), so the read path re-checks the real predicates on the joined
+ * `ec_*` row — see loader.ts. `updated_at` is deliberately not denormalized: it
+ * moves on every edit and is seldom a public sort, so its write cost outweighs
+ * its read value; `updated_at`-sorted taxonomy listings temp-sort instead.
+ *
+ * Order matters: add the columns, backfill, THEN build the indexes so each
+ * index is built once over populated data rather than maintained through the
+ * backfill `UPDATE`.
+ *
+ * Forward-only.
+ */
+
+const DENORM_COLUMNS = [
+	"status",
+	"scheduled_at",
+	"deleted_at",
+	"locale",
+	"published_at",
+	"created_at",
+] as const;
+
+// `entry_id DESC` (not ASC) matters: the listing orders `<sort> DESC, entry_id
+// DESC` (the common case), and a DESC tiebreaker lets SQLite satisfy the whole
+// ORDER BY from the index — no temp B-tree, clean early-`LIMIT`. An ASC
+// tiebreaker forces `USE TEMP B-TREE FOR LAST TERM OF ORDER BY`, which buffers
+// a whole equal-`sortval` block (e.g. a bulk import sharing one timestamp)
+// before emitting. `DESC` also serves the rarer ASC listing via a backward
+// index scan. Mirrors `ec_*`'s `(deleted_at, [locale,] <sort> DESC, id DESC)`.
+const INDEXES: { name: string; columns: string }[] = [
+	{
+		name: "idx_content_taxonomies_pub",
+		columns: "taxonomy_id, collection, deleted_at, published_at DESC, entry_id DESC",
+	},
+	{
+		name: "idx_content_taxonomies_crt",
+		columns: "taxonomy_id, collection, deleted_at, created_at DESC, entry_id DESC",
+	},
+	{
+		name: "idx_content_taxonomies_loc_pub",
+		columns: "taxonomy_id, collection, deleted_at, locale, published_at DESC, entry_id DESC",
+	},
+	{
+		name: "idx_content_taxonomies_loc_crt",
+		columns: "taxonomy_id, collection, deleted_at, locale, created_at DESC, entry_id DESC",
+	},
+];
+
+export async function up(db: Kysely<unknown>): Promise<void> {
+	// 1. Add the six denormalized columns (all nullable, no default). Guarded so
+	//    a partial apply — or a re-run after a mid-migration failure — can retry
+	//    (`ALTER TABLE ADD COLUMN` is not itself idempotent on either dialect).
+	for (const column of DENORM_COLUMNS) {
+		if (await columnExists(db, "content_taxonomies", column)) continue;
+		await sql`
+			ALTER TABLE content_taxonomies ADD COLUMN ${sql.ref(column)} TEXT
+		`.execute(db);
+	}
+
+	// 2. Backfill from each content table by primary key. Drive from the actual
+	//    `ec_*` tables (not `_emdash_collections`) so collections whose table was
+	//    dropped are skipped naturally; the pivot's `collection` value is the
+	//    slug, i.e. the table name without its `ec_` prefix.
+	const tableNames = await listTablesLike(db, "ec_%");
+	for (const tableName of tableNames) {
+		validateIdentifier(tableName, "content table name");
+		const slug = tableName.slice("ec_".length);
+		await sql`
+			UPDATE content_taxonomies
+			SET (status, scheduled_at, deleted_at, locale, published_at, created_at) = (
+				SELECT status, scheduled_at, deleted_at, locale, published_at, created_at
+				FROM ${sql.ref(tableName)}
+				WHERE ${sql.ref(tableName)}.id = content_taxonomies.entry_id
+			)
+			WHERE collection = ${slug}
+		`.execute(db);
+	}
+
+	// 3. Build the composite sort indexes over the now-populated columns.
+	for (const index of INDEXES) {
+		await sql`
+			CREATE INDEX IF NOT EXISTS ${sql.ref(index.name)}
+			ON content_taxonomies (${sql.raw(index.columns)})
+		`.execute(db);
+	}
+}
+
+export async function down(db: Kysely<unknown>): Promise<void> {
+	for (const index of INDEXES) {
+		await sql`DROP INDEX IF EXISTS ${sql.ref(index.name)}`.execute(db);
+	}
+	for (const column of DENORM_COLUMNS) {
+		await sql`
+			ALTER TABLE content_taxonomies DROP COLUMN ${sql.ref(column)}
+		`.execute(db);
+	}
+}

package/src/database/migrations/052_media_usage_read_index.ts

@@ -0,0 +1,26 @@
+import type { Kysely } from "kysely";
+
+const OLD_INDEX = "idx__emdash_media_usage_media_id";
+const READ_INDEX = "idx__emdash_media_usage_media_source_generation";
+
+export async function up(db: Kysely<unknown>): Promise<void> {
+	// D1 DDL is non-transactional: create the replacement before dropping the
+	// old index so an interrupted migration always leaves a media-leading index.
+	await db.schema
+		.createIndex(READ_INDEX)
+		.ifNotExists()
+		.on("_emdash_media_usage")
+		.columns(["media_id", "source_key", "generation"])
+		.execute();
+	await db.schema.dropIndex(OLD_INDEX).ifExists().execute();
+}
+
+export async function down(db: Kysely<unknown>): Promise<void> {
+	await db.schema
+		.createIndex(OLD_INDEX)
+		.ifNotExists()
+		.on("_emdash_media_usage")
+		.column("media_id")
+		.execute();
+	await db.schema.dropIndex(READ_INDEX).ifExists().execute();
+}

package/src/database/migrations/053_plugin_mcp_tools.ts

@@ -0,0 +1,21 @@
+import type { Kysely } from "kysely";
+
+import { columnExists } from "../dialect-helpers.js";
+
+/** Persist explicit per-plugin MCP enablement and the declaration consented to by an admin. */
+export async function up(db: Kysely<unknown>): Promise<void> {
+	if (!(await columnExists(db, "_plugin_state", "mcp_tools_enabled"))) {
+		await db.schema
+			.alterTable("_plugin_state")
+			.addColumn("mcp_tools_enabled", "integer", (col) => col.notNull().defaultTo(0))
+			.execute();
+	}
+	if (!(await columnExists(db, "_plugin_state", "mcp_tools_consent"))) {
+		await db.schema.alterTable("_plugin_state").addColumn("mcp_tools_consent", "text").execute();
+	}
+}
+
+export async function down(db: Kysely<unknown>): Promise<void> {
+	await db.schema.alterTable("_plugin_state").dropColumn("mcp_tools_consent").execute();
+	await db.schema.alterTable("_plugin_state").dropColumn("mcp_tools_enabled").execute();
+}

package/src/database/migrations/runner.ts

@@ -53,6 +53,9 @@ import * as m047 from "./047_restore_taxonomy_parent_index.js";
 import * as m048 from "./048_restore_content_taxonomies_term_index.js";
 import * as m049 from "./049_taxonomies_name_locale_index.js";
 import * as m050 from "./050_media_usage_index_status.js";
+import * as m051 from "./051_content_taxonomies_denorm.js";
+import * as m052 from "./052_media_usage_read_index.js";
+import * as m053 from "./053_plugin_mcp_tools.js";
 
 const MIGRATIONS: Readonly<Record<string, Migration>> = Object.freeze({
 	"001_initial": m001,
@@ -104,6 +107,9 @@ const MIGRATIONS: Readonly<Record<string, Migration>> = Object.freeze({
 	"048_restore_content_taxonomies_term_index": m048,
 	"049_taxonomies_name_locale_index": m049,
 	"050_media_usage_index_status": m050,
+	"051_content_taxonomies_denorm": m051,
+	"052_media_usage_read_index": m052,
+	"053_plugin_mcp_tools": m053,
 });
 
 /** Total number of registered migrations. Exported for use in tests. */

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

package/src/database/repositories/audit.ts

@@ -14,7 +14,8 @@ export type AuditAction =
 	| "logout"
 	| "password_change"
 	| "settings_update"
-	| "schema_change";
+	| "schema_change"
+	| "plugin_tool_invoke";
 
 export type AuditStatus = "success" | "failure" | "denied";