From 0ea5dd350c3a5bcb2a6c07254a8002dcec93daf5 Mon Sep 17 00:00:00 2001
From: Ryan Atkinson <mail@ryanatkn.com>
Date: Sat, 25 Jul 2026 09:32:11 -0400
Subject: [PATCH] fix: reconstruct Svelte name_loc from the no-locations wire

---
 benches/js/CLAUDE.md                          |   5 +-
 benches/js/diagnostics/no_locations_parity.ts | 142 +++++++----
 .../diagnostics/reconstruct_vs_materialize.ts |   5 +-
 crates/tsv_svelte/CLAUDE.md                   |   2 +-
 crates/tsv_wasm/CLAUDE.md                     |   9 +-
 crates/tsv_wasm/README_all.md                 |   2 +-
 crates/tsv_wasm/README_parse.md               |   2 +-
 crates/tsv_wasm/npm/locations.d.ts            |  10 +-
 crates/tsv_wasm/npm/locations.js              | 228 ++++++++++++++++--
 scripts/test_npm.ts                           |  14 +-
 10 files changed, 338 insertions(+), 81 deletions(-)

diff --git a/benches/js/CLAUDE.md b/benches/js/CLAUDE.md
index 2719b2ff4..03fbb5940 100644
--- a/benches/js/CLAUDE.md
+++ b/benches/js/CLAUDE.md
@@ -1619,7 +1619,10 @@ CWD-relative).
   `loc` from `start`/`end` (UTF-16 offsets) + source via the ECMAScript (TS) / LF-only
   (Svelte) line rules, and assert equality. TS is 100% exact; the two Svelte non-derivable
   cases (the `<script>` `Program` tag-position override, the destructure `+1`-column quirk)
-  are classified, not failed. Exits 1 on any unexplained mismatch. The reference
+  are classified, not failed. Svelte's `name_loc` is gated the same way — the name span is
+  derived from each node's own `start`/`end` + type (tag run after `<`, attribute name at
+  the node, directive head token) and both it and its line/column must match the oracle.
+  Exits 1 on any unexplained mismatch. The reference
   reconstruction a `no-locations` consumer would use. Run:
   `deno run --allow-ffi --allow-read --allow-env --allow-net --allow-sys benches/js/diagnostics/no_locations_parity.ts`
 - `diagnostics/reconstruct_vs_materialize.ts` — the **perf** sibling of the parity
diff --git a/benches/js/diagnostics/no_locations_parity.ts b/benches/js/diagnostics/no_locations_parity.ts
index 8ffc10366..f0ac10c4a 100644
--- a/benches/js/diagnostics/no_locations_parity.ts
+++ b/benches/js/diagnostics/no_locations_parity.ts
@@ -8,6 +8,12 @@
  * offsets + source, and asserts they match — so a consumer holding only the
  * no-locations wire can recover exact acorn/svelte `loc` on demand.
  *
+ * Svelte's `name_loc` gets the same treatment. Its name span isn't a node
+ * `start`/`end`, but it is a function of them plus the node type — the tag-name run
+ * after `<`, an attribute name at the node start (a shorthand `{x}` naming its
+ * braces interior), a directive's whole head token — so this file derives the span
+ * and gates both it and its line/column against the oracle wire.
+ *
  * Line rules (mirrored from `tsv_lang::LocationTracker`):
  * - TypeScript / `.ts`: ECMAScript LineTerminators — \n, \r, \r\n (ONE), U+2028,
  *   U+2029 (`new_ecmascript_with_map`).
@@ -71,40 +77,73 @@ interface Tally {
 	mismatch: number;
 	name_loc_exact: number;
 	name_loc_mismatch: number;
-	prefix_ok: number;
-	prefix_off: number;
+	name_span_exact: number;
+	name_span_mismatch: number;
 }
 
-// Svelte name offset = node.start + a fixed per-node-type prefix (the STRETCH
-// claim: the name span is derivable even without name_loc). Prefix = the bytes
-// before the name: `<` for elements, the directive keyword + `:`, `{` for shorthand.
-const NAME_PREFIX: Record<string, number> = {
-	RegularElement: 1,
-	Component: 1,
-	SvelteElement: 1,
-	SvelteComponent: 1,
-	SvelteSelf: 1,
-	SvelteWindow: 1,
-	SvelteDocument: 1,
-	SvelteBody: 1,
-	SvelteHead: 1,
-	SvelteFragment: 1,
-	SvelteBoundary: 1,
-	TitleElement: 1,
-	SlotElement: 1,
-	Attribute: 0,
-	ShorthandAttribute: 1,
-	OnDirective: 3, // on:
-	BindDirective: 5, // bind:
-	ClassDirective: 6, // class:
-	StyleDirective: 6, // style:
-	UseDirective: 4, // use:
-	TransitionDirective: 11, // transition:
-	InDirective: 3, // in:
-	OutDirective: 4, // out:
-	AnimateDirective: 8, // animate:
-	LetDirective: 4, // let:
-};
+// The Svelte name span is derivable from the node's own start/end + type, so the
+// no-locations wire keeps `name_loc` recoverable too. Re-derived here rather than
+// imported from the shipped helper (crates/tsv_wasm/npm/locations.js) — this file
+// is the independent oracle that gates it.
+
+/** Node types whose name is the tag-name run right after `<`. */
+const ELEMENT_NAME_TYPES = new Set([
+	'RegularElement',
+	'Component',
+	'SvelteHead',
+	'SvelteWindow',
+	'SvelteBody',
+	'SvelteDocument',
+	'SvelteElement',
+	'SvelteComponent',
+	'SvelteSelf',
+	'SlotElement',
+	'SvelteFragment',
+	'SvelteBoundary',
+	'TitleElement',
+]);
+
+/** Node types whose name span is the whole directive head (`on:click|preventDefault`). */
+const DIRECTIVE_NAME_TYPES = new Set([
+	'OnDirective',
+	'BindDirective',
+	'ClassDirective',
+	'StyleDirective',
+	'UseDirective',
+	'TransitionDirective', // `in:`/`out:` too — Svelte has no In/OutDirective type
+	'AnimateDirective',
+	'LetDirective',
+]);
+
+/**
+ * The chars that end an attribute/directive name run — tsv's parse of Svelte's
+ * `read_tag` (`/[\s=/>"']/`), ASCII whitespace only.
+ */
+const NAME_TERMINATORS = ' \t\n\r\v\f=/>"\'';
+
+/** The `[start, end]` offsets a node's `name_loc` covers, or null if it carries none. */
+function name_span_of(node: Record<string, unknown>, source: string): [number, number] | null {
+	const { type, name, start, end } = node as {
+		type: string;
+		name?: string;
+		start?: number;
+		end?: number;
+	};
+	if (typeof name !== 'string' || typeof start !== 'number' || typeof end !== 'number') return null;
+	if (ELEMENT_NAME_TYPES.has(type)) return [start + 1, start + 1 + name.length];
+	if (DIRECTIVE_NAME_TYPES.has(type)) {
+		let head_end = start;
+		while (head_end < end && !NAME_TERMINATORS.includes(source[head_end])) head_end++;
+		return [start, head_end];
+	}
+	if (type === 'Attribute') {
+		// a shorthand `{x}` names its braces interior, padding included (`{ x }`) —
+		// unlike a `<script>` attribute, whose literal name can itself be braced
+		if (source[start] === '{' && !source.startsWith(name, start)) return [start + 1, end - 1];
+		return [start, start + name.length];
+	}
+	return null;
+}
 
 function check_node(
 	node: Record<string, unknown>,
@@ -140,24 +179,31 @@ function check_node(
 	}
 	// Svelte name_loc: its `character` sub-field is the name offset; line/column
 	// must reconstruct from it exactly (the spine carries no pattern quirk).
-	const nl = node.name_loc as { start?: { line: number; column: number; character: number } } | undefined;
-	if (nl?.start) {
+	const nl = node.name_loc as
+		| {
+				start?: { line: number; column: number; character: number };
+				end?: { line: number; column: number; character: number };
+		  }
+		| undefined;
+	if (nl?.start && nl.end) {
 		const got = loc_at(nl.start.character, starts);
 		if (got.line === nl.start.line && got.column === nl.start.column) t.name_loc_exact++;
 		else t.name_loc_mismatch++;
-		// Report-only heuristic: the name offset ≈ node.start + a per-type prefix.
-		// Approximate (some node spans lead with a space, so this is off by one) —
-		// a consumer needing the exact name span in the no-loc wire recovers it by
-		// searching the name string within [start,end], not by a fixed prefix. Not
-		// a gate; just surfaces how close the simple rule gets.
-		const prefix = NAME_PREFIX[node.type as string];
-		if (prefix !== undefined && typeof node.start === 'number' && node.start + prefix === nl.start.character) {
-			t.prefix_ok++;
+		// The name span itself — the part a no-loc consumer has to derive, since the
+		// wire drops `name_loc` whole. Per-type rule (tag name after `<`, attribute
+		// name at the node, directive head run), gated like `loc`.
+		const span = name_span_of(node, source);
+		if (span && span[0] === nl.start.character && span[1] === nl.end.character) {
+			t.name_span_exact++;
 		} else {
-			t.prefix_off++;
+			t.name_span_mismatch++;
+			if (t.name_span_mismatch <= 5) {
+				console.error(
+					`  name span mismatch ${node.type as string} @${node.start}: got ${span ? `[${span[0]},${span[1]}]` : 'null'} want [${nl.start.character},${nl.end.character}]`,
+				);
+			}
 		}
 	}
-	void source;
 }
 
 function walk(value: unknown, starts: number[], is_svelte: boolean, source: string, t: Tally): void {
@@ -187,8 +233,8 @@ for (const language of ['typescript', 'svelte'] as Language[]) {
 		mismatch: 0,
 		name_loc_exact: 0,
 		name_loc_mismatch: 0,
-		prefix_ok: 0,
-		prefix_off: 0,
+		name_span_exact: 0,
+		name_span_mismatch: 0,
 	};
 	let checked = 0;
 	for (const f of by_lang[language] ?? []) {
@@ -215,10 +261,10 @@ for (const language of ['typescript', 'svelte'] as Language[]) {
 	);
 	if (is_svelte) {
 		console.error(
-			`  name_loc line/col: exact ${t.name_loc_exact}, MISMATCH ${t.name_loc_mismatch}; name-offset≈start+prefix (report-only): ok ${t.prefix_ok}, off ${t.prefix_off}`,
+			`  name_loc: line/col exact ${t.name_loc_exact}, MISMATCH ${t.name_loc_mismatch}; name span exact ${t.name_span_exact}, MISMATCH ${t.name_span_mismatch}`,
 		);
 	}
-	if (t.mismatch > 0 || t.name_loc_mismatch > 0) any_mismatch = true;
+	if (t.mismatch > 0 || t.name_loc_mismatch > 0 || t.name_span_mismatch > 0) any_mismatch = true;
 }
 
 if (any_mismatch) {
diff --git a/benches/js/diagnostics/reconstruct_vs_materialize.ts b/benches/js/diagnostics/reconstruct_vs_materialize.ts
index 74b97ed4f..1cb25fb69 100644
--- a/benches/js/diagnostics/reconstruct_vs_materialize.ts
+++ b/benches/js/diagnostics/reconstruct_vs_materialize.ts
@@ -22,7 +22,8 @@
  *
  * TypeScript reconstruction is EXACT (pure offset → line/col); Svelte is
  * APPROXIMATE (the `<script>` `Program` tag-position override + destructure
- * `+1`-column quirk + dropped `name_loc` — see `no_locations_parity.ts`), so its
+ * `+1`-column quirk + the in-tag comment `character` field — `name_loc` itself
+ * reconstructs exactly; see `no_locations_parity.ts`), so its
  * B path is still a valid *perf* measurement but its output isn't Svelte's exact
  * `loc`. Both are reported; the headline "reconstruct beats materialize" number is
  * the exact TS one.
@@ -148,7 +149,7 @@ for (const language of ['typescript', 'svelte'] as Language[]) {
 	if (!t || t.files === 0) continue;
 	const exactness = language === 'typescript'
 		? 'EXACT reconstruction'
-		: 'APPROXIMATE — omits name_loc + 2 quirks; see no_locations_parity.ts';
+		: 'APPROXIMATE — 2 quirks + in-tag comment shape; see no_locations_parity.ts';
 	console.log(`\n${language} (${exactness}), ${t.files} files:`);
 	console.log(`  A  full wire, loc materialized in Rust     : ${t.a.toFixed(2)}`);
 	console.log(
diff --git a/crates/tsv_svelte/CLAUDE.md b/crates/tsv_svelte/CLAUDE.md
index 8237e76ce..a23b06f26 100644
--- a/crates/tsv_svelte/CLAUDE.md
+++ b/crates/tsv_svelte/CLAUDE.md
@@ -22,7 +22,7 @@ See [../../CLAUDE.md §Project Structure](../../CLAUDE.md#project-structure) for
 - `parse(source, arena: &'arena Bump) -> Result<Root<'arena>>` — internal AST, bump-arena-allocated (caller owns the `Bump`). The Svelte parser creates the one arena per document and shares it with every embedded sub-AST — `tsv_ts` (`<script>` / `{expr}`) and `tsv_css` (`<style>`) — so the whole component is one bump-allocated graph. See [docs/architecture.md §Nested AST](../../docs/architecture.md#nested-ast-bump-arena-not-flatindexed).
 - `format(&Root, source) -> String` — round-trips through the doc builder; `format_in(&Root, source, &DocArena)` is the same into a caller-provided doc arena (multi-file drivers reuse one via `DocArena::reset()`; embedded `<style>` shares this host arena via `tsv_css::format_embedded_in`, not a second per-block one — the CSS still renders to its own string, only doc-node storage is shared)
 - `convert_ast_json_bytes(...) -> Vec<u8>`, `convert_ast_json_string(...) -> String`, and `convert_ast_json(...) -> serde_json::Value` — the public JSON AST (gated on `feature = "convert"`). The bytes variant is the **sole emission path** (FFI/CLI non-pretty; the string variant adds one output UTF-8 validation for `&str` boundaries — WASM `JSON.parse`, N-API): the writer (`ast/convert/write.rs`) walks the *internal* Svelte AST once and emits the wire JSON directly, never materializing a typed public tree, fusing byte→UTF-16 offset translation into the walk (per-language pipeline shapes: [docs/architecture.md §Closed Scope, Open Convention](../../docs/architecture.md#closed-scope-open-convention)). The Svelte spine (elements, blocks, tags, directives, attributes, `name_loc`) emits fused; embedded `<script>`/`{expr}` route through `tsv_ts`'s embedded writers and `<style>` children through `tsv_css`'s `write_css_node`. Template-expression comments (and `<script>` comments) fuse via an island-scoped attach: each comment-bearing island's wire node tree is recorded during a byte-space skeleton emit (`tsv_ts`'s `SkeletonRecorder`, driven by `ast/convert/special.rs`'s `build_*_writer_comments` — no re-parse of the emitted bytes), the acorn attach machinery in `ast/convert/comment_attachment.rs` walks the recorded tree, and the assignments fold into a span-keyed `WriterComments` the fused writer consults at each node's close (so `leadingComments`/`trailingComments` serialize in place). `convert_ast_json` is a thin wrapper (`serde_json::from_slice(&convert_ast_json_bytes(...))`) for the `Value` consumers (the CLI's `--pretty`, the fixture gate); not an independent conversion. Gated against the canonical Svelte parser's `expected.json`, including the multibyte and template-comment fixtures that exercise the fused offset translation and island-scoped attach.
-- `convert_ast_json_bytes_no_locations(...)` / `convert_ast_json_string_no_locations(...)` — the opt-in **span-only** variant: drops *every* line/column object from the Svelte wire — the acorn `loc` on `<script>`/`{expr}` nodes (via `emit_loc` threaded into the embedded `tsv_ts` writers), the root-comment `loc`, **and the element/attribute/directive `name_loc`**. Only `start`/`end` offsets remain; because that removes all line/column emission, the LF line table is never queried. A name's exact span reconstructs as `node.start + a fixed per-node-type prefix` (`<`→+1, plain attribute→+0, directive→its keyword+`:` length, shorthand→+1) plus source. Mirrors acorn's `locations: false`; a distinct narrower product, not a change to the drop-in wire (which is byte-identical). Invariant: `tests/no_locations.rs`.
+- `convert_ast_json_bytes_no_locations(...)` / `convert_ast_json_string_no_locations(...)` — the opt-in **span-only** variant: drops *every* line/column object from the Svelte wire — the acorn `loc` on `<script>`/`{expr}` nodes (via `emit_loc` threaded into the embedded `tsv_ts` writers), the root-comment `loc`, **and the element/attribute/directive `name_loc`**. Only `start`/`end` offsets remain; because that removes all line/column emission, the LF line table is never queried. `name_loc` stays derivable from a node's own `start`/`end` + type: an element names the tag run at `start + 1`, an attribute names `[start, start + name.len]` (a shorthand `{x}` its braces interior, padding included), and a directive its whole head token — the run from `start` to the first name terminator (`on:click|preventDefault`, not just `click`). The shipped `reconstruct_locations` helper (`crates/tsv_wasm/npm/locations.js`) restores it on that basis; `benches/js/diagnostics/no_locations_parity.ts` gates the derivation against the loc-bearing wire. Mirrors acorn's `locations: false`; a distinct narrower product, not a change to the drop-in wire (which is byte-identical). Invariant: `tests/no_locations.rs`.
 - `script_content_spans(&Root) -> Vec<(u32, u32)>` — byte spans of the instance/module `<script>` contents (gated on `feature = "convert"`). The writer uses it to partition comments into template-expression comments (outside the spans) vs `<script>` comments
 
 ## Distinctives
diff --git a/crates/tsv_wasm/CLAUDE.md b/crates/tsv_wasm/CLAUDE.md
index aafd96758..342b91527 100644
--- a/crates/tsv_wasm/CLAUDE.md
+++ b/crates/tsv_wasm/CLAUDE.md
@@ -85,9 +85,12 @@ rules: `reconstruct_locations(ast, source, opts?)` (one-shot, adds `loc` to ever
 node, **mutates in place**), `create_locator(source, opts?)` (amortized — holds
 the prebuilt line table, exposes `loc_of(node)` / `reconstruct(ast)`), and a bare
 `loc_of(node, source, opts?)` convenience. **Exact for TypeScript**; **approximate
-for Svelte** (doesn't recover `name_loc`, doesn't replicate the `<script>`
-tag-position or destructure `+1`-column parser quirks, and adds `loc` to template
-nodes Svelte's own wire omits); **a no-op for CSS**. It rides the **parse-capable**
+for Svelte** (doesn't replicate the `<script>` tag-position or destructure
+`+1`-column parser quirks, leaves a root in-tag comment without its `character`
+field, and adds `loc` to template nodes Svelte's own wire omits — but `name_loc`
+is restored exactly, its span derived from each node's own `start`/`end` + type,
+as is the name-shaped `loc` on shorthand-attribute identifiers, snippet names, and
+simple-identifier block patterns); **a no-op for CSS**. It rides the **parse-capable**
 packages only (`@fuzdev/tsv_parse_wasm`, `@fuzdev/tsv_wasm`) — it operates on the
 parse wire, so the format-only package has no use for it. `patch_npm_package.ts`
 copies it + the hand-written `npm/locations.d.ts` into the package root and
diff --git a/crates/tsv_wasm/README_all.md b/crates/tsv_wasm/README_all.md
index 8da8c8db5..4e8681c7c 100644
--- a/crates/tsv_wasm/README_all.md
+++ b/crates/tsv_wasm/README_all.md
@@ -37,7 +37,7 @@ const root: Root = parse_svelte('<script>const x = 1;</script>');
 
 Three formatters (`format_svelte`, `format_typescript`, `format_css`) take a source `string` and return the formatted `string`. Three parsers (`parse_svelte`, `parse_typescript`, `parse_css`) return a Svelte-compatible JSON AST; the `parse_*_json` variants return the AST as a compact JSON string instead (faster when writing to disk or the wire). For TypeScript and Svelte, `parse_{typescript,svelte}_no_locations` (and `_json_no_locations`) emit a **span-only** wire — `start`/`end` offsets, no per-node `loc` (Svelte also no `name_loc`) — ~46% smaller and faster to materialize, with line/column derivable from offsets + source. All throw on a parse error.
 
-To turn a span-only wire back into a loc-bearing one, `reconstruct_locations(ast, source)` adds `loc` to every node (mutating in place; `structuredClone` first to keep the input) — **exact for TypeScript** (each node's `loc` value equals acorn's; the key is appended last, so an object consumer matches but a re-serialized tree won't byte-match the wire's key order), **approximate for Svelte** (no `name_loc`, and it skips Svelte's `<script>`/destructure position quirks), a no-op for CSS. For sparse lookups, `create_locator(source, opts?)` reuses one line table across `loc_of(node)` / `reconstruct(ast)` calls (pass `{language: 'svelte'}` for `.svelte`); a bare `loc_of(node, source)` is also exported.
+To turn a span-only wire back into a loc-bearing one, `reconstruct_locations(ast, source)` adds `loc` to every node — and the Svelte `name_loc` — (mutating in place; `structuredClone` first to keep the input) — **exact for TypeScript** (each node's `loc` value equals acorn's; the key is appended last, so an object consumer matches but a re-serialized tree won't byte-match the wire's key order), **approximate for Svelte** (it skips Svelte's `<script>`/destructure position quirks and a root in-tag comment's `character` field; `name_loc` itself is exact), a no-op for CSS. For sparse lookups, `create_locator(source, opts?)` reuses one line table across `loc_of(node)` / `reconstruct(ast)` calls (pass `{language: 'svelte'}` for `.svelte`); a bare `loc_of(node, source)` is also exported.
 
 AST types are bundled in `tsv_ast.d.ts` and re-exported from the package — `import type` any node directly.
 
diff --git a/crates/tsv_wasm/README_parse.md b/crates/tsv_wasm/README_parse.md
index 77fca1461..9e9827ffb 100644
--- a/crates/tsv_wasm/README_parse.md
+++ b/crates/tsv_wasm/README_parse.md
@@ -47,7 +47,7 @@ const ast = reconstruct_locations(parse_typescript_no_locations(src), src);
 // every node now carries loc: {start: {line, column}, end: {line, column}}
 ```
 
-`reconstruct_locations(ast, source)` walks the tree and adds `loc` to every node, **mutating in place** and returning it (`structuredClone(ast)` first if you need the input untouched). It's **exact for TypeScript** — each node's `loc` value equals acorn's exactly (the key is appended last, so an object consumer matches but a re-serialized tree won't byte-match the wire's key order) — and **approximate for Svelte**: it doesn't recover `name_loc` and doesn't replicate Svelte's `<script>` tag-position or destructure `+1`-column parser quirks; everything else reconstructs exactly. CSS is a no-op (there's no `loc` to rebuild).
+`reconstruct_locations(ast, source)` walks the tree and adds `loc` to every node, **mutating in place** and returning it (`structuredClone(ast)` first if you need the input untouched). It's **exact for TypeScript** — each node's `loc` value equals acorn's exactly (the key is appended last, so an object consumer matches but a re-serialized tree won't byte-match the wire's key order) — and **approximate for Svelte**: it doesn't replicate Svelte's `<script>` tag-position or destructure `+1`-column parser quirks, and a root in-tag comment (`<div /* c */ class="x">`) reconstructs without the `character` field Svelte's wire gives it. Everything else reconstructs exactly, including the `name_loc` on elements, attributes, and directives — and the name-shaped `loc` Svelte reports on a shorthand attribute's identifier, a snippet name, and a simple-identifier block pattern. CSS is a no-op (there's no `loc` to rebuild).
 
 For sparse or repeated lookups, `create_locator(source, opts?)` holds the prebuilt line-start table and exposes `loc_of(node)` and `reconstruct(ast)`; pass `{language: 'svelte'}` for a `.svelte` document (LF-only line rule). A one-shot `loc_of(node, source)` is also exported for the occasional single lookup (it rebuilds the table each call).
 
diff --git a/crates/tsv_wasm/npm/locations.d.ts b/crates/tsv_wasm/npm/locations.d.ts
index b56b01a1c..25789eeb7 100644
--- a/crates/tsv_wasm/npm/locations.d.ts
+++ b/crates/tsv_wasm/npm/locations.d.ts
@@ -36,7 +36,10 @@ export interface Loc {
 export interface Locator {
 	/** Line/column for one node, or `null` if it has no numeric `start`/`end`. */
 	loc_of(node: any): Loc | null;
-	/** Add `loc` to every node in `ast`, mutating in place; returns `ast`. */
+	/**
+	 * Add `loc` to every node in `ast` — and `name_loc` to the Svelte elements,
+	 * attributes, and directives that carry one — mutating in place; returns `ast`.
+	 */
 	reconstruct(ast: any): any;
 }
 
@@ -48,8 +51,9 @@ export declare function create_locator(source: string, opts?: LocationOptions):
 
 /**
  * Add a `loc` line/column object to every node of a span-only wire, derived from
- * `start`/`end` + `source`. Mutates `ast` in place and returns it. Exact for
- * TypeScript, approximate for Svelte, a no-op for CSS.
+ * `start`/`end` + `source` — plus the Svelte `name_loc`. Mutates `ast` in place
+ * and returns it. Exact for TypeScript, approximate for Svelte (`name_loc` itself
+ * is exact), a no-op for CSS.
  */
 export declare function reconstruct_locations(ast: any, source: string, opts?: LocationOptions): any;
 
diff --git a/crates/tsv_wasm/npm/locations.js b/crates/tsv_wasm/npm/locations.js
index edf614412..656bcf097 100644
--- a/crates/tsv_wasm/npm/locations.js
+++ b/crates/tsv_wasm/npm/locations.js
@@ -3,14 +3,16 @@
  *
  * The `parse_*_no_locations` exports emit a span-only AST: every node keeps its
  * `start`/`end` (UTF-16 code-unit offsets) but drops the per-node `loc`
- * (line/column) object (Svelte also drops `name_loc`). Line/column is a pure
- * function of an offset plus the source, so a consumer holding only the span-only
- * wire recovers `loc` on demand — no re-parse. This module is that reconstruction,
- * shipped so callers don't reimplement the line rules.
+ * (line/column) object (Svelte also drops the element/attribute/directive
+ * `name_loc`). Line/column is a pure function of an offset plus the source, so a
+ * consumer holding only the span-only wire recovers both on demand — no re-parse.
+ * This module is that reconstruction, shipped so callers don't reimplement the
+ * line rules.
  *
  * Two entry points:
  * - `reconstruct_locations(ast, source)` — one-shot: build the line table once,
- *   walk the tree, add `loc` to every node, return the (mutated) ast.
+ *   walk the tree, add `loc` to every node (and `name_loc` back to the Svelte
+ *   nodes that carry one), return the (mutated) ast.
  * - `create_locator(source)` — amortized: hold the prebuilt line table and expose
  *   `loc_of(node)` (single node) and `reconstruct(ast)` (whole tree). Prefer this
  *   for heavy sparse use; the bare `loc_of(node, source)` convenience rebuilds the
@@ -29,20 +31,35 @@
  * **Svelte is approximate** — reconstruct where you have the source, but be aware
  * of three deliberate divergences from Svelte's own wire (this module does NOT
  * replicate Svelte's parser quirks):
- * - `name_loc` is not recovered — it's dropped entirely from the span-only Svelte
- *   wire, and an element/attribute/directive name span is a Svelte-specific field
- *   with no offset on the node to derive it from.
  * - The `<script>`/`<style>` `Program` `loc` is Svelte's *tag-position* override
  *   (`read_script`), not the content offset the node's `start`/`end` carry, so the
  *   reconstructed `Program` `loc` is the content position, not Svelte's.
  * - Destructure patterns in `{#each … as …}` / `{:then}` / `{:catch}` / `{@const}`
  *   carry a `+1` column in Svelte's wire (parsed under a synthetic `(`); the
  *   reconstruction is the true offset, so it reads one column earlier.
+ * - A root **in-tag** comment — one written between an element's attributes, which
+ *   Svelte's template reader collects — carries a `character` field in its `loc`.
+ *   Nothing on the span-only node distinguishes it from a `<script>` comment, so it
+ *   reconstructs in the plain `{line, column}` shape.
  * - Additionally, Svelte's own wire carries `loc` *only* on embedded ECMAScript
  *   nodes (script + template expressions); this walk adds `loc` to the template
  *   nodes (elements, text, blocks) too, so the result is a superset. Everything
  *   outside the three cases above reconstructs exactly.
  *
+ * **Svelte `name_loc` is exact.** The name span is a function of the node's own
+ * `start`/`end` + type — a tag name is the run after `<`, an attribute name starts
+ * at the node (a shorthand `{x}` names its braces interior, padding included), and
+ * a directive names its whole head token (`on:click|preventDefault`) — so the walk
+ * restores `name_loc` (`{line, column, character}` endpoints) on every element,
+ * attribute, and directive that carries one, matching Svelte's wire.
+ *
+ * That same name shape reaches a few identifiers: Svelte reports `{line, column,
+ * character}` on the ones its own reader creates — a shorthand attribute's
+ * expansion (`{x}`), a snippet name, and a simple-identifier block pattern
+ * (`{#each … as x}`, `{:then x}`, `{:catch x}`, `{@const x = …}`) — so the walk
+ * gives those the `character` field too. The one `character`-bearing shape it can't
+ * reach is the in-tag comment above.
+ *
  * **CSS is a no-op** — `parse_css` emits no `loc` (nothing to reconstruct), so
  * `reconstruct_locations` returns a CSS tree unchanged.
  *
@@ -135,23 +152,191 @@ function infer_language(ast) {
 }
 
 /**
- * Walk `value`, adding a `loc` object to every node with numeric `start`/`end`.
- * Mutates in place. Skips the `loc` key it writes so it never re-walks its own
- * output.
+ * Where a Svelte node's `name_loc` span sits, by node type — one lookup for the
+ * walk's hottest question (most nodes carry no `name_loc`, and `Identifier` has a
+ * `name` field without one):
+ * - `element` — the tag-name run right after the opening `<`.
+ * - `directive` — the whole head token (`on:click|preventDefault`: prefix, name,
+ *   and modifiers), from the node start to the first name terminator. `in:`/`out:`
+ *   are `TransitionDirective`, so they need no entry of their own.
+ * - `attribute` — the name run at the node start, or a shorthand's braces interior.
+ * @type {Map<string, 'element' | 'directive' | 'attribute'>}
+ */
+const NAME_LOC_KINDS = new Map([
+	['RegularElement', 'element'],
+	['Component', 'element'],
+	['SvelteHead', 'element'],
+	['SvelteWindow', 'element'],
+	['SvelteBody', 'element'],
+	['SvelteDocument', 'element'],
+	['SvelteElement', 'element'],
+	['SvelteComponent', 'element'],
+	['SvelteSelf', 'element'],
+	['SlotElement', 'element'],
+	['SvelteFragment', 'element'],
+	['SvelteBoundary', 'element'],
+	['TitleElement', 'element'],
+	['OnDirective', 'directive'],
+	['BindDirective', 'directive'],
+	['ClassDirective', 'directive'],
+	['StyleDirective', 'directive'],
+	['UseDirective', 'directive'],
+	['TransitionDirective', 'directive'],
+	['AnimateDirective', 'directive'],
+	['LetDirective', 'directive'],
+	['Attribute', 'attribute'],
+]);
+
+/**
+ * The chars that end an attribute/directive name run — tsv's parse of Svelte's
+ * `read_tag` (`regex_token_ending_character = /[\s=/>"']/`), whose ASCII-only
+ * whitespace set it mirrors exactly, so the derived span always agrees with the
+ * wire it reconstructs. (A Unicode space inside a name run, which Svelte's `\s`
+ * would end the run on, is the one shape where both read it as a name char.)
+ */
+const NAME_TERMINATORS = ' \t\n\r\v\f=/>"\'';
+
+/**
+ * Whether an `Attribute` is the shorthand form (`{x}`, padding included: `{ x }`),
+ * whose name is its braces interior rather than a run at the node start. A
+ * `<script>`/`<style>` attribute name is a literal run that can itself be braced
+ * (`<script {x}>`, name `{x}`), so a verbatim name at the node start is not one.
+ * @param {any} node
+ * @param {string} source
+ * @returns {boolean}
+ */
+function is_shorthand_attribute(node, source) {
+	if (typeof node.name !== 'string' || typeof node.start !== 'number') return false;
+	return source[node.start] === '{' && !source.startsWith(node.name, node.start);
+}
+
+/**
+ * The `[start, end]` UTF-16 offsets a Svelte node's `name_loc` covers, or `null`
+ * for a node type that carries none.
+ * @param {any} node
+ * @param {string} source
+ * @returns {[number, number] | null}
+ */
+function name_span_of(node, source) {
+	const kind = NAME_LOC_KINDS.get(node.type);
+	if (kind === undefined || typeof node.name !== 'string') return null;
+	if (kind === 'element') {
+		const start = node.start + 1; // the tag name follows `<`
+		return [start, start + node.name.length];
+	}
+	if (kind === 'directive') {
+		let end = node.start;
+		while (end < node.end && !NAME_TERMINATORS.includes(source[end])) end++;
+		return [node.start, end];
+	}
+	if (is_shorthand_attribute(node, source)) return [node.start + 1, node.end - 1];
+	return [node.start, node.start + node.name.length];
+}
+
+/**
+ * The `Identifier` a shorthand attribute expands to (`{x}` → `x`), or `null`.
+ * @param {any} node - a shorthand `Attribute`.
+ * @returns {any | null}
+ */
+function shorthand_identifier_of(node) {
+	// a shorthand's `value` is the bare `ExpressionTag`; a quoted value is an array
+	const tag = Array.isArray(node.value)
+		? node.value.find((v) => v?.type === 'ExpressionTag')
+		: node.value;
+	if (tag?.type !== 'ExpressionTag') return null;
+	return tag.expression?.type === 'Identifier' ? tag.expression : null;
+}
+
+/**
+ * A `name_loc` endpoint — line/column plus the offset itself, the extra
+ * `character` field Svelte's `name_loc` carries and `loc` does not.
+ * @param {number} offset
+ * @param {number[]} starts
+ * @returns {{line: number, column: number, character: number}}
+ */
+function name_loc_at(offset, starts) {
+	const { line, column } = loc_at(offset, starts);
+	return { line, column, character: offset };
+}
+
+/**
+ * Overwrite `node`'s plain `loc` with the name-shaped one, if it's an identifier.
+ * @param {any} node
+ * @param {number[]} starts
+ * @mutates node
+ */
+function stamp_name_shaped_loc(node, starts) {
+	if (node?.type !== 'Identifier' || typeof node.start !== 'number') return;
+	node.loc = { start: name_loc_at(node.start, starts), end: name_loc_at(node.end, starts) };
+}
+
+/**
+ * Give the identifiers under `node` the name-shaped `loc` — the `{line, column,
+ * character}` endpoints Svelte reports on the ones its own reader creates, rather
+ * than the plain `{line, column}` an acorn-parsed node carries. Those are a
+ * shorthand attribute's expansion (`{x}`), a snippet name, and a block pattern
+ * that is a simple identifier (`{#each … as x}`, `{:then x}`, `{:catch x}`,
+ * `{@const x = …}` — a destructure pattern takes the `+1`-column quirk instead).
+ * @param {any} node
+ * @param {number[]} starts
+ * @param {string} source
+ * @mutates node
+ */
+function stamp_character_locs(node, starts, source) {
+	switch (node.type) {
+		case 'Attribute':
+			if (is_shorthand_attribute(node, source)) {
+				stamp_name_shaped_loc(shorthand_identifier_of(node), starts);
+			}
+			return;
+		case 'SnippetBlock':
+			stamp_name_shaped_loc(node.expression, starts);
+			return;
+		case 'EachBlock':
+			stamp_name_shaped_loc(node.context, starts);
+			return;
+		case 'AwaitBlock':
+			stamp_name_shaped_loc(node.value, starts);
+			stamp_name_shaped_loc(node.error, starts);
+			return;
+		case 'ConstTag':
+			for (const d of node.declaration?.declarations ?? []) stamp_name_shaped_loc(d?.id, starts);
+	}
+}
+
+/**
+ * Walk `value`, adding a `loc` object to every node with numeric `start`/`end` —
+ * and, for a Svelte tree, a `name_loc` to every element, attribute, and directive
+ * that carries one. Mutates in place. Skips the keys it writes so it never
+ * re-walks its own output.
  * @param {any} value
  * @param {number[]} starts
+ * @param {string} source
+ * @param {boolean} is_svelte
  */
-function walk_add_loc(value, starts) {
+function walk_add_loc(value, starts, source, is_svelte) {
 	if (Array.isArray(value)) {
-		for (const v of value) walk_add_loc(v, starts);
+		for (const v of value) walk_add_loc(v, starts, source, is_svelte);
 	} else if (value && typeof value === 'object') {
 		if (typeof value.start === 'number' && typeof value.end === 'number') {
 			value.loc = { start: loc_at(value.start, starts), end: loc_at(value.end, starts) };
+			if (is_svelte) {
+				const span = name_span_of(value, source);
+				if (span) {
+					value.name_loc = {
+						start: name_loc_at(span[0], starts),
+						end: name_loc_at(span[1], starts),
+					};
+				}
+			}
 		}
 		for (const key of Object.keys(value)) {
-			if (key === 'loc') continue;
-			walk_add_loc(value[key], starts);
+			if (key === 'loc' || key === 'name_loc') continue;
+			walk_add_loc(value[key], starts, source, is_svelte);
 		}
+		// Re-stamp the identifiers Svelte gives the name-shaped `loc`, after the walk
+		// above wrote them the plain shape.
+		if (is_svelte) stamp_character_locs(value, starts, source);
 	}
 }
 
@@ -170,6 +355,7 @@ export function create_locator(source, opts) {
 	const language = opts?.language ?? 'typescript';
 	const starts = build_line_starts(source, rule_for(language));
 	const is_css = language === 'css';
+	const is_svelte = language === 'svelte';
 	return {
 		loc_of(node) {
 			if (!node || typeof node.start !== 'number' || typeof node.end !== 'number') {
@@ -179,7 +365,7 @@ export function create_locator(source, opts) {
 		},
 		reconstruct(ast) {
 			// CSS has no `loc` in the wire — nothing to reconstruct.
-			if (!is_css) walk_add_loc(ast, starts);
+			if (!is_css) walk_add_loc(ast, starts, source, is_svelte);
 			return ast;
 		},
 	};
@@ -187,9 +373,10 @@ export function create_locator(source, opts) {
 
 /**
  * Add a `loc: {start, end}` line/column object to every node of a span-only wire,
- * derived from each node's `start`/`end` offsets + `source`. Builds the line-start
- * table once, **mutates `ast` in place**, and returns it. `structuredClone(ast)`
- * first if you need the input untouched.
+ * derived from each node's `start`/`end` offsets + `source` — and, for a Svelte
+ * tree, the `name_loc` its elements, attributes, and directives carry. Builds the
+ * line-start table once, **mutates `ast` in place**, and returns it.
+ * `structuredClone(ast)` first if you need the input untouched.
  *
  * Exact for TypeScript; approximate for Svelte; a no-op for CSS — see the module
  * doc for the specifics.
@@ -200,7 +387,8 @@ export function create_locator(source, opts) {
  * @param {{language?: 'typescript' | 'svelte' | 'css'}} [opts] - line rule
  *   selector; inferred from the root node (`Root`/`Program`/`StyleSheetFile`) when
  *   omitted.
- * @returns {any} the same `ast`, now with `loc` on every node.
+ * @returns {any} the same `ast`, now with `loc` on every node (plus `name_loc` on
+ *   the Svelte nodes that carry one).
  */
 export function reconstruct_locations(ast, source, opts) {
 	const language = opts?.language ?? infer_language(ast);
diff --git a/scripts/test_npm.ts b/scripts/test_npm.ts
index 02cda4766..863ac8164 100644
--- a/scripts/test_npm.ts
+++ b/scripts/test_npm.ts
@@ -228,10 +228,15 @@ describe(`locations helper (index.js): ${pkg_dir}`, { skip: !has_parse }, () =>
 	it('reconstruct_locations matches Svelte acorn-node loc, except the documented quirks', () => {
 		// No destructure pattern here, so the Svelte +1-column quirk can't appear;
 		// the `<script>` Program loc (Svelte's tag-position override) is skipped.
-		const sv = '<script>\nconst x = 1;\n</script>\n\n<div class="a">{x}</div>';
+		// Covers each `name_loc` shape (tag name, attribute, shorthand padded and
+		// not, a directive head with modifiers) and each identifier Svelte gives the
+		// name-shaped `loc` (shorthand expansion, snippet name, block patterns).
+		const sv =
+			'<script>\nconst x = 1;\n</script>\n\n<div class="a" on:click|preventDefault={x} {x} { x }>\n\t<svelte:head><title>t</title></svelte:head>\n\t{@const y = x}\n\t{#each [x] as item}{item}{/each}\n\t{#await x}p{:then value}{value}{:catch err}{err}{/await}\n</div>\n{#snippet row(a)}{a}{/snippet}';
 		const full = node_entry.parse_svelte(sv);
 		const recon = node_entry.reconstruct_locations(node_entry.parse_svelte_no_locations(sv), sv);
 		let checked = 0;
+		let name_locs_checked = 0;
 		const walk = (r: any, f: any): void => {
 			if (Array.isArray(f)) {
 				f.forEach((x, i) => walk(r[i], x));
@@ -242,6 +247,12 @@ describe(`locations helper (index.js): ${pkg_dir}`, { skip: !has_parse }, () =>
 					assert.deepEqual(r.loc, f.loc, `loc mismatch at ${f.type}@${f.start}`);
 					checked++;
 				}
+				// `name_loc` (elements, attributes, directives) is exact — its span is a
+				// function of the node's own start/end + type.
+				if (f.name_loc) {
+					assert.deepEqual(r.name_loc, f.name_loc, `name_loc mismatch at ${f.type}@${f.start}`);
+					name_locs_checked++;
+				}
 				for (const k of Object.keys(f)) {
 					if (k === 'loc' || k === 'name_loc') continue;
 					walk(r[k], f[k]);
@@ -250,6 +261,7 @@ describe(`locations helper (index.js): ${pkg_dir}`, { skip: !has_parse }, () =>
 		};
 		walk(recon, full);
 		assert.ok(checked > 0, 'expected at least one acorn node to compare');
+		assert.ok(name_locs_checked > 0, 'expected at least one name_loc to compare');
 		// The walk is a superset: it adds `loc` to template nodes Svelte's wire omits.
 		assert.ok(recon.loc, 'reconstruct added loc to the Root (template node)');
 	});