emdash 1.0.1 → 1.1.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "emdash",
-  "version": "1.0.1",
+  "version": "1.1.0",
   "description": "Astro-native CMS with WordPress migration support",
   "type": "module",
   "main": "dist/index.mjs",
@@ -57,6 +57,7 @@
     "./ui": "./src/ui.ts",
     "./ui/comments": "./src/ui-comments.ts",
     "./ui/search": "./src/components/LiveSearch.astro",
+    "./ui/webmcp-search": "./src/components/WebMcpSearch.astro",
     "./cli": {
       "types": "./dist/cli/index.d.mts",
       "default": "./dist/cli/index.mjs"
@@ -84,6 +85,11 @@
       "default": "./dist/auth/providers/google.mjs"
     },
     "./auth/providers/google-admin": "./src/auth/providers/google-admin.tsx",
+    "./auth/providers/microsoft": {
+      "types": "./dist/auth/providers/microsoft.d.mts",
+      "default": "./dist/auth/providers/microsoft.mjs"
+    },
+    "./auth/providers/microsoft-admin": "./src/auth/providers/microsoft-admin.tsx",
     "./db": {
       "types": "./dist/db/index.d.mts",
       "default": "./dist/db/index.mjs"
@@ -289,11 +295,11 @@
     "upng-js": "^2.1.0",
     "zod": "4.5.4",
     "@atcute/client": "^5.0.0",
-    "@emdash-cms/admin": "1.0.1",
-    "@emdash-cms/auth": "1.0.1",
-    "@emdash-cms/blocks": "1.0.1",
-    "@emdash-cms/gutenberg-to-portable-text": "1.0.1",
+    "@emdash-cms/admin": "1.1.0",
+    "@emdash-cms/auth": "1.1.0",
     "@emdash-cms/plugin-types": "0.5.0",
+    "@emdash-cms/blocks": "1.1.0",
+    "@emdash-cms/gutenberg-to-portable-text": "1.1.0",
     "@emdash-cms/registry-client": "0.7.0",
     "@emdash-cms/registry-lexicons": "0.7.0",
     "@emdash-cms/registry-verification": "0.3.3"

package/src/api/errors.ts

@@ -391,6 +391,9 @@ export const ErrorCode = {
 	DASHBOARD_ERROR: "DASHBOARD_ERROR",
 	DASHBOARD_STATS_ERROR: "DASHBOARD_STATS_ERROR",
 
+	// Calendar
+	CALENDAR_ERROR: "CALENDAR_ERROR",
+
 	// Misc
 	SNAPSHOT_ERROR: "SNAPSHOT_ERROR",
 	TYPEGEN_ERROR: "TYPEGEN_ERROR",

package/src/api/handlers/bylines.ts

@@ -116,7 +116,10 @@ export async function handleBylineTranslations(
 
 /**
  * Create a new byline. When `translationOf` is supplied, the new row joins the
- * source byline's translation_group (a sibling in the same logical identity).
+ * source byline's translation_group (a sibling in the same logical identity)
+ * and keeps the source's linked user unless `userId` is given. A user can own
+ * one byline per locale, so linking a user who already has a byline in the
+ * target locale returns CONFLICT.
  *
  * Translating from a source row only makes sense when the caller names the
  * target locale, otherwise we'd silently clone into the configured default,
@@ -147,6 +150,7 @@ export async function handleBylineCreate(
 		// Existence check up front so the repo's "Source not found" throw
 		// becomes a clean NOT_FOUND on the API.
 		let sourceGroup: string | undefined;
+		let sourceUserId: string | null = null;
 		if (input.translationOf) {
 			const source = await repo.findById(input.translationOf);
 			if (!source) {
@@ -159,8 +163,10 @@ export async function handleBylineCreate(
 				};
 			}
 			sourceGroup = source.translationGroup ?? source.id;
+			sourceUserId = source.userId;
 		}
 
+		const userId = input.userId === undefined ? sourceUserId : input.userId;
 		const effectiveLocale = locale ?? getI18nConfig()?.defaultLocale ?? "en";
 
 		// Translation-group guard: the row-per-locale model (PR #916)
@@ -196,7 +202,7 @@ export async function handleBylineCreate(
 			const inputHasFields = !!input.customFields && Object.keys(input.customFields).length > 0;
 			if (
 				inputHasFields &&
-				bylineFixedFieldsMatch(existing, input, effectiveLocale) &&
+				bylineFixedFieldsMatch(existing, { ...input, userId }, effectiveLocale) &&
 				existing.translationGroup === expectedTranslationGroup &&
 				existingCustomFieldsAreSubsetOf(existing.customFields ?? {}, input.customFields)
 			) {
@@ -217,7 +223,22 @@ export async function handleBylineCreate(
 			};
 		}
 
-		const byline = await repo.create({ ...input, locale: effectiveLocale });
+		// Runs after the slug check: a retried partial create already owns this
+		// user link, and the recovery branch above has to see that row first.
+		if (userId) {
+			const linked = await repo.findByUserId(userId, { locale: effectiveLocale });
+			if (linked) {
+				return {
+					success: false,
+					error: {
+						code: "CONFLICT",
+						message: `This user is already linked to byline "${linked.slug}" in locale "${effectiveLocale}"`,
+					},
+				};
+			}
+		}
+
+		const byline = await repo.create({ ...input, userId, locale: effectiveLocale });
 		return { success: true, data: byline };
 	} catch (error) {
 		// Mirror handleBylineUpdate: surface customFields validation

package/src/api/handlers/calendar.ts

@@ -0,0 +1,246 @@
+/**
+ * Calendar handler
+ *
+ * Lists published entries at their publish time and scheduled entries at
+ * their scheduled time, across every visible collection, in time order.
+ */
+
+import { sql, type Kysely, type RawBuilder } from "kysely";
+
+import {
+	InvalidCursorError,
+	decodeCursor,
+	encodeCursor,
+} from "../../database/repositories/types.js";
+import type { Database } from "../../database/types.js";
+import { validateIdentifier } from "../../database/validate.js";
+import type { ApiResult } from "../types.js";
+
+export type CalendarEntryKind = "published" | "scheduled";
+
+export interface CalendarEntry {
+	collection: string;
+	id: string;
+	locale: string;
+	title: string;
+	status: string;
+	kind: CalendarEntryKind;
+	at: string;
+}
+
+export interface CalendarEntriesResponse {
+	items: CalendarEntry[];
+	nextCursor?: string;
+}
+
+export interface CalendarEntriesParams {
+	from: string;
+	to: string;
+	cursor?: string;
+	limit: number;
+}
+
+const KINDS: readonly CalendarEntryKind[] = ["published", "scheduled"];
+const KIND_COLUMN = { published: "published_at", scheduled: "scheduled_at" } as const;
+const TITLE_FIELD_TYPES = ["string", "text", "slug"];
+const SLUG_PATTERN = /^[a-z][a-z0-9_]*$/;
+
+interface Stream {
+	collection: string;
+	kind: CalendarEntryKind;
+	title: RawBuilder<string>;
+}
+
+interface CalendarCursor {
+	at: string;
+	collection: string;
+	kind: CalendarEntryKind;
+	id: string;
+}
+
+interface StreamRow {
+	id: string;
+	locale: string;
+	status: string;
+	title: string;
+	event_at: string;
+}
+
+function compareText(a: string, b: string): number {
+	return a < b ? -1 : a > b ? 1 : 0;
+}
+
+/** Streams run in collection slug order, published before scheduled. */
+function compareStreams(
+	a: { collection: string; kind: CalendarEntryKind },
+	b: { collection: string; kind: CalendarEntryKind },
+): number {
+	return compareText(a.collection, b.collection) || KINDS.indexOf(a.kind) - KINDS.indexOf(b.kind);
+}
+
+function isKind(value: string | undefined): value is CalendarEntryKind {
+	return value === "published" || value === "scheduled";
+}
+
+/** Stored timestamps are canonical `toISOString()` values. */
+function isCanonicalTime(value: string): boolean {
+	const time = Date.parse(value);
+	return !Number.isNaN(time) && new Date(time).toISOString() === value;
+}
+
+function encodeCalendarCursor(entry: CalendarEntry): string {
+	return encodeCursor(`${entry.at}|${entry.collection}|${entry.kind}`, entry.id);
+}
+
+function decodeCalendarCursor(cursor: string): CalendarCursor {
+	const { orderValue, id } = decodeCursor(cursor);
+	const [at = "", collection = "", kind, ...rest] = orderValue.split("|");
+	if (
+		rest.length > 0 ||
+		!isCanonicalTime(at) ||
+		!SLUG_PATTERN.test(collection) ||
+		!isKind(kind) ||
+		!id
+	) {
+		throw new InvalidCursorError(cursor);
+	}
+	return { at, collection, kind, id };
+}
+
+/**
+ * Title columns follow the admin's rule: the collection's title field, then
+ * `title`, then `name`, skipping empty values, then the slug and the id. A
+ * `title_field` that names no text field is ignored.
+ */
+async function loadStreams(db: Kysely<Database>): Promise<Stream[]> {
+	const rows = await db
+		.selectFrom("_emdash_collections as c")
+		.leftJoin("_emdash_fields as f", (join) =>
+			join
+				.onRef("f.collection_id", "=", "c.id")
+				.on("f.type", "in", TITLE_FIELD_TYPES)
+				.on((eb) =>
+					eb.or([
+						eb("f.slug", "in", ["title", "name"]),
+						eb("f.slug", "=", eb.ref("c.title_field")),
+					]),
+				),
+		)
+		.select(["c.slug as slug", "c.title_field as title_field", "f.slug as field"])
+		.where("c.hidden", "=", 0)
+		.execute();
+
+	const collections = new Map<string, { titleField: string | null; fields: Set<string> }>();
+	for (const row of rows) {
+		const collection = collections.get(row.slug) ?? {
+			titleField: row.title_field,
+			fields: new Set<string>(),
+		};
+		if (row.field) collection.fields.add(row.field);
+		collections.set(row.slug, collection);
+	}
+
+	return [...collections.entries()]
+		.toSorted(([a], [b]) => compareText(a, b))
+		.flatMap(([slug, { titleField, fields }]) => {
+			validateIdentifier(slug, "collection slug");
+			const columns = [...new Set([titleField, "title", "name"])].filter(
+				(column): column is string => !!column && fields.has(column),
+			);
+			const title = sql<string>`COALESCE(${sql.join(
+				[...columns, "slug"].map((column) => {
+					validateIdentifier(column, "title column");
+					return sql`NULLIF(${sql.ref(column)}, '')`;
+				}),
+			)}, id)`;
+			return KINDS.map((kind) => ({ collection: slug, kind, title }));
+		});
+}
+
+function keysetCondition(stream: Stream, cursor: CalendarCursor | undefined) {
+	if (!cursor) return sql``;
+	const column = sql.ref(KIND_COLUMN[stream.kind]);
+	const order = compareStreams(stream, cursor);
+	if (order < 0) return sql`AND ${column} > ${cursor.at}`;
+	if (order === 0) return sql`AND (${column} > ${cursor.at} OR id > ${cursor.id})`;
+	return sql``;
+}
+
+async function queryStream(
+	db: Kysely<Database>,
+	stream: Stream,
+	params: CalendarEntriesParams,
+	cursor: CalendarCursor | undefined,
+): Promise<StreamRow[]> {
+	const column = sql.ref(KIND_COLUMN[stream.kind]);
+	const lower = cursor && cursor.at > params.from ? cursor.at : params.from;
+	const result = await sql<StreamRow>`
+		SELECT id, locale, status, ${stream.title} AS title, ${column} AS event_at
+		FROM ${sql.ref(`ec_${stream.collection}`)}
+		WHERE deleted_at IS NULL
+			AND ${column} IS NOT NULL
+			AND ${column} >= ${lower}
+			AND ${column} < ${params.to}
+			${stream.kind === "published" ? sql`AND status = 'published'` : sql``}
+			${keysetCondition(stream, cursor)}
+		ORDER BY ${column} ASC, id ASC
+		LIMIT ${params.limit + 1}
+	`.execute(db);
+	return result.rows;
+}
+
+/**
+ * Each stream (one collection and kind) is read in its own query, and the
+ * rows are merged by time. Ties keep the stream order and then each stream's
+ * SQL order, which matches the next page's keyset conditions.
+ */
+export async function handleCalendarEntries(
+	db: Kysely<Database>,
+	params: CalendarEntriesParams,
+): Promise<ApiResult<CalendarEntriesResponse>> {
+	try {
+		const cursor = params.cursor ? decodeCalendarCursor(params.cursor) : undefined;
+		const streams = await loadStreams(db);
+		const results = await Promise.all(
+			streams.map(async (stream) => {
+				const rows = await queryStream(db, stream, params, cursor);
+				return rows.map((row, position) => ({ row, stream, position }));
+			}),
+		);
+
+		const merged = results
+			.flat()
+			.toSorted(
+				(a, b) =>
+					compareText(a.row.event_at, b.row.event_at) ||
+					compareStreams(a.stream, b.stream) ||
+					a.position - b.position,
+			);
+
+		const items = merged.slice(0, params.limit).map(
+			({ row, stream }): CalendarEntry => ({
+				collection: stream.collection,
+				id: row.id,
+				locale: row.locale,
+				title: row.title,
+				status: row.status,
+				kind: stream.kind,
+				at: row.event_at,
+			}),
+		);
+		const last = items.at(-1);
+		const nextCursor =
+			merged.length > params.limit && last ? encodeCalendarCursor(last) : undefined;
+
+		return { success: true, data: nextCursor ? { items, nextCursor } : { items } };
+	} catch (error) {
+		if (error instanceof InvalidCursorError) {
+			return { success: false, error: { code: "INVALID_CURSOR", message: error.message } };
+		}
+		console.error("Calendar error:", error);
+		return {
+			success: false,
+			error: { code: "CALENDAR_ERROR", message: "Failed to load calendar" },
+		};
+	}
+}

package/src/api/handlers/content.ts

@@ -5,6 +5,7 @@
 import type { Kysely } from "kysely";
 import { sql } from "kysely";
 
+import { after } from "../../after.js";
 import type { ContentFieldFilters } from "../../content-list-query.js";
 import { isSqlite } from "../../database/dialect-helpers.js";
 import { BylineRepository } from "../../database/repositories/byline.js";
@@ -46,6 +47,7 @@ import {
 	scheduledPolicyRejectionKey,
 	type ScheduledPolicyRejection,
 } from "../../plugins/content-policy.js";
+import { publishRedirectChanges } from "../../redirects/artifacts.js";
 import { invalidateRedirectCache } from "../../redirects/cache.js";
 import { requestCached } from "../../request-cache.js";
 import { isStoragelessFieldRow } from "../../schema/types.js";
@@ -779,7 +781,7 @@ async function createSlugChangeRedirect(
 	contentId: string,
 	oldPublishedAt: string | null,
 	newPublishedAt: string | null,
-): Promise<void> {
+): Promise<boolean> {
 	// A URL pattern has no locale token, so every locale variant of an entry
 	// generates the same URL, and slugs are unique per (slug, locale) — a
 	// translation may still hold the old slug. Redirecting away from a URL
@@ -787,7 +789,7 @@ async function createSlugChangeRedirect(
 	// middleware runs `order: "pre"`, so routing never gets a chance.
 	// Any surviving row counts, published or not: a draft that publishes later
 	// would otherwise be shadowed by the redirect.
-	if (await slugStillTaken(db, collection, oldSlug, contentId)) return;
+	if (await slugStillTaken(db, collection, oldSlug, contentId)) return false;
 
 	const collectionRow = await db
 		.selectFrom("_emdash_collections")
@@ -796,7 +798,7 @@ async function createSlugChangeRedirect(
 		.executeTakeFirst();
 
 	const redirectRepo = new RedirectRepository(db);
-	await redirectRepo.createAutoRedirect(
+	const redirect = await redirectRepo.createAutoRedirect(
 		collection,
 		oldSlug,
 		newSlug,
@@ -806,6 +808,7 @@ async function createSlugChangeRedirect(
 		newPublishedAt,
 	);
 	invalidateRedirectCache();
+	return redirect !== null;
 }
 
 /** Whether a row other than `contentId` still holds `slug` in this collection. */
@@ -1508,6 +1511,7 @@ export async function handleContentUpdate(
 		// Wrap content + SEO writes in a transaction for atomicity.
 		// The _rev check is inside the transaction so the read-then-write
 		// is atomic -- no concurrent write can slip between the check and update.
+		let redirectCreated = false;
 		const item = await withTransaction(db, async (trx) => {
 			const trxRepo = new ContentRepository(trx);
 			const bylineRepo = new BylineRepository(trx);
@@ -1597,7 +1601,7 @@ export async function handleContentUpdate(
 			// pre-update date (the URL that was actually live) and the new URL
 			// the post-update one.
 			if (oldSlug && body.slug) {
-				await createSlugChangeRedirect(
+				redirectCreated = await createSlugChangeRedirect(
 					trx,
 					collection,
 					oldSlug,
@@ -1652,6 +1656,7 @@ export async function handleContentUpdate(
 
 			return updated;
 		});
+		if (redirectCreated) after(() => publishRedirectChanges(db));
 
 		return {
 			success: true,
@@ -2298,6 +2303,7 @@ export async function handleContentPublish(
 ): Promise<ApiResult<ContentResponse>> {
 	try {
 		const expectedRevision = decodeRevisionPrecondition(options._rev);
+		let redirectCreated = false;
 		const item = await withTransaction(db, async (trx) => {
 			const repo = new ContentRepository(trx);
 			const resolvedId = (await resolveId(repo, collection, id)) ?? id;
@@ -2417,7 +2423,7 @@ export async function handleContentPublish(
 				published.slug &&
 				existing.slug !== published.slug
 			) {
-				await createSlugChangeRedirect(
+				redirectCreated = await createSlugChangeRedirect(
 					trx,
 					collection,
 					existing.slug,
@@ -2430,6 +2436,7 @@ export async function handleContentPublish(
 
 			return published;
 		});
+		if (redirectCreated) after(() => publishRedirectChanges(db));
 
 		const hasSeo = await collectionHasSeo(db, collection);
 		await hydrateSeo(db, collection, item, hasSeo);

package/src/api/handlers/media-allowlist.ts

@@ -22,6 +22,7 @@ export const GLOBAL_UPLOAD_ALLOWLIST: readonly string[] = [
 	"image/gif",
 	"image/webp",
 	"image/avif",
+	"image/jxl",
 	"video/",
 	"audio/",
 	"application/pdf",

package/src/api/handlers/media-upload.ts

@@ -14,7 +14,7 @@ import { ulid } from "ulidx";
 import { MediaRepository, type MediaItem } from "../../database/repositories/media.js";
 import type { Database } from "../../database/types.js";
 import { enrichImageMetadata } from "../../media/enrich.js";
-import { matchesMimeAllowlist, normalizeMime } from "../../media/mime.js";
+import { matchesMimeAllowlist, normalizeMime, resolveUploadMimeType } from "../../media/mime.js";
 import type { Storage } from "../../storage/types.js";
 import { decodeBase64Bytes } from "../../utils/base64.js";
 import { computeContentHash } from "../../utils/hash.js";
@@ -107,18 +107,21 @@ export async function handleMediaUpload(
 	if ("success" in acquired) return acquired;
 	const { bytes } = acquired;
 
-	// Validate the raw MIME string before normalize/allowlist: normalizeMime
-	// only strips parameters and matchesMimeAllowlist only checks startsWith,
-	// so without this a crafted value like "image/png\r\nX-Evil: 1" would
-	// reach the storage backend's ContentType header and be echoed by the
-	// media file serving route.
-	if (!CONTENT_TYPE_RE.test(acquired.mimeType)) {
-		return fail("VALIDATION_ERROR", "Invalid content type");
-	}
 	let filename = input.filename;
-	let mimeType = normalizeMime(acquired.mimeType);
+	// Resolve from the supplied content type where possible, but fall back to
+	// the filename extension so callers that can't identify a format such as
+	// JPEG XL (e.g. empty or generic `application/octet-stream`) still work.
+	let mimeType = resolveUploadMimeType(filename, acquired.mimeType);
 	let size = bytes.byteLength;
 
+	// Re-validate the resolved type here: the resolved value is either the
+	// client-supplied type (parameters already stripped) or a value from the
+	// internal extension map, so a crafted Content-Type with header injection
+	// cannot reach the storage backend or the file-serving response.
+	if (!CONTENT_TYPE_RE.test(mimeType)) {
+		return fail("VALIDATION_ERROR", "Invalid content type");
+	}
+
 	if (!matchesMimeAllowlist(mimeType, GLOBAL_UPLOAD_ALLOWLIST)) {
 		return fail("INVALID_TYPE", "File type not allowed");
 	}

package/src/api/handlers/plugins.ts

@@ -187,32 +187,7 @@ export async function handlePluginList(
 			if (state.source !== "marketplace" && state.source !== "registry") continue;
 			if (configuredIds.has(state.pluginId)) continue;
 
-			items.push({
-				id: state.pluginId,
-				name: state.displayName || state.pluginId,
-				version: state.marketplaceVersion ?? state.version,
-				enabled: state.status === "active",
-				status: state.status,
-				source: state.source,
-				marketplaceVersion: state.marketplaceVersion ?? undefined,
-				registryPublisherDid: state.registryPublisherDid ?? undefined,
-				registrySlug: state.registrySlug ?? undefined,
-				capabilities: [],
-				hasAdminPages: false,
-				hasDashboardWidgets: false,
-				hasHooks: false,
-				hasSettings: Object.keys(runtimeSettingsSchemaLookup?.(state.pluginId) ?? {}).length > 0,
-				installedAt: state.installedAt?.toISOString(),
-				activatedAt: state.activatedAt?.toISOString() ?? undefined,
-				deactivatedAt: state.deactivatedAt?.toISOString() ?? undefined,
-				description: state.description ?? undefined,
-				iconUrl:
-					state.source === "marketplace" && marketplaceUrl
-						? marketplaceIconUrl(marketplaceUrl, state.pluginId)
-						: undefined,
-				mcpToolsEnabled: state.mcpToolsEnabled,
-				mcpTools: [],
-			});
+			items.push(buildStateOnlyPluginInfo(state, marketplaceUrl, runtimeSettingsSchemaLookup));
 		}
 
 		return {
@@ -239,6 +214,7 @@ export async function handlePluginGet(
 	sandboxedPluginEntries: SandboxedPluginEntry[],
 	pluginId: string,
 	marketplaceUrl?: string,
+	runtimeSettingsSchemaLookup?: (pluginId: string) => Record<string, unknown> | null,
 ): Promise<ApiResult<PluginResponse>> {
 	try {
 		const stateRepo = new PluginStateRepository(db);
@@ -261,6 +237,16 @@ export async function handlePluginGet(
 			};
 		}
 
+		const state = await stateRepo.get(pluginId);
+		if (state && (state.source === "marketplace" || state.source === "registry")) {
+			return {
+				success: true,
+				data: {
+					item: buildStateOnlyPluginInfo(state, marketplaceUrl, runtimeSettingsSchemaLookup),
+				},
+			};
+		}
+
 		return {
 			success: false,
 			error: {
@@ -284,11 +270,13 @@ export async function handlePluginGet(
  * `_plugin_state` row (marketplace or registry install), with no
  * matching `configuredPlugins` entry. Runtime-installed plugins don't
  * have ResolvedPlugin metadata until they're loaded into the sandbox,
- * so the enable/disable response surfaces the state-row view as a
- * stable shape the admin UI already understands.
+ * so the list, single-plugin, and enable/disable responses surface the
+ * state-row view as a stable shape the admin UI already understands.
  */
 function buildStateOnlyPluginInfo(
 	state: NonNullable<Awaited<ReturnType<PluginStateRepository["get"]>>>,
+	marketplaceUrl?: string,
+	runtimeSettingsSchemaLookup?: (pluginId: string) => Record<string, unknown> | null,
 ): PluginInfo {
 	return {
 		id: state.pluginId,
@@ -304,11 +292,15 @@ function buildStateOnlyPluginInfo(
 		hasAdminPages: false,
 		hasDashboardWidgets: false,
 		hasHooks: false,
-		hasSettings: false,
+		hasSettings: Object.keys(runtimeSettingsSchemaLookup?.(state.pluginId) ?? {}).length > 0,
 		installedAt: state.installedAt?.toISOString(),
 		activatedAt: state.activatedAt?.toISOString() ?? undefined,
 		deactivatedAt: state.deactivatedAt?.toISOString() ?? undefined,
 		description: state.description ?? undefined,
+		iconUrl:
+			state.source === "marketplace" && marketplaceUrl
+				? marketplaceIconUrl(marketplaceUrl, state.pluginId)
+				: undefined,
 		mcpToolsEnabled: state.mcpToolsEnabled,
 		mcpTools: [],
 	};

package/src/api/handlers/redirects.ts

@@ -16,7 +16,7 @@ import {
 import { InvalidCursorError } from "../../database/repositories/types.js";
 import type { FindManyResult } from "../../database/repositories/types.js";
 import type { Database } from "../../database/types.js";
-import { invalidateRedirectCache } from "../../redirects/cache.js";
+import { publishRedirectChanges } from "../../redirects/artifacts.js";
 import { wouldCreateLoop, detectLoops, type RedirectEdge } from "../../redirects/loops.js";
 import { validatePattern, validateDestinationParams, isPattern } from "../../redirects/patterns.js";
 import { isTerminalStatus } from "../../redirects/status.js";
@@ -174,7 +174,7 @@ export async function handleRedirectCreate(
 			);
 			return { success: true, data: redirect };
 		});
-		if (result.success) invalidateRedirectCache();
+		if (result.success) await publishRedirectChanges(db);
 		return result;
 	} catch {
 		return {
@@ -313,12 +313,12 @@ export async function handleRedirectUpdate(
 				}
 			}
 
-			// Check for redirect loops if source or destination changed
+			// Check for redirect loops if the rule's edge changes or it becomes active
 			const willBeEnabled = input.enabled ?? existing.enabled;
 			if (
 				!terminal &&
 				willBeEnabled &&
-				(input.source !== undefined || input.destination !== undefined)
+				(input.source !== undefined || input.destination !== undefined || !existing.enabled)
 			) {
 				const edges = toEdges(await repo.findAllEnabled());
 				const loopPath = wouldCreateLoop(newSource, newDest, edges, id);
@@ -351,7 +351,7 @@ export async function handleRedirectUpdate(
 			await updateLoopCache(repo.db);
 			return { success: true, data: updated };
 		});
-		if (result.success) invalidateRedirectCache();
+		if (result.success) await publishRedirectChanges(db);
 		return result;
 	} catch {
 		return {
@@ -402,7 +402,7 @@ export async function handleRedirectDelete(
 			await updateLoopCache(repo.db);
 			return { success: true, data: { deleted: true } };
 		});
-		if (result.success) invalidateRedirectCache();
+		if (result.success) await publishRedirectChanges(db);
 		return result;
 	} catch {
 		return {

package/src/api/schemas/bylines.ts

@@ -105,7 +105,9 @@ export const bylineCreateBody = z
 		locale: localeCode.optional(),
 		/**
 		 * When set, the new row joins the source byline's translation_group
-		 * rather than minting a fresh one. Requires `locale`.
+		 * rather than minting a fresh one. Requires `locale`. The new row keeps
+		 * the source's `userId` unless the body sets one; `null` leaves it
+		 * unlinked.
 		 */
 		translationOf: z.string().min(1).optional(),
 		/**