@growth-labs/cms 0.5.11 → 0.5.13

package/src/engine/published-content.ts

@@ -6,6 +6,7 @@ import {
 } from './content-metadata.js'
 import type { D1Database } from './d1.js'
 import type { ContentRevisionPayload } from './revisions.js'
+import { TagInputError, validateRevisionTaxonomy } from './taxonomy.js'
 
 const CONTENT_TYPES = new Set<ContentType>(['article', 'video', 'podcast', 'newsletter', 'page'])
 const CONTENT_STATUSES = new Set(['draft', 'scheduled', 'review', 'published', 'archived'])
@@ -168,14 +169,19 @@ function validatePayload(raw: string, row: PublishedContentRow): ContentRevision
 	if (decoded.content !== null && !isPlainRecord(decoded.content)) {
 		return invalidPayload('published revision content must be an object or null')
 	}
-	if (!Array.isArray(decoded.tags) || !decoded.tags.every((tag) => typeof tag === 'string')) {
-		return invalidPayload('published revision tags must be strings')
-	}
-	if (
-		decoded.tags.length > 10 ||
-		decoded.tags.some((tag) => tag.length === 0 || tag.length > 256)
-	) {
-		return invalidPayload('published revision tags exceed their canonical bounds')
+	try {
+		const taxonomy = validateRevisionTaxonomy({
+			tags: decoded.tags,
+			tagLabels: decoded.tagLabels,
+			allowLegacyLabels: true,
+		})
+		decoded.tags = taxonomy.map((tag) => tag.slug)
+		decoded.tagLabels = taxonomy.map((tag) => tag.label)
+	} catch (error) {
+		if (error instanceof TagInputError) {
+			return invalidPayload(`published revision taxonomy is invalid: ${error.code}`)
+		}
+		throw error
 	}
 	if (
 		!Array.isArray(decoded.related) ||

package/src/engine/publisher.ts

@@ -24,6 +24,22 @@ import { type ContentMetadata, serializeContentMetadata } from './content-metada
 import type { D1Database } from './d1.js'
 import { evaluateArticleBody, type PublishGuardOutcome } from './publish-guard.js'
 import { slugify } from './slug.js'
+import {
+	MAX_ITEM_TAG_COUNT,
+	type TaxonomyTag,
+	validateDeclaredTagList,
+	validateStoredTaxonomyRows,
+} from './taxonomy.js'
+
+export {
+	MAX_ITEM_TAG_COUNT,
+	MAX_ITEM_TAGS_TOTAL_BYTES,
+	MAX_TAG_LABEL_BYTES,
+	TagInputError,
+	validateDeclaredTagList,
+	validateRevisionTaxonomy,
+	validateSingleDeclaredTag,
+} from './taxonomy.js'
 
 type ContentVisibility = 'free' | 'premium'
 type BodyBackedContentType = 'article' | 'newsletter' | 'page'
@@ -449,14 +465,6 @@ export async function ensureUniqueSlug(
 	}
 }
 
-function normalizeTags(tags?: string[]): string[] {
-	if (!tags) return []
-	return tags
-		.map((tag) => slugify(tag))
-		.filter(Boolean)
-		.slice(0, 10)
-}
-
 function serializeTakeaways(value: string[] | null | undefined): string | null {
 	if (!value) return null
 	const normalized = value
@@ -466,11 +474,18 @@ function serializeTakeaways(value: string[] | null | undefined): string | null {
 	return normalized.length > 0 ? JSON.stringify(normalized) : null
 }
 
-async function ensureTags(db: D1Database, tags: string[]): Promise<{ id: string; slug: string }[]> {
-	const normalized = normalizeTags(tags)
-	const results: { id: string; slug: string }[] = []
-
-	for (const tag of normalized) {
+async function ensureTags(
+	db: D1Database,
+	pairs: TaxonomyTag[],
+): Promise<
+	Array<{
+		id: string
+		slug: string
+		label: string
+	}>
+> {
+	const results: Array<{ id: string; slug: string; label: string }> = []
+	for (const { slug, label } of pairs) {
 		// Concurrency-safe upsert. A plain SELECT-then-INSERT races under parallel
 		// import shards: two shards can both miss the same shared tag slug and both
 		// INSERT it, and the second hits `UNIQUE constraint failed: content_tags.slug`
@@ -482,20 +497,19 @@ async function ensureTags(db: D1Database, tags: string[]): Promise<{ id: string;
 			.prepare(
 				'INSERT INTO content_tags (id, slug, label) VALUES (?, ?, ?) ON CONFLICT(slug) DO NOTHING',
 			)
-			.bind(crypto.randomUUID(), tag, tag)
+			.bind(crypto.randomUUID(), slug, label)
 			.run()
 
 		const row = await db
 			.prepare('SELECT id, slug FROM content_tags WHERE slug = ? LIMIT 1')
-			.bind(tag)
+			.bind(slug)
 			.first<{ id: string; slug: string }>()
 
 		if (!row) {
-			throw new Error(`content tag "${tag}" could not be resolved after upsert`)
+			throw new Error(`content tag "${slug}" could not be resolved after upsert`)
 		}
-		results.push(row)
+		results.push({ ...row, label })
 	}
-
 	return results
 }
 
@@ -504,19 +518,44 @@ export async function setContentTags(
 	contentId: string,
 	tags: string[],
 ): Promise<void> {
-	const normalized = normalizeTags(tags)
-	await db.prepare('DELETE FROM content_tag_links WHERE content_id = ?').bind(contentId).run()
-	if (normalized.length === 0) return
-
-	const tagRows = await ensureTags(db, normalized)
-
-	const insert = db.prepare('INSERT INTO content_tag_links (content_id, tag_id) VALUES (?, ?)')
+	const pairs = validateDeclaredTagList(tags)
+	await setContentTagPairs(db, contentId, pairs)
+}
 
+async function setContentTagPairs(
+	db: D1Database,
+	contentId: string,
+	pairs: TaxonomyTag[],
+): Promise<void> {
+	await db.prepare('DELETE FROM content_tag_links WHERE content_id = ?').bind(contentId).run()
+	if (pairs.length === 0) return
+	const tagRows = await ensureTags(db, pairs)
+	const insert = db.prepare(
+		'INSERT INTO content_tag_links (content_id, tag_id, label) VALUES (?, ?, ?)',
+	)
 	for (const tag of tagRows) {
-		await insert.bind(contentId, tag.id).run()
+		await insert.bind(contentId, tag.id, tag.label).run()
 	}
 }
 
+export async function getContentTagPairs(
+	db: D1Database,
+	contentId: string,
+): Promise<TaxonomyTag[]> {
+	const tags = await db
+		.prepare(
+			`SELECT t.slug, COALESCE(l.label, t.label) AS label
+			 FROM content_tag_links l
+			 JOIN content_tags t ON t.id = l.tag_id
+			 WHERE l.content_id = ?
+			 ORDER BY t.slug ASC
+			 LIMIT ?`,
+		)
+		.bind(contentId, MAX_ITEM_TAG_COUNT + 1)
+		.all<{ slug: string; label: string }>()
+	return validateStoredTaxonomyRows(tags.results || [])
+}
+
 export async function setContentRelations(
 	db: D1Database,
 	contentId: string,
@@ -567,6 +606,7 @@ export async function createContent(
 						input.content.durationSeconds,
 					)
 				: null
+	const tagPairs = input.tags === undefined ? null : validateDeclaredTagList(input.tags)
 	const id = crypto.randomUUID()
 	const slug = await ensureUniqueSlug(db, input.slug)
 	const visibility = input.visibility || 'free'
@@ -672,8 +712,8 @@ export async function createContent(
 			.run()
 	}
 
-	if (input.tags) {
-		await setContentTags(db, id, input.tags)
+	if (tagPairs) {
+		await setContentTagPairs(db, id, tagPairs)
 	}
 
 	return { id, slug }
@@ -694,6 +734,7 @@ export async function updateContentItem(
 	id: string,
 	input: UpdateContentInput,
 ): Promise<{ slug: string } | null> {
+	const tagPairs = input.tags === undefined ? null : validateDeclaredTagList(input.tags)
 	const existing = await getContentItem(db, id)
 	if (!existing) return null
 
@@ -912,7 +953,7 @@ export async function updateContentItem(
 		.run()
 
 	if (input.tags !== undefined) {
-		await setContentTags(db, id, input.tags)
+		await setContentTagPairs(db, id, tagPairs ?? [])
 	}
 
 	if (input.relations !== undefined) {
@@ -1278,11 +1319,11 @@ export async function duplicateContentItem(
 			.run()
 	}
 
-	// INSERT…SELECT copy #4 — content_tag_links (carry the same tags).
+	// INSERT…SELECT copy #4 — content_tag_links (carry the same canonical tags and labels).
 	await db
 		.prepare(
-			`INSERT INTO content_tag_links (content_id, tag_id)
-			 SELECT ?, tag_id FROM content_tag_links WHERE content_id = ?`,
+			`INSERT INTO content_tag_links (content_id, tag_id, label)
+			 SELECT ?, tag_id, label FROM content_tag_links WHERE content_id = ?`,
 		)
 		.bind(newId, sourceId)
 		.run()
@@ -1347,12 +1388,7 @@ export async function getContentSnapshot(
 			.first<Record<string, unknown>>()
 	}
 
-	const tags = await 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.slug ASC',
-		)
-		.bind(contentId)
-		.all<{ slug: string }>()
+	const tags = await getContentTagPairs(db, contentId)
 
 	const related = await db
 		.prepare(
@@ -1364,7 +1400,8 @@ export async function getContentSnapshot(
 	return {
 		item: base,
 		content,
-		tags: (tags.results || []).map((row) => row.slug),
+		tags: tags.map((row) => row.slug),
+		tagLabels: tags.map((row) => row.label),
 		related: related.results || [],
 	}
 }

package/src/engine/revisions.ts

@@ -8,12 +8,16 @@
 import { parseContentMetadata } from './content-metadata.js'
 import type { D1Database } from './d1.js'
 import { countWords, getContentItem, getContentSnapshot, updateContentItem } from './publisher.js'
+import { validateRevisionTaxonomy } from './taxonomy.js'
 
 /** The one canonical revision snapshot shape (spec §4 "ContentRevisionPayload"). */
 export interface ContentRevisionPayload {
 	item: Record<string, unknown>
 	content: Record<string, unknown> | null
+	/** Canonical tag slugs, ordered ascending. */
 	tags: string[]
+	/** NFC-normalized display labels parallel to tags[]; preserves original casing through revisions. */
+	tagLabels?: string[]
 	related: Array<{ related_id: string; rank: number; reason: string | null }>
 }
 
@@ -212,6 +216,11 @@ export async function restoreRevision(
 		}
 	}
 	const restoredTakeaways = parseTakeaways(body?.editor_takeaways)
+	const restoredTags = validateRevisionTaxonomy({
+		tags: target.payload.tags,
+		tagLabels: target.payload.tagLabels,
+		allowLegacyLabels: true,
+	}).map((tag) => tag.label)
 	// Restore intentionally rolls back CONTENT fields (title/body/tags/relations/
 	// featured/seo/hero/etc.) to the snapshot, but NOT publication state
 	// (status / publish_at / published_at / published_revision_id) — that is by
@@ -237,7 +246,7 @@ export async function restoreRevision(
 		metadata: parseContentMetadata(
 			typeof item.metadata_json === 'string' ? item.metadata_json : '{}',
 		),
-		tags: target.payload.tags,
+		tags: restoredTags,
 		relations: target.payload.related.map((r) => ({
 			relatedId: r.related_id,
 			rank: r.rank,

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).