emdash 0.14.0 → 0.15.0

package/src/astro/routes/api/schema/collections/[slug]/index.ts

@@ -34,7 +34,7 @@ export const GET: APIRoute = async ({ params, url, locals }) => {
 	const query = parseQuery(url, collectionGetQuery);
 	if (isParseError(query)) return query;
 
-	const result = await handleSchemaCollectionGet(emdash!.db, slug, {
+	const result = await handleSchemaCollectionGet(emdash.db, slug, {
 		includeFields: query.includeFields ?? false,
 	});
 	return unwrapResult(result);
@@ -54,12 +54,12 @@ export const PUT: APIRoute = async ({ params, request, locals }) => {
 	if (isParseError(body)) return body;
 
 	const result = await handleSchemaCollectionUpdate(
-		emdash!.db,
+		emdash.db,
 		slug,
-		// eslint-disable-next-line typescript-eslint(no-unsafe-type-assertion) -- parseBody validates via Zod
+		// eslint-disable-next-line typescript/no-unsafe-type-assertion -- parseBody validates via Zod
 		body as UpdateCollectionInput,
 	);
-	emdash!.invalidateUrlPatternCache();
+	emdash.invalidateUrlPatternCache();
 	return unwrapResult(result);
 };
 
@@ -74,9 +74,9 @@ export const DELETE: APIRoute = async ({ params, url, locals }) => {
 	const denied = requirePerm(user, "schema:manage");
 	if (denied) return denied;
 
-	const result = await handleSchemaCollectionDelete(emdash!.db, slug, {
+	const result = await handleSchemaCollectionDelete(emdash.db, slug, {
 		force,
 	});
-	emdash!.invalidateUrlPatternCache();
+	emdash.invalidateUrlPatternCache();
 	return unwrapResult(result);
 };

package/src/astro/routes/api/schema/collections/index.ts

@@ -25,7 +25,7 @@ export const GET: APIRoute = async ({ locals }) => {
 	const denied = requirePerm(user, "schema:read");
 	if (denied) return denied;
 
-	const result = await handleSchemaCollectionList(emdash!.db);
+	const result = await handleSchemaCollectionList(emdash.db);
 	return unwrapResult(result);
 };
 
@@ -41,8 +41,8 @@ export const POST: APIRoute = async ({ request, locals }) => {
 	const body = await parseBody(request, createCollectionBody);
 	if (isParseError(body)) return body;
 
-	// eslint-disable-next-line typescript-eslint(no-unsafe-type-assertion) -- Zod schema output narrowed to CreateCollectionInput
-	const result = await handleSchemaCollectionCreate(emdash!.db, body as CreateCollectionInput);
-	emdash!.invalidateUrlPatternCache();
+	// eslint-disable-next-line typescript/no-unsafe-type-assertion -- Zod schema output narrowed to CreateCollectionInput
+	const result = await handleSchemaCollectionCreate(emdash.db, body as CreateCollectionInput);
+	emdash.invalidateUrlPatternCache();
 	return unwrapResult(result, 201);
 };

package/src/astro/routes/api/schema/index.ts

@@ -29,7 +29,7 @@ export const GET: APIRoute = async ({ request, locals }) => {
 	if (denied) return denied;
 
 	try {
-		const registry = new SchemaRegistry(emdash!.db);
+		const registry = new SchemaRegistry(emdash.db);
 
 		// Get all collections with their fields
 		const collections = await registry.listCollections();

package/src/astro/routes/api/schema/orphans/[slug].ts

@@ -31,6 +31,6 @@ export const POST: APIRoute = async ({ params, request, locals }) => {
 	const options = await parseOptionalBody(request, orphanRegisterBody, {});
 	if (isParseError(options)) return options;
 
-	const result = await handleOrphanedTableRegister(emdash!.db, slug, options);
+	const result = await handleOrphanedTableRegister(emdash.db, slug, options);
 	return unwrapResult(result, 201);
 };

package/src/astro/routes/api/schema/orphans/index.ts

@@ -21,6 +21,6 @@ export const GET: APIRoute = async ({ locals }) => {
 	const denied = requirePerm(user, "schema:manage");
 	if (denied) return denied;
 
-	const result = await handleOrphanedTableList(emdash!.db);
+	const result = await handleOrphanedTableList(emdash.db);
 	return unwrapResult(result);
 };

package/src/astro/routes/api/sections/[slug].ts

@@ -24,7 +24,7 @@ export const GET: APIRoute = async ({ params, locals }) => {
 	const { emdash, user } = locals;
 	const dbErr = requireDb(emdash?.db);
 	if (dbErr) return dbErr;
-	const db = emdash!.db;
+	const db = emdash.db;
 	const { slug } = params;
 
 	const denied = requirePerm(user, "sections:read");
@@ -46,7 +46,7 @@ export const PUT: APIRoute = async ({ params, request, locals }) => {
 	const { emdash, user } = locals;
 	const dbErr = requireDb(emdash?.db);
 	if (dbErr) return dbErr;
-	const db = emdash!.db;
+	const db = emdash.db;
 	const { slug } = params;
 
 	const denied = requirePerm(user, "sections:manage");
@@ -71,7 +71,7 @@ export const DELETE: APIRoute = async ({ params, locals }) => {
 	const { emdash, user } = locals;
 	const dbErr = requireDb(emdash?.db);
 	if (dbErr) return dbErr;
-	const db = emdash!.db;
+	const db = emdash.db;
 	const { slug } = params;
 
 	const denied = requirePerm(user, "sections:manage");

package/src/astro/routes/api/sections/index.ts

@@ -19,7 +19,7 @@ export const GET: APIRoute = async ({ url, locals }) => {
 	const { emdash, user } = locals;
 	const dbErr = requireDb(emdash?.db);
 	if (dbErr) return dbErr;
-	const db = emdash!.db;
+	const db = emdash.db;
 
 	const denied = requirePerm(user, "sections:read");
 	if (denied) return denied;
@@ -39,7 +39,7 @@ export const POST: APIRoute = async ({ request, locals }) => {
 	const { emdash, user } = locals;
 	const dbErr = requireDb(emdash?.db);
 	if (dbErr) return dbErr;
-	const db = emdash!.db;
+	const db = emdash.db;
 
 	const denied = requirePerm(user, "sections:manage");
 	if (denied) return denied;

package/src/astro/types.ts

@@ -427,6 +427,10 @@ export interface EmDashHandlers {
 	// Sandbox runner (for marketplace plugin install/update)
 	getSandboxRunner: () => import("../plugins/sandbox/types.js").SandboxRunner | null;
 
+	// Whether sandbox bypass mode (sandbox: false) is active. Marketplace
+	// install/update routes use this to skip the SANDBOX_NOT_AVAILABLE gate.
+	isSandboxBypassed: () => boolean;
+
 	// Sync marketplace plugin states (after install/update/uninstall)
 	syncMarketplacePlugins: () => Promise<void>;
 

package/src/auth/rate-limit.ts

@@ -119,7 +119,7 @@ export function rateLimitResponse(retryAfterSeconds: number): Response {
  */
 export function getClientIp(request: Request, trustedHeaders: string[] = []): string | null {
 	const headers = request.headers;
-	// eslint-disable-next-line typescript-eslint(no-unsafe-type-assertion) -- CF Workers runtime shape
+	// eslint-disable-next-line typescript/no-unsafe-type-assertion -- CF Workers runtime shape
 	const cf = (request as unknown as { cf?: Record<string, unknown> }).cf;
 
 	// On Cloudflare, prefer the cryptographically trustworthy headers. An

package/src/auth/trusted-proxy.ts

@@ -56,7 +56,7 @@ function getEnvTrustedHeaders(): string[] {
 		// value at runtime (Vite/Astro inline import.meta.env at build time,
 		// which locks the value into the bundle). Fall back to import.meta.env
 		// for bundler-managed environments where process.env isn't populated.
-		// eslint-disable-next-line typescript-eslint(no-unsafe-type-assertion) -- import.meta.env shape varies by bundler
+		// eslint-disable-next-line typescript/no-unsafe-type-assertion -- import.meta.env shape varies by bundler
 		const importMetaEnv = (import.meta as unknown as { env?: Record<string, string | undefined> })
 			.env;
 		raw =

package/src/bylines/index.ts

@@ -4,6 +4,16 @@
  * Provides functions to query byline profiles and byline credits
  * associated with content entries. Follows the same pattern as
  * the taxonomies runtime API.
+ *
+ * i18n model (migration 040): byline rows are per-locale and share a
+ * `translation_group`. Credits on `_emdash_content_bylines.byline_id` store
+ * the translation_group, so a single credit spans every locale of a byline.
+ *
+ * Hydration is strict per locale: a credit at locale X renders iff a byline
+ * row exists at locale X within the credited translation_group. There is no
+ * read-time fallback. Mirrors `getEntryTerms` and the convention in PR #916.
+ * Locale is passed in by callers — `query.ts` resolves it from the entry's
+ * own `data.locale` for the runtime path.
  */
 
 import { sql } from "kysely";
@@ -11,7 +21,9 @@ import { sql } from "kysely";
 import { BylineRepository } from "../database/repositories/byline.js";
 import type { BylineSummary, ContentBylineCredit } from "../database/repositories/types.js";
 import { validateIdentifier } from "../database/validate.js";
+import { resolveLocaleChain } from "../i18n/resolve.js";
 import { getDb } from "../loader.js";
+import { requestCached } from "../request-cache.js";
 import { isMissingTableError } from "../utils/db-errors.js";
 
 /**
@@ -49,28 +61,60 @@ export async function getByline(id: string): Promise<BylineSummary | null> {
 /**
  * Get a byline by slug.
  *
+ * Standalone identity lookup (e.g. rendering an author profile page). Walks
+ * the configured locale fallback chain — same pattern as `getMenu` and
+ * `getTerm`, see PR #916. Returns the first match found, walking
+ * `[requestedLocale, ...fallbacks, defaultLocale]` in order.
+ *
+ * Note: this is intentionally different from credit hydration on a content
+ * entry (`getEntryBylines`), which is strict per locale with no fallback.
+ * The distinction: identity lookups answer "give me this byline", and
+ * falling back to another locale's display name is acceptable. Credit
+ * hydration answers "what should render on this entry", where falling back
+ * silently surfaces a stale-locale name and contradicts editorial intent.
+ *
  * @example
  * ```ts
  * import { getBylineBySlug } from "emdash";
  *
- * const byline = await getBylineBySlug("jane-doe");
+ * const byline = await getBylineBySlug("jane-doe", { locale: "de-de" });
  * if (byline) {
- *   console.log(byline.displayName); // "Jane Doe"
+ *   console.log(byline.displayName);
  * }
  * ```
  */
-export async function getBylineBySlug(slug: string): Promise<BylineSummary | null> {
-	const db = await getDb();
-	const repo = new BylineRepository(db);
-	return repo.findBySlug(slug);
+export async function getBylineBySlug(
+	slug: string,
+	options?: { locale?: string },
+): Promise<BylineSummary | null> {
+	const chain = resolveLocaleChain(options?.locale);
+	const cacheKey = `byline-by-slug:${slug}:${chain.length > 0 ? chain.join(",") : "*"}`;
+	return requestCached(cacheKey, async () => {
+		const db = await getDb();
+		const repo = new BylineRepository(db);
+
+		if (chain.length === 0) {
+			// No i18n or no resolved locale — fall back to the repo's
+			// "lowest-locale-code" deterministic match.
+			return repo.findBySlug(slug);
+		}
+
+		for (const locale of chain) {
+			const row = await repo.findBySlug(slug, { locale });
+			if (row) return row;
+		}
+		return null;
+	});
 }
 
 /**
  * Get byline credits for a single content entry.
  *
- * Returns explicit byline credits from the junction table. If none exist
- * but the entry has an `authorId`, falls back to the user-linked byline
- * (marked as source: "inferred").
+ * Strict per locale (post-migration 040): a credit renders iff a byline row
+ * exists at the requested locale within the credited translation_group.
+ * Callers wanting fallback behaviour apply it themselves. When `locale` is
+ * omitted, returns every locale variant of every credit on the entry —
+ * useful for admin tooling, not for end-user rendering.
  *
  * Internal: not re-exported from the `emdash` package entry point. Every
  * entry returned by `getEmDashCollection` / `getEmDashEntry` already has
@@ -81,20 +125,26 @@ export async function getBylineBySlug(slug: string): Promise<BylineSummary | nul
 export async function getEntryBylines(
 	collection: string,
 	entryId: string,
+	options?: { locale?: string },
 ): Promise<ContentBylineCredit[]> {
 	validateIdentifier(collection, "collection");
 	const db = await getDb();
 	const repo = new BylineRepository(db);
 
-	const explicit = await repo.getContentBylines(collection, entryId);
+	const localeOpt = options?.locale !== undefined ? { locale: options.locale } : undefined;
+	const explicit = await repo.getContentBylines(collection, entryId, localeOpt);
 	if (explicit.length > 0) {
 		return explicit.map((c) => ({ ...c, source: "explicit" as const }));
 	}
 
-	// Fallback: look up user-linked byline from author_id
-	const authorId = await getAuthorId(db, collection, entryId);
-	if (authorId) {
-		const fallback = await repo.findByUserId(authorId);
+	// `primary_byline_id` is the explicit-credit sentinel: non-null
+	// suppresses author fallback even when the credit doesn't resolve
+	// at this locale.
+	const ctx = await getEntryContext(db, collection, entryId);
+	if (ctx.primaryBylineId) return [];
+
+	if (ctx.authorId) {
+		const fallback = await repo.findByUserId(ctx.authorId, localeOpt);
 		if (fallback) {
 			return [{ byline: fallback, sortOrder: 0, roleLabel: null, source: "inferred" }];
 		}
@@ -104,19 +154,27 @@ export async function getEntryBylines(
 }
 
 /**
- * An entry reference for batch byline lookups.
+ * Entry reference for batch byline lookups. Passing `authorId`,
+ * `primaryBylineId`, and `locale` in directly avoids a per-entry
+ * `SELECT` against the content table during hydration.
  *
- * `authorId` is read directly from the row when computing the inferred-byline
- * fallback — passing it in avoids a redundant `SELECT id, author_id` against
- * the content table after every list/entry fetch.
+ * `primaryBylineId` is the explicit-credit sentinel — non-null suppresses
+ * author fallback. `locale` drives the strict per-locale join.
  */
 export interface BylineEntry {
 	id: string;
 	authorId: string | null;
+	primaryBylineId?: string | null;
+	locale?: string | null;
 }
 
 /**
- * Batch-fetch byline credits for multiple content entries in a single query.
+ * Batch-fetch byline credits for multiple content entries.
+ *
+ * Per-entry strict-locale hydration: entries are bucketed by `entry.locale`
+ * and each bucket gets a single batched call to the strict-locale repo
+ * method. Items with no `locale` field (legacy / single-locale installs)
+ * share an unscoped bucket.
  *
  * Internal: consumed by `hydrateEntryBylines` in `query.ts` so that every
  * entry returned from `getEmDashCollection` / `getEmDashEntry` already has
@@ -125,7 +183,7 @@ export interface BylineEntry {
  * from the `emdash` package entry point.
  *
  * @param collection - The collection slug (e.g., "posts")
- * @param entries - Entry id + authorId pairs (authorId is already on the row)
+ * @param entries - Entry id + authorId + locale (each entry resolves at its own locale)
  * @returns Map from entry ID to array of byline credits
  */
 export async function getBylinesForEntries(
@@ -145,33 +203,73 @@ export async function getBylinesForEntries(
 
 	const db = await getDb();
 	const repo = new BylineRepository(db);
-	const entryIds = entries.map((e) => e.id);
-
-	// Sites with no bylines get an empty map back for one query — the previous
-	// "has any bylines" probe traded an extra round-trip on every request to
-	// save that one query on empty sites, which is exactly backwards for the
-	// common case. Pre-migration databases (bylines table missing) fall
-	// through to the `isMissingTableError` catch below and return empty.
-	let bylinesMap;
-	try {
-		bylinesMap = await repo.getContentBylinesMany(collection, entryIds);
-	} catch (error) {
-		if (isMissingTableError(error)) return result;
-		throw error;
+
+	// Bucket entries by locale so each bucket fires a single strict-locale
+	// `getContentBylinesMany` call. Items with no locale field share a
+	// bucket keyed by null (no `WHERE locale = ?` applied — legacy
+	// pre-i18n shape).
+	const buckets = new Map<string | null, BylineEntry[]>();
+	for (const entry of entries) {
+		const key = entry.locale ?? null;
+		const bucket = buckets.get(key);
+		if (bucket) bucket.push(entry);
+		else buckets.set(key, [entry]);
 	}
 
-	const needsFallback = new Map<string, string>();
-	for (const { id, authorId } of entries) {
-		if (!bylinesMap.has(id) && authorId) {
-			needsFallback.set(id, authorId);
+	// Sites with no bylines get an empty map back at the same cost as the
+	// 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.
+	const explicitByEntry = new Map<string, ContentBylineCredit[]>();
+	const entriesNeedingAuthorCheck: BylineEntry[] = [];
+	for (const [locale, bucket] of buckets) {
+		const localeOpt = locale ? { locale } : undefined;
+		const bucketIds = bucket.map((e) => e.id);
+		let bylinesMap;
+		try {
+			bylinesMap = await repo.getContentBylinesMany(collection, bucketIds, localeOpt);
+		} catch (error) {
+			if (isMissingTableError(error)) return result;
+			throw error;
+		}
+		for (const [id, list] of bylinesMap) explicitByEntry.set(id, list);
+
+		for (const entry of bucket) {
+			const hasResolved = bylinesMap.has(entry.id) && bylinesMap.get(entry.id)!.length > 0;
+			if (hasResolved) continue;
+			if (entry.authorId) entriesNeedingAuthorCheck.push(entry);
 		}
 	}
 
-	const uniqueAuthorIds = [...new Set(needsFallback.values())];
-	const authorBylineMap = await repo.findByUserIds(uniqueAuthorIds);
+	// Only entries without an explicit credit (primaryBylineId null) are
+	// eligible for author fallback.
+	const fallbackByEntry = new Map<string, BylineSummary>();
+	if (entriesNeedingAuthorCheck.length > 0) {
+		const authorBuckets = new Map<string | null, BylineEntry[]>();
+		for (const entry of entriesNeedingAuthorCheck) {
+			if (entry.primaryBylineId) continue;
+			const key = entry.locale ?? null;
+			const bucket = authorBuckets.get(key);
+			if (bucket) bucket.push(entry);
+			else authorBuckets.set(key, [entry]);
+		}
+
+		for (const [locale, bucket] of authorBuckets) {
+			const localeOpt = locale ? { locale } : undefined;
+			const authorIds = bucket.map((e) => e.authorId).filter((id): id is string => id !== null);
+			const uniqueAuthorIds = [...new Set(authorIds)];
+			if (uniqueAuthorIds.length === 0) continue;
+			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);
+			}
+		}
+	}
 
 	for (const { id } of entries) {
-		const explicit = bylinesMap.get(id);
+		const explicit = explicitByEntry.get(id);
 		if (explicit && explicit.length > 0) {
 			result.set(
 				id,
@@ -180,35 +278,36 @@ export async function getBylinesForEntries(
 			continue;
 		}
 
-		const authorId = needsFallback.get(id);
-		if (authorId) {
-			const fallback = authorBylineMap.get(authorId);
-			if (fallback) {
-				result.set(id, [{ byline: fallback, sortOrder: 0, roleLabel: null, source: "inferred" }]);
-			}
+		const fallback = fallbackByEntry.get(id);
+		if (fallback) {
+			result.set(id, [{ byline: fallback, sortOrder: 0, roleLabel: null, source: "inferred" }]);
 		}
 	}
 
 	return result;
 }
 
-/**
- * Look up the author_id for a single content entry.
- * Uses raw SQL since we need dynamic table names.
- */
-async function getAuthorId(
+/** Reads `author_id` + `primary_byline_id` for one entry in a single query. */
+async function getEntryContext(
 	db: Awaited<ReturnType<typeof getDb>>,
 	collection: string,
 	entryId: string,
-): Promise<string | null> {
+): Promise<{ authorId: string | null; primaryBylineId: string | null }> {
 	validateIdentifier(collection, "collection");
 	const tableName = `ec_${collection}`;
 
-	const result = await sql<{ author_id: string | null }>`
-		SELECT author_id FROM ${sql.ref(tableName)}
+	const result = await sql<{
+		author_id: string | null;
+		primary_byline_id: string | null;
+	}>`
+		SELECT author_id, primary_byline_id FROM ${sql.ref(tableName)}
 		WHERE id = ${entryId}
 		LIMIT 1
 	`.execute(db);
 
-	return result.rows[0]?.author_id ?? null;
+	const row = result.rows[0];
+	return {
+		authorId: row?.author_id ?? null,
+		primaryBylineId: row?.primary_byline_id ?? null,
+	};
 }

package/src/cli/commands/init.ts

@@ -9,6 +9,7 @@ import { resolve } from "node:path";
 
 import { defineCommand } from "citty";
 import consola from "consola";
+import { sql } from "kysely";
 
 import { createDatabase } from "../../database/connection.js";
 import { runMigrations } from "../../database/migrations/runner.js";
@@ -44,10 +45,10 @@ async function readPackageJson(cwd: string): Promise<PackageJson | null> {
 }
 
 async function runSqlFile(db: ReturnType<typeof createDatabase>, filePath: string): Promise<void> {
-	const sql = await readFile(filePath, "utf-8");
+	const contents = await readFile(filePath, "utf-8");
 
 	// Remove single-line comments
-	const withoutComments = sql
+	const withoutComments = contents
 		.split("\n")
 		.filter((line) => !line.trim().startsWith("--"))
 		.join("\n");
@@ -59,11 +60,7 @@ async function runSqlFile(db: ReturnType<typeof createDatabase>, filePath: strin
 		.filter((s) => s.length > 0);
 
 	for (const statement of statements) {
-		await db.executeQuery({
-			sql: statement,
-			parameters: [],
-			query: { kind: "RawNode", sqlFragments: [statement], parameters: [] },
-		});
+		await db.executeQuery(sql.raw(statement).compile(db));
 	}
 }
 
@@ -73,7 +70,6 @@ async function runSqlFile(db: ReturnType<typeof createDatabase>, filePath: strin
 async function isAlreadyInitialized(db: ReturnType<typeof createDatabase>): Promise<boolean> {
 	try {
 		// Use raw SQL since this runs on an untyped database connection
-		const { sql } = await import("kysely");
 		const result = await sql<{
 			count: number;
 		}>`SELECT COUNT(id) as count FROM _emdash_collections`.execute(db);

package/src/client/index.ts

@@ -19,7 +19,7 @@
 
 import mime from "mime/lite";
 
-import type { PortableTextBlock, FieldSchema } from "./portable-text.js";
+import type { FieldSchema } from "./portable-text.js";
 import { convertDataForRead, convertDataForWrite } from "./portable-text.js";
 import type { Interceptor } from "./transport.js";
 import {

package/src/components/InlinePortableTextEditor.tsx

@@ -26,6 +26,7 @@ import * as React from "react";
 import { createPortal } from "react-dom";
 
 import { computeThumbnailSize } from "../media/thumbnail.js";
+import { InlineCodeBlockExtension } from "./inline-code-block.js";
 
 // ── Portable Text types ────────────────────────────────────────────
 
@@ -1137,7 +1138,7 @@ function InlineMediaPicker({
 				const r = await ecFetch(url);
 				const d = await r.json();
 				const raw = d.data.items ?? [];
-				// eslint-disable-next-line typescript-eslint(no-unsafe-type-assertion) -- API response items mapped to MediaItem shape
+				// eslint-disable-next-line typescript/no-unsafe-type-assertion -- API response items mapped to MediaItem shape
 				const typedRaw = raw as Array<{
 					id: string;
 					filename?: string;
@@ -1765,7 +1766,10 @@ export function InlinePortableTextEditor({
 			StarterKit.configure({
 				heading: { levels: [1, 2, 3] },
 				dropcursor: { color: "#3b82f6", width: 2 },
+				// Replaced with InlineCodeBlockExtension below (adds language picker).
+				codeBlock: false,
 			}),
+			InlineCodeBlockExtension,
 			Image.extend({
 				addAttributes() {
 					return {