emdash 0.21.0 → 0.23.0

package/src/astro/object-cache/adapters.ts

@@ -0,0 +1,50 @@
+/**
+ * Object-cache adapter functions (config time).
+ *
+ * These run in `astro.config.mjs` and return serializable
+ * {@link ObjectCacheDescriptor}s. The backend is instantiated at runtime by
+ * loading the descriptor's `entrypoint`.
+ *
+ * For Cloudflare KV, use `kvCache()` from `@emdash-cms/cloudflare`.
+ *
+ * @example
+ * ```ts
+ * // astro.config.mjs (Node / local)
+ * import emdash, { memoryCache } from "emdash/astro";
+ *
+ * export default defineConfig({
+ *   integrations: [emdash({ objectCache: memoryCache() })],
+ * });
+ * ```
+ */
+
+import type { ObjectCacheDescriptor, ObjectCacheRuntimeConfig } from "../../object-cache/types.js";
+
+/** Options for {@link memoryCache}. */
+export interface MemoryCacheOptions extends ObjectCacheRuntimeConfig {
+	/**
+	 * Soft cap on the number of cached keys per isolate before FIFO eviction.
+	 * @default 1000
+	 */
+	maxEntries?: number;
+}
+
+/**
+ * In-isolate memory object cache.
+ *
+ * Caches query results across requests within a single isolate/process. On
+ * Node (one long-lived process) this is a genuine cross-request cache; on
+ * multi-isolate platforms (Cloudflare) prefer `kvCache()` so the cache is
+ * shared. Useful for local development regardless of target.
+ *
+ * @example
+ * ```ts
+ * emdash({ objectCache: memoryCache({ defaultTtl: 600 }) })
+ * ```
+ */
+export function memoryCache(options: MemoryCacheOptions = {}): ObjectCacheDescriptor {
+	return {
+		entrypoint: "emdash/object-cache/memory",
+		config: { ...options },
+	};
+}

package/src/astro/prefetch.ts

@@ -0,0 +1,77 @@
+/**
+ * Eager, transparent prefetch of site-global "chrome" data.
+ *
+ * On a public page render, the shared layout pulls the same site-global data on
+ * every request -- menus, widget areas, taxonomy term lists, site settings --
+ * but each is awaited inside a separately-rendered Astro component, so they
+ * execute as serial DB round trips. This fires them all CONCURRENTLY at the
+ * very start of the request, before `next()`:
+ *
+ *   - On remote backends (D1, Durable Objects) the round trips overlap instead
+ *     of serializing, collapsing ~N sequential RTTs into ~1 wall-clock RTT. On
+ *     a coalescing backend they additionally batch into a single round trip.
+ *   - The results land in the per-request `requestCached` store under the exact
+ *     keys the layout helpers use, so when the components render they hit a warm
+ *     (in-flight or resolved) cache entry instead of issuing their own query.
+ *
+ * Nothing here changes what templates call -- it warms the real helpers, so the
+ * cache keys and value shapes are guaranteed identical. The caller gates this to
+ * the public-page path on a request-scoped (remote) backend; it is a no-op-ish
+ * waste on synchronous local SQLite, so don't call it there.
+ *
+ * Fire-and-forget: never awaited by middleware, never throws (a prefetch failure
+ * must not affect the request -- the helpers will simply run on demand).
+ */
+
+import { getDb } from "../loader.js";
+import { getMenu } from "../menus/index.js";
+import { setRequestCacheEntry } from "../request-cache.js";
+import { getSiteSettings } from "../settings/index.js";
+import { getTaxonomyDefs, getTaxonomyTerms } from "../taxonomies/index.js";
+import { getWidgetAreas } from "../widgets/index.js";
+
+/** Warm widget areas: one bulk load, primed under each per-area cache key. */
+async function prefetchWidgetAreas(): Promise<void> {
+	const areas = await getWidgetAreas();
+	// getWidgetArea(name) caches under `widget-area:${name}` and returns the same
+	// WidgetArea shape getWidgetAreas yields, so priming here makes those calls hit.
+	for (const area of areas) {
+		setRequestCacheEntry(`widget-area:${area.name}`, area);
+	}
+}
+
+/** Warm every taxonomy's term list via the real helper (primes per-name keys). */
+async function prefetchTaxonomyTerms(): Promise<void> {
+	const defs = await getTaxonomyDefs();
+	await Promise.allSettled(defs.map((def) => getTaxonomyTerms(def.name)));
+}
+
+/** Warm every menu via the real helper (primes `menu:${name}:${locale}`). */
+async function prefetchMenus(): Promise<void> {
+	const db = await getDb();
+	// The layout calls getMenu(name) with hardcoded names; we can't know them, so
+	// discover every menu name and warm them all (small, bounded chrome table).
+	const rows = await db.selectFrom("_emdash_menus").select("name").distinct().execute();
+	const names = [...new Set(rows.map((r) => r.name))];
+	await Promise.allSettled(names.map((name) => getMenu(name)));
+}
+
+/**
+ * Concurrently warm the site-global layout data for the current request.
+ * Safe to call only inside the request ALS frame that owns the (remote)
+ * request-scoped db. Never throws.
+ */
+export async function prefetchLayoutData(): Promise<void> {
+	try {
+		await Promise.allSettled([
+			getSiteSettings(),
+			prefetchMenus(),
+			prefetchWidgetAreas(),
+			prefetchTaxonomyTerms(),
+		]);
+	} catch (error) {
+		// Defensive: Promise.allSettled shouldn't reject, but never let a prefetch
+		// failure surface to the request.
+		console.error("[emdash] layout prefetch failed (non-fatal):", error);
+	}
+}

package/src/astro/routes/admin.astro

@@ -5,7 +5,10 @@
  * This page serves the EmDash admin React SPA.
  * AdminWrapper imports plugin admin modules and passes them to AdminApp.
  */
-import "@emdash-cms/admin/styles.css";
+// `?url` keeps the admin stylesheet out of the page's CSS module graph so
+// Astro's dev SSR doesn't inject it into every public route's <head>. We emit
+// it as a route-scoped <link> below instead. See #1281.
+import adminStylesUrl from "@emdash-cms/admin/styles.css?url";
 // Use package-qualified import so Astro generates a proper module URL
 // (relative imports resolve to absolute paths which break client hydration)
 import AdminWrapper from "emdash/routes/PluginRegistry";
@@ -28,6 +31,7 @@ const pageTitle = adminConfig?.siteName ? `${adminConfig.siteName} Admin` : "EmD
 	<head>
 		<meta charset="UTF-8" />
 		<meta name="viewport" content="width=device-width, initial-scale=1.0" />
+		<link rel="stylesheet" href={adminStylesUrl} />
 		<Font cssVariable="--font-emdash" />
 		{adminConfig?.favicon ? (
 			<link rel="icon" href={adminConfig.favicon} />

package/src/astro/routes/api/comments/[collection]/[contentId]/reactions.ts

@@ -0,0 +1,97 @@
+/**
+ * Public comment reaction endpoints (Tier 1 of the best-in-class comments RFC).
+ *
+ * GET  /_emdash/api/comments/:collection/:contentId/reactions
+ *   - Aggregate reaction counts for the content's approved comments, plus the
+ *     current visitor's active reactions.
+ * POST /_emdash/api/comments/:collection/:contentId/reactions
+ *   - Toggle a reaction on a comment. Public, honeypot- and rate-limit-gated.
+ *
+ * Inherits the `/_emdash/api/comments/` public prefix (no auth); the POST still
+ * requires the `X-EmDash-Request: 1` CSRF header like the comment POST.
+ */
+
+import type { APIRoute } from "astro";
+
+import { apiError, apiSuccess, handleError, requireDb, unwrapResult } from "#api/error.js";
+import { handleReactionCounts, handleReactionToggle } from "#api/handlers/comment-reactions.js";
+import { hashIp } from "#api/handlers/comments.js";
+import { isParseError, parseBody } from "#api/parse.js";
+import { createReactionBody } from "#api/schemas.js";
+import { resolveSecretsCached } from "#config/secrets.js";
+import { extractRequestMeta } from "#plugins/request-meta.js";
+
+export const prerender = false;
+
+export const GET: APIRoute = async ({ params, request, locals }) => {
+	const { emdash } = locals;
+	const { collection, contentId } = params;
+
+	if (!collection || !contentId) {
+		return apiError("VALIDATION_ERROR", "Collection and content ID required", 400);
+	}
+
+	const dbErr = requireDb(emdash?.db);
+	if (dbErr) return dbErr;
+
+	try {
+		// Salted voter hash from request IP (same primitive as comment ip_hash).
+		// Behind Cloudflare (CF-Connecting-IP) or a configured trusted proxy this
+		// is per-visitor. Without a trusted IP it collapses to a shared "unknown"
+		// bucket, so reaction dedup degrades for those visitors — a real
+		// per-visitor token is Tier 2 (visitor identity). Operators should set
+		// trustedProxyHeaders; see the comment ingest route for the same note.
+		const meta = extractRequestMeta(request, emdash.config);
+		let voterHash = "unknown";
+		if (meta.ip) {
+			const { ipSalt } = await resolveSecretsCached(emdash.db);
+			voterHash = await hashIp(meta.ip, ipSalt);
+		}
+
+		const result = await handleReactionCounts(emdash.db, collection, contentId, voterHash);
+		return unwrapResult(result);
+	} catch (error) {
+		return handleError(error, "Failed to read reactions", "REACTION_COUNTS_ERROR");
+	}
+};
+
+export const POST: APIRoute = async ({ params, request, locals }) => {
+	const { emdash } = locals;
+	const { collection, contentId } = params;
+
+	if (!collection || !contentId) {
+		return apiError("VALIDATION_ERROR", "Collection and content ID required", 400);
+	}
+
+	const dbErr = requireDb(emdash?.db);
+	if (dbErr) return dbErr;
+
+	try {
+		const body = await parseBody(request, createReactionBody);
+		if (isParseError(body)) return body;
+
+		// Anti-spam: honeypot — hidden field filled only by bots. Silently accept.
+		if (body.website_url) {
+			return apiSuccess({ reacted: false, counts: {} });
+		}
+
+		const meta = extractRequestMeta(request, emdash.config);
+		let voterHash = "unknown";
+		if (meta.ip) {
+			const { ipSalt } = await resolveSecretsCached(emdash.db);
+			voterHash = await hashIp(meta.ip, ipSalt);
+		}
+
+		const result = await handleReactionToggle(emdash.db, {
+			collection,
+			contentId,
+			commentId: body.commentId,
+			reaction: body.reaction,
+			voterHash,
+		});
+
+		return unwrapResult(result, 200);
+	} catch (error) {
+		return handleError(error, "Failed to toggle reaction", "REACTION_TOGGLE_ERROR");
+	}
+};

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

@@ -15,7 +15,7 @@ import { hashString } from "emdash";
 import { requirePerm } from "#api/authorize.js";
 import { apiSuccess, handleError, requireDb } from "#api/error.js";
 import { SchemaRegistry } from "#schema/registry.js";
-import { generateTypeScript } from "#schema/zod-generator.js";
+import { generateTypeScript, uniqueInterfaceNames } from "#schema/zod-generator.js";
 
 export const prerender = false;
 
@@ -45,8 +45,14 @@ export const GET: APIRoute = async ({ request, locals }) => {
 		const format = url.searchParams.get("format");
 
 		if (format === "typescript") {
-			// Generate TypeScript definitions
-			const types = collectionsWithFields.map((c) => generateTypeScript(c)).join("\n\n");
+			// Generate TypeScript definitions. Singularizing slugs can collapse
+			// distinct collections onto the same interface name, so resolve names
+			// up front to keep every emitted interface unique (`book` + `books`
+			// would otherwise both emit `Book`).
+			const interfaceNames = uniqueInterfaceNames(collectionsWithFields);
+			const types = collectionsWithFields
+				.map((c) => generateTypeScript(c, interfaceNames.get(c.slug)))
+				.join("\n\n");
 
 			const header = `// Generated by EmDash CLI
 // Do not edit manually - run \`emdash types\` to regenerate

package/src/astro/routes/api/setup/dev-bypass.ts

@@ -23,7 +23,7 @@ import { ulid } from "ulidx";
 
 import { apiError, apiSuccess, handleError } from "#api/error.js";
 import { escapeHtml } from "#api/escape.js";
-import { handleApiTokenCreate } from "#api/handlers/api-tokens.js";
+import { deleteApiTokensByName, handleApiTokenCreate } from "#api/handlers/api-tokens.js";
 import { getPublicOrigin } from "#api/public-url.js";
 import { isSafeRedirect } from "#api/redirect.js";
 import { runMigrations } from "#db/migrations/runner.js";
@@ -134,6 +134,10 @@ async function handleDevBypass(context: Parameters<APIRoute>[0]): Promise<Respon
 		// Optionally create a PAT token (?token=1) for headless/CLI testing.
 		let token: string | undefined;
 		if (url.searchParams.has("token")) {
+			// Idempotent by name: a prior reset can leave a stale dev-bypass-token,
+			// and the raw token is only available at creation, so drop any existing
+			// one and mint a fresh, usable PAT rather than accumulating duplicates.
+			await deleteApiTokensByName(emdash.db, user.id, "dev-bypass-token");
 			const result = await handleApiTokenCreate(emdash.db, user.id, {
 				name: "dev-bypass-token",
 				scopes: [

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

@@ -20,6 +20,8 @@ import {
 import { getPublicOrigin } from "#api/public-url.js";
 import { resolveSecretsCached } from "#config/secrets.js";
 
+import { resolveSessionUser } from "../../session-user.js";
+
 export const prerender = false;
 
 export const GET: APIRoute = async ({ request, locals, url, session }) => {
@@ -31,7 +33,7 @@ export const GET: APIRoute = async ({ request, locals, url, session }) => {
 	if (!user && session && emdash?.db) {
 		try {
 			const { createKyselyAdapter } = await import("@emdash-cms/auth/adapters/kysely");
-			const sessionUser = await session.get("user");
+			const sessionUser = await resolveSessionUser(session);
 			if (sessionUser?.id) {
 				const adapter = createKyselyAdapter(emdash.db);
 				const resolved = await adapter.getUserById(sessionUser.id);

package/src/astro/session-user.ts

@@ -0,0 +1,57 @@
+import { after } from "../after.js";
+
+/**
+ * Backstop timeout for resolving the session user. A live session-store read
+ * settles in a few ms, so this only ever fires on a genuinely stalled read.
+ */
+export const SESSION_GET_TIMEOUT_MS = 3_000;
+
+/**
+ * Resolve the Astro session user without risking an isolate-wide hang.
+ *
+ * On Cloudflare Workers, a request cancelled mid-`session.get()` (client
+ * disconnect, context teardown) can leave the underlying session-store read as
+ * a promise that never settles — neither resolving nor rejecting. Awaiting it
+ * directly hangs the request, and because the stalled promise is shared at the
+ * isolate level, every later session-bearing request hangs too (observed as
+ * 0-CPU, multi-minute, `canceled` responses; see #1274). A surrounding
+ * try/catch cannot help: the promise never rejects.
+ *
+ * Two layers, mirroring the reclaimable-cache pattern used elsewhere in core:
+ *  1. `after()` anchors the read so a cancelled request still drives it to
+ *     completion — the promise settles and the isolate is not poisoned for
+ *     subsequent requests (prevents the hang rather than merely surviving it).
+ *  2. A timeout is a fail-closed backstop: a still-stalled (or rejecting) read
+ *     resolves to `undefined`, and every caller treats the absence of a session
+ *     user as unauthenticated (anonymous on public routes, 401/redirect on
+ *     protected ones). It can only ever drop privileges for that one request,
+ *     never grant them.
+ *
+ * Used by every session read on the request path: the main middleware (the
+ * first read on a session-bearing request), the auth middleware, and the
+ * preview-snapshot route (which bypasses the auth middleware).
+ */
+export async function resolveSessionUser<T>(
+	session: { get(key: "user"): Promise<T> } | undefined,
+	timeoutMs = SESSION_GET_TIMEOUT_MS,
+): Promise<T | undefined> {
+	if (!session) return undefined;
+	const read: Promise<T | undefined> = Promise.resolve(session.get("user")).catch(() => undefined);
+	// Keep the worker alive past response/cancellation so the read completes and
+	// the shared promise settles — this is what prevents the isolate poisoning.
+	after(() =>
+		read.then(
+			() => undefined,
+			() => undefined,
+		),
+	);
+	let timer: ReturnType<typeof setTimeout> | undefined;
+	const timeout = new Promise<undefined>((resolve) => {
+		timer = setTimeout(resolve, timeoutMs, undefined);
+	});
+	try {
+		return await Promise.race([read, timeout]);
+	} finally {
+		clearTimeout(timer);
+	}
+}

package/src/astro/types.ts

@@ -265,6 +265,7 @@ export interface EmDashHandlers {
 			slug?: string;
 			status?: string;
 			authorId?: string;
+			bylines?: Array<{ bylineId: string; roleLabel?: string | null }>;
 			locale?: string;
 			translationOf?: string;
 			createdAt?: string | null;

package/src/cli/commands/export-seed.ts

@@ -153,13 +153,16 @@ export async function exportSeed(db: Kysely<Database>, withContent?: string): Pr
 
 	// 7. Export content (if requested)
 	if (withContent !== undefined) {
-		const collections =
-			withContent === "" || withContent === "true"
-				? null // all collections
-				: withContent
-						.split(",")
-						.map((s) => s.trim())
-						.filter(Boolean);
+		// Treat "all" as a synonym for the bare flag and "true". The args help
+		// text documents `all` as a valid value, but without this the literal
+		// string is read as a collection name and matches no collection (#1329).
+		const includeAll = withContent === "" || withContent === "true" || withContent === "all";
+		const collections = includeAll
+			? null // all collections
+			: withContent
+					.split(",")
+					.map((s) => s.trim())
+					.filter(Boolean);
 
 		seed.content = await exportContent(
 			db,

package/src/comments/query.ts

@@ -7,15 +7,26 @@
 
 import type { Kysely } from "kysely";
 
+import { CommentReactionRepository } from "../database/repositories/comment-reaction.js";
 import { CommentRepository } from "../database/repositories/comment.js";
 import type { PublicComment } from "../database/repositories/comment.js";
 import type { Database } from "../database/types.js";
 import { getDb } from "../loader.js";
+import { cachedQuery, CacheNamespace } from "../object-cache/index.js";
+import { reactionScore } from "./ranking.js";
 
 export interface GetCommentsOptions {
 	collection: string;
 	contentId: string;
 	threaded?: boolean;
+	/** Attach aggregate reaction counts to each comment. */
+	reactions?: boolean;
+	/**
+	 * Order of top-level comments. `oldest` (default) preserves the existing
+	 * chronological display; `best` ranks by Wilson-scored reactions (implies
+	 * `reactions`). Replies always stay chronological.
+	 */
+	sort?: "oldest" | "best";
 }
 
 export interface GetCommentsResult {
@@ -38,8 +49,21 @@ export interface GetCommentsResult {
  * ```
  */
 export async function getComments(options: GetCommentsOptions): Promise<GetCommentsResult> {
-	const db = await getDb();
-	return getCommentsWithDb(db, options);
+	// The result varies by every option getCommentsWithDb branches on, so all of
+	// them belong in the key. `best` implies reactions, so normalize the reaction
+	// flag — `{ sort: "best" }` and `{ sort: "best", reactions: true }` produce
+	// identical output and should share one entry.
+	const sort = options.sort ?? "oldest";
+	const withReactions = options.reactions || sort === "best";
+	const threaded = options.threaded ? "t" : "f";
+	return cachedQuery({
+		namespace: CacheNamespace.COMMENTS,
+		key: `comments:${options.collection}:${options.contentId}:${threaded}:${withReactions ? "r" : "n"}:${sort}`,
+		load: async () => {
+			const db = await getDb();
+			return getCommentsWithDb(db, options);
+		},
+	});
 }
 
 /**
@@ -65,16 +89,63 @@ export async function getCommentsWithDb(
 		limit: MAX_COMMENTS,
 	});
 
-	if (options.threaded) {
-		const threaded = CommentRepository.assembleThreads(result.items);
-		const items = threaded.map((c) => CommentRepository.toPublicComment(c));
-		return { items, total };
+	const items: PublicComment[] = options.threaded
+		? CommentRepository.assembleThreads(result.items).map((c) =>
+				CommentRepository.toPublicComment(c),
+			)
+		: result.items.map((c) => CommentRepository.toPublicComment(c));
+
+	// `best` sort needs reaction data, so it implies reactions.
+	if (options.reactions || options.sort === "best") {
+		await attachReactions(db, items);
+		if (options.sort === "best") {
+			sortByBest(items);
+		}
 	}
 
-	const items = result.items.map((c) => CommentRepository.toPublicComment(c));
 	return { items, total };
 }
 
+/**
+ * Attach aggregate reaction counts to a list of public comments (and their
+ * replies), in a single batched query.
+ */
+async function attachReactions(db: Kysely<Database>, items: PublicComment[]): Promise<void> {
+	const ids: string[] = [];
+	for (const comment of items) {
+		ids.push(comment.id);
+		if (comment.replies) {
+			for (const reply of comment.replies) ids.push(reply.id);
+		}
+	}
+	if (ids.length === 0) return;
+
+	const counts = await new CommentReactionRepository(db).countsForComments(ids);
+
+	const assign = (comment: PublicComment) => {
+		const reactions = counts.get(comment.id);
+		if (reactions) comment.reactions = reactions;
+	};
+	for (const comment of items) {
+		assign(comment);
+		comment.replies?.forEach(assign);
+	}
+}
+
+/**
+ * Sort top-level comments by Wilson-scored reactions (descending), tie-broken
+ * by oldest-first to keep ordering stable.
+ */
+function sortByBest(items: PublicComment[]): void {
+	items.sort((a, b) => {
+		const scoreDelta = reactionScore(b.reactions ?? {}) - reactionScore(a.reactions ?? {});
+		if (scoreDelta !== 0) return scoreDelta;
+		if (a.createdAt < b.createdAt) return -1;
+		if (a.createdAt > b.createdAt) return 1;
+		return 0;
+	});
+}
+
 /**
  * Get the count of approved comments for a content item.
  *

package/src/comments/ranking.ts

@@ -0,0 +1,58 @@
+/**
+ * Comment ranking utilities (Tier 1 of the best-in-class comments RFC).
+ *
+ * Wilson score lower-bound (95% confidence) — the same primitive Reddit uses
+ * for its "Best" comment sort. Ranks by the statistical lower bound of the
+ * positive-reaction proportion rather than the raw count, so a comment with a
+ * couple of reactions can't outrank a heavily-reacted one until it earns
+ * confidence, and a late-but-popular comment still rises (submission time is
+ * irrelevant).
+ *
+ * Positive-only reactions (the recommended default) degrade gracefully: with
+ * `down = 0` the score still increases monotonically with `up` while penalising
+ * low-sample comments — wilson(1,0) ≈ 0.21, wilson(10,0) ≈ 0.73,
+ * wilson(200,0) ≈ 0.98.
+ */
+
+/** z for a 95% two-sided confidence interval. */
+const DEFAULT_Z = 1.96;
+
+/** Reactions that count against a comment when both signals are in use. */
+const NEGATIVE_REACTIONS: ReadonlySet<string> = new Set(["dislike", "down"]);
+
+/**
+ * Wilson score lower bound of the positive proportion.
+ *
+ * @param up   count of positive reactions
+ * @param down count of negative reactions
+ * @returns a score in [0, 1]; 0 when there are no reactions
+ */
+export function wilsonLowerBound(up: number, down: number, z: number = DEFAULT_Z): number {
+	const n = up + down;
+	if (n <= 0) return 0;
+	const phat = up / n;
+	const z2 = z * z;
+	const denom = 1 + z2 / n;
+	const centre = phat + z2 / (2 * n);
+	const margin = z * Math.sqrt((phat * (1 - phat) + z2 / (4 * n)) / n);
+	return (centre - margin) / denom;
+}
+
+/**
+ * Reduce a per-reaction count map to a single rank score via the Wilson
+ * lower bound. Any reaction not in {@link NEGATIVE_REACTIONS} is treated as
+ * positive, so the positive-only default (just `like`) works without special
+ * casing.
+ */
+export function reactionScore(counts: Record<string, number>): number {
+	let up = 0;
+	let down = 0;
+	for (const [reaction, count] of Object.entries(counts)) {
+		if (NEGATIVE_REACTIONS.has(reaction)) {
+			down += count;
+		} else {
+			up += count;
+		}
+	}
+	return wilsonLowerBound(up, down);
+}

package/src/components/Block.astro

@@ -0,0 +1,71 @@
+---
+/**
+ * EmDash custom block override for `astro-portabletext`.
+ *
+ * Renders the same HTML as the upstream Block component (h1..h6, blockquote,
+ * `<p>` for `normal`) and additionally surfaces `textAlign` from the rich-text
+ * editor as a WordPress-style `has-text-align-{value}` class on the rendered
+ * paragraph or heading.
+ *
+ * `left` is the editor default and intentionally does not produce a class —
+ * paragraphs/headings without explicit alignment render exactly as they did
+ * before this fix, so existing content is byte-for-byte unchanged.
+ *
+ * Related: https://github.com/emdash-cms/emdash/issues/1201
+ */
+import type { BlockProps } from "astro-portabletext/types";
+
+import { textAlignClassName } from "./portable-text-text-align.js";
+
+type TextAlignedNode = BlockProps["node"] & { textAlign?: string };
+type Props = Omit<BlockProps, "node"> & { node: TextAlignedNode };
+
+const props = Astro.props as Props;
+const { node, index: _index, isInline: _isInline, ...attrs } = props;
+
+const styleIs = (style: string) => style === node.style;
+
+// Allowlist-based; attacker-controlled PT data cannot inject arbitrary classes.
+// See `./portable-text-text-align.ts`.
+const alignClass = textAlignClassName(node.textAlign);
+---
+
+{
+	styleIs("h1") ? (
+		<h1 class={alignClass} {...attrs}>
+			<slot />
+		</h1>
+	) : styleIs("h2") ? (
+		<h2 class={alignClass} {...attrs}>
+			<slot />
+		</h2>
+	) : styleIs("h3") ? (
+		<h3 class={alignClass} {...attrs}>
+			<slot />
+		</h3>
+	) : styleIs("h4") ? (
+		<h4 class={alignClass} {...attrs}>
+			<slot />
+		</h4>
+	) : styleIs("h5") ? (
+		<h5 class={alignClass} {...attrs}>
+			<slot />
+		</h5>
+	) : styleIs("h6") ? (
+		<h6 class={alignClass} {...attrs}>
+			<slot />
+		</h6>
+	) : styleIs("blockquote") ? (
+		<blockquote class={alignClass} {...attrs}>
+			<slot />
+		</blockquote>
+	) : styleIs("normal") ? (
+		<p class={alignClass} {...attrs}>
+			<slot />
+		</p>
+	) : (
+		<p class={alignClass} {...attrs}>
+			<slot />
+		</p>
+	)
+}