# Lua + Luau kernel port (R7b batch 4) — the bug-for-bug checklist

**Status: SURVEY COMPLETE (2026-07-20)** — one combined checklist for BOTH
languages: `languages/luau.ts` is 36 lines extending `languages/lua.ts`, the two
grammars share their node-name vocabulary, and the recommendation is ONE walker
module (`codegraph-kernel/src/lua.rs`, ccpp-style language-parameterized —
`"lua" | "luau" => lua::extract(&file_path, &content, &language)` in
lib.rs:214-226). Survey basis: every TS-side branch a `.lua`/`.luau` file
exercises, with file:line anchors as of **`45a53eb`** (HEAD at survey time,
clean main). Every grammar-shape claim was **probed against the production
vendored wasms** (`dist/extraction/wasm/tree-sitter-{lua,luau}.wasm`) via CST
dumps and childForFieldName truth tables, and every extraction-behavior claim
was **pinned against the real `dist/` extractor** (`extract-*.txt` ground-truth
dumps in the session scratchpad `svy-lua/` — §Probe artifacts), not derived
from code reading alone. Read WITH
`docs/design/rust-kernel-migration-plan.md` (§0a recipe, §2 boundary, §4
tracker, §5 gates) and the format precedents
(`kotlin-kernel-port-checklist.md` — the depth bar — plus
`swift-kernel-port-checklist.md`, `ruby-kernel-port-checklist.md`).

**Blocking findings: none.** Three eyes-open items. (1) **No grammar bump at
all** — both languages are already in `VENDORED_WASM_LANGS` (grammars.ts:292)
and the vendored wasms are the exact port-target revisions
(`../scratchpad/batch4-grammar-probe.md`, verified 2026-07-20: lua = the
v0.4.1 tag, table-identical; luau = crate 1.2.0, table-identical). The port is
kernel-side only: lua takes the **vendored-grammar-C route** (kotlin
mechanism, second use) because v0.4.1 is not on crates.io; luau is a plain
**crate pin `tree-sitter-luau = "=1.2.0"`** (csharp-style), and the crate
tarball's parser.c/scanner.c are **sha-identical to the v1.2.0 tag**
(§Grammar prep — the swift tag≠crate divergence does NOT recur here). (2)
**Error incidence is near-zero for lua** (kong 0.08% — a single deliberately
invalid fixture; lazy.nvim and lua-resty-core 0.00%) — ruby-style: **any
deferral on a lua sweep is a walker-bug signal**. Luau real-world incidence is
**1.4–7.1%** (lune 1.36%, Fusion 7.08%), driven by two grammar-inherent
shapes — generic type packs `(A...) -> T` and default type parameters
`<T = D>` — both-arm by construction (same grammar revision on both arms).
(3) The single biggest bug-for-bug surface is the **require/`visitNode`-hook
machinery** and its **asymmetries**: requires at top level (anywhere visitNode
reaches, including inside top-level `if`/`for`/`while` blocks) become `import`
nodes, while the IDENTICAL statement inside a function body emits a
**`calls "require"` ref** (visitFunctionBody never runs the hook); a top-level
`local x = foo()` initializer emits **no** calls ref while a top-level global
assignment `x = foo()` **does** (§extractVariable). Get these exactly wrong
and sweeps light up on file one.

## Grammar prep (kernel-side only — no wasm change, no bump gate)

Both languages already ship vendored wasms (`VENDORED_WASM_LANGS`,
grammars.ts:291-293; file map `lua: 'tree-sitter-lua.wasm'` /
`luau: 'tree-sitter-luau.wasm'` at grammars.ts:39,41; the :255 comment
records WHY lua was vendored — tree-sitter-wasms' ABI-13 build corrupted the
shared WASM heap). Provenance was verified in the batch-4 grammar probe
(`../scratchpad/batch4-grammar-probe.md`) and re-verified in this survey:

- **lua** — vendored wasm ≡ **tree-sitter-grammars/tree-sitter-lua v0.4.1**,
  tag commit `816840c592ab973500ae9750763c707b447e7fef` (release asset
  table-identical, 0 positional mismatches). Tag parser.c declares
  **ABI 15, STATE_COUNT 262, SYMBOL_COUNT 137, FIELD_COUNT 22** (verified in
  the tag clone — matches the wasm's tables). **v0.4.1 is NOT on crates.io**
  (only 0.1/0.2/0.5 exist) → **vendored-grammar-C route**, the kotlin
  mechanism (`codegraph-kernel/grammars/kotlin` + build.rs cc precedent).
  0.5.0 adds Lua-5.5 `global` (+1 field) — a future accuracy bump, NOT this
  batch.
- **luau** — vendored wasm ≡ **tree-sitter-grammars/tree-sitter-luau v1.2.0
  ≡ crates.io crate 1.2.0**. Survey-verified sha match, tag ↔ crate tarball
  (the swift lesson checked and CLEAR):
  - `src/parser.c` `8f25bc1779400fa93d5492310e291fb895363ec051d44753444e724e99a08250` (both)
  - `src/scanner.c` `a157bb5210454add058a08ce53eabcccad41aab6dac7006def2554e5cfebd376` (both)
  Tag commit `a8914d6c1fc5131f8e1c13f769fa704c9f5eb02f`. parser.c declares
  **ABI 14, STATE_COUNT 585, SYMBOL_COUNT 197, FIELD_COUNT 21**. Crate deps:
  `tree-sitter-language = "0.1"` + `cc` build-dep, `tree-sitter` only as a
  dev-dep (0.26.3) → **no pin conflict** with the kernel's tree-sitter 0.25.
  Route: **`tree-sitter-luau = "=1.2.0"`** in codegraph-kernel/Cargo.toml,
  `"luau" => Some(tree_sitter_luau::LANGUAGE.into())` in langs.rs.
- **Lua kernel C vendor** (`codegraph-kernel/grammars/lua/`), from the v0.4.1
  tag's CHECKED-IN generated artifacts (lua HAS an external scanner — comments
  and long strings):
  - `src/parser.c`  `b34a362e43f0311f405721f3089e94f97f31da403b154d456d093e64609a4081`
  - `src/scanner.c` `35bbd630b5a7421d46d2e91185eeea09bf78565d44cb676b63ca20d0f1b54bbd`
  - `src/tree_sitter/alloc.h`  `b29c1c9fb7cc82f58c84b376df1297d6e2737a1d655fd356db0859e3c29c2fea`
  - `src/tree_sitter/array.h`  `5bdf6ed1a78e3409fd443e085ca967a64c188a5d082aaf7f819bccd53a471c94`
  - `src/tree_sitter/parser.h` `180b893c8734778fd32f372dfbc27bd6ad1cd2221f26150b31256ff6716320d2`
  build.rs: extend the kotlin block — `cc::Build` with
  `include("grammars/lua")`, `file(parser.c)`, `file(scanner.c)`; crib the
  tag's own `bindings/rust/build.rs` flags (`.std("c11")`, include src, msvc
  `-utf-8`); `println!("cargo:rerun-if-changed=grammars/lua")`. langs.rs:
  `extern "C" { fn tree_sitter_lua() -> *const (); }` +
  `"lua" => Some(unsafe { tree_sitter_language::LanguageFn::from_raw(tree_sitter_lua) }.into())`
  (kotlin precedent, langs.rs:17-20,57). `LANGUAGES: [&str; 15]` → **17**
  (langs.rs:24).
- **Grammar-parity rows**: `__tests__/kernel-grammar-parity.test.ts:39`
  `GRAMMAR_LANGUAGES += 'lua', 'luau'` — asserts the C build / crate and the
  vendored wasm are the same revision (id-by-id kind+field tables, ABI 15 for
  lua / ABI 14 for luau). This replaces the bump gate entirely: there is no
  old-vs-new dump-diff because nothing wasm-side changes.
- **Error incidence** (current wasm, all files ≤1MiB, `error-sweep.cjs`):

  | Repo | lang | files | hasError | phantoms | first-error classes |
  |---|---|---|---|---|---|
  | Kong/kong | lua | 1,309 | 1 (0.08%) | 0 | `spec/fixtures/invalid-module.lua` — deliberately invalid |
  | folke/lazy.nvim | lua | 65 | 0 (0.00%) | 0 | — |
  | openresty/lua-resty-core | lua | 38 | 0 (0.00%) | 0 | — |
  | lune-org/lune | luau | 221 | 3 (1.36%) | 0 | `.d.luau` type-pack/typeof declaration shapes |
  | dphfox/Fusion | luau | 113 | 8 (7.08%) | 0 | generic type packs `(A...) -> T`; default type params `type Scope<C = Fusion>` |
  | luau-lang/luau (tests/) | luau | 203 | 39 (19.21%) | 0 | STRESS ONLY — deliberate future-syntax tests (`class Point`, `123i`, `export local`) |
  | JohnnyMorganz/StyLua (tests/) | lua | 419 | 118 (28.16%) | 0 | STRESS ONLY — cfxlua dialect (`+=`, C comments), luau-in-.lua corpora |

  **ZERO phantom-hasError files anywhere** (hasError with no ERROR/missing
  node — probed per-file across all 2,368 files, plus 31 targeted snippet
  probes in `mini-probes-{lua,luau}.out`): unlike kotlin, the defer signal is
  always accompanied by a real ERROR node. Still gate on `has_error()` alone —
  don't scan for ERROR nodes. Error-class probes (`errclass*.luau`): luau
  default type parameters `type X<T = D>` and generic packs `(A...) -> T`
  ERROR; luau also rejects `@native`/`@checked` attributes (real-Luau 2024+
  syntax the 1.2.0 grammar predates) and lua-only syntax (`goto`, bitwise
  `a & b`); lua rejects luau-isms (`type X = …`, `continue`, `+=`, backtick
  interpolation) — cfxlua dialect files land here too. All of these defer to
  wasm, which errors identically (same tables both arms) and still emits its
  best-effort partial extraction.
- Sweep defaults: `--max-deferral 0.1` (kernel-parity.mjs:38) holds
  everywhere. Expect **0–1 deferrals on lua** repos (treat >0 as suspicious,
  ruby-style) and **1.4–7.1% on luau** (typed-framework codebases sit at the
  high end; a JUMP past ~10% is the bug signal).

## Architecture decisions

1. **One walker module, two grammar entries.** `codegraph-kernel/src/lua.rs`
   with a dialect flag (ccpp precedent — lib.rs:219 `"c" | "cpp" =>
   ccpp::extract(..., &language)`). The dialect differences are exactly four
   (§Extractor config): typeAliasTypes, isExported, getSignature return
   suffix, grammar handle. Everything else — require hook, receiver methods,
   variable branch, call shapes, docstrings, fn-refs — is byte-shared.
   **go.rs is the closest crib** (receiver-QN methods, extract_type_alias →
   bool, `node_ids` vec, fn-ref flush deduped on `node_ids[from]` go.rs:1047).
2. **No preParse** (neither lua.ts nor luau.ts has the hook; luau spreads
   lua) → `preParsedSource` (kernel/index.ts:109-112) is a no-op; both arms
   parse raw bytes. **No POST_PASSES entry** → `tryKernelExtractRaw` stays
   eligible (kernel/index.ts:183).
3. **No framework resolver lists lua/luau** (grepped
   `src/resolution/frameworks/*` — zero hits) → no decoded-path forcing in
   parse-worker; all repos ride the raw buffers-to-store transport. No
   synthesis consumer either: `CC_LANGUAGES = {swift, kotlin}`
   (callback-synthesizer.ts:77), `NATIVE = {java, kotlin, objc, cpp}`
   (:1649). The only downstream consumers are resolution-side and
   contract-pinned in §Resolution consumers.
4. **`.lua` → `lua`, `.luau` → `luau`** purely by extension
   (grammars.ts:122-123, `detectLanguage` :469 — no content sniffing; project
   `codegraph.json` extension overrides are TS-side and upstream of the
   kernel). MAX_FILE_SIZE (1 MiB) and generated-file skips are
   orchestrator-side and shared.
5. **REF_FLAG_FILE_PATH (wire v2) is NOT needed.** The lua hook's
   `addUnresolvedReference` (lua.ts:117-123) passes no `filePath`; zero refs
   in any ground-truth dump carried one. The ruby/php bit stays unused.
6. **Value-refs, static-member refs, type-annotation refs, instantiates,
   extends/implements, decorates: ALL structurally absent** for lua/luau —
   §Dead machinery. The walker needs cheap early-outs that preserve exactly
   this nothing.
7. **Deferral policy**: per-file `has_error()` → `defer:` (ruby.rs:143
   message convention). Expected counts per §Grammar prep. wasm recovery is
   canonical for erroring files (incl. the cfxlua/`@native` dialect files).

## Extractor config (languages/lua.ts — 152 lines; languages/luau.ts — 36 lines; read both whole)

`luauExtractor = { ...luaExtractor, <4 overrides> }` (luau.ts:16-36).

Shared types (lua.ts:62-81): functionTypes=[`function_declaration`] (covers
global `function f`, `local function f`, table `function t.f`, method
`function t:m` — ONE node type, form distinguished by the `name:` child;
anonymous `function() end` is `function_definition`, NOT in the list);
classTypes=[] ; methodTypes=[] ; interfaceTypes=[]; structTypes=[];
enumTypes=[]; importTypes=[] (`require` is a function_call — the hook);
callTypes=[`function_call`]; variableTypes=[`variable_declaration`];
nameField=`name`, bodyField=`body`, paramsField=`parameters`.

Luau overrides (luau.ts:20-35): typeAliasTypes=[`type_definition`] (lua: []);
**isExported** = `source.slice(node.startIndex, node.startIndex + 7) ===
'export '` (raw UTF-16 slice of the node's own first 7 chars — `export type X`
nodes START at `export`, probed); **getSignature** = params text + `: <text of
the named child AFTER parameters>` unless that child's type is `block`
(finds params by `startIndex` match in `namedChildren`, so a leading
`generic_type_list` never disturbs it — probed `(v: T): T`).

Hooks PRESENT (port each exactly):

- **visitNode (lua.ts:105-151)** — the require machinery, §Require hook.
- **getSignature (lua.ts:83-86)** — lua: `getChildByField(node,
  'parameters')` text or undefined. Probed: `(a, b)`, `(...)`, `()`.
  (Luau override above; both read the REAL `parameters` field —
  FIELD_COUNT is non-zero here, unlike kotlin: field lookups are LIVE.)
- **getReceiverType (lua.ts:92-99)** — `name:` field child of type
  `dot_index_expression` → its `table:` field text; `method_index_expression`
  → its `table:` field text; else undefined. The table text is VERBATIM
  dotted source: `function M.sub.deep:chained()` → receiver `M.sub.deep`
  (probed). Plain `function f` / `local function f` (name is `identifier`) →
  undefined.

Hooks ABSENT (the walker must NOT invent them): `preParse`, `resolveName`,
`recoverMangledName`, `isMisparsedFunction`, `isConst` (**every
lua/luau variable is kind `variable` — `constant` never occurs**),
`isAsync`/`isStatic` (**both undefined on every node** — flag present-bits
stay 0; NOT kotlin's literal false), `getVisibility` (undefined — visibility
byte 0), `getReturnType` (**returnType never set** — luau return types ride
the SIGNATURE string only), `extractModifiers` (no decorators ever),
`classifyClassNode`, `classifyMethodNode`, `extractPropertyName`,
`propertyTypes`, `fieldTypes`, `enumMemberTypes`, `extraClassNodeTypes`,
`packageTypes`/`extractPackage` (**no namespace node, ever** — QNs never get
a package prefix), `resolveBody` (**body = `getChildByField(node, 'body')`
only**; empty one-liner `function f() end` has NO body field — probed
`field-truth.out` — so no body walk and no endLine extension; the
createNode:1329-1334 extension is structurally a no-op since
function_declaration's extent includes `end`), `extractImport`,
`extractBareCall`, `synthesizeMembers`, `skipBodilessClass`,
`methodsAreTopLevel`, `resolveTypeAliasKind`, `interfaceKind`,
`isExported` for LUA (undefined — see the wire note in §Parity mechanics).

## tree-sitter.ts branches (anchors as of `45a53eb`)

### visitNode dispatch — what each lua/luau node hits (ladder at 936-1303)

| Node | Branch | Behavior |
|---|---|---|
| every node | visitNode hook first (943-953) | `function_call` that IS a require → import + ref, handled=true → `scanFnRefSubtree` + STOP; non-require function_call → false, falls to :1248; `variable_declaration` → emits imports for require initializers, ALWAYS returns false (falls through to variableTypes) |
| every node | maybeCaptureFnRefs (990) | fires for `arguments` / `assignment_statement` / `field` (LUA_SPEC keys) — top-level table registries and call args captured here |
| `function_declaration` | functionTypes:994 | `isInsideClassLikeNode()` is ALWAYS false (no class-like kinds exist; :1486-1500 checks the STACK TOP only, and lua mints only file/function/method/variable/import/type_alias) → extractFunction:1517, whose :1522 receiver short-circuit diverts `function t.f`/`t:m` to extractMethod:1737. skipChildren |
| `variable_declaration` | variableTypes:1098 | gate `!isInsideClassLikeNode() ∥ isClassScopeConstantAssignment` — always passes (first leg). extractVariable:2538 → lua branch :2789. Then `scanFnRefSubtree(node, 0)` (:1110) + skipChildren → **initializer subtrees are NEVER walked** (§extractVariable) |
| `type_definition` (luau) | typeAliasTypes:1071 | extractTypeAlias:2890 → plain path :2967 (no resolveTypeAliasKind) → **returns false → children ARE re-visited** — how `typeof(require(...))` aliases emit an import (§Luau type aliases). Lua: no branch → recursed |
| `function_call` (hook-declined) | callTypes:1248 | extractCall:3684. NO skipChildren → children recursed → nested/inner calls each get their own ref (glued chains, `f()()`) |
| `assignment_statement` (top level) | **no branch** | maybeCaptureFnRefs('assignment_statement') → RHS candidates; then plain recursion → initializer calls DO emit (`globalAssign = topFn(10)` → calls topFn — pinned), anon `function_definition` RHS bodies are walked with the FILE as caller |
| `update_statement` (luau `+=`) | **no branch, no dispatch key** | recursed → RHS calls emit; no fn-ref capture (dispatch has no update_statement key) |
| `return_statement` / `if_statement` / `for_statement` / `while_statement` / `do_statement` (top level) | no branch | recursed → nested variable_declarations/function_calls dispatch normally — **top-level conditional requires become imports; block-locals become top-level variable nodes** (pinned `extract-condreq`: `if ok then local m = require("in.if") end` → import in.if + variable m, both contained by FILE) |
| `comment` | no branch | recursed into `content:` — nothing matches. Consumed only by getPrecedingDocstring |
| `hash_bang_line` (`#!` line 1, lua) | no branch | parses clean (probed); not a comment kind → BREAKS a docstring chain scanning past it |
| INSTANTIATION_KINDS (354-361) / `impl_item`:1274 / `property_signature`:1282 / export_statement:1219 / swift property:1121 | never | no lua/luau node kinds among them. **Zero `instantiates` refs, ever** |

### The require hook (lua.ts:105-151 + requireModule :28-60) — port verbatim

`requireModule(callNode)`: `name:` field child must be type `identifier` with
text exactly `require` (a dotted callee is dot/method_index — never require);
`arguments:` field child required. Then, in ORDER:

1. **String win, breadth-first**: `findDescendant(args, 'string_content')`
   (BFS over namedChildren, lua.ts:9-17) → trimmed text. This catches plain
   `require("a.b")`, single-quote and `[[...]]` requires (string_content is
   inside the string node), **and any require whose argument merely CONTAINS
   a string anywhere** — pinned: `require(script:WaitForChild("Kid"))` →
   import **"Kid"** (the string beats the method-index path);
   `require("a" .. "b")` → import **"a"** (first string_content in BFS
   order — deterministic garbage, preserve).
2. Fallback `findDescendant(args, 'string')` with manual `[[ ]]`/quote
   stripping (reached only if a string node had no content child — empty
   string `require("")` → mod falsy → null).
3. **Roblox instance path**: first descendant `dot_index_expression` (else
   `method_index_expression`) → its `field:` (else `method:`) child text —
   `require(script.Parent.Signal)` → **"Signal"** (the trailing segment).
4. Otherwise null (`require(dynName)`, `require()`).

Hook dispatch (lua.ts:129-150):

- `node.type === 'function_call'`: requireModule ≠ null → `emit(node)` +
  **return true** (claimed — never double-counted as a call); null → return
  false → extractCall emits **`calls "require"`** (pinned:
  `require(dynamicTop)` at top level → calls require from FILE).
- `node.type === 'variable_declaration'`: find the `assignment_statement`
  child → its `expression_list` → for EVERY child of type `function_call`,
  `emit(val)` (multi-require `local a, b = require("x"), require("y")` → two
  imports — pinned). **Always returns false** → extractVariable also runs.
  NOT emitted from here: requires nested deeper in the initializer
  (`{ mod = require("t") }` table value — pinned NO import), and
  `require("m").field` (the exprList child is dot_index_expression — pinned
  NO import; the `accessed` variable still mints).
- `emit(callNode)`: `ctx.createNode('import', mod, callNode, { signature:
  getNodeText(callNode).trim().slice(0, 100) })` — import node **positioned
  at the CALL node** (name = module string, qualifiedName = same via
  buildQualifiedName, id line = call's line) — then, if the stack is
  non-empty, `addUnresolvedReference({ fromNodeId: stack top (always the
  FILE node), referenceName: mod, referenceKind: 'imports', line: call
  startRow+1, column: call startColumn })`. No filePath on the ref.
- **The hook NEVER runs inside function bodies** (visitFunctionBody has no
  hook call — §visitFunctionBody): body-level `local lazy =
  require("app.lazy")` emits **`calls "require"` from the enclosing
  function** and NO import (pinned, `extract-bodies-lua.txt` L8-9 — the
  neovim lazy-loading idiom lands here). Port this asymmetry exactly.

### Node creation, IDs, qualified names

- createNode (1308): id = `generateNodeId(filePath, kind, name, startRow+1)`
  = `` `${kind}:${sha256(`${filePath}:${kind}:${name}:${line}`).hex.slice(0,32)}` ``
  (tree-sitter-helpers.ts:18-30). FILE node id = literal `file:${filePath}`
  (:509), name = basename, qualifiedName = filePath, endLine =
  `source.split('\n').length`, isExported false.
- **No namespace node** (no packageTypes → extractFilePackage:1397 returns
  null). buildQualifiedName (1447-1460) joins the NON-file stack nodes' NAMES
  with `::` — top-level symbols get bare QNs.
- **Receiver-QN override**: table/method functions get `extraProps.
  qualifiedName = composeReceiverQualifiedName(receiver, name)` (1790-1792) =
  `` `${receiverType}::${name}` `` verbatim (1435-1442; namespacePrefix
  always empty outside C++). Pinned QNs: `M::create`, `M.sub.deep::chained`,
  `_G::installed` (yes — `function _G.installed()` mints method
  `_G::installed`). The override REPLACES the stack QN even for nested
  declarations: `function M.attached()` inside a body → `M::attached`, NOT
  `render::attached` (pinned).
- **Nested plain functions** get stack QNs from node NAMES: `local function
  inner()` inside `M:render` → `render::inner` (the method's NAME, not its
  `M::render` QN — buildQualifiedName reads `node.name`); a GLOBAL
  `function leakedGlobal()` declared inside a body is still stack-scoped →
  `render::leakedGlobal` (pinned — quirk, preserve).
- **Variable nodes are positioned at the IDENTIFIER**, not the declaration
  (§extractVariable) — id line/column = the identifier's.
- contains edge from stack top for every created node (1363);
  extractModifiers merge (1355-1358) inert (no hook); captureValueRefScope
  (1374) runs but its output is discarded (§Dead machinery).
- **Duplicate IDs are legal output**: `local x = 1; local x = 2` on one line
  → two `variable:x` rows with the SAME id (pinned, mini-probes
  `sameLineTwoLocals`) — minified/one-liner lua bundles hit this routinely.
  The walker emits both rows verbatim (`node_ids` vec pattern; store upsert
  handles collapse — parity compares pre-store output).

### extractFunction (1517) / extractMethod (1737)

- extractFunction: **:1522 receiver short-circuit is THE routing** —
  getReceiverType ≠ undefined (name is dot/method_index_expression) →
  extractMethod. extractName (:97-192): nameField `name` field hit → :136-143
  unwraps `dot_index_expression → field:` / `method_index_expression →
  method:` → the trailing simple name (`dotted`, `method`, `chain`).
  `<anonymous>` unreachable for function_declaration (grammar requires a
  name; `function_definition` never reaches extractFunction — it's in no
  type list).
- Extras (:1574-1580): docstring (§Docstrings), signature (getSignature),
  visibility undefined, **isExported: lua undefined / luau false** (hook
  slice — a function_declaration never starts with `export `), isAsync
  undefined, isStatic undefined, returnType undefined.
  extractTypeAnnotations (:1594) → early-out (§Dead machinery);
  extractDecoratorsFor (:1599) → scans children/preceding siblings for
  decorator/annotation/attribute kinds — lua's `attribute` node (`<const>`)
  lives inside variable_list, NEVER adjacent to a function → structurally
  zero output (keep the traversal or early-out equivalently — output is
  what's pinned).
- Body: `resolveBody?.() ?? getChildByField(node, 'body')` → the `body:`
  block (absent on empty one-liners) → visitFunctionBody with the node
  pushed.
- extractMethod: receiverType recomputed (1742); gate :1747 passes via
  receiver. Same extras (NOTE: extractMethod passes NO isExported — **luau
  METHODS have isExported undefined while luau functions have false**;
  pinned in `extract-torture-luau.txt`: `method "make"` no flag,
  `function "typedTop"` isExported=false). QN override :1790-1792.
  **Owner-contains (:1799-1813) NEVER fires**: it requires an in-file node
  named `receiverType` with kind ∈ {struct, class, enum, trait} — lua mints
  none of those kinds, and dotted receivers (`M.sub.deep`) match no node
  name anyway. The ONLY containment is the normal stack-top edge (pinned:
  `contains file → method:dotted`, `contains method:render →
  method:attached`).

### extractVariable — the lua/luau branch (2538-2549 head; 2789-2805 branch)

Head: isConst absent → kind ALWAYS `variable` (:2546-2547); docstring from
the DECLARATION node (:2548); `isExported = hook ?? false` (:2549) → **false
for both languages** (luau's slice sees `local …`).

Branch (:2789-2805): `assign` = first namedChild of type
`assignment_statement` ?? node itself (covers bare `local x` with no `=`);
`varList` = assign's `variable_list` child; `exprList` = assign's
`expression_list` child; `names` = varList's children of type `identifier`
ONLY (a `dot_index_expression`/`bracket_index_expression` LHS — possible only
in bare assignment_statements, which never reach here — and `attribute` nodes
(`<const>`/`<close>`) are skipped without disturbing positions); `values` =
exprList's namedChildren. Per name, **positionally paired**:

- `createNode(kind, name, nameNode, …)` — **positioned at the IDENTIFIER**
  (pinned: `variable "http" L2 C6-10`).
- signature = `` `= ${valueText.slice(0,100)}${'...' if ≥100}` `` from
  `values[i]`; **no value at that index → NO signature key at all** (pinned:
  `local ok, err = pcall(...)` → `ok` has the signature, `err` has none).
  Signatures keep raw bytes verbatim — embedded `\n` (`= [[long\nstring]]`),
  CRLF `\r\n`, the full anon-function text (`= function(v)\n\treturn
  hidden(v)\nend`).
- docstring and isExported repeated onto EVERY name of the declaration.

Then the ladder (:1110-1111) runs `scanFnRefSubtree` and sets skipChildren →
**the initializer subtree is never walked**: `local fromCall = topFn(3, 4)`
emits NO calls ref; `local anon = function(v) return hidden(v) end` emits no
function node, no calls (pinned). Contrast the shapes that DO walk (no
branch → recursion): top-level `x = topFn(10)` assignment → calls topFn;
`M.assigned = function(z) return topFn(z) end` → calls topFn **from the
FILE node** (pinned L68). In function BODIES both decl forms walk
(§visitFunctionBody) — the asymmetry is top-level-only.

### Luau type aliases — extractTypeAlias (2890; plain path :2967-2991)

`type_definition` → extractName via the `name:` FIELD: a simple alias's name
child is `identifier`; **a generic alias's name child is `generic_type` and
the node NAME is its verbatim text — `Generic<T>`, `Map<K, V>` (spaces
preserved, pinned)**. Extras: docstring (works — pinned "doc for Point"),
isExported from the luau slice hook — **`export type` → true** (the
type_definition node STARTS at `export`, CST-probed), else false. Then
:2973's `TYPE_ANNOTATION_LANGUAGES.has('luau')` is FALSE → no alias-value
refs (doubly dead: the `value` field is also NULL in this grammar —
`field-truth.out`). **Returns false → the alias's children are RE-VISITED by
the ladder**: a `typeof(require(...))` alias's function_call child hits the
hook → **`type_alias` node + `import` node + imports ref, all three** (pinned:
`FromTypeof` → type_alias L11 C0-55 + import "Config" L11 C25-54 + imports
ref from FILE; the alias node is created FIRST). Body-local `type X = …`
(legal luau) minted NOTHING — visitFunctionBody has no typeAlias branch
(pinned `extract-bodies-luau.txt`). Lua: typeAliasTypes=[] — a stray
`type X =` in a .lua file is a parse ERROR anyway (deferred).

### extractCall (3684) — the raw-text callee world

Entry: the vbnet (:3698), erlang (:3746), ruby (:3913), arkts (:3996)
branches are language-gated off. Generic path :4312-4313: `func =
getChildByField(node, 'function') ?? node.namedChild(0)` — **the `function`
field is NULL in this grammar** (truth-tabled) → always namedChild(0), which
is the `name:` child (identifier / dot_index / method_index /
parenthesized_expression / function_call in chains).

**The member branch (:4364) NEVER fires**: `dot_index_expression` and
`method_index_expression` are NOT in the accepted type list
(member_expression/attribute/selector_expression/navigation_expression/
field_expression). LITERAL_RECEIVER_TYPES (:373-388), SKIP_RECEIVERS
(:4400), and every re-encode are unreachable. Everything falls to the ELSE
(:4518-4520): **calleeName = RAW SOURCE TEXT of the callee node** (UTF-16
substring). Pinned shapes:

- bare `topFn(5)` → `topFn`; sugar calls `require 'x'` / `f {t}` route the
  same (arguments without parens).
- dotted `M.create(2)` → `M.create`; deep `core.util.log("x")` →
  `core.util.log`.
- **colon methods keep the COLON**: `M:render({})` → `M:render`;
  `M.sub.deep:chained(13)` → `M.sub.deep:chained`; in bodies `self:helperMethod(o)`
  → `self:helperMethod`, `self.field.deep(1)` → `self.field.deep` — **`self`
  is NEVER stripped** (no SKIP_RECEIVERS on this path). Resolution depends on
  these exact bytes (§Resolution consumers).
- **bracket calls**: `M.registry[key](3)` → `M.registry[key]`; `t2[k2](14)` →
  `t2[k2]` (brackets verbatim).
- **call-result callees**: `f2()(15)` → outer ref `f2()` + inner ref `f2`
  (children recursed — every chain link emits).
- **the newline-glue trap** (lua's statement ambiguity): a call statement
  followed by a line starting `(` parses as ONE glued chain —
  `obj:foo():bar()\n\t(helper)(4)` emits FOUR refs: `obj:foo():bar()\n\t(helper)`
  (raw text with embedded newline/tab — byte-verbatim), `obj:foo():bar()`,
  `obj:foo():bar`, `obj:foo` (pinned `extract-bodies-lua.txt` L19). Same
  with `string.format("%d", 9)\n("literal"):upper()` → three refs
  (`extract-shapes-lua.txt` L29). Reproduce byte-for-byte, including the
  glued middle links whose "callee" is a whole inner function_call's text.
- **paren-conversion regex (:4529-4532)**: `/^\(\s*\*?\s*([A-Za-z_][\w.]*)\s*\)$/`
  applies — a clean single `(handler)(16)` statement (semicolon-separated or
  first-in-body, un-glued) → callee text `(handler)` → rewritten **`handler`**
  (pinned twice: torture paren_conv; mini-probes `parenFirst` `(cb)()` →
  `cb`). A glued/quoted parenthesized callee (`("x"):upper` — pinned raw)
  does NOT match. Port the regex with JS `\s` semantics (matches `\r`).
- cpp template-strip (:4542-4548) and fn-ptr fan-out (:4556) are gated off.
- Ref: {fromNodeId = stack top, referenceName, referenceKind 'calls', line =
  call startRow+1, column = call startColumn (UTF-16)}.
- Luau extra shapes, all pinned: interpolation calls emit in bodies
  (`` `point {p.x} of {Config.total()}` `` → calls `Config.total` at the
  inner call's position); if-expression arms (`if p.x > 0 then bump() else
  drop()` → both); `v += grow()` → calls grow (update_statement recursed).

### Docstrings (tree-sitter-helpers.ts:95-127) — LIVE, with byte-level quirks

Both grammars have ONE comment kind, `comment` (line `--`, block `--[[ ]]`,
LuaDoc `---`, directives `--!strict`) — `comment` IS in the accepted sibling
set (:109-121) → docstrings work everywhere getPrecedingDocstring is called
(functions, methods, variables — every name of a multi-name decl —, luau
type aliases, imports never — the hook passes no docstring).
DOCSTRING_WRAPPER_TYPES (:55-62) contains `variable_declaration` but the
climb inspects PARENTS — a lua declaration's parent is chunk/block → no
climb, no effect. cleanCommentMarkers (:77-90), per comment, then
`.join('\n').trim()`:

- `--[[ … ]]` / `--[==[ … ]==]` → the `--[`-open strip (:80,
  `^--\[=*\[` + `\]=*\]$`) — pinned "Block comment doc\nspanning two lines",
  "lvl".
- line comments → `^--\s?` per line (:85). **LuaDoc `---` keeps a leading
  `- `** (`--- Summary` → `- Summary`, pinned in both langs). **`--!strict`
  becomes docstring text `!strict`** and JOINS the chain — pinned: torture
  luau's `core` docstring is `"!strict\nheader comment for torture.luau"`.
- **Comment runs chain across blank lines** (siblings skip whitespace);
  the chain BREAKS at any non-comment named sibling — including line 1's
  `hash_bang_line`, which simply terminates the scan (shebang + comment run
  → run kept, pinned).
- **CRLF bytes, pinned** (`extract-torture-crlf-lua.txt`): line-comment
  docstrings are IDENTICAL to LF (each comment `.trim()`ed → `\r` gone,
  joined with `\n`); **block-comment docstrings KEEP interior `\r\n`**
  ("Block comment doc\r\nspanning two lines") — only the ends are trimmed.
  Signatures keep raw `\r\n` too (`= function(v)\r\n\treturn …`). All `gm`
  strips ride `js_multiline_strip` in docstring.rs (#1329) — the lua strips
  (`lua_open`/`lua_close` :49-50, `dashes` :56) are **already in
  docstring.rs** — call the shared module, port nothing.

### Function-as-value capture (#756) — LUA_SPEC (function-ref.ts:322-330)

idTypes = {`identifier`} (bare identifiers only — dotted values never
qualify: `{ on_make = M.make }` captured NOTHING, pinned). dispatch:
`arguments` → args; `assignment_statement` → rhs with NO field (RHS = LAST
named child = the expression_list; the param-storage skip :435-443 reads
namedChild(0) = the variable_list, takes its trailing identifier, and
compares to the WHOLE rhs text — `M.cb = cb` skips (pinned, no candidate);
multi-value RHS never matches); `field` → value via the `value:` field
(**keyed AND positional table fields** — `{ k = v }` and `{ v1 }` both carry
`value:`, truth-tabled). layers: `expression_list` → null (fan out). No
special, no unwrap, no ungatedModes, no addressOfOnly.

- Capture points: visitNode:990 (top-level call args + assignments + every
  `field` node the ladder recurses through), visitFunctionBody:5137, and
  scanFnRefSubtree (hook-consumed require calls + variable_declaration
  subtrees). **scanFnRefSubtree's halt list (:606-614) does NOT include
  `function_definition`** → the scan DESCENDS into anonymous-function
  initializer bodies (depth cap 12), so args/fields inside them still
  produce candidates attributed to the FILE.
- Flush (:639-728): definedHere = same-file function/method NAMES;
  importedNames — lua module paths are dotted, so QUALIFIED_IMPORT (:665)
  contributes the LAST segment (`app.core` → `core`; `two.a` → `a`) and
  SIMPLE_NAME passes Roblox leaves (`Signal`, `Child`) — pinned: `(helper)`
  glue candidate flushed because import `helper` existed. No `this.`/`::`
  shapes ever occur → the bare-name gate is the only live path. Dedupe
  `${fromNodeId}|${name}` — first occurrence's position wins (pinned: three
  `topFn` table-value candidates → ONE function_ref at the first's line).
  Emitted refs: {referenceKind:'function_ref'} → wire code 200.
- Pinned population (torture.lua): `pcall(topFn, 7, 8)` → topFn (args mode);
  `{ on_start = topFn, on_stop = localFn }` + `{ cb = topFn, [1] = localFn,
  nested = { deep_cb = topFn } }` → topFn + localFn once each (field mode +
  dedupe); `skipped = missing` gated out; `M.cb = cb` skipped. Luau:
  `{ plain = typedTop }` → typedTop; `M:update(…, print)` → print gated out
  (not defined/imported).

### visitFunctionBody (5129-5286) — the body walker rows

- maybeCaptureFnRefs (5137) per node. **No visitNode hook** → the require
  asymmetry (§Require hook).
- `function_call` ∈ callTypes → extractCall (5143); no return → children
  recursed (chains emit every link).
- INSTANTIATION_KINDS (5145) never; extractBareCall (5159) absent;
  cpp declaration/assignment branches (5184-5215) gated off.
- extractStaticMemberRef (5218) — dead on entry (§Dead machinery).
- `variable_declarator` type-annotation branch (5230) — no such node kind.
- **Nested `function_declaration` (5245)** → extractName ≠ `<anonymous>`
  always → extractFunction → receiver check: `local function inner` →
  function under the enclosing symbol (`render::inner`); `function M.attached`
  → extractMethod with QN `M::attached`; global `function leakedGlobal` →
  function `render::leakedGlobal` (all pinned).
- classTypes/structTypes/enumTypes/interfaceTypes (5255-5275) — all empty.
- **`variable_declaration` in a body: NO branch** → plain recursion → the
  initializer IS walked: body `local lazy = require("app.lazy")` → calls
  require; body `local x = topFn(9)` → calls topFn — the INVERSE of top
  level. No variable node minted for body locals (pinned).
- **`type_definition` in a luau body: NO branch** → recursed → no alias
  node; a typeof-require inside it would emit `calls require` (hook-less).
- Everything else (if/while/repeat/for, return_statement, update_statement,
  interpolation, cast_expression, parenthesized_expression) is transparent
  recursion.

### Dead machinery — early-outs the walker must reproduce as SILENCE

- **Value-reference edges**: `VALUE_REF_LANGS` (:401) has no lua/luau →
  flushValueRefs (:777-784) discards everything captureValueRefScope
  collected. **Zero `references` edges with `valueRef` metadata.** The
  assignment shadow-prune (:803-878) never runs — its `assignment` case
  (:829) is Python's node kind, not lua's `assignment_statement`, so even a
  future opt-in would no-op. (Trap (a) from the survey brief: RESOLVED —
  structurally dead.)
- **Static-member refs**: STATIC_MEMBER_LANGS (:345-347) excludes lua/luau →
  extractStaticMemberRef (:4750-4751) returns on entry;
  MEMBER_ACCESS_TYPES (:323-331) has no lua kinds anyway. Zero.
- **Type-annotation refs**: TYPE_ANNOTATION_LANGUAGES (:5752-5754) excludes
  lua/luau → extractTypeAnnotations (:5788-5790) early-outs; luau parameter
  types (`parameter > identifier + type` — a node shape lua lacks: lua
  params are bare `name: identifier` children) and return types emit
  NOTHING; type_alias values emit nothing (§Luau type aliases). Zero
  `references` refs of any type-flavored kind.
- **Instantiates**: INSTANTIATION_KINDS has no lua kinds; the ladder and
  body walker never call extractInstantiation (:4610). Constructor-ish
  calls (`setmetatable`, `M.create(2)`) are plain `calls`.
- **Inheritance**: extractClass/extractInterface/extractEnum unreachable
  (empty type lists) → extractInheritance (:5291) never runs. `setmetatable`
  metatable-class patterns emit ONLY the calls ref — **no class synthesis,
  no extends** (pinned: `M.create`'s body → calls setmetatable, nothing
  else).
- **Decorates**: extractDecoratorsFor (:4897-5024) runs for every
  function/method but no decorator/annotation/attribute node kind ever
  appears in the positions it scans (lua's `attribute` = `<const>`/`<close>`
  lives inside variable_list — pinned: `local x <const> = 99` extracts
  variable x, signature `= 99`, no ref; luau's real `@native`/`@checked`
  attributes are grammar ERRORS → deferred files). Zero `decorates` refs.
- **file-level `errors`**: none on clean parses (wasm-arm hasError files add
  their own — kernel defers those wholesale).

## Resolution consumers (TS-side, no port — but they pin the walker's BYTES)

- **`resolveLuaRequire` (import-resolver.ts:1637-1671, dispatch :1450-1457)**
  resolves each `imports` ref by treating the referenceName as a dotted path
  (`telescope.config` → `telescope/config.lua`) or Roblox leaf (`Signal` →
  `Signal.luau`), trying `<p>.lua|.luau|/init.lua|/init.luau` as PATH
  SUFFIXES, longest-shared-prefix-with-the-requiring-file wins, →
  file-node target at confidence 0.9. Walker obligation: referenceName =
  the module string/leaf VERBATIM (dots intact, no normalization).
- **Lua colon-method resolution**: extraction emits `lg:log`-shaped calls;
  name-matcher's `luaColonMatch` (:1514-1520, `/^([\w.]+):(\w+)$/`) splits
  them for local-variable receiver-type inference (#1108), whose lua
  patterns (:1218-1234) include the **#1124 lookahead** — the third pattern
  `\b<r>\b\s*:\s*([A-Z][\w.]*)(?![\w.]|\s*[({"'\[])` rejects PascalCase
  METHOD CALLS (`lg:Log()`, the Roblox convention) as fake "type
  annotations" because Lua's call syntax is the identical `receiver:Name`
  shape. The pre-filter (resolution/index.ts:722-736) keeps single-`:` refs
  alive when either side (or the capitalized receiver) names a known symbol.
  Walker obligation: the SINGLE-COLON byte shape (and `[\w.]`-only
  receivers — brackets/glue garbage simply never resolves).
- Nothing else consumes lua/luau specially (no framework resolvers, no
  synthesizers — §arch-3).

## Parity mechanics (all have bitten before)

- **Emission order** per construct, pinned across all dumps: file node →
  source-order walk. Per require-decl: import node → imports ref happens
  inside the hook, THEN extractVariable's variable nodes (`import:two.a`,
  `import:two.b`, `variable:twoA`, `variable:twoB` — hook loop completes
  first). Contains edges interleave with creation (createNode). Walk-order
  refs (imports + calls interleaved by source position), then function_ref
  refs at flush (:538). No value-ref edges. Store/harness are
  rowid-order-sensitive — reproduce exactly.
- **Wire flags (layout.ts:100-106 bit pairs)**: lua function/method/import/
  type_alias-less world — the ONLY flag ever set for lua is variable
  `isExported=false` (present=1, value=0). Luau ADDITIONALLY sets
  isExported on **functions** (false) and **type_aliases** (true for
  `export type`, false otherwise) — but NOT on methods (extractMethod
  passes none). lua functions: present-bit 0 (undefined). Get the
  present-vs-value distinction byte-right; it is the one lua↔luau
  node-payload divergence besides signatures/typeAliases.
- **visibility byte 0 everywhere; returnType/decorators/typeParameters
  absent everywhere.**
- **UTF-16 columns/slices** (textutil::col16/slice_utf16): every position
  and every getNodeText (callee raw text, signatures, docstring sources,
  import signatures + `.trim()`). Pinned: `local préfixe` → C6-13 (7 UTF-16
  units).
- **CRLF**: §Docstrings byte pins; callee raw text and signatures carry
  `\r\n` verbatim; the paren-conversion regex's `\s*` eats `\r` (JS ⊇ Rust
  `\s` — parity holds). CRLF fixture variants derived in-memory
  (kernel-tsjs-parity pattern).
- **Defer policy**: `has_error()` → `defer:` (no phantom class observed —
  but trust the flag anyway, never node-scan). Deferral expectations §arch-7.
- **generateNodeId inputs**: variables hash the IDENTIFIER's line; imports
  the CALL's line; functions/methods the declaration's line; luau
  type_aliases the type_definition's line (starts at `export` when
  exported). Duplicate-id rows are emitted, not deduped.

## Gates (per plan §5 — NO standalone bump gate; grammar-parity rows instead)

- **Stage 0 (with or before the walker):** kernel C vendor
  (grammars/lua, shas above) + build.rs block + langs.rs entries (+ crate
  pin tree-sitter-luau "=1.2.0") + `GRAMMAR_LANGUAGES += 'lua','luau'` in
  kernel-grammar-parity — proves C/crate ≡ vendored wasm revision (ABI 15 /
  ABI 14, kind+field tables id-by-id). No dump-diff needed: the wasm arm is
  untouched.
- **Torture fixtures** per §Fixtures below, in a new
  `__tests__/kernel-lua-parity.test.ts` (or kernel-lua-luau-parity) with
  CRLF variants; full suite ×2 green with `CODEGRAPH_KERNEL_EXPECT=1`.
- **Parity sweeps** (`scripts/kernel-parity.mjs <dir>`, default
  `--max-deferral 0.1`):
  - `…/svy-lua/gate-repos/kong` (large lua, 1,309 files — expect ≤1 deferral:
    the invalid fixture)
  - `…/gate-repos/lazy.nvim` (small lua, 65 — expect 0)
  - `…/gate-repos/lua-resty-core` (small lua, 38, LuaJIT/OpenResty idioms —
    expect 0)
  - `…/gate-repos/lune` (luau, 221 — expect ~3 deferrals)
  - `…/gate-repos/Fusion` (luau, 113, heavily typed — expect ~8 deferrals)
  - luau-lang/luau tests/ + StyLua tests/ as OPTIONAL stress arms only
    (deliberate-error corpora — run with `--max-deferral 0.3`/`0.5`, judge
    only the non-deferred parity).
  (Re-clone public OSS fresh if the scratchpad is gone — agent-eval policy.)
  Then **full-init dump-diffs byte-identical** (kernel arm vs
  `CODEGRAPH_KERNEL=0`, `scripts/dump-graph.mjs`, cmp) on kong + lazy.nvim +
  lune + Fusion.
- **`DEFAULT_ROUTED += 'lua', 'luau'`** (kernel/index.ts:37) only after all
  of the above; changelog rides the existing kernel entry.

## Fixtures to build

1. `torture.lua` (survey seed + pinned dump `extract-torture-lua.txt` —
   99 lines, parse-clean). Inventory: shebang + comment-run docstring;
   require forms — double-quote, Roblox instance path, single-quote,
   `[[ ]]`, `script:WaitForChild("Child")` (string-wins), `.field`-access
   (NO import), dynamic (NO import), two-in-one-decl (order), pcall-require
   (nothing); LuaDoc `---` (leading `- ` quirk); block-comment doc;
   variable-with-invisible-anon-initializer; `function t.f`/`t:m`/
   `a.b.c:m`/`_G.f` receiver QNs; body: require→calls-require, self-colon
   and self-dot calls, bracket-callee calls, dotted-deep calls, nested
   local/receiver/global functions (QN quirks), `M.assigned = function`
   (file-attributed body calls); table fn-ref registries incl. positional
   `[1] =` keys + nested tables + dedupe + `missing` gate-out + `M.cb = cb`
   param-storage skip; global-assignment call visibility vs local-decl
   invisibility; call shapes — bare/dotted/colon/bracket/`f2()()`/
   `(handler)(16)` conv-rewrite (the survey torture keeps every statement
   un-glued — verified: each L77-83 call emits its own single-line ref; the
   newline-GLUE chain is pinned separately, fixture 5); bare `local x` (no
   signature key — probed `barelocal.lua`); one-line multi-statement
   (`local one = 1 local two = 2 print(...)`); long strings incl. `]==]`;
   `<const>` attribute; non-ASCII line + following symbol (UTF-16 columns);
   goto/label; `return M`.
2. `torture.luau` (seed + `extract-torture-luau.txt` — 62 lines,
   parse-clean): `--!strict` docstring-joining; requires (string + Roblox);
   type aliases — plain (doc), `export type` (isExported=true, LuaDoc),
   generic (`Generic<T>` verbatim name), `typeof(require(...))`
   (alias+import pair); typed/generic/multi-ret/empty-one-liner function
   signatures; typed methods (no isExported); body: type-in-body (nothing),
   require→calls, interpolation call, if-expr arms, `+=` RHS call, cast,
   `continue`; registry table (dotted value dropped, bare captured);
   unicode line.
3. **CRLF variants of both** derived in-memory (kernel-tsjs-parity
   pattern) — pin the block-comment `\r\n` docstring byte and CRLF
   signatures.
4. **Defer fixtures**: one lua file with luau syntax (`x += 1`) and one
   luau file with a default type param (`type S<T = U> = {}`) — kernel
   `defer:`s, wasm-arm output asserted as-is (partial extraction).
5. **Glue fixture** (if not folded into torture.lua): call statement +
   next-line `(`-open statement → the 3-4-ref garbage chain, byte-pinned.
6. **Duplicate-id fixture**: `local x = 1; local x = 2` one-liner (two
   identical-id variable rows).

## Probe artifacts (session scratchpad `svy-lua/`)

`cst-dump.cjs` (CST dumps with fieldNameForNamedChild labels; `--all` mode
walks anon children via cursor) + `cst-shapes-{lua,luau}.txt`;
`field-truth.cjs` + `field-truth.out` (childForFieldName truth table — the
NULL `function` field, name/table/field/method/parameters/body fields, luau
generic_type name, positional-field `value:`); `extract-probe.cjs` (runs the
REAL dist TreeSitterExtractor; prints nodes/edges/refs in emission order with
every wire-relevant field) + ground truths `extract-shapes-lua.txt`,
`extract-shapes-luau.txt`, `extract-bodies-{lua,luau}.txt`,
`extract-requires-lua.txt`, `extract-condreq` (inline),
`extract-torture-{lua,luau}.txt`, `extract-torture-crlf-{lua,luau}.txt`;
`mini-probes.cjs` + `mini-probes-{lua,luau}.out` (31 snippet probes:
one-liners, same-line duplicate ids, long strings/comments, LuaDoc, shebang,
goto, paren-callee conv, bracket/call-call/paren-string callees, numeric/
generic for, varargs, CRLF, integer-div/bitops, cross-dialect rejects,
unicode, luau type/interp/continue/compound/if-expr/cast/directive/
`@native`-reject probes); `errclass{1-4}.luau` (error classification);
`error-sweep.cjs` + `errors-{lua,luau}.txt` (per-repo incidence + phantom
scan); fixtures `shapes.lua`, `shapes.luau`, `bodies.lua`, `bodies.luau`,
`requires.lua`, `condreq.lua`, `sigs.luau`, `generic.luau`,
`torture.{lua,luau}` + CRLF twins; `grammar/` — `tree-sitter-lua` (v0.4.1
tag clone), `tree-sitter-luau` (v1.2.0 tag clone), `luau-crate/`
(crates.io 1.2.0 tarball, sha-matched), shas in §Grammar prep;
`gate-repos/` — kong, lazy.nvim, lua-resty-core, StyLua, luau, Fusion, lune
(shallow clones). Scratch dirs are throwaway — re-derive from this doc if
gone.