@nuasite/cms 0.29.0 → 0.31.0

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
 		}

package/src/source-finder/snippet-utils.ts

@@ -16,7 +16,13 @@ import {
 } from './collection-finder'
 import { findAttributeSourceLocation, searchForExpressionProp, searchForPropInParents } from './cross-file-tracker'
 import { findImageElementNearLine, findImageSourceLocation } from './image-finder'
-import { initializeSearchIndex } from './search-index'
+import {
+	extractTranslationKeyFromSnippet,
+	findInTextIndex,
+	findTemplateElementUsingStringLiteral,
+	findTranslationByKeyAndText,
+	initializeSearchIndex,
+} from './search-index'
 import type { CachedParsedFile, ImageMatch, SourceLocation } from './types'
 
 // ============================================================================
@@ -287,7 +293,18 @@ export async function updateAttributeSources(
 				}
 			}
 
-			// Couldn't resolve - return without source info
+			// Prefer a template-level miss over falling back to the entry
+			// sourcePath, which may be an unrelated file (e.g. an i18n JSON).
+			if (sourceFilePath) {
+				const attrLine = findAttributeLineInSnippet(attrName, snippetLines, openingTagStartLine)
+				return [attrName, {
+					value,
+					sourcePath: sourceFilePath,
+					sourceLine: attrLine,
+					sourceSnippet: (attrLine && sourceLines) ? sourceLines[attrLine - 1] || '' : undefined,
+				}] as const
+			}
+
 			return [attrName, { value }] as const
 		}
 
@@ -466,6 +483,138 @@ export async function extractSourceSnippet(
 // Manifest Enhancement
 // ============================================================================
 
+/**
+ * Build the manifest entry produced when rendered text resolved to a
+ * translation-dictionary file (e.g. `src/i18n/cs.json`).
+ *
+ * Text edits target the JSON entry (`sourcePath`/`sourceLine`/`sourceSnippet`),
+ * while `attributes.*` and `colorClasses.*` keep pointing at the template's
+ * `<tag>` — those edits belong on the element, not the dictionary.
+ */
+async function applyTranslationSource(
+	entry: ManifestEntry,
+	indexHit: SourceLocation,
+	attributes: ManifestEntry['attributes'],
+	colorClasses: ManifestEntry['colorClasses'],
+): Promise<ManifestEntry> {
+	const hitSnippet = indexHit.snippet ?? ''
+	let resolvedAttributes = attributes
+	let resolvedColorClasses = colorClasses
+
+	// When the hit comes from a JSON dictionary, look up the template element
+	// that references the translation key so attr/class edits can target it.
+	const needsTemplateLookup = indexHit.file.endsWith('.json')
+		&& ((attributes && !hasAnySourcePath(attributes)) || (colorClasses && !hasAnySourcePath(colorClasses)))
+
+	if (needsTemplateLookup && entry.tag) {
+		const translationKey = extractTranslationKeyFromSnippet(hitSnippet)
+		if (translationKey) {
+			const templateLoc = await findTemplateElementUsingStringLiteral(translationKey, entry.tag)
+			if (templateLoc) {
+				const openingTagInfo = extractOpeningTagWithLine(templateLoc.lines, templateLoc.line - 1, entry.tag)
+				if (openingTagInfo) {
+					const openingStartLine = openingTagInfo.startLine + 1
+					if (attributes) {
+						resolvedAttributes = await updateAttributeSources(
+							openingTagInfo.snippet,
+							attributes,
+							templateLoc.file,
+							openingStartLine,
+							templateLoc.lines,
+						)
+					}
+					if (colorClasses) {
+						resolvedColorClasses = updateColorClassSources(
+							openingTagInfo.snippet,
+							colorClasses,
+							templateLoc.file,
+							openingStartLine,
+							templateLoc.lines,
+						)
+					}
+				}
+			}
+		}
+	}
+
+	return {
+		...entry,
+		sourcePath: indexHit.file,
+		sourceLine: indexHit.line,
+		sourceSnippet: hitSnippet,
+		variableName: indexHit.variableName,
+		allowStyling: false,
+		attributes: resolvedAttributes,
+		colorClasses: resolvedColorClasses,
+		sourceHash: generateSourceHash(hitSnippet || entry.text || ''),
+	}
+}
+
+/** True when any of the attribute/colorClass values already carries a sourcePath. */
+function hasAnySourcePath(bag: Record<string, { sourcePath?: string }>): boolean {
+	for (const key in bag) {
+		if (bag[key]?.sourcePath) return true
+	}
+	return false
+}
+
+/**
+ * Extract string literals from every `{…}` expression in an Astro snippet.
+ * Intended to recover translation keys from patterns like:
+ *   {t(locale, 'nav.prague4')}
+ *   {cs['nav.prague4']}
+ *   {dict.nav['prague4']}
+ *
+ * Nested braces inside template strings can fool the naive brace tracker but
+ * not in ways that matter here — we only care about literal string arguments.
+ */
+export function extractStringLiteralsFromExpressions(snippet: string): string[] {
+	const literals: string[] = []
+	let depth = 0
+	let exprStart = -1
+	for (let i = 0; i < snippet.length; i++) {
+		const ch = snippet[i]
+		if (ch === '{') {
+			if (depth === 0) exprStart = i + 1
+			depth++
+		} else if (ch === '}') {
+			depth--
+			if (depth === 0 && exprStart >= 0) {
+				const expr = snippet.slice(exprStart, i)
+				const pattern = /'((?:[^'\\]|\\.)+)'|"((?:[^"\\]|\\.)+)"|`((?:[^`\\$]|\\.)+)`/g
+				let m: RegExpExecArray | null
+				while ((m = pattern.exec(expr)) !== null) {
+					const s = m[1] ?? m[2] ?? m[3]
+					if (s) literals.push(s)
+				}
+				exprStart = -1
+			}
+		}
+	}
+	return literals
+}
+
+/**
+ * When the template expression references a literal translation key (e.g.
+ * `{t(locale, 'nav.prague4')}`), look the key up directly in the i18n index
+ * and return the JSON location. Falls back to value-based heuristics only via
+ * the caller's other branches — this path is only taken when the key match
+ * is unambiguous, which is the authoritative signal from the template.
+ */
+function resolveTranslationKeyFromSnippet(
+	snippet: string,
+	entryText: string,
+): SourceLocation | undefined {
+	const literals = extractStringLiteralsFromExpressions(snippet)
+	if (literals.length === 0) return undefined
+	const normalizedText = normalizeText(entryText)
+	for (const literal of literals) {
+		const hit = findTranslationByKeyAndText(literal, normalizedText)
+		if (hit) return hit
+	}
+	return undefined
+}
+
 /**
  * Enhance manifest entries with actual source snippets from source files.
  * This reads the source files and extracts the innerHTML at the specified locations.
@@ -674,6 +823,18 @@ export async function enhanceManifestWithSourceSnippets(
 			}
 		}
 
+		// Missing source info — try the text search index as a last resort.
+		// Templates that render text through helpers (e.g. `{t(locale, 'key')}`)
+		// don't get resolved to the originating i18n JSON in the marking phase,
+		// so the entry arrives here without a sourcePath/sourceLine.
+		if (!entry.sourceSnippet && entry.text?.trim() && entry.tag && (!entry.sourcePath || !entry.sourceLine)) {
+			const indexHit = findInTextIndex(entry.text.trim(), entry.tag)
+			if (indexHit) {
+				const resolved = await applyTranslationSource(entry, indexHit, entry.attributes, entry.colorClasses)
+				return [id, resolved] as const
+			}
+		}
+
 		// Skip if already has sourceSnippet or missing source info
 		if (entry.sourceSnippet || !entry.sourcePath || !entry.sourceLine || !entry.tag) {
 			return [id, entry] as const
@@ -828,6 +989,14 @@ export async function enhanceManifestWithSourceSnippets(
 						}
 					}
 
+					// An explicit `{t(locale, 'key')}`-style reference is a stronger
+					// signal than value-based collection/text-index matches below.
+					const i18nKeySource = resolveTranslationKeyFromSnippet(sourceSnippet, trimmedText)
+					if (i18nKeySource) {
+						const resolved = await applyTranslationSource(entry, i18nKeySource, attributes, colorClasses)
+						return [id, resolved] as const
+					}
+
 					// Search collection frontmatter — text rendered on listing pages
 					// from collection entries (e.g. {post.data.title}) won't be found
 					// through AST or prop lookups since the value lives in a .md file
@@ -844,6 +1013,14 @@ export async function enhanceManifestWithSourceSnippets(
 							] as const
 						}
 					}
+
+					// Last resort — consult the text index (covers i18n JSON dictionaries
+					// and any other indexed text that shares no tag with the rendered element).
+					const indexHit = findInTextIndex(trimmedText, entry.tag)
+					if (indexHit && indexHit.file !== entry.sourcePath) {
+						const resolved = await applyTranslationSource(entry, indexHit, attributes, colorClasses)
+						return [id, resolved] as const
+					}
 				}
 
 				// Original static content path