emdash 0.16.0 → 0.17.0

package/src/astro/routes/api/admin/byline-fields/[slug].ts

@@ -0,0 +1,92 @@
+/**
+ * Byline custom-field schema management — single field CRUD.
+ *
+ * - GET    /_emdash/api/admin/byline-fields/{slug}    read one definition
+ * - PATCH  /_emdash/api/admin/byline-fields/{slug}    update label / required /
+ *                                                     translatable / validation /
+ *                                                     sort order
+ * - DELETE /_emdash/api/admin/byline-fields/{slug}    drop the definition and all
+ *                                                     stored values (FK CASCADE +
+ *                                                     app-level cleanup; see
+ *                                                     `BylineSchemaRegistry.deleteField`)
+ *
+ * Thin wrappers around the handler layer; status mapping happens in
+ * `unwrapResult`. `slug` and `type` are immutable post-create — see
+ * `bylineFieldUpdateBody`. Flipping `translatable` while value rows
+ * exist surfaces as a 409 `TRANSLATABLE_LOCKED`.
+ *
+ * Phase 4 of Discussion #1174.
+ */
+
+import type { APIRoute } from "astro";
+
+import { requirePerm } from "#api/authorize.js";
+import { apiError, requireDb, unwrapResult } from "#api/error.js";
+import {
+	handleBylineFieldDelete,
+	handleBylineFieldGet,
+	handleBylineFieldUpdate,
+} from "#api/handlers/byline-fields.js";
+import { isParseError, parseBody } from "#api/parse.js";
+import { bylineFieldUpdateBody } from "#api/schemas.js";
+
+export const prerender = false;
+
+// GET requires `schema:read` (Editor+); see sibling `index.ts` GET
+// for rationale.
+export const GET: APIRoute = async ({ params, locals }) => {
+	const { emdash, user } = locals;
+	const denied = requirePerm(user, "schema:read");
+	if (denied) return denied;
+
+	const dbErr = requireDb(emdash?.db);
+	if (dbErr) return dbErr;
+
+	const slug = params.slug;
+	if (!slug) return apiError("MISSING_PARAM", "Field slug is required", 400);
+
+	const result = await handleBylineFieldGet(emdash.db, slug);
+	return unwrapResult(result);
+};
+
+export const PATCH: APIRoute = async ({ params, request, locals }) => {
+	const { emdash, user } = locals;
+	const denied = requirePerm(user, "schema:manage");
+	if (denied) return denied;
+
+	const dbErr = requireDb(emdash?.db);
+	if (dbErr) return dbErr;
+
+	const slug = params.slug;
+	if (!slug) return apiError("MISSING_PARAM", "Field slug is required", 400);
+
+	const body = await parseBody(request, bylineFieldUpdateBody);
+	if (isParseError(body)) return body;
+
+	const result = await handleBylineFieldUpdate(emdash.db, slug, {
+		label: body.label,
+		required: body.required,
+		translatable: body.translatable,
+		// `null` clears the stored validation; `undefined` leaves it as-is.
+		// The zod schema makes `validation` itself optional, so an absent
+		// key reaches the handler as `undefined`.
+		validation: body.validation,
+		sortOrder: body.sortOrder,
+	});
+	return unwrapResult(result);
+};
+
+export const DELETE: APIRoute = async ({ params, locals }) => {
+	const { emdash, user } = locals;
+	const denied = requirePerm(user, "schema:manage");
+	if (denied) return denied;
+
+	const dbErr = requireDb(emdash?.db);
+	if (dbErr) return dbErr;
+
+	const slug = params.slug;
+	if (!slug) return apiError("MISSING_PARAM", "Field slug is required", 400);
+
+	const result = await handleBylineFieldDelete(emdash.db, slug);
+	return unwrapResult(result);
+};

package/src/astro/routes/api/admin/byline-fields/index.ts

@@ -0,0 +1,66 @@
+/**
+ * Byline custom-field schema management — list + create.
+ *
+ * - GET  /_emdash/api/admin/byline-fields           list every registered field
+ * - POST /_emdash/api/admin/byline-fields           create a new field definition
+ *
+ * Thin wrappers around `handleBylineFieldList` / `handleBylineFieldCreate`
+ * in `api/handlers/byline-fields.ts`. Both endpoints require
+ * `schema:manage`. Reserved-slug + identifier validation runs at the
+ * zod layer in `bylineFieldCreateBody`; the registry repeats the check
+ * for defence-in-depth. Domain errors surface as typed `ErrorCode`s and
+ * are mapped to HTTP statuses by `unwrapResult` → `mapErrorStatus`.
+ *
+ * Phase 4 of Discussion #1174.
+ */
+
+import type { APIRoute } from "astro";
+
+import { requirePerm } from "#api/authorize.js";
+import { requireDb, unwrapResult } from "#api/error.js";
+import { handleBylineFieldCreate, handleBylineFieldList } from "#api/handlers/byline-fields.js";
+import { isParseError, parseBody } from "#api/parse.js";
+import { bylineFieldCreateBody } from "#api/schemas.js";
+
+export const prerender = false;
+
+// GET requires `schema:read` (Editor+), not `schema:manage` — Phase 6
+// of #1174 surfaced the split: editors need to read field definitions
+// to render custom-field inputs in the byline edit form, while only
+// admins manage the registry. The Phase 4 review-round constraint
+// "every endpoint returns 403 for a user without schema:manage" is
+// superseded for the read endpoints; mutations remain admin-only.
+export const GET: APIRoute = async ({ locals }) => {
+	const { emdash, user } = locals;
+	const denied = requirePerm(user, "schema:read");
+	if (denied) return denied;
+
+	const dbErr = requireDb(emdash?.db);
+	if (dbErr) return dbErr;
+
+	const result = await handleBylineFieldList(emdash.db);
+	return unwrapResult(result);
+};
+
+export const POST: APIRoute = async ({ request, locals }) => {
+	const { emdash, user } = locals;
+	const denied = requirePerm(user, "schema:manage");
+	if (denied) return denied;
+
+	const dbErr = requireDb(emdash?.db);
+	if (dbErr) return dbErr;
+
+	const body = await parseBody(request, bylineFieldCreateBody);
+	if (isParseError(body)) return body;
+
+	const result = await handleBylineFieldCreate(emdash.db, {
+		slug: body.slug,
+		label: body.label,
+		type: body.type,
+		required: body.required,
+		translatable: body.translatable,
+		validation: body.validation ?? null,
+		sortOrder: body.sortOrder,
+	});
+	return unwrapResult(result, 201);
+};

package/src/astro/routes/api/admin/byline-fields/reorder.ts

@@ -0,0 +1,39 @@
+/**
+ * Byline field reorder.
+ *
+ * POST /_emdash/api/admin/byline-fields/reorder
+ *
+ * Body: `{ slugs: string[] }` — the exact set of currently registered
+ * slugs in the desired order. The registry rejects any drift
+ * (`REORDER_MISMATCH` → 400). Empty `[]` against an empty registered
+ * set is a no-op by registry contract; the zod schema permits it.
+ *
+ * Thin wrapper around `handleBylineFieldReorder`.
+ *
+ * Phase 4 of Discussion #1174.
+ */
+
+import type { APIRoute } from "astro";
+
+import { requirePerm } from "#api/authorize.js";
+import { requireDb, unwrapResult } from "#api/error.js";
+import { handleBylineFieldReorder } from "#api/handlers/byline-fields.js";
+import { isParseError, parseBody } from "#api/parse.js";
+import { bylineFieldReorderBody } from "#api/schemas.js";
+
+export const prerender = false;
+
+export const POST: APIRoute = async ({ request, locals }) => {
+	const { emdash, user } = locals;
+	const denied = requirePerm(user, "schema:manage");
+	if (denied) return denied;
+
+	const dbErr = requireDb(emdash?.db);
+	if (dbErr) return dbErr;
+
+	const body = await parseBody(request, bylineFieldReorderBody);
+	if (isParseError(body)) return body;
+
+	const result = await handleBylineFieldReorder(emdash.db, body.slugs);
+	return unwrapResult(result);
+};

package/src/astro/routes/api/admin/bylines/[id]/index.ts

@@ -1,7 +1,8 @@
 import type { APIRoute } from "astro";
 
 import { requirePerm } from "#api/authorize.js";
-import { apiError, apiSuccess, handleError } from "#api/error.js";
+import { apiError, apiSuccess, handleError, requireDb, unwrapResult } from "#api/error.js";
+import { handleBylineUpdate } from "#api/handlers/bylines.js";
 import { isParseError, parseBody } from "#api/parse.js";
 import { bylineUpdateBody } from "#api/schemas.js";
 import { invalidateBylineCache } from "#bylines/index.js";
@@ -33,31 +34,32 @@ export const PUT: APIRoute = async ({ params, request, locals }) => {
 	const denied = requirePerm(user, "bylines:manage");
 	if (denied) return denied;
 
-	if (!emdash?.db) {
-		return apiError("NOT_CONFIGURED", "EmDash is not initialized", 500);
-	}
+	const dbErr = requireDb(emdash?.db);
+	if (dbErr) return dbErr;
 
 	const body = await parseBody(request, bylineUpdateBody);
 	if (isParseError(body)) return body;
 
-	try {
-		const repo = new BylineRepository(emdash.db);
-		const byline = await repo.update(params.id!, {
-			slug: body.slug,
-			displayName: body.displayName,
-			bio: body.bio ?? null,
-			avatarMediaId: body.avatarMediaId ?? null,
-			websiteUrl: body.websiteUrl ?? null,
-			userId: body.userId ?? null,
-			isGuest: body.isGuest,
-		});
+	const result = await handleBylineUpdate(emdash.db, params.id!, {
+		slug: body.slug,
+		displayName: body.displayName,
+		bio: body.bio ?? null,
+		avatarMediaId: body.avatarMediaId ?? null,
+		websiteUrl: body.websiteUrl ?? null,
+		userId: body.userId ?? null,
+		isGuest: body.isGuest,
+		// Forward `customFields` only when present so the repo treats an
+		// omitted key as "leave existing values untouched". An empty
+		// object also no-ops by repo convention — see
+		// `BylineRepository.update`. Validation (unknown slug, type
+		// mismatch, select-choice) happens inside the repo and surfaces
+		// as `EmDashValidationError`, which the handler maps to a 400
+		// `VALIDATION_ERROR` for `unwrapResult` / `mapErrorStatus`.
+		customFields: body.customFields,
+	});
 
-		if (!byline) return apiError("NOT_FOUND", "Byline not found", 404);
-		invalidateBylineCache();
-		return apiSuccess(byline);
-	} catch (error) {
-		return handleError(error, "Failed to update byline", "BYLINE_UPDATE_ERROR");
-	}
+	if (result.success) invalidateBylineCache();
+	return unwrapResult(result);
 };
 
 export const DELETE: APIRoute = async ({ params, locals }) => {

package/src/astro/routes/api/admin/bylines/index.ts

@@ -75,6 +75,7 @@ export const POST: APIRoute = async ({ request, locals }) => {
 			isGuest: body.isGuest,
 			locale: body.locale,
 			translationOf: body.translationOf,
+			customFields: body.customFields,
 		});
 
 		if (result.success) invalidateBylineCache();

package/src/astro/routes/api/auth/me.ts

@@ -9,21 +9,22 @@ import type { APIRoute } from "astro";
 
 export const prerender = false;
 
-import { apiError, apiSuccess } from "#api/error.js";
+import { apiError, apiSuccess, handleError } from "#api/error.js";
 import { isParseError, parseBody } from "#api/parse.js";
 import { authMeActionBody } from "#api/schemas.js";
+import { UserRepository } from "#db/repositories/user.js";
 
-export const GET: APIRoute = async ({ locals, session }) => {
+export const GET: APIRoute = async ({ locals }) => {
 	const { user } = locals;
 
 	if (!user) {
 		return apiError("NOT_AUTHENTICATED", "Not authenticated", 401);
 	}
 
-	// Check if this is the user's first login (for welcome modal)
-	// We track this in the session to show the modal only once
-	const hasSeenWelcome = await session?.get("hasSeenWelcome");
-	const isFirstLogin = !hasSeenWelcome;
+	// Check if this is the user's first login (for welcome modal).
+	// The flag is persisted in the user's `data` JSON column so it survives
+	// session expiry / rotation.
+	const isFirstLogin = !user.data?.welcomeDismissed;
 
 	// Return safe user info (no sensitive data)
 	return apiSuccess({
@@ -41,19 +42,29 @@ export const GET: APIRoute = async ({ locals, session }) => {
  *
  * Mark that the user has seen the welcome modal.
  */
-export const POST: APIRoute = async ({ request, locals, session }) => {
-	const { user } = locals;
+export const POST: APIRoute = async ({ request, locals }) => {
+	const { user, emdash } = locals;
 
 	if (!user) {
 		return apiError("NOT_AUTHENTICATED", "Not authenticated", 401);
 	}
 
+	if (!emdash) return apiError("NOT_CONFIGURED", "EmDash is not initialized", 500);
+
 	const body = await parseBody(request, authMeActionBody);
 	if (isParseError(body)) return body;
 
 	if (body.action === "dismissWelcome") {
-		session?.set("hasSeenWelcome", true);
-		return apiSuccess({ success: true });
+		try {
+			// Persist in the user's data column so it survives session expiry.
+			const userRepo = new UserRepository(emdash.db);
+			await userRepo.update(user.id, {
+				data: { ...user.data, welcomeDismissed: true },
+			});
+			return apiSuccess({ success: true });
+		} catch (error) {
+			return handleError(error, "Failed to dismiss welcome", "WELCOME_DISMISS_ERROR");
+		}
 	}
 
 	return apiError("UNKNOWN_ACTION", "Unknown action", 400);

package/src/astro/routes/api/content/[collection]/[id]/terms/[taxonomy].ts

@@ -11,6 +11,7 @@ import { requirePerm, requireOwnerPerm } from "#api/authorize.js";
 import { apiError, apiSuccess, handleError, requireDb } from "#api/error.js";
 import { parseBody, isParseError } from "#api/parse.js";
 import { contentTermsBody } from "#api/schemas.js";
+import { ContentRepository } from "#db/repositories/content.js";
 import { TaxonomyRepository } from "#db/repositories/taxonomy.js";
 import { invalidateTermCache } from "#taxonomies/index.js";
 
@@ -34,8 +35,16 @@ export const GET: APIRoute = async ({ params, locals }) => {
 	if (dbErr) return dbErr;
 
 	try {
+		// Terms are stored against the per-locale entry row but their
+		// translation_group spans every locale. Resolve the entry's own locale
+		// server-side (deterministic, not client-spoofable) so only the matching
+		// term variant is returned — see issue #1218.
+		const entry = await new ContentRepository(emdash.db).findByIdOrSlug(collection, id);
+		if (!entry) return apiError("NOT_FOUND", "Content not found", 404);
+		const locale = entry.locale ?? undefined;
+
 		const repo = new TaxonomyRepository(emdash.db);
-		const terms = await repo.getTermsForEntry(collection, id, taxonomy);
+		const terms = await repo.getTermsForEntry(collection, entry.id, taxonomy, locale);
 
 		return apiSuccess({
 			terms: terms.map((t) => ({
@@ -101,6 +110,9 @@ export const POST: APIRoute = async ({ params, request, locals }) => {
 	// Resolve the canonical content ID from the handler result.
 	// The URL `id` param may be a slug; we must use the real ID for term storage.
 	const canonicalId = typeof existingItem?.id === "string" ? existingItem.id : id;
+	// The entry is per-locale; scope the term read to its locale so only the
+	// matching translation variant is returned in the response — see #1218.
+	const entryLocale = typeof existingItem?.locale === "string" ? existingItem.locale : undefined;
 
 	try {
 		const body = await parseBody(request, contentTermsBody);
@@ -131,8 +143,8 @@ export const POST: APIRoute = async ({ params, request, locals }) => {
 		// so hydration on subsequent reads issues a fresh query.
 		invalidateTermCache();
 
-		// Get the updated terms using the canonical ID
-		const terms = await repo.getTermsForEntry(collection, canonicalId, taxonomy);
+		// Get the updated terms using the canonical ID, scoped to the entry locale
+		const terms = await repo.getTermsForEntry(collection, canonicalId, taxonomy, entryLocale);
 
 		return apiSuccess({
 			terms: terms.map((t) => ({

package/src/astro/routes/api/content/[collection]/[id].ts

@@ -68,6 +68,7 @@ export const PUT: APIRoute = async ({ params, request, locals, cache }) => {
 	const { emdash, user } = locals;
 	const collection = params.collection!;
 	const id = params.id!;
+	const locale = new URL(request.url).searchParams.get("locale") || undefined;
 	const body = await parseBody(request, contentUpdateBody);
 	if (isParseError(body)) return body;
 
@@ -76,7 +77,7 @@ export const PUT: APIRoute = async ({ params, request, locals, cache }) => {
 	}
 
 	// Fetch item to check ownership
-	const existing = await emdash.handleContentGet(collection, id);
+	const existing = await emdash.handleContentGet(collection, id, locale);
 	if (!existing.success) {
 		return apiError(
 			existing.error?.code ?? "UNKNOWN_ERROR",
@@ -120,6 +121,7 @@ export const PUT: APIRoute = async ({ params, request, locals, cache }) => {
 	// Pass _rev through for optimistic concurrency validation
 	const result = await emdash.handleContentUpdate(collection, resolvedId, {
 		...updateBody,
+		locale,
 		_rev: body._rev,
 	});
 

package/src/astro/routes/api/media.ts

@@ -56,6 +56,7 @@ export const GET: APIRoute = async ({ request, locals }) => {
 		cursor: query.cursor,
 		limit: query.limit,
 		mimeType: query.mimeType,
+		q: query.q,
 	});
 
 	if (!result.success) {

package/src/astro/types.ts

@@ -274,6 +274,7 @@ export interface EmDashHandlers {
 			status?: string;
 			authorId?: string | null;
 			bylines?: Array<{ bylineId: string; roleLabel?: string | null }>;
+			locale?: string;
 			seo?: {
 				title?: string | null;
 				description?: string | null;

package/src/bylines/field-defs-cache.ts

@@ -0,0 +1,138 @@
+/**
+ * Byline field-definitions cache
+ *
+ * Discussion #1174 / Phase 3. Two-tier cache for the byline custom-field
+ * registry, mirroring the `settings/index.ts` pattern.
+ *
+ * **Tier 1 — per-isolate (globalThis).** Field definitions change rarely
+ * but are read on every byline hydration (admin pages, content rendering,
+ * API responses). Caching at the isolate level drops the SELECT-from-
+ * `_emdash_byline_fields` from once-per-hydration to once-per-isolate-
+ * after-bump. The cache holds a Promise (not the resolved value) so
+ * concurrent cold-isolate readers share the in-flight query.
+ *
+ * Stored on globalThis under `Symbol.for("emdash:byline-field-defs")` so
+ * Vite SSR chunk duplication can't produce two independent caches (same
+ * pattern as `request-cache.ts` and `request-context.ts`).
+ *
+ * **Tier 2 — per-request.** Wraps both the version read and the defs
+ * fetch in `requestCached` so a single page render that hits byline
+ * hydration multiple times (e.g. list view + individual byline lookups
+ * in a sidebar) pays at most one version read and one defs fetch in
+ * total. The defs cache key includes the version, so a (highly
+ * unlikely) mid-request bump still produces a self-consistent view —
+ * the second call sees a different key and refetches.
+ *
+ * **Invalidation.** `options.byline_fields_version` is bumped by every
+ * `BylineSchemaRegistry` mutation (Phase 2). Each isolate independently
+ * reads the persisted version on the next request and compares against
+ * its cached version; mismatch triggers a refetch and overwrite. Other
+ * isolates see the change within one request after the bump propagates.
+ *
+ * **Isolated databases bypass the global cache.** Playground and DO
+ * preview sessions set `requestContext.dbIsIsolated = true`, signalling
+ * the per-request `db` points at an isolated schema that may diverge
+ * from the singleton. Schema-derived caches keyed by the singleton's
+ * version would silently leak the singleton's defs into the isolated
+ * request. We follow the `loader.ts:74` `getTaxonomyNames` precedent:
+ * skip both reading from and writing to the global holder when the
+ * request is isolated. The per-request cache (`requestCached`) is keyed
+ * by the WeakMap'd `EmDashRequestContext`, so it can't cross-pollinate
+ * between requests — it stays in play even for isolated DBs.
+ *
+ * **Why a versioned cache and not a TTL?** The version counter gives
+ * deterministic invalidation without the staleness window a TTL would
+ * impose. Field-definition changes need to be visible to the next
+ * request, not eventually. The cost is one cheap `options` read per
+ * request — cheaper than the field-defs fetch it replaces, and cheaper
+ * than maintaining a TTL state machine.
+ */
+
+import type { Kysely } from "kysely";
+
+import type { Database } from "../database/types.js";
+import { requestCached } from "../request-cache.js";
+import { getRequestContext } from "../request-context.js";
+import { BylineSchemaRegistry } from "../schema/byline-registry.js";
+import type { BylineFieldDefinition } from "../schema/types.js";
+
+interface FieldDefsHolder {
+	/** In-flight or resolved defs promise for the cached version. Null until first read. */
+	cached: Promise<BylineFieldDefinition[]> | null;
+	/** Persisted-version value that `cached` was fetched against. */
+	cachedVersion: number;
+}
+
+const HOLDER_KEY = Symbol.for("emdash:byline-field-defs");
+const g = globalThis as Record<symbol, unknown>;
+const holder: FieldDefsHolder =
+	// eslint-disable-next-line typescript/no-unsafe-type-assertion -- globalThis singleton pattern (see request-cache.ts)
+	(g[HOLDER_KEY] as FieldDefsHolder | undefined) ??
+	(() => {
+		const h: FieldDefsHolder = { cached: null, cachedVersion: -1 };
+		g[HOLDER_KEY] = h;
+		return h;
+	})();
+
+const REQUEST_CACHE_KEY_VERSION = "byline-fields-version";
+const REQUEST_CACHE_KEY_DEFS_PREFIX = "byline-field-defs:";
+
+/**
+ * Read the persisted `options.byline_fields_version` counter. Cached for
+ * the duration of the current request via `requestCached`. Returns `0`
+ * when the row is missing (matches `BylineSchemaRegistry.getVersion`).
+ */
+async function getBylineFieldsVersion(db: Kysely<Database>): Promise<number> {
+	return requestCached(REQUEST_CACHE_KEY_VERSION, () => new BylineSchemaRegistry(db).getVersion());
+}
+
+/**
+ * Resolve registered byline custom-field definitions. Two-tier cache:
+ * per-request via `requestCached`, then per-isolate via the global
+ * holder.
+ *
+ * The global holder is bypassed for isolated requests (playground / DO
+ * preview, which point at a divergent schema) and for dirty versions
+ * (odd counter — see `BylineSchemaRegistry`'s class JSDoc — indicates
+ * an in-flight or crashed mutation). Both bypass paths still hit the
+ * per-request cache, so a single render dedupes within itself.
+ *
+ * Always returns an array. Empty = no custom fields registered.
+ */
+export async function getBylineFieldDefs(db: Kysely<Database>): Promise<BylineFieldDefinition[]> {
+	const isolated = getRequestContext()?.dbIsIsolated === true;
+	const version = await getBylineFieldsVersion(db);
+	const dirty = version % 2 !== 0;
+	return requestCached(`${REQUEST_CACHE_KEY_DEFS_PREFIX}${version}`, async () => {
+		if (isolated || dirty) {
+			return new BylineSchemaRegistry(db).listFields();
+		}
+		if (holder.cached !== null && holder.cachedVersion === version) {
+			return holder.cached;
+		}
+		const defs = new BylineSchemaRegistry(db).listFields().catch((error) => {
+			if (holder.cached === defs) {
+				holder.cached = null;
+				holder.cachedVersion = -1;
+			}
+			throw error;
+		});
+		holder.cached = defs;
+		holder.cachedVersion = version;
+		return defs;
+	});
+}
+
+/**
+ * Test/internal helper: clear the per-isolate cache. Useful for unit
+ * tests that mutate the registry directly and need to force a refetch
+ * without going through the full version-bump path.
+ *
+ * Production code paths should rely on the version counter for
+ * invalidation — calling this from a write path would bypass the
+ * coordination that lets other isolates see the change.
+ */
+export function resetBylineFieldDefsCacheForTests(): void {
+	holder.cached = null;
+	holder.cachedVersion = -1;
+}

package/src/bylines/index.ts

@@ -220,10 +220,20 @@ export async function getBylinesForEntries(
 	// previous "has any bylines" probe, without the extra round-trip.
 	// Pre-migration databases (bylines table missing) fall through to the
 	// `isMissingTableError` catch below and return empty.
+	//
+	// Each bucket's `getContentBylinesMany` call uses `skipHydration: true`
+	// so the per-bucket fetches return bylines with `customFields = {}`.
+	// We then hydrate the union of returned bylines in a SINGLE batched
+	// pass via `hydrateBylineCustomFields`. This keeps mixed-locale list
+	// hydration at one batched group-shared query (and one batched
+	// translatable query) per request, even when locale buckets reference
+	// disjoint translation_groups — the strict reading of the Phase 3
+	// query-count envelope.
 	const explicitByEntry = new Map<string, ContentBylineCredit[]>();
 	const entriesNeedingAuthorCheck: BylineEntry[] = [];
+	const hydrationTargets: BylineSummary[] = [];
 	for (const [locale, bucket] of buckets) {
-		const localeOpt = locale ? { locale } : undefined;
+		const localeOpt = locale ? { locale, skipHydration: true } : { skipHydration: true };
 		const bucketIds = bucket.map((e) => e.id);
 		let bylinesMap;
 		try {
@@ -232,7 +242,10 @@ export async function getBylinesForEntries(
 			if (isMissingTableError(error)) return result;
 			throw error;
 		}
-		for (const [id, list] of bylinesMap) explicitByEntry.set(id, list);
+		for (const [id, list] of bylinesMap) {
+			explicitByEntry.set(id, list);
+			for (const credit of list) hydrationTargets.push(credit.byline);
+		}
 
 		for (const entry of bucket) {
 			const hasResolved = bylinesMap.has(entry.id) && bylinesMap.get(entry.id)!.length > 0;
@@ -255,19 +268,39 @@ export async function getBylinesForEntries(
 		}
 
 		for (const [locale, bucket] of authorBuckets) {
-			const localeOpt = locale ? { locale } : undefined;
+			const localeOpt: { locale?: string; skipHydration: true } = locale
+				? { locale, skipHydration: true }
+				: { skipHydration: true };
 			const authorIds = bucket.map((e) => e.authorId).filter((id): id is string => id !== null);
 			const uniqueAuthorIds = [...new Set(authorIds)];
 			if (uniqueAuthorIds.length === 0) continue;
+			// `skipHydration: true` returns bylines with `customFields = {}`
+			// so the fallback path participates in the single batched
+			// `hydrateBylineCustomFields` call below — keeping the query
+			// envelope at "+1 group-shared query per hydration pass" even
+			// when author bylines across locale buckets reference disjoint
+			// translation_groups.
 			const authorBylineMap = await repo.findByUserIds(uniqueAuthorIds, localeOpt);
 			for (const entry of bucket) {
 				if (!entry.authorId) continue;
 				const f = authorBylineMap.get(entry.authorId);
-				if (f) fallbackByEntry.set(entry.id, f);
+				if (f) {
+					fallbackByEntry.set(entry.id, f);
+					hydrationTargets.push(f);
+				}
 			}
 		}
 	}
 
+	// Single batched hydration over every byline returned from both the
+	// per-bucket explicit-credit fetches AND the per-bucket author-
+	// fallback fetches. One translatable query + one group-shared query
+	// for the whole pass, regardless of bucket count or whether
+	// translation_groups overlap across locales.
+	if (hydrationTargets.length > 0) {
+		await repo.hydrateBylineCustomFields(hydrationTargets);
+	}
+
 	for (const { id } of entries) {
 		const explicit = explicitByEntry.get(id);
 		if (explicit && explicit.length > 0) {

package/src/cli/commands/content.ts

@@ -233,6 +233,7 @@ const updateCommand = defineCommand({
 			description: "Revision token from get (prevents overwriting unseen changes)",
 			required: true,
 		},
+		locale: { type: "string", description: "Locale for slug resolution" },
 		draft: {
 			type: "boolean",
 			description: "Keep as draft instead of auto-publishing",
@@ -247,17 +248,18 @@ const updateCommand = defineCommand({
 			const updated = await client.update(args.collection, args.id, {
 				data,
 				_rev: args.rev,
+				locale: args.locale,
 			});
 
 			// Auto-publish unless --draft is set.
 			// Only publish if the update created a draft revision (i.e. the
 			// collection supports revisions and data went to a draft).
 			if (!args.draft && updated.draftRevisionId) {
-				await client.publish(args.collection, args.id);
+				await client.publish(args.collection, updated.id);
 			}
 
 			// Re-fetch to return the current state
-			const item = await client.get(args.collection, args.id);
+			const item = await client.get(args.collection, updated.id);
 			output(item, args);
 		} catch (error) {
 			consola.error(error instanceof Error ? error.message : "Unknown error");