emdash 0.15.0 → 0.16.1

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

@@ -35,13 +35,23 @@ export function portableTextToProsemirror(blocks: PortableTextBlock[]): ProseMir
 
 		// Check for list items
 		if (isTextBlock(block) && block.listItem) {
-			// Collect consecutive list items
+			// Collect a list "run": the level=1 anchor plus everything that
+			// nests under it (level > 1, regardless of listItem type — a number
+			// child under a bullet parent is still part of the same tree). A
+			// level=1 block with a different listItem ends the run. Without the
+			// `level > 1` carve-out the run breaks on the first nested type
+			// switch and the descendant subtree leaks out as its own top-level
+			// list (e.g. `[bullet L1, number L2, bullet L1]` would render as
+			// three sibling lists instead of one bullet list with a numbered
+			// child).
 			const listBlocks: PortableTextTextBlock[] = [];
 			const listType = block.listItem;
 
 			while (i < blocks.length) {
 				const current = blocks[i];
-				if (isTextBlock(current) && current.listItem === listType) {
+				if (!isTextBlock(current) || !current.listItem) break;
+				const level = current.level || 1;
+				if (level > 1 || current.listItem === listType) {
 					listBlocks.push(current);
 					i++;
 				} else {
@@ -230,20 +240,34 @@ function convertListItem(
 
 	// Handle nested items
 	if (nestedItems.length > 0) {
-		// Group nested items by their list type
-		let j = 0;
+		// The shallowest level in `nestedItems` is the effective root of this
+		// item's nested subtree. A new sub-list only starts when we hit
+		// another block at that root level with a different `listItem` type;
+		// deeper blocks (level > minLevel) belong to the current group as
+		// descendants regardless of their own `listItem`. The previous
+		// grouping broke on any type change at any depth, so a deep mixed
+		// tree like `bullet L1 → number L2 → bullet L3 → number L2` would
+		// emit C(L3) as a sibling list under A(L1) instead of nesting it
+		// under B(L2), then degrade C to L2 on round-trip.
+		let minLevel = Infinity;
+		for (const ni of nestedItems) {
+			const level = ni.level || 2;
+			if (level < minLevel) minLevel = level;
+		}
 
+		let j = 0;
 		while (j < nestedItems.length) {
-			const nestedListType = nestedItems[j].listItem || parentListType;
+			const anchorType: "bullet" | "number" = nestedItems[j].listItem || parentListType;
 			const nestedGroup: PortableTextTextBlock[] = [];
 
-			while (
-				j < nestedItems.length &&
-				(nestedItems[j].listItem || parentListType) === nestedListType
-			) {
+			do {
 				nestedGroup.push(nestedItems[j]);
 				j++;
-			}
+			} while (
+				j < nestedItems.length &&
+				((nestedItems[j].level || 2) > minLevel ||
+					(nestedItems[j].listItem || parentListType) === anchorType)
+			);
 
 			if (nestedGroup.length > 0) {
 				// Decrease level for nested conversion
@@ -251,7 +275,7 @@ function convertListItem(
 					...ni,
 					level: (ni.level || 2) - 1,
 				}));
-				content.push(convertList(adjustedGroup, nestedListType));
+				content.push(convertList(adjustedGroup, anchorType));
 			}
 		}
 	}

package/src/database/connection.ts

@@ -1,24 +1,17 @@
 import BetterSqlite3 from "better-sqlite3";
 import { Kysely, SqliteDialect } from "kysely";
 
+import { EmDashDatabaseError } from "./errors.js";
 import { kyselyLogOption } from "./instrumentation.js";
 import type { Database } from "./types.js";
 
+export { EmDashDatabaseError };
+
 export interface DatabaseConfig {
 	url: string;
 	authToken?: string;
 }
 
-export class EmDashDatabaseError extends Error {
-	constructor(
-		message: string,
-		public override cause?: unknown,
-	) {
-		super(message);
-		this.name = "EmDashDatabaseError";
-	}
-}
-
 /**
  * Returns a helpful, actionable message when better-sqlite3's native binary
  * was compiled against a different Node.js version than the one running. This

package/src/database/errors.ts

@@ -0,0 +1,14 @@
+/**
+ * Database error types. Kept in their own module (no driver imports) so the
+ * public package barrel can re-export them without dragging native database
+ * drivers into the module graph of consumers that picked a different dialect.
+ */
+export class EmDashDatabaseError extends Error {
+	constructor(
+		message: string,
+		public override cause?: unknown,
+	) {
+		super(message);
+		this.name = "EmDashDatabaseError";
+	}
+}

package/src/database/index.ts

@@ -1,4 +1,6 @@
-export { createDatabase, EmDashDatabaseError } from "./connection.js";
+// `createDatabase` is intentionally not re-exported here: it lives in
+// `connection.ts`, which statically imports `better-sqlite3`. See #947.
+export { EmDashDatabaseError } from "./errors.js";
 export type { DatabaseConfig } from "./connection.js";
 export { runMigrations, getMigrationStatus, rollbackMigration } from "./migrations/runner.js";
 export type { MigrationStatus } from "./migrations/runner.js";

package/src/database/migrations/runner.ts

@@ -107,16 +107,28 @@ export interface MigrationStatus {
 const MIGRATION_TABLE = "_emdash_migrations";
 const MIGRATION_LOCK_TABLE = "_emdash_migrations_lock";
 
-/**
- * Get migration status
- */
-export async function getMigrationStatus(db: Kysely<Database>): Promise<MigrationStatus> {
-	const migrator = new Migrator({
+export interface MigrationOptions {
+	migrationTableSchema?: string;
+}
+
+function createMigrator(db: Kysely<Database>, options?: MigrationOptions): Migrator {
+	return new Migrator({
 		db,
 		provider: new StaticMigrationProvider(),
 		migrationTableName: MIGRATION_TABLE,
 		migrationLockTableName: MIGRATION_LOCK_TABLE,
+		migrationTableSchema: options?.migrationTableSchema,
 	});
+}
+
+/**
+ * Get migration status
+ */
+export async function getMigrationStatus(
+	db: Kysely<Database>,
+	options?: MigrationOptions,
+): Promise<MigrationStatus> {
+	const migrator = createMigrator(db, options);
 
 	const migrations = await migrator.getMigrations();
 
@@ -274,24 +286,24 @@ function deepErrorMessage(error: unknown): string {
  * success. This matches the user-observable expectation that running
  * migrations twice in a row is a no-op.
  */
-export async function runMigrations(db: Kysely<Database>): Promise<{ applied: string[] }> {
+export async function runMigrations(
+	db: Kysely<Database>,
+	options?: MigrationOptions,
+): Promise<{ applied: string[] }> {
 	// Fast path: check if all migrations are already applied.
 	// A single cheap query vs the Migrator's full schema introspection.
 	// We use `>=` rather than `===` so a database with extra rows from a
 	// newer build (e.g. mid-deploy old isolate, or downgrade) still skips
 	// the migrator instead of falling through to the race-recovery path
 	// unnecessarily.
-	const initialCount = await getAppliedMigrationCount(db);
-	if (initialCount !== null && initialCount >= MIGRATION_COUNT) {
-		return { applied: [] };
+	if (!options?.migrationTableSchema) {
+		const initialCount = await getAppliedMigrationCount(db);
+		if (initialCount !== null && initialCount >= MIGRATION_COUNT) {
+			return { applied: [] };
+		}
 	}
 
-	const migrator = new Migrator({
-		db,
-		provider: new StaticMigrationProvider(),
-		migrationTableName: MIGRATION_TABLE,
-		migrationLockTableName: MIGRATION_LOCK_TABLE,
-	});
+	const migrator = createMigrator(db, options);
 
 	const { error, results } = await migrator.migrateToLatest();
 
@@ -325,13 +337,9 @@ export async function runMigrations(db: Kysely<Database>): Promise<{ applied: st
  */
 export async function rollbackMigration(
 	db: Kysely<Database>,
+	options?: MigrationOptions,
 ): Promise<{ rolledBack: string | null }> {
-	const migrator = new Migrator({
-		db,
-		provider: new StaticMigrationProvider(),
-		migrationTableName: MIGRATION_TABLE,
-		migrationLockTableName: MIGRATION_LOCK_TABLE,
-	});
+	const migrator = createMigrator(db, options);
 
 	const { error, results } = await migrator.migrateDown();
 

package/src/emdash-runtime.ts

@@ -2048,6 +2048,7 @@ export class EmDashRuntime {
 		return {
 			version: VERSION,
 			commit: COMMIT,
+			astroVersion: this.config.astroVersion,
 			hash: manifestHash,
 			collections: manifestCollections,
 			plugins: manifestPlugins,

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

@@ -128,6 +128,8 @@ export type {
 	ResolvePathResult,
 	TranslationSummary,
 	TranslationsResult,
+	WhereRange,
+	WhereValue,
 } from "./query.js";
 
 // Request context (ALS-based ambient state for query functions)

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" }
@@ -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}`),
 				};