emdash 0.39.1 → 0.40.0

package/src/plugins/context.ts

@@ -6,8 +6,11 @@
  */
 
 import type { Kysely } from "kysely";
+import mime from "mime/lite";
 import { ulid } from "ulidx";
 
+import { GLOBAL_UPLOAD_ALLOWLIST } from "../api/handlers/media-allowlist.js";
+import { handleMediaDelete } from "../api/handlers/media.js";
 import {
 	handleRedirectCreate,
 	handleRedirectDelete,
@@ -15,6 +18,7 @@ import {
 	handleRedirectUpdate,
 } from "../api/handlers/redirects.js";
 import { handleTermCreate } from "../api/handlers/taxonomies.js";
+import { CONTENT_TYPE_RE } from "../api/schemas/media.js";
 import { createRedirectBody, updateRedirectBody } from "../api/schemas/redirects.js";
 import { CommentRepository, type Comment } from "../database/repositories/comment.js";
 import { ContentRepository } from "../database/repositories/content.js";
@@ -28,6 +32,10 @@ import {
 	type VersionedRedirectRecord,
 } from "../database/repositories/redirect.js";
 import { SeoRepository } from "../database/repositories/seo.js";
+import {
+	findTaxonomyStructure,
+	selectTaxonomyDefs,
+} from "../database/repositories/taxonomy-def.js";
 import { TaxonomyRepository, type Taxonomy } from "../database/repositories/taxonomy.js";
 import { UserRepository } from "../database/repositories/user.js";
 import { withTransaction } from "../database/transaction.js";
@@ -39,6 +47,7 @@ import {
 	stripCredentialHeaders,
 } from "../import/ssrf.js";
 import { enrichImageMetadata } from "../media/enrich.js";
+import { matchesMimeAllowlist, normalizeMime } from "../media/mime.js";
 import { markContentMediaUsageCollectionStaleSafely } from "../media/usage/content-refresh.js";
 import { SchemaRegistry } from "../schema/registry.js";
 import { invalidateSiteSettingsCache } from "../settings/index.js";
@@ -55,6 +64,7 @@ import {
 	rewritePluginHttpRedirect,
 } from "./http-wire.js";
 import { readPluginMediaBytes, toPluginMediaItem, updatePluginMediaMetadata } from "./media.js";
+import { PluginRouteError } from "./route-error.js";
 import {
 	createPluginSecretRedactor,
 	createSettingsAccess,
@@ -390,9 +400,9 @@ export function createTaxonomyAccess(db: Kysely<Database>): TaxonomyAccess {
 
 	return {
 		async getAll(options?: TaxonomyReadOptions): Promise<TaxonomyDefInfo[]> {
-			let query = db.selectFrom("_emdash_taxonomy_defs").selectAll();
-			if (options?.locale !== undefined) query = query.where("locale", "=", options.locale);
-			const rows = await query.orderBy("name", "asc").execute();
+			let query = selectTaxonomyDefs(db);
+			if (options?.locale !== undefined) query = query.where("d.locale", "=", options.locale);
+			const rows = await query.orderBy("d.name", "asc").execute();
 			return rows.map((row) => ({
 				name: row.name,
 				label: row.label,
@@ -643,15 +653,11 @@ async function resolveTaxonomyDelta(
 		throw taxonomyAccessError("VALIDATION_ERROR", "Taxonomy term IDs must be non-empty strings");
 	}
 
-	const defs = await db
-		.selectFrom("_emdash_taxonomy_defs")
-		.select(["collections"])
-		.where("name", "=", taxonomy)
-		.execute();
-	if (defs.length === 0) {
+	const structure = await findTaxonomyStructure(db, taxonomy);
+	if (!structure) {
 		throw taxonomyAccessError("NOT_FOUND", `Taxonomy '${taxonomy}' not found`);
 	}
-	const attached = defs.some((def) => parseCollectionsColumn(def.collections).includes(collection));
+	const attached = structure.collections.includes(collection);
 	if (!attached) {
 		throw taxonomyAccessError(
 			"VALIDATION_ERROR",
@@ -745,6 +751,17 @@ export function createTaxonomyAccessWithWrite(db: Kysely<Database>): TaxonomyAcc
 	};
 }
 
+/**
+ * Called immediately before a plugin content write; it throws to refuse the
+ * write. When it returns a function, that function is called once the write
+ * has succeeded.
+ */
+export type ContentWriteGuard = () => Promise<void | (() => Promise<void>)>;
+
+async function afterContentWrite(recordWrite: void | (() => Promise<void>)): Promise<void> {
+	if (typeof recordWrite === "function") await recordWrite();
+}
+
 /**
  * Create full content access with write operations.
  *
@@ -756,7 +773,7 @@ export function createTaxonomyAccessWithWrite(db: Kysely<Database>): TaxonomyAcc
  */
 export function createContentAccessWithWrite(
 	db: Kysely<Database>,
-	beforeContentWrite?: () => Promise<void>,
+	beforeContentWrite?: ContentWriteGuard,
 	accessOptions?: { site?: SiteInfo; revisions?: boolean },
 	contentCreate?: (data: {
 		collection: string;
@@ -775,13 +792,15 @@ export function createContentAccessWithWrite(
 			options?: ContentCreateOptions,
 		): Promise<ContentItem> {
 			const locale = resolveContentCreateLocale(options?.locale);
-			await beforeContentWrite?.();
+			const recordWrite = await beforeContentWrite?.();
 			if (contentCreate) {
-				return contentCreate({
+				const created = await contentCreate({
 					collection,
 					input: data,
 					options: { ...options, locale },
 				});
+				await afterContentWrite(recordWrite);
+				return created;
 			}
 			const { fields, seo } = splitSeoFromInput(data);
 			let contentMutated = false;
@@ -824,6 +843,7 @@ export function createContentAccessWithWrite(
 					return result;
 				});
 				await markContentMediaUsageCollectionStaleSafely(db, collection, "CONTENT_USAGE_STALE");
+				await afterContentWrite(recordWrite);
 				return created;
 			} catch (error) {
 				if (contentMutated) {
@@ -834,7 +854,7 @@ export function createContentAccessWithWrite(
 		},
 
 		async update(collection: string, id: string, data: ContentWriteInput): Promise<ContentItem> {
-			await beforeContentWrite?.();
+			const recordWrite = await beforeContentWrite?.();
 			const { fields, seo } = splitSeoFromInput(data);
 			const hasFieldUpdates = Object.keys(fields).length > 0;
 			let contentMutated = false;
@@ -885,6 +905,7 @@ export function createContentAccessWithWrite(
 				if (hasFieldUpdates) {
 					await markContentMediaUsageCollectionStaleSafely(db, collection, "CONTENT_USAGE_STALE");
 				}
+				await afterContentWrite(recordWrite);
 				return updated;
 			} catch (error) {
 				if (contentMutated) {
@@ -895,7 +916,7 @@ export function createContentAccessWithWrite(
 		},
 
 		async delete(collection: string, id: string): Promise<boolean> {
-			await beforeContentWrite?.();
+			const recordWrite = await beforeContentWrite?.();
 			const contentRepo = new ContentRepository(db);
 			const deleted = await contentRepo.delete(collection, id);
 			if (deleted) {
@@ -903,6 +924,7 @@ export function createContentAccessWithWrite(
 				// release the lease itself. Mirrors handleContentDelete.
 				await new EntryLockRepository(db).releaseEntry(collection, id);
 				await markContentMediaUsageCollectionStaleSafely(db, collection, "CONTENT_USAGE_STALE");
+				await afterContentWrite(recordWrite);
 			}
 			return deleted;
 		},
@@ -952,6 +974,36 @@ function createBlockedMediaReadAccess(): MediaAccess {
 	};
 }
 
+function allowedUploadType(contentType: string): string {
+	if (!CONTENT_TYPE_RE.test(contentType)) {
+		throw PluginRouteError.badRequest("Invalid content type");
+	}
+	const mimeType = normalizeMime(contentType);
+	if (!matchesMimeAllowlist(mimeType, GLOBAL_UPLOAD_ALLOWLIST)) {
+		throw new PluginRouteError("UNSUPPORTED_MEDIA_TYPE", "File type not allowed", 415);
+	}
+	return mimeType;
+}
+
+function uploadStorageKey(
+	filename: string,
+	mimeType: string,
+): { basename: string; storageKey: string } {
+	const keyPrefix = ulid();
+	const basename = filename.split("/").pop() ?? filename;
+	const dotIdx = basename.lastIndexOf(".");
+	const nameExt = dotIdx > 0 ? basename.slice(dotIdx + 1).toLowerCase() : "";
+	// Local storage serves files by their key's extension, so it must map to an allowed type.
+	const nameType = mime.getType(nameExt);
+	const nameExtAllowed =
+		nameType !== null && matchesMimeAllowlist(nameType, GLOBAL_UPLOAD_ALLOWLIST);
+	const ext =
+		nameType === mimeType
+			? nameExt
+			: (mime.getExtension(mimeType) ?? (nameExtAllowed ? nameExt : null));
+	return { basename, storageKey: ext ? `${keyPrefix}.${ext}` : keyPrefix };
+}
+
 /**
  * Create full media access with write operations.
  *
@@ -970,34 +1022,33 @@ export function createMediaAccessWithWrite(
 	const mediaRepo = new MediaRepository(db);
 	const readAccess = createMediaAccess(db);
 
-	const getUploadUrl =
-		getUploadUrlFn ??
-		(async (filename: string, contentType: string) => {
-			if (!storage) {
-				throw new Error(
-					"Media getUploadUrl() requires a storage backend. Configure storage in PluginContextFactoryOptions.",
-				);
-			}
+	const getUploadUrl = getUploadUrlFn
+		? async (filename: string, contentType: string) =>
+				getUploadUrlFn(filename, allowedUploadType(contentType))
+		: async (filename: string, contentType: string) => {
+				if (!storage) {
+					throw new Error(
+						"Media getUploadUrl() requires a storage backend. Configure storage in PluginContextFactoryOptions.",
+					);
+				}
 
-			const basename = filename.split("/").pop() ?? filename;
-			const dotIdx = basename.lastIndexOf(".");
-			const ext = dotIdx > 0 ? basename.slice(dotIdx).toLowerCase() : "";
-			const storageKey = `${ulid()}${ext}`;
+				const mimeType = allowedUploadType(contentType);
+				const { basename, storageKey } = uploadStorageKey(filename, mimeType);
 
-			const media = await mediaRepo.createPending({
-				filename: basename,
-				mimeType: contentType,
-				storageKey,
-			});
+				const media = await mediaRepo.createPending({
+					filename: basename,
+					mimeType,
+					storageKey,
+				});
 
-			const signed = await storage.getSignedUploadUrl({
-				key: storageKey,
-				contentType,
-				expiresIn: 3600,
-			});
+				const signed = await storage.getSignedUploadUrl({
+					key: storageKey,
+					contentType: mimeType,
+					expiresIn: 3600,
+				});
 
-			return { uploadUrl: signed.url, mediaId: media.id };
-		});
+				return { uploadUrl: signed.url, mediaId: media.id };
+			};
 
 	return {
 		...readAccess,
@@ -1015,30 +1066,25 @@ export function createMediaAccessWithWrite(
 				);
 			}
 
-			// Generate a storage key with a unique prefix
-			const keyPrefix = ulid();
-			// Extract extension from basename (ignore path separators)
-			const basename = filename.split("/").pop() ?? filename;
-			const dotIdx = basename.lastIndexOf(".");
-			const ext = dotIdx > 0 ? basename.slice(dotIdx).toLowerCase() : "";
-			const storageKey = `${keyPrefix}${ext}`;
+			const mimeType = allowedUploadType(contentType);
+			const { basename, storageKey } = uploadStorageKey(filename, mimeType);
 
 			// Upload to storage first
 			await storage.upload({
 				key: storageKey,
 				body: new Uint8Array(bytes),
-				contentType,
+				contentType: mimeType,
 			});
 
 			// Derive dimensions + LQIP placeholders (no-op for non-images).
-			const enriched = await enrichImageMetadata(new Uint8Array(bytes), contentType);
+			const enriched = await enrichImageMetadata(new Uint8Array(bytes), mimeType);
 
 			// Create DB record — clean up storage on failure
 			let media;
 			try {
 				media = await mediaRepo.create({
 					filename: basename,
-					mimeType: contentType,
+					mimeType,
 					size: bytes.byteLength,
 					storageKey,
 					status: "ready",
@@ -1064,16 +1110,18 @@ export function createMediaAccessWithWrite(
 		},
 
 		async delete(id: string): Promise<boolean> {
-			const deleted = await mediaRepo.delete(id);
+			const result = await handleMediaDelete(db, id, storage);
+			if (!result.success) {
+				if (result.error.code === "NOT_FOUND") return false;
+				throw new Error(result.error.message);
+			}
 			// Plugins can delete media that's referenced by site settings
 			// (`logo`, `favicon`, `seo.defaultOgImage`); the worker-scoped
 			// resolved-URL cache must be dropped or it will keep serving
 			// 404s. Matches the invalidation in
 			// `EmDashRuntime.handleMediaDelete`.
-			if (deleted) {
-				invalidateSiteSettingsCache();
-			}
-			return deleted;
+			invalidateSiteSettingsCache();
+			return true;
 		},
 	};
 }
@@ -1455,7 +1503,7 @@ export function createUserAccess(db: Kysely<Database>): UserAccess {
 
 export interface PluginContextFactoryOptions {
 	db: Kysely<Database>;
-	beforeContentWrite?: () => Promise<void>;
+	beforeContentWrite?: ContentWriteGuard;
 	contentCreate?: PluginContentCreateCallback;
 	contentActions?: ContentActionCallbacks;
 	/**
@@ -1581,7 +1629,7 @@ export interface ContentActionCallbacks {
  */
 export class PluginContextFactory {
 	private resolveDb: () => Kysely<Database>;
-	private beforeContentWrite?: () => Promise<void>;
+	private beforeContentWrite?: ContentWriteGuard;
 	private contentCreate?: PluginContentCreateCallback;
 	private contentActions?: ContentActionCallbacks;
 	private storage?: Storage;

package/src/plugins/cron.ts

@@ -15,6 +15,9 @@ import { ulid } from "ulidx";
 import type { Database } from "../database/types.js";
 import type { CronAccess, CronEvent, CronTaskInfo } from "./types.js";
 
+/** Matches the Workers runtime, which always runs in UTC, so Node hosts fire at the same instant. */
+const CRON_TIMEZONE = "UTC";
+
 /** Stale lock threshold in minutes */
 const STALE_LOCK_MINUTES = 10;
 const ISO_DATETIME_PATTERN =
@@ -324,12 +327,12 @@ export async function setCronTasksEnabled(
 // ─── Cron utilities ────────────────────────────────────────────────────────
 
 /**
- * Compute the next fire time for a cron expression.
+ * Compute the next fire time for a cron expression, resolved in UTC.
  * Supports standard cron (5-field), extended (6-field with seconds), and
  * aliases like @daily, @weekly, @hourly, @monthly, @yearly.
  */
 export function nextCronTime(expression: string, currentTime: Date = new Date()): string {
-	const job = new Cron(expression);
+	const job = new Cron(expression, { timezone: CRON_TIMEZONE });
 	const next = job.nextRun(currentTime);
 	if (!next) {
 		throw new Error(`Invalid cron expression or no future run: "${expression}"`);
@@ -342,8 +345,7 @@ export function nextCronTime(expression: string, currentTime: Date = new Date())
  */
 function isCronExpression(schedule: string): boolean {
 	try {
-		// Cron constructor validates; we discard the instance immediately.
-		const _cron = new Cron(schedule);
+		const _cron = new Cron(schedule, { timezone: CRON_TIMEZONE });
 		void _cron;
 		return true;
 	} catch {

package/src/plugins/define-plugin.ts

@@ -68,7 +68,8 @@ const MCP_TOOL_NAME_PATTERN = /^[a-zA-Z0-9_-]+$/;
  * `satisfies SandboxedPlugin` annotation from `emdash/plugin`. Calling
  * `definePlugin` with an object that has no `id` throws at runtime
  * (the type system already rejects it at compile time — this check is
- * for callers that bypass typechecking).
+ * for callers that bypass typechecking). Passing a plugin descriptor
+ * (an object with an `entrypoint`) also throws.
  */
 export function definePlugin<TStorage extends PluginStorageConfig>(
 	definition: PluginDefinition<TStorage>,
@@ -88,6 +89,15 @@ export function definePlugin<TStorage extends PluginStorageConfig>(
 				'from "emdash/plugin" — identity comes from `emdash-plugin.jsonc`.',
 		);
 	}
+	// A descriptor's hooks live behind its entrypoint, which definePlugin()
+	// cannot load, so wrapping one would register a plugin that does nothing.
+	if ("entrypoint" in definition) {
+		throw new Error(
+			`definePlugin() received a plugin descriptor for "${definition.id}" (it has an ` +
+				"`entrypoint`). Pass the descriptor directly to the `plugins` array of the " +
+				"emdash() integration instead of wrapping it in definePlugin().",
+		);
+	}
 	return defineNativePlugin(definition);
 }
 

package/src/plugins/email-console.ts

@@ -69,6 +69,8 @@ export async function devConsoleEmailDeliver(
 		`\n📧 [dev-email] Email sent\n` +
 			`   From: ${source}\n` +
 			`   To: ${message.to}\n` +
+			(message.cc?.length ? `   Cc: ${message.cc.join(", ")}\n` : "") +
+			(message.replyTo ? `   Reply-To: ${message.replyTo}\n` : "") +
 			`   Subject: ${message.subject}\n` +
 			`   Text: ${message.text.slice(0, 200)}${message.text.length > 200 ? "..." : ""}\n`,
 	);

package/src/plugins/email.ts

@@ -134,6 +134,15 @@ export class EmailPipeline {
 		if (!message.to || typeof message.to !== "string") {
 			throw new Error("Invalid email message: 'to' is required and must be a string");
 		}
+		if (
+			message.cc !== undefined &&
+			(!Array.isArray(message.cc) || message.cc.some((address) => typeof address !== "string"))
+		) {
+			throw new Error("Invalid email message: 'cc' must be an array of strings");
+		}
+		if (message.replyTo !== undefined && typeof message.replyTo !== "string") {
+			throw new Error("Invalid email message: 'replyTo' must be a string");
+		}
 		if (!message.subject || typeof message.subject !== "string") {
 			throw new Error("Invalid email message: 'subject' is required and must be a string");
 		}
@@ -176,6 +185,13 @@ export class EmailPipeline {
 		}
 
 		if (deliverResult.error) {
+			// The caller (e.g. auth routes) often swallows delivery errors to avoid
+			// leaking whether an email address exists. Log here so the failure and
+			// the responsible provider are always visible in runtime logs.
+			console.error(
+				`[email:deliver] Provider "${deliverResult.pluginId}" failed to send email to "${finalMessage.to}":`,
+				deliverResult.error,
+			);
 			throw deliverResult.error;
 		}
 

package/src/plugins/hooks.ts

@@ -1482,6 +1482,13 @@ export interface ExclusiveHookResolutionOptions {
 	 * Used as a tiebreaker when no DB selection exists and multiple providers are active.
 	 */
 	preferredHints?: Map<string, string[]>;
+	/**
+	 * Plugin IDs of built-in providers that give way to a plugin. When no
+	 * selection is stored, a fallback is auto-selected only if no other
+	 * provider of the hook is active, and that selection is not stored, so a
+	 * plugin provider that becomes active later is selected in its place.
+	 */
+	fallbackProviders?: ReadonlySet<string>;
 }
 
 /** Options table key prefix for exclusive hook selections */
@@ -1493,13 +1500,24 @@ const EXCLUSIVE_HOOK_KEY_PREFIX = "emdash:exclusive_hook:";
  * Shared algorithm used by both PluginManager and EmDashRuntime:
  * 1. If a DB selection exists and that plugin is active → keep it.
  * 2. If DB selection is stale (plugin inactive/gone) → clear it.
- * 3. If no selection and only one active provider → auto-select it.
+ * 3. If no selection and only one active provider → auto-select it. Fallback
+ *    providers are not counted when another provider is active, so a single
+ *    plugin provider is selected over a built-in fallback. A fallback
+ *    selection is kept in memory only.
  * 4. If preferred hints match an active provider → first match wins.
  * 5. If multiple providers and no hint → leave unselected (admin must choose).
  */
 export async function resolveExclusiveHooks(opts: ExclusiveHookResolutionOptions): Promise<void> {
-	const { pipeline, isActive, getOption, getOptions, setOption, deleteOption, preferredHints } =
-		opts;
+	const {
+		pipeline,
+		isActive,
+		getOption,
+		getOptions,
+		setOption,
+		deleteOption,
+		preferredHints,
+		fallbackProviders,
+	} = opts;
 	const exclusiveHookNames = pipeline.getRegisteredExclusiveHooks();
 	if (exclusiveHookNames.length === 0) return;
 
@@ -1554,12 +1572,18 @@ export async function resolveExclusiveHooks(opts: ExclusiveHookResolutionOptions
 		}
 
 		// Auto-select if only one active provider
-		if (activeProviderIds.size === 1) {
-			const [onlyProvider] = activeProviderIds;
-			try {
-				await setOption(key, onlyProvider);
-			} catch {
-				// Non-fatal
+		const candidates =
+			activeProviderIds.size > 1 && fallbackProviders
+				? [...activeProviderIds].filter((id) => !fallbackProviders.has(id))
+				: [...activeProviderIds];
+		if (candidates.length === 1) {
+			const [onlyProvider] = candidates;
+			if (!fallbackProviders?.has(onlyProvider)) {
+				try {
+					await setOption(key, onlyProvider);
+				} catch {
+					// Non-fatal
+				}
 			}
 			pipeline.setExclusiveSelection(hookName, onlyProvider);
 			continue;

package/src/plugins/manifest-schema.ts

@@ -104,6 +104,7 @@ const FIELD_TYPES = [
 	"json",
 	"slug",
 	"repeater",
+	"blocks",
 ] as const;
 
 export const HOOK_NAMES = [

package/src/plugins/route-error.ts

@@ -0,0 +1,57 @@
+/**
+ * Error class for plugin routes
+ * Allows plugins to return structured errors with specific HTTP status codes
+ */
+export class PluginRouteError extends Error {
+	constructor(
+		public code: string,
+		message: string,
+		public status: number = 400,
+		public details?: unknown,
+	) {
+		super(message);
+		this.name = "PluginRouteError";
+	}
+
+	/**
+	 * Create a bad request error (400)
+	 */
+	static badRequest(message: string, details?: unknown): PluginRouteError {
+		return new PluginRouteError("BAD_REQUEST", message, 400, details);
+	}
+
+	/**
+	 * Create an unauthorized error (401)
+	 */
+	static unauthorized(message: string = "Unauthorized"): PluginRouteError {
+		return new PluginRouteError("UNAUTHORIZED", message, 401);
+	}
+
+	/**
+	 * Create a forbidden error (403)
+	 */
+	static forbidden(message: string = "Forbidden"): PluginRouteError {
+		return new PluginRouteError("FORBIDDEN", message, 403);
+	}
+
+	/**
+	 * Create a not found error (404)
+	 */
+	static notFound(message: string = "Not found"): PluginRouteError {
+		return new PluginRouteError("NOT_FOUND", message, 404);
+	}
+
+	/**
+	 * Create a conflict error (409)
+	 */
+	static conflict(message: string, details?: unknown): PluginRouteError {
+		return new PluginRouteError("CONFLICT", message, 409, details);
+	}
+
+	/**
+	 * Create an internal error (500)
+	 */
+	static internal(message: string = "Internal error"): PluginRouteError {
+		return new PluginRouteError("INTERNAL_ERROR", message, 500);
+	}
+}

package/src/plugins/routes.ts

@@ -17,12 +17,15 @@ import type {
 import { routeNameSchema } from "@emdash-cms/plugin-types";
 import { z } from "zod";
 
-import { MediaUsageActivationWriteBlockedError } from "../api/media-usage-write-fence.js";
+import { SiteWriteBlockedError } from "../transfer/fence.js";
 import { PluginContextFactory, type PluginContextFactoryOptions } from "./context.js";
 import { extractRequestMeta } from "./request-meta.js";
+import { PluginRouteError } from "./route-error.js";
 import { parseDeclaredPluginRouteInput } from "./route-wire.js";
 import type { ResolvedPlugin, RouteContext, PluginRoute, UserInfo } from "./types.js";
 
+export { PluginRouteError };
+
 /**
  * Body-reading methods on `Request`. EmDash parses the request body once before
  * the handler runs and exposes the result as `ctx.input`, leaving the underlying
@@ -282,7 +285,7 @@ export class PluginRouteHandler {
 				status: 200,
 			};
 		} catch (error) {
-			if (error instanceof MediaUsageActivationWriteBlockedError) {
+			if (error instanceof SiteWriteBlockedError) {
 				return {
 					success: false,
 					error: { code: error.code, message: error.message },
@@ -340,64 +343,6 @@ export class PluginRouteHandler {
 	}
 }
 
-/**
- * Error class for plugin routes
- * Allows plugins to return structured errors with specific HTTP status codes
- */
-export class PluginRouteError extends Error {
-	constructor(
-		public code: string,
-		message: string,
-		public status: number = 400,
-		public details?: unknown,
-	) {
-		super(message);
-		this.name = "PluginRouteError";
-	}
-
-	/**
-	 * Create a bad request error (400)
-	 */
-	static badRequest(message: string, details?: unknown): PluginRouteError {
-		return new PluginRouteError("BAD_REQUEST", message, 400, details);
-	}
-
-	/**
-	 * Create an unauthorized error (401)
-	 */
-	static unauthorized(message: string = "Unauthorized"): PluginRouteError {
-		return new PluginRouteError("UNAUTHORIZED", message, 401);
-	}
-
-	/**
-	 * Create a forbidden error (403)
-	 */
-	static forbidden(message: string = "Forbidden"): PluginRouteError {
-		return new PluginRouteError("FORBIDDEN", message, 403);
-	}
-
-	/**
-	 * Create a not found error (404)
-	 */
-	static notFound(message: string = "Not found"): PluginRouteError {
-		return new PluginRouteError("NOT_FOUND", message, 404);
-	}
-
-	/**
-	 * Create a conflict error (409)
-	 */
-	static conflict(message: string, details?: unknown): PluginRouteError {
-		return new PluginRouteError("CONFLICT", message, 409, details);
-	}
-
-	/**
-	 * Create an internal error (500)
-	 */
-	static internal(message: string = "Internal error"): PluginRouteError {
-		return new PluginRouteError("INTERNAL_ERROR", message, 500);
-	}
-}
-
 /**
  * Registry for all plugin route handlers
  */