emdash 0.14.0 → 0.16.0

package/src/i18n/resolve.ts

@@ -35,3 +35,155 @@ export function resolveLocaleChain(explicit?: string): string[] {
 	if (!isI18nEnabled()) return [locale];
 	return getFallbackChain(locale);
 }
+
+const REPEATED_SLASHES = /\/{2,}/g;
+
+/**
+ * Interpolate a collection `url_pattern` with a row's slug and id.
+ *
+ * Falls back to `/{collection}/{slug}` when no pattern is configured.
+ * Does NOT apply any locale prefix — pass the result through
+ * Astro's `getRelativeLocaleUrl` / `getAbsoluteLocaleUrl` (or the
+ * `localizePath` helper below) to add the locale segment.
+ */
+export function interpolateUrlPattern(options: {
+	pattern: string | null;
+	collection: string;
+	slug: string;
+	id: string;
+}): string {
+	const { pattern, collection, slug, id } = options;
+	const basePattern = pattern ?? `/${encodeURIComponent(collection)}/{slug}`;
+	let path = basePattern
+		.replace("{slug}", encodeURIComponent(slug))
+		.replace("{id}", encodeURIComponent(id));
+	path = path.replace(REPEATED_SLASHES, "/");
+	if (path.length > 1 && path.endsWith("/")) path = path.slice(0, -1);
+	if (!path.startsWith("/")) path = `/${path}`;
+	return path;
+}
+
+/**
+ * Apply a locale prefix to a path, honouring the user's Astro `i18n`
+ * routing config (`prefixDefaultLocale`, custom `path`/`codes` mappings).
+ *
+ * Reads the resolved config from `astro:config/server`, which is always
+ * available regardless of whether i18n is enabled -- so this function
+ * works in both i18n and non-i18n builds without tripping Astro's
+ * `i18nNotEnabled` resolver (the case with importing `astro:i18n`).
+ *
+ * Returns:
+ *   - The original `path` when i18n is not configured.
+ *   - The original `path` for the default locale when
+ *     `prefixDefaultLocale` is false.
+ *   - `/{segment}{path}` for any other configured locale, where
+ *     `{segment}` is the locale's custom `path` if one is set,
+ *     otherwise the locale code.
+ *   - `null` when the row's locale isn't in the configured list.
+ *     Callers should drop the entry: a sitemap link to a route the
+ *     site can't serve is worse than no link at all (search engines
+ *     get a 404 / soft-404 and downrank the page).
+ *
+ * Falls back to `getI18nConfig()` (EmDash's mirror of the same config,
+ * populated at runtime startup) when `astro:config/server` is
+ * unavailable -- e.g. running outside an Astro build context, such as
+ * in vitest.
+ */
+export async function localizePath(path: string, locale: string): Promise<string | null> {
+	const segment = await resolveLocaleSegment(locale);
+	if (segment === undefined) return null;
+	if (segment === null || segment === "") return normalizePath(path);
+	return normalizePath(`/${segment}${path}`);
+}
+
+/**
+ * Resolve the URL segment to use for a locale.
+ *
+ * Returns:
+ *   - `null` when i18n isn't configured (caller should not prefix).
+ *   - `""` when the locale is the default locale and
+ *     `prefixDefaultLocale` is false (caller should not prefix).
+ *   - The locale's custom `path` value, or the locale string itself.
+ *   - `undefined` when the locale isn't in the configured list --
+ *     the row points at a route the site can't serve.
+ */
+async function resolveLocaleSegment(locale: string): Promise<string | null | undefined> {
+	const i18n = await readAstroI18nConfig();
+	if (!i18n || !i18n.locales || i18n.locales.length <= 1) return null;
+
+	const isDefault = locale === i18n.defaultLocale;
+	if (isDefault && !i18n.prefixDefaultLocale) return "";
+
+	// When the locale has a custom `path`/`codes` mapping, use the path
+	// for the URL segment. Otherwise use the locale code directly.
+	for (const entry of i18n.locales) {
+		if (typeof entry === "string") {
+			if (entry === locale) return entry;
+		} else if (entry.codes.includes(locale)) {
+			return entry.path;
+		}
+	}
+
+	return undefined;
+}
+
+interface AstroI18nConfig {
+	defaultLocale: string;
+	locales: Array<string | { codes: readonly string[]; path: string }>;
+	prefixDefaultLocale?: boolean;
+}
+
+let astroI18nCache: AstroI18nConfig | null | undefined;
+
+async function readAstroI18nConfig(): Promise<AstroI18nConfig | null> {
+	if (astroI18nCache !== undefined) return astroI18nCache;
+
+	try {
+		const mod = (await import("astro:config/server")) as {
+			i18n?: {
+				defaultLocale: string;
+				locales: Array<string | { codes: readonly string[]; path: string }>;
+				routing?: { prefixDefaultLocale?: boolean } | string;
+			};
+		};
+		if (!mod.i18n) {
+			astroI18nCache = null;
+			return null;
+		}
+		const routing = mod.i18n.routing;
+		astroI18nCache = {
+			defaultLocale: mod.i18n.defaultLocale,
+			locales: mod.i18n.locales,
+			prefixDefaultLocale:
+				typeof routing === "object" ? (routing.prefixDefaultLocale ?? false) : false,
+		};
+		return astroI18nCache;
+	} catch {
+		// `astro:config/server` isn't resolvable (e.g. running under vitest
+		// outside an Astro build). Fall back to EmDash's runtime config,
+		// which is populated at startup via the same astroConfig object.
+		const cfg = getI18nConfig();
+		if (!cfg || !isI18nEnabled()) {
+			astroI18nCache = null;
+			return null;
+		}
+		astroI18nCache = {
+			defaultLocale: cfg.defaultLocale,
+			locales: cfg.locales,
+			prefixDefaultLocale: cfg.prefixDefaultLocale,
+		};
+		return astroI18nCache;
+	}
+}
+
+/** @internal -- exposed for tests to reset the module-level cache. */
+export function _resetAstroI18nCacheForTests(): void {
+	astroI18nCache = undefined;
+}
+
+function normalizePath(path: string): string {
+	let p = path.replace(REPEATED_SLASHES, "/");
+	if (p.length > 1 && p.endsWith("/")) p = p.slice(0, -1);
+	if (!p.startsWith("/")) p = `/${p}`;
+	return p;
+}

package/src/index.ts

@@ -12,6 +12,9 @@ export type {
 export {
 	ContentRepository,
 	MediaRepository,
+	PluginStorageRepository,
+	UserRepository,
+	OptionsRepository,
 	EmDashValidationError,
 	InvalidCursorError,
 } from "./database/repositories/index.js";
@@ -125,6 +128,8 @@ export type {
 	ResolvePathResult,
 	TranslationSummary,
 	TranslationsResult,
+	WhereRange,
+	WhereValue,
 } from "./query.js";
 
 // Request context (ALS-based ambient state for query functions)
@@ -198,7 +203,11 @@ export {
 	// Sandbox
 	NoopSandboxRunner,
 	SandboxNotAvailableError,
+	SandboxUnavailableError,
 	createNoopSandboxRunner,
+	// HTTP access for plugins (shared between in-process, Cloudflare, and workerd runners)
+	createHttpAccess,
+	createUnrestrictedHttpAccess,
 } from "./plugins/index.js";
 export type {
 	PluginDefinition,

package/src/loader.ts

@@ -20,7 +20,7 @@ import { decodeCursor, encodeCursor } from "./database/repositories/types.js";
 import { validateIdentifier } from "./database/validate.js";
 import type { Database } from "./index.js";
 import { getRequestContext } from "./request-context.js";
-import { isMissingTableError } from "./utils/db-errors.js";
+import { isMissingColumnError, isMissingTableError } from "./utils/db-errors.js";
 
 const FIELD_NAME_PATTERN = /^[a-zA-Z_][a-zA-Z0-9_]*$/;
 
@@ -311,10 +311,12 @@ function buildStatusCondition(
 		const scheduledAtExpr = isPostgres(db)
 			? sql`${sql.ref(scheduledAtField)}::timestamptz`
 			: sql.ref(scheduledAtField);
-		return sql`(${sql.ref(statusField)} = 'published' OR (${sql.ref(statusField)} = 'scheduled' AND ${scheduledAtExpr} <= ${currentTimestampValue(db)}))`;
+		const nowExpr = isPostgres(db)
+			? currentTimestampValue(db)
+			: sql`strftime('%Y-%m-%dT%H:%M:%fZ', 'now')`;
+		return sql`(${sql.ref(statusField)} = 'published' OR (${sql.ref(statusField)} = 'scheduled' AND ${scheduledAtExpr} <= ${nowExpr}))`;
 	}
 
-	// For other statuses (draft, archived), just match exactly
 	return sql`${sql.ref(statusField)} = ${status}`;
 }
 
@@ -408,6 +410,65 @@ function buildCursorCondition(
 	return sql`(${sql.ref(primary.field)} > ${orderValue} OR (${sql.ref(primary.field)} = ${orderValue} AND ${sql.ref(idField)} > ${cursorId}))`;
 }
 
+/** Type guard: is the where value a range object (not a string or array)? */
+function isWhereRange(value: WhereValue): value is WhereRange {
+	return value !== null && typeof value === "object" && !Array.isArray(value);
+}
+
+/**
+ * Build AND conditions for non-taxonomy field filters.
+ * Returns an array of sql fragments; empty if no field filters apply.
+ * Field names are validated against FIELD_NAME_PATTERN to prevent injection.
+ */
+function buildFieldConditions(
+	fields: Record<string, WhereValue>,
+	tablePrefix?: string,
+): ReturnType<typeof sql>[] {
+	const conditions: ReturnType<typeof sql>[] = [];
+
+	for (const [key, value] of Object.entries(fields)) {
+		if (!FIELD_NAME_PATTERN.test(key)) {
+			console.warn(`[emdash] where filter: invalid field name "${key}" ignored`);
+			continue;
+		}
+		if (value == null) continue;
+		const ref = tablePrefix ? sql.ref(`${tablePrefix}.${key}`) : sql.ref(key);
+
+		if (isWhereRange(value)) {
+			if (value.gt !== undefined) conditions.push(sql`${ref} > ${value.gt}`);
+			if (value.gte !== undefined) conditions.push(sql`${ref} >= ${value.gte}`);
+			if (value.lt !== undefined) conditions.push(sql`${ref} < ${value.lt}`);
+			if (value.lte !== undefined) conditions.push(sql`${ref} <= ${value.lte}`);
+		} else if (Array.isArray(value)) {
+			if (value.length > 0) {
+				conditions.push(sql`${ref} IN (${sql.join(value.map((v) => sql`${v}`))})`);
+			}
+		} else {
+			conditions.push(sql`${ref} = ${value}`);
+		}
+	}
+
+	return conditions;
+}
+
+/**
+ * Range filter for comparison operators on field values.
+ * Values are compared as strings in the database. This works correctly for
+ * ISO 8601 dates (e.g. "2024-01-01T00:00:00Z") because lexicographic ordering
+ * matches chronological ordering. Ensure date values use a consistent format.
+ */
+export interface WhereRange {
+	gt?: string;
+	gte?: string;
+	lt?: string;
+	lte?: string;
+}
+
+/**
+ * A where clause value: exact match, multi-value match, or range comparison.
+ */
+export type WhereValue = string | string[] | WhereRange;
+
 /**
  * Filter for loadCollection - type is required
  */
@@ -421,9 +482,16 @@ export interface CollectionFilter {
 	 */
 	cursor?: string;
 	/**
-	 * Filter by field values or taxonomy terms
+	 * Filter by field values, taxonomy terms, or ranges.
+	 *
+	 * Taxonomy names are detected automatically and filtered via JOIN.
+	 * Other keys are treated as column filters on the content table.
+	 *
+	 * @example { category: 'news' } - taxonomy term
+	 * @example { series: 'main' } - exact match on a content field
+	 * @example { published_at: { gte: '2024-01-01', lt: '2025-01-01' } } - date range
 	 */
-	where?: Record<string, string | string[]>;
+	where?: Record<string, WhereValue>;
 	/**
 	 * Order results by field(s)
 	 * @default { created_at: "desc" }
@@ -471,7 +539,7 @@ export async function getDb(): Promise<Kysely<Database>> {
 	// Per-request DB override via ALS (normal mode)
 	const ctx = getRequestContext();
 	if (ctx?.db) {
-		return ctx.db as Kysely<Database>; // eslint-disable-line typescript-eslint(no-unsafe-type-assertion) -- db is typed as unknown in RequestContext to avoid circular deps
+		return ctx.db as Kysely<Database>; // eslint-disable-line typescript/no-unsafe-type-assertion -- db is typed as unknown in RequestContext to avoid circular deps
 	}
 
 	if (!dbInstance) {
@@ -551,79 +619,81 @@ export function emdashLoader(): LiveLoader<EntryData, EntryFilter, CollectionFil
 					? buildCursorCondition(cursor, orderBy, tableName)
 					: null;
 
-				// Check if we need taxonomy filtering
+				// Separate taxonomy filters from field filters
 				let result: { rows: Record<string, unknown>[] };
+				let taxonomyFilter: { name: string; slugs: string[] } | null = null;
+				const fieldFilters: Record<string, WhereValue> = {};
 
 				if (where && Object.keys(where).length > 0) {
-					// Get taxonomy names to detect taxonomy filters
 					const taxNames = await getTaxonomyNames(db);
-					const taxonomyFilters: Record<string, string | string[]> = {};
 
 					for (const [key, value] of Object.entries(where)) {
+						if (value == null) continue;
 						if (taxNames.has(key)) {
-							taxonomyFilters[key] = value;
+							if (isWhereRange(value)) {
+								console.warn(
+									`[emdash] where filter: range operators are not supported on taxonomy "${key}", ignored`,
+								);
+								continue;
+							}
+							if (taxonomyFilter) {
+								console.warn(
+									`[emdash] where filter: only one taxonomy is supported per query, "${key}" ignored`,
+								);
+								continue;
+							}
+							const slugs = Array.isArray(value) ? value : [value];
+							taxonomyFilter = { name: key, slugs };
+						} else {
+							fieldFilters[key] = value;
 						}
 					}
+				}
 
-					// If we have taxonomy filters, use JOIN
-					if (Object.keys(taxonomyFilters).length > 0) {
-						// Build query with taxonomy JOIN
-						// For now, support single taxonomy filter (can extend later for multiple)
-						const [taxName, termSlugs] = Object.entries(taxonomyFilters)[0];
-						const slugs = Array.isArray(termSlugs) ? termSlugs : [termSlugs];
-						const orderByClause = buildOrderByClause(orderBy, tableName);
-
-						const statusCondition = buildStatusCondition(db, status, tableName);
-						const localeCondition = locale
-							? sql`AND ${sql.ref(tableName)}.locale = ${locale}`
-							: sql``;
-						const cursorCond = cursorConditionPrefixed
-							? sql`AND ${cursorConditionPrefixed}`
-							: sql``;
-						result = await sql<Record<string, unknown>>`
-							SELECT DISTINCT ${sql.ref(tableName)}.* FROM ${sql.ref(tableName)}
-							INNER JOIN content_taxonomies ct
-								ON ct.collection = ${type}
-								AND ct.entry_id = ${sql.ref(tableName)}.id
-							INNER JOIN taxonomies t
-								ON t.id = ct.taxonomy_id
-							WHERE ${sql.ref(tableName)}.deleted_at IS NULL
-								AND ${statusCondition}
-								${localeCondition}
-								${cursorCond}
-								AND t.name = ${taxName}
-								AND t.slug IN (${sql.join(slugs.map((s) => sql`${s}`))})
-							${orderByClause}
-							${fetchLimit ? sql`LIMIT ${fetchLimit}` : sql``}
-						`.execute(db);
-					} else {
-						// No taxonomy filters, use simple query
-						const orderByClause = buildOrderByClause(orderBy);
-						const statusCondition = buildStatusCondition(db, status);
-						const localeFilter = locale ? sql`AND locale = ${locale}` : sql``;
-						const cursorCond = cursorCondition ? sql`AND ${cursorCondition}` : sql``;
-						result = await sql<Record<string, unknown>>`
-							SELECT * FROM ${sql.ref(tableName)}
-							WHERE deleted_at IS NULL
+				if (taxonomyFilter) {
+					const orderByClause = buildOrderByClause(orderBy, tableName);
+					const statusCondition = buildStatusCondition(db, status, tableName);
+					const localeCondition = locale
+						? sql`AND ${sql.ref(tableName)}.locale = ${locale}`
+						: sql``;
+					const cursorCond = cursorConditionPrefixed ? sql`AND ${cursorConditionPrefixed}` : sql``;
+					const fieldConds = buildFieldConditions(fieldFilters, tableName);
+					const fieldCondsSQL =
+						fieldConds.length > 0 ? sql`${sql.join(fieldConds, sql` AND `)}` : null;
+
+					result = await sql<Record<string, unknown>>`
+						SELECT DISTINCT ${sql.ref(tableName)}.* FROM ${sql.ref(tableName)}
+						INNER JOIN content_taxonomies ct
+							ON ct.collection = ${type}
+							AND ct.entry_id = ${sql.ref(tableName)}.id
+						INNER JOIN taxonomies t
+							ON t.id = ct.taxonomy_id
+						WHERE ${sql.ref(tableName)}.deleted_at IS NULL
 							AND ${statusCondition}
-							${localeFilter}
+							${localeCondition}
 							${cursorCond}
-							${orderByClause}
-							${fetchLimit ? sql`LIMIT ${fetchLimit}` : sql``}
-						`.execute(db);
-					}
+							AND t.name = ${taxonomyFilter.name}
+							AND t.slug IN (${sql.join(taxonomyFilter.slugs.map((s) => sql`${s}`))})
+							${fieldCondsSQL ? sql`AND ${fieldCondsSQL}` : sql``}
+						${orderByClause}
+						${fetchLimit ? sql`LIMIT ${fetchLimit}` : sql``}
+					`.execute(db);
 				} else {
-					// No where clause, use simple query
 					const orderByClause = buildOrderByClause(orderBy);
 					const statusCondition = buildStatusCondition(db, status);
 					const localeFilter = locale ? sql`AND locale = ${locale}` : sql``;
 					const cursorCond = cursorCondition ? sql`AND ${cursorCondition}` : sql``;
+					const fieldConds = buildFieldConditions(fieldFilters);
+					const fieldCondsSQL =
+						fieldConds.length > 0 ? sql`${sql.join(fieldConds, sql` AND `)}` : null;
+
 					result = await sql<Record<string, unknown>>`
 						SELECT * FROM ${sql.ref(tableName)}
 						WHERE deleted_at IS NULL
 						AND ${statusCondition}
 						${localeFilter}
 						${cursorCond}
+						${fieldCondsSQL ? sql`AND ${fieldCondsSQL}` : sql``}
 						${orderByClause}
 						${fetchLimit ? sql`LIMIT ${fetchLimit}` : sql``}
 					`.execute(db);
@@ -693,13 +763,17 @@ export function emdashLoader(): LiveLoader<EntryData, EntryFilter, CollectionFil
 					},
 				};
 			} catch (error) {
-				// Handle missing table gracefully - return empty collection.
-				// This happens before migrations have run.
-				if (isMissingTableError(error)) {
+				// Handle missing table/column gracefully - return empty collection.
+				// Missing table happens before migrations have run.
+				// Missing column happens when a where filter references a non-existent field.
+				const message = error instanceof Error ? error.message : String(error);
+				if (isMissingTableError(error) || isMissingColumnError(error)) {
+					if (isMissingColumnError(error)) {
+						console.warn(`[emdash] where filter: ${message}`);
+					}
 					return { entries: [] };
 				}
 
-				const message = error instanceof Error ? error.message : String(error);
 				return {
 					error: new Error(`Failed to load collection: ${message}`),
 				};

package/src/mcp/server.ts

@@ -511,12 +511,12 @@ export function createMcpServer(): McpServer {
 			if (result.success && !canReadDrafts(extra)) {
 				const data =
 					result.data && typeof result.data === "object"
-						? // eslint-disable-next-line typescript-eslint(no-unsafe-type-assertion) -- handler returns unknown data; narrowed by typeof check
+						? // eslint-disable-next-line typescript/no-unsafe-type-assertion -- handler returns unknown data; narrowed by typeof check
 							(result.data as Record<string, unknown>)
 						: undefined;
 				const item =
 					data?.item && typeof data.item === "object"
-						? // eslint-disable-next-line typescript-eslint(no-unsafe-type-assertion) -- narrowed by typeof check
+						? // eslint-disable-next-line typescript/no-unsafe-type-assertion -- narrowed by typeof check
 							(data.item as Record<string, unknown>)
 						: undefined;
 				const status = typeof item?.status === "string" ? item.status : null;
@@ -1140,7 +1140,7 @@ export function createMcpServer(): McpServer {
 			if (result.success && !canReadDrafts(extra)) {
 				const data =
 					result.data && typeof result.data === "object"
-						? // eslint-disable-next-line typescript-eslint(no-unsafe-type-assertion) -- handler returns unknown data; narrowed by typeof check
+						? // eslint-disable-next-line typescript/no-unsafe-type-assertion -- handler returns unknown data; narrowed by typeof check
 							(result.data as Record<string, unknown>)
 						: undefined;
 				const translations = Array.isArray(data?.translations) ? data.translations : [];

package/src/media/mime.ts

@@ -1,5 +1,5 @@
 export function normalizeMime(mime: string): string {
-	return mime.split(";")[0]!.trim().toLowerCase();
+	return mime.split(";")[0].trim().toLowerCase();
 }
 
 export function matchesMimeAllowlist(mime: string, allowList: readonly string[]): boolean {

package/src/page/absolute-url.ts

@@ -44,7 +44,7 @@ const OTHER_SCHEME_RE = /^[a-z][a-z0-9+.-]*:/i;
  * exploitable, plus more pathological shapes like leading newlines that
  * could inject across header boundaries downstream.
  */
-// eslint-disable-next-line eslint(no-control-regex) -- intentional: rejecting control chars is the whole point of this regex
+// eslint-disable-next-line no-control-regex -- intentional: rejecting control chars is the whole point of this regex
 const WHITESPACE_OR_CONTROL_RE = /[\s\u0000-\u001f\u007f-\u009f]/;
 const TRAILING_SLASH_RE = /\/$/;
 

package/src/plugin-utils.ts

@@ -8,6 +8,16 @@
  * Import as: `import { apiFetch, parseApiResponse, isRecord } from "emdash/plugin-utils";`
  */
 
+import type { EmDashHandlers } from "./astro/types.js";
+
+export type PublicPluginApiRouteHandler = EmDashHandlers["handlePublicPluginApiRoute"];
+
+export interface PublicPluginRuntimeLocals {
+	emdash?: {
+		handlePublicPluginApiRoute?: PublicPluginApiRouteHandler;
+	};
+}
+
 /**
  * Fetch wrapper that adds the `X-EmDash-Request` CSRF protection header.
  *
@@ -20,6 +30,19 @@ export function apiFetch(input: string | URL | Request, init?: RequestInit): Pro
 	return fetch(input, { ...init, headers });
 }
 
+/**
+ * Get the public-only plugin route dispatcher exposed to SSR page components.
+ *
+ * This intentionally reads `handlePublicPluginApiRoute`, not the raw
+ * `handlePluginApiRoute` used by core's authenticated plugin API route.
+ */
+export function getPublicPluginApiRouteHandler(
+	locals: PublicPluginRuntimeLocals | null | undefined,
+): PublicPluginApiRouteHandler | undefined {
+	const handler = locals?.emdash?.handlePublicPluginApiRoute;
+	return typeof handler === "function" ? handler : undefined;
+}
+
 /**
  * Parse an API response, unwrapping the `{ data: T }` envelope.
  *

package/src/plugins/adapt-sandbox-entry.ts

@@ -11,7 +11,7 @@
  */
 
 import type { PluginDescriptor } from "../astro/integration/runtime.js";
-import type { SandboxedPlugin } from "../plugin-types.js";
+import type { RouteEntry, RouteHandler, SandboxedPlugin } from "../plugin-types.js";
 import { PLUGIN_CAPABILITIES, HOOK_NAMES } from "./manifest-schema.js";
 import { normalizeCapabilities } from "./types.js";
 import type {
@@ -96,6 +96,31 @@ function resolveSandboxedHook(entry: AnyHookEntry, pluginId: string): ResolvedHo
 	};
 }
 
+/**
+ * Normalise a `RouteEntry` (bare handler or `{ handler, public?, input? }`
+ * config) to the config form. The `input` schema is intentionally typed
+ * `unknown` in `RouteEntry` — sandboxed plugins describe it loosely
+ * because the strict `z.ZodType<TInput>` constraint of the runtime's
+ * `PluginRoute` only narrows once the route is wired into the router.
+ * The wider type flows through to the runtime which validates at
+ * invocation time.
+ */
+function normalizeRouteEntry(entry: RouteEntry): {
+	handler: RouteHandler;
+	public?: boolean;
+	input?: PluginRoute["input"];
+} {
+	if (typeof entry === "function") {
+		return { handler: entry };
+	}
+	return {
+		handler: entry.handler,
+		public: entry.public,
+		// eslint-disable-next-line typescript-eslint/no-unsafe-type-assertion -- RouteEntry.input is intentionally `unknown` (sandboxed plugins) and validated by the runtime at invocation time
+		input: entry.input as PluginRoute["input"],
+	};
+}
+
 const VALID_CAPABILITIES_SET = new Set<string>(PLUGIN_CAPABILITIES);
 
 const VALID_HOOK_NAMES_SET = new Set<string>(HOOK_NAMES);
@@ -136,9 +161,13 @@ export function adaptSandboxEntry(
 	// Resolve hooks. `SandboxedPlugin.hooks` is keyed by hook name with
 	// per-key entry types; iterating with `Object.entries` collapses
 	// keys to `string`, so we treat each entry as the union `AnyHookEntry`
-	// for the duration of the loop.
+	// for the duration of the loop. The widening from the strict mapped
+	// type to a plain record is sound because each entry still matches
+	// one of the bare-handler / config-object shapes captured by
+	// `AnyHookEntry`.
 	const resolvedHooks: ResolvedPluginHooks = {};
 	if (definition.hooks) {
+		// eslint-disable-next-line typescript-eslint/no-unsafe-type-assertion -- widening the strict mapped type to a string-keyed record for iteration; entries still match AnyHookEntry
 		const hookMap = definition.hooks as Record<string, AnyHookEntry>;
 		for (const [hookName, entry] of Object.entries(hookMap)) {
 			if (!VALID_HOOK_NAMES_SET.has(hookName)) {
@@ -166,49 +195,25 @@ export function adaptSandboxEntry(
 	const resolvedRoutes: Record<string, PluginRoute> = {};
 	if (definition.routes) {
 		for (const [routeName, rawEntry] of Object.entries(definition.routes)) {
-			const isConfig = typeof rawEntry === "object" && rawEntry !== null && "handler" in rawEntry;
-			const handler = isConfig
-				? (rawEntry as { handler: (...args: unknown[]) => Promise<unknown> }).handler
-				: (rawEntry as (...args: unknown[]) => Promise<unknown>);
-			const publicFlag = isConfig ? (rawEntry as { public?: boolean }).public : undefined;
-			const inputSchema = isConfig ? (rawEntry as { input?: unknown }).input : undefined;
+			const normalized = normalizeRouteEntry(rawEntry);
+			const { handler, public: publicFlag, input: inputSchema } = normalized;
 			resolvedRoutes[routeName] = {
-				// eslint-disable-next-line @typescript-eslint/no-unsafe-type-assertion -- route entry.input is intentionally loosely typed; callers validate at runtime
-				input: inputSchema as PluginRoute["input"],
+				input: inputSchema,
 				public: publicFlag,
 				handler: async (ctx) => {
-					// In-process, `ctx.request` is a real WHATWG `Request`
-					// with a `Headers` object. The author-facing
-					// `SandboxedRequest` type promises a plain
-					// `Record<string, string>` (the shape the sandbox's
-					// serialised form delivers). Normalise so handlers
-					// behave the same in-process and in-isolate.
+					// `ctx.request` is a real WHATWG `Request` (this is the
+					// in-process adapter; the worker-sandbox adapter handles
+					// the serialised case). Flatten `Headers` to the plain
+					// `Record<string, string>` shape that author-facing
+					// `SandboxedRequest` promises so handler bodies are
+					// identical across both adapters.
 					const headers: Record<string, string> = {};
-					if (ctx.request && typeof ctx.request === "object") {
-						const h: unknown = (ctx.request as { headers?: unknown }).headers;
-						if (h && typeof h === "object") {
-							if (typeof (h as Headers).forEach === "function") {
-								(h as Headers).forEach((value, name) => {
-									headers[name] = value;
-								});
-							} else {
-								for (const [name, value] of Object.entries(h as Record<string, string>)) {
-									headers[name] = value;
-								}
-							}
-						}
-					}
+					ctx.request.headers.forEach((value, name) => {
+						headers[name] = value;
+					});
 					const requestShape = {
-						url:
-							(ctx.request as { url?: unknown } | undefined)?.url &&
-							typeof (ctx.request as { url: unknown }).url === "string"
-								? (ctx.request as { url: string }).url
-								: "",
-						method:
-							(ctx.request as { method?: unknown } | undefined)?.method &&
-							typeof (ctx.request as { method: unknown }).method === "string"
-								? (ctx.request as { method: string }).method
-								: "GET",
+						url: ctx.request.url,
+						method: ctx.request.method,
 						headers,
 					};
 					const routeCtx = {

package/src/plugins/email-console.ts

@@ -33,7 +33,7 @@ export interface StoredEmail {
 const GLOBAL_KEY = Symbol.for("emdash:dev-emails");
 const g = globalThis as Record<symbol, unknown>;
 const storedEmails: StoredEmail[] = (() => {
-	// eslint-disable-next-line typescript-eslint(no-unsafe-type-assertion) -- globalThis singleton pattern (see request-context.ts)
+	// eslint-disable-next-line typescript/no-unsafe-type-assertion -- globalThis singleton pattern (see request-context.ts)
 	const existing = g[GLOBAL_KEY] as StoredEmail[] | undefined;
 	if (existing) return existing;
 	const fresh: StoredEmail[] = [];