@growth-labs/cms 0.5.10 → 0.5.12

package/src/engine/tags.ts

@@ -4,6 +4,7 @@
 
 import type { D1Database } from './d1.js'
 import { slugify } from './slug.js'
+import { validateSingleDeclaredTag } from './taxonomy.js'
 
 export interface TagSummary {
 	id: string
@@ -12,6 +13,16 @@ export interface TagSummary {
 	count: number
 }
 
+export const DEFAULT_TAG_LIST_LIMIT = 100
+export const MAX_TAG_LIST_LIMIT = 500
+export const DEFAULT_TAG_SEARCH_LIMIT = 50
+
+function normalizeLimit(value: number | undefined, fallback: number, max: number): number {
+	const limit = value ?? fallback
+	if (!Number.isSafeInteger(limit) || limit < 1 || limit > max) return fallback
+	return limit
+}
+
 export async function getTag(db: D1Database, tagId: string): Promise<TagSummary | null> {
 	const row = await db
 		.prepare(
@@ -27,64 +38,73 @@ export async function getTag(db: D1Database, tagId: string): Promise<TagSummary
 }
 
 export async function createTag(db: D1Database, label: string): Promise<TagSummary | null> {
-	const slug = slugify(label)
-	const trimmed = label.trim()
-	if (!slug || !trimmed) return null
+	const tag = validateSingleDeclaredTag(label)
 	const existing = await db
 		.prepare('SELECT id FROM content_tags WHERE slug = ? LIMIT 1')
-		.bind(slug)
+		.bind(tag.slug)
 		.first<{ id: string }>()
 	if (existing) return null
 	const id = crypto.randomUUID()
 	await db
 		.prepare('INSERT INTO content_tags (id, slug, label) VALUES (?, ?, ?)')
-		.bind(id, slug, trimmed)
+		.bind(id, tag.slug, tag.label)
 		.run()
-	return { id, slug, label: trimmed, count: 0 }
+	return { id, slug: tag.slug, label: tag.label, count: 0 }
 }
 
-export async function listTags(db: D1Database): Promise<TagSummary[]> {
+export async function listTags(
+	db: D1Database,
+	options: { limit?: number } = {},
+): Promise<TagSummary[]> {
+	const limit = normalizeLimit(options.limit, DEFAULT_TAG_LIST_LIMIT, MAX_TAG_LIST_LIMIT)
 	const result = await db
 		.prepare(
 			`SELECT t.id, t.slug, t.label, COUNT(l.content_id) AS count
 			 FROM content_tags t
 			 LEFT JOIN content_tag_links l ON l.tag_id = t.id
-			 GROUP BY t.id ORDER BY count DESC, t.label ASC`,
+			 GROUP BY t.id ORDER BY count DESC, t.label ASC LIMIT ?`,
 		)
+		.bind(limit)
 		.all<{ id: string; slug: string; label: string; count: number }>()
 	return result.results || []
 }
 
-export async function searchTags(db: D1Database, q: string): Promise<TagSummary[]> {
+export async function searchTags(
+	db: D1Database,
+	q: string,
+	options: { limit?: number } = {},
+): Promise<TagSummary[]> {
 	const needle = `${slugify(q)}%`
+	if (needle === '%') return []
+	const limit = normalizeLimit(options.limit, DEFAULT_TAG_SEARCH_LIMIT, MAX_TAG_LIST_LIMIT)
 	const result = await db
 		.prepare(
 			`SELECT t.id, t.slug, t.label, COUNT(l.content_id) AS count
 			 FROM content_tags t
 			 LEFT JOIN content_tag_links l ON l.tag_id = t.id
-			 WHERE t.slug LIKE ? GROUP BY t.id ORDER BY t.label ASC LIMIT 50`,
+			 WHERE t.slug LIKE ? GROUP BY t.id ORDER BY t.label ASC LIMIT ?`,
 		)
-		.bind(needle)
+		.bind(needle, limit)
 		.all<{ id: string; slug: string; label: string; count: number }>()
 	return result.results || []
 }
 
 export async function renameTag(db: D1Database, tagId: string, label: string): Promise<boolean> {
-	const slug = slugify(label)
-	const trimmed = label.trim()
-	if (!slug || !trimmed) return false
+	const tag = validateSingleDeclaredTag(label)
 	// content_tags.slug is UNIQUE — a rename whose target slug is already taken by
 	// a DIFFERENT tag would throw a constraint error. Fail gracefully (the
 	// Promise<boolean> contract) instead, matching the empty-slug early return.
 	const clash = await db
 		.prepare('SELECT id FROM content_tags WHERE slug = ? AND id != ? LIMIT 1')
-		.bind(slug, tagId)
+		.bind(tag.slug, tagId)
 		.first<{ id: string }>()
 	if (clash) return false
-	const res = await db
-		.prepare('UPDATE content_tags SET label = ?, slug = ? WHERE id = ?')
-		.bind(trimmed, slug, tagId)
-		.run()
+	const [res] = await db.batch([
+		db
+			.prepare('UPDATE content_tags SET label = ?, slug = ? WHERE id = ?')
+			.bind(tag.label, tag.slug, tagId),
+		db.prepare('UPDATE content_tag_links SET label = ? WHERE tag_id = ?').bind(tag.label, tagId),
+	])
 	return Boolean(res.meta && (res.meta as { changes?: number }).changes)
 }
 

package/src/engine/taxonomy.ts

@@ -0,0 +1,226 @@
+import { slugify } from './slug.js'
+
+/** Maximum number of tags per content item. Covers the measured fleet max (16) with headroom. */
+export const MAX_ITEM_TAG_COUNT = 32
+/** Maximum UTF-8 byte length for a single declared tag display label. */
+export const MAX_TAG_LABEL_BYTES = 128
+/** Maximum total UTF-8 bytes across all declared tag labels for one content item. */
+export const MAX_ITEM_TAGS_TOTAL_BYTES = 2_048
+
+export type TagInputErrorCode =
+	| 'tags_not_array'
+	| 'tag_not_string'
+	| 'tag_blank'
+	| 'tag_untrimmed'
+	| 'tag_not_nfc'
+	| 'tag_label_too_long'
+	| 'tag_non_slugifiable'
+	| 'tag_duplicate'
+	| 'tag_count_exceeded'
+	| 'tags_total_bytes_exceeded'
+	| 'tag_canonical_invalid'
+	| 'tag_labels_mismatch'
+	| 'tag_label_mismatch'
+
+export interface TaxonomyTag {
+	slug: string
+	label: string
+}
+
+export class TagInputError extends Error {
+	constructor(
+		readonly code: TagInputErrorCode,
+		message: string,
+		readonly limit: number,
+		readonly actual: number,
+		readonly index: number | null = null,
+	) {
+		super(message)
+		this.name = 'TagInputError'
+	}
+}
+
+export function utf8ByteLength(value: string): number {
+	return new TextEncoder().encode(value).byteLength
+}
+
+function fail(
+	code: TagInputErrorCode,
+	message: string,
+	limit: number,
+	actual: number,
+	index: number | null = null,
+): never {
+	throw new TagInputError(code, message, limit, actual, index)
+}
+
+function assertTagCount(tags: readonly unknown[]): void {
+	if (tags.length > MAX_ITEM_TAG_COUNT) {
+		fail(
+			'tag_count_exceeded',
+			`tag count exceeds the ${MAX_ITEM_TAG_COUNT}-item limit`,
+			MAX_ITEM_TAG_COUNT,
+			tags.length,
+		)
+	}
+}
+
+function validateDeclaredLabel(value: unknown, index: number): TaxonomyTag {
+	if (typeof value !== 'string') {
+		fail('tag_not_string', 'each tag must be a string', MAX_ITEM_TAG_COUNT, -1, index)
+	}
+	if (!value.trim()) {
+		fail('tag_blank', 'tag must not be blank or whitespace-only', MAX_ITEM_TAG_COUNT, -1, index)
+	}
+	if (value !== value.trim()) {
+		fail(
+			'tag_untrimmed',
+			'tag must not contain surrounding whitespace',
+			MAX_ITEM_TAG_COUNT,
+			-1,
+			index,
+		)
+	}
+	if (value !== value.normalize('NFC')) {
+		fail('tag_not_nfc', 'tag must be NFC-normalized', MAX_ITEM_TAG_COUNT, -1, index)
+	}
+	const labelBytes = utf8ByteLength(value)
+	if (labelBytes > MAX_TAG_LABEL_BYTES) {
+		fail(
+			'tag_label_too_long',
+			`tag label exceeds the ${MAX_TAG_LABEL_BYTES}-byte limit`,
+			MAX_TAG_LABEL_BYTES,
+			labelBytes,
+			index,
+		)
+	}
+	const slug = slugify(value)
+	if (!slug) {
+		fail(
+			'tag_non_slugifiable',
+			'tag label must produce a non-empty slug after canonicalization',
+			MAX_ITEM_TAG_COUNT,
+			-1,
+			index,
+		)
+	}
+	return { slug, label: value }
+}
+
+function validateCanonicalSlug(value: unknown, index: number): string {
+	if (typeof value !== 'string') {
+		fail('tag_not_string', 'each canonical tag must be a string', MAX_ITEM_TAG_COUNT, -1, index)
+	}
+	if (
+		!value ||
+		value !== value.trim() ||
+		value !== value.normalize('NFC') ||
+		slugify(value) !== value
+	) {
+		fail(
+			'tag_canonical_invalid',
+			'canonical tag must be a normalized slug',
+			MAX_ITEM_TAG_COUNT,
+			-1,
+			index,
+		)
+	}
+	const slugBytes = utf8ByteLength(value)
+	if (slugBytes > MAX_TAG_LABEL_BYTES) {
+		fail(
+			'tag_label_too_long',
+			`canonical tag exceeds the ${MAX_TAG_LABEL_BYTES}-byte limit`,
+			MAX_TAG_LABEL_BYTES,
+			slugBytes,
+			index,
+		)
+	}
+	return value
+}
+
+function validatePairs(pairs: TaxonomyTag[]): TaxonomyTag[] {
+	const seen = new Set<string>()
+	let totalBytes = 0
+	for (let index = 0; index < pairs.length; index += 1) {
+		const pair = pairs[index] as TaxonomyTag
+		if (seen.has(pair.slug)) {
+			fail(
+				'tag_duplicate',
+				`duplicate tag after canonicalization: slug "${pair.slug}"`,
+				MAX_ITEM_TAG_COUNT,
+				-1,
+				index,
+			)
+		}
+		seen.add(pair.slug)
+		totalBytes += utf8ByteLength(pair.label)
+		if (totalBytes > MAX_ITEM_TAGS_TOTAL_BYTES) {
+			fail(
+				'tags_total_bytes_exceeded',
+				`total tag bytes exceed the ${MAX_ITEM_TAGS_TOTAL_BYTES}-byte limit`,
+				MAX_ITEM_TAGS_TOTAL_BYTES,
+				totalBytes,
+				index,
+			)
+		}
+	}
+	return pairs
+}
+
+export function validateDeclaredTagList(tags: unknown): TaxonomyTag[] {
+	if (!Array.isArray(tags)) {
+		fail('tags_not_array', 'tags must be an array', MAX_ITEM_TAG_COUNT, -1)
+	}
+	assertTagCount(tags)
+	return validatePairs(tags.map((tag, index) => validateDeclaredLabel(tag, index)))
+}
+
+export function validateSingleDeclaredTag(label: unknown): TaxonomyTag {
+	return validateDeclaredTagList([label])[0] as TaxonomyTag
+}
+
+export function validateRevisionTaxonomy(input: {
+	tags: unknown
+	tagLabels?: unknown
+	allowLegacyLabels?: boolean
+}): TaxonomyTag[] {
+	const tags = input.tags
+	if (!Array.isArray(tags)) {
+		fail('tags_not_array', 'revision tags must be an array', MAX_ITEM_TAG_COUNT, -1)
+	}
+	assertTagCount(tags)
+	const labels = input.tagLabels === undefined && input.allowLegacyLabels ? tags : input.tagLabels
+	if (!Array.isArray(labels) || labels.length !== tags.length) {
+		fail(
+			'tag_labels_mismatch',
+			'revision tagLabels must be parallel to tags',
+			tags.length,
+			Array.isArray(labels) ? labels.length : -1,
+		)
+	}
+	const pairs = tags.map((tag, index) => {
+		const slug = validateCanonicalSlug(tag, index)
+		const label = validateDeclaredLabel(labels[index], index)
+		if (label.slug !== slug) {
+			fail(
+				'tag_label_mismatch',
+				'revision tag label does not canonicalize to its parallel tag',
+				MAX_ITEM_TAG_COUNT,
+				-1,
+				index,
+			)
+		}
+		return { slug, label: label.label }
+	})
+	return validatePairs(pairs)
+}
+
+export function validateStoredTaxonomyRows(
+	rows: readonly { slug: unknown; label: unknown }[],
+): TaxonomyTag[] {
+	return validateRevisionTaxonomy({
+		tags: rows.map((row) => row.slug),
+		tagLabels: rows.map((row) => row.label),
+		allowLegacyLabels: false,
+	})
+}

package/src/index.ts

@@ -30,6 +30,8 @@
 
 // The publishing engine — the content data-access core (WS7-05). Also
 // available at the `@growth-labs/cms/engine` subpath.
+// Tag taxonomy bounds (MAX_ITEM_TAG_COUNT, MAX_TAG_LABEL_BYTES, MAX_ITEM_TAGS_TOTAL_BYTES)
+// and TagInputError are re-exported via engine/index.js.
 export * from './engine/index.js'
 
 // Injected-provider interfaces + null implementations (spec §3.3).

package/src/routes/content.ts

@@ -36,6 +36,7 @@ import {
 	evaluateContentBodyForPublish,
 	getContentItem,
 	getContentRelations,
+	getContentTagPairs,
 	publishContent,
 	scheduleContent,
 	unpublishContent,
@@ -50,6 +51,7 @@ import {
 } from '../engine/revisions.js'
 import { applySlugRenameRedirects } from '../engine/slug-redirects.js'
 import { softDeleteContent } from '../engine/soft-delete.js'
+import { TagInputError } from '../engine/taxonomy.js'
 import type { ContentStatus } from '../schema/types.js'
 import { type ContentAction, canPerformContentAction } from './authz-matrix.js'
 import type { CmsRouteConfig } from './config.js'
@@ -582,13 +584,7 @@ async function getContentPayload(ctx: RouteContext, type: string, id: string) {
 }
 
 async function getContentTags(ctx: RouteContext, id: string): Promise<string[]> {
-	const result = await ctx.db
-		.prepare(
-			'SELECT t.slug FROM content_tag_links l JOIN content_tags t ON t.id = l.tag_id WHERE l.content_id = ? ORDER BY t.label ASC',
-		)
-		.bind(id)
-		.all<{ slug: string }>()
-	return (result.results || []).map((row) => row.slug)
+	return (await getContentTagPairs(ctx.db, id)).map((row) => row.slug)
 }
 
 async function getMediaAssetUrls(db: D1Database, ids: string[]): Promise<Record<string, string>> {
@@ -612,6 +608,19 @@ async function readJson(ctx: RouteContext): Promise<unknown> {
 	return ctx.request.json().catch(() => null)
 }
 
+function tagInputErrorResponse(error: TagInputError): Response {
+	return json(
+		{
+			error: 'Invalid tags',
+			code: error.code,
+			limit: error.limit,
+			actual: error.actual,
+			index: error.index,
+		},
+		400,
+	)
+}
+
 export interface ContentRouteHandlers {
 	/** GET /content — cursor-paginated list (q, author, status, types filters; excludes deleted). */
 	list(ctx: RouteContext): Promise<Response>
@@ -1034,6 +1043,7 @@ export function createContentRoutes(config: ContentRouteConfig): ContentRouteHan
 			try {
 				created = await createContent(ctx.db, parsed.data)
 			} catch (error) {
+				if (error instanceof TagInputError) return tagInputErrorResponse(error)
 				const conflict = verifiedMediaDurationConflictResponse(error)
 				if (conflict) return conflict
 				throw error
@@ -1073,17 +1083,30 @@ export function createContentRoutes(config: ContentRouteConfig): ContentRouteHan
 			const item = await getContentItem(ctx.db, id)
 			if (!item) return json({ error: 'Not found' }, 404)
 
-			const [content, tags, relations, author] = await Promise.all([
-				getContentPayload(ctx, item.type, id),
-				getContentTags(ctx, id),
-				getContentRelations(ctx.db, id),
-				item.author_id
-					? ctx.db
-							.prepare('SELECT name, slug FROM authors WHERE id = ? LIMIT 1')
-							.bind(item.author_id)
-							.first<{ name: string | null; slug: string | null }>()
-					: Promise.resolve(null),
-			])
+			let content: unknown
+			let tags: string[]
+			let relations: Awaited<ReturnType<typeof getContentRelations>>
+			let author: { name: string | null; slug: string | null } | null
+			try {
+				const resolvedContent = await Promise.all([
+					getContentPayload(ctx, item.type, id),
+					getContentTags(ctx, id),
+					getContentRelations(ctx.db, id),
+					item.author_id
+						? ctx.db
+								.prepare('SELECT name, slug FROM authors WHERE id = ? LIMIT 1')
+								.bind(item.author_id)
+								.first<{ name: string | null; slug: string | null }>()
+						: Promise.resolve(null),
+				])
+				content = resolvedContent[0]
+				tags = resolvedContent[1]
+				relations = resolvedContent[2]
+				author = resolvedContent[3]
+			} catch (error) {
+				if (error instanceof TagInputError) return tagInputErrorResponse(error)
+				throw error
+			}
 			const contentRecord = content as Record<string, unknown> | null
 			const thumbnailImageId =
 				typeof contentRecord?.thumbnail_image_id === 'string'
@@ -1193,6 +1216,7 @@ export function createContentRoutes(config: ContentRouteConfig): ContentRouteHan
 			try {
 				updated = await updateContentItem(ctx.db, id, parsed.data)
 			} catch (error) {
+				if (error instanceof TagInputError) return tagInputErrorResponse(error)
 				const conflict = verifiedMediaDurationConflictResponse(error)
 				if (conflict) return conflict
 				throw error
@@ -1332,7 +1356,6 @@ export function createContentRoutes(config: ContentRouteConfig): ContentRouteHan
 						422,
 					)
 				}
-
 				if (!existing.excerpt?.trim()) {
 					let failureReason: string | null = null
 					if (!resolved.hooks.llm) {
@@ -1370,8 +1393,19 @@ export function createContentRoutes(config: ContentRouteConfig): ContentRouteHan
 						}
 					}
 				}
-				await publishContent(ctx.db, id, now)
-				await createRevision(ctx.db, id, ctx.userId || null)
+				try {
+					await getContentTagPairs(ctx.db, id)
+				} catch (error) {
+					if (error instanceof TagInputError) return tagInputErrorResponse(error)
+					throw error
+				}
+				try {
+					await publishContent(ctx.db, id, now)
+					await createRevision(ctx.db, id, ctx.userId || null)
+				} catch (error) {
+					if (error instanceof TagInputError) return tagInputErrorResponse(error)
+					throw error
+				}
 
 				// Write first-party activity log row (cms_activity_log, P5 Task 3).
 				// Wrapped so a logging failure never breaks the publish response.
@@ -1554,10 +1588,16 @@ export function createContentRoutes(config: ContentRouteConfig): ContentRouteHan
 			}
 
 			if (action === 'snapshot') {
-				const revision = await createRevisionWithDelta(ctx.db, id, {
-					createdBy: ctx.userId ?? null,
-					tag: 'autosave',
-				})
+				let revision: Awaited<ReturnType<typeof createRevisionWithDelta>>
+				try {
+					revision = await createRevisionWithDelta(ctx.db, id, {
+						createdBy: ctx.userId ?? null,
+						tag: 'autosave',
+					})
+				} catch (error) {
+					if (error instanceof TagInputError) return tagInputErrorResponse(error)
+					throw error
+				}
 				if (!revision) return json({ error: 'Not found' }, 404)
 				return json({ status: 'snapshot', revisionId: revision.id })
 			}
@@ -1885,7 +1925,13 @@ export function createContentRoutes(config: ContentRouteConfig): ContentRouteHan
 			const rev = ctx.params.rev
 			if (!rev) return json({ error: 'Missing rev' }, 400)
 
-			const ok = await restoreRevision(ctx.db, id, rev, { createdBy: ctx.userId ?? null })
+			let ok: Awaited<ReturnType<typeof restoreRevision>>
+			try {
+				ok = await restoreRevision(ctx.db, id, rev, { createdBy: ctx.userId ?? null })
+			} catch (error) {
+				if (error instanceof TagInputError) return tagInputErrorResponse(error)
+				throw error
+			}
 			if (!ok) return json({ error: 'Not found' }, 404)
 
 			return json({ restored: true })

package/src/routes/tags.ts

@@ -4,6 +4,7 @@
 
 import { z } from 'zod'
 import { createTag, deleteTag, getTag, listTags, renameTag, searchTags } from '../engine/tags.js'
+import { TagInputError } from '../engine/taxonomy.js'
 import type { CmsRouteConfig } from './config.js'
 import { resolveConfig } from './config.js'
 import { json, type RouteContext } from './context.js'
@@ -12,6 +13,25 @@ const TagWriteSchema = z.object({
 	label: z.string().min(1),
 })
 
+function parseLimit(value: string | null): number | undefined {
+	if (value === null) return undefined
+	const limit = Number(value)
+	return Number.isSafeInteger(limit) ? limit : undefined
+}
+
+function tagInputErrorResponse(error: TagInputError): Response {
+	return json(
+		{
+			error: 'Invalid tag',
+			code: error.code,
+			limit: error.limit,
+			actual: error.actual,
+			index: error.index,
+		},
+		400,
+	)
+}
+
 export interface TagRouteHandlers {
 	/**
 	 * GET /tags or GET /tags?q=<query>
@@ -42,8 +62,9 @@ export function createTagRoutes(config: CmsRouteConfig): TagRouteHandlers {
 
 			const url = new URL(ctx.request.url)
 			const q = url.searchParams.get('q')
+			const limit = parseLimit(url.searchParams.get('limit'))
 
-			const tags = q ? await searchTags(ctx.db, q) : await listTags(ctx.db)
+			const tags = q ? await searchTags(ctx.db, q, { limit }) : await listTags(ctx.db, { limit })
 			return json({ tags })
 		},
 
@@ -55,7 +76,13 @@ export function createTagRoutes(config: CmsRouteConfig): TagRouteHandlers {
 			if (!parsed.success) {
 				return json({ error: 'Invalid request', details: parsed.error.flatten() }, 400)
 			}
-			const tag = await createTag(ctx.db, parsed.data.label)
+			let tag: Awaited<ReturnType<typeof createTag>>
+			try {
+				tag = await createTag(ctx.db, parsed.data.label)
+			} catch (error) {
+				if (error instanceof TagInputError) return tagInputErrorResponse(error)
+				throw error
+			}
 			if (!tag) return json({ error: 'Tag already exists or label is invalid' }, 409)
 			return json({ tag }, 201)
 		},
@@ -73,7 +100,13 @@ export function createTagRoutes(config: CmsRouteConfig): TagRouteHandlers {
 			if (!parsed.success) {
 				return json({ error: 'Invalid request', details: parsed.error.flatten() }, 400)
 			}
-			const ok = await renameTag(ctx.db, id, parsed.data.label)
+			let ok: Awaited<ReturnType<typeof renameTag>>
+			try {
+				ok = await renameTag(ctx.db, id, parsed.data.label)
+			} catch (error) {
+				if (error instanceof TagInputError) return tagInputErrorResponse(error)
+				throw error
+			}
 			if (!ok) return json({ error: 'Tag slug already exists or label is invalid' }, 409)
 			const tag = await getTag(ctx.db, id)
 			return json({ tag })

package/src/schema/migrations.ts

@@ -811,7 +811,21 @@ ALTER TABLE content_insight_dismissals
   ADD COLUMN reason_code TEXT CHECK (reason_code IS NULL OR reason_code IN ('off_topic', 'already_covered', 'cant_win', 'wrong_format', 'not_now', 'other'));
 ALTER TABLE content_insight_dismissals
   ADD COLUMN note TEXT CHECK (note IS NULL OR length(note) <= 500);
-`,
+	`,
+	},
+	{
+		id: '0023_content_tag_link_labels',
+		sql: `
+ALTER TABLE content_tag_links
+  ADD COLUMN label TEXT;
+UPDATE content_tag_links
+SET label = (
+  SELECT label
+  FROM content_tags
+  WHERE content_tags.id = content_tag_links.tag_id
+ )
+ WHERE label IS NULL;
+	`,
 	},
 ]
 

package/src/schema/types.ts

@@ -167,6 +167,7 @@ export interface ContentTagRow {
 export interface ContentTagLinkRow {
 	content_id: string
 	tag_id: string
+	label: string | null
 }
 
 export interface ContentRelationRow {

package/src/ui/editor/Rte.tsx

@@ -14,14 +14,10 @@
 // Runtime/visual verification is done via the Playwright smoke (SMOKE.md P2 section).
 
 import { Editor } from '@tiptap/core'
-import Image from '@tiptap/extension-image'
-import Link from '@tiptap/extension-link'
-import Underline from '@tiptap/extension-underline'
-import StarterKit from '@tiptap/starter-kit'
 import { useEffect, useRef, useState } from 'react'
 import { Icon } from '../icons.js'
+import { createRteExtensions } from './extensions.js'
 import { docToMarkdown, markdownToDoc } from './serialize.js'
-import { TweetEmbed } from './tweet-embed.js'
 
 // ---------------------------------------------------------------------------
 // Toolbar config
@@ -114,13 +110,7 @@ export function Rte({
 
 		const editor = new Editor({
 			element: el,
-			extensions: [
-				StarterKit,
-				Underline,
-				Link.configure({ openOnClick: false }),
-				Image,
-				TweetEmbed,
-			],
+			extensions: createRteExtensions(),
 			content: markdownToDoc(initialValueRef.current),
 			editable: !readOnly,
 			onUpdate({ editor: e }) {

package/src/ui/editor/extensions.ts

@@ -0,0 +1,18 @@
+import Image from '@tiptap/extension-image'
+import Link from '@tiptap/extension-link'
+import Underline from '@tiptap/extension-underline'
+import StarterKit from '@tiptap/starter-kit'
+import { TrimBoundaryMarks } from './trim-boundary-marks.js'
+import { TweetEmbed } from './tweet-embed.js'
+
+/** The single extension set used by Masthead and its behavioral editor tests. */
+export function createRteExtensions() {
+	return [
+		StarterKit.configure({ link: false, underline: false }),
+		Underline,
+		Link.configure({ openOnClick: false }),
+		TrimBoundaryMarks,
+		Image,
+		TweetEmbed,
+	]
+}