i18n-lens-language-server 0.13.0 → 0.15.0

package/README.md

@@ -10,9 +10,11 @@ Zed extension plus Language Server for Vue, TypeScript, TSX, JavaScript and JSX.
 - Diagnostics: report missing keys, missing locale entries, mismatched interpolation params, and (on locale files) keys whose params differ across languages
 - Optional raw-text diagnostics: flag likely untranslated Vue/HTML template text and selected user-facing attributes
 - Quick fixes: add missing / remove unused interpolation params, and create missing keys in unambiguous JSON locale targets using versioned edits
+- Extract / Inline code actions: explicitly extract Vue/HTML template text into a new locale key, or replace a supported translation call with one locale's stored text
 - Completion: suggest existing i18n keys with default locale text only inside supported i18n key positions
 - Definition: jump from a source key to its locale definition; when several locales define the key, pick which language file to open
 - References: from a locale definition or source usage, find references within the same project/package context, including open source files not yet saved to disk
+- Recursive locale directories: nested JSON, TS, and JS files map to dot-separated namespaces, with `index` files contributing to their parent namespace
 
 ## Installation
 
@@ -105,9 +107,10 @@ The natural-language heuristics are inspired by i18n Ally's raw-string detection
 
 Comments, `script`/`style`, Vue custom blocks, interpolations (`{{ ... }}`), translation-component subtrees (`i18n-t`/`I18nT`, legacy `i18n`, `Trans`) and `v-t` elements are excluded. `code`/`pre`, `v-pre`, `v-html`, `v-text` and `translate="no"` subtrees are also skipped; use `translate="no"` to mark intentionally untranslated content. Vue templates using `src` or a non-HTML `lang` (such as Pug) are not inspected.
 
-There is no Babel/JavaScript/TypeScript/JSX string analysis, workspace-wide scan, automatic extraction or raw-text quick fix. Only open Vue/HTML buffers receive these warnings. The parser is tolerant of incomplete markup, not a full Vue compiler; complex or malformed templates can be missed. Existing key/parameter diagnostics and quick fixes are unchanged.
+Raw-text diagnostics do not analyze JavaScript/TypeScript/JSX strings, scan the whole workspace, or extract text automatically. Only open Vue/HTML buffers receive these warnings. Explicit Extract actions are available separately from the editor's code-action menu, even when these warnings are disabled (see below). The parser is tolerant of incomplete markup, not a full Vue compiler; complex or malformed templates can be missed. Existing key/parameter diagnostics and quick fixes are unchanged.
 
 For local development, HTML registration in `extension.toml` requires reinstalling the dev extension in Zed, then running `scripts/deploy-local.ps1` again and restarting the language server. Updating only the server does not register HTML buffers.
+
 ## Creating missing keys safely
 
 The missing-key quick fix supports a single JSON file per locale and directory layouts such as `locales/en/common.json`. For `t('common.submit')`, it inserts `submit` into `common.json`, without duplicating the `common.` prefix. `index.json` has no file-stem prefix.
@@ -120,6 +123,53 @@ The missing-key quick fix supports a single JSON file per locale and directory l
 
 Recognition skips calls inside comments and ordinary strings, and does not treat a concatenated key such as `t('prefix.' + name)` as a static key. Vue directive expressions, JSX expressions, and calls inside template-literal interpolations remain supported. Recognition is lexical, not full framework binding or scope analysis.
 
+## Extract and Inline code actions
+
+These actions **rewrite source code**; they are separate from the read-only inline translation hints above. Open the editor's code-action menu at the text or call you want to change and review the proposed edits before applying them. Both actions require client support for `workspace.workspaceEdit.documentChanges`.
+
+### Extract template text
+
+In a Vue HTML `<template>` or an HTML document, place the caret in a supported static text fragment, or select a range that fully contains it, and choose **Extract to i18n key "…"**. A selection can offer separate actions for several fragments; it does not extract arbitrary substrings or apply a batch conversion. `rawTextDiagnostics` can remain disabled.
+
+For example, in `Home.vue` with no existing source keys:
+
+```html
+<!-- Before -->
+<button>Save changes</button>
+<!-- After -->
+<button>{{ $t('Home.save_changes') }}</button>
+```
+
+Extract also adds `"Home": { "save_changes": "Save changes" }` to the selected locale's JSON, preserving unrelated entries. It writes **only one locale**: the current project/package's `defaultLocale`, including locale-name normalization and language aliases, or the first loaded locale if none matches. No loaded locales means no Extract action. It does not create a missing default language or populate every translation.
+
+- Supported attributes are `title`, `alt`, `placeholder`, `label`, and `aria-label`, including whole, simple quoted literals in bound attributes. Static attributes become bindings such as `:title="$t('Home.save_changes')"`. HTML files receive the same **Vue-style syntax**; this is not a framework-neutral HTML rewrite.
+- Key prefixes come from nearby existing template keys, then a file-wide common parent prefix, then the filename stem. The suffix uses a short ASCII text slug or a deterministic hash for text without ASCII words. Every extraction allocates a new key rather than reusing identical text; conflicts in the selected locale can change the prefix or add a numeric suffix.
+- Extract shares the template exclusions described under raw-text diagnostics. It does not extract ordinary JS/TS/JSX strings, evaluate dynamic expressions, or turn interpolated text into parameterized messages. Fragments containing entities or `&`, `<`, `>`, `{`, or `}` are skipped, and repeated whitespace in the stored value is collapsed to a single space.
+- Locale edits follow the JSON target rules in **Creating missing keys safely** above. Invalid JSON, duplicate properties, ambiguous layouts, conflicting paths, or TS/JS targets suppress the action. New namespace files additionally require client support for `create`, an established sibling-locale JSON layout, and an existing parent directory; Extract does not create directories.
+
+### Inline a translation call
+
+Place the caret or a selection inside a static-key call such as `t('Home.save_changes')` and choose an **Inline** action for the desired locale. One action is offered per loaded locale that defines the key. It changes only the source and leaves the locale entry intact.
+
+Inline supports `t`, `$t`, `tc`, `$tc`, `i18n.t`, and `i18n.tc` calls with **only the key argument**, in Vue/HTML templates and JS/TS/JSX/TSX source. Passing any additional argument, even `{}`, suppresses the action. Other recognized forms such as `formatMessage`, `v-t`, or translation components are not supported by Inline.
+
+Calls are located with real parsers: Vue's template compiler (`@vue/compiler-dom`) for `.vue` and HTML documents, and Babel for JS/TS/JSX/TSX source and `<script>` blocks. Only a genuine call expression is rewritten:
+
+- **JS/TS/JSX/TSX and `<script>`**: the call becomes a JS string literal; JSX children and attributes keep braces, e.g. `title={'Save'}`. Look-alike text such as `<p>t('key')</p>` in JSX is not a call and is left alone.
+- **Template text**: the call becomes HTML-escaped text; a whole `{{ t('key') }}` becomes plain text unless the translation contains braces, in which case a JS string stays inside the interpolation.
+- **Attributes**: a whole `:title="t('key')"` / `v-bind:title` binding becomes `title="…"`; a static `title="$t('key')"` keeps its attribute.
+- HTML `<script type="text/x-template">` contents are handled as a template; other non-JavaScript script types are skipped.
+
+When the context cannot be proven safe, no action is offered: partial expressions such as `:title="t('key') + suffix"`, bindings with modifiers or dynamic arguments, other directives, unclosed tags or interpolations while typing, CDATA, `<style>` and custom SFC blocks, and `<template lang="pug">` or similar.
+
+Inline is intended to insert the locale's **stored text**, not a resolved runtime message: `{name}`, plural forms, and linked messages are not evaluated. A call without extra arguments can still rely on runtime behavior, so check that replacing it with literal text is appropriate. Vue's own whitespace condensing still applies to text produced from a whole interpolation.
+
+### Editing and failure boundaries
+
+Extract returns the source and locale changes in one LSP `WorkspaceEdit`; the editor applies them. Open buffers use their unsaved text and document version. Closed files have no version check against external changes. **Atomic application and rollback after permission or other client-side failures are not guaranteed or fully tested**; inspect both files if an edit fails. Failure while generating Extract or Inline actions is logged without discarding unrelated quick fixes.
+
+Rename is not included in this release; it remains tracked in [issue #2](https://github.com/yizixu/zed-i18n-lens/issues/2).
+
 ## Project configuration
 
 I18n Lens supports two configuration sources:
@@ -189,7 +239,7 @@ Supported options:
 
 | Option | Type | Default | Description |
 |---|---|---|---|
-| `defaultLocale` | string | `zh-CN` | Locale used for completion details and inline translation hints. Supports exact names such as `en-US`, case-insensitive matching, `_`/`-` normalization, and language aliases such as `en` matching `en-US`. |
+| `defaultLocale` | string | `zh-CN` | Preferred locale for Extract, completion details, and inline translation hints. Supports exact names such as `en-US`, case-insensitive matching, `_`/`-` normalization, and language aliases such as `en` matching `en-US`. |
 | `localeDirs` | string[] | `src/locales`, `src/i18n`, `locales`, `i18n` | Workspace-relative directories to scan for locale files. In package configs, paths are relative to that package root. |
 | `inlayHints.enabled` | boolean | `true` | Enables or disables inline translation hints from this language server. Hover, completion, definition, diagnostics, and quick fixes can still work when inline hints are disabled. |
 | `inlayHints.maxLength` | number | `24` | Maximum inline hint label length before truncation. Hover still shows the full text. |
@@ -220,6 +270,19 @@ src/locales/ja-JP/common.json
 
 A file named `common.json` contributes keys with the `common.` prefix. A file named `index.json` contributes keys without an `index.` prefix.
 
+Locale directories are scanned recursively. Subdirectories contribute to the namespace:
+
+```text
+src/locales/en-US/system/user.json       -> system.user.*
+src/locales/en-US/system/index.json      -> system.*
+src/locales/en-US/system/forms/fields.ts -> system.forms.fields.*
+src/locales/en-US/index/index.json       -> index.*
+```
+
+Nested JSON, TS, and JS locale files support translation previews, definition, references, and unsaved buffer updates. Adding files in nested directories refreshes translations automatically. Missing-key quick fixes retain the existing namespace directory layout when the target is unambiguous and its parent directory exists.
+
+If `localeDirs` overlap, an explicitly configured nested root is excluded from its ancestor's recursive scan, regardless of configuration order or nesting depth. For example, with `["locales", "locales/modules/features"]`, `locales/modules/features/en/user.json` belongs to locale `en` with keys `user.*`, not locale `modules`. Intermediate directories without locale files are watched for new files but do not count as locales. Empty locale files still count as locales and report missing keys.
+
 Top-level TS/JS modules such as `locales/en.ts` are also loaded, without adding an `en.` prefix. Directory modules such as `locales/en/common.ts` retain the `common.` prefix; `index.ts` has no file-stem prefix. Modules are parsed statically, never executed. Their definitions support Find References and cross-language parameter diagnostics, not source-code completions or inlay hints. TS/JS key positioning remains best-effort rather than a full syntax-tree analysis.
 
 ## Monorepo workspaces

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "i18n-lens-language-server",
-  "version": "0.13.0",
+  "version": "0.15.0",
   "type": "module",
   "description": "Language server for configurable i18n inlay hints, hover, completion, diagnostics, definition, and references in Vue/TS/TSX/JS.",
   "license": "MIT",
@@ -20,6 +20,9 @@
     "start": "node server/index.js"
   },
   "dependencies": {
+    "@babel/parser": "^7.29.13",
+    "@vue/compiler-dom": "^3.5.45",
+    "entities": "^7.0.1",
     "htmlparser2": "^10.1.0",
     "vscode-languageserver": "^9.0.1",
     "vscode-languageserver-textdocument": "^1.0.12"

package/server/core.js

@@ -1,4 +1,7 @@
 import { parseDocument, DomUtils } from 'htmlparser2';
+import { parse as parseScript, parseExpression } from '@babel/parser';
+import { parse as parseTemplate, NodeTypes, ErrorCodes } from '@vue/compiler-dom';
+import { decodeHTML, decodeHTMLAttribute } from 'entities';
 
 export const DEFAULT_CONFIG = Object.freeze({
   defaultLocale: 'zh-CN',
@@ -67,11 +70,13 @@ function templateInterpolations(text, excludedRanges) {
 
 // Intentionally conservative: natural-language candidates, not arbitrary strings
 // or a dictionary. Single title-cased labels and non-Latin text are useful too.
-export function isLikelyUserFacingText(value) {
+export function isLikelyUserFacingText(value, loose = false) {
   const text = value.trim();
   if (!/\p{L}/u.test(text)) return false;
   if (/^(?:https?:|mailto:|www\.|[/#])|\S+@\S+\.\S+/i.test(text)) return false;
   if (/^[\w.-]+(?:[/\\][\w.-]+)+$|^[\w-]+(?:\.[\w-]+)+$/.test(text)) return false;
+  // Extraction is user-triggered: any remaining text with letters qualifies.
+  if (loose) return true;
   if (/^[A-Z\d_-]+$|^[a-z\d]+(?:[_-][a-z\d]+)+$|^[a-z]+(?:[A-Z][a-z\d]*)+$/.test(text)) return false;
   if (/[^\p{Script=Latin}\p{N}\p{P}\p{S}\p{Z}\p{M}\s]/u.test(text)) return true;
   return (/\s/.test(text) && (text.match(/\p{L}[\p{L}\p{M}]*/gu) || []).length >= 2)
@@ -83,7 +88,7 @@ export function isLikelyUserFacingText(value) {
  * UTF-16, matching LSP positions. Mask Vue expressions before HTML parsing so
  * comparisons and string literals inside {{ ... }} cannot become markup.
  */
-export function getRawTextDiagnostics(text, language, enabled = false) {
+export function getRawTextDiagnostics(text, language, enabled = false, loose = false) {
   if (!enabled || !['vue', 'html'].includes(language)) return [];
   const parserOptions = { withStartIndices: true, withEndIndices: true, recognizeSelfClosing: true };
   // An unmatched "{{" in a comment, script, style or custom SFC block must
@@ -107,10 +112,12 @@ export function getRawTextDiagnostics(text, language, enabled = false) {
   }).join('') + text.slice(previous);
   const document = parseDocument(masked, parserOptions);
   const diagnostics = [];
+  const calls = extractI18nKeys(text);
   function report(raw, start, value = raw) {
     const leading = raw.length - raw.trimStart().length;
     const trailing = raw.trimEnd().length;
-    if (!isLikelyUserFacingText(value)) return;
+    if (calls.some((c) => c.call && c.call.start <= start + leading && start + trailing <= c.call.end)) return;
+    if (!isLikelyUserFacingText(value, loose)) return;
     diagnostics.push({
       range: makeRange(text, start + leading, start + trailing),
       severity: 2,
@@ -303,14 +310,16 @@ function offsetToPosition(text, offset) {
 function makeRange(text, start, end) {
   return { start: offsetToPosition(text, start), end: offsetToPosition(text, end) };
 }
-// Lexical mask over mixed Vue/TS/JSX text: returns the sorted ranges that are
-// NOT real code — comments, plain strings, template-literal raw text, HTML
-// comments, and ordinary (non-directive) attribute values. Vue directive
+// Lexical mask over mixed Vue/TS/JSX text: returns opaque ranges (comments,
+// plain strings, template-literal raw text, HTML comments, ordinary attribute
+// values) plus interiors of plain HTML/JSX attributes. Those interiors look
+// like `title="$t('…')"` but are static text, not real calls — extractI18nKeys
+// skips them unless includeStaticAttrCalls (Inline only). Vue directive
 // attribute values (`:x="…"`, `v-x="…"`, `@x="…"`, `#x="…"`) and `${…}`
-// interpolations inside template literals stay transparent so real
-// expressions inside them are still scanned. Best-effort lexing only — no AST.
+// interpolations stay transparent. Best-effort lexing only — no AST.
 function computeOpaqueRanges(text) {
   const ranges = [];
+  const attrValues = [];
   const stack = [{ type: 'code' }];
   const top = () => stack[stack.length - 1];
   let i = 0;
@@ -334,7 +343,11 @@ function computeOpaqueRanges(text) {
     }
     if (f.type === 'string') {
       if (ch === '\\') { i += 2; continue; }
-      if (ch === f.quote) { ranges.push({ start: f.start, end: i + 1 }); stack.pop(); }
+      if (ch === f.quote) {
+        ranges.push({ start: f.start, end: i + 1 });
+        if (f.attrValue) attrValues.push({ start: f.start + 1, end: i });
+        stack.pop();
+      }
       i++;
       continue;
     }
@@ -372,7 +385,7 @@ function computeOpaqueRanges(text) {
     if (ch === '<' && text[i + 1] === '!' && text[i + 2] === '-' && text[i + 3] === '-') { stack.push({ type: 'htmlComment', start: i }); i += 4; continue; }
     if (ch === '"' || ch === "'") {
       if (f.type === 'code' && isAttrExprQuote(text, i)) stack.push({ type: 'attrExpr', quote: ch, depth: 0 });
-      else stack.push({ type: 'string', quote: ch, start: i });
+      else stack.push({ type: 'string', quote: ch, start: i, attrValue: f.type === 'code' && isPlainAttrQuote(text, i) });
       i++;
       continue;
     }
@@ -381,19 +394,32 @@ function computeOpaqueRanges(text) {
   }
   while (stack.length > 1) {
     const f = stack.pop();
-    if (f.start !== undefined) ranges.push({ start: f.start, end: text.length });
+    if (f.start === undefined) continue;
+    ranges.push({ start: f.start, end: text.length });
+    if (f.attrValue) attrValues.push({ start: f.start + 1, end: text.length });
   }
-  return ranges;
+  ranges.sort((a, b) => a.start - b.start || a.end - b.end);
+  return { ranges, attrValues };
 }
 
 // A quote is a Vue directive attribute opener when preceded by `name=` where
 // name is `:foo`, `@foo`, `#foo`, `v-foo`, or `ns:foo` (v-on:, v-bind:, …).
-// Plain attributes (`title="…"`, JSX `attr="…"`) keep string semantics.
 function isAttrExprQuote(text, quoteOffset) {
   const before = text.slice(Math.max(0, quoteOffset - 200), quoteOffset);
   return /(?:^|[\s<"'`])(?:[:@#][\w.:[\]-]*|[\w-]+:[\w.:[\]-]*|v-[\w.:[\]-]*)\s*=\s*$/.test(before);
 }
 
+// Plain HTML/JSX attributes (`title="…"`, `alt='…'`) stay opaque as strings so
+// apostrophes in values cannot swallow later code. Lookalike t() text inside
+// them is not a real call (see extractI18nKeys includeStaticAttrCalls).
+function isPlainAttrQuote(text, quoteOffset) {
+  const before = text.slice(0, quoteOffset);
+  const lastLt = before.lastIndexOf('<');
+  const lastGt = before.lastIndexOf('>');
+  if (lastLt < 0 || lastLt < lastGt || !/^[A-Za-z]/.test(before.slice(lastLt + 1))) return false;
+  return /(?:^|[\s"'`/])[\w.:[\]-]+\s*=\s*$/.test(before.slice(-80));
+}
+
 function isOpaque(ranges, offset) {
   let lo = 0;
   let hi = ranges.length - 1;
@@ -408,10 +434,10 @@ function isOpaque(ranges, offset) {
 }
 
 
-export function extractI18nKeys(text) {
+export function extractI18nKeys(text, { includeStaticAttrCalls = false } = {}) {
   const found = [];
-  const opaque = computeOpaqueRanges(text);
-  collectFunctionCallKeys(text, found, opaque);
+  const { ranges: opaque, attrValues } = computeOpaqueRanges(text);
+  collectFunctionCallKeys(text, found, opaque, includeStaticAttrCalls ? attrValues : []);
   collectFormatMessageKeys(text, found, opaque);
   const patterns = [
     // <i18n-t keypath="key"> (Vue I18n) and <Trans i18nKey="key"> (react-i18next)
@@ -439,14 +465,15 @@ export function extractI18nKeys(text) {
   return found;
 }
 
-function collectFunctionCallKeys(text, found, opaque) {
+function collectFunctionCallKeys(text, found, opaque, attrValues = []) {
   // t/$t/tc/$tc/i18n.t/i18n.tc(...) — function calls, incl. Vue I18n plural tc
   const re = /(?:\x24tc?|\btc?|\bi18n\.tc?)\s*\(/g;
   let match;
   while ((match = re.exec(text))) {
     const parenOffset = re.lastIndex - 1;
     if (/[\w$]/.test(text[match.index - 1] || '')) continue;
-    if (isOpaque(opaque, match.index)) continue;
+    const inAttr = attrValues.some((r) => match.index >= r.start && match.index < r.end);
+    if (!inAttr && isOpaque(opaque, match.index)) continue;
     const callText = readParens(text, parenOffset);
     if (!callText) continue;
     // First arg must be exactly one string literal — dynamic keys like
@@ -459,7 +486,8 @@ function collectFunctionCallKeys(text, found, opaque) {
     const args = splitArgsWithOffsets(callText.slice(1, -1));
     const paramsEdit = getParamsEdit(args.slice(1), parenOffset + 1, parenOffset + callText.length - 1);
     const paramsObject = extractParamsObject(args.slice(1), parenOffset + 1);
-    found.push({ key, range: makeRange(text, start, end), startOffset: start, endOffset: end, providedParams: collectParamNames(args.slice(1)), paramsEdit, paramsObject });
+    found.push({ key, range: makeRange(text, start, end), startOffset: start, endOffset: end, providedParams: collectParamNames(args.slice(1)), paramsEdit, paramsObject,
+      call: { start: match.index, end: parenOffset + callText.length, argCount: args.length, quote: keyMatch[1] } });
   }
 }
 
@@ -642,25 +670,22 @@ export function collectLocaleWatchPaths(localeCache, localeDirs = []) {
 
 export function findLocaleKeyTarget(locale, key, localeTexts = {}) {
   if (!locale || !Object.prototype.hasOwnProperty.call(locale.flat || {}, key)) return undefined;
-  const files = Array.isArray(locale.files) && locale.files.length
-    ? locale.files
-    : (locale.path ? [locale.path] : []);
-  const candidates = files
-    .map((filePath) => ({ filePath, lookupKey: lookupKeyForLocaleFile(locale, filePath, key) }))
-    .sort((a, b) => Number(a.lookupKey === key) - Number(b.lookupKey === key));
-
-  for (const candidate of candidates) {
-    const text = localeTexts[candidate.filePath];
-    if (!text) continue;
-    const range = localeKeyRange(text, candidate.lookupKey, /\.json$/i.test(candidate.filePath));
-    if (range) return { filePath: candidate.filePath, position: range.start, range };
-  }
-
-  const fallback = candidates[0];
-  return fallback ? { filePath: fallback.filePath } : undefined;
+  // Namespace specificity does not determine which file won during loading.
+  const filePath = locale.keyFiles?.[key];
+  if (!filePath) return undefined;
+  const lookupKey = lookupKeyForLocaleFile(locale, filePath, key);
+  if (lookupKey === undefined) return undefined;
+  const text = localeTexts[filePath];
+  const range = text ? localeKeyRange(text, lookupKey, /\.json$/i.test(filePath)) : undefined;
+  return range ? { filePath, position: range.start, range } : { filePath };
 }
 
 function lookupKeyForLocaleFile(locale, filePath, key) {
+  const prefix = locale.filePrefixes?.[filePath];
+  if (prefix !== undefined) {
+    if (!prefix) return key;
+    return key.startsWith(prefix + '.') ? key.slice(prefix.length + 1) : undefined;
+  }
   const isNestedLocaleFile = !locale.topLevelFiles?.includes(filePath) && normalizeFsPath(locale.path) !== normalizeFsPath(filePath);
   const stem = fileStem(filePath);
   if (isNestedLocaleFile && stem && stem !== 'index' && key.startsWith(stem + '.')) return key.slice(stem.length + 1);
@@ -771,6 +796,7 @@ export function getLocaleParamDiagnostics(locale, filePath, text, locales) {
     const consistency = getLocaleParamConsistency(key, locales);
     if (consistency.consistent) continue;
     const lookupKey = lookupKeyForLocaleFile(locale, filePath, key);
+    if (lookupKey === undefined) continue;
     const range = localeKeyRange(text, lookupKey, isJson, jsonRoot);
     if (range) diagnostics.push(paramInconsistencyDiagnostic(key, range, consistency.perLocale));
   }
@@ -825,6 +851,511 @@ export function getParamCodeActions(text, diagnostics = []) {
   });
 }
 
+/**
+ * If [contentStart, contentEnd) is translatable text inside a static attribute
+ * value or a bound attribute's whole string literal, returns safe rewrite bounds.
+ */
+function attributeLiteralContext(text, contentStart, contentEnd) {
+  const before = text.slice(0, contentStart);
+  const after = text.slice(contentEnd);
+  let bound = /(?:^|[\s>])(?::|v-bind:)([\w-]+)\s*=\s*(["'])\s*(['"]?)\s*$/.exec(before);
+  let plain = !bound && /(?:^|[\s>])([\w-]+)\s*=\s*(["'])\s*$/.exec(before);
+  const unquoted = !bound && !plain
+    && (/(?:^|[\s>])(?::|v-bind:)([\w-]+)\s*=\s*$/.exec(before)
+      || /(?:^|[\s>])([\w-]+)\s*=\s*$/.exec(before));
+  if (unquoted && !/^[^\s"'=<>`]/.test(after)) {
+    const attrStart = contentStart - unquoted[0].length + unquoted[0].search(/\S/);
+    return { name: unquoted[1], openQuote: '"', innerQuote: '', attrStart, attrEnd: contentEnd };
+  }
+  const m = bound || plain;
+  if (!m) return null;
+  const name = m[1];
+  const openQuote = bound ? bound[2] : plain[2];
+  const innerQuote = bound?.[3] || '';
+  const closeRe = innerQuote
+    ? new RegExp(`^\\s*${escapeRegExp(innerQuote)}\\s*${escapeRegExp(openQuote)}`)
+    : new RegExp(`^\\s*${escapeRegExp(openQuote)}`);
+  const closeMatch = closeRe.exec(after);
+  if (!closeMatch) return null;
+  const attrStart = contentStart - m[0].length + m[0].search(/\S/);
+  const attrEnd = contentEnd + closeMatch[0].length;
+  return { name, openQuote, innerQuote, attrStart, attrEnd };
+}
+
+/**
+ * "Extract to i18n key" for raw-text diagnostics (or raw text inside a selected
+ * range). Key = `<prefix>.<slug>` where the prefix comes from deriveKeyPrefix
+ * (nearest ancestor keys > file keys > file stem); always a new key (identical
+ * text elsewhere is not reused; it may need a different translation).
+ */
+export function getExtractCodeActions(text, language, filePath, range, diagnostics = [], defaultFlat = {}) {
+  let targets = diagnostics.filter((d) => d.code === 'raw-text');
+  const start = range ? positionToOffset(text, range.start) : 0;
+  const end = range ? positionToOffset(text, range.end) : 0;
+  if (!targets.length && range) {
+    // Selection: every loose candidate inside it. Cursor: the candidate under it.
+    targets = getRawTextDiagnostics(text, language, true, true).filter((d) => {
+      const s = positionToOffset(text, d.range.start);
+      const e = positionToOffset(text, d.range.end);
+      return end > start ? s >= start && e <= end : s <= start && start <= e;
+    });
+  }
+  const calls = extractI18nKeys(text, { includeStaticAttrCalls: true });
+  return targets.flatMap((diagnostic) => {
+    const s = positionToOffset(text, diagnostic.range.start);
+    const e = positionToOffset(text, diagnostic.range.end);
+    if (calls.some((c) => c.call && c.call.start <= s && e <= c.call.end)) return [];
+    const value = text.slice(s, e).replace(/\s+/g, ' ');
+    // v1: no entities or interpolation-like content; their decoded value is ambiguous.
+    if (!value || /[&<>{}]/.test(value)) return [];
+    const { prefix, source: keySource } = deriveKeyPrefix(text, language, filePath, s, e, defaultFlat);
+    const key = uniqueKey(prefix + '.' + slugify(value), defaultFlat);
+    if (!key) return [];
+    const attr = attributeLiteralContext(text, s, e);
+    let edit;
+    if (attr) {
+      edit = { range: makeRange(text, attr.attrStart, attr.attrEnd), newText: `:${attr.name}="$t('${key}')"` };
+    } else {
+      edit = { range: makeRange(text, s, e), newText: `{{ $t('${key}') }}` };
+    }
+    return [{ title: `Extract to i18n key "${key}"`, diagnostic, key, keySource, value, edit }];
+  });
+}
+
+const VOID_ELEMENTS = new Set(['area', 'base', 'br', 'col', 'embed', 'hr', 'img', 'input', 'link', 'meta', 'param', 'source', 'track', 'wbr']);
+
+/** Lightweight tag-stack scan: returns elements { tag, start, end, attrs, openEnd }; void/self-closing ones span only their opening tag. */
+function scanElements(text, opaque = computeOpaqueRanges(text).ranges) {
+  const elements = [];
+  const stack = [];
+  const re = /<!--[\s\S]*?-->|<\/([A-Za-z][\w:.-]*)\s*>|<([A-Za-z][\w:.-]*)((?:[^>"']|"[^"]*"|'[^']*')*?)(\/?)>/g;
+  let m;
+  while ((m = re.exec(text))) {
+    if (isOpaque(opaque, m.index)) continue;
+    if (m[1]) {
+      const tag = m[1].toLowerCase();
+      const idx = stack.map((x) => x.tag).lastIndexOf(tag);
+      if (idx < 0) continue;
+      while (stack.length > idx) {
+        const el = stack.pop();
+        el.end = stack.length === idx ? re.lastIndex : m.index;
+        elements.push(el);
+      }
+    } else if (m[2]) {
+      const tag = m[2].toLowerCase();
+      const el = { tag, start: m.index, end: text.length, attrs: m[3], openEnd: re.lastIndex };
+      if (m[4] || VOID_ELEMENTS.has(tag)) {
+        // Retain the opening span so attributes on <img> / <Component />
+        // are not mistaken for text in an enclosing element.
+        el.end = re.lastIndex;
+        elements.push(el);
+        continue;
+      }
+      if (tag === 'script' || tag === 'style') {
+        const close = text.toLowerCase().indexOf('</' + tag, re.lastIndex);
+        const stop = close < 0 ? text.length : text.indexOf('>', close) + 1 || text.length;
+        el.end = stop;
+        elements.push(el);
+        re.lastIndex = stop;
+        continue;
+      }
+      stack.push(el);
+    }
+  }
+  while (stack.length) elements.push(stack.pop());
+  return elements;
+}
+
+const SCRIPT_PARSE_OPTIONS = {
+  sourceType: 'unambiguous',
+  errorRecovery: true,
+  allowReturnOutsideFunction: true,
+  allowAwaitOutsideFunction: true,
+  allowImportExportEverywhere: true,
+};
+
+// Babel's modern (TC39) and legacy decorator plugins are mutually exclusive;
+// a file only has to parse under one of them.
+function scriptPluginSets(dialect) {
+  const syntax = dialect === 'typescript' ? ['typescript'] : dialect === 'typescriptreact' ? ['typescript', 'jsx'] : ['jsx'];
+  return [[...syntax, 'decorators', 'decoratorAutoAccessors'], [...syntax, 'decorators-legacy']];
+}
+
+function hasCallAt(node, start, end) {
+  while (node) {
+    if (node.type === 'CallExpression' && node.start === start && node.end === end) return true;
+    let next = null;
+    for (const key of Object.keys(node)) {
+      if (key === 'loc' || key === 'leadingComments' || key === 'trailingComments' || key === 'innerComments') continue;
+      for (const child of [].concat(node[key])) {
+        if (child && typeof child.type === 'string' && child.start <= start && end <= child.end) { next = child; break; }
+      }
+      if (next) break;
+    }
+    node = next;
+  }
+  return false;
+}
+
+// Lexing cannot tell generics, comparisons, regexes, JSX text and code apart;
+// only a parsed CallExpression qualifies. Parse failures offer nothing.
+function isCallInScript(code, dialect, start, end) {
+  return scriptPluginSets(dialect).some((plugins) => {
+    try {
+      return hasCallAt(parseScript(code, { ...SCRIPT_PARSE_OPTIONS, plugins }).program, start, end);
+    } catch {
+      return false;
+    }
+  });
+}
+
+function isCallInExpression(code, dialect, start, end) {
+  try {
+    return hasCallAt(parseExpression(code, { plugins: dialect === 'typescript' ? ['typescript'] : [], errorRecovery: true }), start, end);
+  } catch {
+    return false;
+  }
+}
+
+/**
+ * Vue (and the browser for in-DOM templates) decodes entities in `{{ }}` and
+ * attribute values before evaluating them, so `a &lt; b ? t('k') : ''` is
+ * judged on its decoded code. Returns the call's span inside that code.
+ */
+function decodedCall(raw, from, to, decode) {
+  const code = decode(raw);
+  const call = raw.slice(from, to);
+  const pos = decode(raw.slice(0, from)).length;
+  return code.slice(pos, pos + call.length) === call ? { code, start: pos, end: pos + call.length } : null;
+}
+
+// HTML attribute names are ASCII case-insensitive (`TYPE`); compiler-sfc reads
+// SFC block attributes such as `lang` case-sensitively.
+function staticAttr(element, name, html) {
+  const prop = element.props.find((p) => p.type === NodeTypes.ATTRIBUTE && (html ? p.name.toLowerCase() : p.name) === name);
+  return prop?.value?.content;
+}
+
+// True when [start, end) lies in a CDATA section of this TEXT node's source.
+// Vue folds CDATA into the surrounding text node and its loc may start just
+// after the `<![CDATA[` marker.
+function inCdata(text, node, start, end) {
+  let from = node.loc.start.offset;
+  if (text.startsWith('<![CDATA[', from - 9)) from -= 9;
+  const to = node.loc.end.offset;
+  for (let i = text.indexOf('<![CDATA[', from); i >= 0 && i < to; i = text.indexOf('<![CDATA[', i)) {
+    const close = text.indexOf(']]>', i + 9);
+    const stop = close < 0 ? to : close + 3;
+    if (i < end && start < stop) return true;
+    i = stop;
+  }
+  return false;
+}
+
+function scriptDialect(lang) {
+  if (lang === 'ts') return 'typescript';
+  return lang === 'tsx' ? 'typescriptreact' : 'javascript';
+}
+
+// Vue reads any attribute name starting with these as a directive.
+const DIRECTIVE_NAME = /^(?:v-|[:@#.])/i;
+
+function attributeTarget(text, prop, start, end, dialect, lowercaseNames) {
+  const callText = text.slice(start, end);
+  if (prop.type === NodeTypes.ATTRIBUTE) {
+    // Browsers lowercase attribute names before Vue sees an in-DOM template,
+    // so `V-BIND:TITLE` is a binding there even though Vue's case-sensitive
+    // parser saw a static attribute.
+    if (lowercaseNames && DIRECTIVE_NAME.test(prop.name)) return null;
+    // Static attribute text such as title="$t('key')" is a look-alike, not a call.
+    if (!prop.value) return null;
+    const raw = text.slice(prop.value.loc.start.offset, prop.value.loc.end.offset).replace(/^(["'])([\s\S]*)\1$/, '$2');
+    if (raw.trim() !== callText) return null;
+    return { kind: 'attribute', name: prop.name, bound: false, quote: '"', start: prop.loc.start.offset, end: prop.loc.end.offset };
+  }
+  // Only a whole, unmodified `:name` / `v-bind:name` binding can become a plain attribute.
+  if (prop.name !== 'bind' || !prop.arg?.isStatic || prop.modifiers.length || !prop.exp) return null;
+  const expStart = prop.exp.loc.start.offset;
+  const raw = text.slice(expStart, prop.exp.loc.end.offset);
+  const decoded = decodedCall(raw, start - expStart, end - expStart, decodeHTMLAttribute);
+  if (!decoded || decoded.code.trim() !== callText || !isCallInExpression(decoded.code, dialect, decoded.start, decoded.end)) return null;
+  const quote = /["']/.test(text[expStart - 1]) ? text[expStart - 1] : '"';
+  // `:v-bind:title` binds an attribute literally named `v-bind:title`; written
+  // as a plain attribute it would turn into a directive, so it stays bound.
+  return { kind: 'attribute', name: prop.arg.content, bound: true, keepBound: DIRECTIVE_NAME.test(prop.arg.content), quote, start: prop.loc.start.offset, end: prop.loc.end.offset };
+}
+
+const TOLERATED_TEMPLATE_ERRORS = new Set([ErrorCodes.X_MISSING_END_TAG, ErrorCodes.UNEXPECTED_CHARACTER_IN_UNQUOTED_ATTRIBUTE_VALUE]);
+// HTML's "JavaScript MIME type essence match" list plus module and JSX/Babel blocks.
+const JS_SCRIPT_TYPES = new Set([
+  '', 'module', 'text/jsx', 'text/babel',
+  'application/ecmascript', 'application/javascript', 'application/x-ecmascript', 'application/x-javascript',
+  'text/ecmascript', 'text/javascript', 'text/javascript1.0', 'text/javascript1.1', 'text/javascript1.2', 'text/javascript1.3',
+  'text/javascript1.4', 'text/javascript1.5', 'text/jscript', 'text/livescript', 'text/x-ecmascript', 'text/x-javascript',
+]);
+
+/**
+ * Where a call sits in a Vue SFC or HTML document, from Vue's own template
+ * parser (it understands `{{ }}`, directives and raw-text blocks). Returns
+ * null whenever the context is not provably one of the rewritable kinds.
+ */
+function templateInlineTarget(text, language, start, end, lowercaseNames = language === 'html') {
+  let root;
+  let invalid = false;
+  try {
+    // Browsers end script/style raw text case-insensitively (`<SCRIPT>`);
+    // Vue's parser only knows lowercase. Same-length rewrite keeps offsets.
+    const source = language === 'vue' ? text : text.replace(/<(\/?)(script|style)(?=[\s/>])/gi, (_, slash, tag) => `<${slash}${tag.toLowerCase()}`);
+    root = parseTemplate(source, {
+      parseMode: language === 'vue' ? 'sfc' : 'html',
+      comments: true,
+      // Missing end tags and quotes inside unquoted values (browsers accept
+      // both) keep node bounds intact; anything else, such as unclosed tags or
+      // interpolations while typing, leaves the context unknown.
+      onError: (error) => { if (!TOLERATED_TEMPLATE_ERRORS.has(error.code)) invalid = true; },
+      onWarn: () => {},
+    });
+  } catch {
+    return null;
+  }
+  if (invalid) return null;
+  const sfcBlocks = language === 'vue' ? root.children.filter((n) => n.type === NodeTypes.ELEMENT) : [];
+  const exprDialect = sfcBlocks.some((n) => n.tag === 'script' && /^tsx?$/.test(staticAttr(n, 'lang') || '')) ? 'typescript' : 'javascript';
+  const ancestors = [];
+  let parent = root;
+  for (;;) {
+    const node = parent.children?.find((n) => n.loc.start.offset <= start && end <= n.loc.end.offset);
+    if (!node) return null;
+    if (node.type === NodeTypes.ELEMENT) {
+      if (language === 'vue' && parent === root && node.tag === 'template' && (staticAttr(node, 'lang') || 'html') !== 'html') return null;
+      const prop = node.props.find((p) => p.loc.start.offset <= start && end <= p.loc.end.offset);
+      if (prop) return attributeTarget(text, prop, start, end, exprDialect, lowercaseNames);
+      ancestors.push(node);
+      parent = node;
+      continue;
+    }
+    if (node.type === NodeTypes.INTERPOLATION) {
+      const exp = node.content;
+      const expStart = exp.loc.start.offset;
+      const decoded = decodedCall(text.slice(expStart, exp.loc.end.offset), start - expStart, end - expStart, decodeHTML);
+      if (!decoded || !isCallInExpression(decoded.code, exprDialect, decoded.start, decoded.end)) return null;
+      return { kind: 'interpolation', whole: decoded.code.trim() === text.slice(start, end), start: node.loc.start.offset, end: node.loc.end.offset };
+    }
+    if (node.type !== NodeTypes.TEXT) return null;
+    if (parent.type === NodeTypes.ELEMENT && parent.tag === 'script') {
+      const base = node.loc.start.offset;
+      const code = text.slice(base, node.loc.end.offset);
+      if (language === 'vue') return isCallInScript(code, scriptDialect(staticAttr(parent, 'lang')), start - base, end - base) ? { kind: 'script' } : null;
+      const type = (staticAttr(parent, 'type', true) || '').trim().toLowerCase();
+      if (JS_SCRIPT_TYPES.has(type)) return isCallInScript(code, 'javascript', start - base, end - base) ? { kind: 'script' } : null;
+      if (type !== 'text/x-template') return null;
+      // An in-DOM Vue template: its raw contents are compiled as a template,
+      // without the browser lowercasing attribute names first.
+      const inner = templateInlineTarget(code, 'html', start - base, end - base, false);
+      return inner && ('start' in inner ? { ...inner, start: inner.start + base, end: inner.end + base } : inner);
+    }
+    if (parent.type === NodeTypes.ELEMENT && parent.tag === 'style') return null;
+    // SFC text outside <template> (custom blocks, stray root text) is not markup.
+    if (language === 'vue' && !ancestors.some((el) => el.tag === 'template' && sfcBlocks.includes(el))) return null;
+    // CDATA exists only in SVG/MathML content and is never entity-decoded, so
+    // HTML escaping would change it. Elsewhere (`<textarea>`) it is plain text.
+    if (parent.type === NodeTypes.ELEMENT && parent.ns !== 0 && inCdata(text, node, start, end)) return null;
+    return { kind: 'text' };
+  }
+}
+
+function commonKeyPrefix(keys) {
+  let common;
+  for (const key of keys) {
+    const parts = key.split('.').slice(0, -1);
+    if (common === undefined) common = parts;
+    else {
+      let i = 0;
+      while (i < common.length && i < parts.length && common[i] === parts[i]) i++;
+      common = common.slice(0, i);
+    }
+  }
+  return common && common.length ? common.join('.') : '';
+}
+
+const normalizeSegment = (value) => value.toLowerCase().replace(/[^a-z0-9]/g, '');
+
+/** Descend into an existing child group whose name matches an ancestor's id/data-anchor. */
+function descendByAnchor(prefix, ancestors, flat) {
+  const children = new Set();
+  for (const k of Object.keys(flat)) {
+    if (!k.startsWith(prefix + '.')) continue;
+    const rest = k.slice(prefix.length + 1).split('.');
+    if (rest.length > 1) children.add(rest[0]);
+  }
+  for (const el of ancestors) {
+    const a = /(?:^|\s)(?:id|data-anchor)\s*=\s*(["'])([^"']+)\1/.exec(el.attrs);
+    if (!a) continue;
+    const want = normalizeSegment(a[2]);
+    const hit = [...children].find((c) => normalizeSegment(c) === want);
+    if (hit) return prefix + '.' + hit;
+  }
+  return prefix;
+}
+
+/**
+ * Prefix for a new extracted key: common prefix of keys in the nearest ancestor
+ * element that has any, else of all keys in the file, else the file stem.
+ */
+function deriveKeyPrefix(text, language, filePath, s, e, flat) {
+  const keys = extractI18nKeys(text);
+  if (keys.length && (language === 'vue' || language === 'html')) {
+    const ancestors = scanElements(text)
+      .filter((el) => el.start <= s && el.end >= e && el.tag !== 'template')
+      .sort((a, b) => (a.end - a.start) - (b.end - b.start));
+    for (let i = 0; i < ancestors.length; i++) {
+      const el = ancestors[i];
+      const inside = keys.filter((k) => k.startOffset >= el.start && k.endOffset <= el.end).map((k) => k.key);
+      if (!inside.length) continue;
+      const prefix = commonKeyPrefix(inside);
+      if (prefix) return { prefix: descendByAnchor(prefix, ancestors.slice(0, i + 1), flat), source: 'ancestor' };
+      break;
+    }
+  }
+  const filePrefix = commonKeyPrefix(keys.map((k) => k.key));
+  if (filePrefix) return { prefix: filePrefix, source: 'file' };
+  return { prefix: fileStem(filePath), source: 'filename' };
+}
+
+function slugify(value) {
+  const words = value.toLowerCase().match(/[a-z0-9]+/g) || [];
+  if (words.length) return words.slice(0, 4).join('_');
+  // Non-Latin text: deterministic FNV-1a hash instead of a transliteration.
+  let hash = 0x811c9dc5;
+  for (const ch of value) hash = Math.imul(hash ^ ch.codePointAt(0), 0x01000193) >>> 0;
+  return 'text_' + hash.toString(16);
+}
+
+function uniqueKey(base, flat) {
+  const leaves = new Set(Object.keys(flat));
+  const branches = new Set();
+  for (const key of leaves) {
+    for (let dot = key.indexOf('.'); dot !== -1; dot = key.indexOf('.', dot + 1)) branches.add(key.slice(0, dot));
+  }
+  const hasLeafAncestor = (key) => {
+    for (let dot = key.indexOf('.'); dot !== -1; dot = key.indexOf('.', dot + 1)) {
+      if (leaves.has(key.slice(0, dot))) return true;
+    }
+    return false;
+  };
+  const taken = (key) => leaves.has(key) || branches.has(key) || hasLeafAncestor(key);
+
+  function allocate(candidate) {
+    if (!candidate) return undefined;
+    if (!taken(candidate)) return candidate;
+    // Suffixing the last segment cannot escape a leaf ancestor (`Home` vs
+    // `Home.hello_world_2`), so give up this candidate rather than loop.
+    if (hasLeafAncestor(candidate)) return undefined;
+    for (let n = 2; n <= 10000; n++) {
+      const key = candidate + '_' + n;
+      if (!taken(key)) return key;
+    }
+    return undefined;
+  }
+
+  // Prefixes that are already string leaves cannot host children. Drop those
+  // segments and keep the rest under the longest still-object (or empty)
+  // prefix: `hello.hello_world` with leaf `hello` → `hello_world`; `a.b.c.d`
+  // with leaf `a.b` → `a.c.d`. Exact / descendant collisions still suffix
+  // the last segment (`d_2`, `d_3`, …).
+  const parts = base.split('.');
+  const kept = [];
+  for (let i = 0; i < parts.length; i++) {
+    const next = [...kept, parts[i]].join('.');
+    if (i < parts.length - 1 && Object.hasOwn(flat, next)) continue;
+    kept.push(parts[i]);
+  }
+  return allocate(kept.join('.'));
+}
+
+/**
+ * "Inline as <locale>": replace a param-less t('key') call with locale text.
+ * `language` is 'vue' | 'html' for template documents, otherwise
+ * 'typescript' | 'typescriptreact' | 'javascript' (JSX enabled). Source files
+ * only inline real call expressions, replaced by a JS string literal.
+ */
+export function getInlineCodeActions(text, language, range, locales = {}) {
+  const isTemplate = language === 'vue' || language === 'html';
+  const offset = positionToOffset(text, range.start);
+  const endOffset = positionToOffset(text, range.end || range.start);
+  // Cursor (or selection) must sit inside the call; a whole-file range offers nothing.
+  const item = extractI18nKeys(text, { includeStaticAttrCalls: isTemplate }).find((c) => c.call && offset >= c.call.start && endOffset <= c.call.end);
+  if (!item || item.call.argCount !== 1) return [];
+  const { start, end, quote } = item.call;
+  const target = isTemplate
+    ? templateInlineTarget(text, language, start, end)
+    : isCallInScript(text, language, start, end) && { kind: 'script' };
+  if (!target) return [];
+  return Object.entries(locales).flatMap(([name, locale]) => {
+    const value = locale?.flat?.[item.key];
+    if (typeof value !== 'string') return [];
+    return [{ title: `Inline i18n key "${item.key}" as ${name}`, edit: inlineEdit(text, target, start, end, quote, value) }];
+  });
+}
+
+function inlineEdit(text, target, start, end, quote, value) {
+  const replace = (from, to, newText) => ({ range: makeRange(text, from, to), newText });
+  if (target.kind === 'script') return replace(start, end, escapeJsString(value, quote));
+  // Template text: `{{`/`}}` in the translation must not become a Vue interpolation.
+  if (target.kind === 'text') return replace(start, end, escapeMarkup(value).replace(/\{/g, '&#123;').replace(/\}/g, '&#125;'));
+  if (target.kind === 'interpolation') {
+    // Without braces the whole `{{ t('key') }}` becomes plain text.
+    if (target.whole && !/[{}]/.test(value)) return replace(target.start, target.end, escapeMarkup(value));
+    // A JS literal with no markup-significant characters at all: entities
+    // would change whether browser Vue re-decodes the whole expression, `<`
+    // is parsed as a tag in in-DOM templates, and `}}` ends the interpolation.
+    return replace(start, end, markupFreeJsString(value, quote));
+  }
+  // Braces stay inside a bound JS string, not a plain attribute Vue could re-read.
+  if (target.bound && (target.keepBound || /[{}]/.test(value))) {
+    const jsQuote = target.quote === '"' ? "'" : '"';
+    return replace(target.start, target.end, `:${target.name}=${target.quote}${escapeHtmlAttribute(escapeJsString(value, jsQuote), target.quote)}${target.quote}`);
+  }
+  return replace(target.start, target.end, `${target.name}="${escapeMarkup(value)}"`);
+}
+
+function markupFreeJsString(value, quote) {
+  const escaped = value.replace(/[\\\n\r\u2028\u2029&<>"'`${}]/g, (ch) => {
+    if (ch === '\\') return '\\\\';
+    if (ch === '\n') return '\\n';
+    if (ch === '\r') return '\\r';
+    return '\\u' + ch.charCodeAt(0).toString(16).toUpperCase().padStart(4, '0');
+  });
+  return quote + escaped + quote;
+}
+
+function escapeHtml(value) {
+  return value.replace(/&/g, '&amp;').replace(/</g, '&lt;').replace(/>/g, '&gt;').replace(/"/g, '&quot;');
+}
+
+// HTML parsing turns a literal CR (or CRLF) into LF; a character reference keeps it.
+function escapeMarkup(value) {
+  return escapeHtml(value).replace(/\r/g, '&#13;');
+}
+
+function escapeHtmlAttribute(value, quote) {
+  const escaped = escapeHtml(value);
+  return quote === "'" ? escaped.replace(/'/g, '&#39;') : escaped;
+}
+
+function escapeJsString(value, quote) {
+  let escaped = String(value)
+    .replace(/\\/g, '\\\\')
+    .replace(new RegExp(escapeRegExp(quote), 'g'), '\\' + quote)
+    .replace(/\r/g, '\\r')
+    .replace(/\n/g, '\\n');
+  if (quote === '`') escaped = escaped.replace(/\$\{/g, '\\${');
+  // Break </script> / </style> so a generated literal cannot close an HTML
+  // <script> / <style> element. `\/` is still `/` in JS string values.
+  escaped = escaped.replace(/<\/(script|style)/gi, '<\\/$1');
+  return quote + escaped + quote;
+}
+
 function sameRange(a, b) {
   return a?.start?.line === b?.start?.line
     && a?.start?.character === b?.start?.character
@@ -921,6 +1452,7 @@ export function localeKeyAtPosition(locale, filePath, text, position) {
   let lineFallbackCount = 0;
   for (const fullKey of Object.keys(locale.flat)) {
     const lookupKey = lookupKeyForLocaleFile(locale, filePath, fullKey);
+    if (lookupKey === undefined) continue;
     const range = localeKeyRange(text, lookupKey, isJson, jsonRoot);
     if (!range || range.start.line !== position.line) continue;
     if (comparePosition(position, range.start) >= 0 && comparePosition(position, range.end) < 0) return fullKey;
@@ -932,7 +1464,7 @@ export function localeKeyAtPosition(locale, filePath, text, position) {
 
 export function getCompletionPrefix(text, position) {
   const before = text.slice(0, positionToOffset(text, position));
-  const opaque = computeOpaqueRanges(before);
+  const { ranges: opaque } = computeOpaqueRanges(before);
   const patterns = [
     /(?:\x24tc?|\btc?|\bi18n\.tc?)\s*\(\s*['"]([A-Za-z0-9_.:-]*)$/,
     /\bformatMessage\s*\(\s*\{[^}]*?\bid\s*:\s*['"]([A-Za-z0-9_.:-]*)$/,
@@ -1086,12 +1618,13 @@ function buildNestedProperty(parts, value, indent, unit, eol) {
 }
 
 
+// File and directory namespaces are applied by the loader, not the parser.
 export function parseTsLocaleModule(text, fileName = 'index.ts') {
   const result = {};
   const stem = fileName.replace(/\.[cm]?[tj]sx?$/i, '');
   const exportObject = extractObjectAfter(text, /export\s+default\s*/g);
   if (exportObject) {
-    Object.assign(result, flattenJsObjectLiteral(exportObject, stem === 'index' ? '' : stem));
+    Object.assign(result, flattenJsObjectLiteral(exportObject));
   }
 
   if (stem === 'index') {

package/server/index.js

@@ -27,6 +27,9 @@ import {
   didWatchedFileChange,
   collectLocaleWatchPaths,
   resolveProjectContext,
+  getExtractCodeActions,
+  resolvePreferredLocale,
+  getInlineCodeActions,
 } from './core.js';
 
 const connection = createConnection(ProposedFeatures.all);
@@ -187,6 +190,13 @@ connection.onCodeAction((params) => {
     }
   }
   actions.push(...getCreateKeyActions(diagnostics, getProjectContext(params.textDocument.uri)));
+  if (clientSupportsDocumentChanges && doc && !isLocaleFileUri(doc.uri)) {
+    // A refactor failure must not discard existing quick fixes or its sibling action.
+    try { actions.push(...getExtractActions(doc, params, diagnostics)); }
+    catch (error) { connection.console.error(`Extract failed for ${doc.uri}: ${error.message}`); }
+    try { actions.push(...getInlineActions(doc, params)); }
+    catch (error) { connection.console.error(`Inline failed for ${doc.uri}: ${error.message}`); }
+  }
   return actions;
 });
 
@@ -220,21 +230,63 @@ function getCreateKeyActions(diagnostics, context) {
   return actions;
 }
 
+function templateLanguageOf(doc) {
+  if (/\.vue$/i.test(doc.uri) || doc.languageId === 'vue') return 'vue';
+  return /\.html?$/i.test(doc.uri) || doc.languageId === 'html' ? 'html' : undefined;
+}
+
+// Parser dialect for Inline in non-template documents; the extension wins over languageId.
+function sourceLanguageOf(doc) {
+  if (/\.tsx$/i.test(doc.uri)) return 'typescriptreact';
+  if (/\.[cm]?ts$/i.test(doc.uri)) return 'typescript';
+  if (/\.[cm]?jsx?$/i.test(doc.uri)) return 'javascript';
+  if (doc.languageId === 'typescriptreact' || doc.languageId === 'tsx') return 'typescriptreact';
+  return doc.languageId === 'typescript' ? 'typescript' : 'javascript';
+}
+
+function getExtractActions(doc, params, diagnostics) {
+  const language = templateLanguageOf(doc);
+  if (!language) return [];
+  const context = getProjectContext(doc.uri);
+  const { locales, localeTexts } = loadLocalesForContext(context);
+  const locale = resolvePreferredLocale(locales, context.config.defaultLocale);
+  if (!locale) return [];
+  return getExtractCodeActions(doc.getText(), language, fileURLToPath(doc.uri), params.range, diagnostics, locale.flat).flatMap((action) => {
+    const plan = planKeyInsertion(action.key, locale, locales, localeTexts, action.value);
+    if (!plan || (plan.create && !clientSupportsCreateFile)) return [];
+    const documentChanges = [];
+    if (plan.create) documentChanges.push(CreateFile.create(plan.uri));
+    documentChanges.push(TextDocumentEdit.create({ uri: plan.uri, version: plan.version }, [minimalTextEdit(plan.text, plan.newText)]));
+    documentChanges.push(TextDocumentEdit.create({ uri: doc.uri, version: doc.version }, [action.edit]));
+    return [{ title: action.title, kind: CodeActionKind.QuickFix, diagnostics: [action.diagnostic], edit: { documentChanges } }];
+  });
+}
+
+function getInlineActions(doc, params) {
+  const { locales } = loadLocalesForContext(getProjectContext(doc.uri));
+  const language = templateLanguageOf(doc) || sourceLanguageOf(doc);
+  return getInlineCodeActions(doc.getText(), language, params.range, locales).map((action) => ({
+    title: action.title,
+    kind: CodeActionKind.RefactorInline,
+    edit: { documentChanges: [TextDocumentEdit.create({ uri: doc.uri, version: doc.version }, [action.edit])] },
+  }));
+}
+
 // Namespace routing follows loaded file stems. Index-owned prefixes and
 // overlapping layouts are not guessed; ambiguous targets disable the action.
-function planKeyInsertion(key, locale, locales, localeTexts) {
+function planKeyInsertion(key, locale, locales, localeTexts, value = '') {
   if (!locale) return undefined;
   if (!locale.directories?.length) {
     const files = locale.files || [];
     return files.length === 1 && /\.json$/i.test(files[0])
-      ? insertInto(files[0], key) : undefined;
+      ? insertInto(files[0], key, value) : undefined;
   }
   if (locale.directories.length !== 1 || locale.topLevelFiles?.length) return undefined;
   const directory = locale.directories[0];
-  const targets = filesByStem(locale);
-  const namespaceFiles = [...targets.keys()].filter((stem) => stem !== 'index' && key.startsWith(stem + '.'));
+  const targets = filesByPrefix(locale);
+  const namespaceFiles = [...targets.keys()].filter((prefix) => prefix && key.startsWith(prefix + '.'));
   if (namespaceFiles.length > 1 || targets.has(key)) return undefined;
-  const indexFiles = targets.get('index') || [];
+  const indexFiles = targets.get('') || [];
   const indexFile = indexFiles.length === 1 && /\.json$/i.test(indexFiles[0]) ? indexFiles[0] : undefined;
   let indexOwnsPrefix = false;
   if (indexFiles.length) {
@@ -252,38 +304,45 @@ function planKeyInsertion(key, locale, locales, localeTexts) {
     const stem = namespaceFiles[0];
     const files = targets.get(stem);
     return files.length === 1 && /\.json$/i.test(files[0])
-      ? insertInto(files[0], key.slice(stem.length + 1)) : undefined;
+      ? insertInto(files[0], key.slice(stem.length + 1), value) : undefined;
   }
-  if (indexOwnsPrefix) return insertInto(indexFile, key);
+  if (indexOwnsPrefix) return insertInto(indexFile, key, value);
 
   const siblingStems = new Map();
   for (const sibling of Object.values(locales)) {
     if (sibling === locale || sibling.directories?.length !== 1 || sibling.topLevelFiles?.length) continue;
-    for (const [stem, files] of filesByStem(sibling)) {
-      if (stem === 'index' || !key.startsWith(stem + '.')) continue;
-      siblingStems.set(stem, (siblingStems.get(stem) || []).concat(files));
+    for (const [stem, files] of filesByPrefix(sibling)) {
+      if (!stem || !key.startsWith(stem + '.')) continue;
+      siblingStems.set(stem, (siblingStems.get(stem) || []).concat(files.map((file) => ({
+        file,
+        relativePath: path.relative(sibling.directories[0], file),
+      }))));
     }
   }
   if (siblingStems.size > 1) return undefined;
   if (siblingStems.size === 1) {
-    const [stem, files] = siblingStems.entries().next().value;
-    if (files.some((file) => !/\.json$/i.test(file))) return undefined;
-    return insertOrCreate(path.join(directory, stem + '.json'), key.slice(stem.length + 1));
+    const [stem, targets] = siblingStems.entries().next().value;
+    if (targets.some(({ file }) => !/\.json$/i.test(file))) return undefined;
+    const relativePaths = new Set(targets.map(({ relativePath }) => relativePath));
+    if (relativePaths.size !== 1) return undefined;
+    const targetPath = path.join(directory, [...relativePaths][0]);
+    return fs.existsSync(path.dirname(targetPath))
+      ? insertOrCreate(targetPath, key.slice(stem.length + 1), value) : undefined;
   }
-  return indexFile ? insertInto(indexFile, key) : undefined;
+  return indexFile ? insertInto(indexFile, key, value) : undefined;
 }
 
-function filesByStem(locale) {
-  const stems = new Map();
+function filesByPrefix(locale) {
+  const prefixes = new Map();
   for (const file of locale.files || []) {
-    const stem = path.basename(file, path.extname(file));
-    if (!stems.has(stem)) stems.set(stem, []);
-    stems.get(stem).push(file);
+    const prefix = locale.filePrefixes[file];
+    if (!prefixes.has(prefix)) prefixes.set(prefix, []);
+    prefixes.get(prefix).push(file);
   }
-  return stems;
+  return prefixes;
 }
 
-function insertInto(filePath, lookupKey) {
+function insertInto(filePath, lookupKey, value = '') {
   if (!lookupKey) return undefined;
   const text = openDocumentText(filePath) ?? readFileSafe(filePath);
   if (text === undefined) return undefined;
@@ -291,7 +350,7 @@ function insertInto(filePath, lookupKey) {
   // an empty object (matching its line-ending style) so the fix still lands
   // instead of silently disappearing.
   const source = text.trim() ? text : (text.includes('\r\n') ? '{}\r\n' : '{}\n');
-  const newText = insertNestedJsonKey(source, lookupKey, '');
+  const newText = insertNestedJsonKey(source, lookupKey, value);
   if (newText === undefined) return undefined;
   return toEditPlan(filePath, text, newText, false);
 }
@@ -299,17 +358,17 @@ function insertInto(filePath, lookupKey) {
 // Prefer an in-place insert when the file exists or is open as a buffer (the
 // file may have been deleted on disk while its document stays alive); fall
 // back to a CreateFile only when there is truly nothing to edit.
-function insertOrCreate(filePath, lookupKey) {
-  if (fs.existsSync(filePath) || openDocument(filePath)) return insertInto(filePath, lookupKey);
-  return createIn(filePath, lookupKey);
+function insertOrCreate(filePath, lookupKey, value = '') {
+  if (fs.existsSync(filePath) || openDocument(filePath)) return insertInto(filePath, lookupKey, value);
+  return createIn(filePath, lookupKey, value);
 }
 
 // Create a missing namespace JSON file: only ever proposed with a CreateFile
 // operation ahead of the text edit, and only when the file truly does not
 // exist — never as a fallback guess.
-function createIn(filePath, lookupKey) {
+function createIn(filePath, lookupKey, value = '') {
   if (!lookupKey || fs.existsSync(filePath) || openDocument(filePath)) return undefined;
-  const newText = insertNestedJsonKey('{}\n', lookupKey, '');
+  const newText = insertNestedJsonKey('{}\n', lookupKey, value);
   if (newText === undefined) return undefined;
   return toEditPlan(filePath, '', newText, true);
 }
@@ -370,7 +429,7 @@ function watchLocalePaths() {
       .map((dir) => path.join(context.root, dir))
       .filter((dir) => fs.existsSync(dir));
     const loaded = loadLocalesForContext(context);
-    for (const watchPath of collectLocaleWatchPaths(loaded.locales, configuredDirs)) nextPaths.add(watchPath);
+    for (const watchPath of collectLocaleWatchPaths(loaded.locales, [...configuredDirs, ...loaded.watchDirectories])) nextPaths.add(watchPath);
   }
 
   for (const watchedPath of watchedLocalePaths) {
@@ -448,8 +507,7 @@ function normalizeIncomingSettings(value) {
 function validate(document) {
   const context = getProjectContext(document.uri);
   const { locales } = loadLocalesForContext(context);
-  const templateLanguage = /\.vue$/i.test(document.uri) ? 'vue'
-    : /\.html?$/i.test(document.uri) || document.languageId === 'html' ? 'html' : undefined;
+  const templateLanguage = templateLanguageOf(document);
   if ((isSourceFile(document.uri) || templateLanguage) && !isLocaleFileUri(document.uri)) {
     const text = document.getText();
     const diagnostics = [
@@ -480,10 +538,7 @@ function localeDirOfFile(filePath) {
       const absDir = normalizeFsPathLocal(path.resolve(contextRoot, dir));
       if (!isPathInsidePath(normalized, absDir) || normalized === absDir) continue;
       const relative = normalized.slice(absDir.length + 1);
-      const depth = relative.split('/').length - 1;
-      // Only files directly under the localeDir or one level deep (the locale
-      // directory itself) are locale files, matching the loaders.
-      if (depth <= 1) return { context, dir: absDir, relative };
+      return { context, dir: absDir, relative };
     }
   }
   return undefined;
@@ -646,35 +701,52 @@ function loadLocalesForContext(context) {
 
   const locales = {};
   const localeTexts = {};
-  for (const dir of context.config.localeDirs) {
-    const fullDir = path.join(context.root, dir);
+  const watchDirectories = new Set();
+  const localeRoots = context.config.localeDirs.map((dir) => path.resolve(context.root, dir));
+  for (const fullDir of localeRoots) {
     if (!fs.existsSync(fullDir)) continue;
     loadLocaleFiles(fullDir, locales, localeTexts);
     for (const entry of fs.readdirSync(fullDir, { withFileTypes: true })) {
-      if (entry.isDirectory()) loadLocaleDirectory(path.join(fullDir, entry.name), entry.name, locales, localeTexts);
+      if (entry.isDirectory()) loadLocaleDirectory(path.join(fullDir, entry.name), entry.name, locales, localeTexts, localeRoots, watchDirectories);
     }
   }
-  const loaded = { locales, localeTexts };
+  const loaded = { locales, localeTexts, watchDirectories: [...watchDirectories] };
   localeCacheByContext.set(cacheKey, loaded);
   return loaded;
 }
 
-function loadLocaleDirectory(localeDir, localeName, next, localeTexts) {
-  next[localeName] ||= { path: localeDir, flat: {}, files: [] };
-  next[localeName].directories ||= [];
-  if (!next[localeName].directories.includes(localeDir)) next[localeName].directories.push(localeDir);
-  for (const file of fs.readdirSync(localeDir).sort()) {
+function loadLocaleDirectory(localeDir, localeName, next, localeTexts, localeRoots, watchDirectories, rootDir = localeDir) {
+  // An explicit locale root owns its subtree, independently of config order.
+  if (localeRoots.includes(localeDir)) return;
+  // Fileless directories still need watching, but must not create phantom locales.
+  watchDirectories.add(localeDir);
+  for (const entry of fs.readdirSync(localeDir, { withFileTypes: true }).sort((a, b) => a.name.localeCompare(b.name))) {
+    const file = entry.name;
     const fullPath = path.join(localeDir, file);
-    if (fs.statSync(fullPath).isDirectory()) continue;
+    if (entry.isDirectory()) {
+      loadLocaleDirectory(fullPath, localeName, next, localeTexts, localeRoots, watchDirectories, rootDir);
+      continue;
+    }
     if (!LOCALE_FILE_RE.test(file)) continue;
-    if (!next[localeName].files.includes(fullPath)) next[localeName].files.push(fullPath);
+    if (entry.isSymbolicLink() && fs.statSync(fullPath).isDirectory()) continue;
+    next[localeName] ||= { path: rootDir, flat: {}, keyFiles: {}, files: [] };
+    const locale = next[localeName];
+    locale.directories ||= [];
+    if (!locale.directories.includes(rootDir)) locale.directories.push(rootDir);
+    locale.filePrefixes ||= {};
+    const relativeFile = path.relative(rootDir, fullPath);
+    if (!locale.files.includes(fullPath)) locale.files.push(fullPath);
+    locale.filePrefixes[fullPath] = localeFilePrefix(relativeFile);
     try {
       const text = localeText(fullPath);
       if (text === undefined) continue;
       localeTexts[fullPath] = text;
-      if (file.endsWith('.json')) Object.assign(next[localeName].flat, prefixByFile(file, flattenLocale(JSON.parse(text))));
-      else if (/\.[cm]?[tj]s$/i.test(file)) Object.assign(next[localeName].flat, parseTsLocaleModule(text, file));
-      else continue;
+      const flat = prefixByFile(relativeFile, file.endsWith('.json')
+        ? flattenLocale(JSON.parse(text)) : parseTsLocaleModule(text, file));
+      for (const [key, value] of Object.entries(flat)) {
+        locale.flat[key] = value;
+        locale.keyFiles[key] = fullPath;
+      }
     } catch (error) { connection.console.warn('Failed to load locale file ' + fullPath + ': ' + error.message); }
   }
 }
@@ -698,7 +770,9 @@ function loadLocaleFiles(fullDir, next, localeTexts) {
       const isModule = /\.[cm]?[tj]s$/i.test(file);
       if (!isJson && !isModule) continue;
       const name = file.replace(/\.(json|[cm]?[tj]s)$/i, '');
-      next[name] ||= { path: fullPath, flat: {}, files: [], topLevelFiles: [] };
+      next[name] ||= { path: fullPath, flat: {}, keyFiles: {}, files: [], topLevelFiles: [] };
+      next[name].filePrefixes ||= {};
+      next[name].filePrefixes[fullPath] = '';
       next[name].topLevelFiles ||= [];
       if (!next[name].files.includes(fullPath)) next[name].files.push(fullPath);
       if (!next[name].topLevelFiles.includes(fullPath)) next[name].topLevelFiles.push(fullPath);
@@ -706,15 +780,25 @@ function loadLocaleFiles(fullDir, next, localeTexts) {
       if (text === undefined) continue;
       localeTexts[fullPath] = text;
       const flat = isJson ? flattenLocale(JSON.parse(text)) : parseTsLocaleModule(text, 'index.ts');
-      Object.assign(next[name].flat, flat);
+      for (const [key, value] of Object.entries(flat)) {
+        next[name].flat[key] = value;
+        next[name].keyFiles[key] = fullPath;
+      }
     } catch (error) { connection.console.warn('Failed to load locale file ' + fullPath + ': ' + error.message); }
   }
 }
 
 function prefixByFile(file, flat) {
-  const stem = path.basename(file, path.extname(file));
-  if (stem === 'index') return flat;
-  return Object.fromEntries(Object.entries(flat).map(([key, value]) => [stem + '.' + key, value]));
+  const prefix = localeFilePrefix(file);
+  if (!prefix) return flat;
+  return Object.fromEntries(Object.entries(flat).map(([key, value]) => [prefix + '.' + key, value]));
+}
+
+function localeFilePrefix(file) {
+  const segments = file.replace(/\\/g, '/').split('/');
+  const stem = segments.pop().replace(/\.[^.]+$/, '');
+  if (stem !== 'index') segments.push(stem);
+  return segments.join('.');
 }
 
 documents.listen(connection);