refactor(codegen-ts): simplify template-source annotator/renderers (behavior-preserving)

annotate.ts: factor the duplicated escaped/unescaped variable-token
construction (implicit-iterator + resolve-and-push) into a single
makeVarToken helper.

render.ts: factor the repeated styled-span + optional <a href> wrapping
across the var/unescaped, section/inverted/close, and partial cases into
a single linkSpan helper.

Token IR, all rendered bytes, and every golden are byte-identical;
codegen-ts suite green at 809/809.

Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com>

Author: dmealing

server/typescript/packages/codegen-ts/src/generators/template-source-annotate.ts

@@ -132,6 +132,22 @@ export function annotateTemplate(
 		return { field, href: fieldHref(field.owner, field.name) };
 	}
 
+	// Build a variable token ({{x}} or {{&x}}/{{{x}}}). The implicit iterator
+	// `.` is always valid against the current context; any other path resolves
+	// against the enriched tree (carrying field + href when found).
+	function makeVarToken(
+		kind: "var" | "unescaped",
+		raw: string,
+		value: string,
+		stack: ResolveStack<AnnotatePayloadField>,
+	): TplToken {
+		if (value === ".") return { kind, raw, path: value, valid: true };
+		const r = resolveAt(stack, value);
+		return r
+			? { kind, raw, path: value, field: r.field, href: r.href, valid: true }
+			: { kind, raw, path: value, valid: false };
+	}
+
 	function walk(
 		tokens: Token[],
 		stack: ResolveStack<AnnotatePayloadField>,
@@ -156,48 +172,15 @@ export function annotateTemplate(
 					// {{x}} — escaped variable.
 					const raw = source.slice(start, end);
 					cursor = end;
-					if (value === ".") {
-						// Implicit iterator — always valid, references the current context.
-						out.push({ kind: "var", raw, path: value, valid: true });
-						break;
-					}
-					const r = resolveAt(stack, value);
-					out.push(
-						r
-							? {
-									kind: "var",
-									raw,
-									path: value,
-									field: r.field,
-									href: r.href,
-									valid: true,
-								}
-							: { kind: "var", raw, path: value, valid: false },
-					);
+					out.push(makeVarToken("var", raw, value, stack));
 					break;
 				}
 				case "&":
 				case "{": {
 					// {{&x}} / {{{x}}} — unescaped variable (mustache.js emits "&" for both).
 					const raw = source.slice(start, end);
 					cursor = end;
-					if (value === ".") {
-						out.push({ kind: "unescaped", raw, path: value, valid: true });
-						break;
-					}
-					const r = resolveAt(stack, value);
-					out.push(
-						r
-							? {
-									kind: "unescaped",
-									raw,
-									path: value,
-									field: r.field,
-									href: r.href,
-									valid: true,
-								}
-							: { kind: "unescaped", raw, path: value, valid: false },
-					);
+					out.push(makeVarToken("unescaped", raw, value, stack));
 					break;
 				}
 				case "#":

server/typescript/packages/codegen-ts/src/generators/template-source-render.ts

@@ -141,6 +141,17 @@ function styledSpan(style: string, inner: string): string {
 	return `<span style="${style}">${inner}</span>`;
 }
 
+/** A styled span for a token kind, wrapped in a clickable `<a href>` when the
+ *  token resolved to a link (else the bare span). The raw text is HTML-escaped. */
+function linkSpan(
+	style: string,
+	raw: string,
+	href: string | undefined,
+): string {
+	const span = styledSpan(style, escapeHtml(raw));
+	return href ? `<a href="${escapeHtml(href)}">${span}</a>` : span;
+}
+
 /**
  * The collapsed <details> "Linked view": a <pre> reproducing the template where
  * each token is an inline-styled <span> (color by kind) and each resolved
@@ -159,22 +170,19 @@ export function renderRichLinkedHtml(tokens: TplToken[]): string {
 			}
 			case "var":
 			case "unescaped": {
-				const span = styledSpan(STYLE_VAR, escapeHtml(t.raw));
-				pre += t.href ? `<a href="${escapeHtml(t.href)}">${span}</a>` : span;
+				pre += linkSpan(STYLE_VAR, t.raw, t.href);
 				break;
 			}
 			case "section":
 			case "inverted":
 			case "close": {
-				const span = styledSpan(STYLE_SECTION, escapeHtml(t.raw));
 				// Only open tags (section/inverted) carry an href; close tags don't.
 				const href = "href" in t ? t.href : undefined;
-				pre += href ? `<a href="${escapeHtml(href)}">${span}</a>` : span;
+				pre += linkSpan(STYLE_SECTION, t.raw, href);
 				break;
 			}
 			case "partial": {
-				const span = styledSpan(STYLE_PARTIAL, escapeHtml(t.raw));
-				pre += t.href ? `<a href="${escapeHtml(t.href)}">${span}</a>` : span;
+				pre += linkSpan(STYLE_PARTIAL, t.raw, t.href);
 				break;
 			}
 			case "comment": {