emdash 0.14.0 → 0.16.0

package/src/plugins/index.ts

@@ -67,6 +67,7 @@ export type { PluginManagerOptions, PluginState } from "./manager.js";
 export {
 	NoopSandboxRunner,
 	SandboxNotAvailableError,
+	SandboxUnavailableError,
 	createNoopSandboxRunner,
 } from "./sandbox/index.js";
 export type {

package/src/plugins/marketplace.ts

@@ -509,7 +509,7 @@ export async function extractBundle(tarballBytes: Uint8Array): Promise<PluginBun
 	}
 
 	// Compute SHA-256 checksum of the tarball for verification
-	// eslint-disable-next-line typescript-eslint(no-unsafe-type-assertion) -- Uint8Array is a valid BufferSource at runtime; TS lib mismatch
+	// eslint-disable-next-line typescript/no-unsafe-type-assertion -- Uint8Array is a valid BufferSource at runtime; TS lib mismatch
 	const hashBuffer = await crypto.subtle.digest("SHA-256", tarballBytes as unknown as BufferSource);
 	const hashArray = new Uint8Array(hashBuffer);
 	const checksum = Array.from(hashArray, (b) => b.toString(16).padStart(2, "0")).join("");

package/src/plugins/sandbox/index.ts

@@ -4,6 +4,7 @@
  */
 
 export { NoopSandboxRunner, SandboxNotAvailableError, createNoopSandboxRunner } from "./noop.js";
+export { SandboxUnavailableError } from "./types.js";
 
 export type {
 	SandboxRunner,

package/src/plugins/sandbox/noop.ts

@@ -15,9 +15,10 @@ import type { SandboxRunner, SandboxedPluginInstance, SandboxOptions } from "./t
 export class SandboxNotAvailableError extends Error {
 	constructor() {
 		super(
-			"Plugin sandboxing is not available on this platform. " +
-				"Sandboxed plugins require Cloudflare Workers with Worker Loader. " +
-				"Use trusted plugins (from config) instead, or deploy to Cloudflare.",
+			"Plugin sandboxing is not available. " +
+				"Configure a sandbox runner: use @emdash-cms/cloudflare/sandbox on Cloudflare, " +
+				"or @emdash-cms/sandbox-workerd/sandbox on Node.js (requires workerd). " +
+				"Without sandboxing, use trusted plugins (from config) instead.",
 		);
 		this.name = "SandboxNotAvailableError";
 	}
@@ -40,6 +41,13 @@ export class NoopSandboxRunner implements SandboxRunner {
 		return false;
 	}
 
+	/**
+	 * Always returns false - no sandbox runtime to be healthy.
+	 */
+	isHealthy(): boolean {
+		return false;
+	}
+
 	/**
 	 * Always throws - can't load sandboxed plugins without isolation.
 	 */

package/src/plugins/sandbox/types.ts

@@ -75,6 +75,15 @@ export interface SandboxOptions {
 	siteInfo?: { name: string; url: string; locale: string };
 	/** Email send callback, wired from the EmailPipeline by the runtime */
 	emailSend?: SandboxEmailSendCallback;
+	/**
+	 * Media storage adapter for sandboxed plugin uploads and deletes.
+	 * When provided, plugins with write:media can upload and delete files
+	 * via ctx.media.upload() and ctx.media.delete().
+	 */
+	mediaStorage?: {
+		upload(options: { key: string; body: Uint8Array; contentType: string }): Promise<unknown>;
+		delete(key: string): Promise<unknown>;
+	};
 }
 
 /**
@@ -137,6 +146,14 @@ export interface SandboxRunner {
 	 */
 	isAvailable(): boolean;
 
+	/**
+	 * Check if the sandbox runtime is currently healthy.
+	 * For in-process runners this always returns true.
+	 * For sidecar-based runners (workerd), returns false if the
+	 * child process has crashed and hasn't been restarted yet.
+	 */
+	isHealthy(): boolean;
+
 	/**
 	 * Load a sandboxed plugin from code.
 	 *
@@ -161,6 +178,17 @@ export interface SandboxRunner {
 	terminateAll(): Promise<void>;
 }
 
+/**
+ * Error thrown when the sandbox runtime is unavailable.
+ * This happens when the sidecar process has crashed or hasn't started.
+ */
+export class SandboxUnavailableError extends Error {
+	constructor(pluginId: string, reason: string) {
+		super(`Plugin sandbox unavailable for ${pluginId}: ${reason}`);
+		this.name = "SandboxUnavailableError";
+	}
+}
+
 /**
  * Factory function type for creating sandbox runners.
  * Exported by platform adapters (e.g., @emdash-cms/adapter-cloudflare/sandbox).

package/src/query.ts

@@ -26,7 +26,7 @@
 
 import { encodeCursor } from "./database/repositories/types.js";
 import { getFallbackChain, getI18nConfig, isI18nEnabled } from "./i18n/config.js";
-import { CURSOR_RAW_VALUES } from "./loader.js";
+import { CURSOR_RAW_VALUES, type WhereRange, type WhereValue } from "./loader.js";
 import { requestCached } from "./request-cache.js";
 import { getRequestContext } from "./request-context.js";
 import { isMissingTableError } from "./utils/db-errors.js";
@@ -82,6 +82,8 @@ export type SortDirection = "asc" | "desc";
  */
 export type OrderBySpec = Record<string, SortDirection>;
 
+export type { WhereRange, WhereValue };
+
 export interface CollectionFilter {
 	status?: "draft" | "published" | "archived";
 	limit?: number;
@@ -99,11 +101,17 @@ 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' } - Filter by taxonomy term
 	 * @example { category: ['news', 'featured'] } - Filter by multiple terms (OR)
+	 * @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" }
@@ -456,10 +464,21 @@ function collectionCacheKey(type: string, filter?: CollectionFilter): string {
 }
 
 function stableStringify(value: Record<string, unknown>): string {
+	return JSON.stringify(stableOrder(value));
+}
+
+function stableOrder(value: Record<string, unknown>): Record<string, unknown> {
 	const keys = Object.keys(value).toSorted();
 	const ordered: Record<string, unknown> = {};
-	for (const k of keys) ordered[k] = value[k];
-	return JSON.stringify(ordered);
+	for (const k of keys) {
+		const v = value[k];
+		if (isRecord(v)) {
+			ordered[k] = stableOrder(v);
+		} else {
+			ordered[k] = v;
+		}
+	}
+	return ordered;
 }
 
 async function getEmDashCollectionUncached<T extends string, D = InferCollectionData<T>>(
@@ -715,9 +734,24 @@ async function hydrateEntryBylines<D>(type: string, entries: ContentEntry<D>[]):
 			.map((e) => {
 				const data = entryData(e);
 				const id = dataStr(data, "id");
-				return id ? { id, authorId: dataStr(data, "authorId") || null } : null;
+				if (!id) return null;
+				return {
+					id,
+					authorId: dataStr(data, "authorId") || null,
+					primaryBylineId: dataStr(data, "primaryBylineId") || null,
+					locale: dataStr(data, "locale") || null,
+				};
 			})
-			.filter((r): r is { id: string; authorId: string | null } => r !== null);
+			.filter(
+				(
+					r,
+				): r is {
+					id: string;
+					authorId: string | null;
+					primaryBylineId: string | null;
+					locale: string | null;
+				} => r !== null,
+			);
 		if (refs.length === 0) return;
 
 		const bylinesMap = await getBylinesForEntries(type, refs);

package/src/registry/config.ts

@@ -130,7 +130,7 @@ export function parseDurationSeconds(duration: string | number): number {
 		);
 	}
 
-	const value = parseInt(match[1]!, 10);
+	const value = parseInt(match[1], 10);
 	const unit = match[2];
 
 	switch (unit) {

package/src/request-cache.ts

@@ -22,7 +22,7 @@ type CacheStore = WeakMap<EmDashRequestContext, Map<string, Promise<unknown>>>;
 const STORE_KEY = Symbol.for("emdash:request-cache");
 const g = globalThis as Record<symbol, unknown>;
 const store: CacheStore =
-	// 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)
 	(g[STORE_KEY] as CacheStore | undefined) ??
 	(() => {
 		const wm: CacheStore = new WeakMap();
@@ -50,7 +50,7 @@ export function requestCached<T>(key: string, fn: () => Promise<T>): Promise<T>
 	const existing = cache.get(key);
 	if (existing) {
 		if (ctx.metrics) ctx.metrics.cacheHits += 1;
-		// eslint-disable-next-line typescript-eslint(no-unsafe-type-assertion) -- heterogeneous cache; key namespacing guarantees the stored promise resolves to T
+		// eslint-disable-next-line typescript/no-unsafe-type-assertion -- heterogeneous cache; key namespacing guarantees the stored promise resolves to T
 		return existing as Promise<T>;
 	}
 	if (ctx.metrics) ctx.metrics.cacheMisses += 1;
@@ -80,7 +80,7 @@ export function peekRequestCache<T>(key: string): Promise<T> | undefined {
 	const ctx = getRequestContext();
 	if (!ctx) return undefined;
 	const cache = store.get(ctx);
-	// eslint-disable-next-line typescript-eslint(no-unsafe-type-assertion) -- heterogeneous cache; caller is responsible for using a T-compatible key
+	// eslint-disable-next-line typescript/no-unsafe-type-assertion -- heterogeneous cache; caller is responsible for using a T-compatible key
 	return cache?.get(key) as Promise<T> | undefined;
 }
 

package/src/request-context.ts

@@ -99,7 +99,7 @@ export interface EmDashRequestContext {
 const ALS_KEY = Symbol.for("emdash:request-context");
 
 const storage: AsyncLocalStorage<EmDashRequestContext> =
-	// eslint-disable-next-line typescript-eslint(no-unsafe-type-assertion) -- globalThis singleton pattern
+	// eslint-disable-next-line typescript/no-unsafe-type-assertion -- globalThis singleton pattern
 	((globalThis as Record<symbol, unknown>)[ALS_KEY] as
 		| AsyncLocalStorage<EmDashRequestContext>
 		| undefined) ??

package/src/settings/index.ts

@@ -44,7 +44,7 @@ interface SiteSettingsHolder {
 const SITE_SETTINGS_CACHE_KEY = Symbol.for("emdash:site-settings");
 const g = globalThis as Record<symbol, unknown>;
 const holder: SiteSettingsHolder =
-	// 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)
 	(g[SITE_SETTINGS_CACHE_KEY] as SiteSettingsHolder | undefined) ??
 	(() => {
 		const h: SiteSettingsHolder = { version: 0, cached: null, cachedVersion: -1 };
@@ -174,19 +174,19 @@ export async function getSiteSettingWithDb<K extends SiteSettingKey>(
 	// We use the non-generic getSiteSettingsWithDb for media resolution instead.
 	if ((key === "logo" || key === "favicon") && isMediaReference(value)) {
 		const resolved = await resolveMediaReference(value, db, storage);
-		// eslint-disable-next-line typescript-eslint(no-unsafe-type-assertion) -- TS can't narrow generic K from key equality; resolved type is correct
+		// eslint-disable-next-line typescript/no-unsafe-type-assertion -- TS can't narrow generic K from key equality; resolved type is correct
 		return resolved as SiteSettings[K] | undefined;
 	}
 
 	if (key === "seo" && value && typeof value === "object") {
-		// eslint-disable-next-line typescript-eslint(no-unsafe-type-assertion) -- TS can't narrow generic K from key equality
+		// eslint-disable-next-line typescript/no-unsafe-type-assertion -- TS can't narrow generic K from key equality
 		const seo = value as SeoSettings;
 		if (seo.defaultOgImage) {
 			const resolved = {
 				...seo,
 				defaultOgImage: await resolveMediaReference(seo.defaultOgImage, db, storage),
 			};
-			// eslint-disable-next-line typescript-eslint(no-unsafe-type-assertion) -- TS can't narrow generic K from key equality
+			// eslint-disable-next-line typescript/no-unsafe-type-assertion -- TS can't narrow generic K from key equality
 			return resolved as SiteSettings[K] | undefined;
 		}
 	}

package/src/storage/local.ts

@@ -121,7 +121,7 @@ export class LocalStorage implements Storage {
 			// Convert Node.js stream to web ReadableStream
 			// Readable.toWeb returns ReadableStream (which is ReadableStream<unknown>),
 			// but Node ReadStreams produce Buffer/Uint8Array chunks
-			// eslint-disable-next-line typescript-eslint(no-unsafe-type-assertion) -- Readable.toWeb returns ReadableStream<unknown>; Node ReadStreams produce Uint8Array chunks
+			// eslint-disable-next-line typescript/no-unsafe-type-assertion -- Readable.toWeb returns ReadableStream<unknown>; Node ReadStreams produce Uint8Array chunks
 			const webStream: ReadableStream<Uint8Array> = Readable.toWeb(
 				nodeStream,
 			) as ReadableStream<Uint8Array>;

package/src/storage/s3.ts

@@ -134,7 +134,7 @@ export class S3Storage implements Storage {
 
 		// S3ClientConfig types `credentials` as required, but the SDK accepts
 		// omitted credentials at runtime (falls back to the provider chain).
-		/* eslint-disable typescript-eslint(no-unsafe-type-assertion) -- upstream @aws-sdk/client-s3 overstates required fields */
+		/* eslint-disable typescript/no-unsafe-type-assertion -- upstream @aws-sdk/client-s3 overstates required fields */
 		const clientConfig = {
 			endpoint: config.endpoint,
 			region: config.region || "auto",
@@ -149,7 +149,7 @@ export class S3Storage implements Storage {
 					}
 				: {}),
 		} as S3ClientConfig;
-		/* eslint-enable typescript-eslint(no-unsafe-type-assertion) */
+		/* eslint-enable typescript/no-unsafe-type-assertion */
 		this.client = new S3Client(clientConfig);
 	}
 
@@ -260,7 +260,7 @@ export class S3Storage implements Storage {
 
 	async list(options: ListOptions = {}): Promise<ListResult> {
 		try {
-			// eslint-disable-next-line typescript-eslint(no-unsafe-type-assertion) -- S3 client.send returns generic output; narrowing to ListObjectsV2Response
+			// eslint-disable-next-line typescript/no-unsafe-type-assertion -- S3 client.send returns generic output; narrowing to ListObjectsV2Response
 			const response = (await this.client.send(
 				new ListObjectsV2Command({
 					Bucket: this.bucket,

package/src/utils/db-errors.ts

@@ -22,6 +22,30 @@ function messageOf(error: unknown): string {
 	return "";
 }
 
+/**
+ * Returns true when `error` is a "column does not exist" error.
+ * Used to handle where filters that reference non-existent field names
+ * gracefully (return empty results) instead of propagating a SQL error.
+ */
+export function isMissingColumnError(error: unknown): boolean {
+	const message = messageOf(error);
+	if (!message) return false;
+
+	// SQLite / D1: "no such column: foo"
+	if (message.includes("no such column")) return true;
+
+	// PostgreSQL SQLSTATE 42703: 'column "foo" does not exist'
+	// Exclude "relation" to avoid false positives on table names containing "column"
+	if (
+		message.includes("does not exist") &&
+		message.includes("column") &&
+		!message.includes("relation")
+	)
+		return true;
+
+	return false;
+}
+
 /**
  * Returns true when `error` is a "table does not exist" error across the
  * dialects EmDash supports (D1/SQLite and PostgreSQL). Used by runtime

package/src/widgets/index.ts

@@ -55,7 +55,7 @@ export async function getWidgetArea(name: string): Promise<WidgetArea | null> {
 		// they're all non-null once w_id is (we match on widgets.area_id, so
 		// a widget row always has the not-null columns filled). Cast is the
 		// price of that structural fact.
-		// eslint-disable-next-line typescript-eslint(no-unsafe-type-assertion) -- left-join row is non-null when w_id is set; see above
+		// eslint-disable-next-line typescript/no-unsafe-type-assertion -- left-join row is non-null when w_id is set; see above
 		const widgetRow = {
 			id: row.w_id,
 			type: row.w_type,