emdash 0.22.0 → 0.24.0

package/src/media/local-runtime.ts

@@ -29,6 +29,14 @@ export interface LocalMediaRuntimeConfig {
 	enabled?: boolean;
 	// These are injected by the runtime, not from user config
 	db?: Kysely<Database>;
+	/**
+	 * Resolver for the live connection, preferred over `db`. The runtime
+	 * injects it so a connection-backed adapter (Postgres over Hyperdrive)
+	 * serves provider queries from the current request-scoped connection in ALS
+	 * rather than a snapshot of the per-isolate singleton. Omitted for stateless
+	 * adapters (D1, Node SQLite), where `db` is used directly.
+	 */
+	getDb?: () => Kysely<Database>;
 	storage?: Storage;
 }
 
@@ -42,11 +50,15 @@ export const createMediaProvider: CreateMediaProviderFn<LocalMediaRuntimeConfig>
 		throw new Error("Local media provider requires database connection");
 	}
 
-	const repo = new MediaRepository(db);
+	// Resolve the connection per operation (not captured once) so a
+	// connection-backed adapter uses the current event-scoped connection; falls
+	// back to the injected `db` for stateless adapters.
+	const resolveDb = config.getDb ?? (() => db);
+	const repo = () => new MediaRepository(resolveDb());
 
 	const provider: MediaProvider = {
 		async list(options: MediaListOptions) {
-			const result = await repo.findMany({
+			const result = await repo().findMany({
 				cursor: options.cursor,
 				limit: options.limit,
 				mimeType: options.mimeType,
@@ -75,7 +87,7 @@ export const createMediaProvider: CreateMediaProviderFn<LocalMediaRuntimeConfig>
 		},
 
 		async get(id: string) {
-			const item = await repo.findById(id);
+			const item = await repo().findById(id);
 			if (!item) return null;
 
 			return {
@@ -108,7 +120,8 @@ export const createMediaProvider: CreateMediaProviderFn<LocalMediaRuntimeConfig>
 		},
 
 		async delete(id: string) {
-			const item = await repo.findById(id);
+			const repoInstance = repo();
+			const item = await repoInstance.findById(id);
 			if (!item) return;
 
 			// Delete from storage if available
@@ -120,7 +133,7 @@ export const createMediaProvider: CreateMediaProviderFn<LocalMediaRuntimeConfig>
 				}
 			}
 
-			await repo.delete(id);
+			await repoInstance.delete(id);
 
 			// If this row was referenced by `logo`, `favicon`, or
 			// `seo.defaultOgImage`, the worker-scoped settings cache now

package/src/plugins/context.ts

@@ -432,23 +432,55 @@ export function createMediaAccess(db: Kysely<Database>): MediaAccess {
 
 /**
  * Create full media access with write operations.
- * If storage is not provided, upload() will throw at call time.
+ *
+ * `getUploadUrlFn` is optional: when omitted, `getUploadUrl()` is derived from
+ * `storage` (create a pending record + a signed PUT URL), mirroring the REST
+ * `/_emdash/api/media/upload-url` endpoint. `upload()` only needs `storage`.
+ * If storage is not provided, both throw at call time.
  */
 export function createMediaAccessWithWrite(
 	db: Kysely<Database>,
-	getUploadUrlFn: (
-		filename: string,
-		contentType: string,
-	) => Promise<{ uploadUrl: string; mediaId: string }>,
+	getUploadUrlFn:
+		| ((filename: string, contentType: string) => Promise<{ uploadUrl: string; mediaId: string }>)
+		| undefined,
 	storage?: Storage,
 ): MediaAccessWithWrite {
 	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 basename = filename.split("/").pop() ?? filename;
+			const dotIdx = basename.lastIndexOf(".");
+			const ext = dotIdx > 0 ? basename.slice(dotIdx).toLowerCase() : "";
+			const storageKey = `${ulid()}${ext}`;
+
+			const media = await mediaRepo.createPending({
+				filename: basename,
+				mimeType: contentType,
+				storageKey,
+			});
+
+			const signed = await storage.getSignedUploadUrl({
+				key: storageKey,
+				contentType,
+				expiresIn: 3600,
+			});
+
+			return { uploadUrl: signed.url, mediaId: media.id };
+		});
+
 	return {
 		...readAccess,
 
-		getUploadUrl: getUploadUrlFn,
+		getUploadUrl,
 
 		async upload(
 			filename: string,
@@ -836,14 +868,26 @@ export function createUserAccess(db: Kysely<Database>): UserAccess {
 
 export interface PluginContextFactoryOptions {
 	db: Kysely<Database>;
+	/**
+	 * Resolver for the database connection, preferred over `db` when present.
+	 * Called per `createContext()` so connection-backed adapters (e.g. Postgres
+	 * over Hyperdrive) get the current request/event-scoped connection from ALS
+	 * rather than a snapshot of the per-isolate singleton — reusing the
+	 * singleton's socket from a later event trips workerd's cross-request I/O
+	 * guard. When omitted, `db` is used directly (correct for stateless
+	 * adapters like D1 and Node SQLite). `db` remains required as the fallback.
+	 */
+	getDb?: () => Kysely<Database>;
 	/**
 	 * Storage backend for direct media uploads.
 	 * If not provided, upload() will throw.
 	 */
 	storage?: Storage;
 	/**
-	 * Function to generate upload URLs for media.
-	 * If not provided, media write operations will throw.
+	 * Explicit provider for `ctx.media.getUploadUrl()`. Optional: when omitted
+	 * but `storage` is configured, the factory derives a working `getUploadUrl()`
+	 * (and `upload()`) from storage. Only when neither `getUploadUrl` nor
+	 * `storage` is present do media write operations become unavailable.
 	 */
 	getUploadUrl?: (
 		filename: string,
@@ -877,8 +921,7 @@ export interface PluginContextFactoryOptions {
  * Factory for creating plugin contexts
  */
 export class PluginContextFactory {
-	private optionsRepo: OptionsRepository;
-	private db: Kysely<Database>;
+	private resolveDb: () => Kysely<Database>;
 	private storage?: Storage;
 	private getUploadUrl?: (
 		filename: string,
@@ -888,10 +931,16 @@ export class PluginContextFactory {
 	private urlHelper: (path: string) => string;
 	private cronReschedule?: () => void;
 	private emailPipeline?: EmailPipeline;
+	/**
+	 * Plugin IDs already warned about a missing media-write backend, so the
+	 * warning fires once per factory instead of on every hook/route context
+	 * creation (which would spam logs for hook-participating plugins).
+	 */
+	private warnedMissingMediaBackend = new Set<string>();
 
 	constructor(options: PluginContextFactoryOptions) {
-		this.db = options.db;
-		this.optionsRepo = new OptionsRepository(options.db);
+		const fixedDb = options.db;
+		this.resolveDb = options.getDb ?? (() => fixedDb);
 		this.storage = options.storage;
 		this.getUploadUrl = options.getUploadUrl;
 		this.site = createSiteInfo(options.siteInfo ?? {});
@@ -906,10 +955,17 @@ export class PluginContextFactory {
 	createContext(plugin: ResolvedPlugin): PluginContext {
 		const capabilities = new Set(plugin.capabilities);
 
+		// Resolve the connection once per context. For stateless adapters this
+		// is the singleton; for connection-backed adapters it's the current
+		// request/event-scoped connection from ALS. All repos below are built
+		// from this local `db` so a hook never queries a stale singleton socket.
+		const db = this.resolveDb();
+		const optionsRepo = new OptionsRepository(db);
+
 		// Always available
-		const kv = createKVAccess(this.optionsRepo, plugin.id);
+		const kv = createKVAccess(optionsRepo, plugin.id);
 		const log = createLogAccess(plugin.id);
-		const storage = createStorageAccess(this.db, plugin.id, plugin.storage);
+		const storage = createStorageAccess(db, plugin.id, plugin.storage);
 
 		// Capability-gated: content
 		// Note: capabilities reach this point already normalized to the
@@ -917,17 +973,33 @@ export class PluginContextFactory {
 		// names ("read:content", "write:content") never appear here.
 		let content: ContentAccess | ContentAccessWithWrite | undefined;
 		if (capabilities.has("content:write")) {
-			content = createContentAccessWithWrite(this.db);
+			content = createContentAccessWithWrite(db);
 		} else if (capabilities.has("content:read")) {
-			content = createContentAccess(this.db);
+			content = createContentAccess(db);
 		}
 
 		// Capability-gated: media
+		// `upload()` only needs `storage`; `getUploadUrl()` is derived from
+		// storage when no explicit provider is wired. Granting write access on
+		// either avoids silently degrading media:write to read-only — the bug
+		// where the runtime threads `storage` but not `getUploadUrl`.
 		let media: MediaAccess | MediaAccessWithWrite | undefined;
-		if (capabilities.has("media:write") && this.getUploadUrl) {
-			media = createMediaAccessWithWrite(this.db, this.getUploadUrl, this.storage);
+		if (capabilities.has("media:write")) {
+			if (this.getUploadUrl || this.storage) {
+				media = createMediaAccessWithWrite(db, this.getUploadUrl, this.storage);
+			} else {
+				if (!this.warnedMissingMediaBackend.has(plugin.id)) {
+					this.warnedMissingMediaBackend.add(plugin.id);
+					log.warn(
+						"declares the media:write capability but no storage backend is configured; upload() is unavailable.",
+					);
+				}
+				if (capabilities.has("media:read")) {
+					media = createMediaAccess(db);
+				}
+			}
 		} else if (capabilities.has("media:read")) {
-			media = createMediaAccess(this.db);
+			media = createMediaAccess(db);
 		}
 
 		// Capability-gated: http
@@ -941,14 +1013,14 @@ export class PluginContextFactory {
 		// Capability-gated: users
 		let users: UserAccess | undefined;
 		if (capabilities.has("users:read")) {
-			users = createUserAccess(this.db);
+			users = createUserAccess(db);
 		}
 
-		// Cron access ��� always available (scoped to plugin), but only if
+		// Cron access — always available (scoped to plugin), but only if
 		// the runtime provided a reschedule callback (i.e. cron is wired up).
 		let cron: CronAccess | undefined;
 		if (this.cronReschedule) {
-			cron = new CronAccessImpl(this.db, plugin.id, this.cronReschedule);
+			cron = new CronAccessImpl(db, plugin.id, this.cronReschedule);
 		}
 
 		// Email access — requires email:send capability AND a configured provider

package/src/plugins/cron.ts

@@ -39,10 +39,26 @@ export type RescheduleFn = () => void;
  * Stateless — all state lives in the database.
  */
 export class CronExecutor {
+	/**
+	 * Resolves the database connection to use for this tick. A resolver (not a
+	 * captured instance) so connection-backed adapters work across events: on
+	 * Cloudflare the `scheduled()` handler installs an event-scoped connection
+	 * in ALS, and this resolves to it instead of the per-isolate singleton
+	 * whose socket belongs to an earlier request. Accepts a plain `Kysely` too
+	 * (wrapped in a constant resolver) for callers/tests that don't need ALS.
+	 */
+	private readonly resolveDb: () => Kysely<Database>;
+
 	constructor(
-		private db: Kysely<Database>,
+		db: Kysely<Database> | (() => Kysely<Database>),
 		private invokeCronHook: InvokeCronHookFn,
-	) {}
+	) {
+		this.resolveDb = typeof db === "function" ? db : () => db;
+	}
+
+	private get db(): Kysely<Database> {
+		return this.resolveDb();
+	}
 
 	/**
 	 * Process all overdue tasks.

package/src/plugins/routes.ts

@@ -12,6 +12,42 @@ import { PluginContextFactory, type PluginContextFactoryOptions } from "./contex
 import { extractRequestMeta } from "./request-meta.js";
 import type { ResolvedPlugin, RouteContext, PluginRoute } from "./types.js";
 
+/**
+ * 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
+ * stream consumed. Calling any of these on `ctx.request` would re-read a spent
+ * stream and throw an opaque platform error ("Body is unusable: Body has already
+ * been read") with no hint about `ctx.input` — so the guard replaces them with an
+ * actionable message instead (#1293).
+ */
+const CONSUMED_BODY_METHODS = new Set(["json", "text", "arrayBuffer", "blob", "formData", "bytes"]);
+
+/**
+ * Wrap the request handed to a plugin route handler so an accidental
+ * `ctx.request.json()` (or `.text()`, `.formData()`, …) fails with a message
+ * pointing at `ctx.input` rather than the runtime's cryptic "body already read"
+ * error. Every non-body member passes through unchanged; function members are
+ * bound to the underlying request so methods like `clone()` don't throw an
+ * "Illegal invocation" when called on the proxy.
+ */
+function guardConsumedRequestBody(request: Request): Request {
+	return new Proxy(request, {
+		get(target, prop) {
+			if (typeof prop === "string" && CONSUMED_BODY_METHODS.has(prop)) {
+				return () => {
+					throw new Error(
+						`[emdash] ctx.request.${prop}() is not available inside a plugin route handler: ` +
+							`EmDash has already parsed the request body and exposes it as ctx.input. ` +
+							`Read ctx.input instead of ctx.request.${prop}().`,
+					);
+				};
+			}
+			const value = Reflect.get(target, prop, target);
+			return typeof value === "function" ? value.bind(target) : value;
+		},
+	});
+}
+
 /**
  * Route metadata (public flag) without the handler.
  * Used by the catch-all route to decide auth before dispatch.
@@ -100,7 +136,10 @@ export class PluginRouteHandler {
 		const routeContext: RouteContext = {
 			...baseContext,
 			input: validatedInput,
-			request: options.request,
+			// The body is already parsed into `input`; guard `ctx.request`'s
+			// body-reading methods so a re-read fails with an actionable message
+			// (#1293). Metadata extraction uses the original request (headers only).
+			request: guardConsumedRequestBody(options.request),
 			requestMeta: extractRequestMeta(options.request, this.trustedProxyHeaders),
 		};
 

package/src/query.ts

@@ -26,7 +26,13 @@
 
 import { encodeCursor } from "./database/repositories/types.js";
 import { getFallbackChain, getI18nConfig, isI18nEnabled } from "./i18n/config.js";
-import { CURSOR_RAW_VALUES, type WhereRange, type WhereValue } from "./loader.js";
+import {
+	CURSOR_RAW_VALUES,
+	FOLDED_BYLINES,
+	FOLDED_TERMS,
+	type WhereRange,
+	type WhereValue,
+} from "./loader.js";
 import {
 	cachedQuery,
 	contentNamespaces,
@@ -34,6 +40,7 @@ import {
 } from "./object-cache/index.js";
 import { requestCached } from "./request-cache.js";
 import { getRequestContext } from "./request-context.js";
+import type { TaxonomyTerm } from "./taxonomies/types.js";
 import { isMissingTableError } from "./utils/db-errors.js";
 import {
 	createEditable,
@@ -89,22 +96,17 @@ export type OrderBySpec = Record<string, SortDirection>;
 
 export type { WhereRange, WhereValue };
 
-export interface CollectionFilter {
+/**
+ * Fields shared by every collection query, independent of pagination mode.
+ *
+ * Cursor and offset pagination are mutually exclusive, so they live on the
+ * `CursorCollectionFilter` / `OffsetCollectionFilter` variants rather than
+ * here. Use the {@link CollectionFilter} union for any value that may be
+ * either.
+ */
+export interface CollectionFilterBase {
 	status?: "draft" | "published" | "archived";
 	limit?: number;
-	/**
-	 * Opaque cursor for keyset pagination.
-	 * Pass the `nextCursor` value from a previous result to fetch the next page.
-	 * @example
-	 * ```ts
-	 * const cursor = Astro.url.searchParams.get("cursor") ?? undefined;
-	 * const { entries, nextCursor } = await getEmDashCollection("posts", {
-	 *   limit: 10,
-	 *   cursor,
-	 * });
-	 * ```
-	 */
-	cursor?: string;
 	/**
 	 * Filter by field values, taxonomy terms, byline credits, or ranges.
 	 *
@@ -140,6 +142,56 @@ export interface CollectionFilter {
 	locale?: string;
 }
 
+/** Keyset-paginated query filter. Cannot also carry an `offset`. */
+export interface CursorCollectionFilter extends CollectionFilterBase {
+	/**
+	 * Opaque cursor for keyset pagination.
+	 * Pass the `nextCursor` value from a previous result to fetch the next page.
+	 * @example
+	 * ```ts
+	 * const cursor = Astro.url.searchParams.get("cursor") ?? undefined;
+	 * const { entries, nextCursor } = await getEmDashCollection("posts", {
+	 *   limit: 10,
+	 *   cursor,
+	 * });
+	 * ```
+	 */
+	cursor?: string;
+	offset?: never;
+}
+
+/** Offset-paginated query filter. Cannot also carry a `cursor`. */
+export interface OffsetCollectionFilter extends CollectionFilterBase {
+	/**
+	 * Skip this many entries before returning results (offset pagination).
+	 *
+	 * Use with `limit` to render numbered archive routes like `/page/2`
+	 * without walking cursors or over-fetching from the start:
+	 *
+	 * ```ts
+	 * const perPage = 20;
+	 * const { entries, hasMore } = await getEmDashCollection("posts", {
+	 *   limit: perPage,
+	 *   offset: (page - 1) * perPage,
+	 *   orderBy: { published_at: "desc" },
+	 * });
+	 * ```
+	 *
+	 * Only a positive integer applies.
+	 */
+	offset?: number;
+	cursor?: never;
+}
+
+/**
+ * Filter for `getEmDashCollection`.
+ *
+ * A union of the cursor and offset pagination variants: supplying both
+ * `cursor` and `offset` is a compile-time error, since they are mutually
+ * exclusive ways to express "the next page" (cursor wins at runtime).
+ */
+export type CollectionFilter = CursorCollectionFilter | OffsetCollectionFilter;
+
 export interface ContentEntry<T = Record<string, unknown>> {
 	id: string;
 	data: T;
@@ -169,6 +221,12 @@ export interface CollectionResult<T> {
 	 * Pass this as `cursor` in the next query to get the next page.
 	 */
 	nextCursor?: string;
+	/**
+	 * Whether more entries exist beyond this page. Set whenever `limit` is
+	 * provided (cursor or offset pagination), so numbered archive routes can
+	 * render a "next page" link without computing a total count.
+	 */
+	hasMore?: boolean;
 }
 
 /**
@@ -343,6 +401,7 @@ export async function getEmDashCollection<T extends string, D = InferCollectionD
 interface CachedCollectionValue {
 	entries: unknown[];
 	nextCursor?: string;
+	hasMore?: boolean;
 	cacheHint: CacheHint;
 }
 
@@ -370,6 +429,7 @@ async function loadCollectionCached<T extends string, D = InferCollectionData<T>
 				value: {
 					entries: result.entries.map(entrySnapshot),
 					nextCursor: result.nextCursor,
+					hasMore: result.hasMore,
 					cacheHint: result.cacheHint,
 				},
 			};
@@ -383,6 +443,7 @@ async function loadCollectionCached<T extends string, D = InferCollectionData<T>
 	return {
 		entries: snapshot.value.entries.map((entry) => reviveEntry<D>(entry)),
 		nextCursor: snapshot.value.nextCursor,
+		hasMore: snapshot.value.hasMore,
 		cacheHint: snapshot.value.cacheHint,
 	};
 }
@@ -410,7 +471,10 @@ export function bucketFilter(filter: CollectionFilter | undefined): BucketedFilt
 		limit === undefined ||
 		limit >= BUCKET_LIMIT_THRESHOLD ||
 		limit <= 0 ||
-		filter?.cursor !== undefined
+		filter?.cursor !== undefined ||
+		// Offset paginates a deliberate page window; its limit is part of the
+		// pagination contract, so don't round it up the way "recent N" widgets get.
+		filter?.offset !== undefined
 	) {
 		return { fetchFilter: filter, requestedLimit: undefined };
 	}
@@ -442,7 +506,8 @@ export function sliceCollectionResult<D>(
 	// buildCursorCondition in loader.ts — it filters strictly past this row.
 	const lastEntry = sliced.at(-1);
 	const nextCursor = lastEntry ? encodeEntryCursor(lastEntry, orderBy) : undefined;
-	return { ...cached, entries: sliced, nextCursor };
+	// Truncating to the requested limit means at least one more entry existed.
+	return { ...cached, entries: sliced, nextCursor, hasMore: true };
 }
 
 /** Map of database column names to camelCase keys present on entry.data. */
@@ -526,6 +591,7 @@ function collectionCacheKey(type: string, filter?: CollectionFilter): string {
 		filter.status ?? "",
 		filter.limit ?? "",
 		filter.cursor ?? "",
+		filter.offset ?? "",
 		filter.where ? stableStringify(filter.where) : "",
 		filter.orderBy ? JSON.stringify(filter.orderBy) : "",
 		filter.locale ?? "",
@@ -626,11 +692,19 @@ async function getEmDashCollectionUncached<T extends string, D = InferCollection
 		filter?.locale ?? ctx?.locale ?? (isI18nEnabled() ? i18nConfig!.defaultLocale : undefined);
 
 	const requestedLimit = filter?.limit;
+	// cursor and offset are mutually exclusive on the loader filter union, so
+	// spread only the one in play (cursor wins) rather than emitting both keys.
+	const pageParam =
+		filter?.cursor !== undefined
+			? { cursor: filter.cursor }
+			: filter?.offset !== undefined
+				? { offset: filter.offset }
+				: {};
 	const result = await getLiveCollection(COLLECTION_NAME, {
 		type,
 		status: filter?.status,
 		limit: requestedLimit && requestedLimit > 0 ? requestedLimit + 1 : filter?.limit,
-		cursor: filter?.cursor,
+		...pageParam,
 		where: filter?.where,
 		orderBy: filter?.orderBy,
 		locale: resolvedLocale,
@@ -645,6 +719,9 @@ async function getEmDashCollectionUncached<T extends string, D = InferCollection
 	const hasMore = requestedLimit != null && requestedLimit > 0 && entries.length > requestedLimit;
 	const pageEntries = hasMore ? entries.slice(0, requestedLimit) : entries;
 	const nextCursor = hasMore ? encodeEntryCursor(pageEntries.at(-1), filter?.orderBy) : undefined;
+	// `hasMore` is only meaningful when a limit bounds the page; otherwise the
+	// query returned everything and there is no "next page" to report.
+	const hasMoreResult = requestedLimit != null && requestedLimit > 0 ? hasMore : undefined;
 
 	const isEditMode = ctx?.editMode ?? false;
 	const entriesWithEdit = pageEntries.map((entry: ContentEntry<D>) => {
@@ -668,7 +745,12 @@ async function getEmDashCollectionUncached<T extends string, D = InferCollection
 		hydrateEntryTerms(type, entriesWithEdit, resolvedLocale),
 	]);
 
-	return { entries: entriesWithEdit, nextCursor, cacheHint: cacheHint ?? {} };
+	return {
+		entries: entriesWithEdit,
+		nextCursor,
+		hasMore: hasMoreResult,
+		cacheHint: cacheHint ?? {},
+	};
 }
 
 /**
@@ -930,6 +1012,67 @@ interface CachedEntryValue {
 async function hydrateEntryBylines<D>(type: string, entries: ContentEntry<D>[]): Promise<void> {
 	if (entries.length === 0) return;
 
+	// Fast path: bylines were folded into the content query. Parse the JSON
+	// (no extra round trip) for the common case — explicit credits, no byline
+	// custom fields, no author fallback. The query path below handles the rest:
+	//  - author fallback (entry has authorId but no explicit credit), and
+	//  - custom byline fields (can't be expressed in the folded subquery).
+	if (entries.every((e) => FOLDED_BYLINES in entryData(e))) {
+		const parsed = entries.map((entry) => {
+			const data = entryData(entry);
+			const folded = Reflect.get(data, FOLDED_BYLINES);
+			const rows = Array.isArray(folded) ? folded : [];
+			const credits = rows
+				.map((raw) => {
+					const b = raw?.byline ?? {};
+					return {
+						roleLabel: raw?.roleLabel ?? null,
+						sortOrder: Number(raw?.sortOrder ?? 0),
+						source: "explicit" as const,
+						byline: { ...b, isGuest: Boolean(b.isGuest), customFields: {} },
+					};
+				})
+				.toSorted((a, b) => a.sortOrder - b.sortOrder);
+			return { data, credits };
+		});
+
+		// Fall back to the full query path when the fold can't be trusted to be
+		// complete: an entry with a byline reference (explicit primary, or an
+		// author for the author-fallback) but no folded credits — e.g. a credit
+		// in a different locale than the row, which the locale-correlated subquery
+		// skips, or the author-fallback path which the fold doesn't express.
+		let needsQueryPath = parsed.some(
+			(p) =>
+				p.credits.length === 0 &&
+				(dataStr(p.data, "authorId") !== "" || dataStr(p.data, "primaryBylineId") !== ""),
+		);
+		let hasCustomFields = false;
+		if (!needsQueryPath) {
+			try {
+				const { getDb } = await import("./loader.js");
+				const db = await getDb();
+				const { getBylineFieldDefs } = await import("./bylines/field-defs-cache.js");
+				hasCustomFields = (await getBylineFieldDefs(db)).length > 0;
+			} catch (error) {
+				// A missing table is expected pre-migration and means there are no
+				// custom fields — the fold's values are complete. Any other error
+				// (lock-init failure, dialect error) means the probe can't be
+				// trusted, so fall back to the query path rather than risk serving
+				// folded bylines with empty customFields.
+				if (!isMissingTableError(error)) needsQueryPath = true;
+			}
+		}
+
+		if (!needsQueryPath && !hasCustomFields) {
+			for (const p of parsed) {
+				p.data.bylines = p.credits;
+				p.data.byline = p.credits[0]?.byline ?? null;
+			}
+			return;
+		}
+		// Fall through to the full query path for fallback / custom-field cases.
+	}
+
 	try {
 		const { getBylinesForEntries } = await import("./bylines/index.js");
 
@@ -1005,6 +1148,45 @@ async function hydrateEntryTerms<D>(
 ): Promise<void> {
 	if (entries.length === 0) return;
 
+	// Fast path: terms were folded into the content query. Group the JSON and
+	// skip the separate content_taxonomies query.
+	if (entries.every((e) => FOLDED_TERMS in entryData(e))) {
+		const perEntry: Array<{ entryId: string; byTaxonomy: Record<string, TaxonomyTerm[]> }> = [];
+		for (const entry of entries) {
+			const data = entryData(entry);
+			const folded = Reflect.get(data, FOLDED_TERMS);
+			const rows = Array.isArray(folded) ? folded : [];
+			const grouped: Record<string, TaxonomyTerm[]> = {};
+			for (const r of rows) {
+				const name = String(r?.name);
+				(grouped[name] ??= []).push({
+					id: r?.id,
+					name,
+					slug: r?.slug,
+					label: r?.label,
+					parentId: r?.parent_id ?? undefined,
+					children: [],
+					locale: r?.locale,
+					translationGroup: r?.translation_group,
+				});
+			}
+			// Match getAllTermsForEntries' ORDER BY label (dropped from the
+			// aggregate since SQLite and Postgres order it differently).
+			for (const [name, arr] of Object.entries(grouped)) {
+				grouped[name] = arr.toSorted((a, b) => String(a.label).localeCompare(String(b.label)));
+			}
+			data.terms = grouped;
+			const entryId = dataStr(data, "id");
+			if (entryId) perEntry.push({ entryId, byTaxonomy: grouped });
+		}
+		// Prime the per-entry request cache (wildcard + present taxonomies) so
+		// subsequent getEntryTerms(...) calls in this render hit the cache instead
+		// of issuing an N+1 query. No DB lookup — purely from the folded data.
+		const { primeFoldedEntryTerms } = await import("./taxonomies/index.js");
+		primeFoldedEntryTerms(type, perEntry, { locale });
+		return;
+	}
+
 	try {
 		const { getAllTermsForEntries } = await import("./taxonomies/index.js");