@px-lsp/server 0.1.0

package/src/gui/widgetInfo.ts

@@ -0,0 +1,245 @@
+/**
+ * paradox/guiWidgetInfo backend: the properties of ONE widget, with the
+ * template/type chain each value came from. This is the designer inspector's
+ * read side.
+ *
+ * Two rules keep it honest:
+ * - It addresses the widget the way the WRITER does (`findWidgetAtLine` over
+ *   the source model), so what the inspector lists is what a `setProperties`
+ *   op would rewrite, on the same line, in the same file.
+ * - It resolves the widget the way the ENGINE does (`effectiveDefs` +
+ *   `expandWidgetWithOrigins`), so it cannot list a value the canvas did not
+ *   lay the widget out with. Last-in-wins per key, exactly as the engine reads
+ *   an expanded body.
+ *
+ * Values are rendered from the parser's own tokens rather than sliced out of
+ * the document: a property inherited from a type lives in another file, whose
+ * text the def store does not keep.
+ *
+ * Three answers ride on the same expansion, so none of them can disagree with
+ * the property list: what a row OVERRIDES (the values the same key had before
+ * it), the TEXTURES the widget draws (with their frame-sheet grid), and, when
+ * the caller asks for it, the PLACEMENT trace explaining the widget's rect.
+ * The placement trace is the only one that costs a layout run, so it is the
+ * only one behind a flag.
+ *
+ * No `vscode` imports: unit-tested in plain Node.
+ */
+import type {
+  GuiPlacement,
+  GuiTextureInfo,
+  GuiWidgetInfo,
+  GuiWidgetOverride,
+  GuiWidgetProperty,
+} from "@px-lsp/protocol/protocol";
+import type { BlockNode, Statement, ValueNode } from "../parser";
+import {
+  computeGuiLayout,
+  effectiveDefs,
+  PROPERTY_BLOCKS,
+  resolveFill,
+  type Fill,
+  type PlacementExplain,
+} from "./layoutEngine";
+import { expandWidgetWithOrigins, typeBaseChain, type GuiDefs } from "./guiDefs";
+import { profileMeasurer } from "./layoutService";
+import { findWidgetAtLine, parseGuiSource, type GuiSourceFile } from "./sourceModel";
+import { describeTexture, type TextureRoots } from "./textureInfo";
+
+/** Marker words whose assignment is a named slot, not a property. */
+const SLOT_KEYS = new Set(["block", "blockoverride"]);
+
+/** Marker words that turn the FOLLOWING assignment into a declaration. */
+const DECL_MARKERS = new Set(["template", "local_template", "types", "type", "block", "blockoverride"]);
+
+export interface WidgetInfoOptions {
+  /** Run the layout with an explanation trace and fill `placement`. */
+  placement?: boolean;
+  /** Roots a texture path resolves against; without them a texture row carries
+   * the path alone (no sheet size, so no grid). */
+  roots?: TextureRoots;
+  /** Viewport the placement trace lays out against; the service's own default. */
+  viewport?: { w: number; h: number };
+}
+
+export function computeGuiWidgetInfo(
+  text: string,
+  line: number,
+  store?: GuiDefs,
+  options?: WidgetInfoOptions
+): GuiWidgetInfo | null {
+  const file = parseGuiSource(text);
+  const target = findWidgetAtLine(file, line);
+  if (!target || !target.block) return null;
+  // A template/type DECLARATION is not an instance: expanding its own name
+  // would splice the definition into itself. The canvas never selects one.
+  if (target.marker) return null;
+
+  const defs = effectiveDefs(text, store);
+  const expanded = expandWidgetWithOrigins(target.key, target.block, defs);
+
+  // Last-in-wins per key, and the winner keeps the position it was written at:
+  // inherited rows stay where the type put them, an override moves down to the
+  // instance body, which is where its bytes are.
+  const byKey = new Map<string, GuiWidgetProperty>();
+  // The same winners as raw nodes, for the readers that need structure rather
+  // than a rendering (textures, frame sheets).
+  const rawByKey = new Map<string, ValueNode>();
+  let marker: string | null = null;
+  for (const { stmt, origin } of expanded.statements) {
+    if (stmt.kind === "value") {
+      marker =
+        stmt.value.kind === "scalar" && DECL_MARKERS.has(stmt.value.text.toLowerCase())
+          ? stmt.value.text.toLowerCase()
+          : null;
+      continue;
+    }
+    const wasDecl = marker !== null;
+    marker = null;
+    if (wasDecl || !stmt.value) continue;
+    const keyLower = stmt.key.text.toLowerCase();
+    if (SLOT_KEYS.has(keyLower)) continue;
+    // The inverse rule the writer and the engine share: a block child is a
+    // widget unless its key is a known attribute block.
+    if (stmt.value.kind === "block" && !PROPERTY_BLOCKS.has(keyLower)) continue;
+    const shadowed = byKey.get(keyLower);
+    // The shadowed value is the "overrides X from template Y" note: it is the
+    // engine's own discard, recorded where the discard happens rather than
+    // reconstructed from a second walk.
+    const overrides: GuiWidgetOverride[] | undefined = shadowed
+      ? [...(shadowed.overrides ?? []), { value: shadowed.value, origin: shadowed.origin }]
+      : undefined;
+    byKey.delete(keyLower);
+    byKey.set(keyLower, {
+      key: stmt.key.text,
+      value: renderValue(stmt.value),
+      origin,
+      ...(overrides ? { overrides } : {}),
+    });
+    rawByKey.set(keyLower, stmt.value);
+  }
+
+  const info: GuiWidgetInfo = {
+    key: target.key,
+    name: nameOf(expanded.statements),
+    typeChain: typeBaseChain(target.key, [defs]),
+    properties: [...byKey.values()],
+    textures: texturesOf(rawByKey, constantsIn(file), defs, options?.roots),
+  };
+
+  if (options?.placement) {
+    // The trace is what the flag gates: an ordinary layout never records it,
+    // so the default path stays at today's cost.
+    const explain: PlacementExplain = { line: target.line };
+    computeGuiLayout(text, { defs: store, viewport: options.viewport, explain, measurer: profileMeasurer() });
+    // Placement is structurally the wire type, like LayoutNode is.
+    if (explain.result) info.placement = explain.result as unknown as GuiPlacement;
+  }
+  return info;
+}
+
+/** The widget's effective `name`, last-in-wins like every other scalar. */
+function nameOf(statements: readonly { stmt: Statement }[]): string | undefined {
+  let found: string | undefined;
+  for (const { stmt } of statements) {
+    if (stmt.kind !== "assignment" || stmt.value?.kind !== "scalar") continue;
+    if (stmt.key.text.toLowerCase() === "name") found = stmt.value.text;
+  }
+  return found;
+}
+
+/** Top-level `@name = 42` constants, which a `framesize` or `frame` may use. */
+function constantsIn(file: GuiSourceFile): Map<string, number> {
+  const consts = new Map<string, number>();
+  for (const entry of file.root.entries) {
+    if (!entry.key.startsWith("@") || entry.valueKind !== "scalar" || entry.value === null) continue;
+    const v = parseFloat(entry.value);
+    if (Number.isFinite(v)) consts.set(entry.key, v);
+  }
+  return consts;
+}
+
+/**
+ * The textures the widget draws: its own fill first, then its background. Read
+ * off the same last-in-wins winners the property list came from, and the
+ * background through the engine's own `resolveFill`, so a row here names a
+ * texture the canvas drew.
+ */
+function texturesOf(
+  raw: Map<string, ValueNode>,
+  consts: Map<string, number>,
+  defs: GuiDefs,
+  roots?: TextureRoots
+): GuiTextureInfo[] {
+  const out: GuiTextureInfo[] = [];
+  const own = raw.get("texture");
+  if (own?.kind === "scalar") {
+    const framesize = numberPair(raw.get("framesize"), consts);
+    out.push(
+      describeTexture(
+        {
+          texture: own.text,
+          framesize,
+          frame: framesize ? numberOf(raw.get("frame"), consts) : undefined,
+        },
+        "fill",
+        roots
+      )
+    );
+  }
+  const background = raw.get("background");
+  const block: BlockNode | null =
+    background?.kind === "block" ? background : background?.kind === "tagged-block" ? background.block : null;
+  if (block) {
+    const fill: Fill = resolveFill(block, consts, defs);
+    if (fill.texture !== undefined) {
+      out.push(
+        describeTexture(
+          { texture: fill.texture, framesize: fill.framesize, frame: fill.frame },
+          "background",
+          roots
+        )
+      );
+    }
+  }
+  return out;
+}
+
+function numberOf(value: ValueNode | undefined, consts: Map<string, number>): number | undefined {
+  if (value?.kind !== "scalar") return undefined;
+  if (value.text.startsWith("@")) return consts.get(value.text);
+  const v = parseFloat(value.text);
+  return Number.isFinite(v) ? v : undefined;
+}
+
+function numberPair(value: ValueNode | undefined, consts: Map<string, number>): [number, number] | undefined {
+  if (value?.kind !== "block") return undefined;
+  const nums: number[] = [];
+  for (const s of value.statements) {
+    if (s.kind !== "value" || s.value.kind !== "scalar") continue;
+    const n = numberOf(s.value, consts);
+    nums.push(n ?? 0);
+  }
+  return nums.length >= 2 ? [nums[0], nums[1]] : undefined;
+}
+
+/**
+ * A value as authored, from the tokens alone. Quoted scalars keep their quotes
+ * (`.gui` distinguishes them and the row should read like the source); a block
+ * renders with single spaces, so the rendering is independent of the interior
+ * whitespace of a file this reader may not have.
+ */
+function renderValue(value: ValueNode): string {
+  if (value.kind === "scalar") return value.quoted ? `"${value.text}"` : value.text;
+  if (value.kind === "tagged-block") return `${value.tag.text} ${renderValue(value.block)}`;
+  const parts = value.statements.map(renderStatement);
+  return parts.length === 0 ? "{}" : `{ ${parts.join(" ")} }`;
+}
+
+function renderStatement(stmt: Statement): string {
+  if (stmt.kind === "value") return renderValue(stmt.value);
+  const key = stmt.key.quoted ? `"${stmt.key.text}"` : stmt.key.text;
+  if (!stmt.value) return stmt.op === null ? key : `${key} ${stmt.op}`;
+  const value = renderValue(stmt.value);
+  return stmt.op === null ? `${key} ${value}` : `${key} ${stmt.op} ${value}`;
+}

package/src/index/docComments.ts

@@ -0,0 +1,103 @@
+/**
+ * PdxDoc doc comments (§E). A contiguous `#` comment block immediately above a
+ * definition (no blank line between) documents it. Plain lines are prose;
+ * `@tag` lines are structured.
+ *
+ * Extraction works off the raw file lines above a definition's line — no CST
+ * re-parse, encoding-safe (BOM/CRLF handled by the caller splitting on \n and
+ * this module trimming \r). Cost is near zero at index time.
+ *
+ * No `vscode` imports here: unit-tested in plain Node.
+ */
+
+/** Recognized structured tags (§E1). Unknown `@tags` render as prose. */
+export const KNOWN_DOC_TAGS = new Set(["scope", "param", "saves", "returns", "example", "deprecated"]);
+
+/** One structured tag line: `@scope`, `@param NAME desc`, `@example`, … */
+export interface DocTag {
+  /** Tag name without the leading `@` (e.g. "param", "scope"). */
+  tag: string;
+  /** Everything after the tag word (e.g. "DYNASTY_HOUSE the house…"). Empty for bare tags. */
+  text: string;
+}
+
+export interface DocBlock {
+  /** Prose lines joined; capped at PROSE_CAP. Empty string when no prose. */
+  doc: string;
+  tags: DocTag[];
+}
+
+/** Prose is capped so the index stays lean (~338 K defs on AGOT). */
+export const PROSE_CAP = 1000;
+
+/**
+ * True for a separator line — a comment that is only `#`/punctuation/repeats
+ * with no prose (`####`, `#---`, `# ===`, `# ***`). These are section dividers,
+ * not documentation, and are skipped (§E2). A line with any letter/digit after
+ * the `#` run is real prose, not a separator.
+ */
+function isSeparator(afterHash: string): boolean {
+  const t = afterHash.trim();
+  if (t === "") return false; // a blank comment line is a spacer, handled separately
+  return !/[A-Za-z0-9]/.test(t);
+}
+
+/**
+ * Parse a comment block (top-to-bottom, in file order) into prose + tags.
+ * Lines must already be stripped of their trailing \r and be `#`-comment lines
+ * (leading whitespace allowed). Separator lines are dropped.
+ */
+export function parseDocBlock(commentLines: string[]): DocBlock | null {
+  const proseParts: string[] = [];
+  const tags: DocTag[] = [];
+
+  for (const raw of commentLines) {
+    const line = raw.replace(/\r$/, "");
+    const trimmed = line.trim();
+    if (!trimmed.startsWith("#")) continue;
+    const afterHash = trimmed.replace(/^#+[ \t]?/, "");
+    if (isSeparator(trimmed.slice(1))) continue; // slice off first `#` for the check
+    if (afterHash.trim() === "") continue; // blank comment line inside the block: skip
+
+    const tagMatch = /^@([A-Za-z_][A-Za-z0-9_]*)\b[ \t]*(.*)$/.exec(afterHash);
+    if (tagMatch && KNOWN_DOC_TAGS.has(tagMatch[1].toLowerCase())) {
+      tags.push({ tag: tagMatch[1].toLowerCase(), text: tagMatch[2].trim() });
+    } else {
+      proseParts.push(afterHash.trim());
+    }
+  }
+
+  if (proseParts.length === 0 && tags.length === 0) return null;
+
+  let doc = proseParts.join(" ");
+  if (doc.length > PROSE_CAP) doc = doc.slice(0, PROSE_CAP);
+  return { doc, tags };
+}
+
+/**
+ * Given all file lines (split on `\n`, so entries may retain trailing `\r`) and
+ * the 0-based line of a definition, return its attached doc block or null.
+ *
+ * Walks upward collecting contiguous `#` comment lines. Stops at the first
+ * blank/non-comment line — a blank line detaches the block (§E2). Separator
+ * lines interrupt attachment too: a divider above the def is not documentation.
+ */
+export function docForDefinition(lines: string[], defLine: number): DocBlock | null {
+  const collected: string[] = [];
+  for (let i = defLine - 1; i >= 0; i--) {
+    const line = lines[i] ?? "";
+    const trimmed = line.replace(/\r$/, "").trim();
+    if (trimmed === "") break; // blank line detaches
+    if (!trimmed.startsWith("#")) break; // code line detaches
+    // A pure separator directly adjacent detaches the block (a divider is not doc);
+    // but a separator further up simply bounds an already-collected block.
+    if (isSeparator(trimmed.slice(1))) {
+      if (collected.length === 0) return null;
+      break;
+    }
+    collected.push(line);
+  }
+  if (collected.length === 0) return null;
+  collected.reverse();
+  return parseDocBlock(collected);
+}

package/src/index/extract.ts

@@ -0,0 +1,252 @@
+/**
+ * Schema-driven definition extraction: given a file's content and its schema
+ * entry, produce the definitions it contains. This is what the per-entry
+ * schema fixture tests exercise.
+ *
+ * No `vscode` imports here: unit-tested in plain Node.
+ */
+import type { Definition, DefSource } from "@px-lsp/protocol/types";
+import type { SchemaEntry } from "../schema/types";
+import { LineIndex, parseLoc, parseScript, walkStatements, type Statement } from "../parser";
+import { docForDefinition } from "./docComments";
+import { shareDefinitionStrings } from "./intern";
+import { activeProfile } from "../games/active";
+
+/** Max loc value length kept in memory; the edit flow re-reads the yml from disk. */
+export const LOC_VALUE_LIMIT = 200;
+
+const DEF_NAME = /^[A-Za-z0-9_][A-Za-z0-9_.-]*$/;
+export const EVENT_ID = /^[A-Za-z0-9_-]+\.\d+$/;
+const TITLE_KEY = /^[ekdcb]_[A-Za-z0-9_-]+$/;
+
+export function extractDefinitions(
+  content: string,
+  entry: SchemaEntry,
+  file: string,
+  source: DefSource
+): Definition[] {
+  const extraction = entry.extraction ?? "top-level-key";
+  if (extraction === "loc-key") return extractLocDefinitions(content, file, source);
+
+  const defs: Definition[] = [];
+  const { root } = parseScript(content);
+  const lines = new LineIndex(content);
+  // Raw lines (split on \n; entries may keep a trailing \r) for encoding-safe
+  // leading-comment capture (§E). Computed once per file, near-zero cost.
+  const rawLines = content.split("\n");
+  const push = (name: string, offset: number, container?: string) => {
+    const line = lines.positionAt(offset).line;
+    const def: Definition = { name, kind: entry.kind, file, line, source };
+    if (container !== undefined) def.container = container;
+    const block = docForDefinition(rawLines, line);
+    if (block) {
+      if (block.doc) def.doc = block.doc;
+      if (block.tags.length > 0) def.tags = block.tags;
+    }
+    defs.push(def);
+  };
+
+  // Scripted effects/triggers/modifiers can declare $PARAM$ parameters in their body.
+  const harvestParams =
+    entry.kind === "scripted_effect" ||
+    entry.kind === "scripted_trigger" ||
+    entry.kind === "scripted_modifier";
+  const PARAM = /\$([A-Za-z0-9_]+)(?:\|[^$\n]*)?\$/g;
+
+  // Names declared INSIDE a definition body but referenced like definitions
+  // elsewhere: trait `group = X` (has_trait accepts the group) and game-concept
+  // `alias = { a b }` (loc [Concept] links). Deduped per file.
+  const seenInnerNames = new Set<string>();
+
+  // Database entry modes (`REPLACE:key = { ... }`), for games whose profile
+  // declares them: index under the bare name, keep the mode on the Definition.
+  const entryModes = activeProfile().entryModes;
+  const modePrefix = entryModes?.length ? new RegExp(`^(${entryModes.join("|")}):`) : null;
+
+  switch (extraction) {
+    case "top-level-key":
+      for (const stmt of root.statements) {
+        if (stmt.kind !== "assignment" || stmt.key.quoted) continue;
+        if (stmt.op !== "=" && stmt.op !== "?=") continue;
+        let name = stmt.key.text;
+        let entryMode: string | undefined;
+        const mode = modePrefix?.exec(name);
+        if (mode) {
+          entryMode = mode[1];
+          name = name.slice(mode[0].length);
+        }
+        if (!DEF_NAME.test(name) || name === "namespace") continue;
+        push(name, stmt.key.range.start);
+        if (entryMode) defs[defs.length - 1].entryMode = entryMode;
+        if (harvestParams) {
+          const body = content.slice(stmt.range.start, stmt.range.end);
+          const params: string[] = [];
+          PARAM.lastIndex = 0;
+          let m: RegExpExecArray | null;
+          while ((m = PARAM.exec(body)) !== null) {
+            if (!params.includes(m[1])) params.push(m[1]);
+          }
+          if (params.length > 0) defs[defs.length - 1].params = params;
+        }
+        // Scripted lists generate every_/any_/random_/ordered_<name> iterators;
+        // the `base` link decides the iterated scope (scopes/model.ts consumes it).
+        if (entry.kind === "scripted_list" && stmt.value?.kind === "block") {
+          for (const s of stmt.value.statements) {
+            if (s.kind !== "assignment" || s.key.quoted || s.key.text !== "base") continue;
+            if (s.value?.kind !== "scalar" || s.value.quoted) continue;
+            defs[defs.length - 1].value = s.value.text;
+            break;
+          }
+        }
+        if (entry.kind === "trait" && stmt.value?.kind === "block") {
+          for (const s of stmt.value.statements) {
+            if (s.kind !== "assignment" || s.key.quoted || s.key.text !== "group") continue;
+            if (s.value?.kind !== "scalar" || s.value.quoted || !DEF_NAME.test(s.value.text)) continue;
+            if (seenInnerNames.has(s.value.text)) continue;
+            seenInnerNames.add(s.value.text);
+            defs.push({
+              name: s.value.text,
+              kind: "trait_group",
+              file,
+              line: lines.positionAt(s.value.range.start).line,
+              source,
+              container: name,
+            });
+          }
+        }
+        if (entry.kind === "game_concept" && stmt.value?.kind === "block") {
+          for (const s of stmt.value.statements) {
+            if (
+              s.kind !== "assignment" ||
+              s.key.quoted ||
+              s.key.text !== "alias" ||
+              s.value?.kind !== "block"
+            )
+              continue;
+            for (const el of s.value.statements) {
+              if (el.kind !== "value" || el.value.kind !== "scalar" || el.value.quoted) continue;
+              if (!DEF_NAME.test(el.value.text) || seenInnerNames.has(el.value.text)) continue;
+              seenInnerNames.add(el.value.text);
+              defs.push({
+                name: el.value.text,
+                kind: "game_concept",
+                file,
+                line: lines.positionAt(el.value.range.start).line,
+                source,
+                container: name,
+              });
+            }
+          }
+        }
+      }
+      break;
+
+    case "event-id": {
+      // Event files may also declare `scripted_trigger NAME = { ... }` /
+      // `scripted_effect NAME = { ... }` inline (file-local, but referenced
+      // like their common/ counterparts). The tolerant parser reads the
+      // keyword as a bare marker scalar followed by the NAME assignment.
+      // Scanned at EVERY depth: one tolerant-parse hiccup earlier in a
+      // thousand-line vanilla file nests everything after it inside a block,
+      // and the declarations must survive that (#5). Event ids stay
+      // top-level only — nested ids are option/trigger content, not events.
+      const scanList = (statements: Statement[], depth: number) => {
+        let inlineKind: "scripted_trigger" | "scripted_effect" | null = null;
+        for (const stmt of statements) {
+          if (stmt.kind === "value") {
+            const text = stmt.value.kind === "scalar" && !stmt.value.quoted ? stmt.value.text : "";
+            inlineKind = text === "scripted_trigger" || text === "scripted_effect" ? text : null;
+            if (stmt.value.kind === "block") scanList(stmt.value.statements, depth + 1);
+            else if (stmt.value.kind === "tagged-block") scanList(stmt.value.block.statements, depth + 1);
+            continue;
+          }
+          const marker = inlineKind;
+          inlineKind = null;
+          if (stmt.key.quoted) continue;
+          if (stmt.op === "=" || stmt.op === "?=") {
+            if (marker && DEF_NAME.test(stmt.key.text)) {
+              const line = lines.positionAt(stmt.key.range.start).line;
+              const def: Definition = { name: stmt.key.text, kind: marker, file, line, source };
+              const block = docForDefinition(rawLines, line);
+              if (block) {
+                if (block.doc) def.doc = block.doc;
+                if (block.tags.length > 0) def.tags = block.tags;
+              }
+              const body = content.slice(stmt.range.start, stmt.range.end);
+              const params: string[] = [];
+              PARAM.lastIndex = 0;
+              let m: RegExpExecArray | null;
+              while ((m = PARAM.exec(body)) !== null) {
+                if (!params.includes(m[1])) params.push(m[1]);
+              }
+              if (params.length > 0) def.params = params;
+              defs.push(def);
+            } else if (depth === 0 && EVENT_ID.test(stmt.key.text)) {
+              push(stmt.key.text, stmt.key.range.start);
+            }
+          }
+          if (stmt.value?.kind === "block") scanList(stmt.value.statements, depth + 1);
+          else if (stmt.value?.kind === "tagged-block") scanList(stmt.value.block.statements, depth + 1);
+        }
+      };
+      scanList(root.statements, 0);
+      break;
+    }
+
+    case "nested-title":
+      // Landed titles nest: e_empire { k_kingdom { d_duchy { c_county { b_barony } } } }
+      walkStatements(root, (stmt: Statement, ancestors) => {
+        if (stmt.kind !== "assignment" || stmt.key.quoted) return;
+        if (!TITLE_KEY.test(stmt.key.text)) return;
+        if (stmt.value?.kind !== "block") return;
+        // Container: the nearest ancestor assignment that is itself a title.
+        let container: string | undefined;
+        for (let i = ancestors.length - 1; i >= 0; i--) {
+          const a = ancestors[i];
+          if (a.kind === "assignment" && TITLE_KEY.test(a.key.text)) {
+            container = a.key.text;
+            break;
+          }
+        }
+        push(stmt.key.text, stmt.key.range.start, container);
+      });
+      break;
+
+    case "gui-type": {
+      // GUI: `type NAME = base { ... }`, `template NAME { ... }` and
+      // `local_template NAME { ... }`. The tolerant parser reads these as a bare
+      // marker scalar statement followed by an assignment whose key is the NAME.
+      // `types Group { ... }` wraps the `type` pattern one level down.
+      const scan = (statements: Statement[]) => {
+        for (let i = 0; i < statements.length - 1; i++) {
+          const marker = statements[i];
+          if (marker.kind !== "value" || marker.value.kind !== "scalar" || marker.value.quoted) continue;
+          const kw = marker.value.text.toLowerCase();
+          if (kw !== "type" && kw !== "template" && kw !== "local_template" && kw !== "types") continue;
+          const named = statements[i + 1];
+          if (named.kind !== "assignment" || named.key.quoted) continue;
+          if (kw === "types") {
+            if (named.value?.kind === "block") scan(named.value.statements);
+          } else if (DEF_NAME.test(named.key.text)) {
+            push(named.key.text, named.key.range.start);
+          }
+        }
+      };
+      scan(root.statements);
+      break;
+    }
+  }
+  // Every string above is a slice of `content` and would pin the whole file for
+  // as long as the index holds the definition (§C2).
+  return shareDefinitionStrings(defs);
+}
+
+export function extractLocDefinitions(content: string, file: string, source: DefSource): Definition[] {
+  const defs: Definition[] = [];
+  for (const entry of parseLoc(content).entries) {
+    let value = entry.value;
+    if (value.length > LOC_VALUE_LIMIT) value = value.slice(0, LOC_VALUE_LIMIT);
+    defs.push({ name: entry.key, kind: "loc_key", file, line: entry.line, source, value });
+  }
+  return shareDefinitionStrings(defs);
+}