@nuasite/cms 0.30.0 → 0.32.0

package/src/handlers/source-writer.ts

@@ -7,7 +7,7 @@ import type { AttributeChangePayload, ChangePayload, SaveBatchRequest } from '..
 import type { ManifestWriter } from '../manifest-writer'
 import { extractAstroImageOriginalUrl } from '../source-finder/snippet-utils'
 import type { CmsManifest, ManifestEntry } from '../types'
-import { acquireFileLock, escapeReplacement, normalizePagePath, resolveAndValidatePath } from '../utils'
+import { acquireFileLock, escapeRegex, escapeReplacement, normalizePagePath, resolveAndValidatePath } from '../utils'
 
 export interface SaveBatchResponse {
 	updated: number
@@ -216,8 +216,8 @@ export function applyImageChange(
 	let replacedIndex = -1
 	for (const srcToFind of srcCandidates) {
 		// Use non-global patterns to replace only the first occurrence
-		const srcPatternDouble = new RegExp(`src="${escapeRegExp(srcToFind)}"`)
-		const srcPatternSingle = new RegExp(`src='${escapeRegExp(srcToFind)}'`)
+		const srcPatternDouble = new RegExp(`src="${escapeRegex(srcToFind)}"`)
+		const srcPatternSingle = new RegExp(`src='${escapeRegex(srcToFind)}'`)
 
 		const escapedNewSrc = escapeReplacement(newSrc)
 		const doubleMatch = newContent.match(srcPatternDouble)
@@ -487,7 +487,39 @@ function appendClassToAttribute(
 	return { success: false, error: 'No class attribute found in source file' }
 }
 
-function applyAttributeChanges(
+/**
+ * Locate `sourceSnippet` in `content` and replace the first quoted occurrence
+ * of `oldValue` inside that snippet with `newValue`, then splice back. Returns
+ * the updated file content, or undefined if the snippet isn't in the file or
+ * contains no quoted match.
+ *
+ * Used as the save-path for attribute values backed by a JS literal (variable
+ * definition, conditional branch) where there's no `attrName=` prefix on the
+ * source line. Scoping the match to the recorded snippet prevents accidental
+ * hits elsewhere in the file.
+ */
+const QUOTED_LITERAL_DELIMITERS = [`'`, `"`, '`'] as const
+
+function replaceLiteralInSnippet(
+	content: string,
+	snippet: string,
+	oldValue: string,
+	newValue: string,
+): string | undefined {
+	if (!content.includes(snippet)) return undefined
+
+	const safeNewValue = escapeReplacement(newValue)
+	const escapedOld = escapeRegex(oldValue)
+	for (const quote of QUOTED_LITERAL_DELIMITERS) {
+		const pattern = new RegExp(`${quote}(${escapedOld})${quote}`)
+		if (!pattern.test(snippet)) continue
+		const updated = snippet.replace(pattern, `${quote}${safeNewValue}${quote}`)
+		if (updated !== snippet) return content.replace(snippet, updated)
+	}
+	return undefined
+}
+
+export function applyAttributeChanges(
 	content: string,
 	change: ChangePayload,
 ): {
@@ -517,10 +549,10 @@ function applyAttributeChanges(
 			if (lineIndex >= 0 && lineIndex < lines.length) {
 				const line = lines[lineIndex]!
 				const doubleQuotePattern = new RegExp(
-					`(${escapeRegExp(attributeName)}\\s*=\\s*)"(${escapeRegExp(attrOldValue)})"`,
+					`(${escapeRegex(attributeName)}\\s*=\\s*)"(${escapeRegex(attrOldValue)})"`,
 				)
 				const singleQuotePattern = new RegExp(
-					`(${escapeRegExp(attributeName)}\\s*=\\s*)'(${escapeRegExp(attrOldValue)})'`,
+					`(${escapeRegex(attributeName)}\\s*=\\s*)'(${escapeRegex(attrOldValue)})'`,
 				)
 
 				const safeNewValue = escapeReplacement(attrNewValue)
@@ -533,10 +565,33 @@ function applyAttributeChanges(
 					newContent = lines.join('\n')
 					attrApplied++
 				} else {
-					failedChanges.push({
-						cmsId: change.cmsId,
-						error: `Attribute '${attributeName}="${attrOldValue}"' not found on line ${targetLine}`,
-					})
+					// JS-backed value (variable def or conditional branch) — no
+					// `attrName=` on the line, so scope the replacement to the
+					// recorded snippet.
+					const snippet = attrChange.sourceSnippet
+					if (!snippet) {
+						failedChanges.push({
+							cmsId: change.cmsId,
+							error: `Attribute '${attributeName}="${attrOldValue}"' not found on line ${targetLine}`,
+						})
+					} else {
+						const snippetResult = replaceLiteralInSnippet(
+							newContent,
+							snippet,
+							attrOldValue,
+							attrNewValue,
+						)
+						if (snippetResult) {
+							newContent = snippetResult
+							attrApplied++
+						} else {
+							failedChanges.push({
+								cmsId: change.cmsId,
+								error: `Attribute '${attributeName}="${attrOldValue}"' not found on line ${targetLine} `
+									+ `and source snippet did not yield a quoted literal match`,
+							})
+						}
+					}
 				}
 			} else {
 				failedChanges.push({
@@ -547,10 +602,10 @@ function applyAttributeChanges(
 		} else {
 			// Fallback: replace first occurrence in the whole file
 			const doubleQuotePattern = new RegExp(
-				`(${escapeRegExp(attributeName)}\\s*=\\s*)"(${escapeRegExp(attrOldValue)})"`,
+				`(${escapeRegex(attributeName)}\\s*=\\s*)"(${escapeRegex(attrOldValue)})"`,
 			)
 			const singleQuotePattern = new RegExp(
-				`(${escapeRegExp(attributeName)}\\s*=\\s*)'(${escapeRegExp(attrOldValue)})'`,
+				`(${escapeRegex(attributeName)}\\s*=\\s*)'(${escapeRegex(attrOldValue)})'`,
 			)
 
 			const safeNewValue = escapeReplacement(attrNewValue)
@@ -590,7 +645,10 @@ export function applyTextChange(
 		return { success: false, error: 'Source snippet not found in file' }
 	}
 
-	const newText = htmlValue ?? newValue
+	// Never write HTML back into entries that don't allow styling — these are string props,
+	// collection fields, etc. where inline HTML would produce invalid source code.
+	const stylingAllowed = manifest.entries[change.cmsId]?.allowStyling !== false
+	const newText = stylingAllowed ? (htmlValue ?? newValue) : newValue
 
 	// When originalValue contains CMS placeholders (child elements like {{cms:cms-5}}),
 	// replace only the text segments between placeholders directly in the sourceSnippet.
@@ -724,10 +782,10 @@ function findTextInSnippet(snippet: string, decodedText: string): string | null
 		["'", '&apos;'],
 	]
 
-	let pattern = escapeRegExp(decodedText)
+	let pattern = escapeRegex(decodedText)
 	for (const [char, entity] of entityMap) {
-		const escapedChar = escapeRegExp(char)
-		const escapedEntity = escapeRegExp(entity)
+		const escapedChar = escapeRegex(char)
+		const escapedEntity = escapeRegex(entity)
 		pattern = pattern.replace(new RegExp(escapedChar, 'g'), `(?:${escapedChar}|${escapedEntity})`)
 	}
 
@@ -736,7 +794,7 @@ function findTextInSnippet(snippet: string, decodedText: string): string | null
 	if (match) return match[0]
 
 	// Try matching with <br> tags stripped from snippet
-	const chars = [...decodedText].map((ch) => escapeRegExp(ch))
+	const chars = [...decodedText].map((ch) => escapeRegex(ch))
 	const brAwarePattern = chars.join('(?:<br\\b[^>]*\\/?>)*')
 	const brRegex = new RegExp(brAwarePattern)
 	const brMatch = snippet.match(brRegex)
@@ -1008,7 +1066,3 @@ function tryBrNormalizedChange(
 
 	return result !== sourceSnippet ? result : null
 }
-
-function escapeRegExp(string: string): string {
-	return string.replace(/[.*+?^${}()|[\]\\]/g, '\\$&')
-}

package/src/source-finder/ast-extractors.ts

@@ -21,6 +21,43 @@ export function getStringValue(node: BabelNode): string | null {
 	return null
 }
 
+/**
+ * Collect every string-literal value reachable from a node, each paired with
+ * the line the literal itself sits on. Handles:
+ *   - StringLiteral / TemplateLiteral (no substitutions) — a single value
+ *   - ConditionalExpression (`a ? b : c`) — recurses into both branches
+ *   - LogicalExpression (`a || b`, `a && b`, `a ?? b`) — recurses into both sides
+ *
+ * The per-literal line is what lets `findAttributeSourceLocation` route edits
+ * to the *specific* branch whose value matches the rendered attribute.
+ */
+export function extractPossibleStringValues(
+	node: BabelNode,
+	lineTransformer: LineTransformer,
+): Array<{ value: string; line: number }> {
+	const results: Array<{ value: string; line: number }> = []
+	collect(node)
+	return results
+
+	function collect(n: BabelNode): void {
+		const simple = getStringValue(n)
+		if (simple !== null) {
+			const loc = n.loc as { start: { line: number } } | undefined
+			results.push({ value: simple, line: lineTransformer(loc?.start.line ?? 1) })
+			return
+		}
+		if (n.type === 'ConditionalExpression') {
+			collect(n.consequent as BabelNode)
+			collect(n.alternate as BabelNode)
+			return
+		}
+		if (n.type === 'LogicalExpression') {
+			collect(n.left as BabelNode)
+			collect(n.right as BabelNode)
+		}
+	}
+}
+
 // ============================================================================
 // Object and Array Extraction
 // ============================================================================

package/src/source-finder/cache.ts

@@ -21,6 +21,9 @@ let searchIndexInitialized = false
 /** Pre-built reverse index: normalizedText → SourceLocation[] (collection data files) */
 let collectionTextIndex: Map<string, SourceLocation[]> | null = null
 
+/** Lazy reverse index on i18n entries: translationKey → SearchIndexEntry[]. Rebuilt on demand after any mutation. */
+let translationKeyIndex: Map<string, SearchIndexEntry[]> | null = null
+
 /** Files that changed since last indexing — tracked by Vite watcher */
 const dirtyFiles = new Set<string>()
 
@@ -58,6 +61,24 @@ export function setSearchIndexInitialized(value: boolean): void {
 
 export function addToTextSearchIndex(entry: SearchIndexEntry): void {
 	textSearchIndex.push(entry)
+	translationKeyIndex = null
+}
+
+/**
+ * Reverse-index i18n entries by their dictionary key, rebuilt lazily after
+ * mutations. Callers should treat the returned Map as read-only.
+ */
+export function getTranslationKeyIndex(): Map<string, SearchIndexEntry[]> {
+	if (translationKeyIndex) return translationKeyIndex
+	const map = new Map<string, SearchIndexEntry[]>()
+	for (const entry of textSearchIndex) {
+		if (!entry.translationKey) continue
+		const existing = map.get(entry.translationKey)
+		if (existing) existing.push(entry)
+		else map.set(entry.translationKey, [entry])
+	}
+	translationKeyIndex = map
+	return map
 }
 
 export function addToImageSearchIndex(entry: ImageIndexEntry): void {
@@ -102,6 +123,7 @@ export function clearDirtyFiles(): void {
 export function removeFileFromIndexes(relFile: string): void {
 	filterInPlace(textSearchIndex, (e) => e.file !== relFile)
 	filterInPlace(imageSearchIndex, (e) => e.file !== relFile)
+	translationKeyIndex = null
 }
 
 /** Remove non-matching elements in-place (single pass, no per-element splice). */
@@ -132,4 +154,5 @@ export function clearSourceFinderCache(): void {
 	imageSearchIndex.length = 0
 	searchIndexInitialized = false
 	collectionTextIndex = null
+	translationKeyIndex = null
 }

package/src/source-finder/search-index.ts

@@ -15,6 +15,7 @@ import {
 	getImageSearchIndex,
 	getMarkdownFileCache,
 	getTextSearchIndex,
+	getTranslationKeyIndex,
 	isSearchIndexInitialized,
 	removeFileFromIndexes,
 	setCollectionTextIndex,
@@ -127,6 +128,10 @@ async function doInitializeSearchIndex(): Promise<void> {
 	// Index image-like values from content collection data files (JSON/YAML)
 	await indexContentCollectionImages()
 
+	// Index text values from translation dictionary files (JSON) under i18n/locales folders.
+	// Enables lookups for `{t(locale, 'key')}`-rendered content whose text lives in JSON.
+	await indexTranslationFiles()
+
 	setSearchIndexInitialized(true)
 }
 
@@ -192,6 +197,9 @@ async function doReindexDirtyFiles(): Promise<void> {
 				const content = await fs.readFile(absPath, 'utf-8')
 				if (absPath.endsWith('.json')) {
 					indexJsonImages(content, relFile)
+					if (isTranslationFilePath(absPath)) {
+						indexJsonTextValues(content, relFile)
+					}
 				} else if (absPath.endsWith('.yaml') || absPath.endsWith('.yml')) {
 					indexYamlImages(content, relFile)
 				} else if (absPath.endsWith('.md') || absPath.endsWith('.mdx')) {
@@ -743,19 +751,269 @@ function indexYamlLikeLines(lines: string[], relFile: string, lineOffset: number
 }
 
 // ============================================================================
-// Index Lookup
+// Translation Dictionary Indexing (i18n JSON files)
 // ============================================================================
 
+/** Directory names conventionally used for translation dictionaries */
+const I18N_DIR_NAMES = new Set(['i18n', 'locales', 'locale', 'translations', 'dictionaries'])
+
+/** Tag marker for entries that have no single originating template tag */
+const TRANSLATION_TAG_MARKER = '*'
+
 /**
- * Fast text lookup using pre-built index
+ * Return true if `absPath` lives under a directory commonly used for
+ * translation dictionaries (i18n, locales, translations, dictionaries).
  */
-export function findInTextIndex(textContent: string, tag: string): SourceLocation | undefined {
-	const normalizedSearch = normalizeText(textContent)
+export function isTranslationFilePath(absPath: string): boolean {
+	if (!absPath.endsWith('.json')) return false
+	const segments = absPath.split(path.sep)
+	return segments.some((segment) => I18N_DIR_NAMES.has(segment.toLowerCase()))
+}
+
+/**
+ * Index text string values from JSON dictionaries under `src/i18n`, `src/locales`, etc.
+ * These cover templates that render strings through helpers like `{t(locale, 'key')}` —
+ * the rendered text lives in a JSON file rather than the template itself, so without
+ * this index the source finder has no way to associate the two.
+ */
+async function indexTranslationFiles(): Promise<void> {
+	const srcDir = path.join(getProjectRoot(), 'src')
+	const translationFiles: string[] = []
+	await collectTranslationFiles(srcDir, translationFiles)
+
+	await Promise.all(translationFiles.map(async (filePath) => {
+		try {
+			const content = await fs.readFile(filePath, 'utf-8')
+			const relFile = path.relative(getProjectRoot(), filePath)
+			indexJsonTextValues(content, relFile)
+		} catch {
+			// Skip unreadable files
+		}
+	}))
+}
+
+/**
+ * Walk `dir` and push any .json files that live inside a conventional i18n folder
+ * (at any depth) into `results`.
+ */
+async function collectTranslationFiles(dir: string, results: string[]): Promise<void> {
+	try {
+		const entries = await fs.readdir(dir, { withFileTypes: true })
+		await Promise.all(entries.map(async (entry) => {
+			const fullPath = path.join(dir, entry.name)
+			if (entry.isDirectory()) {
+				if (I18N_DIR_NAMES.has(entry.name.toLowerCase())) {
+					await collectJsonFilesRecursive(fullPath, results)
+				} else if (entry.name !== 'node_modules' && !entry.name.startsWith('.')) {
+					await collectTranslationFiles(fullPath, results)
+				}
+			}
+		}))
+	} catch {
+		// Directory doesn't exist
+	}
+}
+
+async function collectJsonFilesRecursive(dir: string, results: string[]): Promise<void> {
+	try {
+		const entries = await fs.readdir(dir, { withFileTypes: true })
+		await Promise.all(entries.map(async (entry) => {
+			const fullPath = path.join(dir, entry.name)
+			if (entry.isDirectory()) {
+				await collectJsonFilesRecursive(fullPath, results)
+			} else if (entry.isFile() && entry.name.endsWith('.json')) {
+				results.push(fullPath)
+			}
+		}))
+	} catch {
+		// Directory doesn't exist
+	}
+}
+
+/** JSON escape sequences that decode to a single character */
+const JSON_ESCAPE_MAP: Record<string, string> = {
+	'\\"': '"',
+	'\\\\': '\\',
+	'\\/': '/',
+	'\\n': '\n',
+	'\\r': '\r',
+	'\\t': '\t',
+	'\\b': '\b',
+	'\\f': '\f',
+}
+
+function unescapeJsonString(raw: string): string {
+	return raw.replace(/\\["\\/nrtbf]|\\u[0-9a-fA-F]{4}/g, (match) => {
+		if (match.startsWith('\\u')) {
+			return String.fromCharCode(parseInt(match.slice(2), 16))
+		}
+		return JSON_ESCAPE_MAP[match] ?? match
+	})
+}
+
+/**
+ * Find a template element with the given tag whose descendant expression
+ * references the given string literal (e.g. a translation key passed to
+ * `t(locale, 'nav.key')` or an object lookup like `cs['nav.key']`).
+ *
+ * Used to recover the template source location for an element whose rendered
+ * text came from a translation dictionary — class/attribute edits need to
+ * point at the template even when text edits point at the JSON.
+ */
+export async function findTemplateElementUsingStringLiteral(
+	stringLiteral: string,
+	tag: string,
+): Promise<{ file: string; line: number; lines: string[] } | undefined> {
+	const srcDir = path.join(getProjectRoot(), 'src')
+	const searchDirs = [
+		path.join(srcDir, 'components'),
+		path.join(srcDir, 'layouts'),
+		path.join(srcDir, 'pages'),
+	]
+
+	for (const dir of searchDirs) {
+		const result = await searchDirForStringLiteral(dir, stringLiteral, tag)
+		if (result) return result
+	}
+	return undefined
+}
+
+async function searchDirForStringLiteral(
+	dir: string,
+	stringLiteral: string,
+	tag: string,
+): Promise<{ file: string; line: number; lines: string[] } | undefined> {
+	try {
+		const entries = await fs.readdir(dir, { withFileTypes: true })
+		for (const entry of entries) {
+			const fullPath = path.join(dir, entry.name)
+			if (entry.isDirectory()) {
+				const result = await searchDirForStringLiteral(fullPath, stringLiteral, tag)
+				if (result) return result
+			} else if (entry.isFile() && entry.name.endsWith('.astro')) {
+				const cached = await getCachedParsedFile(fullPath)
+				if (!cached) continue
+				const line = findElementLineUsingStringLiteral(cached.ast, stringLiteral, tag)
+				if (line !== undefined) {
+					return {
+						file: path.relative(getProjectRoot(), fullPath),
+						line,
+						lines: cached.lines,
+					}
+				}
+			}
+		}
+	} catch {
+		// Directory doesn't exist
+	}
+	return undefined
+}
+
+function findElementLineUsingStringLiteral(
+	ast: AstroNode,
+	stringLiteral: string,
+	tag: string,
+): number | undefined {
 	const tagLower = tag.toLowerCase()
-	const index = getTextSearchIndex()
+	const quotedPatterns = [`'${stringLiteral}'`, `"${stringLiteral}"`, `\`${stringLiteral}\``]
+
+	let result: number | undefined
+
+	function visit(node: AstroNode) {
+		if (result !== undefined) return
+		if ((node.type === 'element' || node.type === 'component') && node.name.toLowerCase() === tagLower) {
+			const elemNode = node as ElementNode | ComponentNode
+			const exprText = getExpressionText(elemNode)
+			if (exprText && quotedPatterns.some((p) => exprText.includes(p))) {
+				result = elemNode.position?.start.line
+				return
+			}
+		}
+		if ('children' in node && Array.isArray(node.children)) {
+			for (const child of node.children) {
+				if (result !== undefined) break
+				visit(child)
+			}
+		}
+	}
+
+	visit(ast)
+	return result
+}
+
+/** Collect the combined text of every expression descendant of `node`. */
+function getExpressionText(node: AstroNode): string {
+	let text = ''
+	function visit(n: AstroNode) {
+		if (n.type === 'expression') {
+			text += getTextContent(n)
+			return
+		}
+		if ('children' in n && Array.isArray(n.children)) {
+			for (const child of n.children) visit(child)
+		}
+	}
+	visit(node)
+	return text
+}
+
+/**
+ * Extract the JSON dictionary key from a translation-file snippet.
+ * Expects a line shaped like `  "nav.whatsHappening": "Co se děje v EduArt?",`
+ * and returns `"nav.whatsHappening"`.
+ */
+export function extractTranslationKeyFromSnippet(snippet: string): string | undefined {
+	const match = snippet.match(/^\s*"((?:[^"\\]|\\.)*)"\s*:/)
+	return match?.[1]
+}
 
-	// Helper to build SourceLocation from a text index entry
-	const toLocation = (entry: SearchIndexEntry): SourceLocation => ({
+/**
+ * Extract all string key/value pairs from a JSON file and add each one to the
+ * text search index with a wildcard tag. The dictionary key is retained on
+ * each entry so a template expression like `{t(locale, 'nav.prague4')}` can
+ * resolve directly to the JSON line via the literal key. Non-user-facing
+ * values (paths, URLs, image assets, single characters) are skipped.
+ */
+export function indexJsonTextValues(content: string, relFile: string): void {
+	const lines = content.split('\n')
+	// Match `"key": "value"` pairs on a single line, handling backslash escapes.
+	// Nested objects aren't matched (their `"key":` is followed by `{`, not `"`).
+	const pattern = /"((?:[^"\\]|\\.)*)"\s*:\s*"((?:[^"\\]|\\.)*)"/g
+	for (let i = 0; i < lines.length; i++) {
+		const line = lines[i]!
+		pattern.lastIndex = 0
+		let match: RegExpExecArray | null
+		while ((match = pattern.exec(line)) !== null) {
+			const key = unescapeJsonString(match[1]!)
+			const value = unescapeJsonString(match[2]!)
+			if (!value) continue
+			if (IMAGE_EXTENSIONS.test(value)) continue
+			if (value.startsWith('/') || value.startsWith('./') || value.startsWith('../')) continue
+			if (/^https?:\/\//.test(value)) continue
+
+			const normalized = normalizeText(value)
+			if (normalized.length < 2) continue
+
+			addToTextSearchIndex({
+				file: relFile,
+				line: i + 1,
+				snippet: line,
+				type: 'static',
+				normalizedText: normalized,
+				tag: TRANSLATION_TAG_MARKER,
+				translationKey: key,
+			})
+		}
+	}
+}
+
+// ============================================================================
+// Index Lookup
+// ============================================================================
+
+/** Helper to build SourceLocation from a text index entry */
+function textEntryToLocation(entry: SearchIndexEntry): SourceLocation {
+	return {
 		file: entry.file,
 		line: entry.line,
 		snippet: entry.snippet,
@@ -763,17 +1021,50 @@ export function findInTextIndex(textContent: string, tag: string): SourceLocatio
 		type: entry.type,
 		variableName: entry.variableName,
 		definitionLine: entry.definitionLine,
-	})
+	}
+}
+
+/**
+ * Look up an i18n dictionary entry by its literal key (e.g. `nav.prague4`),
+ * preferring the match whose value equals `normalizedText` so the right locale
+ * wins when multiple dictionaries share the same key.
+ */
+export function findTranslationByKeyAndText(key: string, normalizedText: string): SourceLocation | undefined {
+	const entries = getTranslationKeyIndex().get(key)
+	if (!entries) return undefined
+	let fallback: SourceLocation | undefined
+	for (const entry of entries) {
+		if (entry.normalizedText === normalizedText) return textEntryToLocation(entry)
+		fallback ??= textEntryToLocation(entry)
+	}
+	return fallback
+}
+
+/**
+ * Fast text lookup using pre-built index
+ */
+export function findInTextIndex(textContent: string, tag: string): SourceLocation | undefined {
+	const normalizedSearch = normalizeText(textContent)
+	const tagLower = tag.toLowerCase()
+	const index = getTextSearchIndex()
 
-	// First try exact match with same tag — prefer collection data files
+	// Single pass for exact matches: collect the best same-tag template hit
+	// *and* any i18n dictionary hit at once. A JSON dictionary entry is an
+	// authoritative translatable signal, so it beats a non-collection
+	// template match (which is often a coincidental same-text element).
 	let bestMatch: SourceLocation | undefined
+	let translationHit: SourceLocation | undefined
 	for (const entry of index) {
-		if (entry.tag === tagLower && entry.normalizedText === normalizedSearch) {
-			const result = toLocation(entry)
+		if (entry.normalizedText !== normalizedSearch) continue
+		if (entry.tag === tagLower) {
+			const result = textEntryToLocation(entry)
 			if (isCollectionFile(entry.file)) return result
 			bestMatch ??= result
+		} else if (entry.tag === TRANSLATION_TAG_MARKER) {
+			translationHit ??= textEntryToLocation(entry)
 		}
 	}
+	if (translationHit) return translationHit
 	if (bestMatch) return bestMatch
 
 	// Then try partial match for longer text — prefer collection data files
@@ -781,7 +1072,7 @@ export function findInTextIndex(textContent: string, tag: string): SourceLocatio
 		const textPreview = normalizedSearch.slice(0, Math.min(30, normalizedSearch.length))
 		for (const entry of index) {
 			if (entry.tag === tagLower && entry.normalizedText.includes(textPreview)) {
-				const result = toLocation(entry)
+				const result = textEntryToLocation(entry)
 				if (isCollectionFile(entry.file)) return result
 				bestMatch ??= result
 			}
@@ -792,7 +1083,7 @@ export function findInTextIndex(textContent: string, tag: string): SourceLocatio
 	// Try any tag match — prefer collection data files
 	for (const entry of index) {
 		if (entry.normalizedText === normalizedSearch) {
-			const result = toLocation(entry)
+			const result = textEntryToLocation(entry)
 			if (isCollectionFile(entry.file)) return result
 			bestMatch ??= result
 		}