emdash 0.14.0 → 0.15.0

package/src/database/repositories/byline.ts

@@ -24,6 +24,18 @@ export interface CreateBylineInput {
 	websiteUrl?: string | null;
 	userId?: string | null;
 	isGuest?: boolean;
+	/**
+	 * Locale this byline row belongs to. When omitted, the DB DEFAULT (the
+	 * configured `defaultLocale` after migration 040) is used. Keeps behaviour
+	 * consistent with `TaxonomyRepository.create`.
+	 */
+	locale?: string;
+	/**
+	 * When set, the new row joins the source byline's translation_group rather
+	 * than minting a fresh one. The source must exist; otherwise the create
+	 * throws. Mirrors `TaxonomyRepository.create`.
+	 */
+	translationOf?: string;
 }
 
 export interface UpdateBylineInput {
@@ -53,9 +65,29 @@ function rowToByline(row: BylineRow): BylineSummary {
 		isGuest: row.is_guest === 1,
 		createdAt: row.created_at,
 		updatedAt: row.updated_at,
+		locale: row.locale,
+		translationGroup: row.translation_group,
 	};
 }
 
+/**
+ * Byline repository for content credits.
+ *
+ * Bylines are per-locale (migration 040). Translations of the same byline
+ * share a `translation_group` ULID. `_emdash_content_bylines.byline_id` and
+ * `ec_*.primary_byline_id` store the translation_group (not a row id) so a
+ * single credit spans every locale variant of a byline.
+ *
+ * The repository does not resolve locale fallbacks on its own — callers
+ * supply the locale they want. Hydration is strict per locale: a credit at
+ * locale X renders iff a byline row exists at locale X within the credited
+ * translation group. This mirrors `TaxonomyRepository.getTermsForEntry` and
+ * the convention established by PR #916.
+ *
+ * Runtime helpers in `packages/core/src/bylines/index.ts` may layer fallback
+ * resolution on top for the "look up one byline by slug" path, but the
+ * relation-hydration methods on this class are always strict.
+ */
 export class BylineRepository {
 	constructor(private db: Kysely<Database>) {}
 
@@ -68,21 +100,28 @@ export class BylineRepository {
 		return row ? rowToByline(row) : null;
 	}
 
-	async findBySlug(slug: string): Promise<BylineSummary | null> {
-		const row = await this.db
-			.selectFrom("_emdash_bylines")
-			.selectAll()
-			.where("slug", "=", slug)
-			.executeTakeFirst();
+	/**
+	 * Find a byline by slug. When `locale` is provided, filter by it strictly.
+	 * When omitted, returns the lowest-locale-code match (deterministic across
+	 * calls). Mirrors `TaxonomyRepository.findBySlug`.
+	 */
+	async findBySlug(slug: string, options?: { locale?: string }): Promise<BylineSummary | null> {
+		let query = this.db.selectFrom("_emdash_bylines").selectAll().where("slug", "=", slug);
+		if (options?.locale !== undefined) query = query.where("locale", "=", options.locale);
+		const row = await query.orderBy("locale", "asc").executeTakeFirst();
 		return row ? rowToByline(row) : null;
 	}
 
-	async findByUserId(userId: string): Promise<BylineSummary | null> {
-		const row = await this.db
-			.selectFrom("_emdash_bylines")
-			.selectAll()
-			.where("user_id", "=", userId)
-			.executeTakeFirst();
+	/**
+	 * Find the byline linked to a CMS user. Post-migration 040 the partial
+	 * unique on user_id is `(user_id, locale)`, so `locale` is required to
+	 * disambiguate when multiple locale variants exist. When omitted, returns
+	 * the lowest-locale-code match.
+	 */
+	async findByUserId(userId: string, options?: { locale?: string }): Promise<BylineSummary | null> {
+		let query = this.db.selectFrom("_emdash_bylines").selectAll().where("user_id", "=", userId);
+		if (options?.locale !== undefined) query = query.where("locale", "=", options.locale);
+		const row = await query.orderBy("locale", "asc").executeTakeFirst();
 		return row ? rowToByline(row) : null;
 	}
 
@@ -90,6 +129,7 @@ export class BylineRepository {
 		search?: string;
 		isGuest?: boolean;
 		userId?: string;
+		locale?: string;
 		cursor?: string;
 		limit?: number;
 	}): Promise<FindManyResult<BylineSummary>> {
@@ -121,6 +161,10 @@ export class BylineRepository {
 			query = query.where("user_id", "=", options.userId);
 		}
 
+		if (options?.locale !== undefined) {
+			query = query.where("locale", "=", options.locale);
+		}
+
 		if (options?.cursor) {
 			const decoded = decodeCursor(options.cursor);
 			query = query.where((eb) =>
@@ -145,10 +189,44 @@ export class BylineRepository {
 		return result;
 	}
 
+	/**
+	 * List every sibling row in `translation_group`. Used by the admin
+	 * `TranslationsPanel` to render one entry per configured locale.
+	 */
+	async listTranslations(id: string): Promise<BylineSummary[]> {
+		const anchor = await this.findById(id);
+		if (!anchor) return [];
+		const group = anchor.translationGroup ?? anchor.id;
+		return this.findByTranslationGroup(group);
+	}
+
+	/**
+	 * Direct lookup by `translation_group`. Returns every locale variant of a
+	 * byline, ordered by locale code (deterministic).
+	 */
+	async findByTranslationGroup(translationGroup: string): Promise<BylineSummary[]> {
+		const rows = await this.db
+			.selectFrom("_emdash_bylines")
+			.selectAll()
+			.where("translation_group", "=", translationGroup)
+			.orderBy("locale", "asc")
+			.execute();
+		return rows.map(rowToByline);
+	}
+
 	async create(input: CreateBylineInput): Promise<BylineSummary> {
 		const id = ulid();
 		const now = new Date().toISOString();
 
+		// translationOf joins the source byline's group; otherwise we mint a
+		// fresh group equal to id (matching migration 040's backfill pattern).
+		let translationGroup: string = id;
+		if (input.translationOf) {
+			const source = await this.findById(input.translationOf);
+			if (!source) throw new Error("Source byline for translation not found");
+			translationGroup = source.translationGroup ?? source.id;
+		}
+
 		await this.db
 			.insertInto("_emdash_bylines")
 			.values({
@@ -162,6 +240,10 @@ export class BylineRepository {
 				is_guest: input.isGuest ? 1 : 0,
 				created_at: now,
 				updated_at: now,
+				// When omitted the DB DEFAULT (configured defaultLocale) is used —
+				// keeps behaviour consistent with TaxonomyRepository.create.
+				...(input.locale !== undefined ? { locale: input.locale } : {}),
+				translation_group: translationGroup,
 			})
 			.execute();
 
@@ -192,22 +274,46 @@ export class BylineRepository {
 		return await this.findById(id);
 	}
 
+	/**
+	 * Delete a byline row. When this row is the last sibling in its
+	 * translation group, also drops every junction row pointing at the group
+	 * and clears `primary_byline_id` references. When other siblings remain
+	 * in the group, junctions and `primary_byline_id` pointers stay intact —
+	 * the credit lives on at other locales.
+	 *
+	 * Migration 040 dropped the FK on `_emdash_content_bylines.byline_id`, so
+	 * this cascade is implemented here in application code.
+	 */
 	async delete(id: string): Promise<boolean> {
 		const existing = await this.findById(id);
 		if (!existing) return false;
 
-		await withTransaction(this.db, async (trx) => {
-			await trx.deleteFrom("_emdash_content_bylines").where("byline_id", "=", id).execute();
+		const group = existing.translationGroup ?? existing.id;
 
+		await withTransaction(this.db, async (trx) => {
 			await trx.deleteFrom("_emdash_bylines").where("id", "=", id).execute();
 
+			// Count remaining siblings in the translation group. If none
+			// remain, purge dependent rows; otherwise leave them intact so
+			// the credit still resolves at other locales.
+			const remaining = await trx
+				.selectFrom("_emdash_bylines")
+				.select(({ fn }) => [fn.count<number>("id").as("count")])
+				.where("translation_group", "=", group)
+				.executeTakeFirst();
+			const remainingCount = Number(remaining?.count ?? 0);
+			if (remainingCount > 0) return;
+
+			// Last sibling gone: cascade in application code.
+			await trx.deleteFrom("_emdash_content_bylines").where("byline_id", "=", group).execute();
+
 			const tableNames = await listTablesLike(trx, "ec_%");
 			for (const tableName of tableNames) {
 				validateIdentifier(tableName, "content table");
 				await sql`
 					UPDATE ${sql.ref(tableName)}
 					SET primary_byline_id = NULL
-					WHERE primary_byline_id = ${id}
+					WHERE primary_byline_id = ${group}
 				`.execute(trx);
 			}
 		});
@@ -215,13 +321,21 @@ export class BylineRepository {
 		return true;
 	}
 
+	/**
+	 * Strict per-locale credit hydration. Joins `_emdash_content_bylines` to
+	 * `_emdash_bylines` on `translation_group = byline_id`, then filters to
+	 * the requested locale. Credits whose translation group lacks a row at
+	 * the requested locale are omitted — callers wanting fallback behaviour
+	 * apply it themselves. Mirrors `TaxonomyRepository.getTermsForEntry`.
+	 */
 	async getContentBylines(
 		collectionSlug: string,
 		contentId: string,
+		options?: { locale?: string },
 	): Promise<ContentBylineCredit[]> {
-		const rows = await this.db
+		let query = this.db
 			.selectFrom("_emdash_content_bylines as cb")
-			.innerJoin("_emdash_bylines as b", "b.id", "cb.byline_id")
+			.innerJoin("_emdash_bylines as b", "b.translation_group", "cb.byline_id")
 			.select([
 				"cb.sort_order as sort_order",
 				"cb.role_label as role_label",
@@ -235,12 +349,15 @@ export class BylineRepository {
 				"b.is_guest as is_guest",
 				"b.created_at as created_at",
 				"b.updated_at as updated_at",
+				"b.locale as locale",
+				"b.translation_group as translation_group",
 			])
 			.where("cb.collection_slug", "=", collectionSlug)
 			.where("cb.content_id", "=", contentId)
-			.orderBy("cb.sort_order", "asc")
-			.execute();
+			.orderBy("cb.sort_order", "asc");
+		if (options?.locale !== undefined) query = query.where("b.locale", "=", options.locale);
 
+		const rows = await query.execute();
 		return rows.map((row) => ({
 			byline: rowToByline(row),
 			sortOrder: row.sort_order,
@@ -249,21 +366,68 @@ export class BylineRepository {
 	}
 
 	/**
-	 * Batch-fetch byline credits for multiple content items in a single query.
-	 * Returns a Map keyed by contentId.
+	 * Does this entry have any explicit byline credits — at any locale?
+	 *
+	 * Used to disambiguate "no credits exist" (fall back to author-linked
+	 * byline) from "credits exist but don't resolve at the requested locale"
+	 * (strict per-locale model: render no byline). Without this check the
+	 * locale-strict hydration would silently turn a missing translation into
+	 * an author-inferred byline, contradicting editorial intent.
+	 */
+	async hasContentBylines(collectionSlug: string, contentId: string): Promise<boolean> {
+		const row = await this.db
+			.selectFrom("_emdash_content_bylines")
+			.select("id")
+			.where("collection_slug", "=", collectionSlug)
+			.where("content_id", "=", contentId)
+			.limit(1)
+			.executeTakeFirst();
+		return row !== undefined;
+	}
+
+	/**
+	 * Batch variant of `hasContentBylines`. Returns the set of content IDs
+	 * that have at least one junction row (locale-agnostic).
+	 */
+	async hasContentBylinesMany(collectionSlug: string, contentIds: string[]): Promise<Set<string>> {
+		const result = new Set<string>();
+		if (contentIds.length === 0) return result;
+
+		const uniqueContentIds = [...new Set(contentIds)];
+		for (const chunk of chunks(uniqueContentIds, SQL_BATCH_SIZE)) {
+			const rows = await this.db
+				.selectFrom("_emdash_content_bylines")
+				.select("content_id")
+				.distinct()
+				.where("collection_slug", "=", collectionSlug)
+				.where("content_id", "in", chunk)
+				.execute();
+			for (const row of rows) result.add(row.content_id);
+		}
+		return result;
+	}
+
+	/**
+	 * Batch variant of `getContentBylines`. Same strict-per-locale semantics
+	 * applied to the requested locale (single value, not per-entry).
+	 *
+	 * When callers need per-entry-locale filtering (e.g. a list endpoint
+	 * returning entries at mixed locales), they should group the input ids by
+	 * the entry's locale and call this method once per group.
 	 */
 	async getContentBylinesMany(
 		collectionSlug: string,
 		contentIds: string[],
+		options?: { locale?: string },
 	): Promise<Map<string, ContentBylineCredit[]>> {
 		const result = new Map<string, ContentBylineCredit[]>();
 		if (contentIds.length === 0) return result;
 
 		const uniqueContentIds = [...new Set(contentIds)];
 		for (const chunk of chunks(uniqueContentIds, SQL_BATCH_SIZE)) {
-			const rows = await this.db
+			let query = this.db
 				.selectFrom("_emdash_content_bylines as cb")
-				.innerJoin("_emdash_bylines as b", "b.id", "cb.byline_id")
+				.innerJoin("_emdash_bylines as b", "b.translation_group", "cb.byline_id")
 				.select([
 					"cb.content_id as content_id",
 					"cb.sort_order as sort_order",
@@ -278,11 +442,15 @@ export class BylineRepository {
 					"b.is_guest as is_guest",
 					"b.created_at as created_at",
 					"b.updated_at as updated_at",
+					"b.locale as locale",
+					"b.translation_group as translation_group",
 				])
 				.where("cb.collection_slug", "=", collectionSlug)
 				.where("cb.content_id", "in", chunk)
-				.orderBy("cb.sort_order", "asc")
-				.execute();
+				.orderBy("cb.sort_order", "asc");
+			if (options?.locale !== undefined) query = query.where("b.locale", "=", options.locale);
+
+			const rows = await query.execute();
 
 			for (const row of rows) {
 				const contentId = row.content_id;
@@ -305,18 +473,20 @@ export class BylineRepository {
 
 	/**
 	 * Batch-fetch byline profiles linked to user IDs in a single query.
-	 * Returns a Map keyed by userId.
+	 * Strict-locale variant of `findByUserId`.
 	 */
-	async findByUserIds(userIds: string[]): Promise<Map<string, BylineSummary>> {
+	async findByUserIds(
+		userIds: string[],
+		options?: { locale?: string },
+	): Promise<Map<string, BylineSummary>> {
 		const result = new Map<string, BylineSummary>();
 		if (userIds.length === 0) return result;
 
 		for (const chunk of chunks(userIds, SQL_BATCH_SIZE)) {
-			const rows = await this.db
-				.selectFrom("_emdash_bylines")
-				.selectAll()
-				.where("user_id", "in", chunk)
-				.execute();
+			let query = this.db.selectFrom("_emdash_bylines").selectAll().where("user_id", "in", chunk);
+			if (options?.locale !== undefined) query = query.where("locale", "=", options.locale);
+
+			const rows = await query.execute();
 
 			for (const row of rows) {
 				if (row.user_id) {
@@ -327,6 +497,85 @@ export class BylineRepository {
 		return result;
 	}
 
+	/**
+	 * Clone every junction row from `sourceContentId` to `targetContentId`,
+	 * preserving `sort_order` and `role_label`. Used by the content
+	 * translation flow: a newly created translation inherits the source's
+	 * byline credits at the storage level. Because the junction stores
+	 * `translation_group` (not a row id), the copy is locale-agnostic — the
+	 * credits resolve to whichever locale variants of each byline exist when
+	 * the translated entry is hydrated.
+	 *
+	 * No-op when the source has no credits. Skips when the target already
+	 * has credits (idempotent for re-runs).
+	 */
+	async copyContentBylines(
+		collection: string,
+		sourceContentId: string,
+		targetContentId: string,
+	): Promise<void> {
+		validateIdentifier(collection, "collection slug");
+		const tableName = `ec_${collection}`;
+		validateIdentifier(tableName, "content table");
+
+		// Like `setContentBylines`, this method is expected to be called
+		// within a transaction context (content handlers wrap in
+		// withTransaction). All operations use `this.db` directly so an
+		// outer transaction can serialise the copy alongside the create.
+		const existing = await this.db
+			.selectFrom("_emdash_content_bylines")
+			.select("id")
+			.where("collection_slug", "=", collection)
+			.where("content_id", "=", targetContentId)
+			.executeTakeFirst();
+		if (existing) return;
+
+		const sourceRows = await this.db
+			.selectFrom("_emdash_content_bylines")
+			.select(["byline_id", "sort_order", "role_label"])
+			.where("collection_slug", "=", collection)
+			.where("content_id", "=", sourceContentId)
+			.orderBy("sort_order", "asc")
+			.execute();
+		if (sourceRows.length === 0) return;
+
+		const now = new Date().toISOString();
+		await this.db
+			.insertInto("_emdash_content_bylines")
+			.values(
+				sourceRows.map((row) => ({
+					id: ulid(),
+					collection_slug: collection,
+					content_id: targetContentId,
+					byline_id: row.byline_id,
+					sort_order: row.sort_order,
+					role_label: row.role_label,
+					created_at: now,
+				})),
+			)
+			.execute();
+
+		// Mirror primary_byline_id from source so the cached pointer on the
+		// target row matches the junction state we just wrote.
+		const firstByline = sourceRows[0]?.byline_id ?? null;
+		await sql`
+			UPDATE ${sql.ref(tableName)}
+			SET primary_byline_id = ${firstByline}
+			WHERE id = ${targetContentId}
+		`.execute(this.db);
+	}
+
+	/**
+	 * Replace the set of byline credits on a content entry. Accepts row ids
+	 * at the wire (consistent with how the admin sends them), translates
+	 * each to its `translation_group` on write, and stores the group in
+	 * `_emdash_content_bylines.byline_id` and `ec_*.primary_byline_id`.
+	 *
+	 * The returned credits are hydrated with strict-locale matching at the
+	 * locale of the rows the caller supplied (i.e. the locale of the byline
+	 * each `bylineId` resolves to) — adequate for the autosave round-trip,
+	 * which then re-hydrates the entry against its own locale separately.
+	 */
 	async setContentBylines(
 		collectionSlug: string,
 		contentId: string,
@@ -336,29 +585,48 @@ export class BylineRepository {
 		const tableName = `ec_${collectionSlug}`;
 		validateIdentifier(tableName, "content table");
 
-		const seen = new Set<string>();
-		const bylines = inputBylines.filter((item) => {
-			if (seen.has(item.bylineId)) return false;
-			seen.add(item.bylineId);
-			return true;
-		});
-
-		// This method is expected to be called within a transaction context
-		// (content handlers wrap in withTransaction, seed applies sequentially).
-		// All operations use this.db directly -- callers are responsible for
-		// wrapping in a transaction when atomicity is required.
-		if (bylines.length > 0) {
-			const ids = bylines.map((item) => item.bylineId);
+		// Resolve each wire row id to its translation_group up front so we
+		// can (a) validate the rows exist and (b) dedupe by the value that
+		// actually lands in the junction. Deduping by wire row id BEFORE
+		// resolving would let two locale siblings of the same byline slip
+		// through and trigger a UNIQUE(collection, content, byline_id)
+		// failure at insert time. A single SELECT keeps this O(1) DB
+		// calls regardless of how many credits are being set.
+		const idToGroup = new Map<string, string>();
+		if (inputBylines.length > 0) {
+			const wireIds = [...new Set(inputBylines.map((item) => item.bylineId))];
 			const rows = await this.db
 				.selectFrom("_emdash_bylines")
-				.select("id")
-				.where("id", "in", ids)
+				.select(["id", "translation_group"])
+				.where("id", "in", wireIds)
 				.execute();
-			if (rows.length !== ids.length) {
+			if (rows.length !== wireIds.length) {
 				throw new Error("One or more byline IDs do not exist");
 			}
+			for (const row of rows) {
+				idToGroup.set(row.id, row.translation_group ?? row.id);
+			}
 		}
 
+		// Dedupe by translation_group. Preserves the order of first
+		// occurrence so the editor's intent (which sibling appears first)
+		// is honored. `roleLabel` follows the first occurrence too.
+		const seenGroups = new Set<string>();
+		const bylines: Array<ContentBylineInput & { group: string }> = [];
+		for (const item of inputBylines) {
+			const group = idToGroup.get(item.bylineId);
+			if (!group) {
+				throw new Error(`Missing translation_group for byline ${item.bylineId}`);
+			}
+			if (seenGroups.has(group)) continue;
+			seenGroups.add(group);
+			bylines.push({ ...item, group });
+		}
+
+		// This method is expected to be called within a transaction context
+		// (content handlers wrap in withTransaction, seed applies sequentially).
+		// All operations use this.db directly -- callers are responsible for
+		// wrapping in a transaction when atomicity is required.
 		await this.db
 			.deleteFrom("_emdash_content_bylines")
 			.where("collection_slug", "=", collectionSlug)
@@ -367,13 +635,14 @@ export class BylineRepository {
 
 		for (let i = 0; i < bylines.length; i++) {
 			const item = bylines[i];
+			if (!item) continue;
 			await this.db
 				.insertInto("_emdash_content_bylines")
 				.values({
 					id: ulid(),
 					collection_slug: collectionSlug,
 					content_id: contentId,
-					byline_id: item.bylineId,
+					byline_id: item.group,
 					sort_order: i,
 					role_label: item.roleLabel ?? null,
 					created_at: new Date().toISOString(),
@@ -381,9 +650,10 @@ export class BylineRepository {
 				.execute();
 		}
 
+		const primaryGroup = bylines[0]?.group ?? null;
 		await sql`
 			UPDATE ${sql.ref(tableName)}
-			SET primary_byline_id = ${bylines[0]?.bylineId ?? null}
+			SET primary_byline_id = ${primaryGroup}
 			WHERE id = ${contentId}
 		`.execute(this.db);
 

package/src/database/repositories/media.ts

@@ -20,7 +20,7 @@ function normalizeMimeFilter(input?: string | readonly string[]): string[] {
 	return arr
 		.filter((entry): entry is string => typeof entry === "string" && entry.length > 0)
 		.map((entry) =>
-			entry.endsWith("/") ? entry.toLowerCase() : entry.split(";")[0]!.trim().toLowerCase(),
+			entry.endsWith("/") ? entry.toLowerCase() : entry.split(";")[0].trim().toLowerCase(),
 		);
 }
 
@@ -365,7 +365,7 @@ export class MediaRepository {
 			contentHash: row.content_hash,
 			blurhash: row.blurhash,
 			dominantColor: row.dominant_color,
-			// eslint-disable-next-line typescript-eslint(no-unsafe-type-assertion) -- DB stores string; validated at insert but linter can't follow
+			// eslint-disable-next-line typescript/no-unsafe-type-assertion -- DB stores string; validated at insert but linter can't follow
 			status: row.status as MediaStatus,
 			createdAt: row.created_at,
 			authorId: row.author_id,

package/src/database/repositories/menu.ts

@@ -463,7 +463,7 @@ export class MenuRepository {
 				.where("menu_id", "=", menuId)
 				.where("parent_id", "is", input.parentId ?? null)
 				.executeTakeFirst();
-			// eslint-disable-next-line typescript-eslint(no-unsafe-type-assertion) -- Kysely fn.max returns unknown; always a number for sort_order column
+			// eslint-disable-next-line typescript/no-unsafe-type-assertion -- Kysely fn.max returns unknown; always a number for sort_order column
 			sortOrder = ((maxOrder?.max as number) ?? -1) + 1;
 		}
 

package/src/database/repositories/options.ts

@@ -26,7 +26,7 @@ export class OptionsRepository {
 			.executeTakeFirst();
 
 		if (!row) return null;
-		// eslint-disable-next-line typescript-eslint(no-unsafe-type-assertion) -- JSON.parse returns any; generic callers provide T
+		// eslint-disable-next-line typescript/no-unsafe-type-assertion -- JSON.parse returns any; generic callers provide T
 		return JSON.parse(row.value) as T;
 	}
 
@@ -116,7 +116,7 @@ export class OptionsRepository {
 
 		const result = new Map<string, T>();
 		for (const row of rows) {
-			// eslint-disable-next-line typescript-eslint(no-unsafe-type-assertion) -- JSON.parse returns any; generic callers provide T
+			// eslint-disable-next-line typescript/no-unsafe-type-assertion -- JSON.parse returns any; generic callers provide T
 			result.set(row.name, JSON.parse(row.value) as T);
 		}
 		return result;
@@ -160,7 +160,7 @@ export class OptionsRepository {
 
 		const result = new Map<string, T>();
 		for (const row of rows) {
-			// eslint-disable-next-line typescript-eslint(no-unsafe-type-assertion) -- JSON.parse returns any; generic callers provide T
+			// eslint-disable-next-line typescript/no-unsafe-type-assertion -- JSON.parse returns any; generic callers provide T
 			result.set(row.name, JSON.parse(row.value) as T);
 		}
 		return result;

package/src/database/repositories/plugin-storage.ts

@@ -57,7 +57,7 @@ export class PluginStorageRepository<T = unknown> implements StorageCollection<T
 			.executeTakeFirst();
 
 		if (!row) return null;
-		// eslint-disable-next-line typescript-eslint(no-unsafe-type-assertion) -- JSON.parse returns any; generic callers provide T
+		// eslint-disable-next-line typescript/no-unsafe-type-assertion -- JSON.parse returns any; generic callers provide T
 		return JSON.parse(row.data) as T;
 	}
 
@@ -132,7 +132,7 @@ export class PluginStorageRepository<T = unknown> implements StorageCollection<T
 
 		const result = new Map<string, T>();
 		for (const row of rows) {
-			// eslint-disable-next-line typescript-eslint(no-unsafe-type-assertion) -- JSON.parse returns any; generic callers provide T
+			// eslint-disable-next-line typescript/no-unsafe-type-assertion -- JSON.parse returns any; generic callers provide T
 			result.set(row.id, JSON.parse(row.data) as T);
 		}
 		return result;
@@ -255,7 +255,7 @@ export class PluginStorageRepository<T = unknown> implements StorageCollection<T
 		const hasMore = rows.length > limit;
 		const items = rows.slice(0, limit).map((row) => ({
 			id: row.id,
-			// eslint-disable-next-line typescript-eslint(no-unsafe-type-assertion) -- JSON.parse returns any; generic callers provide T
+			// eslint-disable-next-line typescript/no-unsafe-type-assertion -- JSON.parse returns any; generic callers provide T
 			data: JSON.parse(row.data) as T,
 		}));
 

package/src/database/repositories/types.ts

@@ -63,6 +63,19 @@ export interface BylineSummary {
 	isGuest: boolean;
 	createdAt: string;
 	updatedAt: string;
+	/**
+	 * Locale this byline row is presented in. Added by migration 040.
+	 * `(slug, locale)` is unique; a single slug can repeat across locales.
+	 */
+	locale: string;
+	/**
+	 * Shared across translations of the same byline. Added by migration 040.
+	 * `_emdash_content_bylines.byline_id` and `ec_*.primary_byline_id` store
+	 * this value, so a credit spans every locale variant of a byline.
+	 * Nullable in storage for backwards compatibility; new rows always
+	 * populate it.
+	 */
+	translationGroup: string | null;
 }
 
 export interface ContentBylineCredit {

package/src/database/types.ts

@@ -502,6 +502,21 @@ export interface BylineTable {
 	is_guest: number;
 	created_at: Generated<string>;
 	updated_at: Generated<string>;
+	/**
+	 * Locale this byline row is presented in. Added by migration 040. Backfilled
+	 * to the configured `defaultLocale` for pre-040 rows. `(slug, locale)` is
+	 * unique; the partial unique on `user_id` widens to `(user_id, locale)`.
+	 */
+	locale: Generated<string>;
+	/**
+	 * Shared across translations of the same byline. Added by migration 040.
+	 * Equals `id` for the anchor row; siblings inherit it from their source.
+	 * `_emdash_content_bylines.byline_id` and `ec_*.primary_byline_id` store
+	 * this value rather than a row id, so credits span every locale variant of
+	 * a byline. Nullable in the schema for backwards compatibility; new rows
+	 * always populate it.
+	 */
+	translation_group: string | null;
 }
 
 export interface ContentBylineTable {