emdash 0.8.0 → 0.10.0

package/src/plugins/define-plugin.ts

@@ -13,6 +13,7 @@
  *
  */
 
+import { normalizeCapabilities } from "./types.js";
 import type {
 	PluginDefinition,
 	ResolvedPlugin,
@@ -20,6 +21,7 @@ import type {
 	ResolvedPluginHooks,
 	ResolvedHook,
 	HookConfig,
+	PluginCapability,
 	PluginStorageConfig,
 	StandardPluginDefinition,
 } from "./types.js";
@@ -65,7 +67,7 @@ const SEMVER_PATTERN = /^\d+\.\d+\.\d+/;
  * export default definePlugin({
  *   id: "my-plugin",
  *   version: "1.0.0",
- *   capabilities: ["read:content"],
+ *   capabilities: ["content:read"],
  *   hooks: {
  *     "content:beforeSave": async (event, ctx) => {
  *       ctx.log.info("Saving content", { collection: event.collection });
@@ -143,8 +145,24 @@ function defineNativePlugin<TStorage extends PluginStorageConfig>(
 		throw new Error(`Invalid plugin version "${version}". Must be semver format (e.g., "1.0.0").`);
 	}
 
-	// Validate capabilities
-	const validCapabilities = new Set([
+	// Validate capabilities. Both current names and deprecated aliases are
+	// accepted; aliases are silently rewritten to current names below so the
+	// runtime only ever sees the canonical form. Authors are warned at
+	// bundle/validate and hard-failed at publish.
+	const validCapabilities = new Set<string>([
+		// Current names
+		"network:request",
+		"network:request:unrestricted",
+		"content:read",
+		"content:write",
+		"media:read",
+		"media:write",
+		"users:read",
+		"email:send",
+		"hooks.email-transport:register",
+		"hooks.email-events:register",
+		"hooks.page-fragments:register",
+		// Deprecated aliases
 		"network:fetch",
 		"network:fetch:any",
 		"read:content",
@@ -152,7 +170,6 @@ function defineNativePlugin<TStorage extends PluginStorageConfig>(
 		"read:media",
 		"write:media",
 		"read:users",
-		"email:send",
 		"email:provide",
 		"email:intercept",
 		"page:inject",
@@ -163,16 +180,27 @@ function defineNativePlugin<TStorage extends PluginStorageConfig>(
 		}
 	}
 
-	// Capability implications: broader capabilities imply narrower ones
-	const normalizedCapabilities = [...capabilities];
-	if (capabilities.includes("write:content") && !capabilities.includes("read:content")) {
-		normalizedCapabilities.push("read:content");
+	// Silent normalization: rewrite deprecated names to current names. Done
+	// before the implication pass so implications work on canonical names.
+	// `as PluginCapability[]` is safe because `normalizeCapabilities` only
+	// returns strings from the validated input plus current names from the
+	// rename map, all of which are in the union.
+	const canonical = normalizeCapabilities(capabilities) as PluginCapability[];
+
+	// Capability implications: broader capabilities imply narrower ones.
+	// Operates on canonical names only.
+	const normalizedCapabilities: PluginCapability[] = [...canonical];
+	if (canonical.includes("content:write") && !canonical.includes("content:read")) {
+		normalizedCapabilities.push("content:read");
 	}
-	if (capabilities.includes("write:media") && !capabilities.includes("read:media")) {
-		normalizedCapabilities.push("read:media");
+	if (canonical.includes("media:write") && !canonical.includes("media:read")) {
+		normalizedCapabilities.push("media:read");
 	}
-	if (capabilities.includes("network:fetch:any") && !capabilities.includes("network:fetch")) {
-		normalizedCapabilities.push("network:fetch");
+	if (
+		canonical.includes("network:request:unrestricted") &&
+		!canonical.includes("network:request")
+	) {
+		normalizedCapabilities.push("network:request");
 	}
 
 	// Normalize hooks

package/src/plugins/hooks.ts

@@ -248,28 +248,32 @@ export class HookPipeline {
 	 * capability will have that hook silently skipped at registration time.
 	 */
 	private static readonly HOOK_REQUIRED_CAPABILITY: ReadonlyMap<string, string> = new Map([
-		// Email
-		["email:beforeSend", "email:intercept"],
-		["email:afterSend", "email:intercept"],
-		["email:deliver", "email:provide"],
-		// Content — beforeSave can mutate content, so requires write:content.
-		// afterSave is read-only notification, so read:content suffices.
-		["content:beforeSave", "write:content"],
-		["content:afterSave", "read:content"],
-		["content:beforeDelete", "read:content"],
-		["content:afterDelete", "read:content"],
-		["content:afterPublish", "read:content"],
-		["content:afterUnpublish", "read:content"],
+		// Email — registering email:beforeSend/afterSend/deliver requires the
+		// matching `hooks.email-*:register` capability. These are distinct
+		// from `email:send` (which gates ctx.email) so that "this plugin
+		// reads/writes email events" is visible separately from "this
+		// plugin can send email".
+		["email:beforeSend", "hooks.email-events:register"],
+		["email:afterSend", "hooks.email-events:register"],
+		["email:deliver", "hooks.email-transport:register"],
+		// Content — beforeSave can mutate content, so requires content:write.
+		// afterSave is read-only notification, so content:read suffices.
+		["content:beforeSave", "content:write"],
+		["content:afterSave", "content:read"],
+		["content:beforeDelete", "content:read"],
+		["content:afterDelete", "content:read"],
+		["content:afterPublish", "content:read"],
+		["content:afterUnpublish", "content:read"],
 		// Media
-		["media:beforeUpload", "write:media"],
-		["media:afterUpload", "read:media"],
+		["media:beforeUpload", "media:write"],
+		["media:afterUpload", "media:read"],
 		// Comments — hooks expose author email, IP hash, user agent
-		["comment:beforeCreate", "read:users"],
-		["comment:moderate", "read:users"],
-		["comment:afterCreate", "read:users"],
-		["comment:afterModerate", "read:users"],
+		["comment:beforeCreate", "users:read"],
+		["comment:moderate", "users:read"],
+		["comment:afterCreate", "users:read"],
+		["comment:afterModerate", "users:read"],
 		// Page fragments — can inject arbitrary scripts into every public page
-		["page:fragments", "page:inject"],
+		["page:fragments", "hooks.page-fragments:register"],
 	]);
 
 	/**

package/src/plugins/index.ts

@@ -192,3 +192,12 @@ export type {
 	StandardRouteEntry,
 } from "./types.js";
 export { isStandardPluginDefinition } from "./types.js";
+
+// Capability normalization (legacy → canonical alias layer)
+export {
+	CAPABILITY_RENAMES,
+	isDeprecatedCapability,
+	normalizeCapability,
+	normalizeCapabilities,
+} from "./types.js";
+export type { CurrentPluginCapability, DeprecatedPluginCapability } from "./types.js";

package/src/plugins/manifest-schema.ts

@@ -12,7 +12,31 @@ import { z } from "zod";
 
 // ── Enum values (must stay in sync with types.ts) ───────────────
 
-export const PLUGIN_CAPABILITIES = [
+/**
+ * Current capability names — the ones authors should use going forward.
+ * See `PluginCapability` in `types.ts` for documentation of each.
+ */
+export const CURRENT_PLUGIN_CAPABILITIES = [
+	"network:request",
+	"network:request:unrestricted",
+	"content:read",
+	"content:write",
+	"media:read",
+	"media:write",
+	"users:read",
+	"email:send",
+	"hooks.email-transport:register",
+	"hooks.email-events:register",
+	"hooks.page-fragments:register",
+] as const;
+
+/**
+ * Legacy capability names accepted during the deprecation window.
+ * Normalized to current names via `normalizeCapability()` in types.ts
+ * before reaching the runtime. Plugin authors are warned at bundle/validate
+ * and hard-failed at publish.
+ */
+export const DEPRECATED_PLUGIN_CAPABILITIES = [
 	"network:fetch",
 	"network:fetch:any",
 	"read:content",
@@ -20,12 +44,23 @@ export const PLUGIN_CAPABILITIES = [
 	"read:media",
 	"write:media",
 	"read:users",
-	"email:send",
 	"email:provide",
 	"email:intercept",
 	"page:inject",
 ] as const;
 
+/**
+ * Full set of accepted capability strings — current + deprecated.
+ *
+ * The manifest schema accepts both during the transition. The runtime only
+ * ever sees current names because `normalizeCapability()` rewrites legacy
+ * names at every external boundary (definePlugin, adaptSandboxEntry).
+ */
+export const PLUGIN_CAPABILITIES = [
+	...CURRENT_PLUGIN_CAPABILITIES,
+	...DEPRECATED_PLUGIN_CAPABILITIES,
+] as const;
+
 /** Must stay in sync with FieldType in schema/types.ts */
 const FIELD_TYPES = [
 	"string",

package/src/plugins/types.ts

@@ -20,20 +20,151 @@ import type { FieldType } from "../schema/types.js";
 // =============================================================================
 
 /**
- * Plugin capabilities determine what APIs are available in context
+ * Plugin capabilities determine what APIs are available in context.
+ *
+ * Capabilities follow the formula `<resource>[.<sub-resource>]:<verb>[:<qualifier>]`
+ * — resource first, verb second, matching RBAC. The `unrestricted` qualifier
+ * (used by `network:request:unrestricted`) is intentionally verbose so that
+ * granting it stands out in manifest review.
+ *
+ * Hook-registration capabilities (`hooks.<family>:register`) are a distinct
+ * audit category from data-access capabilities — they gate which hooks a
+ * plugin is allowed to register, not which context APIs it gets.
+ *
+ * @see CAPABILITY_RENAMES for the legacy → current mapping, and
+ *      `normalizeCapability()` for the runtime alias layer.
  */
 export type PluginCapability =
-	| "network:fetch" // ctx.http is available (host-restricted via allowedHosts)
-	| "network:fetch:any" // ctx.http is available (unrestricted outbound — use for user-configured URLs)
-	| "read:content" // ctx.content.get/list available
-	| "write:content" // ctx.content.create/update/delete available
-	| "read:media" // ctx.media.get/list available
-	| "write:media" // ctx.media.getUploadUrl/delete available
-	| "read:users" // ctx.users is available
+	// ── Network ─────────────────────────────────────────────────
+	| "network:request" // ctx.http is available (host-restricted via allowedHosts)
+	| "network:request:unrestricted" // ctx.http is available (unrestricted outbound — use for user-configured URLs)
+	// ── Content ─────────────────────────────────────────────────
+	| "content:read" // ctx.content.get/list available
+	| "content:write" // ctx.content.create/update/delete available
+	// ── Media ───────────────────────────────────────────────────
+	| "media:read" // ctx.media.get/list available
+	| "media:write" // ctx.media.getUploadUrl/delete available
+	// ── Users ───────────────────────────────────────────────────
+	| "users:read" // ctx.users is available
+	// ── Email ───────────────────────────────────────────────────
 	| "email:send" // ctx.email is available (when a provider is configured)
-	| "email:provide" // can register email:deliver exclusive hook (transport provider)
-	| "email:intercept" // can register email:beforeSend / email:afterSend hooks
-	| "page:inject"; // can register page:fragments hook (inject scripts/styles into pages)
+	// ── Hook registration ───────────────────────────────────────
+	| "hooks.email-transport:register" // can register email:deliver exclusive hook (transport provider)
+	| "hooks.email-events:register" // can register email:beforeSend / email:afterSend hooks
+	| "hooks.page-fragments:register" // can register page:fragments hook (inject scripts/styles into pages)
+	// ── Deprecated (legacy aliases) ─────────────────────────────
+	// Kept in the union for one minor with @deprecated tags so existing
+	// plugins typecheck during migration. Normalized to current names at
+	// definition time via normalizeCapability(). Will be removed in the
+	// following minor.
+	/** @deprecated Use `network:request` instead. */
+	| "network:fetch"
+	/** @deprecated Use `network:request:unrestricted` instead. */
+	| "network:fetch:any"
+	/** @deprecated Use `content:read` instead. */
+	| "read:content"
+	/** @deprecated Use `content:write` instead. */
+	| "write:content"
+	/** @deprecated Use `media:read` instead. */
+	| "read:media"
+	/** @deprecated Use `media:write` instead. */
+	| "write:media"
+	/** @deprecated Use `users:read` instead. */
+	| "read:users"
+	/** @deprecated Use `hooks.email-transport:register` instead. */
+	| "email:provide"
+	/** @deprecated Use `hooks.email-events:register` instead. */
+	| "email:intercept"
+	/** @deprecated Use `hooks.page-fragments:register` instead. */
+	| "page:inject";
+
+/**
+ * Deprecated capability names that map to current names.
+ *
+ * These are accepted at every external boundary (manifest parse, definePlugin,
+ * adaptSandboxEntry) and silently normalized to the new names before reaching
+ * the runtime. The runtime never sees deprecated names.
+ *
+ * Authors are warned at `bundle` / `validate`, and hard-failed at `publish`.
+ */
+export type DeprecatedPluginCapability =
+	| "network:fetch"
+	| "network:fetch:any"
+	| "read:content"
+	| "write:content"
+	| "read:media"
+	| "write:media"
+	| "read:users"
+	| "email:provide"
+	| "email:intercept"
+	| "page:inject";
+
+/**
+ * Current (non-deprecated) capability names.
+ */
+export type CurrentPluginCapability = Exclude<PluginCapability, DeprecatedPluginCapability>;
+
+/**
+ * Mapping from deprecated capability names to their current replacements.
+ *
+ * Used by `normalizeCapability()` and the marketplace `diffCapabilities`
+ * helper to compare manifests across the rename without flagging spurious
+ * "capability changed" prompts on upgrade.
+ */
+export const CAPABILITY_RENAMES: Readonly<
+	Record<DeprecatedPluginCapability, CurrentPluginCapability>
+> = Object.freeze({
+	"network:fetch": "network:request",
+	"network:fetch:any": "network:request:unrestricted",
+	"read:content": "content:read",
+	"write:content": "content:write",
+	"read:media": "media:read",
+	"write:media": "media:write",
+	"read:users": "users:read",
+	"email:provide": "hooks.email-transport:register",
+	"email:intercept": "hooks.email-events:register",
+	"page:inject": "hooks.page-fragments:register",
+});
+
+/**
+ * Type guard: is this capability one of the deprecated legacy names?
+ *
+ * Uses an own-property check so that prototype keys like "toString" or
+ * "constructor" don't accidentally pass.
+ */
+export function isDeprecatedCapability(cap: string): cap is DeprecatedPluginCapability {
+	return Object.hasOwn(CAPABILITY_RENAMES, cap);
+}
+
+/**
+ * Normalize a capability string — deprecated names map to current names,
+ * current names pass through unchanged. Unknown strings are returned as-is
+ * so that downstream validators can produce a precise error.
+ */
+export function normalizeCapability(cap: string): string {
+	if (isDeprecatedCapability(cap)) {
+		return CAPABILITY_RENAMES[cap];
+	}
+	return cap;
+}
+
+/**
+ * Normalize an array of capabilities. Deduplicates by normalized name so
+ * that a plugin declaring both `read:content` and `content:read` ends up
+ * with a single `content:read` entry.
+ */
+export function normalizeCapabilities(caps: readonly string[]): string[] {
+	const seen = new Set<string>();
+	const out: string[] = [];
+	for (const cap of caps) {
+		const normalized = normalizeCapability(cap);
+		if (!seen.has(normalized)) {
+			seen.add(normalized);
+			out.push(normalized);
+		}
+	}
+	return out;
+}
 
 // =============================================================================
 // Storage Types
@@ -1201,6 +1332,15 @@ export interface PortableTextBlockConfig {
 	placeholder?: string;
 	/** Block Kit form fields for the editing UI. If declared, replaces the simple URL input. */
 	fields?: PortableTextBlockField[];
+	/**
+	 * Optional. Display category in the slash menu. Defaults to "Embeds".
+	 *
+	 * Plugin authors should pick a meaningful category that reflects what the
+	 * block actually is — e.g. "Sections", "Marketing", "Media", "Embeds",
+	 * "Layout". Blocks with the same category are grouped together in the
+	 * editor's slash menu.
+	 */
+	category?: string;
 }
 
 /**

package/src/preview/urls.ts

@@ -6,6 +6,8 @@
 
 import { generatePreviewToken } from "./tokens.js";
 
+const REPEATED_SLASHES = /\/{2,}/g;
+
 /**
  * Options for generating a preview URL
  */
@@ -20,8 +22,18 @@ export interface GetPreviewUrlOptions {
 	expiresIn?: string | number;
 	/** Base URL of the site. If not provided, returns a relative URL. */
 	baseUrl?: string;
-	/** Custom path pattern. Use {collection} and {id} as placeholders. Default: "/{collection}/{id}" */
+	/**
+	 * Custom path pattern. Supports `{collection}`, `{id}` and `{locale}`
+	 * placeholders. Default: `"/{collection}/{id}"`.
+	 */
 	pathPattern?: string;
+	/**
+	 * Locale segment substituted for the `{locale}` placeholder in `pathPattern`.
+	 * Pass an empty string to omit the locale prefix (e.g. for the default locale
+	 * when `prefixDefaultLocale` is `false`); adjacent slashes left by an empty
+	 * value are collapsed and any trailing slash is trimmed.
+	 */
+	locale?: string;
 }
 
 /**
@@ -65,6 +77,7 @@ export async function getPreviewUrl(options: GetPreviewUrlOptions): Promise<stri
 		expiresIn = "1h",
 		baseUrl,
 		pathPattern = "/{collection}/{id}",
+		locale = "",
 	} = options;
 
 	// Generate the signed token
@@ -74,8 +87,15 @@ export async function getPreviewUrl(options: GetPreviewUrlOptions): Promise<stri
 		secret,
 	});
 
-	// Build the path
-	const path = pathPattern.replace("{collection}", collection).replace("{id}", id);
+	// Build the path. `{locale}` may resolve to an empty string (default locale
+	// without a prefix); collapse the resulting double slashes and trim a
+	// trailing slash so the URL stays clean.
+	let path = pathPattern
+		.replace("{collection}", collection)
+		.replace("{id}", id)
+		.replace("{locale}", locale);
+	path = path.replace(REPEATED_SLASHES, "/");
+	if (path.length > 1 && path.endsWith("/")) path = path.slice(0, -1);
 
 	// Add token as query parameter
 	const url = new URL(path, baseUrl || "http://placeholder");

package/src/query.ts

@@ -12,7 +12,9 @@
  * and sets the context; query functions read it automatically.
  */
 
+import { encodeCursor } from "./database/repositories/types.js";
 import { getFallbackChain, getI18nConfig, isI18nEnabled } from "./i18n/config.js";
+import { CURSOR_RAW_VALUES } from "./loader.js";
 import { requestCached } from "./request-cache.js";
 import { getRequestContext } from "./request-context.js";
 import { isMissingTableError } from "./utils/db-errors.js";
@@ -279,9 +281,144 @@ export async function getEmDashCollection<T extends string, D = InferCollectionD
 	// appears on the home page AND in the sidebar) — caching collapses
 	// those duplicate queries, along with the bylines and taxonomy-term
 	// hydration each call would otherwise re-do.
-	return requestCached(collectionCacheKey(type, filter), () =>
-		getEmDashCollectionUncached<T, D>(type, filter),
+	//
+	// Bucket small limits to a shared minimum so a page with several
+	// "recent N posts" widgets at slightly different limits (e.g. a
+	// post-detail page asking for 4 in the body and 5 in the sidebar)
+	// shares one fetch + hydration round-trip rather than running two.
+	// Cursor-paginated calls are exempt: their limit is part of the
+	// pagination contract.
+	const bucketed = bucketFilter(filter);
+	const cached = await requestCached(collectionCacheKey(type, bucketed.fetchFilter), () =>
+		getEmDashCollectionUncached<T, D>(type, bucketed.fetchFilter),
 	);
+	return bucketed.requestedLimit === undefined
+		? cached
+		: sliceCollectionResult(cached, bucketed.requestedLimit, filter?.orderBy);
+}
+
+/**
+ * Threshold for limit bucketing. Page templates routinely render small
+ * "recent posts" widgets at limits 3-8; rounding those up to a single
+ * shared bucket lets one fetch satisfy several widgets within a request.
+ * Above this, the requested limit is honoured exactly — bucketing limit:50
+ * to limit:64 would waste hydration work for callers fetching real pages.
+ */
+const BUCKET_LIMIT_THRESHOLD = 10;
+
+interface BucketedFilter {
+	/** Filter to pass to the loader (with limit possibly raised). */
+	fetchFilter: CollectionFilter | undefined;
+	/** Original limit; defined only when bucketing was applied. */
+	requestedLimit: number | undefined;
+}
+
+/** @internal exported for unit tests; not part of the public API. */
+export function bucketFilter(filter: CollectionFilter | undefined): BucketedFilter {
+	const limit = filter?.limit;
+	if (
+		limit === undefined ||
+		limit >= BUCKET_LIMIT_THRESHOLD ||
+		limit <= 0 ||
+		filter?.cursor !== undefined
+	) {
+		return { fetchFilter: filter, requestedLimit: undefined };
+	}
+	return {
+		fetchFilter: { ...filter, limit: BUCKET_LIMIT_THRESHOLD },
+		requestedLimit: limit,
+	};
+}
+
+/**
+ * Slice a cached bucketed result down to the originally-requested limit
+ * and recompute `nextCursor` from the row that would have been the
+ * over-fetch detector for that limit. When truncation is needed, returns
+ * a shallow-copied result with a new `entries` array; otherwise returns
+ * the cached result unchanged (including error results and results
+ * already within the requested limit).
+ */
+/** @internal exported for unit tests; not part of the public API. */
+export function sliceCollectionResult<D>(
+	cached: CollectionResult<D>,
+	limit: number,
+	orderBy: OrderBySpec | undefined,
+): CollectionResult<D> {
+	if (cached.error) return cached;
+	if (cached.entries.length <= limit) return cached;
+	const sliced = cached.entries.slice(0, limit);
+	// Mirror the loader's encoding: cursor points at the last returned row,
+	// so "next page" picks up at the row immediately after it. See
+	// 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 };
+}
+
+/** Map of database column names to camelCase keys present on entry.data. */
+const ENTRY_DATA_KEY_MAP: Record<string, string> = {
+	created_at: "createdAt",
+	updated_at: "updatedAt",
+	published_at: "publishedAt",
+	scheduled_at: "scheduledAt",
+	author_id: "authorId",
+	primary_byline_id: "primaryBylineId",
+};
+
+// Mirror loader.ts FIELD_NAME_PATTERN. Kept in sync intentionally — diverging
+// would let the encoder accept a field name the loader's getPrimarySort then
+// rejected, producing a cursor that paginates against a different column.
+const FIELD_NAME_PATTERN = /^[a-zA-Z_][a-zA-Z0-9_]*$/;
+
+/**
+ * Encode a `nextCursor` from a content entry, mirroring the loader's
+ * encoding scheme: `(orderValue, id)` where `orderValue` is the primary
+ * sort field's stringified value. For date columns, reads the raw DB
+ * string the loader stashed via CURSOR_RAW_VALUES — round-tripping the
+ * parsed Date through `toISOString()` would lose precision for stored
+ * values that aren't already ISO-with-milliseconds.
+ */
+function encodeEntryCursor<D>(
+	entry: ContentEntry<D>,
+	orderBy: OrderBySpec | undefined,
+): string | undefined {
+	const data = entryData(entry);
+	const id = dataStr(data, "id");
+	if (!id) return undefined;
+
+	// Match loader.ts getPrimarySort: take the first valid field, default to created_at.
+	let dbField = "created_at";
+	if (orderBy) {
+		for (const field of Object.keys(orderBy)) {
+			if (FIELD_NAME_PATTERN.test(field)) {
+				dbField = field;
+				break;
+			}
+		}
+	}
+
+	// Date columns: prefer the raw stored string captured by the loader so
+	// the cursor matches what a direct loader fetch would emit, regardless
+	// of how the DB stored the timestamp.
+	const rawDateValuesRaw = Reflect.get(data, CURSOR_RAW_VALUES);
+	if (rawDateValuesRaw !== null && typeof rawDateValuesRaw === "object") {
+		const raw = Reflect.get(rawDateValuesRaw, dbField);
+		if (typeof raw === "string") return encodeCursor(raw, id);
+	}
+
+	const dataKey = ENTRY_DATA_KEY_MAP[dbField] ?? dbField;
+	const value = data[dataKey];
+	let orderValue: string;
+	if (value instanceof Date) {
+		orderValue = value.toISOString();
+	} else if (typeof value === "string" || typeof value === "number") {
+		orderValue = String(value);
+	} else {
+		// Match the loader's empty-string fallback for null/undefined order
+		// values so cursor decoding stays valid even at the boundary.
+		orderValue = "";
+	}
+	return encodeCursor(orderValue, id);
 }
 
 /**
@@ -562,10 +699,16 @@ async function hydrateEntryBylines<D>(type: string, entries: ContentEntry<D>[]):
 	try {
 		const { getBylinesForEntries } = await import("./bylines/index.js");
 
-		const ids = entries.map((e) => dataStr(entryData(e), "id")).filter(Boolean);
-		if (ids.length === 0) return;
+		const refs = entries
+			.map((e) => {
+				const data = entryData(e);
+				const id = dataStr(data, "id");
+				return id ? { id, authorId: dataStr(data, "authorId") || null } : null;
+			})
+			.filter((r): r is { id: string; authorId: string | null } => r !== null);
+		if (refs.length === 0) return;
 
-		const bylinesMap = await getBylinesForEntries(type, ids);
+		const bylinesMap = await getBylinesForEntries(type, refs);
 
 		for (const entry of entries) {
 			const data = entryData(entry);